@adobe/ecs 0.1.0 → 0.2.1

package/src/implementation/world/sharing.ts

@@ -1,17 +1,20 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { createResolved } from '../../interface/system/create-resolved.js';
+import type { Resolved } from '../../interface/system/declaration.js';
+import type { SystemLookupLists } from '../../interface/system/access.js';
 import type { World } from '../../interface/world/world.js';
-import type { Failure } from '../../interface/report/failure.js';
-import { definitionOf, idOfKey, indexDefinitionOf, itemOfId, keyOfId, labelOfItem, requireDefinition, type Definition } from '../../interface/registry/index.js';
+import type { Failure } from './failures.js';
+import { definitionOf, idOfKey, indexDefinitionOf, itemOfId, keyOfId, requireDefinition, type Definition } from '../../interface/registry/index.js';
 import type { Views } from '../../interface/registry/layout.js';
 import { failureOf } from './failures.js';
 import {
-    completedWord, done, controlBytes, inputByMessage, inputLayoutOf, inputMoved, platformLocks, postedWord, protocolName, rejected, runSlots, slotRun,
-    signalWord, unreadWord, slotInput, slotNumber, slotPayload, slotStatus, slotViews, slotWords, slotsWord, threadChannel, unposted,
+    completedWord, done, controlBytes, inputByMessage, inputLayoutOf, inputMoved, platformLocks, postedWord, protocolName, rejected, resolved, runSlots,
+    signalWord, unreadWord, slotInput, slotNumber, slotPayload, slotStatus, slotViews, slotWords, slotsWord, threadChannel, threadLock, unposted,
     type ObserverDeclaration, type ObserverIndex, type ThreadChannel, type ToJoined, type ToWorld,
 } from './joining.js';
-import { createObserverTarget, droppedObserver, endTarget, joinedRun, type ObserverTarget } from './joined-observer.js';
+import { createObserverTarget, droppedObserver, endTarget, joinedRun, ranThere, type ObserverTarget } from './joined-observer.js';
 import type { Leaf } from '../../interface/system/leaf.js';
 import { Index } from '../../interface/indexes/index-type.js';
-import { System } from '../../interface/system/system.js';
 import { createMoveLog, freeMoveLog, type MoveLog } from './move-log.js';
 import { lineWords } from './protocol.js';
 import { claimThreads, releaseThreads } from './remote.js';
@@ -25,9 +28,9 @@ import { heldInput, type HeldInput } from './transfers.js';
 export type SharingHost = {
     readonly state: State;
     /** Runs a system as `world.run` does. */
-    readonly run: (definition: Definition, input: unknown) => Promise<number>;
-    /** A failure for the next run's report. */
-    readonly defer: (failure: Failure) => void;
+    readonly run: (definition: Definition, input: unknown) => Promise<unknown>;
+    /** Reports a failure found on a joined thread out of band. */
+    readonly report: (failure: Failure) => void;
     /**
      * Why a joined thread that imported the systems of ids `imported` can't claim `threads`: a system it can't run
      * there, or a finalizer on one; null when none.
@@ -90,6 +93,8 @@ type Joined = {
     observer: ObserverTarget | null;
     /** Its own observer systems, as the world declares them, by its numbers for them. */
     readonly proxies: Map<number, Leaf>;
+    /** Settles what `share` returned: once it has joined, or failed to; null once settled. */
+    settle: { readonly resolve: () => void; readonly reject: (error: Error) => void } | null;
 };
 
 const hasWaitAsync = (): boolean => typeof Atomics.waitAsync === "function";
@@ -98,7 +103,8 @@ const messageOf = (error: unknown): string => error instanceof Error ? error.mes
 
 /**
  * The world's side of joined threads: `share` records a thread joining, then its handshake records its claims, which a
- * thread claimed twice can't join; `progress` shows each one's, in the order they were shared. Runs come through its
+ * thread claimed twice can't join, and `share` resolves once the thread says it's ready, or rejects saying why it
+ * didn't join; `progress` shows each one's, in the order they were shared. Runs come through its
  * slots in shared memory, in sequence, naming systems by its numbers, and complete through its completed word, with a
  * number in its slot; its observer systems are posted to it after each sync point, with one notify
  * per thread a turn.
@@ -163,15 +169,14 @@ export const createSharing = (host: SharingHost) => {
     };
 
     /**
-     * A run finished: its status and its number, the run's or 0 for a rejection, in its slot, a rejection posted, and
-     * completed advanced through those in order.
+     * A run finished: its status in its slot, its value or rejection posted first, and completed advanced through those
+     * in order. Throws, finishing nothing, for a message that can't be posted.
      */
-    const finish = (thread: Joined, sequence: number, status: number, run: number, message: ToJoined | null): void => {
+    const finish = (thread: Joined, sequence: number, status: number, message: ToJoined | null): void => {
         const { control } = thread;
         if (control === null || thread.status === "gone") return;
         if (message !== null) post(thread, message);
         const base = slotsWord + ((sequence - 1) % runSlots) * slotWords;
-        Atomics.store(control, base + slotRun, run);
         Atomics.store(control, base + slotStatus, status);
         thread.finished.add(sequence);
         let completed = thread.completed;
@@ -183,7 +188,17 @@ export const createSharing = (host: SharingHost) => {
     };
 
     const reject = (thread: Joined, sequence: number, text: string): void =>
-        finish(thread, sequence, rejected, 0, { protocol: protocolName, kind: "rejected", sequence, message: text });
+        finish(thread, sequence, rejected, { protocol: protocolName, kind: "rejected", sequence, message: text });
+
+    /** A run resolved to a value, posted to its thread; one that can't be posted, as one holding a function, rejects. */
+    const resolve = (thread: Joined, sequence: number, value: unknown): void => {
+        try {
+            finish(thread, sequence, resolved, { protocol: protocolName, kind: "resolved", sequence, value });
+        }
+        catch (error) {
+            reject(thread, sequence, `Its value can't be posted to the joined thread: ${messageOf(error)}`);
+        }
+    };
 
     /** Run `sequence` of `thread`, whose input moved to `holder`, finished: if no task there took it, it's released there. */
     const released = (holder: Joined | null, thread: Joined, sequence: number, held: HeldInput | null = null): void => {
@@ -239,10 +254,10 @@ export const createSharing = (host: SharingHost) => {
                 released(holder, thread, sequence);
                 continue;
             }
-            const layout = bytes >= 0 && definition.kind !== "composite" ? inputLayoutOf(definition, definition.declaration.input) : null;
+            const layout = bytes >= 0 && definition.kind !== "composite" ? inputLayoutOf(definition, definition.input) : null;
             const held = holder !== null && holder.tasks !== null ? heldInput(thread.number, sequence, holder.tasks) : null;
             const value = own ? joinedRun(sequence) : held ?? (layout !== null && layout.kind === "linear" ? layout.read(thread.views[slot], 0) : input);
-            let ran: Promise<number>;
+            let ran: Promise<unknown>;
             try {
                 ran = host.run(definition, value);
             }
@@ -252,7 +267,7 @@ export const createSharing = (host: SharingHost) => {
                 continue;
             }
             const settled = ran.then(
-                run => finish(thread, sequence, done, run, null),
+                result => result === undefined ? finish(thread, sequence, done, null) : resolve(thread, sequence, result),
                 error => reject(thread, sequence, messageOf(error)),
             );
             if (held !== null) void settled.then(() => released(holder, thread, sequence, held));
@@ -310,11 +325,29 @@ export const createSharing = (host: SharingHost) => {
      */
     const refuse = (thread: Joined, message: string): void => {
         post(thread, { protocol: protocolName, kind: "refused", message });
+        thread.settle?.reject(new Error(message));
+        thread.settle = null;
         gone(thread);
     };
 
+    /** It has joined: its claims are made, and what it did as its join resolved arrived, its observer systems included. */
+    const ready = (thread: Joined): void => {
+        if (thread.status !== "joined") return;
+        thread.settle?.resolve();
+        thread.settle = null;
+    };
+
+    /**
+     * Tells a thread the lock this one holds while it lives, once it does, so it hears of this thread's end: as it's
+     * shared, and again as it asks to join, when it surely listens.
+     */
+    const tellLock = (thread: Joined): void => {
+        void threadLock().then(lock => { if (lock !== null && thread.status !== "gone") post(thread, { protocol: protocolName, kind: "thread lock", lock }); });
+    };
+
     const join = (thread: Joined, threads: readonly string[], waits: boolean, lock: string | null, imported: readonly string[]): void => {
         if (thread.status !== "joining") return;
+        tellLock(thread);
         const locks = platformLocks();
         // Granted once the thread no longer holds it: it left, or ended.
         if (lock !== null && locks !== null) locks.request(lock, { signal: thread.abort.signal }, () => gone(thread)).catch(() => {});
@@ -331,7 +364,7 @@ export const createSharing = (host: SharingHost) => {
         controlBlocks.set(thread, offset);
         thread.views = slotViews(memory.memory.buffer, start);
         thread.status = "joined";
-        thread.observer = createObserverTarget(thread.number, threads.length === 0 ? `#${thread.number}` : threads.join(`" and "`), message => post(thread, message), () => wakeSoon(thread));
+        thread.observer = createObserverTarget(thread.number, threads.length === 0 ? `#${thread.number}` : threads.join(`" and "`), message => post(thread, message), () => wakeSoon(thread), thread.imported);
         const joined = (): void => post(thread, {
             protocol: protocolName, kind: "joined", memory: memory.memory, control: start, waits: hasWaitAsync(), log: thread.log?.block ?? null,
             tasks: thread.tasks?.block ?? null, thread: thread.number,
@@ -385,6 +418,8 @@ export const createSharing = (host: SharingHost) => {
         if (thread.status === "gone") return;
         const { control, log, tasks } = thread;
         thread.status = "gone";
+        thread.settle?.reject(new Error(closed ? "The world is disposed." : "The thread was gone before it joined."));
+        thread.settle = null;
         threads.delete(thread);
         byNumber.delete(thread.number);
         // With no thread left to read them, strings' records are let go between runs, unless another shares first.
@@ -435,7 +470,7 @@ export const createSharing = (host: SharingHost) => {
                 if (tasks === null) return;
                 for (const [index, error] of message.errors) {
                     const finalizer = tasks.finalizerAt(index);
-                    if (finalizer !== undefined) host.defer(failureOf("finalizer", labelOfItem(finalizer), Object.assign(new Error(error.message), { name: error.name, stack: error.stack })));
+                    if (finalizer !== undefined) host.report(failureOf("finalizer", finalizer, Object.assign(new Error(error.message), { name: error.name, stack: error.stack })));
                 }
                 return;
             }
@@ -471,13 +506,21 @@ export const createSharing = (host: SharingHost) => {
             case "observer failed": {
                 for (const [index, error] of message.errors) {
                     const placed = thread.observer?.placed[index];
-                    if (placed !== undefined) host.defer(failureOf("system", placed.label, Object.assign(new Error(error.message), { name: error.name, stack: error.stack })));
+                    if (placed !== undefined) host.report(failureOf("system", { name: placed.label, id: placed.id }, Object.assign(new Error(error.message), { name: error.name, stack: error.stack }), placed));
+                }
+                return;
+            }
+            case "observer ran": {
+                for (const [index, value, error] of message.results) {
+                    const placed = thread.observer?.placed[index];
+                    if (placed !== undefined) ranThere(state, placed, value, error === null ? undefined : Object.assign(new Error(error.message), { name: error.name, stack: error.stack }));
                 }
                 return;
             }
             case "observer dropped": return thread.observer === null ? undefined : droppedObserver(state, thread.observer, message.indexes);
             case "observer again": return state.observer.again?.();
             case "wake": return drain(thread);
+            case "ready": return ready(thread);
             case "leave": {
                 gone(thread, true);
                 return free(thread);
@@ -485,26 +528,46 @@ export const createSharing = (host: SharingHost) => {
         }
     };
 
-    /** Lets a thread join through `port`: `"joining"`, with no claims. */
-    const share = (port: Parameters<World["share"]>[0]): void => {
+    /** By port, the thread sharing it last: a port is shared once while that thread lives. */
+    const sharedPorts = new WeakMap<object, Joined>();
+
+    /** Lets a thread join through `port`: `"joining"`, with no claims. Resolves once it has joined; rejects saying why it didn't. */
+    const share = (port: Parameters<World["share"]>[0]): Promise<void> => {
+        const earlier = sharedPorts.get(port);
+        if (earlier !== undefined && earlier.status !== "gone") return Promise.reject(new Error("The port is shared already, with a thread that hasn't left."));
+        let settle: Joined["settle"] = null;
+        const joined = new Promise<void>((resolve, reject) => { settle = { resolve, reject }; });
         const thread: Joined = {
             channel: threadChannel<ToJoined, ToWorld>(port), status: "joining", claims: [], control: null, views: [], waits: true,
             names: new Map(), next: 1, completed: 0, finished: new Set(), inputs: new Map(), moved: new Map(), peers: new Set(), woken: false,
             abort: new AbortController(), log: null, number: ++numbered, imported: new Set(), tasks: null, observer: null, proxies: new Map(),
+            settle,
         };
         threads.add(thread);
         byNumber.set(thread.number, thread);
+        sharedPorts.set(port, thread);
         // From now on the thread may read strings, which it reads out of their records.
         if (state.strings !== null) keepRecords(state.strings, state.archetypes);
         show(thread, "joining");
         thread.channel.onMessage(message => { if (thread.status !== "gone" || message.kind === "leave") receive(thread, message); });
         thread.channel.onClose(() => gone(thread));
+        // A worker that failed before it joined never will; one that joined goes on, as a browser worker that threw does.
+        thread.channel.onFailure(message => {
+            if (thread.status !== "joining") return;
+            thread.settle?.reject(new Error(`The thread failed before it joined: ${message}`));
+            thread.settle = null;
+            gone(thread);
+        });
+        // A port whose other end closed before it was shared hears no close.
+        if (thread.channel.closed()) gone(thread);
+        else tellLock(thread);
+        return joined;
     };
 
     /**
      * A joined thread's own observer system, declared by its number for it: the world's value standing for it, which
      * runs on that thread, with the keys and indexes it names by id; a run of that number runs it. One the world can't
-     * declare, naming a key or index it never imported, is a failure in the next run's report.
+     * declare, naming a key or index it never imported, is reported out of band, and its runs reject.
      */
     /** Indexes made for joined threads' observer systems from declarations without ids, by what they declare, kept while the world lives. */
     const madeIndexes = new Map<string, ReturnType<typeof indexDefinitionOf>>();
@@ -519,7 +582,7 @@ export const createSharing = (host: SharingHost) => {
         let index = madeIndexes.get(identity);
         if (index === undefined) {
             // `Index.create` checks the declaration as the joined thread's was checked.
-            index = indexDefinitionOf(Reflect.apply(Index.create, undefined, [{ name: declared.name, key, sorted: declared.sorted, unique: declared.unique, components: { has, not } }]));
+            index = indexDefinitionOf(Reflect.apply(Index.create, undefined, [{ name: declared.name, key, sorted: declared.sorted, unique: declared.unique, components: { with: has, not } }]));
             madeIndexes.set(identity, index);
         }
         return index;
@@ -537,10 +600,10 @@ export const createSharing = (host: SharingHost) => {
                 for (const [field, numbers] of entries) if (numbers !== null && (numbers.length > 0 || field === "changed")) result[field] = keys(numbers);
                 return result;
             };
-            const lookup: { [name: string]: object } = {};
+            const lookup: { [name: string]: SystemLookupLists } = {};
             for (const each of declared.lookup) {
                 if (each.index === null) {
-                    lookup[each.name] = listed([["read", each.read], ["has", each.has], ["not", each.not], ["changed", each.changed]]);
+                    lookup[each.name] = listed([["read", each.read], ["has", each.has], ["optional", each.optional], ["not", each.not], ["changed", each.changed]]);
                     continue;
                 }
                 const index = typeof each.index === "string" ? indexDefinitionOf(itemOfId(each.index)) : madeIndex(thread, each.index);
@@ -549,19 +612,20 @@ export const createSharing = (host: SharingHost) => {
             }
             const { components, resources } = declared;
             // Unnamed, so other systems' labels stay as they are; its own is the thread's.
-            const declaration = {
+            const declaration: Resolved = {
                 observer: true,
-                ...components === null ? {} : { components: listed([["read", components.read], ["has", components.has], ["not", components.not], ["added", components.added], ["changed", components.changed]]) },
+                // Its `where` runs on its thread; here, an empty one says it has one, which every archetype passes.
+                ...components === null ? {} : { components: { ...listed([["read", components.read], ["has", components.has], ["optional", components.optional], ["not", components.not], ["added", components.added], ["changed", components.changed]]), ...components.where ? { where: {} } : {} } },
                 ...resources === null ? {} : { resources: listed([["read", resources.read], ["changed", resources.changed], ["is", resources.is], ["not", resources.not]]) },
                 ...declared.lookup.length === 0 ? {} : { lookup },
             };
-            // `System.create` checks the declaration as the joined thread's was checked; its body runs only there.
-            const created = requireDefinition(Reflect.apply(System.create, undefined, [declaration, () => {}]));
+            // Checked as the joined thread's was; its body runs only there.
+            const created = requireDefinition(createResolved(declaration, () => {}));
             if (created.kind === "composite") return;
             proxy = created;
         }
         catch (error) {
-            host.defer(failureOf("system", name, error));
+            host.report(failureOf("system", { name, id: null }, error));
             // Its runs reject.
             thread.names.set(number, { id: `#observer:${number}`, value: null });
             drain(thread);

package/src/implementation/world/staging.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Entity } from '../../interface/entity/entity.js';
 import { viewsOf, type Layout, type Views } from '../../interface/registry/layout.js';
 import { writeF32, writeF32Lanes, writeF64, writeI32, writeOf, writeU32, type Archetype } from './archetype.js';
@@ -27,12 +28,23 @@ export type Column = {
 export type SpawnBatch = {
     /** Sorted component ids. */
     readonly ids: readonly number[];
-    /** The archetype of `ids`, found at the first sync point the batch commits at. */
+    /**
+     * By component id, the number of each shared component's value its spawns hold, which their archetype holds once:
+     * interned again as the batch is revived.
+     */
+    shared: readonly (number | undefined)[];
+    /** The archetype of `ids`, found at the first sync point the batch commits at, and its generation then. */
     archetype: Archetype | null;
+    generation: number;
     readonly columns: readonly Column[];
     entities: Float64Array;
     count: number;
     capacity: number;
+    /**
+     * Set once the batch was let go of with a value it holds (`batches.ts`), its capacity 0, so a spawner still holding
+     * it revives it as it next opens a row; null otherwise.
+     */
+    revive: (() => void) | null;
 };
 
 /** Writes one value into row `row` of a column, specialized to the column's layout when the spawner is made. */
@@ -43,18 +55,27 @@ export type Positional = (...values: unknown[]) => Entity;
 
 const initialCapacity = 64;
 
+/** The shared values of a batch without shared components: none. */
+const noShared: readonly (number | undefined)[] = [];
+
 const columnOf = (layout: Layout, id: number, capacity: number): Column => {
     const stride = layout.kind === "linear" ? layout.stride : 0;
     return { id, layout, ...writeOf(layout), stride, views: viewsOf(new ArrayBuffer(capacity * stride), 0, capacity * stride), values: [], remote: null };
 };
 
 /** An empty batch of spawns of exactly these components, by their layouts. */
-export const createBatch = (layouts: readonly Layout[], ids: readonly number[]): SpawnBatch => {
+export const createBatch = (layouts: readonly Layout[], ids: readonly number[], shared: readonly (number | undefined)[] = noShared): SpawnBatch => {
     const sorted = [...ids].sort((a, b) => a - b);
-    return { ids: sorted, archetype: null, columns: sorted.map(id => columnOf(layouts[id], id, initialCapacity)), entities: new Float64Array(initialCapacity), count: 0, capacity: initialCapacity };
+    return { ids: sorted, shared, archetype: null, columns: sorted.map(id => columnOf(layouts[id], id, initialCapacity)), entities: new Float64Array(initialCapacity), count: 0, capacity: initialCapacity, revive: null, generation: 0 };
 };
 
 const grow = (batch: SpawnBatch): void => {
+    const { revive } = batch;
+    if (revive !== null) {
+        batch.revive = null;
+        revive();
+        if (batch.count < batch.capacity) return;
+    }
     const capacity = batch.capacity * 2;
     for (const column of batch.columns) {
         const views = viewsOf(new ArrayBuffer(capacity * column.stride), 0, capacity * column.stride);
@@ -150,23 +171,45 @@ const store = (column: Column, k: number, value: string): string => {
     }
 };
 
+/** Statements copying a value encoded once into the column's layout, `e${k}`, into row `row`: by word where it has whole words. */
+const copy = (column: Column, k: number): string => (column.stride & 3) === 0
+    ? `{ const e = e${k}, d = c${k}.views.u32, at = row * ${column.stride >> 2}; for (let i = 0; i < ${column.stride >> 2}; i++) d[at + i] = e[i]; }`
+    : `{ const e = e${k}, d = c${k}.views.u8, at = row * ${column.stride}; for (let i = 0; i < ${column.stride}; i++) d[at + i] = e[i]; }`;
+
+/** A value encoded once in a column's layout, as `generated` copies it into each spawn: words where it has whole words. */
+export const encodedIn = (column: Column, value: unknown): Uint32Array | Uint8Array | null => {
+    if (column.layout.kind !== "linear") return null;
+    const views = viewsOf(new ArrayBuffer(column.stride), 0, column.stride);
+    column.layout.write(views, 0, value);
+    return (column.stride & 3) === 0 ? views.u32 : views.u8;
+};
+
+/** What a spawner's parameter `values = none` takes when its call gives nothing: none of them. */
+export const noValues: { readonly [key: symbol]: unknown } = {};
+
+/** Keys a spawner's `values` must not give, each given failing through `refuse`: a spawn's constants. */
+export type Guarded = { readonly keys: readonly unknown[]; readonly refuse: (key: unknown) => never };
+
 /**
  * A function generated to spawn into `batch`, taking `parameters`: one straight-line store per column, of the value
  * expression `values[k]` gives, which may name key `k${k}` of `keys`, so each store sees one layout and each read one
- * object shape, then reserves its entity with `take(entities)`. Only numbers are written into the code: keys, columns
- * and writers are its arguments. Null where code can't be generated.
+ * object shape, or a copy of a value `encoded` once for every spawn, then reserves its entity with `take(entities)`.
+ * Only numbers are written into the code: keys, columns, writers and encoded values are its arguments. Null where code
+ * can't be generated. With `guarded`, it first refuses each of its keys its parameter `values` gives.
  */
-export const generated = <F, E = Reservations>(entities: E, take: (entities: E) => Entity, batch: SpawnBatch, parameters: readonly string[], keys: readonly unknown[], columns: readonly Column[], writers: readonly Writer[], values: (k: number) => string): F | null => {
+export const generated = <F, E = Reservations>(entities: E, take: (entities: E) => Entity, batch: SpawnBatch, parameters: readonly string[], keys: readonly unknown[], columns: readonly Column[], writers: readonly Writer[], values: (k: number) => string, encoded: readonly (Uint32Array | Uint8Array | null)[] = [], guarded: Guarded | null = null): F | null => {
     if (!generating) return null;
+    const guards = guarded === null ? [] : guarded.keys.map((_, g) => `if (values[g${g}] !== undefined) refuse(g${g});`);
     const body = [
-        `return (${parameters.join(", ")}) => {`, "const row = openRow(batch);", "let v;",
-        ...columns.map((column, k) => store(column, k, values(k))),
+        `return (${parameters.join(", ")}) => {`, ...guards, "const row = openRow(batch);", "let v;",
+        ...columns.map((column, k) => encoded[k] === null || encoded[k] === undefined ? store(column, k, values(k)) : copy(column, k)),
         "const entity = take(entities);", "claim(batch, entity);", "return entity;", "};",
     ].join("\n");
     try {
-        const factory = new Function("batch", "entities", "openRow", "claim", "take", ...columns.flatMap((_, k) => [`k${k}`, `c${k}`, `w${k}`]), body);
+        const guardKeys = guarded?.keys ?? [];
+        const factory = new Function("batch", "entities", "openRow", "claim", "take", "refuse", "none", ...columns.flatMap((_, k) => [`k${k}`, `c${k}`, `w${k}`, `e${k}`]), ...guardKeys.map((_, g) => `g${g}`), body);
         // The factory returns the function its body above makes.
-        const made: F = factory(batch, entities, openRow, claim, take, ...columns.flatMap((_, k) => [keys[k], columns[k], writers[k]]));
+        const made: F = factory(batch, entities, openRow, claim, take, guarded?.refuse ?? null, noValues, ...columns.flatMap((_, k) => [keys[k], columns[k], writers[k], encoded[k] ?? null]), ...guardKeys);
         return made;
     }
     catch {