functionalscript 0.45.0 → 0.46.0

package/fjs/media/json/parser/proof.f.d.mts

@@ -1,8 +1,13 @@
 /**
  * @import { JsonToken } from '../tokenizer/types.ts'
+ * @import { NumberPolicy } from './types.ts'
  */
 export declare const proof: {
     valid: (() => void)[];
     invalid: (() => void)[];
     siblingContainers: (() => void)[];
+    policy: {
+        exactLexeme: () => void;
+        rejected: () => void;
+    };
 };

package/fjs/media/json/parser/proof.f.mjs

@@ -1,18 +1,26 @@
 /**
  * @import { JsonToken } from '../tokenizer/types.ts'
+ * @import { NumberPolicy } from './types.ts'
  */
 
-import { parse } from './module.f.mjs'
+import { parse as parseWithPolicy } from './module.f.mjs'
 import { tokenize } from '../tokenizer/module.f.mjs'
 import { toArray } from '../../../types/list/module.f.mjs'
 import { stringify as jsonStringify } from '../module.f.mjs'
 import { sort } from '../../../types/object/module.f.mjs'
 import { stringToList } from '../../../text/utf16/module.f.mjs'
+import { error, ok } from '../../../types/result/module.f.mjs'
 import { assertEq } from '../../../asserts/module.f.mjs'
 
 /** @type {(s: string) => readonly JsonToken[]} */
 const tokenizeString = s => toArray(tokenize(stringToList(s)))
 
+/** The structural machine is proved through the ordinary `number` policy. */
+/** @type {NumberPolicy<number>} */
+const numberPolicy = token => ok(parseFloat(token.value))
+
+const parse = parseWithPolicy(numberPolicy)
+
 const stringify = jsonStringify(sort)
 
 export const proof = {
@@ -311,4 +319,26 @@ export const proof = {
             assertEq(Array.isArray(value) ? value.length : -1, 12000)
         },
     ],
+    // The numeric policy is the parser's only opinion about numbers: it is
+    // handed the token, so it reads the exact lexeme, and it may reject one.
+    policy: {
+        // the lexeme reaches the policy unrounded — `1.0`, `1e0` and `1` are
+        // one `number` but three tokens
+        exactLexeme: () => {
+            /** @type {NumberPolicy<string>} */
+            const lexemePolicy = token => ok(token.value)
+            const [tag, value] = parseWithPolicy(lexemePolicy)(tokenizeString('[1.0,1e0,1,-0]'))
+            assertEq(tag, 'ok')
+            assertEq(stringify(value), '["1.0","1e0","1","-0"]')
+        },
+        // a policy that cannot represent the number fails the parse as an
+        // ordinary `Result`, with its own message
+        rejected: () => {
+            /** @type {NumberPolicy<never>} */
+            const rejectPolicy = () => error('no numbers here')
+            const [tag, message] = parseWithPolicy(rejectPolicy)(tokenizeString('{"a":[1]}'))
+            assertEq(tag, 'error')
+            assertEq(message, 'no numbers here')
+        },
+    },
 }

package/fjs/media/json/parser/types.d.ts

@@ -1,39 +1,58 @@
 /**
- * Internal state types for the JSON parser.
+ * Types for the shared structural JSON parser: its numeric policy, the tree
+ * that policy produces, and the parser's internal state.
  *
  * @module
  */
-import type { Unknown } from '../types.ts';
+import type { Tree } from '../types.ts';
 import type { OrderedMap } from '../../../types/ordered_map/types.ts';
 import type { List } from '../../../types/list/types.ts';
+import type { Result } from '../../../types/result/types.ts';
 import type { JsonToken } from '../tokenizer/types.ts';
+import type { NumberToken } from '../../../js/tokenizer/types.ts';
 /** JSON tokens that carry a directly-usable value. */
 export type _ValueToken = Extract<JsonToken, {
     readonly kind: 'null' | 'false' | 'true' | 'string' | 'number';
 }>;
-export type _JsonObject = {
+/**
+ * A numeric policy: how one codec materializes a JSON number token into its
+ * own numeric domain `P`.
+ *
+ * The policy is handed the token itself, so it decides from the exact lexeme —
+ * before any narrowing the parser might otherwise have imposed. It may fail:
+ * a valid JSON number can be outside the domain the codec offers (the extended
+ * codec has no non-finite `number`), and that has to be an ordinary parse
+ * error rather than an escaping runtime exception.
+ */
+export type NumberPolicy<P> = (token: NumberToken) => Result<P, string>;
+/**
+ * The tree a numeric policy `P` parses into: JSON's containers over `P` plus
+ * the primitives every policy shares.
+ */
+export type ParseUnknown<P> = Tree<P | null | boolean | string>;
+export type _JsonObject<P> = {
     readonly kind: 'object';
-    readonly values: OrderedMap<Unknown>;
+    readonly values: OrderedMap<ParseUnknown<P>>;
     readonly key: string;
 };
-export type _JsonArray = {
+export type _JsonArray<P> = {
     readonly kind: 'array';
-    readonly values: List<Unknown>;
+    readonly values: List<ParseUnknown<P>>;
 };
-type _JsonStackElement = _JsonObject | _JsonArray;
-export type _JsonStack = List<_JsonStackElement>;
-export type _StateParse = {
+type _JsonStackElement<P> = _JsonObject<P> | _JsonArray<P>;
+export type _JsonStack<P> = List<_JsonStackElement<P>>;
+export type _StateParse<P> = {
     readonly status: '' | '[' | '[v' | '[,' | '{' | '{k' | '{:' | '{v' | '{,';
-    readonly top: _JsonStackElement | null;
-    readonly stack: _JsonStack;
+    readonly top: _JsonStackElement<P> | null;
+    readonly stack: _JsonStack<P>;
 };
-type _StateResult = {
+type _StateResult<P> = {
     readonly status: 'result';
-    readonly value: Unknown;
+    readonly value: ParseUnknown<P>;
 };
 type _StateError = {
     readonly status: 'error';
     readonly message: string;
 };
-export type _JsonState = _StateParse | _StateResult | _StateError;
+export type _JsonState<P> = _StateParse<P> | _StateResult<P> | _StateError;
 export {};

package/fjs/media/json/rtti/module.f.d.mts

@@ -8,7 +8,7 @@
  * `typeof`. That spelling is deliberate: `@type {const}` also type-checks here,
  * but leaves declaration emit no name for the recursive positions, so it
  * inlines the structure, gives up at depth, and degrades the emitted `.d.mts`
- * to `any`. See AGENTS.md §6.2.
+ * to `any`. See `fjs/AGENTS.md` §3.2.
  *
  * The TypeScript counterparts live in the sibling
  * [`../types.ts`](../types.ts), which pins them against these schemas with

package/fjs/media/json/rtti/module.f.mjs

@@ -8,7 +8,7 @@
  * `typeof`. That spelling is deliberate: `@type {const}` also type-checks here,
  * but leaves declaration emit no name for the recursive positions, so it
  * inlines the structure, gives up at depth, and degrades the emitted `.d.mts`
- * to `any`. See AGENTS.md §6.2.
+ * to `any`. See `fjs/AGENTS.md` §3.2.
  *
  * The TypeScript counterparts live in the sibling
  * [`../types.ts`](../types.ts), which pins them against these schemas with

package/fjs/media/json/rtti/proof.f.mjs

@@ -8,20 +8,20 @@
  */
 
 import { assertEq } from '../../../asserts/module.f.mjs'
-import { validate } from '../../../types/rtti/validate/module.f.mjs'
+import { parse } from '../../../types/rtti/parse/module.f.mjs'
 import { primitive, unknown, object, array } from './module.f.mjs'
 
-// Reduces a validation to its `ok`/`error` tag: these schemas are about what is
-// accepted, not about the payload, which validation returns unchanged. The
-// erased `ValidateE` keeps the shared helper from re-instantiating each
-// schema's deep recursive result type (TS2589).
+// Reduces a parse to its `ok`/`error` tag: these schemas are about what is
+// accepted, not about the payload `parse` rebuilds. The erased `ValidateE`
+// keeps the shared helper from re-instantiating each schema's deep recursive
+// result type (TS2589).
 /** @type {(v: ValidateE) => (value: Unknown) => string} */
 const tag = v => value => v(value)[0]
 
-const primitiveAccepts = tag(validate(primitive))
-const unknownAccepts = tag(validate(unknown))
-const objectAccepts = tag(validate(object))
-const arrayAccepts = tag(validate(array))
+const primitiveAccepts = tag(parse(primitive))
+const unknownAccepts = tag(parse(unknown))
+const objectAccepts = tag(parse(object))
+const arrayAccepts = tag(parse(array))
 
 export const proof = {
     primitive: {

package/fjs/media/json/schema/module.f.mjs

@@ -26,7 +26,7 @@
 import { assert, assertNotNullish } from '../../../asserts/module.f.mjs'
 import { at, definedEntries } from '../../../types/object/module.f.mjs'
 import { array, number, option, or, record, string } from '../../../types/rtti/module.f.mjs'
-import { cmp, toData, unitBit, unknown as top } from '../../../types/rtti/data/module.f.mjs'
+import { cmp, toData, unitBit, unknown as top, withoutUnits } from '../../../types/rtti/data/module.f.mjs'
 import { unknown as jsonUnknown } from '../rtti/module.f.mjs'
 
 /** @type {() => readonly ['const', typeof unknownConst]} */
@@ -199,18 +199,8 @@ const admitsUndefined = rules => n => {
  *
  * @type {(n: Node) => Node}
  */
-const stripUndefined = n => {
-    if (typeof n === 'string') { return n }
-    const unit = (n.unit ?? 0) & ~undefinedBit
-    return {
-        ...(unit === 0 ? {} : { unit }),
-        ...(n.number === undefined ? {} : { number: n.number }),
-        ...(n.string === undefined ? {} : { string: n.string }),
-        ...(n.bigint === undefined ? {} : { bigint: n.bigint }),
-        ...(n.array === undefined ? {} : { array: n.array }),
-        ...(n.object === undefined ? {} : { object: n.object }),
-    }
-}
+const stripUndefined = n =>
+    typeof n === 'string' ? n : withoutUnits(undefinedBit)(n)
 
 /**
  * A set of objects: `properties` for the declared keys — a key admitting

package/fjs/media/json/schema/proof.f.d.mts

@@ -1,5 +1,4 @@
 /**
- * @import { Unknown as JsonValue } from '../types.ts'
  * @import { Unknown } from './module.f.mjs'
  * @import { Data } from '../../../types/rtti/data/types.ts'
  */

package/fjs/media/json/schema/proof.f.mjs

@@ -1,5 +1,4 @@
 /**
- * @import { Unknown as JsonValue } from '../types.ts'
  * @import { Unknown } from './module.f.mjs'
  * @import { Data } from '../../../types/rtti/data/types.ts'
  */
@@ -11,7 +10,7 @@ import { unitBit } from '../../../types/rtti/data/module.f.mjs'
 import { assert, assertEq } from '../../../asserts/module.f.mjs'
 
 /** @type {(v: Unknown) => string} */
-const serialize = v => stringify(e => e)(/** @type {JsonValue} */ (/** @type {unknown} */ (v)))
+const serialize = v => stringify(e => e)(v)
 
 /** @type {(rtti: Parameters<typeof toJsonSchema>[0], expected: Unknown) => () => void} */
 const eq = (rtti, expected) => () => {

package/fjs/media/json/serializer/module.f.d.mts

@@ -1,5 +1,10 @@
 /**
- * JSON serializer for deterministic string output.
+ * JSON serializer for deterministic string output: the atoms every JSON leaf
+ * is spelled with, and the one recursive walk over JSON's containers.
+ *
+ * `treeSerialize` is that walk. It knows objects and arrays and nothing about
+ * leaves, so a codec supplies its own leaf spelling — standard JSON and
+ * extended JSON differ only there, not in a second object/array walker.
  *
  * `stringSerialize` is FunctionalScript, not the host's `JSON.stringify`: it
  * escapes over this repository's own UTF-16 decoder and reproduces the
@@ -10,8 +15,10 @@
  * @import { List } from '../../../types/list/types.ts'
  * @import { Reduce } from '../../../types/function/operator/types.ts'
  * @import { CodePoint } from '../../../text/utf16/types.ts'
+ * @import { Tree, TreeObject, TreeArray, TreeEntry, TreeEntries, TreeMapEntries } from '../types.ts'
  */
 import type { List } from '../../../types/list/types.ts';
+import type { Tree, TreeMapEntries } from '../types.ts';
 /**
  * Serializes a string as a JSON string literal.
  *
@@ -38,3 +45,27 @@ export declare const objectWrap: (input: List<List<string>>) => List<string>;
  * @type {(input: List<List<string>>) => List<string>}
  */
 export declare const arrayWrap: (input: List<List<string>>) => List<string>;
+/**
+ * The separator between a serialized property key and its value. Shared with
+ * the DJS serializer, which builds the same `key : value` fragment.
+ *
+ * @type {List<string>}
+ */
+export declare const colon: List<string>;
+/**
+ * The recursive walk over a JSON-shaped tree: objects, arrays, and a leaf
+ * spelling supplied by the codec.
+ *
+ * Every leaf of `Tree<P>` reaches `leafSerialize` — containers are the only
+ * thing this function recognizes — so a codec that adds a leaf type (extended
+ * JSON's `bigint`) or respells one (extended JSON's `3.0` for a whole-valued
+ * `number`) changes `leafSerialize` alone.
+ *
+ * Object entries whose value is `undefined` are dropped: `undefined` is a
+ * missing property, not a leaf of any of these trees.
+ *
+ * @template P
+ * @param {(value: P) => List<string>} leafSerialize
+ * @returns {(sort: TreeMapEntries<P>) => (value: Tree<P>) => List<string>}
+ */
+export declare const treeSerialize: <P>(leafSerialize: (value: P) => List<string>) => (sort: TreeMapEntries<P>) => (value: Tree<P>) => List<string>;

package/fjs/media/json/serializer/module.f.mjs

@@ -1,5 +1,10 @@
 /**
- * JSON serializer for deterministic string output.
+ * JSON serializer for deterministic string output: the atoms every JSON leaf
+ * is spelled with, and the one recursive walk over JSON's containers.
+ *
+ * `treeSerialize` is that walk. It knows objects and arrays and nothing about
+ * leaves, so a codec supplies its own leaf spelling — standard JSON and
+ * extended JSON differ only there, not in a second object/array walker.
  *
  * `stringSerialize` is FunctionalScript, not the host's `JSON.stringify`: it
  * escapes over this repository's own UTF-16 decoder and reproduces the
@@ -10,12 +15,15 @@
  * @import { List } from '../../../types/list/types.ts'
  * @import { Reduce } from '../../../types/function/operator/types.ts'
  * @import { CodePoint } from '../../../text/utf16/types.ts'
+ * @import { Tree, TreeObject, TreeArray, TreeEntry, TreeEntries, TreeMapEntries } from '../types.ts'
  */
 
 import { flat, map, reduce, empty } from '../../../types/list/module.f.mjs'
 import { concat } from '../../../types/string/module.f.mjs'
 import { codePointToString, stringToCodePointList } from '../../../text/utf16/module.f.mjs'
 import { errorMask } from '../../../text/code_point/module.f.mjs'
+import { definedEntries, isObject } from '../../../types/object/module.f.mjs'
+import { compose, fn } from '../../../types/function/module.f.mjs'
 import {
     backspace,
     cr,
@@ -68,7 +76,7 @@ const unicodeEscape = unit =>
 const escapeCodePoint = codePoint =>
     (codePoint & errorMask) !== 0
         ? unicodeEscape(codePoint & 0xffff)
-        : escapeTable[/** @type {keyof typeof escapeTable} */ (codePoint)]
+        : escapeTable[codePoint]
             ?? (codePoint < space ? unicodeEscape(codePoint) : codePointToString(codePoint))
 
 /**
@@ -129,3 +137,57 @@ export const objectWrap
  */
 export const arrayWrap
     = wrap('[')(']')
+
+/**
+ * The separator between a serialized property key and its value. Shared with
+ * the DJS serializer, which builds the same `key : value` fragment.
+ *
+ * @type {List<string>}
+ */
+export const colon = [':']
+
+/**
+ * The recursive walk over a JSON-shaped tree: objects, arrays, and a leaf
+ * spelling supplied by the codec.
+ *
+ * Every leaf of `Tree<P>` reaches `leafSerialize` — containers are the only
+ * thing this function recognizes — so a codec that adds a leaf type (extended
+ * JSON's `bigint`) or respells one (extended JSON's `3.0` for a whole-valued
+ * `number`) changes `leafSerialize` alone.
+ *
+ * Object entries whose value is `undefined` are dropped: `undefined` is a
+ * missing property, not a leaf of any of these trees.
+ *
+ * @template P
+ * @param {(value: P) => List<string>} leafSerialize
+ * @returns {(sort: TreeMapEntries<P>) => (value: Tree<P>) => List<string>}
+ */
+export const treeSerialize = leafSerialize => sort => {
+    // `definedEntries` is generic; naming it at `P` here is what keeps the leaf
+    // type through the `fn(...)` composition below, which would otherwise
+    // instantiate it at `unknown`.
+    /** @type {(object: TreeObject<P>) => TreeEntries<P>} */
+    const objectEntries = definedEntries
+    /** @type {(kv: TreeEntry<P>) => List<string>} */
+    const propertySerialize = ([k, v]) => flat([
+        stringSerialize(k),
+        colon,
+        f(v)
+    ])
+    const mapPropertySerialize = map(propertySerialize)
+    /** @type {(object: TreeObject<P>) => List<string>} */
+    const objectSerialize = fn(objectEntries)
+        .map(sort)
+        .map(mapPropertySerialize)
+        .map(objectWrap)
+        .result
+    /** @type {(value: Tree<P>) => List<string>} */
+    const f = value => {
+        if (value instanceof Array) { return arraySerialize(value) }
+        if (isObject(value)) { return objectSerialize(value) }
+        return leafSerialize(value)
+    }
+    /** @type {(value: TreeArray<P>) => List<string>} */
+    const arraySerialize = compose(map(f))(arrayWrap)
+    return f
+}

package/fjs/media/json/tokenizer/module.f.mjs

@@ -10,7 +10,6 @@
  */
 
 import { concat, empty, flat, stateScan, toArray } from '../../../types/list/module.f.mjs'
-import { multiply } from '../../../types/bigfloat/module.f.mjs'
 import { tokenize as jsTokenize } from '../../../js/tokenizer/module.f.mjs'
 import { assertEq } from '../../../asserts/module.f.mjs'
 
@@ -49,8 +48,13 @@ const parseDefaultState = input => {
 const parseMinusState = input => {
     if (input === null) return [[{ kind: 'error', message: 'invalid token' }], { kind: 'def' }]
     switch (input.token.kind) {
-        case '-': return [[{ kind: 'error', message: 'invalid token' }], { kind: '-' }]
-        case 'number': return [[{ kind: 'number', bf: multiply(input.token.bf)(-1n), value: `-${input.token.value}` }], { kind: 'def' }]
+        // negation is lexical: the minus sign joins the lexeme, so the token
+        // stays the exact source text of the JSON number.
+        case 'number': return [[{ kind: 'number', value: `-${input.token.value}` }], { kind: 'def' }]
+        // No `'-'` case: the underlying JS tokenizer always merges adjacent
+        // `-` characters into a single `'--'` token (see `js/tokenizer`), so
+        // this state never sees a second `'-'` — a run of `-` past the first
+        // always falls through to the `default` arm below instead.
         default: return [{ first: { kind: 'error', message: 'invalid token' }, tail: mapToken(input.token) }, { kind: 'def' }]
     }
 }

package/fjs/media/json/tokenizer/proof.f.d.mts

@@ -5,4 +5,10 @@ export declare const proof: {
     json: (() => void)[];
     id: (() => void)[];
     keywords: (() => void)[];
+    lossless: {
+        oversizedCoefficient: () => void;
+        unboundedExponent: () => void;
+        negativeUnboundedExponent: () => void;
+        negativeOversized: () => void;
+    };
 };

package/fjs/media/json/tokenizer/proof.f.mjs

@@ -7,6 +7,7 @@ import { toArray } from '../../../types/list/module.f.mjs'
 import { stringifyAsTree } from '../../../djs/serializer/module.f.mjs'
 import { sort } from '../../../types/object/module.f.mjs'
 import { stringToList } from '../../../text/utf16/module.f.mjs'
+import { assertStructurallySame } from '../../../asserts/module.f.mjs'
 
 /** @type {(s: string) => readonly JsonToken[]} */
 const tokenizeString = s => toArray(tokenize(stringToList(s)))
@@ -109,11 +110,11 @@ export const proof = {
         },
         () => {
             const result = stringify(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 = stringify(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 = stringify(tokenizeString('00'))
@@ -125,23 +126,23 @@ export const proof = {
         },
         () => {
             const result = stringify(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 = stringify(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 = stringify(tokenizeString('1 2'))
-            if (result !== '[{"bf":[1n,0],"kind":"number","value":"1"},{"bf":[2n,0],"kind":"number","value":"2"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"1"},{"kind":"number","value":"2"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('0. 2'))
-            if (result !== '[{"kind":"error","message":"invalid number"},{"bf":[2n,0],"kind":"number","value":"2"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"error","message":"invalid number"},{"kind":"number","value":"2"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('10-0'))
-            if (result !== '[{"bf":[10n,0],"kind":"number","value":"10"},{"bf":[0n,0],"kind":"number","value":"-0"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"10"},{"kind":"number","value":"-0"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('9a:'))
@@ -149,7 +150,7 @@ export const proof = {
         },
         () => {
             const result = stringify(tokenizeString('-10'))
-            if (result !== '[{"bf":[-10n,0],"kind":"number","value":"-10"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"-10"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('-'))
@@ -165,7 +166,7 @@ export const proof = {
         },
         () => {
             const result = stringify(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 = stringify(tokenizeString('-00'))
@@ -173,15 +174,15 @@ export const proof = {
         },
         () => {
             const result = stringify(tokenizeString('-.123'))
-            if (result !== '[{"kind":"error","message":"invalid token"},{"kind":"error","message":"invalid token"},{"bf":[123n,0],"kind":"number","value":"123"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"error","message":"invalid token"},{"kind":"error","message":"invalid token"},{"kind":"number","value":"123"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = stringify(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 = stringify(tokenizeString('-0.9'))
-            if (result !== '[{"bf":[-9n,-1],"kind":"number","value":"-0.9"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"-0.9"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('-0.'))
@@ -193,11 +194,11 @@ export const proof = {
         },
         () => {
             const result = stringify(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 = stringify(tokenizeString('-12.00'))
-            if (result !== '[{"bf":[-1200n,-2],"kind":"number","value":"-12.00"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"-12.00"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('-12.'))
@@ -209,27 +210,27 @@ export const proof = {
         },
         () => {
             const result = stringify(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 = stringify(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 = stringify(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 = stringify(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 = stringify(tokenizeString('-12e-0001'))
-            if (result !== '[{"bf":[-12n,-1],"kind":"number","value":"-12e-0001"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"-12e-0001"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('-12.34e1234'))
-            if (result !== '[{"bf":[-1234n,1232],"kind":"number","value":"-12.34e1234"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"-12.34e1234"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('0e'))
@@ -287,5 +288,45 @@ export const proof = {
             const result = stringify(tokenizeString('[null]'))
             if (result !== '[{"kind":"["},{"kind":"null"},{"kind":"]"},{"kind":"eof"}]') { throw result }
         },
-    ]
+    ],
+    // Losslessness starts at the tokenizer boundary: a syntactically valid
+    // JSON number reaches `NumberToken.value` as its exact lexeme. Nothing
+    // derived from it — a coefficient bigint, an exponent number — is built
+    // while scanning, so no valid input can fail to tokenize because such a
+    // derived value would exceed a runtime numeric limit.
+    //
+    // The runtime's own bigint limit (V8 rejects magnitudes above 2^30 bits,
+    // roughly 3.2e8 decimal digits) is not exercised here: the smallest input
+    // that reaches it is a JSON document of some hundreds of megabytes. These
+    // cases stay far below that while still being far above what `number` and
+    // `Number.MAX_SAFE_INTEGER` can hold.
+    lossless: {
+        // a coefficient with more digits than any JavaScript number can carry
+        oversizedCoefficient: () => {
+            const value = `1${'0'.repeat(100000)}1`
+            assertStructurallySame(
+                tokenizeString(value),
+                [{ kind: 'number', value }, { kind: 'eof' }])
+        },
+        // exponent text far beyond JavaScript-number precision: `Number` of it
+        // is `Infinity`, yet every digit still has to reach the token
+        unboundedExponent: () => {
+            const value = '1e999999999999999999999'
+            assertStructurallySame(
+                tokenizeString(value),
+                [{ kind: 'number', value }, { kind: 'eof' }])
+        },
+        negativeUnboundedExponent: () => {
+            const value = '-1.5e-999999999999999999999'
+            assertStructurallySame(
+                tokenizeString(value),
+                [{ kind: 'number', value }, { kind: 'eof' }])
+        },
+        negativeOversized: () => {
+            const value = `-1${'0'.repeat(100000)}1`
+            assertStructurallySame(
+                tokenizeString(value),
+                [{ kind: 'number', value }, { kind: 'eof' }])
+        },
+    },
 }