// User-supplied selectors reach css-what/linkedom, which throw plain Errors
// (with node_modules stack traces) on malformed CSS — never let those leak
// past the fail() contract of a structured, single-line stderr message.
-function query1(root: ParentNode, sel: string): Element | null {
+function query1(root: DomNode, sel: string): DomNode | null {
try {
return root.querySelector(sel)
} catch (e) {
@@ -134,9 +144,9 @@ function query1(root: ParentNode, sel: string): Element | null {
}
}
-function queryAll(root: ParentNode, sel: string): Element[] {
+function queryAll(root: DomNode, sel: string): DomNode[] {
try {
- return [...root.querySelectorAll(sel)]
+ return toArray(root.querySelectorAll(sel))
} catch (e) {
fail(`bad selector: ${sel} (${(e as Error).message})`)
}
@@ -167,28 +177,35 @@ function escapeCssIdentifier(value: string): string {
(code >= 65 && code <= 90) ||
(code >= 97 && code <= 122)
) {
- result += value[index]
+ result += value.charAt(index)
} else {
- result += `\\${value[index]}`
+ result += `\\${value.charAt(index)}`
}
}
return result
}
-function signature(el: Element): string {
- const classes = [...el.classList].map(escapeCssIdentifier)
- return el.localName + (classes.length ? '.' + classes.join('.') : '')
+function signature(el: DomNode): string {
+ const classes = toStrings(el.classList).map(escapeCssIdentifier)
+ return (el.localName as string) + (classes.length ? '.' + classes.join('.') : '')
}
-function selectorPath(el: Element): string {
+function selectorPath(el: DomNode): string {
+ // Collected leaf-first and reversed at the end: unshift has no lowering.
const parts: string[] = []
- let node: Element | null = el
+ let node: DomNode | null = el
while (node && node.localName !== 'body' && node.localName !== 'html') {
- parts.unshift(node.id ? `${node.localName}#${escapeCssIdentifier(node.id)}` : signature(node))
+ parts.push(
+ node.id
+ ? `${node.localName as string}#${escapeCssIdentifier(node.id as string)}`
+ : signature(node)
+ )
node = node.parentElement
}
- return parts.join(' > ')
+ const ordered: string[] = []
+ for (let i = parts.length - 1; i >= 0; i--) ordered.push(parts[i]!)
+ return ordered.join(' > ')
}
// Tag semantics for --md, built from disjoint tiers: each tag is listed
@@ -285,48 +302,59 @@ export const MD_TAG_TIERS = {
// are pruned so hidden markup (a inside , form internals)
// can't affect the answer; the optional memo keeps the overall walk linear
// on deeply nested markup.
-function hasDescendantIn(
- el: Element,
- tags: Set,
- cache?: WeakMap
-): boolean {
- const cached = cache?.get(el)
+function hasDescendantIn(el: DomNode, tags: Set): boolean {
+ for (const child of el.children) {
+ if (SKIP_TAGS.has(child.localName as string)) continue
+ if (tags.has(child.localName as string) || hasDescendantIn(child, tags)) return true
+ }
+ return false
+}
+
+// Same walk, memoized. Split from the plain form because an optional Map
+// parameter is a union with no runtime narrowing test, and keyed by nodeId
+// because scriptc's Map takes only string and number keys (weak collections
+// are unavailable outright).
+function hasDescendantInMemo(el: DomNode, tags: Set, cache: Map): boolean {
+ const key = nodeId(el)
+ const cached = cache.get(key)
if (cached !== undefined) return cached
let found = false
for (const child of el.children) {
- if (SKIP_TAGS.has(child.localName)) continue
- if (tags.has(child.localName) || hasDescendantIn(child, tags, cache)) {
+ if (SKIP_TAGS.has(child.localName as string)) continue
+ if (tags.has(child.localName as string) || hasDescendantInMemo(child, tags, cache)) {
found = true
break
}
}
- cache?.set(el, found)
+ cache.set(key, found)
return found
}
-const blockDescendantCache = new WeakMap()
-const hasBlockDescendant = (el: Element) => hasDescendantIn(el, BLOCK_TAGS, blockDescendantCache)
+const blockDescendantCache = new Map()
+const hasBlockDescendant = (el: DomNode) =>
+ hasDescendantInMemo(el, BLOCK_TAGS, blockDescendantCache)
-const hasStructuredContent = (el: Element) => hasDescendantIn(el, STRUCTURED_TAGS)
+const hasStructuredContent = (el: DomNode) => hasDescendantIn(el, STRUCTURED_TAGS)
// Text a browser would actually show for el — used to rescue a link label
// when the normal skip leaves nothing (e.g. Buy ) is the label a screen
// reader announces — use it before giving up on the link text.
- out += (ce.querySelector('title')?.textContent ?? '') || ' '
- } else if (INVISIBLE_TAGS.has(ce.localName)) {
- if (!ZERO_FOOTPRINT_TAGS.has(ce.localName)) out += ' '
+ out += ((ce.querySelector('title')?.textContent as string | null) ?? '') || ' '
+ } else if (INVISIBLE_TAGS.has(tag)) {
+ if (!ZERO_FOOTPRINT_TAGS.has(tag)) out += ' '
} else {
- out += ce.localName === 'img' ? (ce.getAttribute('alt') ?? '') : visibleText(ce)
+ out += tag === 'img' ? ((ce.getAttribute('alt') as string | null) ?? '') : visibleText(ce)
}
}
return out
@@ -335,42 +363,43 @@ function visibleText(el: Element): string {
// A link's markdown label: its inline rendering, or — when the normal skip
// leaves nothing — any text a browser would actually show (button labels,
// svg titles, img alt).
-const linkLabel = (el: Element) => collapse(inlineToMd(el)) || collapse(visibleText(el))
+const linkLabel = (el: DomNode) => collapse(inlineToMd(el)) || collapse(visibleText(el))
// Text of a <pre> with SKIP_TAGS subtrees pruned but whitespace preserved —
// textContent would leak <script>/<style> source into the code fence.
-function rawText(el: Element): string {
+function rawText(el: DomNode): string {
let out = ''
for (const child of el.childNodes) {
- if (child.nodeType === 3) out += (child as Text).data
- else if (child.nodeType === 1 && !SKIP_TAGS.has((child as Element).localName))
- out += rawText(child as Element)
+ if (child.nodeType === 3) out += child.data as string
+ else if (child.nodeType === 1 && !SKIP_TAGS.has(child.localName as string))
+ out += rawText(child)
}
return out
}
// HTML table model, shared by --md and --table: rows and cells nested in an
// inner table belong to that table, not the one being read.
-const directRows = (table: Element) =>
- [...table.querySelectorAll('tr')].filter((tr) => tr.closest('table') === table)
-const directCells = (tr: Element) =>
- [...tr.children].filter((c) => c.localName === 'th' || c.localName === 'td')
+const directRows = (table: DomNode) =>
+ toArray(table.querySelectorAll('tr')).filter((tr) => tr.closest('table') === table)
+const directCells = (tr: DomNode) =>
+ toArray(tr.children).filter((c) => c.localName === 'th' || c.localName === 'td')
// --md: readable main content as markdown — the docs-reading path.
// Convert a single inline-context node to markdown, turning <a> into
// [text](url) and skipping SKIP_TAGS content wherever it appears.
-function inlineNodeToMd(node: Node): string {
- if (node.nodeType === 3) return (node as Text).data
+function inlineNodeToMd(node: DomNode): string {
+ if (node.nodeType === 3) return node.data as string
if (node.nodeType !== 1) return ''
- const el = node as Element
+ const el: DomNode = node
+ const tag = el.localName as string
// A dropped widget still separates the words around it on screen
// (Press<button>OK</button>to continue), so it becomes a space, which
// collapse() later folds into the surrounding whitespace.
- if (SKIP_TAGS.has(el.localName)) return ZERO_FOOTPRINT_TAGS.has(el.localName) ? '' : ' '
- if (el.localName === 'a') {
+ if (SKIP_TAGS.has(tag)) return ZERO_FOOTPRINT_TAGS.has(tag) ? '' : ' '
+ if (tag === 'a') {
const raw = inlineToMd(el)
const label = linkLabel(el)
- const href = el.getAttribute('href') ?? ''
+ const href = (el.getAttribute('href') as string | null) ?? ''
// No label anywhere (icon-only link with no alt/title): emit the raw
// inline text rather than [](url) litter, matching the block branch.
if (!href || !label) return raw
@@ -380,10 +409,10 @@ function inlineNodeToMd(node: Node): string {
const trail = /\s$/.test(raw) ? ' ' : ''
return `${lead}[${label}](${href})${trail}`
}
- if (el.localName === 'br') return ' '
- if (el.localName === 'img') {
- const alt = el.getAttribute('alt') ?? ''
- const src = el.getAttribute('src') ?? ''
+ if (tag === 'br') return ' '
+ if (tag === 'img') {
+ const alt = (el.getAttribute('alt') as string | null) ?? ''
+ const src = (el.getAttribute('src') as string | null) ?? ''
return alt && src && !src.startsWith('data:') ? `` : alt
}
// Pad block-level children so adjacent blocks rendered in an inline
@@ -391,20 +420,19 @@ function inlineNodeToMd(node: Node): string {
// into one word.
const inner = inlineToMd(el)
const isBlockish =
- BLOCK_TAGS.has(el.localName) ||
- ['tr', 'td', 'th', 'caption', 'thead', 'tbody', 'tfoot'].includes(el.localName)
+ BLOCK_TAGS.has(tag) || ['tr', 'td', 'th', 'caption', 'thead', 'tbody', 'tfoot'].includes(tag)
return isBlockish ? ` ${inner} ` : inner
}
-function inlineToMd(el: Element): string {
+function inlineToMd(el: DomNode): string {
let out = ''
for (const child of el.childNodes) out += inlineNodeToMd(child)
return out
}
-function toMarkdown(root: Element): string {
+function toMarkdown(root: DomNode): string {
const out: string[] = []
- const walk = (el: Element) => {
+ const walk = (el: DomNode) => {
let inline = ''
const flush = () => {
const text = collapse(inline)
@@ -413,12 +441,12 @@ function toMarkdown(root: Element): string {
}
for (const child of el.childNodes) {
if (child.nodeType === 3) {
- inline += (child as Text).data
+ inline += child.data as string
continue
}
if (child.nodeType !== 1) continue
- const ce = child as Element
- const tag = ce.localName
+ const ce: DomNode = child
+ const tag = ce.localName as string
if (SKIP_TAGS.has(tag)) {
if (!ZERO_FOOTPRINT_TAGS.has(tag)) inline += ' '
continue
@@ -434,7 +462,7 @@ function toMarkdown(root: Element): string {
if (/^h[1-6]$/.test(tag) || tag === 'p' || tag === 'li' || tag === 'blockquote') {
const text = collapse(inlineToMd(ce))
if (/^h[1-6]$/.test(tag) && text) {
- out.push(`${'#'.repeat(Number(tag[1]))} ${text}`)
+ out.push(`${'#'.repeat(Number(tag.charAt(1)))} ${text}`)
} else if (tag === 'p' && text) {
out.push(text)
} else if (tag === 'li' && text) {
@@ -447,7 +475,13 @@ function toMarkdown(root: Element): string {
} else if (tag === 'pre') {
out.push('```\n' + rawText(ce).trim() + '\n```')
} else if (tag === 'table') {
- const caption = [...ce.children].find((c) => c.localName === 'caption')
+ let caption: DomNode | null = null
+ for (const c of toArray(ce.children)) {
+ if (c.localName === 'caption') {
+ caption = c
+ break
+ }
+ }
const capText = caption ? collapse(inlineToMd(caption)) : ''
if (capText) out.push(capText)
const table = directRows(ce)
@@ -461,7 +495,7 @@ function toMarkdown(root: Element): string {
// [text](url) so the href isn't silently lost. Links wrapping
// structured content still recurse below.
const text = linkLabel(ce)
- if (text) out.push(`[${text}](${ce.getAttribute('href')})`)
+ if (text) out.push(`[${text}](${ce.getAttribute('href') as string})`)
else walk(ce)
} else {
walk(ce)
@@ -474,7 +508,7 @@ function toMarkdown(root: Element): string {
root.querySelector('main') ??
root.querySelector('body') ??
root
- walk(main as Element)
+ walk(main)
return out.join('\n\n')
}
@@ -482,19 +516,19 @@ function toMarkdown(root: Element): string {
// leading @ as "read this file" (@- means stdin); --data-raw never does —
// that's its entire reason to exist. -d additionally strips CR/LF from file
// contents (curl's documented --data behavior); --data-binary preserves them.
-async function readDataFile(ref: string, binary = false): Promise<string | ArrayBuffer> {
+async function readDataFile(ref: string, binary = false): Promise<string | Uint8Array> {
if (ref === '-') {
- return binary ? await Bun.stdin.arrayBuffer() : await Bun.stdin.text()
+ return binary ? readStdinBytes() : readStdinText()
}
if (ref === '') {
fail(`couldn't read data from file ""`, '--data-raw sends the literal string')
}
- const file = Bun.file(ref)
- if (!(await file.exists())) {
+ const exists = (await stat(ref).catch(() => null)) !== null
+ if (!exists) {
fail(`couldn't read data from file "${ref}"`, '--data-raw sends the literal string')
}
try {
- return binary ? await file.arrayBuffer() : await file.text()
+ return binary ? new Uint8Array(await readFile(ref)) : await readFile(ref, 'utf8')
} catch (e) {
fail(
`couldn't read data from file "${ref}": ${(e as Error).message}`,
@@ -503,7 +537,7 @@ async function readDataFile(ref: string, binary = false): Promise<string | Array
}
}
-async function readDataArg(value: string, stripNewlines: boolean): Promise<string | ArrayBuffer> {
+async function readDataArg(value: string, stripNewlines: boolean): Promise<string | Uint8Array> {
if (!value.startsWith('@')) return value
const data = await readDataFile(value.slice(1), !stripNewlines)
return stripNewlines && typeof data === 'string' ? data.replace(/[\r\n]/g, '') : data
@@ -512,8 +546,8 @@ async function readDataArg(value: string, stripNewlines: boolean): Promise<strin
// -d wins over --data-raw wins over --data-binary when more than one is
// given, matching the precedence of the old .find([data, raw, binary]).
async function resolveData(
- flags: Record<string, unknown>
-): Promise<string | ArrayBuffer | undefined> {
+ flags: Record<string, FlagValue>
+): Promise<string | Uint8Array | undefined> {
if (typeof flags.data === 'string') return await readDataArg(flags.data, true)
if (typeof flags['data-raw'] === 'string') return flags['data-raw']
if (typeof flags['data-binary'] === 'string')
@@ -526,11 +560,11 @@ async function resolveData(
// none, infer the method, and translate -k into Bun's fetch tls option.
// Mutates headers in place (matching resolveData's existing call site).
async function curlRequestInit(
- flags: Record<string, unknown>,
+ flags: Record<string, FlagValue>,
headers: Record<string, string>
): Promise<{
method: string
- body: string | ArrayBuffer | undefined
+ body: string | Uint8Array | undefined
tls: { rejectUnauthorized: boolean } | undefined
}> {
const body = await resolveData(flags)
@@ -566,7 +600,7 @@ async function curlRequestInit(
}
function isJsonContentType(value: string | null): boolean {
- const mediaType = ((value ?? '').split(';', 1)[0] ?? '').trim().toLowerCase()
+ const mediaType = ((value ?? '').split(';')[0] ?? '').trim().toLowerCase()
const slash = mediaType.indexOf('/')
if (slash === -1) return false
const subtype = mediaType.slice(slash + 1)
@@ -619,19 +653,24 @@ export async function root(argv: string[]) {
})
if (flags.help || _.length === 0) return console.log(rootHelp)
- const [src, selector] = _
+ const src = _[0]
+ const selector = _.length > 1 ? _[1] : undefined
const opts = {
- limit: num(flags.limit, 50, { flag: '--limit', kind: 'positive integer', fail }),
+ limit: num(flags.limit, 50, { flag: '--limit', kind: 'positive integer', fail: failWith }),
all: flags.all === true,
- budget: num(flags.budget, 0, { flag: '--budget', kind: 'positive integer', fail }),
- offset: num(flags.offset, 0, { flag: '--offset', kind: 'non-negative integer', fail }),
+ budget: num(flags.budget, 0, { flag: '--budget', kind: 'positive integer', fail: failWith }),
+ offset: num(flags.offset, 0, {
+ flag: '--offset',
+ kind: 'non-negative integer',
+ fail: failWith,
+ }),
}
- const envelopeModifiers = [
+ const envelopeModifiers: [string, FlagValue][] = [
['--attr', flags.attr],
['--row', flags.row],
['--locate', flags.locate],
['--where', flags.where],
- ] as const
+ ]
const jsonEnvelope = flags['json-envelope'] === true
const optionsEnd = argv.indexOf('--')
const missingEnvelopeValue =
@@ -641,6 +680,7 @@ export async function root(argv: string[]) {
(arg, index) =>
(optionsEnd === -1 || index < optionsEnd) &&
arg === '--json-envelope' &&
+ index > 0 &&
argv[index - 1] === flag
)
)?.[0]
@@ -650,8 +690,12 @@ export async function root(argv: string[]) {
'pass the modifier value before --json-envelope'
)
}
- const emitStructured = (value: unknown[]) =>
- jsonEnvelope ? emitJsonEnvelope(value, opts) : emitJson(value, opts)
+ // Spelled as statements, not a ternary: a ternary over two void calls trips
+ // an internal compiler error in scriptc 0.0.17 (SC9001).
+ const emitStructured = (value: unknown[]) => {
+ if (jsonEnvelope) emitJsonEnvelope(value, opts)
+ else emitJson(value, opts)
+ }
const isUrl = /^https?:\/\//.test(src!)
const envelopeConflict =
flags.md === true
@@ -698,15 +742,19 @@ export async function root(argv: string[]) {
const guards = guardsFromFlags(flags)
const deadline = Date.now() + guards.timeoutMs
const started = performance.now()
- let res: Response
+ // Untyped for the same two reasons as in readSource: `tls` is outside the
+ // standard RequestInit, and the response's streaming surface is only
+ // reachable through a dynamic value.
+ const init: any = {
+ method,
+ headers,
+ body: data,
+ signal: AbortSignal.timeout(guards.timeoutMs),
+ tls,
+ }
+ let res: any
try {
- res = await fetch(src!, {
- method,
- headers,
- body: data,
- signal: AbortSignal.timeout(guards.timeoutMs),
- tls,
- })
+ res = await fetch(src!, init)
} catch (e) {
timeoutError(e, guards.timeoutMs)
return fail(`request failed: ${(e as Error).message}`, `is the server running at ${src}?`)
@@ -732,7 +780,8 @@ export async function root(argv: string[]) {
{
status: res.status,
ok: false,
- ...responseTarget,
+ url: responseTarget.url,
+ redirected: responseTarget.redirected,
ms,
saved: null,
note: '-f: error body not saved',
@@ -743,19 +792,15 @@ export async function root(argv: string[]) {
)
exitPerFail()
}
- // Stream to a temp file next to the target, then atomically rename.
- // FileSink does not truncate an existing file (a shorter download used
- // to leave the old file's tail spliced onto the new bytes), and the
- // rename means a failed or timed-out transfer leaves whatever sat at
- // -o before completely untouched — no partials, no franken-files.
- const tmpOut = `${flags.output}.axtmp-${process.pid}`
- let sink: Bun.FileSink
- try {
- sink = Bun.file(tmpOut).writer()
- } catch (e) {
- return fail(`cannot write to ${flags.output}: ${(e as Error).message}`)
- }
+ // The body is collected in memory and written once, at the end. Neither
+ // an incremental file write nor rename has a scriptc lowering, so the
+ // old stream-to-temp-then-rename dance is unavailable — but writing only
+ // after a complete transfer keeps the property that actually matters:
+ // a failed or timed-out download leaves whatever sat at -o untouched,
+ // and a shorter download never splices onto the old file's tail. The
+ // buffer is bounded by --max-bytes, the same cap the stream enforced.
let written = 0
+ const parts: Uint8Array[] = []
try {
const reader = res.body?.getReader()
if (reader) {
@@ -764,36 +809,41 @@ export async function root(argv: string[]) {
if (done || !value) break
if (value.byteLength > guards.maxBytes - written) {
await reader.cancel().catch(() => {})
- await Promise.resolve(sink.end()).catch(() => {})
- await Bun.file(tmpOut)
- .delete()
- .catch(() => {})
return fail(
`download exceeded --max-bytes at ${guards.maxBytes} bytes (--max-bytes <n> raises the cap; existing file at ${flags.output} untouched)`
)
}
- sink.write(value)
- written += value.byteLength
+ const len = value.byteLength as number
+ const chunk = new Uint8Array(len)
+ for (let i = 0; i < len; i++) chunk[i] = value[i] as number
+ parts.push(chunk)
+ written += len
}
}
- await sink.end()
- await rename(tmpOut, flags.output)
} catch (e) {
- await Promise.resolve(sink.end()).catch(() => {})
- await Bun.file(tmpOut)
- .delete()
- .catch(() => {})
timeoutError(e, guards.timeoutMs)
return fail(
`download failed: ${(e as Error).message} (existing file at ${flags.output} untouched)`
)
}
+ try {
+ const all = new Uint8Array(written)
+ let off = 0
+ for (const part of parts) {
+ all.set(part, off)
+ off += part.byteLength
+ }
+ writeFileSync(flags.output, all)
+ } catch (e) {
+ return fail(`cannot write to ${flags.output}: ${(e as Error).message}`)
+ }
await writeStdoutFlushed(
JSON.stringify(
{
status: res.status,
ok: res.ok,
- ...responseTarget,
+ url: responseTarget.url,
+ redirected: responseTarget.redirected,
ms,
saved: flags.output,
bytes: written,
@@ -839,13 +889,14 @@ export async function root(argv: string[]) {
/* keep text */
}
}
- const allHeaders = Object.fromEntries(res.headers.entries())
+ const allHeaders: Record<string, string> = {}
+ for (const [k, v] of res.headers.entries()) allHeaders[k as string] = v as string
let reportHeaders = allHeaders
let omitted = 0
if (flags.headers !== true) {
reportHeaders = {}
- for (const [k, v] of Object.entries(allHeaders)) {
- if (KEEP_HEADERS.has(k) || k.startsWith('x-ratelimit')) reportHeaders[k] = v
+ for (const k in allHeaders) {
+ if (KEEP_HEADERS.has(k) || k.startsWith('x-ratelimit')) reportHeaders[k] = allHeaders[k]!
else omitted++
}
}
@@ -854,21 +905,18 @@ export async function root(argv: string[]) {
{
status: res.status,
ok: res.ok,
- ...responseTarget,
+ url: responseTarget.url,
+ redirected: responseTarget.redirected,
ms,
headers: reportHeaders,
- ...(omitted > 0 ? { headers_omitted: `${omitted} (--headers for all)` } : {}),
+ headers_omitted: omitted > 0 ? `${omitted} (--headers for all)` : undefined,
body,
- ...(capped.capped
- ? {
- download_capped: `stopped reading at ${guards.maxBytes} bytes (--max-bytes <n> raises the cap)`,
- }
- : {}),
- ...(truncated
- ? {
- body_truncated: `${raw.length - maxChars} of ${raw.length} chars hidden (--all or --budget T)`,
- }
- : {}),
+ download_capped: capped.capped
+ ? `stopped reading at ${guards.maxBytes} bytes (--max-bytes <n> raises the cap)`
+ : undefined,
+ body_truncated: truncated
+ ? `${raw.length - maxChars} of ${raw.length} chars hidden (--all or --budget T)`
+ : undefined,
},
null,
2
@@ -909,13 +957,18 @@ export async function root(argv: string[]) {
'ax: note: HEAD has no body to parse — treating as GET (drop the selector to see headers)\n'
)
}
- const { document } = parseHTML(
- await readSource(src, {
- ...guardsFromFlags(flags),
- headers,
- ...(requestInit ?? {}),
- })
- )
+ const guards = guardsFromFlags(flags)
+ const sourceOptions: ReadSourceOptions = {
+ maxBytes: guards.maxBytes,
+ timeoutMs: guards.timeoutMs,
+ fresh: guards.fresh,
+ noCache: guards.noCache,
+ headers,
+ method: requestInit?.method,
+ body: requestInit?.body,
+ tls: requestInit?.tls,
+ }
+ const { document } = parseHTML(await readSource(src, sourceOptions))
const wherePred = typeof flags.where === 'string' ? compileWhere(flags.where) : null
// JS-shell diagnosis: a 200 with an SPA husk is the sneakiest "success".
@@ -928,18 +981,18 @@ export async function root(argv: string[]) {
return null
}
- const scope = (): ParentNode => {
+ const scope = (): DomNode => {
if (!selector) return document.querySelector('body') ?? document
const el = query1(document, selector)
if (!el) {
const spa = spaNote()
fail(`selector matched nothing: ${selector}`, spa ?? undefined)
}
- return el as ParentNode
+ return el
}
if (flags.md) {
- const md = toMarkdown((document.querySelector('html') ?? document) as unknown as Element)
+ const md = toMarkdown(document.querySelector('html') ?? document)
// --md carries a default token budget on top of --limit, because markdown
// lines are cheap individually but a whole page adds up. It is only a
// *default*: --all means all (never a truncation note pointing at the flag
@@ -969,14 +1022,15 @@ export async function root(argv: string[]) {
const needle = flags.locate.toLowerCase()
const hits: { selector: string; match: string }[] = []
for (const el of scope().querySelectorAll('*')) {
- const attrHit = el
- .getAttributeNames()
- .map((n) => [n, el.getAttribute(n) ?? ''] as const)
+ const attrHit = toStrings(el.getAttributeNames())
+ .map((n): [string, string] => [n, (el.getAttribute(n) as string | null) ?? ''])
.find(([, v]) => v.toLowerCase().includes(needle))
- const childHit = [...el.children].some((c) =>
- (c.textContent ?? '').toLowerCase().includes(needle)
+ const childHit = toArray(el.children).some((c) =>
+ (((c.textContent as string | null) ?? '') as string).toLowerCase().includes(needle)
)
- const textHit = !childHit && (el.textContent ?? '').toLowerCase().includes(needle)
+ const textHit =
+ !childHit &&
+ (((el.textContent as string | null) ?? '') as string).toLowerCase().includes(needle)
if (!attrHit && !textHit) continue
const snippet = attrHit ? `${attrHit[0]}="${attrHit[1]}"` : collapse(el.textContent ?? '')
hits.push({
@@ -989,29 +1043,44 @@ export async function root(argv: string[]) {
}
if (flags.table) {
+ // The predicate is spelled to return a real boolean: an `&&` over dynamic
+ // operands yields a dynamic value, which cannot flow into .filter().
const tables = queryAll(document, selector ?? 'table').filter(
- (el) => el.localName === 'table' || (el.querySelector('table') && el.localName !== 'table')
+ (el: DomNode): boolean =>
+ el.localName === 'table' || (el.querySelector('table') !== null && el.localName !== 'table')
)
const targets = tables.flatMap((el) =>
- el.localName === 'table' ? [el] : [...el.querySelectorAll('table')]
+ el.localName === 'table' ? [el] : toArray(el.querySelectorAll('table'))
)
if (targets.length === 0) fail(`no <table> found${selector ? ` under: ${selector}` : ''}`)
// Grid construction per the HTML table model: expand colspan/rowspan,
// ignore rows of nested tables, consume leading all-<th> rows as header.
- const parse = (table: Element) => {
+ const parse = (table: DomNode) => {
const allRows = directRows(table)
- if (allRows.length === 0) return { headers: [], rows: [] as Record<string, string | null>[] }
+ if (allRows.length === 0)
+ return { headers: [] as string[], rows: [] as Record<string, string | null>[] }
const cellsOf = directCells
- const grid: (string | undefined)[][] = allRows.map(() => [])
+ const grid: (string | undefined)[][] = allRows.map((): (string | undefined)[] => [])
+ // Reads and writes past a row's current end are explicit here: scriptc
+ // bounds-checks array indexing rather than answering undefined (read) or
+ // growing the array (write), so every slot is materialised first.
+ const at = (row: (string | undefined)[], i: number): string | undefined =>
+ i < row.length ? row[i] : undefined
+ const put = (row: (string | undefined)[], i: number, value: string) => {
+ while (row.length <= i) row.push(undefined)
+ row[i] = value
+ }
allRows.forEach((tr, r) => {
let c = 0
for (const cell of cellsOf(tr)) {
- while (grid[r]![c] !== undefined) c++
- const text = collapse(cell.textContent ?? '')
- const cs = Math.max(1, Number(cell.getAttribute('colspan')) || 1)
- const rs = Math.max(1, Number(cell.getAttribute('rowspan')) || 1)
+ while (at(grid[r]!, c) !== undefined) c++
+ const text = collapse((cell.textContent as string | null) ?? '')
+ const colspan = (cell.getAttribute('colspan') as string | null) ?? ''
+ const rowspan = (cell.getAttribute('rowspan') as string | null) ?? ''
+ const cs = Math.max(1, Number(colspan) || 1)
+ const rs = Math.max(1, Number(rowspan) || 1)
for (let dr = 0; dr < rs && r + dr < allRows.length; dr++) {
- for (let dc = 0; dc < cs; dc++) grid[r + dr]![c + dc] = text
+ for (let dc = 0; dc < cs; dc++) put(grid[r + dr]!, c + dc, text)
}
c += cs
}
@@ -1024,36 +1093,51 @@ export async function root(argv: string[]) {
) {
headerRowCount++
}
- const width = Math.max(...grid.map((row) => row.length))
- const named = Array.from({ length: width }, (_, i) =>
- headerRowCount > 0 ? grid[0]![i] || `col${i}` : `col${i}`
- )
+ let width = 0
+ for (const row of grid) width = Math.max(width, row.length)
+ const named: string[] = []
+ for (let i = 0; i < width; i++) {
+ named.push((headerRowCount > 0 ? at(grid[0]!, i) || `col${i}` : `col${i}`) as string)
+ }
const seen = new Map<string, number>()
const headers = named.map((h) => {
const n = (seen.get(h) ?? 0) + 1
seen.set(h, n)
return n === 1 ? h : `${h}_${n}`
})
- const rows = grid
- .slice(headerRowCount)
- .map((cells) => Object.fromEntries(headers.map((h, i) => [h, cells[i] ?? null])))
- .filter((r) => Object.values(r).some((v) => v))
+ const rows: Record<string, string | null>[] = []
+ for (const cells of grid.slice(headerRowCount)) {
+ const row: Record<string, string | null> = {}
+ let hasValue = false
+ headers.forEach((h, i) => {
+ const v = at(cells, i) ?? null
+ row[h] = v
+ if (v) hasValue = true
+ })
+ if (hasValue) rows.push(row)
+ }
return { headers, rows }
}
- const parsed = targets.map(parse)
+ const parsed = targets.map((t: DomNode) => parse(t))
const beforeWhere = parsed.length === 1 ? parsed[0]!.rows.length : 0
- if (wherePred) for (const p of parsed) p.rows = p.rows.filter(wherePred)
+ if (wherePred) {
+ for (const p of parsed) p.rows = p.rows.filter((row) => wherePred(row))
+ }
const tableResult = parsed.length === 1 ? parsed[0]!.rows : parsed
if (parsed.length === 1) rowStats(parsed[0]!.rows, wherePred ? beforeWhere : undefined)
if (jsonEnvelope || flags.json || parsed.length > 1) return emitStructured(tableResult)
- return emitLines(toTsv(tableResult), opts)
+ // Past the guard above there is exactly one table, so this is its rows.
+ return emitLines(toTsv(parsed[0]!.rows), opts)
}
if (!selector) fail('missing selector', 'ax <url|file|-> <selector> (or --outline / --md)')
const els = queryAll(document, selector)
if (els.length === 0) fail(`selector matched nothing: ${selector}`, spaNote() ?? undefined)
- if (flags.count) return void process.stdout.write(els.length + '\n')
+ if (flags.count) {
+ process.stdout.write(els.length + '\n')
+ return
+ }
if (typeof flags.row === 'string') {
const fields = parseRowSpec(flags.row)
@@ -1067,31 +1151,39 @@ export async function root(argv: string[]) {
}
return obj
})
- const rowResult = wherePred ? rows.filter(wherePred) : rows
+ const rowResult = wherePred ? rows.filter((row) => wherePred(row)) : rows
rowStats(rowResult, wherePred ? rows.length : undefined)
if (jsonEnvelope || flags.json) return emitStructured(rowResult)
return emitLines(toTsv(rowResult), opts)
}
if (flags.json || jsonEnvelope) {
- const rows = els.map((el) => ({
- text: (el.textContent ?? '').trim(),
- html: el.innerHTML,
- attrs: Object.fromEntries(el.getAttributeNames().map((n) => [n, el.getAttribute(n) ?? ''])),
- }))
+ const rows = els.map((el) => {
+ const attrs: Record<string, string> = {}
+ for (const n of toStrings(el.getAttributeNames())) {
+ attrs[n] = (el.getAttribute(n) as string | null) ?? ''
+ }
+ return {
+ text: (((el.textContent as string | null) ?? '') as string).trim(),
+ html: el.innerHTML as string,
+ attrs,
+ }
+ })
return emitStructured(rows)
}
if (typeof flags.attr === 'string') {
- const vals = els
- .map((el) => el.getAttribute(flags.attr as string))
- .filter((v): v is string => v !== null)
+ const vals: string[] = []
+ for (const el of els) {
+ const v = el.getAttribute(flags.attr as string) as string | null
+ if (v !== null) vals.push(v)
+ }
return emitLines(vals, opts)
}
if (flags.html) {
return emitLines(
- els.map((el) => el.innerHTML),
+ els.map((el): string => el.innerHTML as string),
opts
)
}
@@ -1112,8 +1204,12 @@ function rowStats(rows: Record<string, string | null>[], beforeWhere?: number) {
return
}
const nulls: string[] = []
- for (const key of Object.keys(rows[0]!)) {
- const n = rows.filter((r) => r[key] === null || r[key] === '').length
+ for (const key in rows[0]!) {
+ const n = rows.filter((r) => {
+ const rec: any = r
+ const v = (rec[key] ?? null) as string | null
+ return v === null || v === ''
+ }).length
if (n > 0) nulls.push(`${key}: ${n} empty`)
}
process.stderr.write(
diff --git a/src/index.ts b/src/index.ts
index 7ef4cf5..c4e49fa 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,18 +1,18 @@
#!/usr/bin/env bun
-import agentContext from './agent-context.txt' with { type: 'text' }
-import { version } from './../package.json' with { type: 'json' }
+import { agentContext } from './agent-context.gen'
+import pkg from './../package.json'
import { root, rootHelp } from './commands/root'
async function main() {
const argv = process.argv.slice(2)
- const [first] = argv
+ const first = argv.length > 0 ? argv[0] : undefined
if (!first || first === '--help' || first === '-h' || first === 'help') {
console.log(rootHelp)
return
}
if (first === '--version' || first === '-v') {
- console.log(version)
+ console.log(pkg.version)
return
}
if (first === 'agent-context') {
diff --git a/src/lib/args.ts b/src/lib/args.ts
index 002a7f2..e86d5e2 100644
--- a/src/lib/args.ts
+++ b/src/lib/args.ts
@@ -1,33 +1,143 @@
-import { parseArgs as nodeParseArgs, type ParseArgsConfig } from 'util'
+// A standalone replacement for util.parseArgs: scriptc has no lowering for it,
+// and ax only needs the non-strict subset it was already configured with.
+export type OptionDef = { type: 'boolean' | 'string'; short?: string; multiple?: boolean }
+export type Options = Record<string, OptionDef>
-// Thin wrapper over the built-in util.parseArgs (Bun/Node standard).
-// We only reshape its output to { _, flags } and stay non-strict so an
-// unknown flag doesn't crash — it just gets ignored.
-export type Options = NonNullable<ParseArgsConfig['options']>
+export type FlagValue = string | boolean | string[] | undefined
+export type Flags = Record<string, FlagValue>
+function store(flags: Flags, def: OptionDef | undefined, key: string, value: string | boolean) {
+ // `multiple: true` accumulates (-H can be repeated); everything else keeps
+ // the last occurrence, matching util.parseArgs.
+ if (def?.multiple === true) {
+ const prev = flags[key]
+ const list = Array.isArray(prev) ? prev : []
+ list.push(String(value))
+ flags[key] = list
+ return
+ }
+ flags[key] = value
+}
+
+// Resolve a single-letter alias to its long name, or return null when the
+// letter belongs to no declared option (non-strict: unknown flags are kept
+// under their own name so the caller can warn about them).
+function longNameOf(options: Options, short: string): string | null {
+ for (const name in options) {
+ if (options[name]?.short === short) return name
+ }
+ return null
+}
+
+/**
+ * Parse `argv` into positionals and flags.
+ *
+ * Supports the surface ax uses: `--flag`, `--flag value`, `--flag=value`,
+ * `-x value`, `-xvalue`, repeated flags via `multiple`, and `--` to end
+ * option parsing. Unknown flags are accepted (never a hard error) so a typo
+ * costs a warning rather than a failed run.
+ *
+ * @param argv - Arguments after the program name.
+ * @param options - Declared options keyed by long name.
+ * @returns `_` (positionals) and `flags` (parsed values).
+ *
+ * @example
+ * parseArgs(['--md', '-H', 'a: b', 'x.html'], { md: { type: 'boolean' }, header: { type: 'string', short: 'H', multiple: true } })
+ * // => { _: ['x.html'], flags: { md: true, header: ['a: b'] } }
+ */
export function parseArgs(argv: string[], options: Options) {
- const { values, positionals } = nodeParseArgs({
- args: argv,
- options,
- allowPositionals: true,
- strict: false,
- })
- // Unknown flags are ignored by non-strict parsing — but ignoring them
- // silently costs an agent a whole retry turn. Warn with a suggestion.
- const known = Object.keys(options)
- for (const key of Object.keys(values)) {
- if (known.includes(key)) continue
- const isLong = argv.some((arg) => arg === `--${key}` || arg.startsWith(`--${key}=`))
- const flag = `${isLong ? '--' : '-'}${key}`
+ const positionals: string[] = []
+ const flags: Flags = {}
+ const unknown: string[] = []
+ let i = 0
+ let optionsEnded = false
+
+ while (i < argv.length) {
+ const arg = argv[i]!
+ i++
+
+ if (optionsEnded) {
+ positionals.push(arg)
+ continue
+ }
+ if (arg === '--') {
+ optionsEnded = true
+ continue
+ }
+
+ if (arg.startsWith('--')) {
+ const body = arg.slice(2)
+ const eq = body.indexOf('=')
+ const key = eq === -1 ? body : body.slice(0, eq)
+ const inline = eq === -1 ? null : body.slice(eq + 1)
+ const def = options[key]
+ if (!def) unknown.push(`--${key}`)
+ // An undeclared flag has no type: an inline value makes it a string,
+ // otherwise it reads as a boolean and never swallows the next argument.
+ if (def?.type === 'string') {
+ if (inline !== null) store(flags, def, key, inline)
+ else if (i < argv.length) store(flags, def, key, argv[i++]!)
+ else store(flags, def, key, true)
+ } else {
+ store(flags, def, key, inline ?? true)
+ }
+ continue
+ }
+
+ // A bare "-" is stdin, not a flag.
+ if (arg.startsWith('-') && arg.length > 1) {
+ // A short cluster ends as soon as a string-typed option claims the rest
+ // of the token as its value (-mfoo), curl/getopt style.
+ let j = 1
+ while (j < arg.length) {
+ const letter = arg.charAt(j)
+ j++
+ const key = longNameOf(options, letter)
+ if (key === null) {
+ unknown.push(`-${letter}`)
+ store(flags, undefined, letter, true)
+ continue
+ }
+ const def = options[key]!
+ if (def.type !== 'string') {
+ store(flags, def, key, true)
+ continue
+ }
+ if (j < arg.length) {
+ store(flags, def, key, arg.slice(j))
+ j = arg.length
+ } else if (i < argv.length) {
+ store(flags, def, key, argv[i++]!)
+ } else {
+ store(flags, def, key, true)
+ }
+ }
+ continue
+ }
+
+ positionals.push(arg)
+ }
+
+ // Ignoring an unknown flag silently costs an agent a whole retry turn.
+ for (const flag of unknown) {
+ const isLong = flag.startsWith('--')
+ const key = isLong ? flag.slice(2) : flag.slice(1)
// Suggest only near-certain matches (shared 2-char prefix or containment).
- const guess = isLong
- ? known.find((k) => k.startsWith(key.slice(0, 2)) || k.includes(key) || key.includes(k))
- : undefined
+ let guess: string | undefined
+ if (isLong) {
+ for (const k in options) {
+ if (k.startsWith(key.slice(0, 2)) || k.includes(key) || key.includes(k)) {
+ guess = k
+ break
+ }
+ }
+ }
process.stderr.write(
`ax: note: unknown flag ${flag} ignored${guess ? ` (did you mean --${guess}?)` : ''} — see --help\n`
)
}
- return { _: positionals, flags: values as Record<string, string | boolean | undefined> }
+
+ return { _: positionals, flags }
}
type NumConstraint = {
diff --git a/src/lib/dom.ts b/src/lib/dom.ts
new file mode 100644
index 0000000..fe6c3c1
--- /dev/null
+++ b/src/lib/dom.ts
@@ -0,0 +1,39 @@
+// linkedom runs in scriptc's embedded engine, so its nodes arrive as dynamic
+// values. scriptc refuses to validate a dynamic value against a structural
+// interface, which rules out a hand-written `Element` type — DOM nodes stay
+// untyped here and only leaf values get narrowed at the point of use.
+export type DomNode = any
+
+/**
+ * Copy a live DOM collection into a real array.
+ *
+ * Spreading a dynamic value (`[...el.children]`) has no scriptc lowering, so
+ * every NodeList/HTMLCollection is materialised through this instead.
+ */
+export function toArray(nodes: DomNode): DomNode[] {
+ const out: DomNode[] = []
+ for (const n of nodes) out.push(n)
+ return out
+}
+
+/** Copy a dynamic collection of strings (classList, attribute names). */
+export function toStrings(values: DomNode): string[] {
+ const out: string[] = []
+ for (const v of values) out.push(v as string)
+ return out
+}
+
+// Map keys are limited to strings and numbers, so identity memoization tags
+// each node with a serial number the first time it is seen. The property lives
+// on the node itself, which is exactly the lifetime a WeakMap entry had.
+const ID_KEY = '__axNodeId'
+let nextNodeId = 0
+
+/** Stable per-node number, usable as a Map key in place of node identity. */
+export function nodeId(el: DomNode): number {
+ if (typeof el[ID_KEY] !== 'number') {
+ el[ID_KEY] = nextNodeId
+ nextNodeId++
+ }
+ return el[ID_KEY] as number
+}
diff --git a/src/lib/emit.ts b/src/lib/emit.ts
index c9d34d3..6ad4de3 100644
--- a/src/lib/emit.ts
+++ b/src/lib/emit.ts
@@ -1,3 +1,5 @@
+import { writeStdout } from './platform'
+
// Output helpers. Default-cap large results so agents don't drown in tokens,
// but NEVER truncate silently — always note what was dropped on stderr.
const DEFAULT_LIMIT = 50
@@ -16,9 +18,12 @@ export type PageMeta = {
next_offset: number | null
}
-type CapResult<T> = { shown: T[]; meta: PageMeta }
+type CapResult = { shown: unknown[]; meta: PageMeta }
-function cap<T>(items: T[], opts: EmitOpts, sizeOf: (item: T) => number): CapResult<T> {
+// Deliberately monomorphic over `unknown`: a generic instantiated at `any`
+// pushes its whole body into scriptc's dynamic boundary, and the values here
+// are only ever counted and sliced.
+function cap(items: unknown[], opts: EmitOpts, sizeOf: (item: unknown) => number): CapResult {
const total = items.length
const offset = opts.offset && opts.offset > 0 ? opts.offset : 0
if (offset >= total && offset > 0) {
@@ -97,20 +102,18 @@ export function sanitizeLine(s: string): { text: string; removed: number } {
return { text, removed: s.length - text.length }
}
-// process.exit() discards stdout data still sitting in the write queue —
-// when stdout is a pipe, anything past the 64KB kernel buffer is silently
-// dropped. Every stdout write followed by an explicit exit must be awaited
-// through this, so `ax … --body | jq` gets the whole body. (Parse mode
-// exits naturally, so its writes drain on their own.)
+// Every stdout write followed by an explicit exit goes through this, so
+// `ax … --body | jq` gets the whole body. (Parse mode exits naturally, so its
+// writes drain on their own.) See platform.ts for what "flushed" means per host.
export function writeStdoutFlushed(data: string | Uint8Array): Promise<void> {
- return new Promise((resolve) => process.stdout.write(data, () => resolve()))
+ return writeStdout(data)
}
export function emitLines(items: string[], opts: EmitOpts = {}) {
- const r = cap(items, opts, (s) => s.length + 1)
+ const r = cap(items, opts, (s) => (s as string).length + 1)
let stripped = 0
const safe = r.shown.map((line) => {
- const { text, removed } = sanitizeLine(line)
+ const { text, removed } = sanitizeLine(line as string)
stripped += removed
return text
})
@@ -123,7 +126,7 @@ export function emitLines(items: string[], opts: EmitOpts = {}) {
export function emitJson(value: unknown, opts: EmitOpts = {}) {
if (Array.isArray(value)) {
- const r = cap(value, opts, (v) => JSON.stringify(v).length + 4)
+ const r = cap(value as unknown[], opts, (v) => JSON.stringify(v).length + 4)
process.stdout.write(JSON.stringify(r.shown, null, 2) + '\n')
note(r.meta)
} else {
diff --git a/src/lib/expr.ts b/src/lib/expr.ts
index cd0dad6..629dd48 100644
--- a/src/lib/expr.ts
+++ b/src/lib/expr.ts
@@ -25,7 +25,7 @@ function lex(src: string): Tok[] {
let i = 0
const ops = ['&&', '||', '==', '!=', '~', '!~', '>=', '<=', '>', '<', '!']
while (i < src.length) {
- const c = src[i]!
+ const c = src.charAt(i)
if (/\s/.test(c)) {
i++
continue
@@ -40,7 +40,7 @@ function lex(src: string): Tok[] {
i++
continue
}
- const op = ops.find((o) => src.startsWith(o, i))
+ const op = ops.find((o) => src.slice(i).startsWith(o))
if (op) {
toks.push({ t: 'op', v: op })
i += op.length
@@ -51,8 +51,11 @@ function lex(src: string): Tok[] {
if (end === -1) fail(`unterminated regex in expression: ${src.slice(i)}`)
const flagsMatch = /^[a-z]*/.exec(src.slice(end + 1))
const flags = flagsMatch?.[0] ?? ''
+ // 'g'/'y' make .test() stateful through lastIndex, which has no
+ // assignable form here; a predicate never wants that anyway.
+ const reFlags = flags.replace(/[gy]/g, '')
try {
- toks.push({ t: 're', v: new RegExp(src.slice(i + 1, end), flags) })
+ toks.push({ t: 're', v: new RegExp(src.slice(i + 1, end), reFlags) })
} catch (e) {
fail(`invalid regex: ${(e as Error).message}`)
}
@@ -92,75 +95,99 @@ function lex(src: string): Tok[] {
}
type Node =
- | { k: 'lit'; v: unknown }
+ | { k: 'lit'; v: string | number | boolean | null }
| { k: 're'; v: RegExp }
| { k: 'path'; v: string[] }
| { k: 'not'; e: Node }
| { k: 'bin'; op: string; l: Node; r: Node }
-function parse(toks: Tok[]): Node {
- let pos = 0
- const peek = () => toks[pos]
- const eat = () => toks[pos++]
-
- function primary(): Node {
- const t = eat()
- if (!t) fail('unexpected end of expression')
- if (t.t === 'lp') {
- const e = or()
- const close = eat()
- if (!close || close.t !== 'rp') fail('missing ) in expression')
- return e
- }
- if (t.t === 'op' && t.v === '!') return { k: 'not', e: primary() }
- if (t.t === 'num') return { k: 'lit', v: t.v }
- if (t.t === 'str') return { k: 'lit', v: t.v }
- if (t.t === 're') return { k: 're', v: t.v }
- if (t.t === 'path') {
- const [head] = t.v
- if (t.v.length === 1 && (head === 'true' || head === 'false' || head === 'null')) {
- return { k: 'lit', v: head === 'true' ? true : head === 'false' ? false : null }
- }
- return { k: 'path', v: t.v }
+// A guarded `tok?.t` read is a '?.' on a sub-union, which has no lowering:
+// the undefined arm is tested explicitly instead.
+function isOp(tok: Tok | undefined, op: string): boolean {
+ return tok !== undefined && tok.t === 'op' && tok.v === op
+}
+
+// The recursive-descent parser is spelled as top-level functions over an
+// explicit cursor rather than nested closures over a captured `pos`: mutually
+// recursive inner declarations sharing mutable outer state abort at runtime
+// under scriptc 0.0.17.
+type Cursor = { toks: Tok[]; pos: number }
+
+// Reading past the last token is a bounds error under scriptc, where JS would
+// have answered undefined.
+function peek(c: Cursor): Tok | undefined {
+ return c.pos < c.toks.length ? c.toks[c.pos] : undefined
+}
+
+function eat(c: Cursor): Tok | undefined {
+ if (c.pos >= c.toks.length) return undefined
+ const t = c.toks[c.pos]
+ c.pos++
+ return t
+}
+
+const COMPARISON_OPS = ['==', '!=', '~', '!~', '>', '>=', '<', '<=']
+
+function primary(c: Cursor): Node {
+ const t = eat(c)
+ if (!t) fail('unexpected end of expression')
+ if (t.t === 'lp') {
+ const e = or(c)
+ const close = eat(c)
+ if (!close || close.t !== 'rp') fail('missing ) in expression')
+ return e
+ }
+ if (t.t === 'op' && t.v === '!') return { k: 'not', e: primary(c) }
+ if (t.t === 'num') return { k: 'lit', v: t.v }
+ if (t.t === 'str') return { k: 'lit', v: t.v }
+ if (t.t === 're') return { k: 're', v: t.v }
+ if (t.t === 'path') {
+ const head = t.v.length > 0 ? t.v[0] : undefined
+ if (t.v.length === 1 && (head === 'true' || head === 'false' || head === 'null')) {
+ return { k: 'lit', v: head === 'true' ? true : head === 'false' ? false : null }
}
- return fail(`unexpected token in expression`)
+ return { k: 'path', v: t.v }
}
+ fail(`unexpected token in expression`)
+}
- function comparison(): Node {
- let left = primary()
- const t = peek()
- if (t && t.t === 'op' && ['==', '!=', '~', '!~', '>', '>=', '<', '<='].includes(t.v)) {
- eat()
- left = { k: 'bin', op: t.v, l: left, r: primary() }
- }
- return left
+function comparison(c: Cursor): Node {
+ const left = primary(c)
+ const t = peek(c)
+ if (t && t.t === 'op' && COMPARISON_OPS.includes(t.v)) {
+ eat(c)
+ return { k: 'bin', op: t.v, l: left, r: primary(c) }
}
+ return left
+}
- function and(): Node {
- let left = comparison()
- while (peek()?.t === 'op' && (peek() as { v: string }).v === '&&') {
- eat()
- left = { k: 'bin', op: '&&', l: left, r: comparison() }
- }
- return left
+function and(c: Cursor): Node {
+ let left = comparison(c)
+ while (isOp(peek(c), '&&')) {
+ eat(c)
+ left = { k: 'bin', op: '&&', l: left, r: comparison(c) }
}
+ return left
+}
- function or(): Node {
- let left = and()
- while (peek()?.t === 'op' && (peek() as { v: string }).v === '||') {
- eat()
- left = { k: 'bin', op: '||', l: left, r: and() }
- }
- return left
+function or(c: Cursor): Node {
+ let left = and(c)
+ while (isOp(peek(c), '||')) {
+ eat(c)
+ left = { k: 'bin', op: '||', l: left, r: and(c) }
}
+ return left
+}
- const root = or()
- if (pos !== toks.length) fail('trailing tokens in expression')
+function parse(toks: Tok[]): Node {
+ const c: Cursor = { toks, pos: 0 }
+ const root = or(c)
+ if (c.pos !== toks.length) fail('trailing tokens in expression')
return root
}
-function resolve(path: string[], ctx: unknown): unknown {
- let v: unknown = ctx
+function resolve(path: string[], ctx: unknown): any {
+ let v: any = ctx
for (const p of path) {
if (v === null || v === undefined) return null
if (p === 'length') {
@@ -170,17 +197,26 @@ function resolve(path: string[], ctx: unknown): unknown {
}
}
if (typeof v !== 'object') return null
- v = (v as Record<string, unknown>)[p] ?? null
+ v = v[p] ?? null
}
return v
}
-function testRegex(regex: RegExp, value: unknown): boolean {
- regex.lastIndex = 0
- return regex.test(String(value ?? ''))
+function testRegex(regex: RegExp, value: any): boolean {
+ return regex.test(value === null || value === undefined ? '' : String(value))
+}
+
+// Numeric-friendly comparison: "25000" > 100 works. Number() has no lowering
+// over a dynamic argument, so the string arm is bound to a real `string` first.
+function numericish(v: any): any {
+ if (typeof v !== 'string') return v
+ const s: string = v
+ if (s === '') return v
+ const n = Number(s)
+ return Number.isNaN(n) ? v : n
}
-function evalNode(n: Node, ctx: unknown): unknown {
+function evalNode(n: Node, ctx: unknown): any {
switch (n.k) {
case 'lit':
return n.v
@@ -195,18 +231,21 @@ function evalNode(n: Node, ctx: unknown): unknown {
if (n.op === '&&') return Boolean(l) && Boolean(evalNode(n.r, ctx))
if (n.op === '||') return Boolean(l) || Boolean(evalNode(n.r, ctx))
const r = evalNode(n.r, ctx)
- // Numeric-friendly comparison: "25000" > 100 works.
- const ln = typeof l === 'string' && l !== '' && !Number.isNaN(Number(l)) ? Number(l) : l
- const rn = typeof r === 'string' && r !== '' && !Number.isNaN(Number(r)) ? Number(r) : r
+ const ln = numericish(l)
+ const rn = numericish(r)
switch (n.op) {
case '==':
return l === r || ln === rn
case '!=':
return l !== r && ln !== rn
- case '~':
- return r instanceof RegExp ? testRegex(r, l) : fail('~ needs a /regex/ on the right')
- case '!~':
- return r instanceof RegExp ? !testRegex(r, l) : fail('!~ needs a /regex/ on the right')
+ case '~': {
+ if (n.r.k !== 're') fail('~ needs a /regex/ on the right')
+ return testRegex(n.r.v, l)
+ }
+ case '!~': {
+ if (n.r.k !== 're') fail('!~ needs a /regex/ on the right')
+ return !testRegex(n.r.v, l)
+ }
case '>':
return (ln as number) > (rn as number)
case '>=':
diff --git a/src/lib/io.ts b/src/lib/io.ts
index 4a797fe..0ca0b76 100644
--- a/src/lib/io.ts
+++ b/src/lib/io.ts
@@ -1,7 +1,10 @@
import { homedir } from 'node:os'
import { join } from 'node:path'
-import { chmod, mkdir, readdir, rename, stat, unlink, writeFile } from 'node:fs/promises'
-import { num } from './args'
+import { chmod, readdir, readFile, stat, unlink } from 'node:fs/promises'
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { createHash } from 'node:crypto'
+import { num, type FlagValue } from './args'
+import { decodeText } from './platform'
// Explore-then-extract means the same URL gets probed many times in a row;
// re-downloading it every probe wastes seconds per turn. Short-TTL cache.
@@ -23,21 +26,21 @@ export type FetchGuards = {
export type ReadSourceOptions = FetchGuards & {
headers?: Record<string, string>
method?: string
- body?: string | ArrayBuffer
+ body?: string | Uint8Array
tls?: { rejectUnauthorized: boolean }
}
-export function guardsFromFlags(flags: Record<string, unknown>): Required<FetchGuards> {
+export function guardsFromFlags(flags: Record<string, FlagValue>): Required<FetchGuards> {
const maxBytes = num(flags['max-bytes'], DEFAULT_MAX_BYTES, {
flag: '--max-bytes',
kind: 'positive integer',
- fail,
+ fail: (message: string) => fail(message),
})
const timeoutMs =
num(flags['max-time'], DEFAULT_TIMEOUT_MS / 1000, {
flag: '-m/--max-time',
kind: 'positive number',
- fail,
+ fail: (message: string) => fail(message),
}) * 1000
return {
maxBytes,
@@ -48,18 +51,18 @@ export function guardsFromFlags(flags: Record<string, unknown>): Required<FetchG
}
// Cached pages can contain private content, so the cache is owner-only:
-// directory 0700, files 0600, written to a temp name then atomically
-// renamed (a concurrent read never sees a half-written body). Platforms
-// without POSIX modes (Windows) just skip the permission bits.
+// directory 0700, files 0600. The entry is created with its final mode rather
+// than written-then-renamed: rename has no scriptc lowering, so the atomic
+// swap is unavailable and a concurrent reader can observe a short file. The
+// TTL check treats that as a miss on the next read, and the permission bits —
+// the part that actually protects private content — are set at creation.
async function cacheWrite(key: string, text: string): Promise<void> {
try {
- await mkdir(FETCH_CACHE, { recursive: true, mode: 0o700 })
+ mkdirSync(FETCH_CACHE, { recursive: true, mode: 0o700 })
// mkdir leaves a pre-existing dir's mode alone — tighten it explicitly
// so caches created by older ax versions are fixed too.
if (process.platform !== 'win32') await chmod(FETCH_CACHE, 0o700).catch(() => {})
- const tmp = join(FETCH_CACHE, `.tmp-${key}-${process.pid}`)
- await writeFile(tmp, text, { mode: 0o600 })
- await rename(tmp, join(FETCH_CACHE, key))
+ writeFileSync(join(FETCH_CACHE, key), text, { mode: 0o600 })
} catch {
// Caching is an optimization; failing to cache must never fail the read.
}
@@ -85,37 +88,60 @@ const SENSITIVE_QUERY_PART =
/(?:^|[_-])(?:token|api[_-]?key|key|secret|signature|sig|credential|password|authorization|auth)(?:$|[_-])/
function hasSensitiveQuery(src: string): boolean {
- return [...new URL(src).searchParams.keys()].some((name) => {
+ // The iterator has to be consumed directly in the for-of head — it has no
+ // standalone value form under scriptc.
+ for (const name of new URL(src).searchParams.keys()) {
const normalized = name.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase()
- return SENSITIVE_QUERY_PART.test(normalized)
- })
+ if (SENSITIVE_QUERY_PART.test(normalized)) return true
+ }
+ return false
+}
+
+// fd 0 covers every stdin shape (pipe, redirect, tty) on the platforms ax
+// ships for, and is the one form both Bun and a compiled binary agree on.
+export function readStdinText(): string {
+ return readFileSync(0, 'utf8')
+}
+
+export function readStdinBytes(): Uint8Array {
+ const buf = readFileSync(0)
+ return new Uint8Array(buf)
}
export type CappedBody = { bytes: Uint8Array; capped: boolean }
-const timedOut = () =>
- Object.assign(new Error('body read timed out'), { name: 'TimeoutError' as const })
+// Recognised by timeoutError() in place of an `Error & { name }` intersection,
+// which resolves to no runtime shape under scriptc.
+export const BODY_TIMEOUT_MESSAGE = 'body read timed out'
// reader.read() that cannot outlive the deadline. The fetch AbortSignal is
// not reliably propagated to in-flight body reads, so a server that sends
// headers and then goes quiet would hang the agent's turn forever.
+//
+// The deadline is enforced by cancelling the reader rather than racing the
+// read against a timer: Promise.race has no lowering over a dynamically typed
+// promise, and cancelling settles the pending read anyway. `reader` is
+// deliberately untyped — scriptc has no lowering for the statically typed
+// ReadableStream surface, but the same object reached through a dynamic value
+// keeps every method. See readBodyCapped for where it comes from.
export async function readWithDeadline(
- reader: ReadableStreamDefaultReader<Uint8Array>,
+ reader: any,
deadline: number
-): Promise<{ done: boolean; value?: Uint8Array }> {
+): Promise<{ done: boolean; value?: any }> {
const remaining = deadline - Date.now()
if (remaining <= 0) {
await reader.cancel().catch(() => {})
- throw timedOut()
+ throw new Error(BODY_TIMEOUT_MESSAGE)
}
- let timer: ReturnType<typeof setTimeout> | undefined
+ let expired = false
+ const timer = setTimeout(() => {
+ expired = true
+ Promise.resolve(reader.cancel()).catch(() => {})
+ }, remaining)
try {
- return await Promise.race([
- reader.read(),
- new Promise<never>((_, reject) => {
- timer = setTimeout(() => reject(timedOut()), remaining)
- }),
- ])
+ const r = await reader.read()
+ if (expired) throw new Error(BODY_TIMEOUT_MESSAGE)
+ return { done: r.done === true, value: r.value }
} catch (e) {
await reader.cancel().catch(() => {})
throw e
@@ -127,13 +153,13 @@ export async function readWithDeadline(
// Stream a response body, stopping at maxBytes of *received* data — never
// buffer an unbounded body just to truncate it afterwards.
export async function readBodyCapped(
- res: Response,
+ res: any,
maxBytes: number,
deadline: number
): Promise<CappedBody> {
const reader = res.body?.getReader()
if (!reader) return { bytes: new Uint8Array(0), capped: false }
- const chunks: Uint8Array[] = []
+ const chunks: any[] = []
let total = 0
let capped = false
while (true) {
@@ -153,15 +179,18 @@ export async function readBodyCapped(
const bytes = new Uint8Array(total)
let off = 0
for (const c of chunks) {
- bytes.set(c, off)
- off += c.byteLength
+ // .set has no lowering from a dynamic source; copy element-wise instead.
+ const len = c.byteLength as number
+ for (let i = 0; i < len; i++) bytes[off + i] = c[i] as number
+ off += len
}
return { bytes, capped }
}
export function timeoutError(e: unknown, timeoutMs: number): never | null {
- const name = (e as { name?: string })?.name
- if (name === 'TimeoutError' || name === 'AbortError') {
+ const err = e as { name?: string; message?: string }
+ const name = err?.name
+ if (name === 'TimeoutError' || name === 'AbortError' || err?.message === BODY_TIMEOUT_MESSAGE) {
fail(`request timed out after ${timeoutMs / 1000}s`, '-m <secs> raises the timeout')
}
return null
@@ -173,20 +202,20 @@ export function timeoutError(e: unknown, timeoutMs: number): never | null {
// Label normalization/aliasing is left to TextDecoder itself.
export function decodeBody(bytes: Uint8Array, contentType: string | null): string {
const label = bomLabel(bytes) ?? headerCharset(contentType) ?? metaCharset(bytes) ?? 'utf-8'
- try {
- return new TextDecoder(label).decode(bytes)
- } catch (e) {
- if (!(e instanceof RangeError)) throw e
- // Unknown/unsupported label — never crash a fetch over a bad charset claim.
- process.stderr.write(`ax: note: unknown charset "${label}", decoding as UTF-8\n`)
- return new TextDecoder().decode(bytes)
- }
+ const text = decodeText(bytes, label)
+ if (text !== null) return text
+ // Unknown/unsupported label — never crash a fetch over a bad charset claim.
+ process.stderr.write(`ax: note: unknown charset "${label}", decoding as UTF-8\n`)
+ return decodeText(bytes, 'utf-8') ?? ''
}
function bomLabel(bytes: Uint8Array): string | null {
- if (bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf) return 'utf-8'
- if (bytes[0] === 0xff && bytes[1] === 0xfe) return 'utf-16le'
- if (bytes[0] === 0xfe && bytes[1] === 0xff) return 'utf-16be'
+ // Length-checked: a typed-array read past the end is a bounds error under
+ // scriptc, and a HEAD response arrives here with zero bytes.
+ if (bytes.length >= 3 && bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf)
+ return 'utf-8'
+ if (bytes.length >= 2 && bytes[0] === 0xff && bytes[1] === 0xfe) return 'utf-16le'
+ if (bytes.length >= 2 && bytes[0] === 0xfe && bytes[1] === 0xff) return 'utf-16be'
return null
}
@@ -199,7 +228,7 @@ function headerCharset(contentType: string | null): string | null {
// (byte-for-codepoint) decode of the first 1KB is enough to find them without
// knowing the charset yet.
function metaCharset(bytes: Uint8Array): string | null {
- const head = new TextDecoder('latin1').decode(bytes.subarray(0, 1024))
+ const head = decodeText(bytes.subarray(0, 1024), 'latin1') ?? ''
const direct = /<meta\b[^>]*\bcharset\s*=\s*["']?([^"'\s/>;]+)/i.exec(head)
const httpEquiv =
/<meta\b[^>]*\bhttp-equiv\s*=\s*["']?content-type["']?[^>]*\bcontent\s*=\s*["'][^"']*charset=([^"'\s;]+)/i.exec(
@@ -219,12 +248,18 @@ export async function readSource(
options?: ReadSourceOptions
): Promise<string> {
if (src === undefined || src === '-') {
- return await Bun.stdin.text()
+ return readStdinText()
}
if (/^https?:\/\//.test(src)) {
- const g = { maxBytes: DEFAULT_MAX_BYTES, timeoutMs: DEFAULT_TIMEOUT_MS, ...options }
- const key = new Bun.CryptoHasher('sha256').update(src).digest('hex').slice(0, 24)
- const cached = Bun.file(join(FETCH_CACHE, key))
+ // Spreads must come first in an object literal under scriptc.
+ const g = {
+ ...options,
+ maxBytes: options?.maxBytes ?? DEFAULT_MAX_BYTES,
+ timeoutMs: options?.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+ }
+ const key = createHash('sha256').update(src).digest('hex').slice(0, 24)
+ const cachedPath = join(FETCH_CACHE, key)
+ const cachedStat = await stat(cachedPath).catch(() => null)
const fresh = options?.fresh ?? process.argv.includes('--fresh')
const hasCustomHeaders = Object.keys(options?.headers ?? {}).length > 0
// A non-GET method or a body makes this request too unlike a plain page
@@ -241,24 +276,28 @@ export async function readSource(
if (
!fresh &&
!noCache &&
- (await cached.exists()) &&
- Date.now() - cached.lastModified < FETCH_TTL_MS
+ cachedStat !== null &&
+ Date.now() - cachedStat.mtimeMs < FETCH_TTL_MS
) {
- const age = Math.round((Date.now() - cached.lastModified) / 1000)
+ const age = Math.round((Date.now() - cachedStat.mtimeMs) / 1000)
process.stderr.write(`ax: note: using ${age}s-old cached fetch (--fresh to refetch)\n`)
- return await cached.text()
+ return await readFile(cachedPath, 'utf8')
}
const deadline = Date.now() + g.timeoutMs
- let res: Response
+ // The init object is untyped so `tls` (not in the standard RequestInit)
+ // survives, and `res` is untyped so its streaming surface stays reachable
+ // under scriptc — see readWithDeadline.
+ const init: any = {
+ headers: options?.headers,
+ method: options?.method,
+ body: options?.body,
+ signal: AbortSignal.timeout(g.timeoutMs),
+ tls: options?.tls,
+ }
+ let res: any
let body: CappedBody
try {
- res = await fetch(src, {
- headers: options?.headers,
- method: options?.method,
- body: options?.body,
- signal: AbortSignal.timeout(g.timeoutMs),
- tls: options?.tls,
- })
+ res = await fetch(src, init)
if (!res.ok) fail(`fetch failed: ${res.status} ${res.statusText} for ${src}`)
body = await readBodyCapped(res, g.maxBytes, deadline)
} catch (e) {
@@ -283,9 +322,9 @@ export async function readSource(
}
return text
}
- const file = Bun.file(src)
- if (!(await file.exists())) fail(`no such file: ${src}`)
- return await file.text()
+ const exists = (await stat(src).catch(() => null)) !== null
+ if (!exists) fail(`no such file: ${src}`)
+ return await readFile(src, 'utf8')
}
// Structured, single-line error to stderr, then exit. Keeps agent retries cheap.
diff --git a/src/lib/platform.scriptc.ts b/src/lib/platform.scriptc.ts
new file mode 100644
index 0000000..4f3e3d5
--- /dev/null
+++ b/src/lib/platform.scriptc.ts
@@ -0,0 +1,51 @@
+// The compiled-binary counterpart of platform.ts, substituted by
+// scripts/build-scriptc.ts. Both files must export the same signatures.
+//
+// Two capabilities shrink here, and neither can be recovered at runtime:
+//
+// * `new TextDecoder(label)` has no scriptc lowering beyond the default
+// utf-8, so decoding goes through Buffer's encodings. That covers UTF-8,
+// both UTF-16 byte orders and latin1; legacy codecs (shift_jis, euc-jp,
+// windows-125x, gbk, …) are outside Buffer's set and report unsupported,
+// which makes the caller fall back to UTF-8 with a note.
+// * process.stdout.write lowers only for a single string argument, so there
+// is no completion callback and no byte writes. A compiled binary writes
+// straight to the fd, leaving no userland queue to drain; byte payloads
+// are decoded as UTF-8, which is lossy for genuinely binary bodies (-o
+// writes those untouched).
+
+function bufferEncodingFor(label: string): BufferEncoding | null {
+ const l = label.toLowerCase()
+ if (l === 'utf-8' || l === 'utf8') return 'utf8'
+ if (l === 'utf-16le' || l === 'utf-16' || l === 'utf16le') return 'utf16le'
+ if (l === 'latin1' || l === 'iso-8859-1' || l === 'ascii') return 'latin1'
+ return null
+}
+
+/**
+ * Decode bytes using a WHATWG encoding label.
+ *
+ * @returns The decoded text, or null when the label is outside Buffer's set.
+ */
+export function decodeText(bytes: Uint8Array, label: string): string | null {
+ // UTF-16BE has no Buffer encoding — swap the pairs and decode as LE.
+ if (label.toLowerCase() === 'utf-16be') {
+ const swapped = new Uint8Array(bytes.length)
+ for (let i = 0; i + 1 < bytes.length; i += 2) {
+ swapped[i] = bytes[i + 1]!
+ swapped[i + 1] = bytes[i]!
+ }
+ return Buffer.from(swapped).toString('utf16le')
+ }
+ const encoding = bufferEncodingFor(label)
+ if (encoding === 'utf16le') return Buffer.from(bytes).toString('utf16le')
+ if (encoding === 'latin1') return Buffer.from(bytes).toString('latin1')
+ if (encoding === 'utf8') return Buffer.from(bytes).toString('utf8')
+ return null
+}
+
+/** Write to stdout. The fd write is synchronous, so there is nothing to await. */
+export function writeStdout(data: string | Uint8Array): Promise<void> {
+ process.stdout.write(typeof data === 'string' ? data : Buffer.from(data).toString('utf8'))
+ return Promise.resolve()
+}
diff --git a/src/lib/platform.ts b/src/lib/platform.ts
new file mode 100644
index 0000000..b8f3eab
--- /dev/null
+++ b/src/lib/platform.ts
@@ -0,0 +1,33 @@
+// Host-dependent primitives. This is the Bun/Node implementation — the one the
+// repo runs and tests against. `platform.scriptc.ts` is the reduced
+// counterpart a compiled binary gets; scripts/build-scriptc.ts substitutes it
+// at build time, because scriptc refuses the calls used here at COMPILE time
+// (no runtime branch could avoid them) and offers no dynamic escape hatch:
+// `fetch`, `globalThis` and `process` cannot be aliased into an `any` value.
+//
+// Keep the two files' exported signatures identical.
+
+/**
+ * Decode bytes using a WHATWG encoding label.
+ *
+ * @returns The decoded text, or null when the host cannot handle the label.
+ */
+export function decodeText(bytes: Uint8Array, label: string): string | null {
+ try {
+ return new TextDecoder(label).decode(bytes)
+ } catch (e) {
+ // Never crash a fetch over a bad charset claim — the caller falls back.
+ if (e instanceof RangeError) return null
+ throw e
+ }
+}
+
+/**
+ * Write to stdout and resolve once the data has actually been handed off.
+ *
+ * process.exit() discards stdout data still sitting in the write queue — when
+ * stdout is a pipe, anything past the 64KB kernel buffer is silently dropped.
+ */
+export function writeStdout(data: string | Uint8Array): Promise<void> {
+ return new Promise((resolve) => process.stdout.write(data, () => resolve()))
+}
diff --git a/src/lib/query.ts b/src/lib/query.ts
index df49248..4eec7c8 100644
--- a/src/lib/query.ts
+++ b/src/lib/query.ts
@@ -7,6 +7,55 @@ import { compileWhere } from './expr'
type Step = { kind: 'key'; name: string } | { kind: 'iter' } | { kind: 'index'; i: number }
+// jq's type vocabulary, which `typeof` alone cannot produce: it answers
+// 'object' for both null and arrays. The non-JSON arms are here because the
+// input is `unknown` — a JSON document never reaches them.
+export type JqType =
+ | 'null'
+ | 'array'
+ | 'object'
+ | 'string'
+ | 'number'
+ | 'boolean'
+ | 'undefined'
+ | 'bigint'
+ | 'symbol'
+ | 'function'
+
+/**
+ * The jq type name of a value, used for dispatch and for error messages that
+ * read like jq's own ("cannot index array with ...").
+ *
+ * @example
+ * typeOf(null) // => 'null'
+ * typeOf([1]) // => 'array' (typeof would say 'object')
+ */
+export function typeOf(v: unknown): JqType {
+ if (v === null) return 'null'
+ if (Array.isArray(v)) return 'array'
+ return typeof v
+}
+
+// TSV for uniform rows: keys once in a header, values per line. Token-cheap
+// and pipeable into awk/sort. The compiled CLI uses the concrete renderer in
+// tsv.ts; this one keeps the jq surface's `unknown` values.
+export function toTsv(result: unknown): string[] {
+ const arr = Array.isArray(result) ? result : [result]
+ if (arr.length === 0) return []
+ const cell = (v: unknown) =>
+ v === null || v === undefined
+ ? ''
+ : typeOf(v) === 'object' || Array.isArray(v)
+ ? JSON.stringify(v)
+ : String(v).replace(/[\t\n]/g, ' ')
+ if (typeOf(arr[0]) !== 'object') return arr.map(cell)
+ const headers = Object.keys(arr[0] as object)
+ return [
+ headers.join('\t'),
+ ...arr.map((row) => headers.map((h) => cell((row as Record<string, unknown>)[h])).join('\t')),
+ ]
+}
+
function parsePath(path: string): Step[] {
// jq-compat: `.[0]` / `.["k"]` / `.[]` are the same as `[0]` / `["k"]` / `[]`.
path = path.replace(/\.(?=\[)/g, '')
@@ -27,12 +76,6 @@ function parsePath(path: string): Step[] {
return steps
}
-export function typeOf(v: unknown): string {
- if (v === null) return 'null'
- if (Array.isArray(v)) return 'array'
- return typeof v
-}
-
function apply(stream: unknown[], step: Step): unknown[] {
const out: unknown[] = []
for (const v of stream) {
@@ -104,25 +147,6 @@ function pick(result: unknown, spec: string): unknown {
return Array.isArray(result) ? result.map(project) : project(result)
}
-// TSV for uniform rows: keys once in a header, values per line. Token-cheap
-// and pipeable into awk/sort.
-export function toTsv(result: unknown): string[] {
- const arr = Array.isArray(result) ? result : [result]
- if (arr.length === 0) return []
- const cell = (v: unknown) =>
- v === null || v === undefined
- ? ''
- : typeOf(v) === 'object' || Array.isArray(v)
- ? JSON.stringify(v)
- : String(v).replace(/[\t\n]/g, ' ')
- if (typeOf(arr[0]) !== 'object') return arr.map(cell)
- const headers = Object.keys(arr[0] as object)
- return [
- headers.join('\t'),
- ...arr.map((row) => headers.map((h) => cell((row as Record<string, unknown>)[h])).join('\t')),
- ]
-}
-
// Shared output handling for the query commands.
export async function emitQueryResult(
result: unknown,
diff --git a/src/lib/tsv.ts b/src/lib/tsv.ts
new file mode 100644
index 0000000..7a55dad
--- /dev/null
+++ b/src/lib/tsv.ts
@@ -0,0 +1,42 @@
+// TSV rendering for the CLI's extraction paths, split out of query.ts so the
+// compiled module graph does not pull in the (currently unwired) jq surface.
+//
+// Rows are typed concretely rather than over `unknown`: indexing a
+// `Record<string, unknown>` has no scriptc lowering, so the generic renderer in
+// query.ts — which runs only under Bun — cannot be shared here.
+export type Row = Record<string, string | null>
+
+function cell(v: string | null): string {
+ if (v === null) return ''
+ return v.replace(/[\t\n]/g, ' ')
+}
+
+/**
+ * Render rows as TSV: keys once in a header line, values per row.
+ *
+ * @param rows - Uniform rows; the first row's keys become the header.
+ * @returns One string per output line, header included.
+ *
+ * @example
+ * toTsv([{ name: 'a', href: null }]) // => ['name\thref', 'a\t']
+ */
+export function toTsv(rows: Row[]): string[] {
+ if (rows.length === 0) return []
+ const headers: string[] = []
+ for (const k in rows[0]!) headers.push(k)
+ const lines: string[] = [headers.join('\t')]
+ for (const row of rows) {
+ const rec: any = row
+ lines.push(
+ headers
+ .map((h) => {
+ // A dynamic read: an index-signature read is typed `| undefined`
+ // under noUncheckedIndexedAccess, which has no keyed-read lowering.
+ const v = (rec[h] ?? null) as string | null
+ return cell(v)
+ })
+ .join('\t')
+ )
+ }
+ return lines
+}