functionalscript 0.18.0 → 0.20.0

package/fs/dev/tf/{test.f.js → proof.f.js}

@@ -1,8 +1,9 @@
 import { pure } from "../../types/effects/module.f.js";
 import { emptyState } from "../../types/effects/node/virtual/module.f.js";
 import { virtual } from "../../types/effects/node/virtual/module.f.js";
-import { assert, assertEq } from "../module.f.js";
-import { test, defaultReporter, fmtPath, fmtTerm, fmtImport, ghEscape, isInteger, isIdentifier, defaultTest, } from "./module.f.js";
+import { assert, assertEq, todo } from "../module.f.js";
+import { testAll, defaultReporter, fmtPath, fmtTerm, fmtImport, ghEscape, isInteger, isIdentifier, defaultTest, } from "./module.f.js";
+import { shouldLoad } from "../module.f.js";
 const makeReporter = () => {
     const events = [];
     const reporter = {
@@ -12,10 +13,15 @@ const makeReporter = () => {
     };
     return [reporter, () => events];
 };
+const noopTestContext = { test: todo };
 const options = (initCwd, github = false) => ({
     args: [],
     env: { INIT_CWD: initCwd, ...(github ? { GITHUB_ACTION: 'true' } : {}) },
     std: { stdout: { isTTY: false }, stderr: { isTTY: false } },
+    testContext: noopTestContext,
+    bunTestContext: noopTestContext,
+    playwrightTestContext: noopTestContext,
+    engine: 'node',
 });
 const ok0 = () => ({ result: ['ok', undefined], duration: 0 });
 const fail0 = () => ({ result: ['error', 'oops'], duration: 0 });
@@ -23,7 +29,7 @@ const ok1 = () => ({ result: ['ok', undefined], duration: 1 });
 const run = (dir, initCwd = '.') => {
     const [reporter, getEvents] = makeReporter();
     const state = { ...emptyState, root: dir };
-    const [, exitCode] = virtual(state)(test(reporter)(options(initCwd)));
+    const [, exitCode] = virtual(state)(testAll(reporter)(options(initCwd)));
     return [getEvents(), exitCode];
 };
 // Runs the real `defaultReporter` and returns its captured stdout/stderr so the
@@ -31,13 +37,13 @@ const run = (dir, initCwd = '.') => {
 const runMain = (dir, github = false) => {
     const state = { ...emptyState, root: dir };
     const opts = options('.', github);
-    const [finalState, exitCode] = virtual(state)(test(defaultReporter(opts))(opts));
+    const [finalState, exitCode] = virtual(state)(testAll(defaultReporter(opts))(opts));
     return [finalState.stdout, finalState.stderr, exitCode];
 };
 // flat object: two passing tests
 export const flat = () => {
     const [events, exit] = run({
-        'a.test.f.ts': () => ({ a: ok0, b: ok1 }),
+        'a.proof.f.ts': () => ({ proof: { a: ok0, b: ok1 } }),
     });
     assertEq(exit, 0);
     const [e0, e1, e2] = events;
@@ -51,7 +57,7 @@ export const flat = () => {
 // nested object: leaf tests carry the full path including the sub-tree key
 export const nested = () => {
     const [events, exit] = run({
-        'n.test.f.ts': () => ({ math: { add: ok0, sub: ok0 } }),
+        'n.proof.f.ts': () => ({ proof: { math: { add: ok0, sub: ok0 } } }),
     });
     assertEq(exit, 0);
     const [e0, e1, e2] = events;
@@ -65,7 +71,7 @@ export const nested = () => {
 // throw key: tests inside 'throw' pass on error result
 export const throwKey = () => {
     const [events, exit] = run({
-        't.test.f.ts': () => ({ throw: { a: fail0 } }),
+        't.proof.f.ts': () => ({ proof: { throw: { a: fail0 } } }),
     });
     assertEq(exit, 0);
     const [e0, e1] = events;
@@ -78,7 +84,7 @@ export const throwKey = () => {
 // throw key fails when test does not throw (returns ok in throw context)
 export const throwKeyFail = () => {
     const [events, exit] = run({
-        't.test.f.ts': () => ({ throw: { a: ok0 } }),
+        't.proof.f.ts': () => ({ proof: { throw: { a: ok0 } } }),
     });
     assertEq(exit, 1);
     const [e0, e1] = events;
@@ -90,7 +96,7 @@ export const throwKeyFail = () => {
 // mixed pass/fail updates summary counts
 export const mixedPassFail = () => {
     const [events, exit] = run({
-        'm.test.f.ts': () => ({ good: ok0, bad: fail0 }),
+        'm.proof.f.ts': () => ({ proof: { good: ok0, bad: fail0 } }),
     });
     assertEq(exit, 1);
     const summary = events[events.length - 1];
@@ -103,11 +109,13 @@ export const mixedPassFail = () => {
 export const returnValueSubTree = () => {
     const inner = () => ({ result: ['ok', undefined], duration: 0 });
     const [events, exit] = run({
-        'r.test.f.ts': () => ({
-            outer: () => ({
-                result: ['ok', { inner }],
-                duration: 0,
-            }),
+        'r.proof.f.ts': () => ({
+            proof: {
+                outer: () => ({
+                    result: ['ok', { inner }],
+                    duration: 0,
+                }),
+            }
         }),
     });
     // outer passes, then inner (from return value) also passes
@@ -121,7 +129,7 @@ export const returnValueSubTree = () => {
 // integer-indexed array keys appear as numeric path segments
 export const arrayKeys = () => {
     const [events, exit] = run({
-        'a.test.f.ts': () => ({ arr: [ok0, ok0] }),
+        'a.proof.f.ts': () => ({ proof: { arr: [ok0, ok0] } }),
     });
     assertEq(exit, 0);
     const passEvents = events.filter(e => e[0] === 'result');
@@ -129,22 +137,24 @@ export const arrayKeys = () => {
     assertEq(passEvents[0][2][1], '0');
     assertEq(passEvents[1][2][1], '1');
 };
-// non-test files are skipped (only files ending in test.f.ts/js are loaded)
+// non-proof files are skipped: plain `.ts` is not loaded; `.f.ts` without
+// a `proof` export is loaded but produces no events
 export const nonTestFilesSkipped = () => {
     const [events, exit] = run({
-        'helper.ts': () => ({ a: ok0 }),
-        'b.test.f.ts': () => ({ x: ok0 }),
+        'helper.ts': () => ({ a: ok0 }), // not loaded (plain .ts)
+        'module.f.ts': () => ({ someExport: ok0 }), // loaded, no proof → skipped
+        'b.proof.f.ts': () => ({ proof: { x: ok0 } }), // loaded, has proof → runs
     });
     assertEq(exit, 0);
     const results = events.filter(e => e[0] === 'result');
     assertEq(results.length, 1);
-    assertEq(results[0][1], './b.test.f.ts');
+    assertEq(results[0][1], './b.proof.f.ts');
 };
 // multiple test files each produce result events
 export const multipleFiles = () => {
     const [events, exit] = run({
-        'a.test.f.ts': () => ({ x: ok0 }),
-        'b.test.f.ts': () => ({ y: ok0 }),
+        'a.proof.f.ts': () => ({ proof: { x: ok0 } }),
+        'b.proof.f.ts': () => ({ proof: { y: ok0 } }),
     });
     assertEq(exit, 0);
     const results = events.filter(e => e[0] === 'result');
@@ -159,51 +169,51 @@ export const throwByFunctionName = () => {
     // const named = ({ throw: () => fail0() }).throw
     const x = { throw: () => fail0() };
     const [events, exit] = run({
-        't.test.f.ts': () => ({ here: x.throw }),
+        't.proof.f.ts': () => ({ proof: { here: x.throw } }),
     });
     assertEq(exit, 0);
     const passEvents = events.filter(e => e[0] === 'result');
     assertEq(passEvents.length, 1);
     assertEq(passEvents[0][2][0], 'here');
 };
-// every module export — `default` and named — becomes a top-level path segment
+// only the `proof` export is used; other module properties are ignored
 export const namedExports = () => {
     const [events, exit] = run({
-        'e.test.f.ts': () => ({ default: ok0, helper: ok0 }),
+        'e.proof.f.ts': () => ({ proof: { a: ok0, b: ok0 }, other: ok0 }),
     });
     assertEq(exit, 0);
     const passEvents = events.filter(e => e[0] === 'result');
-    assertEq(passEvents.length, 2);
-    assertEq(passEvents[0][2][0], 'default');
-    assertEq(passEvents[1][2][0], 'helper');
+    assertEq(passEvents.length, 2); // `other` is ignored
+    assertEq(passEvents[0][2][0], 'a');
+    assertEq(passEvents[1][2][0], 'b');
 };
 // the default (non-GitHub) reporter formats module/pass/summary lines on stdout
 export const defaultReporterOutput = () => {
     const [stdout, stderr, exit] = runMain({
-        'a.test.f.ts': () => ({ x: ok0 }),
+        'a.proof.f.ts': () => ({ proof: { x: ok0 } }),
     });
     assertEq(exit, 0);
     assertEq(stderr, '');
-    assertEq(stdout, 'import("./a.test.f.ts").x(): ok, 0.0000 ms\n'
+    assertEq(stdout, 'import("./a.proof.f.ts").proof.x(): ok, 0.0000 ms\n'
         + 'Number of tests: pass: 1, fail: 0, total: 1\n'
         + 'Time: 0.0000 ms\n');
 };
 // a failure on the non-GitHub reporter writes the error to stderr, not stdout
 export const defaultReporterFailOutput = () => {
     const [, stderr, exit] = runMain({
-        'a.test.f.ts': () => ({ bad: fail0 }),
+        'a.proof.f.ts': () => ({ proof: { bad: fail0 } }),
     });
     assertEq(exit, 1);
-    assertEq(stderr, 'import("./a.test.f.ts").bad(): error, 0.0000 ms\noops\n');
+    assertEq(stderr, 'import("./a.proof.f.ts").proof.bad(): error, 0.0000 ms\noops\n');
 };
 // the GitHub reporter emits an `::error` annotation with a percent-encoded
 // title (the JSON path) and message
 export const githubReporterOutput = () => {
     const [, stderr, exit] = runMain({
-        's.test.f.ts': () => ({ 'a:b,c%d': fail0 }),
+        's.proof.f.ts': () => ({ proof: { 'a:b,c%d': fail0 } }),
     }, true);
     assertEq(exit, 1);
-    assertEq(stderr, '::error file=./s.test.f.ts,line=1,title=import("./s.test.f.ts")["a%3Ab%2Cc%25d"]()::oops\n');
+    assertEq(stderr, '::error file=./s.proof.f.ts,line=1,title=import("./s.proof.f.ts").proof["a%3Ab%2Cc%25d"]()::oops\n');
 };
 // direct unit tests for the pure path-format helpers
 export const helpers = {
@@ -224,12 +234,32 @@ export const helpers = {
         assert(!isIdentifier('1a'));
         assert(!isIdentifier('a-b'));
     },
+    shouldLoad: () => {
+        // all .f.ts / .f.js — FS modules are safe to bulk-load
+        assert(shouldLoad('module.f.ts'));
+        assert(shouldLoad('module.f.js'));
+        assert(shouldLoad('a.proof.f.ts'));
+        assert(shouldLoad('dir/module.f.ts'));
+        // vanilla opt-in by filename
+        assert(shouldLoad('proof.ts'));
+        assert(shouldLoad('proof.js'));
+        assert(shouldLoad('proof.mts'));
+        assert(shouldLoad('proof.mjs'));
+        assert(shouldLoad('math.proof.ts'));
+        assert(shouldLoad('math.proof.js'));
+        assert(shouldLoad('math.proof.mts'));
+        assert(shouldLoad('dir/math.proof.ts'));
+        // non-FS, non-proof vanilla files are not loaded
+        assert(!shouldLoad('helper.ts'));
+        assert(!shouldLoad('module.ts'));
+        assert(!shouldLoad('proof.tsx'));
+    },
     fmtImport: () => {
-        assertEq(fmtImport('./a.test.f.ts', []), 'import("./a.test.f.ts")()');
-        assertEq(fmtImport('./a.test.f.ts', ['math', 'add']), 'import("./a.test.f.ts").math.add()');
-        assertEq(fmtImport('./a.test.f.ts', ['users', '3']), 'import("./a.test.f.ts").users[3]()');
-        assertEq(fmtImport('./a.test.f.ts', ['x', 'hello world']), 'import("./a.test.f.ts").x["hello world"]()');
-        assertEq(fmtImport('./a.test.f.ts', ['outer', null, 'inner']), 'import("./a.test.f.ts").outer().inner()');
+        assertEq(fmtImport('./a.proof.f.ts', []), 'import("./a.proof.f.ts").proof()');
+        assertEq(fmtImport('./a.proof.f.ts', ['math', 'add']), 'import("./a.proof.f.ts").proof.math.add()');
+        assertEq(fmtImport('./a.proof.f.ts', ['users', '3']), 'import("./a.proof.f.ts").proof.users[3]()');
+        assertEq(fmtImport('./a.proof.f.ts', ['x', 'hello world']), 'import("./a.proof.f.ts").proof.x["hello world"]()');
+        assertEq(fmtImport('./a.proof.f.ts', ['outer', null, 'inner']), 'import("./a.proof.f.ts").proof.outer().inner()');
     },
     fmtPath: () => {
         assertEq(fmtPath([]), '');
@@ -252,3 +282,20 @@ export const helpers = {
         assertEq(ghEscape('a%b:c,d'), 'a%25b%3Ac%2Cd');
     },
 };
+export const proof = {
+    flat,
+    nested,
+    throwKey,
+    throwKeyFail,
+    mixedPassFail,
+    returnValueSubTree,
+    arrayKeys,
+    nonTestFilesSkipped,
+    multipleFiles,
+    throwByFunctionName,
+    namedExports,
+    defaultReporterOutput,
+    defaultReporterFailOutput,
+    githubReporterOutput,
+    helpers
+};

package/fs/dev/tf/scenarios/all.d.ts

@@ -0,0 +1 @@
+export {};

package/fs/dev/tf/scenarios/all.js

@@ -0,0 +1,3 @@
+import { run } from "../module.js";
+// we need `await` for Playwright.
+await run();

package/fs/dev/tf/scenarios/async-subtests.fail.d.ts

@@ -0,0 +1,4 @@
+export declare const withSubtests: () => Promise<{
+    sub1: () => void;
+    sub2: () => never;
+}>;

package/fs/dev/tf/scenarios/async-subtests.fail.js

@@ -0,0 +1,7 @@
+export const withSubtests = async () => {
+    await new Promise(resolve => setTimeout(resolve, 10));
+    return {
+        sub1: () => { },
+        sub2: () => { throw 'sub-test failure'; },
+    };
+};

package/fs/dev/tf/scenarios/async-subtests.pass.d.ts

@@ -0,0 +1,4 @@
+export declare const withSubtests: () => Promise<{
+    sub1: () => void;
+    sub2: () => void;
+}>;

package/fs/dev/tf/scenarios/async-subtests.pass.js

@@ -0,0 +1,7 @@
+export const withSubtests = async () => {
+    await new Promise(resolve => setTimeout(resolve, 10));
+    return {
+        sub1: () => { },
+        sub2: () => { },
+    };
+};

package/fs/dev/tf/scenarios/async.fail.d.ts

@@ -0,0 +1 @@
+export declare const sleep_fail: () => Promise<never>;

package/fs/dev/tf/scenarios/async.fail.js

@@ -0,0 +1,4 @@
+export const sleep_fail = async () => {
+    await new Promise(resolve => setTimeout(resolve, 10));
+    throw 'async failure';
+};

package/fs/dev/tf/scenarios/async.pass.d.ts

@@ -0,0 +1 @@
+export declare const sleep: () => Promise<void>;

package/fs/dev/tf/scenarios/async.pass.js

@@ -0,0 +1,3 @@
+export const sleep = async () => {
+    await new Promise(resolve => setTimeout(resolve, 10));
+};

package/fs/dev/tf/scenarios/fail.fail.f.d.ts

@@ -0,0 +1 @@
+export declare const failing: () => never;

package/fs/dev/tf/scenarios/fail.fail.f.js

@@ -0,0 +1 @@
+export const failing = () => { throw 'intentional failure'; };

package/fs/dev/tf/scenarios/return-value.pass.f.d.ts

@@ -0,0 +1 @@
+export declare const outer: () => unknown;

package/fs/dev/tf/scenarios/return-value.pass.f.js

@@ -0,0 +1,2 @@
+const inner = () => { };
+export const outer = () => ({ inner });

package/fs/dev/tf/scenarios/thenable.pass.d.ts

@@ -0,0 +1,3 @@
+export declare const thenableResolves: () => {
+    then(resolve: (v: undefined) => void): void;
+};

package/fs/dev/tf/scenarios/thenable.pass.js

@@ -0,0 +1,9 @@
+// A test that returns a thenable (Promise-like object, not a real Promise).
+// Per FunctionalScript convention, thenables are treated as plain values —
+// not awaited. Both sandbox (fjs) and registerModule (node/bun/deno/playwright)
+// must exit 0: the thenable object is walked as a sub-tree whose only key
+// `then` is a function with parameters, so no leaf tests are found and the
+// test trivially passes.
+export const thenableResolves = () => ({
+    then(resolve) { resolve(undefined); }
+});

package/fs/dev/tf/scenarios/thenable2.pass.f.d.ts

@@ -0,0 +1,3 @@
+export declare const shouldPass: () => {
+    then: () => string;
+};

package/fs/dev/tf/scenarios/thenable2.pass.f.js

@@ -0,0 +1,3 @@
+export const shouldPass = () => ({
+    then: () => 'ok'
+});

package/fs/{bnf/test.f.d.ts → dev/tf/scenarios/throw.pass.f.d.ts}

@@ -1,4 +1,6 @@
 declare const _default: {
-    test: () => void;
+    throw: {
+        a: () => never;
+    };
 };
 export default _default;

package/fs/dev/tf/scenarios/throw.pass.f.js

@@ -0,0 +1,3 @@
+export default {
+    throw: { a: () => { throw 'expected'; } }
+};

package/fs/dev/version/proof.f.d.ts

@@ -0,0 +1,3 @@
+export declare const proof: {
+    new: () => void;
+};

package/fs/dev/version/{test.f.js → proof.f.js}

@@ -77,7 +77,7 @@ const e = '{\n' +
     '    "typescript": "^4.7.4"\n' +
     '  }\n' +
     '}';
-export default {
+export const proof = {
     new: () => {
         const w = (name) => {
             const fn = `${name}.json`;

package/fs/djs/ast/{test.f.d.ts → proof.f.d.ts}

@@ -1,8 +1,7 @@
-declare const _default: {
+export declare const proof: {
     test: () => void;
     testCref: () => void;
     testAref: () => void;
     testArray: () => void;
     testObj: () => void;
 };
-export default _default;

package/fs/djs/ast/{test.f.js → proof.f.js}

@@ -1,7 +1,7 @@
 import { sort } from "../../types/object/module.f.js";
 import { run } from "./module.f.js";
 import { stringifyAsTree } from "../serializer/module.f.js";
-export default {
+export const proof = {
     test: () => {
         const djs = run([1])([]);
         const result = stringifyAsTree(sort)(djs);

package/fs/djs/parser/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     valid: (() => void)[];
     invalid: (() => void)[];
     errorMetadata: (() => void)[];
@@ -11,4 +11,3 @@ declare const _default: {
     invalidWithArgs: (() => void)[];
     comments: (() => void)[];
 };
-export default _default;

package/fs/djs/parser/{test.f.js → proof.f.js}

@@ -7,7 +7,7 @@ import { stringifyAsTree } from "../serializer/module.f.js";
 import { stringify } from "../../json/module.f.js";
 const tokenizeString = s => toArray(tokenize(stringToList(s))(''));
 const stringifyDjsModule = stringifyAsTree(sort);
-export default {
+export const proof = {
     valid: [
         () => {
             const tokenList = tokenizeString('export default null');

package/fs/djs/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     tooFewArgs: {
         noArgs: () => void;
         oneArg: () => void;
@@ -8,4 +8,3 @@ declare const _default: {
     fileNotFound: () => void;
     parseError: () => void;
 };
-export default _default;

package/fs/djs/{test.f.js → proof.f.js}

@@ -9,7 +9,7 @@ const readOutput = (root, path) => {
     }
     return utf8ToString(file);
 };
-export default {
+export const proof = {
     tooFewArgs: {
         noArgs: () => {
             const [state, code] = virtual(emptyState)(compile([]));

package/fs/djs/serializer/module.f.d.ts

@@ -7,11 +7,11 @@ import type { Unknown } from '../module.f.ts';
 import type { Entry as ObjectEntry } from '../../types/object/module.f.ts';
 import { type List } from '../../types/list/module.f.ts';
 export declare const undefinedSerialize: string[];
-type RefCounter = [number, number, boolean];
+type RefCounter = readonly [number, number];
 type Entry = ObjectEntry<Unknown>;
 type Entries = List<Entry>;
 type MapEntries = (entries: Entries) => Entries;
-type Refs = Map<Unknown, RefCounter>;
+type Refs = ReadonlyMap<Unknown, RefCounter>;
 export declare const serializeWithoutConst: (mapEntries: MapEntries) => (value: Unknown) => List<string>;
 export declare const stringify: (sort: MapEntries) => (djs: Unknown) => string;
 export declare const stringifyAsTree: (mapEntries: MapEntries) => (value: Unknown) => string;

package/fs/djs/serializer/module.f.js

@@ -7,88 +7,47 @@ import { serialize as bigintSerialize } from "../../types/bigint/module.f.js";
 import { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } from "../../json/serializer/module.f.js";
 const colon = [':'];
 export const undefinedSerialize = ['undefined'];
-const getConstantsOp = djs => state => {
-    switch (typeof djs) {
-        case 'boolean': {
-            return state;
-        }
-        case 'number':
-        case 'string':
-        case 'bigint': {
-            return getConstantSelf(djs)(state);
-        }
-        default: {
-            if (djs === null) {
-                return state;
-            }
-            if (djs === undefined) {
-                return state;
-            }
-            if (djs instanceof Array) {
-                return getConstantSelf(djs)(fold(getConstantsOp)(state)(djs));
-            }
-            return getConstantSelf(djs)(fold(getConstantsOp)(state)(map(entryValue)(entries(djs))));
+const getConstants = refs => {
+    const checkSelf = djs => state => {
+        const refCounter = refs.get(djs);
+        if (refCounter !== undefined && refCounter[1] > 1 && !state.added.has(djs)) {
+            return {
+                added: new Set([...state.added, djs]),
+                consts: { head: state.consts, tail: [djs] }
+            };
         }
-    }
-};
-const getConstantSelf = djs => state => {
-    const refs = state.refs;
-    const refCounter = refs.get(djs);
-    if (refCounter !== undefined && refCounter[1] > 1 && !refCounter[2]) {
-        refCounter[2] = true;
-        refs.set(djs, refCounter);
-        return { refs, consts: { head: state.consts, tail: [djs] } };
-    }
-    return state;
-};
-const getConstants = djs => refs => {
-    return getConstantsOp(djs)(refs);
-};
-const entryValue = kv => kv[1];
-export const serializeWithoutConst = sort => {
-    const propertySerialize = ([k, v]) => flat([
-        stringSerialize(k),
-        colon,
-        f(v)
-    ]);
-    const mapPropertySerialize = map(propertySerialize);
-    const objectSerialize = fn(entries)
-        .map(sort)
-        .map(mapPropertySerialize)
-        .map(objectWrap)
-        .result;
-    const f = value => {
-        switch (typeof value) {
+        return state;
+    };
+    const op = djs => state => {
+        switch (typeof djs) {
             case 'boolean': {
-                return boolSerialize(value);
-            }
-            case 'number': {
-                return numberSerialize(value);
-            }
-            case 'string': {
-                return stringSerialize(value);
+                return state;
             }
+            case 'number':
+            case 'string':
             case 'bigint': {
-                return [bigintSerialize(value)];
+                return checkSelf(djs)(state);
             }
             default: {
-                if (value === null) {
-                    return nullSerialize;
+                if (djs === null) {
+                    return state;
                 }
-                if (value === undefined) {
-                    return undefinedSerialize;
+                if (djs === undefined) {
+                    return state;
                 }
-                if (value instanceof Array) {
-                    return arraySerialize(value);
+                if (djs instanceof Array) {
+                    return checkSelf(djs)(fold(op)(state)(djs));
                 }
-                return objectSerialize(value);
+                return checkSelf(djs)(fold(op)(state)(map(entryValue)(entries(djs))));
             }
         }
     };
-    const arraySerialize = compose(map(f))(arrayWrap);
-    return f;
+    const init = { added: new Set(), consts: [] };
+    return djs => op(djs)(init).consts;
 };
-const serializeWithConst = sort => refs => root => {
+const entryValue = kv => kv[1];
+const noRef = () => null;
+const buildSerialize = refLookup => sort => {
     const propertySerialize = ([k, v]) => flat([
         stringSerialize(k),
         colon,
@@ -101,11 +60,9 @@ const serializeWithConst = sort => refs => root => {
         .map(objectWrap)
         .result;
     const f = value => {
-        if (value !== root) {
-            const refCounter = refs.get(value);
-            if (refCounter !== undefined && refCounter[1] > 1) {
-                return [`c${refCounter[0]}`];
-            }
+        const ref = refLookup(value);
+        if (ref !== null) {
+            return ref;
         }
         switch (typeof value) {
             case 'boolean': {
@@ -137,6 +94,17 @@ const serializeWithConst = sort => refs => root => {
     const arraySerialize = compose(map(f))(arrayWrap);
     return f;
 };
+export const serializeWithoutConst = buildSerialize(noRef);
+const serializeWithConst = sort => refs => root => buildSerialize(value => {
+    if (value === root) {
+        return null;
+    }
+    const refCounter = refs.get(value);
+    if (refCounter !== undefined && refCounter[1] > 1) {
+        return [`c${refCounter[0]}`];
+    }
+    return null;
+})(sort);
 const countRefsOp = djs => refs => {
     switch (typeof djs) {
         case 'boolean':
@@ -167,14 +135,14 @@ const countRefsOp = djs => refs => {
 };
 const addRef = djs => refs => {
     const refCounter = refs.get(djs);
-    if (refCounter === undefined) {
-        return refs.set(djs, [refs.size, 1, false]);
-    }
-    return refs.set(djs, [refCounter[0], refCounter[1] + 1, false]);
+    const newCounter = refCounter === undefined
+        ? [refs.size, 1]
+        : [refCounter[0], refCounter[1] + 1];
+    return new Map([...refs, [djs, newCounter]]);
 };
 export const stringify = sort => djs => {
     const refs = countRefs(djs);
-    const consts = getConstants(djs)({ refs, consts: [] }).consts;
+    const consts = getConstants(refs)(djs);
     const constSerialize = entry => {
         const refCounter = refs.get(entry);
         if (refCounter === undefined) {