functionalscript 0.45.0 → 0.46.1

package/fjs/djs/tokenizer/proof.f.mjs

@@ -1,11 +1,10 @@
 /**
- * @import { Unknown } from '../types.ts'
  */
 
-import { descentParser } from '../../bnf/descent/module.f.mjs'
+import { isRepeat, toData } from '../../bnf/data/module.f.mjs'
 import { stringToCodePointList, stringToList } from '../../text/utf16/module.f.mjs'
 import { toArray } from '../../types/list/module.f.mjs'
-import { jsGrammar, tokenizeString, descentParserCpOnly, tokenizeJs, tokenize } from './module.f.mjs'
+import { jsGrammar, jsMatcher, tokenizeString, descentParserCpOnly, tokenizeJs, tokenize } from './module.f.mjs'
 import { assert, assertEq } from '../../asserts/module.f.mjs'
 import { stringifyAsTree } from '../serializer/module.f.mjs'
 import { sort } from '../../types/object/module.f.mjs'
@@ -25,13 +24,21 @@ const errorAt = s => {
 }
 
 export const proof = {
+    // The whole-file grammar is one repetition of a token, and `toData` records
+    // that rather than leaving it as the right-recursive variant `repeat0Plus`
+    // builds — which is why the tokenizer reads its entry name from `jsMatcher`
+    // instead of naming a rule: the rules that encoded the repetition are gone.
+    jsGrammar: () => {
+        const [ruleSet, entry] = toData(jsGrammar())
+        assert(isRepeat(ruleSet[entry]), JSON.stringify([ruleSet[entry], entry]))
+    },
     isValid: [() => {
-            const m = descentParser(jsGrammar())
+            const [m, entry] = jsMatcher()
 
             /** @type {(s: string, expected: boolean) => void} */
             const expect = (s, expected) => {
                 const cp = toArray(stringToCodePointList(s))
-                const mr = descentParserCpOnly(m, '', cp)
+                const mr = descentParserCpOnly(m, entry, cp)
                 const success = mr.success && mr.idx === cp.length
                 assertEq(success, expected, JSON.stringify([s, mr]))
             }
@@ -67,121 +74,121 @@ export const proof = {
     ],
     tokenizer: [
         () => {
-            const m = descentParser(jsGrammar())
+            const [m, entry] = jsMatcher()
             const cp = toArray(stringToCodePointList('tr'))
-            const mr = descentParserCpOnly(m, '', cp)
+            const mr = descentParserCpOnly(m, entry, cp)
             const seq = mr.ast.sequence[0]
             assert(!(seq instanceof Array), JSON.stringify(mr))
             assertEq(seq.tag, 'id', JSON.stringify(mr))
         },
         () => {
-            const m = descentParser(jsGrammar())
+            const [m, entry] = jsMatcher()
             const cp = toArray(stringToCodePointList('"tr"'))
-            const mr = descentParserCpOnly(m, '', cp)
+            const mr = descentParserCpOnly(m, entry, cp)
             const seq = mr.ast.sequence[0]
             assert(!(seq instanceof Array), JSON.stringify(mr))
             assertEq(seq.tag, 'string', JSON.stringify(mr))
         },
         () => {
-            const m = descentParser(jsGrammar())
+            const [m, entry] = jsMatcher()
             const cp = toArray(stringToCodePointList('56.7e+5'))
-            const mr = descentParserCpOnly(m, '', cp)
+            const mr = descentParserCpOnly(m, entry, cp)
             const seq = mr.ast.sequence[0]
             assert(!(seq instanceof Array), JSON.stringify(mr))
             assertEq(seq.tag, 'number', JSON.stringify(mr))
         },
         () => {
-            const m = descentParser(jsGrammar())
+            const [m, entry] = jsMatcher()
             const cp = toArray(stringToCodePointList('56n'))
-            const mr = descentParserCpOnly(m, '', cp)
+            const mr = descentParserCpOnly(m, entry, cp)
             const seq = mr.ast.sequence[0]
             assert(!(seq instanceof Array), JSON.stringify(mr))
             assertEq(seq.tag, 'number', JSON.stringify(mr))
         },
         () => {
-            const m = descentParser(jsGrammar())
+            const [m, entry] = jsMatcher()
             const cp = toArray(stringToCodePointList('*'))
-            const mr = descentParserCpOnly(m, '', cp)
+            const mr = descentParserCpOnly(m, entry, cp)
             const seq = mr.ast.sequence[0]
             assert(!(seq instanceof Array), JSON.stringify(mr))
             assertEq(seq.tag, '*', JSON.stringify(mr))
         },
         () => {
-            const m = descentParser(jsGrammar())
+            const [m, entry] = jsMatcher()
             const cp = toArray(stringToCodePointList('**'))
-            const mr = descentParserCpOnly(m, '', cp)
+            const mr = descentParserCpOnly(m, entry, cp)
             const seq = mr.ast.sequence[0]
             assert(!(seq instanceof Array), JSON.stringify(mr))
             assertEq(seq.tag, '**', JSON.stringify(mr))
         },
         () => {
-            const m = descentParser(jsGrammar())
+            const [m, entry] = jsMatcher()
             const cp = toArray(stringToCodePointList('=>'))
-            const mr = descentParserCpOnly(m, '', cp)
+            const mr = descentParserCpOnly(m, entry, cp)
             const seq = mr.ast.sequence[0]
             assert(!(seq instanceof Array), JSON.stringify(mr))
             assertEq(seq.tag, '=>', JSON.stringify(mr))
         },
         () => {
-            const m = descentParser(jsGrammar())
+            const [m, entry] = jsMatcher()
             const cp = toArray(stringToCodePointList('=='))
-            const mr = descentParserCpOnly(m, '', cp)
+            const mr = descentParserCpOnly(m, entry, cp)
             const seq = mr.ast.sequence[0]
             assert(!(seq instanceof Array), JSON.stringify(mr))
             assert(!(seq.tag !== '=='), JSON.stringify(mr))
         },
         () => {
-            const m = descentParser(jsGrammar())
+            const [m, entry] = jsMatcher()
             const cp = toArray(stringToCodePointList('==='))
-            const mr = descentParserCpOnly(m, '', cp)
+            const mr = descentParserCpOnly(m, entry, cp)
             const seq = mr.ast.sequence[0]
             assert(!(seq instanceof Array), JSON.stringify(mr))
             assert(!(seq.tag !== '==='), JSON.stringify(mr))
         },
         () => {
-            const m = descentParser(jsGrammar())
+            const [m, entry] = jsMatcher()
             const cp = toArray(stringToCodePointList('='))
-            const mr = descentParserCpOnly(m, '', cp)
+            const mr = descentParserCpOnly(m, entry, cp)
             const seq = mr.ast.sequence[0]
             assert(!(seq instanceof Array), JSON.stringify(mr))
             assertEq(seq.tag, '=', JSON.stringify(mr))
         },
         () => {
-            const m = descentParser(jsGrammar())
+            const [m, entry] = jsMatcher()
             const cp = toArray(stringToCodePointList(' '))
-            const mr = descentParserCpOnly(m, '', cp)
+            const mr = descentParserCpOnly(m, entry, cp)
             const seq = mr.ast.sequence[0]
             assert(!(seq instanceof Array), JSON.stringify(mr))
             assertEq(seq.tag, ' ', JSON.stringify(mr))
         },
         () => {
-            const m = descentParser(jsGrammar())
+            const [m, entry] = jsMatcher()
             const cp = toArray(stringToCodePointList('\n'))
-            const mr = descentParserCpOnly(m, '', cp)
+            const mr = descentParserCpOnly(m, entry, cp)
             const seq = mr.ast.sequence[0]
             assert(!(seq instanceof Array), JSON.stringify(mr))
             assertEq(seq.tag, '\n', JSON.stringify(mr))
         },
         () => {
-            const m = descentParser(jsGrammar())
+            const [m, entry] = jsMatcher()
             const cp = toArray(stringToCodePointList('/\n'))
-            const mr = descentParserCpOnly(m, '', cp)
+            const mr = descentParserCpOnly(m, entry, cp)
             const seq = mr.ast.sequence[0]
             assert(!(seq instanceof Array), JSON.stringify(mr))
             assertEq(seq.tag, '/', JSON.stringify(mr))
         },
         () => {
-            const m = descentParser(jsGrammar())
+            const [m, entry] = jsMatcher()
             const cp = toArray(stringToCodePointList('//\n'))
-            const mr = descentParserCpOnly(m, '', cp)
+            const mr = descentParserCpOnly(m, entry, cp)
             const seq = mr.ast.sequence[0]
             assert(!(seq instanceof Array), JSON.stringify(mr))
             assertEq(seq.tag, 'comment', JSON.stringify(mr))
         },
         () => {
-            const m = descentParser(jsGrammar())
+            const [m, entry] = jsMatcher()
             const cp = toArray(stringToCodePointList('/*1*/'))
-            const mr = descentParserCpOnly(m, '', cp)
+            const mr = descentParserCpOnly(m, entry, cp)
             const seq = mr.ast.sequence[0]
             assert(!(seq instanceof Array), JSON.stringify(mr))
             assertEq(seq.tag, 'comment', JSON.stringify(mr))
@@ -290,11 +297,11 @@ export const proof = {
         },
         () => {
             const result = tokenizeString('0')
-            if (result !== '[{"bf":[0n,0],"kind":"number","value":"0"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"0"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = tokenizeString('[0]')
-            if (result !== '[{"kind":"["},{"bf":[0n,0],"kind":"number","value":"0"},{"kind":"]"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"["},{"kind":"number","value":"0"},{"kind":"]"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = tokenizeString('00')
@@ -306,15 +313,15 @@ export const proof = {
         },
         () => {
             const result = tokenizeString('123456789012345678901234567890')
-            if (result !== '[{"bf":[123456789012345678901234567890n,0],"kind":"number","value":"123456789012345678901234567890"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"123456789012345678901234567890"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = tokenizeString('{90}')
-            if (result !== '[{"kind":"{"},{"bf":[90n,0],"kind":"number","value":"90"},{"kind":"}"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"{"},{"kind":"number","value":"90"},{"kind":"}"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = tokenizeString('1 2')
-            if (result !== '[{"bf":[1n,0],"kind":"number","value":"1"},{"kind":"ws"},{"bf":[2n,0],"kind":"number","value":"2"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"1"},{"kind":"ws"},{"kind":"number","value":"2"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = tokenizeString('0. 2')
@@ -322,7 +329,7 @@ export const proof = {
         },
         () => {
             const result = tokenizeString('10-0')
-            if (result !== '[{"bf":[10n,0],"kind":"number","value":"10"},{"kind":"-"},{"bf":[0n,0],"kind":"number","value":"0"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"10"},{"kind":"-"},{"kind":"number","value":"0"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = tokenizeString('9a:')
@@ -330,11 +337,11 @@ export const proof = {
         },
         () => {
             const result = tokenizeString('-10')
-            if (result !== '[{"kind":"-"},{"bf":[10n,0],"kind":"number","value":"10"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"-"},{"kind":"number","value":"10"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = tokenizeString('-0')
-            if (result !== '[{"kind":"-"},{"bf":[0n,0],"kind":"number","value":"0"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"-"},{"kind":"number","value":"0"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = tokenizeString('-00')
@@ -342,15 +349,15 @@ export const proof = {
         },
         () => {
             const result = tokenizeString('-.123')
-            if (result !== '[{"kind":"-"},{"kind":"."},{"bf":[123n,0],"kind":"number","value":"123"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"-"},{"kind":"."},{"kind":"number","value":"123"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = tokenizeString('0.01')
-            if (result !== '[{"bf":[1n,-2],"kind":"number","value":"0.01"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"0.01"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = tokenizeString('-0.9')
-            if (result !== '[{"kind":"-"},{"bf":[9n,-1],"kind":"number","value":"0.9"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"-"},{"kind":"number","value":"0.9"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = tokenizeString('-0.')
@@ -362,11 +369,11 @@ export const proof = {
         },
         () => {
             const result = tokenizeString('12.34')
-            if (result !== '[{"bf":[1234n,-2],"kind":"number","value":"12.34"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"12.34"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = tokenizeString('-12.00')
-            if (result !== '[{"kind":"-"},{"bf":[1200n,-2],"kind":"number","value":"12.00"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"-"},{"kind":"number","value":"12.00"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = tokenizeString('-12.')
@@ -378,27 +385,27 @@ export const proof = {
         },
         () => {
             const result = tokenizeString('0e1')
-            if (result !== '[{"bf":[0n,1],"kind":"number","value":"0e1"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"0e1"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = tokenizeString('0e+2')
-            if (result !== '[{"bf":[0n,2],"kind":"number","value":"0e+2"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"0e+2"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = tokenizeString('0e-0')
-            if (result !== '[{"bf":[0n,0],"kind":"number","value":"0e-0"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"0e-0"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = tokenizeString('12e0000')
-            if (result !== '[{"bf":[12n,0],"kind":"number","value":"12e0000"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"12e0000"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = tokenizeString('-12e-0001')
-            if (result !== '[{"kind":"-"},{"bf":[12n,-1],"kind":"number","value":"12e-0001"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"-"},{"kind":"number","value":"12e-0001"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = tokenizeString('-12.34e1234')
-            if (result !== '[{"kind":"-"},{"bf":[1234n,1232],"kind":"number","value":"12.34e1234"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"-"},{"kind":"number","value":"12.34e1234"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = tokenizeString('0e')
@@ -418,11 +425,11 @@ export const proof = {
         },
         () => {
             const result = tokenizeString('123 _123')
-            if (result !== '[{"bf":[123n,0],"kind":"number","value":"123"},{"kind":"ws"},{"kind":"id","value":"_123"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"123"},{"kind":"ws"},{"kind":"id","value":"_123"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = tokenizeString('123 $123')
-            if (result !== '[{"bf":[123n,0],"kind":"number","value":"123"},{"kind":"ws"},{"kind":"id","value":"$123"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"123"},{"kind":"ws"},{"kind":"id","value":"$123"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = tokenizeString('123_123')
@@ -477,7 +484,7 @@ export const proof = {
         },
         () => {
             const result = tokenizeString('1*2')
-            if (result !== '[{"bf":[1n,0],"kind":"number","value":"1"},{"kind":"*"},{"bf":[2n,0],"kind":"number","value":"2"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"1"},{"kind":"*"},{"kind":"number","value":"2"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = tokenizeString('( )')
@@ -886,19 +893,19 @@ export const proof = {
         () => {
             // keywords other than true/false/null/undefined become plain ids
             const result = toArray(tokenize(stringToList('break'))(''))
-            assertEq(stringify(/** @type {Unknown} */ (result)), '[{"metadata":{"column":1,"line":1,"path":""},"token":{"kind":"id","value":"break"}},{"metadata":{"column":6,"line":1,"path":""},"token":{"kind":"eof"}}]')
+            assertEq(stringify(result), '[{"metadata":{"column":1,"line":1,"path":""},"token":{"kind":"id","value":"break"}},{"metadata":{"column":6,"line":1,"path":""},"token":{"kind":"eof"}}]')
         },
         () => {
             const result = toArray(tokenize(stringToList('-10'))(''))
-            assertEq(stringify(/** @type {Unknown} */ (result)), '[{"metadata":{"column":2,"line":1,"path":""},"token":{"bf":[-10n,0],"kind":"number","value":"-10"}},{"metadata":{"column":4,"line":1,"path":""},"token":{"kind":"eof"}}]')
+            assertEq(stringify(result), '[{"metadata":{"column":2,"line":1,"path":""},"token":{"kind":"number","value":"-10"}},{"metadata":{"column":4,"line":1,"path":""},"token":{"kind":"eof"}}]')
         },
         () => {
             const result = toArray(tokenize(stringToList('-0'))(''))
-            assertEq(stringify(/** @type {Unknown} */ (result)), '[{"metadata":{"column":2,"line":1,"path":""},"token":{"bf":[0n,0],"kind":"number","value":"-0"}},{"metadata":{"column":3,"line":1,"path":""},"token":{"kind":"eof"}}]')
+            assertEq(stringify(result), '[{"metadata":{"column":2,"line":1,"path":""},"token":{"kind":"number","value":"-0"}},{"metadata":{"column":3,"line":1,"path":""},"token":{"kind":"eof"}}]')
         },
         () => {
             const result = toArray(tokenize(stringToList('-1234567890n'))(''))
-            assertEq(stringify(/** @type {Unknown} */ (result)), '[{"metadata":{"column":2,"line":1,"path":""},"token":{"kind":"bigint","value":-1234567890n}},{"metadata":{"column":13,"line":1,"path":""},"token":{"kind":"eof"}}]')
+            assertEq(stringify(result), '[{"metadata":{"column":2,"line":1,"path":""},"token":{"kind":"bigint","value":-1234567890n}},{"metadata":{"column":13,"line":1,"path":""},"token":{"kind":"eof"}}]')
         },
         () => {
             // `js/tokenizer` merges '--' into one decrement-operator token, so
@@ -906,31 +913,31 @@ export const proof = {
             // it's one error straight from the default state's unknown-token
             // fallback, mapping the whole '--' token to a single error.
             const result = toArray(tokenize(stringToList('--'))(''))
-            assertEq(stringify(/** @type {Unknown} */ (result)), '[{"metadata":{"column":1,"line":1,"path":""},"token":{"kind":"error","message":"invalid token"}},{"metadata":{"column":3,"line":1,"path":""},"token":{"kind":"eof"}}]')
+            assertEq(stringify(result), '[{"metadata":{"column":1,"line":1,"path":""},"token":{"kind":"error","message":"invalid token"}},{"metadata":{"column":3,"line":1,"path":""},"token":{"kind":"eof"}}]')
         },
         () => {
             const result = toArray(tokenize(stringToList('---'))(''))
-            assertEq(stringify(/** @type {Unknown} */ (result)), '[{"metadata":{"column":1,"line":1,"path":""},"token":{"kind":"error","message":"invalid token"}},{"metadata":{"column":4,"line":1,"path":""},"token":{"kind":"error","message":"invalid token"}},{"metadata":{"column":4,"line":1,"path":""},"token":{"kind":"eof"}}]')
+            assertEq(stringify(result), '[{"metadata":{"column":1,"line":1,"path":""},"token":{"kind":"error","message":"invalid token"}},{"metadata":{"column":4,"line":1,"path":""},"token":{"kind":"error","message":"invalid token"}},{"metadata":{"column":4,"line":1,"path":""},"token":{"kind":"eof"}}]')
         },
         () => {
             // dangling '-' at eof
             const result = toArray(tokenize(stringToList('-'))(''))
-            assertEq(stringify(/** @type {Unknown} */ (result)), '[{"metadata":{"column":2,"line":1,"path":""},"token":{"kind":"error","message":"invalid token"}},{"metadata":{"column":2,"line":1,"path":""},"token":{"kind":"eof"}}]')
+            assertEq(stringify(result), '[{"metadata":{"column":2,"line":1,"path":""},"token":{"kind":"error","message":"invalid token"}},{"metadata":{"column":2,"line":1,"path":""},"token":{"kind":"eof"}}]')
         },
         () => {
             // '-' followed by neither a number/bigint nor eof: one error for
             // the dangling '-', then the following token maps through normally.
             const result = toArray(tokenize(stringToList('-{'))(''))
-            assertEq(stringify(/** @type {Unknown} */ (result)), '[{"metadata":{"column":2,"line":1,"path":""},"token":{"kind":"error","message":"invalid token"}},{"metadata":{"column":2,"line":1,"path":""},"token":{"kind":"{"}},{"metadata":{"column":3,"line":1,"path":""},"token":{"kind":"eof"}}]')
+            assertEq(stringify(result), '[{"metadata":{"column":2,"line":1,"path":""},"token":{"kind":"error","message":"invalid token"}},{"metadata":{"column":2,"line":1,"path":""},"token":{"kind":"{"}},{"metadata":{"column":3,"line":1,"path":""},"token":{"kind":"eof"}}]')
         },
         () => {
             const result = toArray(tokenize(stringToList('[-1234567890n]'))(''))
-            assertEq(stringify(/** @type {Unknown} */ (result)), '[{"metadata":{"column":1,"line":1,"path":""},"token":{"kind":"["}},{"metadata":{"column":3,"line":1,"path":""},"token":{"kind":"bigint","value":-1234567890n}},{"metadata":{"column":14,"line":1,"path":""},"token":{"kind":"]"}},{"metadata":{"column":15,"line":1,"path":""},"token":{"kind":"eof"}}]')
+            assertEq(stringify(result), '[{"metadata":{"column":1,"line":1,"path":""},"token":{"kind":"["}},{"metadata":{"column":3,"line":1,"path":""},"token":{"kind":"bigint","value":-1234567890n}},{"metadata":{"column":14,"line":1,"path":""},"token":{"kind":"]"}},{"metadata":{"column":15,"line":1,"path":""},"token":{"kind":"eof"}}]')
         },
         () => {
             // grammar-level tokenizer error position flows through the DJS wrapper unchanged
             const result = toArray(tokenize(stringToList('00'))(''))
-            assertEq(stringify(/** @type {Unknown} */ (result)), '[{"metadata":{"column":2,"line":1,"path":""},"token":{"kind":"error","message":"invalid token"}}]')
+            assertEq(stringify(result), '[{"metadata":{"column":2,"line":1,"path":""},"token":{"kind":"error","message":"invalid token"}}]')
         },
     ],
     // Regression coverage for large inputs: both a file with many short tokens and a

package/fjs/djs/transpiler/module.f.d.mts

@@ -7,25 +7,30 @@
  * @import { Result } from '../../types/result/types.ts'
  * @import { ParseError } from '../parser/types.ts'
  * @import { AstModule } from '../ast/types.ts'
+ * @import { Operation } from '../../effects/types.ts'
+ * @import { IoChannel } from '../../effects/node/types.ts'
  * @import { Effect } from '../../effects/types.ts'
  * @import { ReadFile } from '../../effects/node/types.ts'
  * @import { ParseContext } from './types.ts'
  */
 import type { Unknown } from '../types.ts';
-import type { Result } from '../../types/result/types.ts';
 import type { ParseError } from '../parser/types.ts';
 import type { Effect } from '../../effects/types.ts';
 import type { ReadFile } from '../../effects/node/types.ts';
 /**
- * Transpiles a DJS module graph rooted at `path` into a single `Unknown` value.
+ * Transpiles the file at `path` into a single `Unknown` value.
  *
- * Reads each file via the `ReadFile` effect, resolves imports recursively, and
- * evaluates the AST. Returns `['ok', value]` on success, or `['error', ParseError]`
- * on a parse failure or circular dependency.
+ * The extension names its language: a `.json` file is a JSON document, read by
+ * `fjs/media/json`, and anything else is a FunctionalScript module, whose
+ * imports are resolved recursively — each of them a module too, whatever it is
+ * called ([spec: the `__proto__` key](../../../spec/README.md#the-__proto__-key)).
  *
- * @type {(path: string) => Effect<ReadFile, Result<Unknown, ParseError>>}
+ * Returns `['ok', value]` on success, or `['error', ParseError]` on a parse
+ * failure, a missing file, or a circular dependency.
+ *
+ * @type {(path: string) => Effect<ReadFile, Unknown, ParseError>}
  */
-export declare const transpile: (path: string) => Effect<ReadFile, Result<Unknown, ParseError>>;
+export declare const transpile: (path: string) => Effect<ReadFile, Unknown, ParseError>;
 export declare const proof: {
     throw: {
         mapDjsUnresolvedImport: () => Unknown;