@geastack/compiler 1.0.15

package/dist/representation/numeric-index.d.ts

@@ -0,0 +1,13 @@
+import type { StructuralTypeId } from '../identity/ids.js';
+import type { Ownership, Representation } from './model.js';
+export interface NativeNumericIndex {
+    readonly kind: 'elements' | 'dictionary' | 'record-index';
+    readonly value: Representation;
+    readonly ownership: Ownership;
+}
+/** The native indexed storage reached by a numeric property key.
+ * A record's named numeric fields would need runtime field dispatch before
+ * the sidecar lookup, so those are not admitted as a plain table access.
+ */
+export declare const nativeNumericIndexOf: (value: Representation, resolve: (id: StructuralTypeId) => Representation) => NativeNumericIndex | null;
+export declare const hasNativeNumericIndexArms: (value: Representation, resolve: (id: StructuralTypeId) => Representation) => boolean;

package/dist/representation/numeric-index.js

@@ -0,0 +1,29 @@
+/** The native indexed storage reached by a numeric property key.
+ * A record's named numeric fields would need runtime field dispatch before
+ * the sidecar lookup, so those are not admitted as a plain table access.
+ */
+export const nativeNumericIndexOf = (value, resolve) => {
+    if (value.kind === 'array-object' || value.kind === 'typed-array') {
+        if (value.ownership !== 'shared-refcount')
+            return null;
+        return {
+            kind: 'elements',
+            value: value.kind === 'array-object' ? value.element : { kind: 'scalar', domain: 'number' },
+            ownership: value.ownership
+        };
+    }
+    if (value.kind === 'dictionary' && value.key === 'number')
+        return { kind: 'dictionary', value: value.value, ownership: value.ownership };
+    const record = value.kind === 'native-record-ref' && value.native === null ? resolve(value.shapeId) : value;
+    if (record.kind !== 'record-with-index')
+        return null;
+    const index = record.indexes.find((candidate) => candidate.key === 'number' || candidate.key === 'string');
+    if (!index)
+        return null;
+    if (record.fields.some((field) => String(Number(field.key)) === field.key))
+        return null;
+    return { kind: 'record-index', value: index.value, ownership: record.ownership };
+};
+export const hasNativeNumericIndexArms = (value, resolve) => value.kind === 'tagged-union' &&
+    value.arms.some((arm) => nativeNumericIndexOf(arm.value, resolve) !== null) &&
+    value.arms.every((arm) => arm.value.kind === 'null' || arm.value.kind === 'undefined' || nativeNumericIndexOf(arm.value, resolve) !== null);

package/dist/representation/object-shape.d.ts

@@ -0,0 +1,109 @@
+import type { StructuralTypeId } from '../identity/ids.js';
+import type { PropertyKeyShape, StructuralIndexShape, StructuralShape } from '../semantics/model/structural-types.js';
+import type { RecordAccessor, Representation } from './model.js';
+/**
+ * How an object *shape* divides into the physical parts a record carrier is
+ * made of: which members are storage, which index signature rides alongside
+ * them, and which members are not stored at all because a body answers them.
+ *
+ * Read off the shape and nothing else. A use site that re-decided any of this
+ * would be a second authority over one layout, and the two would disagree
+ * exactly where it is least visible -- a field the allocation writes and the
+ * read never looks at.
+ */
+/**
+ * A structural index signature narrowed to a key domain this compiler can
+ * actually carry. String, number, and symbol each have a physical container
+ * (`Dictionary`/`NumericDictionary`/`SymbolDictionary` in
+ * `targets/cpp/runtime/gea_runtime.h`). A symbol sidecar stores the runtime
+ * `gea::Symbol` identity itself; collapsing it to a printable description
+ * would make distinct `Symbol('state')` values alias, while boxing it into a
+ * string table would violate the no-boxing rule. Carrying `key` as this
+ * narrowed union, rather than the raw
+ * `StructuralIndexShape['key']`, is what lets a caller spell `dictionary`'s
+ * key or a `record-with-index` sidecar directly without re-deciding (or
+ * casting) it.
+ */
+export interface CarriableIndex {
+    readonly key: 'string' | 'number' | 'symbol';
+    readonly value: StructuralTypeId;
+}
+export declare const carriableIndexOf: (index: StructuralIndexShape) => CarriableIndex | null;
+/** Every index domain the structural model can carry, preserving its JS domain. */
+export declare const carriableIndexesOf: (shape: Extract<StructuralShape, {
+    kind: "object";
+}>) => readonly CarriableIndex[] | string;
+/**
+ * An object shape's own single string- or number-index, members-free
+ * dictionary body, or `null` when it is not shaped like one.
+ *
+ * Read entirely off `index`/`members` -- the shape's own structure -- so a
+ * named declaration can ask this exact question about its body (below)
+ * without deriving anything beyond the one index value a real dictionary
+ * answer needs.
+ */
+/**
+ * The index signatures a shape physically has, which is not always the number
+ * TypeScript reports.
+ *
+ * `[x: string | number]: unknown` (mongodb's `WriteConcernErrorResult`) is ONE
+ * index signature the program wrote, and the checker models it as TWO index
+ * infos -- one per key domain -- carrying the identical value type. Reading
+ * that as "more than one index signature" refuses a shape that declares a
+ * single one.
+ *
+ * The collapse is a fact about the language, not a convenience: a property key
+ * IS a string (ECMA-262 `ToPropertyKey`), so `obj[1]` and `obj['1']` name the
+ * same property, and TypeScript itself enforces that a numeric index type is
+ * assignable to the string one (TS2413). A string-keyed `gea::Dictionary`
+ * therefore already carries every key the numeric domain admits -- the numeric
+ * info is a VIEW of that storage, never storage of its own.
+ *
+ * Gated on the two infos agreeing EXACTLY on their value id. Assignability is
+ * not identity, and a shape whose numeric domain carries a genuinely narrower
+ * value -- `{ [k: string]: unknown; [k: number]: string }` -- has two different
+ * carriers and keeps refusing, rather than being silently widened to one.
+ */
+export declare const physicalIndexesOf: (shape: Extract<StructuralShape, {
+    kind: "object";
+}>) => readonly StructuralIndexShape[];
+export declare const dictionaryIndexOf: (shape: Extract<StructuralShape, {
+    kind: "object";
+}>) => CarriableIndex | null;
+/**
+ * The record-field key text for one structural member.
+ *
+ * A string or number key is spelled exactly as the language names it --
+ * `String(key.value)`, unchanged from before -- because that text *is* the
+ * field the program wrote. A symbol key has no such text: two symbols the
+ * program never confuses (`Symbol('x')` created twice, or `Symbol.iterator`
+ * versus a `unique symbol` that happens to print the same) can share a
+ * printable description, so the description is not a name a field could
+ * safely be keyed by. What a symbol key *does* have, uniquely, is the
+ * declaration `structural.ts`'s `keyOfSymbol` already anchored it to -- the
+ * same identity `structuralShapeKey` (semantics/model/structural-types.ts)
+ * already keys a shape by (`sym(<declaration>)`), which is why this reuses
+ * that exact text rather than inventing a second spelling for one fact. This
+ * is a compile-time-constant identity, not a runtime string, so the field it
+ * names is an ordinary struct member -- `targets/cpp/types.ts`'s
+ * `cppRecordFieldName` is the one place that text becomes the member's actual
+ * C++ name, the same split a tuple's positional key already uses.
+ */
+export declare const recordFieldKeyOf: (key: PropertyKeyShape) => string;
+export declare const recordAccessorsOf: (shape: Extract<StructuralShape, {
+    kind: "object";
+}>, 
+/** The caller's own `deriveStored` -- the identical call a data field's carrier comes from. See `RecordAccessor.value`. */
+deriveStored: (type: StructuralTypeId) => Representation) => readonly RecordAccessor[];
+/**
+ * Whether an object shape is pure data: named members, every one a value rather
+ * than something callable, none accessor-backed (an accessor has no storage and
+ * so contributes no field), and no index signature.
+ *
+ * This is the whole of the transparent-versus-opaque question for a host type,
+ * and it is asked of the CHECKER rather than of a table. A hand-maintained list
+ * of "constructible host types" would be a second authority over a question the
+ * declaration already answers, and it would drift the first time the host grew
+ * a method.
+ */
+export declare const isDataOnlyObjectShape: (shape: StructuralShape | null, shapeOf: (id: StructuralTypeId) => StructuralShape | null) => boolean;

package/dist/representation/object-shape.js

@@ -0,0 +1,123 @@
+import { functionId } from '../identity/ids.js';
+import { symbolPropertyKeyText } from '../semantics/model/structural-types.js';
+export const carriableIndexOf = (index) => index.key === 'string' || index.key === 'number' || index.key === 'symbol' ? { key: index.key, value: index.value } : null;
+/** Every index domain the structural model can carry, preserving its JS domain. */
+export const carriableIndexesOf = (shape) => {
+    const result = [];
+    for (const index of shape.index) {
+        const carriable = carriableIndexOf(index);
+        if (!carriable)
+            return `no primitive for a record carrier with a ${index.key}-keyed index signature`;
+        result.push(carriable);
+    }
+    return result;
+};
+/**
+ * An object shape's own single string- or number-index, members-free
+ * dictionary body, or `null` when it is not shaped like one.
+ *
+ * Read entirely off `index`/`members` -- the shape's own structure -- so a
+ * named declaration can ask this exact question about its body (below)
+ * without deriving anything beyond the one index value a real dictionary
+ * answer needs.
+ */
+/**
+ * The index signatures a shape physically has, which is not always the number
+ * TypeScript reports.
+ *
+ * `[x: string | number]: unknown` (mongodb's `WriteConcernErrorResult`) is ONE
+ * index signature the program wrote, and the checker models it as TWO index
+ * infos -- one per key domain -- carrying the identical value type. Reading
+ * that as "more than one index signature" refuses a shape that declares a
+ * single one.
+ *
+ * The collapse is a fact about the language, not a convenience: a property key
+ * IS a string (ECMA-262 `ToPropertyKey`), so `obj[1]` and `obj['1']` name the
+ * same property, and TypeScript itself enforces that a numeric index type is
+ * assignable to the string one (TS2413). A string-keyed `gea::Dictionary`
+ * therefore already carries every key the numeric domain admits -- the numeric
+ * info is a VIEW of that storage, never storage of its own.
+ *
+ * Gated on the two infos agreeing EXACTLY on their value id. Assignability is
+ * not identity, and a shape whose numeric domain carries a genuinely narrower
+ * value -- `{ [k: string]: unknown; [k: number]: string }` -- has two different
+ * carriers and keeps refusing, rather than being silently widened to one.
+ */
+export const physicalIndexesOf = (shape) => {
+    if (shape.index.length !== 2)
+        return shape.index;
+    const stringIndex = shape.index.find((one) => one.key === 'string');
+    const numberIndex = shape.index.find((one) => one.key === 'number');
+    if (!stringIndex || !numberIndex)
+        return shape.index;
+    if (stringIndex.value !== numberIndex.value || stringIndex.readonly !== numberIndex.readonly)
+        return shape.index;
+    return [stringIndex];
+};
+export const dictionaryIndexOf = (shape) => {
+    const indexes = physicalIndexesOf(shape);
+    const [only] = indexes;
+    if (shape.members.length !== 0 || indexes.length !== 1 || !only)
+        return null;
+    return carriableIndexOf(only);
+};
+/**
+ * The record-field key text for one structural member.
+ *
+ * A string or number key is spelled exactly as the language names it --
+ * `String(key.value)`, unchanged from before -- because that text *is* the
+ * field the program wrote. A symbol key has no such text: two symbols the
+ * program never confuses (`Symbol('x')` created twice, or `Symbol.iterator`
+ * versus a `unique symbol` that happens to print the same) can share a
+ * printable description, so the description is not a name a field could
+ * safely be keyed by. What a symbol key *does* have, uniquely, is the
+ * declaration `structural.ts`'s `keyOfSymbol` already anchored it to -- the
+ * same identity `structuralShapeKey` (semantics/model/structural-types.ts)
+ * already keys a shape by (`sym(<declaration>)`), which is why this reuses
+ * that exact text rather than inventing a second spelling for one fact. This
+ * is a compile-time-constant identity, not a runtime string, so the field it
+ * names is an ordinary struct member -- `targets/cpp/types.ts`'s
+ * `cppRecordFieldName` is the one place that text becomes the member's actual
+ * C++ name, the same split a tuple's positional key already uses.
+ */
+export const recordFieldKeyOf = (key) => key.kind === 'symbol' ? symbolPropertyKeyText(key.declaration) : String(key.value);
+export const recordAccessorsOf = (shape, 
+/** The caller's own `deriveStored` -- the identical call a data field's carrier comes from. See `RecordAccessor.value`. */
+deriveStored) => shape.members.flatMap((member) => member.accessor
+    ? [
+        {
+            key: recordFieldKeyOf(member.key),
+            // The declaration *is* the function's identity here: `functionId`
+            // is the one rule that maps a declaration to the body compiled
+            // for it, and re-spelling it locally would be a second answer to
+            // a question the identity module already owns.
+            getter: member.accessor.getter ? functionId(member.accessor.getter) : null,
+            setter: member.accessor.setter ? functionId(member.accessor.setter) : null,
+            value: deriveStored(member.type)
+        }
+    ]
+    : []);
+/**
+ * Whether an object shape is pure data: named members, every one a value rather
+ * than something callable, none accessor-backed (an accessor has no storage and
+ * so contributes no field), and no index signature.
+ *
+ * This is the whole of the transparent-versus-opaque question for a host type,
+ * and it is asked of the CHECKER rather than of a table. A hand-maintained list
+ * of "constructible host types" would be a second authority over a question the
+ * declaration already answers, and it would drift the first time the host grew
+ * a method.
+ */
+export const isDataOnlyObjectShape = (shape, shapeOf) => {
+    if (shape?.kind !== 'object')
+        return false;
+    // `membersDropped` is the whole reason this is not simply a scan of
+    // `members`: an ambient body arrives already filtered to its data, so a
+    // host interface of pure methods reads as "no callable members" unless the
+    // projection itself disqualifies it.
+    if (shape.membersDropped)
+        return false;
+    if (shape.members.length === 0 || shape.index.length > 0)
+        return false;
+    return shape.members.every((member) => member.accessor === null && shapeOf(member.type)?.kind !== 'signature');
+};

package/dist/representation/optional.d.ts

@@ -0,0 +1,12 @@
+import type { Representation } from './model.js';
+/**
+ * Wrap a payload in an absence tag without stacking two of them.
+ *
+ * Stacking is only ever a collapse: one flag cannot say which of two absent
+ * values it stands for. When the tags agree the wrapper adds nothing -- an
+ * `Optional<T>` already tagged `null` *is* `T | null`. When they differ the
+ * carrier would have to encode `null` and `undefined` in one boolean, and they
+ * are distinguishable values, so it is refused with that stated rather than
+ * silently answering one of the two questions wrong.
+ */
+export declare const optionalOf: (payload: Representation, absence: "null" | "undefined") => Representation;

package/dist/representation/optional.js

@@ -0,0 +1,87 @@
+const unresolved = (reason) => ({ kind: 'unresolved', reason });
+/**
+ * Wrap a payload in an absence tag without stacking two of them.
+ *
+ * Stacking is only ever a collapse: one flag cannot say which of two absent
+ * values it stands for. When the tags agree the wrapper adds nothing -- an
+ * `Optional<T>` already tagged `null` *is* `T | null`. When they differ the
+ * carrier would have to encode `null` and `undefined` in one boolean, and they
+ * are distinguishable values, so it is refused with that stated rather than
+ * silently answering one of the two questions wrong.
+ */
+export const optionalOf = (payload, absence) => {
+    if (payload.kind === 'unresolved')
+        return payload;
+    if (payload.kind === 'optional') {
+        return payload.absence === absence
+            ? payload
+            : unresolved('no primitive for a carrier tagged with both absent values; one flag cannot say which one it holds');
+    }
+    if (payload.kind === 'undefined') {
+        return absence === 'undefined'
+            ? payload
+            : unresolved('no primitive for a carrier tagged with both absent values; one flag cannot say which one it holds');
+    }
+    // A host handle already carries its own absence, so an `Optional` around one
+    // is a SECOND absence flag over a value that has one.
+    //
+    // This is the host's own answer, not an optimization. Every handle shape in
+    // this compiler is absence-carrying by construction: `gea::NativeHandle`
+    // default-constructs to `id_ = -1`, and a host-stated carrier does the same --
+    // the Apple bridge writes `struct NSObject { double handle = 0; explicit
+    // operator bool() const { return handle != 0; } }`. And the hosts THEMSELVES
+    // spell a nullable handle as a plain one: the Apple package declares
+    // `image: NSImage | null` in TypeScript and `void installToolbar(std::string,
+    // NSObject)` in the C++ its own generator writes for the same nullable
+    // parameter. So `NSImage | null` and `NSImage` are one physical type at that
+    // boundary, and two carriers for it would be the two-authorities defect --
+    // every host call needing a conversion between a type and itself, which is
+    // exactly what emitted `Optional<NSImage>.handle` and did not compile.
+    //
+    // `null` only. `undefined` is a JavaScript state no host produces: nothing
+    // across an ObjC boundary is ever anything but an object or nil, so a carrier
+    // asked to hold `T | undefined` is being asked a question about the program's
+    // own values and keeps the flag that answers it.
+    if (payload.kind === 'native-handle' && absence === 'null')
+        return payload;
+    // A refcounted class instance is the same argument in the program's own
+    // half. `gea::Ref<T>` default-constructs to `nullptr` and converts to `bool`
+    // over exactly that, so `TreeNode | null` and `TreeNode` are one physical
+    // type -- and `targets/cpp/types.ts`'s `carriesAbsence` has always said so,
+    // which is why the emitter needed no new spelling for it.
+    //
+    // The second flag was not free: `Optional<Ref<T>>` is two words where one
+    // would do, so every nullable field doubled, every parameter carrying one
+    // was passed in two registers, and every read of it branched on a tag beside
+    // a pointer that already held the answer. Measured on
+    // `bench/comparison/fixtures/binary_trees.ts`, whose `left`/`right` are both
+    // `TreeNode | null`: 84.5ms to 63.0ms.
+    //
+    // `shared-refcount` only, and `null` only. An `owned` or `borrowed` instance
+    // is not a handle to a heap object -- there is no null state to stand for the
+    // absence -- and `undefined` is a JavaScript state the pointer cannot spell,
+    // exactly as for a host handle.
+    if (payload.kind === 'class-ref' && payload.ownership === 'shared-refcount' && absence === 'null')
+        return payload;
+    // The box is the other carrier that already holds its own absence, and it
+    // holds BOTH of them: `gea::Value`'s tag has a `Null` state and an
+    // `Undefined` state (gea_runtime.h), and a default-constructed box IS
+    // `undefined`. So `any | undefined` and `any` are one physical type, which
+    // is also what the checker says -- `any` already admits `undefined`, and
+    // TypeScript types the body binding of `a?: any` as plain `any`.
+    //
+    // Wrapping anyway is the two-authorities defect in its exact shape, and it
+    // was measured as one: the ABI projection declared `optional(dynamic,
+    // undefined)` for every `a?: any` parameter while the body bound `dynamic`,
+    // so `projection/abi.ts` refused the convention of fifteen functions --
+    // every callback in a heterogeneous listener table -- and no body that took
+    // one could lower.
+    //
+    // Both absences, unlike the handle above, because unlike a host handle a box
+    // really does distinguish them: `x === null` and `x === undefined` each read
+    // the tag they name (`emit-presence.ts`'s `absenceComparisonText`), so
+    // collapsing loses nothing a second flag would have carried.
+    if (payload.kind === 'dynamic')
+        return payload;
+    return { kind: 'optional', payload, absence };
+};

package/dist/representation/plan.d.ts

@@ -0,0 +1,60 @@
+import type { ComponentId, SemanticResultId } from '../identity/ids.js';
+import { type Representation } from './model.js';
+/**
+ * The sealed representation plan.
+ *
+ * The plan is the single authority for what a value physically *is*. Producers
+ * never mutate it while a round is running: they add immutable evidence, and
+ * selection happens once, per authority component, after that component has
+ * reached quiescence. That ordering is what removes the whole category of
+ * "later reconciliation" passes -- there is no window in which one consumer can
+ * read a weaker answer that another consumer has already replaced.
+ */
+/**
+ * How strong a piece of evidence is.
+ *
+ * Conservative evidence is a real answer while an operation is unresolved, but
+ * it is a *candidate*, never a co-equal authority. When exact evidence arrives
+ * for the same coordinate, the transaction selects it and retires the candidate
+ * from selection while keeping it for diagnostics.
+ */
+export type EvidenceStrength = 'conservative' | 'exact';
+export interface RepresentationEvidence {
+    readonly result: SemanticResultId;
+    readonly representation: Representation;
+    readonly strength: EvidenceStrength;
+    /** Which producer published this, so a conflict names both sides. */
+    readonly producer: string;
+    /**
+     * True when the language itself requires a closed family or join at this
+     * coordinate. Two exact rows may coexist only under this flag; otherwise
+     * disagreement is a conflict, not a menu.
+     */
+    readonly joinsClosedFamily: boolean;
+}
+/** Two exact publications that disagree at one coordinate. */
+export interface RepresentationConflict {
+    readonly result: SemanticResultId;
+    readonly component: ComponentId;
+    readonly left: RepresentationEvidence;
+    readonly right: RepresentationEvidence;
+}
+export interface SealedRepresentationPlan {
+    /** The selected carrier for every published result. */
+    readonly selected: ReadonlyMap<SemanticResultId, Representation>;
+    /** Every row ever published, retained for diagnostics only. */
+    readonly evidence: ReadonlyMap<SemanticResultId, readonly RepresentationEvidence[]>;
+    readonly conflicts: readonly RepresentationConflict[];
+}
+export interface RepresentationPlanBuilder {
+    /** Add immutable evidence. Never overwrites; selection happens at commit. */
+    readonly publish: (evidence: RepresentationEvidence) => void;
+    /**
+     * Select and commit one authority component. A component with a conflict
+     * commits nothing: connected members commit together or stay blocked, so no
+     * consumer can observe half a component.
+     */
+    readonly commitComponent: (component: ComponentId, members: readonly SemanticResultId[]) => readonly RepresentationConflict[];
+    readonly seal: () => SealedRepresentationPlan;
+}
+export declare const createRepresentationPlanBuilder: () => RepresentationPlanBuilder;

package/dist/representation/plan.js

@@ -0,0 +1,78 @@
+import { representationKey } from './model.js';
+const selectFrom = (rows) => {
+    const exact = rows.filter((row) => row.strength === 'exact');
+    if (exact.length === 0) {
+        const conservative = rows[0];
+        return { selected: conservative ? conservative.representation : null, conflict: null };
+    }
+    const first = exact[0];
+    if (!first)
+        return { selected: null, conflict: null };
+    // Hoisted: the loop compares every candidate against this one carrier, and
+    // rebuilding its key per candidate made the comparison quadratic in the
+    // number of exact rows for a key that never changes.
+    const firstKey = representationKey(first.representation);
+    for (const candidate of exact.slice(1)) {
+        if (representationKey(candidate.representation) === firstKey)
+            continue;
+        // A closed family is the one case where the language really does produce
+        // two exact answers; anything else is two producers disagreeing, and
+        // letting a consumer pick would make lookup order a semantic decision.
+        if (candidate.joinsClosedFamily && first.joinsClosedFamily)
+            continue;
+        return { selected: null, conflict: [first, candidate] };
+    }
+    return { selected: first.representation, conflict: null };
+};
+export const createRepresentationPlanBuilder = () => {
+    const evidence = new Map();
+    const selected = new Map();
+    const committed = new Set();
+    const conflicts = [];
+    let sealed = false;
+    const publish = (row) => {
+        if (sealed)
+            throw new Error(`representation plan is sealed; ${row.producer} published ${row.result} after freeze`);
+        const rows = evidence.get(row.result) ?? [];
+        rows.push(row);
+        evidence.set(row.result, rows);
+    };
+    const commitComponent = (component, members) => {
+        if (sealed)
+            throw new Error(`representation plan is sealed; component ${component} cannot commit after freeze`);
+        if (committed.has(component))
+            throw new Error(`component ${component} committed twice`);
+        const found = [];
+        const pending = new Map();
+        for (const member of members) {
+            const rows = evidence.get(member) ?? [];
+            const { selected: choice, conflict } = selectFrom(rows);
+            if (conflict) {
+                found.push({ result: member, component, left: conflict[0], right: conflict[1] });
+                continue;
+            }
+            if (choice)
+                pending.set(member, choice);
+        }
+        if (found.length > 0) {
+            conflicts.push(...found);
+            return found;
+        }
+        committed.add(component);
+        for (const [member, choice] of pending)
+            selected.set(member, choice);
+        return [];
+    };
+    const seal = () => {
+        sealed = true;
+        const frozenEvidence = new Map();
+        for (const [result, rows] of evidence)
+            frozenEvidence.set(result, Object.freeze([...rows]));
+        return Object.freeze({
+            selected: new Map(selected),
+            evidence: frozenEvidence,
+            conflicts: Object.freeze([...conflicts])
+        });
+    };
+    return { publish, commitComponent, seal };
+};