functionalscript 0.43.1 → 0.45.0

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

@@ -0,0 +1,236 @@
+/**
+ * JSON parser that consumes tokenizer output into JSON values.
+ *
+ * @module
+ *
+ * @import { Unknown } from '../types.ts'
+ * @import { Result } from '../../../types/result/types.ts'
+ * @import { List } from '../../../types/list/types.ts'
+ * @import { Fold } from '../../../types/function/operator/types.ts'
+ * @import { JsonToken } from '../tokenizer/types.ts'
+ * @import { _JsonObject, _JsonArray, _StateParse, _JsonState, _JsonStack, _ValueToken } from './types.ts'
+ */
+
+import { error, ok } from '../../../types/result/module.f.mjs'
+import { fold, next, toArray, concat } from '../../../types/list/module.f.mjs'
+import { setReplace } from '../../../types/ordered_map/module.f.mjs'
+import { fromMap } from '../../../types/object/module.f.mjs'
+import { assertEq } from '../../../asserts/module.f.mjs'
+
+/** @type {(obj: _JsonObject) => (key: string) => _JsonObject} */
+const addKeyToObject =
+    obj => key => ({ kind: 'object', values: obj.values, key: key })
+
+/** @type {(obj: _JsonObject) => (value: Unknown) => _JsonObject} */
+const addValueToObject =
+    obj => value => ({ kind: 'object', values: setReplace(obj.key)(value)(obj.values), key: '' })
+
+/** @type {(array: _JsonArray) => (value: Unknown) => _JsonArray} */
+const addToArray =
+    array => value => ({ kind: 'array', values: concat(array.values)([value]) })
+
+/** @type {(state: _StateParse) => (key: string) => _JsonState} */
+const pushKey = state => value => {
+    if (state.top?.kind === 'object') { return { status: '{k', top: addKeyToObject(state.top)(value), stack: state.stack } }
+    return { status: 'error', message: 'error' }
+}
+
+/** @type {(state: _StateParse) => (value: Unknown) => _JsonState} */
+const pushValue = state => value => {
+    if (state.top === null) { return { status: 'result', value: value } }
+    if (state.top.kind === 'array') { return { status: '[v', top: addToArray(state.top)(value), stack: state.stack } }
+    return { status: '{v', top: addValueToObject(state.top)(value), stack: state.stack }
+}
+
+/** @type {(state: _StateParse) => _JsonState} */
+const startArray = state => {
+    const newStack = state.top === null ? null : { first: state.top, tail: state.stack }
+    return { status: '[', top: { kind: 'array', values: null }, stack: newStack }
+}
+
+/**
+ * Pops the enclosing container off `stack`. `next` is forced here rather than
+ * left as a `drop(1)` thunk: the stack is written only by startArray/startObject,
+ * always as a literal cons, and a lazy pop would leave one unforced thunk per
+ * closed container — a chain that overflows the stack when it is finally forced.
+ *
+ * @type {(stack: _JsonStack) => _StateParse}
+ */
+const popStack = stack => {
+    const ne = next(stack)
+    return ne === null
+        ? { status: '', top: null, stack: null }
+        : { status: '', top: ne.first, stack: ne.tail }
+}
+
+/**
+ * `endArray` only ever runs while parsing the array `startArray` opened
+ * (status `'['`/`'[v'`), so `state.top` is always that array here.
+ *
+ * @type {(state: _StateParse) => _JsonState}
+ */
+const endArray = state => {
+    const array = toArray(/** @type {_JsonArray} */ (state.top).values)
+    const newState = popStack(state.stack)
+    return pushValue(newState)(array)
+}
+
+/** @type {(state: _StateParse) => _JsonState} */
+const startObject = state => {
+    const newStack = state.top === null ? null : { first: state.top, tail: state.stack }
+    return { status: '{', top: { kind: 'object', values: null, key: '' }, stack: newStack }
+}
+
+/**
+ * `endObject` only ever runs while parsing the object `startObject` opened
+ * (status `'{'`/`'{v'`), so `state.top` is always that object here.
+ *
+ * @type {(state: _StateParse) => _JsonState}
+ */
+const endObject = state => {
+    const obj = fromMap(/** @type {_JsonObject} */ (state.top).values)
+    const newState = popStack(state.stack)
+    return pushValue(newState)(obj)
+}
+
+/**
+ * Only ever called on a token `isValueToken` has already confirmed carries a
+ * value, so the switch covers every `_ValueToken` case with no fallback arm.
+ *
+ * @type {(token: _ValueToken) => Unknown}
+ */
+const tokenToValue = token => {
+    switch (token.kind) {
+        case 'null': return null
+        case 'false': return false
+        case 'true': return true
+        case 'number': return parseFloat(token.value)
+        case 'string': return token.value
+    }
+}
+
+/**
+ * @param {JsonToken} token
+ * @returns {token is _ValueToken}
+ */
+const isValueToken = token => {
+    switch (token.kind) {
+        case 'null':
+        case 'false':
+        case 'true':
+        case 'number':
+        case 'string': return true
+        default: return false
+    }
+}
+
+/** @type {(token: JsonToken) => (state: _StateParse) => _JsonState} */
+const parseValueOp = token => state => {
+    switch (token.kind) {
+        // A value is required here (top level, after `[`+`,`, or after `:`),
+        // so `]` is never valid — strict JSON has no trailing commas.
+        case ']':
+            return { status: 'error', message: 'unexpected token' }
+        case '[': return startArray(state)
+        case '{': return startObject(state)
+        default:
+            if (isValueToken(token)) { return pushValue(state)(tokenToValue(token)) }
+            return { status: 'error', message: 'unexpected token' }
+    }
+}
+
+/** @type {(token: JsonToken) => (state: _StateParse) => _JsonState} */
+const parseArrayStartOp = token => state => {
+    if (isValueToken(token)) { return pushValue(state)(tokenToValue(token)) }
+    if (token.kind === '[') { return startArray(state) }
+    if (token.kind === ']') { return endArray(state) }
+    if (token.kind === '{') { return startObject(state) }
+    return { status: 'error', message: 'unexpected token' }
+}
+
+/** @type {(token: JsonToken) => (state: _StateParse) => _JsonState} */
+const parseArrayValueOp = token => state => {
+    if (token.kind === ']') { return endArray(state) }
+    if (token.kind === ',') { return { status: '[,', top: state.top, stack: state.stack } }
+    return { status: 'error', message: 'unexpected token' }
+}
+
+/** @type {(token: JsonToken) => (state: _StateParse) => _JsonState} */
+const parseObjectStartOp = token => state => {
+    if (token.kind === 'string') { return pushKey(state)(token.value) }
+    if (token.kind === '}') { return endObject(state) }
+    return { status: 'error', message: 'unexpected token' }
+}
+
+/** @type {(token: JsonToken) => (state: _StateParse) => _JsonState} */
+const parseObjectKeyOp = token => state => {
+    if (token.kind === ':') { return { status: '{:', top: state.top, stack: state.stack } }
+    return { status: 'error', message: 'unexpected token' }
+}
+
+/** @type {(token: JsonToken) => (state: _StateParse) => _JsonState} */
+const parseObjectNextOp = token => state => {
+    if (token.kind === '}') { return endObject(state) }
+    if (token.kind === ',') { return { status: '{,', top: state.top, stack: state.stack } }
+    return { status: 'error', message: 'unexpected token' }
+}
+
+/** @type {(token: JsonToken) => (state: _StateParse) => _JsonState} */
+const parseObjectCommaOp = token => state => {
+    // After a `,` a member (string key) is required — `}` here would be a
+    // trailing comma, which strict JSON rejects.
+    if (token.kind === 'string') { return pushKey(state)(token.value) }
+    return { status: 'error', message: 'unexpected token' }
+}
+
+/** @type {Fold<JsonToken, _JsonState>} */
+const foldOp = token => state => {
+    if (token.kind === 'eof')
+        return state
+
+    switch (state.status) {
+        case 'result': return { status: 'error', message: 'unexpected token' }
+        case 'error': return { status: 'error', message: state.message }
+        case '': return parseValueOp(token)(state)
+        case '[': return parseArrayStartOp(token)(state)
+        case '[v': return parseArrayValueOp(token)(state)
+        case '[,': return parseValueOp(token)(state)
+        case '{': return parseObjectStartOp(token)(state)
+        case '{k': return parseObjectKeyOp(token)(state)
+        case '{:': return parseValueOp(token)(state)
+        case '{v': return parseObjectNextOp(token)(state)
+        case '{,': return parseObjectCommaOp(token)(state)
+    }
+}
+
+/**
+ * Parses a list of JSON tokens into a JSON-compatible value.
+ *
+ * Returns `ok` with the parsed value on success, or `error` with a message
+ * when the token sequence is invalid or incomplete.
+ *
+ * @type {(tokenList: List<JsonToken>) => Result<Unknown, string>}
+ */
+export const parse = tokenList => {
+    const state = fold(foldOp)({ status: '', top: null, stack: null })(tokenList)
+    switch (state.status) {
+        case 'result': return ok(state.value)
+        case 'error': return error(state.message)
+        default: return error('unexpected end')
+    }
+}
+
+export const proof = {
+    pushKey: {
+        // `pushKey` is only ever invoked while `state.top` is an object (the
+        // state machine's `'{'`/`'{,'` statuses guarantee it), so its
+        // non-object guard is a defensive branch unreachable through `parse`.
+        // Call it directly to cover that branch.
+        nonObjectTop: () => {
+            /** @type {_StateParse} */
+            const state = { status: '[', top: { kind: 'array', values: null }, stack: null }
+            const result = pushKey(state)('key')
+            assertEq(result.status, 'error')
+        },
+    },
+}

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

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

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

@@ -0,0 +1,314 @@
+/**
+ * @import { JsonToken } from '../tokenizer/types.ts'
+ */
+
+import { parse } 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 { assertEq } from '../../../asserts/module.f.mjs'
+
+/** @type {(s: string) => readonly JsonToken[]} */
+const tokenizeString = s => toArray(tokenize(stringToList(s)))
+
+const stringify = jsonStringify(sort)
+
+export const proof = {
+    valid: [
+        () => {
+            const tokenList = tokenizeString('null')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["ok",null]')
+        },
+        () => {
+            const tokenList = tokenizeString('true')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["ok",true]')
+        },
+        () => {
+            const tokenList = tokenizeString('false')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["ok",false]')
+        },
+        () => {
+            const tokenList = tokenizeString('0.1')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["ok",0.1]')
+        },
+        () => {
+            const tokenList = tokenizeString('1.1e+2')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["ok",110]')
+        },
+        () => {
+            const tokenList = tokenizeString('"abc"')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["ok","abc"]')
+        },
+        () => {
+            const tokenList = tokenizeString('[]')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["ok",[]]')
+        },
+        () => {
+            const tokenList = tokenizeString('[1]')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["ok",[1]]')
+        },
+        () => {
+            const tokenList = tokenizeString('[[]]')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["ok",[[]]]')
+        },
+        () => {
+            const tokenList = tokenizeString('[0,[1,[2,[]]],3]')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["ok",[0,[1,[2,[]]],3]]')
+        },
+        () => {
+            const tokenList = tokenizeString('{}')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["ok",{}]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('[{}]')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["ok",[{}]]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('{"a":true,"b":false,"c":null}')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["ok",{"a":true,"b":false,"c":null}]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('{"a":{"b":{"c":["d"]}}}')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["ok",{"a":{"b":{"c":["d"]}}}]') { throw result }
+        }
+    ],
+    invalid: [
+        () => {
+            const tokenList = tokenizeString('')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["error","unexpected end"]')
+        },
+        // Trailing commas are not valid JSON — strict parser rejects them.
+        () => {
+            const tokenList = tokenizeString('[1,]')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["error","unexpected token"]')
+        },
+        () => {
+            const tokenList = tokenizeString('{"a":1,}')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["error","unexpected token"]')
+        },
+        () => {
+            const tokenList = tokenizeString('"123')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["error","unexpected token"]')
+        },
+        // A literal control character inside a string is not valid JSON (RFC
+        // 8259 §7) even though the shared tokenizer would otherwise accept it.
+        () => {
+            const tokenList = tokenizeString('"\t"')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["error","unexpected token"]')
+        },
+        () => {
+            const tokenList = tokenizeString('{"a":"\t"}')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["error","unexpected token"]')
+        },
+        () => {
+            const tokenList = tokenizeString('[,]')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["error","unexpected token"]')
+        },
+        () => {
+            const tokenList = tokenizeString('[1 2]')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["error","unexpected token"]')
+        },
+        () => {
+            const tokenList = tokenizeString('[1,,2]')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["error","unexpected token"]')
+        },
+        () => {
+            const tokenList = tokenizeString('[]]')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["error","unexpected token"]')
+        },
+        () => {
+            const tokenList = tokenizeString('["a"')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["error","unexpected end"]')
+        },
+        () => {
+            const tokenList = tokenizeString('[,1]')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["error","unexpected token"]')
+        },
+        () => {
+            const tokenList = tokenizeString('[:]')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["error","unexpected token"]')
+        },
+        () => {
+            const tokenList = tokenizeString(']')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["error","unexpected token"]')
+        },
+        () => {
+            const tokenList = tokenizeString('{,}')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["error","unexpected token"]')
+        },
+        () => {
+            const tokenList = tokenizeString('{1:2}')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["error","unexpected token"]')
+        },
+        () => {
+            const tokenList = tokenizeString('{"1"2}')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["error","unexpected token"]')
+        },
+        () => {
+            const tokenList = tokenizeString('{"1"::2}')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["error","unexpected token"]')
+        },
+        () => {
+            const tokenList = tokenizeString('{"1":2,,"3":4')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["error","unexpected token"]')
+        },
+        () => {
+            const tokenList = tokenizeString('{}}')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["error","unexpected token"]')
+        },
+        () => {
+            const tokenList = tokenizeString('{"1":2')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["error","unexpected end"]')
+        },
+        () => {
+            const tokenList = tokenizeString('{,"1":2}')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["error","unexpected token"]')
+        },
+        () => {
+            const tokenList = tokenizeString('}')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["error","unexpected token"]')
+        },
+        () => {
+            const tokenList = tokenizeString('{"a":1 "b":2}')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["error","unexpected token"]')
+        },
+        () => {
+            const tokenList = tokenizeString('[{]}')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["error","unexpected token"]')
+        },
+        () => {
+            const tokenList = tokenizeString('{[}]')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["error","unexpected token"]')
+        },
+        () => {
+            const tokenList = tokenizeString('10-5')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["error","unexpected token"]')
+        },
+        () => {
+            const tokenList = tokenizeString('undefined')
+            const obj = parse(tokenList)
+            const result = stringify(obj)
+            assertEq(result, '["error","unexpected token"]')
+        },
+    ],
+    // Regression: closing a container used to pop the parser stack lazily
+    // (`drop(1)`, which is `apply(dropStep)` and returns a `Thunk`), leaving one
+    // unforced thunk per closed container. The chain was forced only at the end,
+    // costing a call-stack frame per container and overflowing at roughly 5000 of
+    // them — nested or flat siblings alike — while primitives were unbounded,
+    // since they never push or pop. `popStack` in `module.f.mjs` forces the pop
+    // instead, which is why these sizes are safe now.
+    siblingContainers: [
+        () => {
+            const [tag, value] = parse(tokenizeString(`[${Array(6000).fill('{}').join(',')}]`))
+            assertEq(tag, 'ok')
+            assertEq(Array.isArray(value) ? value.length : -1, 6000)
+        },
+        () => {
+            const [tag, value] = parse(tokenizeString(`[${Array(6000).fill('[]').join(',')}]`))
+            assertEq(tag, 'ok')
+            assertEq(Array.isArray(value) ? value.length : -1, 6000)
+        },
+        () => {
+            const keys = Array.from({ length: 6000 }, (_, i) => `"k${i}":{}`)
+            const [tag, value] = parse(tokenizeString(`{${keys.join(',')}}`))
+            assertEq(tag, 'ok')
+            assertEq(typeof value === 'object' && value !== null ? Object.keys(value).length : -1, 6000)
+        },
+        () => {
+            // deep nesting shares the same stack path and overflowed at 5000
+            const [tag] = parse(tokenizeString('['.repeat(5000) + ']'.repeat(5000)))
+            assertEq(tag, 'ok')
+        },
+        () => {
+            // baseline that always worked: primitives never touch the stack
+            const [tag, value] = parse(tokenizeString(`[${Array.from({ length: 12000 }, (_, i) => i).join(',')}]`))
+            assertEq(tag, 'ok')
+            assertEq(Array.isArray(value) ? value.length : -1, 12000)
+        },
+    ],
+}

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

@@ -0,0 +1,39 @@
+/**
+ * Internal state types for the JSON parser.
+ *
+ * @module
+ */
+import type { Unknown } from '../types.ts';
+import type { OrderedMap } from '../../../types/ordered_map/types.ts';
+import type { List } from '../../../types/list/types.ts';
+import type { JsonToken } from '../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 = {
+    readonly kind: 'object';
+    readonly values: OrderedMap<Unknown>;
+    readonly key: string;
+};
+export type _JsonArray = {
+    readonly kind: 'array';
+    readonly values: List<Unknown>;
+};
+type _JsonStackElement = _JsonObject | _JsonArray;
+export type _JsonStack = List<_JsonStackElement>;
+export type _StateParse = {
+    readonly status: '' | '[' | '[v' | '[,' | '{' | '{k' | '{:' | '{v' | '{,';
+    readonly top: _JsonStackElement | null;
+    readonly stack: _JsonStack;
+};
+type _StateResult = {
+    readonly status: 'result';
+    readonly value: Unknown;
+};
+type _StateError = {
+    readonly status: 'error';
+    readonly message: string;
+};
+export type _JsonState = _StateParse | _StateResult | _StateError;
+export {};

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

@@ -0,0 +1,79 @@
+import { parse, setProperty, stringify } from './module.f.mjs'
+import { sort } from '../../types/object/module.f.mjs'
+import { identity } from '../../types/function/module.f.mjs'
+import { assertEq } from '../../asserts/module.f.mjs'
+
+export const proof = {
+    setProperty: [
+        () => {
+            if (setProperty("Hello")([])({}) !== "Hello") { throw 'error' }
+        },
+        () => {
+            // src === null: should treat as empty object
+            const x = stringify(sort)(setProperty("Hello")(['a'])(null))
+            if (x !== '{"a":"Hello"}') { throw x }
+        },
+        () => {
+            // typeof src !== 'object': primitive src treated as empty object
+            const x = stringify(sort)(setProperty("Hello")(['a'])(/** @type {null} */ (/** @type {unknown} */ (42))))
+            if (x !== '{"a":"Hello"}') { throw x }
+        },
+        () => {
+            // src instanceof Array: array src treated as empty object
+            const x = stringify(sort)(setProperty("Hello")(['a'])(/** @type {null} */ (/** @type {unknown} */ ([1, 2]))))
+            if (x !== '{"a":"Hello"}') { throw x }
+        },
+    ],
+    stringify: [
+        {
+            sort: () => {
+                const r = setProperty("Hello")(['a'])({})
+                const x = stringify(sort)(r)
+                if (x !== '{"a":"Hello"}') { throw x }
+            },
+            identity: () => {
+                const x = stringify(identity)(setProperty("Hello")(['a'])({}))
+                if (x !== '{"a":"Hello"}') { throw x }
+            },
+        },
+        {
+            sort: () => {
+                const x = stringify(sort)(setProperty("Hello")(['a'])({ c: [], b: 12 }))
+                if (x !== '{"a":"Hello","b":12,"c":[]}') { throw x }
+            },
+            identity: () => {
+                const x = stringify(identity)(setProperty("Hello")(['a'])({ c: [], b: 12 }))
+                if (x !== '{"c":[],"b":12,"a":"Hello"}') { throw x }
+            },
+        },
+        {
+            sort: () => {
+                const _0 = { a: { y: [24] }, c: [], b: 12 }
+                const _1 = setProperty("Hello")(['a', 'x'])(_0)
+                const _2 = stringify(sort)(_1)
+                if (_2 !== '{"a":{"x":"Hello","y":[24]},"b":12,"c":[]}') { throw _2 }
+            },
+            identity: () => {
+                const _0 = { a: { y: [24] }, c: [], b: 12 }
+                const _1 = setProperty("Hello")(['a', 'x'])(_0)
+                const _2 = stringify(identity)(_1)
+                if (_2 !== '{"a":{"y":[24],"x":"Hello"},"c":[],"b":12}') { throw _2 }
+            }
+        }
+    ],
+    undefined: () => {
+        assertEq(stringify(sort)({ x: undefined }), '{}')
+    },
+    parse: {
+        ok: () => {
+            const [t, v] = parse('{"a":[1,true,null],"b":"x"}')
+            assertEq(t, 'ok')
+            assertEq(stringify(sort)(v), '{"a":[1,true,null],"b":"x"}')
+        },
+        // Malformed input is an error value, not a throw.
+        error: () => {
+            const [t] = parse('{')
+            assertEq(t, 'error')
+        },
+    },
+}