functionalscript 0.42.0 → 0.43.1

package/fjs/bnf/data/module.f.d.ts

@@ -11,7 +11,7 @@ export type TerminalRange = number;
  */
 export type Sequence = readonly string[];
 /** A variant of rule names. */
-export type Variant = StringMap<string, string>;
+export type Variant = StringMap<string>;
 /**
  * Grammar rule definition.
  *
@@ -29,7 +29,7 @@ export type RuleSet = Readonly<Record<string, Rule>>;
  * variant branch.
  */
 export type EmptyTag = string | true | undefined;
-type EmptyTagMap = StringMap<string, EmptyTag>;
+type EmptyTagMap = StringMap<EmptyTag>;
 /**
  * Computes, for every rule in the set, whether it can match empty input, by
  * the standard nullable-set fixpoint: a sequence is nullable iff all of its

package/fjs/bnf/ll1/module.f.d.ts

@@ -26,7 +26,7 @@ type DispatchRuleCollection = {
     readonly tag: string | undefined;
     readonly rules: DispatchRuleOrName[];
 };
-type DispatchMap = StringMap<string, DispatchRule>;
+type DispatchMap = StringMap<DispatchRule>;
 /**
  * Represents a parsed AST sequence.
  */

package/fjs/bnf/module.f.d.ts

@@ -89,7 +89,7 @@ export declare const range: (ab: string) => TerminalRange;
 /**
  * A set of terminal ranges compatible with the `Variant` rule.
  */
-export type RangeVariant = StringMap<string, TerminalRange>;
+export type RangeVariant = StringMap<TerminalRange>;
 export declare const remove: (range: TerminalRange, v: RangeVariant) => RangeVariant;
 /**
  * Returns the complement set of the provided ranges over {@link fullRange}.

package/fjs/cas/evo/module.f.d.ts

@@ -45,7 +45,7 @@
 import { type Effect, type Operation } from '../../effects/module.f.ts';
 import { type Key, type MemOp } from '../../effects/memory/module.f.ts';
 import { type Cas } from '../module.f.ts';
-import { type Revision } from '../../media/revision/module.f.ts';
+import { type LockMap, type Revision } from '../../media/revision/module.f.ts';
 import { type Result } from '../../types/result/module.f.ts';
 import { type StringMap } from '../../types/object/module.f.ts';
 import type { Vec } from '../../types/bit_vec/module.f.ts';
@@ -98,6 +98,7 @@ export type RevisionData = {
     readonly subject?: Subject | undefined;
     readonly archived?: true | undefined;
     readonly generation?: number | undefined;
+    readonly lock?: LockMap | undefined;
 };
 /**
  * Per-subject bookkeeping: every revision hash seen for the subject, every
@@ -119,7 +120,7 @@ export type SubjectState = {
 };
 /** In-memory index: subject → its {@link SubjectState}. */
 export type Cache = {
-    readonly bySubject: StringMap<string, SubjectState>;
+    readonly bySubject: StringMap<SubjectState>;
 };
 /** A cache with no known subjects yet — the starting point for {@link buildCache}. */
 export declare const emptyCache: Cache;

package/fjs/cas/evo/module.f.js

@@ -49,9 +49,7 @@ import { collectRead } from '../module.f.js';
 import { cBase32ToVec, vecToCBase32 } from '../../basen/cbase32/module.f.js';
 import { fromVec } from '../../text/utf8/module.f.js';
 import { tryUtf8 } from '../../text/module.f.js';
-import { decodeText, dialect, checkReferences, isHash } from '../../media/revision/module.f.js';
-import { stringify } from '../../media/json/module.f.js';
-import { identity } from '../../types/function/module.f.js';
+import { decodeText, encodeText, dialect, checkReferences, isHash } from '../../media/revision/module.f.js';
 import { ok, error } from '../../types/result/module.f.js';
 import { nonEmpty, empty as elEmpty } from '../../effects/list/module.f.js';
 import { at, definedEntries } from '../../types/object/module.f.js';
@@ -59,8 +57,6 @@ import { unwrap } from '../../types/nullable/module.f.js';
 import { isNotFound } from '../../effects/node/module.f.js';
 /** A cache with no known subjects yet — the starting point for {@link buildCache}. */
 export const emptyCache = { bySubject: {} };
-/** Canonical JSON encoder for a `Revision` — key order carries no meaning for detection. */
-const toJson = stringify(identity);
 const emptySubjectState = { hashes: [], parents: [], archived: [] };
 /** Adds every item of `items` to `set` that isn't already there, preserving `set`'s existing order. */
 const union = (set) => (items) => items.reduce((acc, h) => acc.includes(h) ? acc : [...acc, h], set);
@@ -77,6 +73,8 @@ const union = (set) => (items) => items.reduce((acc, h) => acc.includes(h) ? acc
  * (`fjs/media/revision` `checkReferences`), so decoding here cannot fail.
  */
 const canonicalHash = (h) => vecToCBase32(unwrap(cBase32ToVec(h)));
+/** Canonicalizes every direct hash in a structurally validated flat lock map. */
+const canonicalLock = (lock) => Object.fromEntries(definedEntries(lock).map(([subject, hash]) => [subject, canonicalHash(hash)]));
 /** A subject's current heads: revision hashes seen that no other revision of the same subject names as a parent. */
 const headsOf = (state) => state.hashes.filter(h => !state.parents.includes(h));
 /**
@@ -325,6 +323,7 @@ export const addRevision = (cas) => (cacheKey) => (input) => eff(resolveParents(
         snapshot: snapshotResult[1],
         generation: computeGeneration(parentsResult[1]),
         archived: input.archived,
+        lock: input.lock,
     };
     const referencesResult = checkReferences(revision);
     if (referencesResult[0] === 'error') {
@@ -341,8 +340,9 @@ export const addRevision = (cas) => (cacheKey) => (input) => eff(resolveParents(
         ...revision,
         parents: revision.parents.map(canonicalHash),
         snapshot: canonicalHash(revision.snapshot),
+        lock: revision.lock === undefined ? undefined : canonicalLock(revision.lock),
     };
-    const bytes = tryUtf8(toJson(canonicalRevision));
+    const bytes = tryUtf8(encodeText(canonicalRevision));
     if (bytes === null) {
         return pure(error('revision too large to encode'));
     }
@@ -370,12 +370,13 @@ export const addRevision = (cas) => (cacheKey) => (input) => eff(resolveParents(
  * inside `canonicalHash` is safe. Field order follows the stored blob's
  * (minus `dialect`), which is what a JSON encoding of the result shows.
  */
-const toRevisionData = ({ subject, parents, snapshot, generation, archived }) => ({
+const toRevisionData = ({ subject, parents, snapshot, generation, archived, lock }) => ({
     subject,
     parents: parents.map(canonicalHash),
     snapshot: canonicalHash(snapshot),
     generation,
     archived,
+    lock: lock === undefined ? undefined : canonicalLock(lock),
 });
 /**
  * Second stage of {@link readRevision}: interprets an already-performed read

package/fjs/cas/evo/proof.f.d.ts

@@ -35,6 +35,10 @@ export declare const proof: {
     revisionNonRevisionBlobIsError: () => void;
     revisionCanonicalizesReferenceSpellings: () => void;
     revisionRoundTripsThroughAdd: () => void;
+    revisionLockRoundTripsAndCanonicalizes: () => void;
+    revisionAbsentAndEmptyLocksRemainDistinct: () => void;
+    revisionInvalidLockValueIsRejected: () => void;
+    equivalentLockOrdersReuseOneCasAddress: () => void;
     syncRevisionFoldsValidRevisionIntoCache: () => void;
     syncRevisionIgnoresNonRevisionContent: () => void;
     evoHeadUnknownSubjectIsEmpty: () => void;

package/fjs/cas/evo/proof.f.js

@@ -596,6 +596,60 @@ export const proof = {
         assert(readded[0] === 'ok', ['expected re-add ok', readded]);
         assertEq(readded[1], child[1]);
     },
+    revisionLockRoundTripsAndCanonicalizes: () => {
+        const c = fileCas(sha256)(home);
+        const [state0, cacheKey] = virtual(emptyState)(initEvo(c));
+        const e = evo(c)(cacheKey);
+        const canonical = vecToCBase32(vec8(0xffn));
+        const alias = canonical.toUpperCase();
+        const [state1, added] = virtual(state0)(e.add({
+            parents: [], subject: 'doc', snapshot: canonical,
+            lock: { dependency: alias },
+        }));
+        assert(added[0] === 'ok', ['expected add ok', added]);
+        const [, result] = virtual(state1)(e.revision(added[1]));
+        assert(result[0] === 'ok', ['expected revision ok', result]);
+        assertEq(result[1].lock?.dependency, canonical);
+    },
+    revisionAbsentAndEmptyLocksRemainDistinct: () => {
+        const c = fileCas(sha256)(home);
+        const [state0, cacheKey] = virtual(emptyState)(initEvo(c));
+        const e = evo(c)(cacheKey);
+        const snapshot = vecToCBase32(vec8(0x42n));
+        const [state1, absent] = virtual(state0)(e.add({ parents: [], subject: 'absent', snapshot }));
+        assert(absent[0] === 'ok', ['expected add ok', absent]);
+        const [state2, empty] = virtual(state1)(e.add({ parents: [], subject: 'empty', snapshot, lock: {} }));
+        assert(empty[0] === 'ok', ['expected add ok', empty]);
+        const [state3, absentRead] = virtual(state2)(e.revision(absent[1]));
+        assert(absentRead[0] === 'ok', ['expected revision ok', absentRead]);
+        const [, emptyRead] = virtual(state3)(e.revision(empty[1]));
+        assert(emptyRead[0] === 'ok', ['expected revision ok', emptyRead]);
+        assertEq(absentRead[1].lock, undefined);
+        assertEq(Object.keys(emptyRead[1].lock ?? {}).length, 0);
+    },
+    revisionInvalidLockValueIsRejected: () => {
+        const c = fileCas(sha256)(home);
+        const [state0, cacheKey] = virtual(emptyState)(initEvo(c));
+        const e = evo(c)(cacheKey);
+        const [, result] = virtual(state0)(e.add({
+            parents: [], subject: 'doc', snapshot: vecToCBase32(vec8(0x42n)),
+            lock: { dependency: 'not a hash!' },
+        }));
+        assertEq(result[0], 'error');
+    },
+    equivalentLockOrdersReuseOneCasAddress: () => {
+        const c = fileCas(sha256)(home);
+        const [state0, cacheKey] = virtual(emptyState)(initEvo(c));
+        const e = evo(c)(cacheKey);
+        const a = vecToCBase32(vec8(0x1an));
+        const b = vecToCBase32(vec8(0x2bn));
+        const snapshot = vecToCBase32(vec8(0x3cn));
+        const [state1, first] = virtual(state0)(e.add({ parents: [], subject: 'doc', snapshot, lock: { '2': b, '10': a } }));
+        assert(first[0] === 'ok', ['expected add ok', first]);
+        const [, second] = virtual(state1)(e.add({ lock: { '10': a, '2': b }, snapshot, subject: 'doc', parents: [] }));
+        assert(second[0] === 'ok', ['expected add ok', second]);
+        assertEq(second[1], first[1]);
+    },
     // A raw CAS write (e.g. `cas_add`) of valid revision content is folded
     // into the cache exactly as `addRevision` would, without going through
     // `evo.add` — this is what keeps `cas_add` and `evo_add` writes to the

package/fjs/dev/module.f.d.ts

@@ -10,7 +10,7 @@ export type Module = {
     readonly proof?: unknown;
     readonly [k: string]: unknown;
 };
-export type ModuleMap = StringMap<string, Module>;
+export type ModuleMap = StringMap<Module>;
 /**
  * Returns `true` if the file should be loaded for proof discovery.
  *

package/fjs/effects/node/module.f.d.ts

@@ -109,7 +109,7 @@ export type Stat = readonly ['stat', (path: string) => IoResult<FileStat>];
 export declare const stat: Func<Stat>;
 export type Fs = Mkdir | ReadFile | ReadBytes | Readdir | WriteFile | Rm | Rename | Exec | Access | CreateExclusive | WriteBytes | Stat;
 export type Server = Nominal<'server', `160855c4f69310fece3273c1853ac32de43dee1eb41bf59d821917f8eebe9272`, unknown>;
-export type Headers = StringMap<string, string>;
+export type Headers = StringMap<string>;
 export type IncomingMessage = {
     readonly method: string;
     readonly url: string;
@@ -129,7 +129,7 @@ export declare const listen: Func<Listen>;
 export type Http = CreateServer | Listen;
 export type Forever = ['forever', () => never];
 export declare const forever: Func<Forever>;
-export type Module = StringMap<string, unknown>;
+export type Module = StringMap<unknown>;
 export type Import = ['import', (path: string) => IoResult<Module>];
 export declare const import_: Func<Import>;
 /** Named output streams accepted by the `Write` effect. */

package/fjs/fsm/module.f.d.ts

@@ -9,7 +9,7 @@ import { type ByteSet } from '../types/byte_set/module.f.ts';
 import { type RangeMapArray } from '../types/range_map/module.f.ts';
 type Rule = readonly [string, ByteSet, string];
 export type Grammar = List<Rule>;
-type Dfa = StringMap<string, RangeMapArray<string>>;
+type Dfa = StringMap<RangeMapArray<string>>;
 export declare const toRange: (s: string) => ByteSet;
 export declare const toUnion: (s: string) => ByteSet;
 export declare const dfa: (grammar: Grammar) => Dfa;

package/fjs/media/html/module.f.d.ts

@@ -17,7 +17,7 @@ type Element2 = readonly [Tag, Attributes, ...Node[]];
  * - `[tag, attributes, ...children]` for elements with attributes.
  */
 export type Element = Element1 | Element2;
-type Attributes = StringMap<string, string>;
+type Attributes = StringMap<string>;
 export type Node = Element | string;
 /**
  * Converts a FunctionalScript element into a list of HTML string chunks.

package/fjs/media/revision/module.f.d.ts

@@ -20,6 +20,10 @@ export declare const mediaType: "application/vnd.fjs.revision+json";
  * not by this schema on its own.
  */
 export declare const hash: import("../../types/rtti/module.f.ts").String;
+/** Structural schema for a Stage 1 flat lock map. */
+declare const lock: import("../../types/rtti/module.f.ts").Type1<"record", import("../../types/rtti/module.f.ts").String>;
+/** A flat set of subject-to-snapshot bindings supplied to dependency resolvers. */
+export type LockMap = Ts<typeof lock>;
 /**
  * rtti schema for a `revision` BLOB. See the README for the full semantics of
  * each field; `dialect` is the type discriminant, matched here as an exact
@@ -32,9 +36,12 @@ export declare const revisionSchema: {
     readonly snapshot: import("../../types/rtti/module.f.ts").String;
     readonly generation: import("../../types/rtti/module.f.ts").Number;
     readonly archived: import("../../types/rtti/module.f.ts").Or<readonly [true, undefined]>;
+    readonly lock: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Type1<"record", import("../../types/rtti/module.f.ts").String>, undefined]>;
 };
 /** The TypeScript type derived from {@link revisionSchema} — the single source of truth. */
 export type Revision = Ts<typeof revisionSchema>;
+/** Serializes a revision canonically, recursively sorting every object's property names. */
+export declare const encodeText: (revision: Revision) => string;
 /** True when `s` decodes as a cbase32 CAS hash (rejects `https://` and any other non-cbase32 string). */
 export declare const isHash: (s: string) => boolean;
 /** Either a structural validation error or a semantic (hash / generation) error message. */
@@ -84,3 +91,4 @@ export declare const decodeText: (text: string) => Result<Revision, RevisionErro
  * `snapshot` is not a cbase32 hash is not one.
  */
 export declare const revisionDialect: DialectEntry;
+export {};

package/fjs/media/revision/module.f.js

@@ -14,12 +14,14 @@
  *
  * @module
  */
-import { array, number, option, string } from '../../types/rtti/module.f.js';
+import { array, number, option, record, string } from '../../types/rtti/module.f.js';
 import { validate as rttiValidate } from '../../types/rtti/validate/module.f.js';
 import { parse as parseJson } from '../json/module.f.js';
 import { cBase32ToVec } from '../../basen/cbase32/module.f.js';
 import { error, ok } from '../../types/result/module.f.js';
 import { dialectEntry } from '../module.f.js';
+import { definedEntries, sort } from '../../types/object/module.f.js';
+import { stringify } from '../json/module.f.js';
 /**
  * Format tag: names the dialect of this BLOB. The media type it is served
  * with is derived mechanically: `application/` + `dialect` + `+json`.
@@ -37,6 +39,8 @@ export const mediaType = `application/${dialect}+json`;
  * not by this schema on its own.
  */
 export const hash = string;
+/** Structural schema for a Stage 1 flat lock map. */
+const lock = record(string);
 /**
  * rtti schema for a `revision` BLOB. See the README for the full semantics of
  * each field; `dialect` is the type discriminant, matched here as an exact
@@ -49,7 +53,10 @@ export const revisionSchema = {
     snapshot: hash,
     generation: number,
     archived: option(true),
+    lock: option(lock),
 };
+/** Serializes a revision canonically, recursively sorting every object's property names. */
+export const encodeText = stringify(sort);
 /** Structural-only validator: checks the shape, not the hash / generation semantics. */
 const validateShape = rttiValidate(revisionSchema);
 /** True when `s` decodes as a cbase32 CAS hash (rejects `https://` and any other non-cbase32 string). */
@@ -89,6 +96,11 @@ export const checkReferences = (r) => {
     if (!isHash(r.snapshot)) {
         return error(`snapshot is not a valid hash: ${r.snapshot}`);
     }
+    for (const [subject, snapshot] of definedEntries(r.lock ?? {})) {
+        if (!isHash(snapshot)) {
+            return error(`lock value for ${subject} is not a valid hash: ${snapshot}`);
+        }
+    }
     if (!Number.isSafeInteger(r.generation) || r.generation < 0) {
         return error(`generation must be a non-negative safe integer: ${r.generation}`);
     }

package/fjs/media/revision/proof.f.d.ts

@@ -18,6 +18,12 @@ export declare const proof: {
         positiveGenerationAccepted: () => void;
         httpsRejectedInParents: () => void;
         archivedAccepted: () => void;
+        lockAbsentAccepted: () => void;
+        emptyLockAccepted: () => void;
+        validLockAccepted: () => void;
+        malformedLockRejected: () => void;
+        invalidHashLockRejected: () => void;
+        aliasHashLockAccepted: () => void;
         wrongDialectRejected: () => void;
         missingSubjectRejected: () => void;
         extraFieldsAccepted: () => void;
@@ -28,4 +34,9 @@ export declare const proof: {
         malformedJsonRejected: () => void;
         ordinaryJsonRejected: () => void;
     };
+    encodeText: {
+        recursivelySortsObjectsLexicographically: () => void;
+        preservesArrayOrder: () => void;
+        parsedEquivalentSourcesConverge: () => void;
+    };
 };

package/fjs/media/revision/proof.f.js

@@ -1,9 +1,12 @@
 import { assert, assertEq } from '../../asserts/module.f.js';
-import { dialect, mediaType, isHash, validate, decodeText } from './module.f.js';
+import { dialect, mediaType, isHash, validate, decodeText, encodeText } from './module.f.js';
 // Valid cbase32 hashes (round-tripped in fjs/basen/cbase32/proof.f.ts): single
 // cbase32 symbols, cheap to write inline here.
 const h1 = '8';
 const h2 = 'r';
+// `I` is accepted as an alias spelling of canonical cBase32 `1`.
+const alias = 'I';
+const _lockMapAllowsMissingSubjects = {};
 // A shape-valid revision: every required field present (`snapshot` and
 // `generation` included), with `extra` overriding or adding fields per test.
 const revisionOf = (extra) => ({
@@ -95,6 +98,32 @@ export const proof = {
             const [t] = validate(revisionOf({ archived: true }));
             assertEq(t, 'ok');
         },
+        lockAbsentAccepted: () => {
+            const r = validate(revisionOf({}));
+            assert(r[0] === 'ok', ['expected ok', r]);
+            assertEq(r[1].lock, undefined);
+        },
+        emptyLockAccepted: () => {
+            const r = validate(revisionOf({ lock: {} }));
+            assert(r[0] === 'ok', ['expected ok', r]);
+            assertEq(Object.keys(r[1].lock ?? {}).length, 0);
+        },
+        validLockAccepted: () => {
+            const [t] = validate(revisionOf({ lock: { dependency: h1 } }));
+            assertEq(t, 'ok');
+        },
+        malformedLockRejected: () => {
+            const [t] = validate(revisionOf({ lock: { dependency: 1 } }));
+            assertEq(t, 'error');
+        },
+        invalidHashLockRejected: () => {
+            const [t] = validate(revisionOf({ lock: { dependency: 'https://example.com/x' } }));
+            assertEq(t, 'error');
+        },
+        aliasHashLockAccepted: () => {
+            const [t] = validate(revisionOf({ lock: { dependency: alias } }));
+            assertEq(t, 'ok');
+        },
         // Wrong dialect tag: structural validation rejects it outright.
         wrongDialectRejected: () => {
             const [t] = validate({ dialect: 'vnd.fjs.other', subject: h1, parents: [], snapshot: h2, generation: 0 });
@@ -137,4 +166,25 @@ export const proof = {
             assertEq(t, 'error');
         },
     },
+    encodeText: {
+        recursivelySortsObjectsLexicographically: () => {
+            const revision = revisionOf({ lock: { '2': h2, '10': h1 } });
+            const decoded = validate(revision);
+            assert(decoded[0] === 'ok', ['expected ok', decoded]);
+            assertEq(encodeText(decoded[1]), `{"dialect":"${dialect}","generation":0,"lock":{"10":"${h1}","2":"${h2}"},"parents":[],"snapshot":"${h2}","subject":"${h1}"}`);
+        },
+        preservesArrayOrder: () => {
+            const decoded = validate(revisionOf({ parents: [h2, h1] }));
+            assert(decoded[0] === 'ok', ['expected ok', decoded]);
+            assert(encodeText(decoded[1]).includes(`"parents":["${h2}","${h1}"]`));
+        },
+        parsedEquivalentSourcesConverge: () => {
+            const a = decodeText(` { "subject":"${h1}", "snapshot":"${h2}", "parents":[], "generation":0, "dialect":"${dialect}" } `);
+            const b = decodeText(`{"dialect":"${dialect}","generation":0,"parents":[],"snapshot":"${h2}","subject":"${h1}"}`);
+            assert(a[0] === 'ok', ['expected ok', a]);
+            assert(b[0] === 'ok', ['expected ok', b]);
+            assertEq(encodeText(a[1]), encodeText(b[1]));
+        },
+    },
 };
+void _lockMapAllowsMissingSubjects;

package/fjs/types/object/module.f.d.ts

@@ -1,12 +1,35 @@
 import { type List } from '../list/module.f.ts';
 import { type Nullable } from '../nullable/module.f.ts';
 import { type OrderedMap } from '../ordered_map/module.f.ts';
-export type Map<T> = StringMap<string, T>;
+/** A record over the keys of `K`, each value possibly missing at runtime. */
+export type OptionalMap<K extends string, T> = {
+    readonly [k in K]?: T;
+};
+/**
+ * A record over the keys of `K`, each value required.
+ *
+ * `K` has to be a finite union of string literals: `RequiredMap<string, T>` is
+ * `never`, because no object can carry every string as a key. Use `StringMap<T>`
+ * for an open key set — its values are optional, which is what such a key set
+ * means at runtime.
+ *
+ * There is no known way to ask TypeScript whether `K` is finite, so the guard
+ * approximates it with `string extends K`, which holds exactly when `K` is
+ * `string`. Other infinite key sets are not caught: a template literal such as
+ * `x-${string}` yields a template index signature instead of `never`, and its
+ * reads are typed `T` while the runtime value is `undefined`. Keep `K` a union
+ * of string literals.
+ */
+export type RequiredMap<K extends string, T> = string extends K ? never : {
+    readonly [k in K]: T;
+};
+/** A record with an open key set. Every value can be missing at runtime. */
+export type StringMap<T> = OptionalMap<string, T>;
 export type Entry<T> = readonly [string, T];
-export declare const at: (name: string) => <T>(object: Map<T>) => Nullable<Exclude<T, undefined>>;
+export declare const at: (name: string) => <T>(object: StringMap<T>) => Nullable<Exclude<T, undefined>>;
 export declare const sort: <T>(e: List<Entry<T>>) => List<Entry<T>>;
-export declare const fromEntries: <T>(e: List<Entry<T>>) => Map<T>;
-export declare const fromMap: <T>(m: OrderedMap<T>) => Map<T>;
+export declare const fromEntries: <T>(e: List<Entry<T>>) => StringMap<T>;
+export declare const fromMap: <T>(m: OrderedMap<T>) => StringMap<T>;
 /**
  * A set of objects with a single key.
  *
@@ -14,7 +37,7 @@ export declare const fromMap: <T>(m: OrderedMap<T>) => Map<T>;
  * https://stackoverflow.com/questions/57571664/typescript-type-for-an-object-with-only-one-key-no-union-type-allowed-as-a-key
  */
 export type OneKey<K extends string, V> = {
-    [P in K]: (StringMap<P, V> & Partial<StringMap<Exclude<K, P>, never>>) extends infer O ? {
+    [P in K]: (RequiredMap<P, V> & OptionalMap<Exclude<K, P>, never>) extends infer O ? {
         [Q in keyof O]: O[Q];
     } : never;
 }[K];
@@ -24,13 +47,8 @@ export type OneKey<K extends string, V> = {
 export type NotUnion<T, U = T> = T extends unknown ? [
     U
 ] extends [T] ? T : never : never;
-export type SingleProperty<T extends StringMap<string, never>> = keyof T extends NotUnion<keyof T> ? T : never;
+export type SingleProperty<T extends StringMap<never>> = keyof T extends NotUnion<keyof T> ? T : never;
 export declare const isObject: (value: unknown) => value is { readonly [k in string]: unknown; };
 /** Returns only the defined (non-undefined) values of a partial record. */
-export declare const definedValues: <T>(map: StringMap<string, Exclude<T, undefined>>) => readonly Exclude<T, undefined>[];
-export type StringMap<K extends string, T> = string extends K ? {
-    readonly [k in string]?: T;
-} : {
-    readonly [k in K]: T;
-};
-export declare const definedEntries: <T>(cmd: StringMap<string, Exclude<T, undefined>>) => readonly (readonly [string, Exclude<T, undefined>])[];
+export declare const definedValues: <T>(map: StringMap<Exclude<T, undefined>>) => readonly Exclude<T, undefined>[];
+export declare const definedEntries: <T>(cmd: StringMap<Exclude<T, undefined>>) => readonly (readonly [string, Exclude<T, undefined>])[];

package/fjs/types/object/module.f.js

@@ -1,7 +1,8 @@
 /**
- * Plain-object helpers and types: `Map<T>`/`Entry<T>` shapes, safe property
- * lookup via `at`, conversions between entries and `OrderedMap`, and the
- * `OneKey`/`SingleProperty`/`NotUnion` utility types.
+ * Plain-object helpers and types: the `OptionalMap`/`RequiredMap`/`StringMap`
+ * record shapes and `Entry<T>`, safe property lookup via `at`, conversions
+ * between entries and `OrderedMap`, and the `OneKey`/`SingleProperty`/`NotUnion`
+ * utility types.
  *
  * @module
  */

package/fjs/types/object/proof.f.d.ts

@@ -1,18 +1,4 @@
-import type { StringMap } from './module.f.ts';
-type E<A, B> = A extends B ? B extends A ? true : false : false;
-type _InfiniteIsOptional = E<StringMap<string, bigint>, {
-    readonly [k in string]?: bigint;
-}>;
-type _FiniteIsRequired = E<StringMap<'a' | 'b', bigint>, {
-    readonly a: bigint;
-    readonly b: bigint;
-}>;
 export declare const proof: {
-    stringMap: {
-        infiniteIsOptional: _InfiniteIsOptional;
-        finiteIsRequired: _FiniteIsRequired;
-    };
     ctor: () => void;
     property: () => void;
 };
-export {};

package/fjs/types/object/proof.f.js

@@ -1,10 +1,6 @@
 import { at } from './module.f.js';
 import { assertEq } from '../../asserts/module.f.js';
 export const proof = {
-    stringMap: {
-        infiniteIsOptional: true,
-        finiteIsRequired: true,
-    },
     ctor: () => {
         const a = {};
         const value = at('constructor')(a);

package/fjs/types/rtti/common/module.f.d.ts

@@ -74,11 +74,11 @@ export type Visitor<R> = {
 /** Type guard narrowing `Unknown` to a specific container type `C`. */
 export type IsContainer<C extends Unknown> = (value: Unknown) => value is C;
 /** Maps a `Tag1` to its runtime container type. */
-export type Container<K extends Tag1> = K extends 'array' ? ReadonlyArray<Unknown> : StringMap<string, Unknown>;
+export type Container<K extends Tag1> = K extends 'array' ? ReadonlyArray<Unknown> : StringMap<Unknown>;
 /** `IsContainer` guard for arrays, shared by `validate` and `parse`. */
 export declare const isArray: IsContainer<ReadonlyArray<Unknown>>;
 /** `IsContainer` guard for records/structs, shared by `validate` and `parse`. */
-export declare const isObject: IsContainer<StringMap<string, Unknown>>;
+export declare const isObject: IsContainer<StringMap<Unknown>>;
 /**
  * Runs `item` over each `[key, value]` entry, bailing out with the first
  * error, path-prefixed with that entry's key. On success, folds each item's

package/fjs/types/rtti/module.f.d.ts

@@ -6,7 +6,7 @@ export type Const = null | boolean | number | string | undefined | bigint | {
 } | readonly Type[];
 export type ConstObject = Struct | Tuple;
 /** A struct schema: plain object whose values are nested `Type`s. */
-export type Struct = StringMap<string, Type>;
+export type Struct = StringMap<Type>;
 /** A tuple schema: readonly array whose elements are nested `Type`s. */
 export type Tuple = readonly Type[];
 declare const primitive0List: readonly ['bigint', 'boolean', 'number', 'string'];

package/fjs/types/rtti/ts/module.f.d.ts

@@ -31,7 +31,7 @@ export type Object = {
 /** Maps a `Tag0` to its TypeScript type. */
 export type Info0Ts<T extends Tag0> = T extends 'boolean' ? boolean : T extends 'number' ? number : T extends 'string' ? string : T extends 'bigint' ? bigint : T extends 'unknown' ? Unknown : never;
 /** Maps a `Const` schema to its TypeScript type. */
-export type ConstTs<T> = T extends readonly Type[] ? TupleTs<T> : T extends StringMap<string, Type> ? StructTs<T> : T;
+export type ConstTs<T> = T extends readonly Type[] ? TupleTs<T> : T extends StringMap<Type> ? StructTs<T> : T;
 /** Maps a `Tag1` and inner type to its TypeScript type. */
 export type Info1Ts<K extends Tag1, T extends Type> = K extends 'array' ? ArrayTs<T> : K extends 'record' ? RecordTs<T> : never;
 /** Maps an array schema `T` to `readonly Ts<T>[]`. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.42.0",
+  "version": "0.43.1",
   "type": "module",
   "files": [
     "**/*.js",