@astrosheep/keiyaku 4.5.29 → 4.6.2

package/build/src/library/{fleet.js → selection.js}

@@ -1,23 +1,95 @@
 /** @architectureCompositionRoot */
-import { AkumaNotBornError, readBudgetedStatus, withoutReportedChanges, } from "../akuma/akuma.js";
-import { AkumaObservationError } from "../akuma/akuma-errors.js";
-import { createAkumaProduct } from "../akuma/akuma-product.js";
+import { withoutReportedChanges } from "../akuma/projection.js";
+import { AkumaNotBornError, AkumaObservationError } from "../akuma/akuma-errors.js";
+import { AkumaOwner } from "../akuma/akuma-owner.js";
+import { decodeAskObservation, executeAskAkuma, executeKillAkuma, executeTellAkuma, } from "../akuma/akuma-selection-execution.js";
+import { executeWaitAkuma, } from "../akuma/akuma-wait.js";
+import { parsePublicHistoryId } from "../akuma/identity.js";
 import { executionChannel, localExecutionContext } from "../akuma/requests.js";
-import { requestForwardedFleetKill, requestForwardedFleetTell, requestForwardedFleetTellWait, requestForwardedFleetWait, } from "../akuma/fleet-request.js";
-import { executeKillAkuma, executeTellAkuma, executeTellWaitAkuma, executeWaitAkuma, } from "../akuma/fleet-execution.js";
+import { schemaJsonText } from "../akuma/schema.js";
+import { requestForwardedSelectionAsk, requestForwardedSelectionKill, requestForwardedSelectionTell, requestForwardedSelectionWait, } from "../akuma/selection-request.js";
 import { readAliases } from "../alias/index.js";
 import { observeDispatchAssociation } from "../dispatch/index.js";
 import { observeContractAt } from "../git/observe.js";
 import { withGitDecodeChannel } from "../git/read-observation.js";
 import { observeCreatedTaskObservations } from "../task/created-observation.js";
-import { schemaJsonText } from "../akuma/schema.js";
 import { addressAkuma, addressAkumaSet, resolveAkuma, resolveAkumaSet, } from "./address.js";
 import { requireInput } from "./input.js";
-import { fleetResultSchemas, parseAkumaObservation, } from "../akuma/fleet-observation.js";
 import { scopeForRepo } from "./repo.js";
-import { parsePublicHistoryId } from "../akuma/identity.js";
-function source(path) {
-    return createAkumaProduct(path);
+export function selectionSeam(execution) {
+    const channel = executionChannel(execution);
+    return channel.kind === "body-request" ? forwardedSelection(channel.directory) : localSelection();
+}
+function forwardedSelection(directory) {
+    return {
+        addressOne: resolveAkuma,
+        addressSet: resolveAkumaSet,
+        wait: async (addressed, mode) => await forwardedWait(addressed, { ...mode, directory }),
+        kill: async (addressed, abort) => await requestForwardedSelectionKill({
+            directory,
+            targets: addressed.orderedIds,
+            ...(abort === undefined ? {} : { signal: abort }),
+        }),
+        tell: async (addressed, input, abort) => await requestForwardedSelectionTell({
+            directory,
+            target: addressed.id,
+            body: input.body,
+            ...(input.interrupt === true ? { interrupt: true } : {}),
+            ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
+            ...(abort === undefined ? {} : { signal: abort }),
+        }),
+        ask: async (addressed, input, abort) => {
+            const result = await requestForwardedSelectionAsk({
+                directory,
+                target: addressed.id,
+                body: input.body,
+                ...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs }),
+                ...(input.schema === undefined ? {} : { schema: input.schema }),
+                ...(input.interrupt === true ? { interrupt: true } : {}),
+                ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
+                ...(abort === undefined ? {} : { signal: abort }),
+            });
+            return (input.schema === undefined
+                ? result
+                : { ...result, observation: decodeAskObservation(result.observation, input.schema) });
+        },
+    };
+}
+function localSelection() {
+    return {
+        addressOne: addressAkuma,
+        addressSet: addressAkumaSet,
+        wait: async (addressed, mode, observer) => await localWait(addressed, { ...mode, ...(observer === undefined ? {} : { observer }) }),
+        kill: async (addressed, abort) => await executeKillAkuma({
+            path: addressed.path,
+            ids: addressed.orderedIds,
+            ...(abort === undefined ? {} : { signal: abort }),
+        }),
+        tell: async (addressed, input, abort) => await executeTellAkuma({
+            path: addressed.path,
+            id: addressed.id,
+            body: input.body,
+            ...(input.interrupt === true ? { interrupt: true } : {}),
+            ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
+            ...(abort === undefined ? {} : { signal: abort }),
+        }),
+        ask: async (addressed, input, abort) => {
+            const result = await executeAskAkuma({
+                path: addressed.path,
+                id: addressed.id,
+                body: input.body,
+                ...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs }),
+                ...(input.schema === undefined ? {} : { schemaJson: schemaJsonText(input.schema) }),
+                ...(input.interrupt === true ? { interrupt: true } : {}),
+                ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
+                ...(input.observe === undefined ? {} : { onObserve: input.observe }),
+                ...(abort === undefined ? {} : { signal: abort }),
+            });
+            return (input.schema === undefined
+                ? result
+                : { ...result, observation: decodeAskObservation(result.observation, input.schema) });
+        },
+    };
 }
 function observationDiagnostic(error) {
     return error instanceof Error ? error.message : String(error);
@@ -86,32 +158,23 @@ function waitIdentityFacts(path, repo) {
     };
 }
 async function observeAkuma(status, path, repo) {
-    return (await observeAkumaSet([status], path, repo))[0];
+    return (await composeAkumaAssociations([status], path, repo))[0];
 }
-async function observeAkumaStage(path, id, repo, admittedTellId) {
-    try {
-        const observed = await readBudgetedStatus(path, id, {
-            aperture: "receipt",
-            ...(admittedTellId === undefined ? {} : { admittedTellId }),
-        });
-        return { kind: "observed", ...(await observeAkuma(observed.status, path, repo)) };
-    }
-    catch (error) {
-        if (error instanceof AkumaNotBornError)
-            throw error;
-        return { kind: "unobserved", diagnostic: observationDiagnostic(error) };
-    }
-}
-async function observeAkumaSet(statuses, path, repo) {
+/**
+ * The one upper composition of association-free native status evidence into its
+ * public observation shape. It reads Alias-independent Dispatch and Task
+ * associations after the lower values, never before or inside them.
+ */
+async function composeAkumaAssociations(statuses, path, repo) {
     const created = await createdTasksFor(path, statuses);
     const discharged = placementDischarged(repo);
     return await Promise.all(statuses.map(async (status, index) => {
         const contract = await dispatchAssociation(repo, status.id);
-        return parseAkumaObservation({
+        return {
             status: await composeObservation(status, contract, discharged),
             contract,
             createdTasks: created[index],
-        });
+        };
     }));
 }
 function timeout(value) {
@@ -129,19 +192,29 @@ function signal(value) {
         throw new TypeError("signal must be an AbortSignal");
     return value;
 }
+/**
+ * Compose one wait's association-free native evidence into its public
+ * observation shape, attaching the same upper associations as a single-status
+ * observation.
+ */
+async function composeWaitResult(path, repo, result) {
+    return {
+        mode: result.mode,
+        reason: result.reason,
+        observations: await composeAkumaAssociations(result.observations, path, repo),
+        unobserved: result.unobserved,
+    };
+}
+/**
+ * Re-attach upper associations after a wait result crosses a forwarded
+ * boundary; the serving side must observe its own Dispatch and Task state.
+ */
 async function attachWaitAssociations(path, repo, result) {
-    const created = await createdTasksFor(path, result.observations.map((observation) => observation.status));
-    const discharged = placementDischarged(repo);
-    return fleetResultSchemas.wait.parse({
-        ...result,
-        observations: await Promise.all(result.observations.map(async (observation, index) => {
-            const contract = await dispatchAssociation(repo, observation.status.id);
-            return parseAkumaObservation({
-                status: await composeObservation(observation.status, contract, discharged),
-                contract,
-                createdTasks: created[index],
-            });
-        })),
+    return await composeWaitResult(path, repo, {
+        mode: result.mode,
+        reason: result.reason,
+        observations: result.observations.map((observation) => observation.status),
+        unobserved: result.unobserved,
     });
 }
 function directAddress(values) {
@@ -161,7 +234,7 @@ function setAddress(values) {
 export async function statusAkuma(input) {
     const addressed = await addressAkuma(input);
     try {
-        return await observeAkuma(await source(addressed.path).selectHandle({ id: addressed.id }).status(), addressed.path, input.repo);
+        return await observeAkuma(await new AkumaOwner(addressed.id, addressed.path).status(), addressed.path, input.repo);
     }
     catch (error) {
         throw observationError(addressed.id, error);
@@ -176,7 +249,7 @@ function completionMode(value) {
     return value;
 }
 async function forwardedWait(addressed, input) {
-    return await attachWaitAssociations(addressed.path, input.repo, await requestForwardedFleetWait({
+    return await attachWaitAssociations(addressed.path, input.repo, await requestForwardedSelectionWait({
         directory: input.directory,
         targets: addressed.orderedIds,
         completion: input.completion,
@@ -186,7 +259,7 @@ async function forwardedWait(addressed, input) {
 }
 async function localWait(addressed, input) {
     try {
-        return await attachWaitAssociations(addressed.path, input.repo, await executeWaitAkuma({
+        return await composeWaitResult(addressed.path, input.repo, await executeWaitAkuma({
             path: addressed.path,
             ids: addressed.orderedIds,
             completion: input.completion,
@@ -204,155 +277,99 @@ async function localWait(addressed, input) {
         throw observationError(addressed.orderedIds[0], error);
     }
 }
-export async function waitAkuma(input, execution = localExecutionContext(), observer) {
+export async function waitAkuma(input, execution = localExecutionContext()) {
+    return await waitAkumaOn(selectionSeam(execution), input);
+}
+function waitObserver(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        throw new TypeError("observe must be a WaitObserver");
+    const record = value;
+    for (const key of Object.keys(record)) {
+        if (key !== "selected" && key !== "observe")
+            throw new TypeError(`observe has unknown field: ${key}`);
+        if (record[key] !== undefined && typeof record[key] !== "function")
+            throw new TypeError(`observe.${key} must be a function`);
+    }
+    return {
+        ...(record.selected === undefined
+            ? {}
+            : { selected: record.selected }),
+        ...(record.observe === undefined
+            ? {}
+            : { observe: record.observe }),
+    };
+}
+export async function waitAkumaOn(seam, input) {
     const values = requireInput(input, "Akumas.wait input");
     for (const key of Object.keys(values)) {
-        if (!["path", "akuma", "repo", "completion", "timeoutMs", "signal"].includes(key)) {
+        if (!["path", "akuma", "repo", "completion", "timeoutMs", "signal", "observe"].includes(key)) {
             throw new TypeError(`Akumas.wait input has unknown field: ${key}`);
         }
     }
+    const observer = waitObserver(values.observe);
     const selected = completionMode(values.completion);
     const timeoutMs = timeout(values.timeoutMs);
     const callerSignal = signal(values.signal);
-    const channel = executionChannel(execution);
     const repo = values.repo;
-    const mode = {
+    const addressed = await seam.addressSet(setAddress(values));
+    return await seam.wait(addressed, {
         completion: selected,
         ...(timeoutMs === undefined ? {} : { timeoutMs }),
         ...(callerSignal === undefined ? {} : { signal: callerSignal }),
         ...(repo === undefined ? {} : { repo }),
-    };
-    if (channel.kind === "body-request") {
-        // A forwarded operation resolves coordinates without proving birth: the
-        // parent Fleet owns the target, so this process never probes locally.
-        const addressed = await resolveAkumaSet(setAddress(values));
-        return await forwardedWait(addressed, { ...mode, directory: channel.directory });
-    }
-    const addressed = await addressAkumaSet(setAddress(values));
-    return await localWait(addressed, { ...mode, ...(observer === undefined ? {} : { observer }) });
+    }, observer);
 }
-export async function killAkuma(input, execution = localExecutionContext()) {
+export async function killAkumaOn(seam, input) {
     const values = requireInput(input, "Akumas.kill input");
     for (const key of Object.keys(values)) {
         if (!["path", "akuma", "repo", "signal"].includes(key)) {
             throw new TypeError(`Akumas.kill input has unknown field: ${key}`);
         }
     }
-    const callerSignal = signal(values.signal);
-    const channel = executionChannel(execution);
-    if (channel.kind === "body-request") {
-        const addressed = await resolveAkumaSet(setAddress(values));
-        return await requestForwardedFleetKill({
-            directory: channel.directory,
-            targets: addressed.orderedIds,
-            ...(callerSignal === undefined ? {} : { signal: callerSignal }),
-        });
-    }
-    const addressed = await addressAkumaSet(setAddress(values));
-    return await executeKillAkuma({
-        path: addressed.path,
-        ids: addressed.orderedIds,
-        ...(callerSignal === undefined ? {} : { signal: callerSignal }),
-    });
+    return await seam.kill(await seam.addressSet(setAddress(values)), signal(values.signal));
 }
 export async function tellAkuma(input, execution = localExecutionContext()) {
+    return await tellAkumaOn(selectionSeam(execution), input);
+}
+export async function tellAkumaOn(seam, input) {
     const values = requireInput(input, "Akumas.tell input");
     for (const key of Object.keys(values)) {
-        if (!["path", "akuma", "body", "repo", "initiator", "signal"].includes(key)) {
+        if (key === "schema")
+            throw new TypeError("Akumas.tell does not accept schema; use Akumas.ask");
+        if (!["path", "akuma", "body", "repo", "interrupt", "initiator", "signal"].includes(key)) {
             throw new TypeError(`Akumas.tell input has unknown field: ${key}`);
         }
     }
     if (typeof values.body !== "string")
         throw new TypeError("body must be a string");
-    const callerSignal = signal(values.signal);
-    const channel = executionChannel(execution);
-    if (channel.kind === "body-request") {
-        const addressed = await resolveAkuma(directAddress(values));
-        return await requestForwardedFleetTell({
-            directory: channel.directory,
-            target: addressed.id,
-            body: values.body,
-            ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
-            ...(callerSignal === undefined ? {} : { signal: callerSignal }),
-        });
-    }
-    const addressed = await addressAkuma(directAddress(values));
-    return await executeTellAkuma({
-        path: addressed.path,
-        id: addressed.id,
-        body: values.body,
-        ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
-        ...(callerSignal === undefined ? {} : { signal: callerSignal }),
-    });
+    if (values.interrupt !== undefined && typeof values.interrupt !== "boolean")
+        throw new TypeError("interrupt must be a boolean");
+    return await seam.tell(await seam.addressOne(directAddress(values)), input, signal(values.signal));
 }
-function validateTellWaitInput(values) {
+function validateAskInput(values) {
     for (const key of Object.keys(values)) {
         if (!["path", "akuma", "body", "repo", "timeoutMs", "schema", "interrupt", "initiator", "signal", "observe"].includes(key)) {
-            throw new TypeError(`Akumas tell wait input has unknown field: ${key}`);
+            throw new TypeError(`Akumas.ask input has unknown field: ${key}`);
         }
     }
     if (typeof values.body !== "string")
         throw new TypeError("body must be a string");
-    if (typeof values.timeoutMs !== "number" ||
-        !Number.isFinite(values.timeoutMs) ||
-        !Number.isInteger(values.timeoutMs) ||
-        values.timeoutMs < 0) {
+    if (values.timeoutMs !== undefined &&
+        (typeof values.timeoutMs !== "number" ||
+            !Number.isFinite(values.timeoutMs) ||
+            !Number.isInteger(values.timeoutMs) ||
+            values.timeoutMs < 0)) {
         throw new TypeError("timeoutMs must be a nonnegative finite millisecond duration");
     }
     if (values.interrupt !== undefined && typeof values.interrupt !== "boolean")
         throw new TypeError("interrupt must be a boolean");
 }
-export async function tellWaitAkuma(input, execution = localExecutionContext()) {
-    const values = requireInput(input, "Akumas tell wait input");
-    validateTellWaitInput(values);
-    const callerSignal = signal(values.signal);
-    const channel = executionChannel(execution);
-    if (channel.kind === "body-request") {
-        // A forwarded Tell is resolved by its serving parent, so this process must
-        // not prove the target against its own Heart files.
-        const addressed = await resolveAkuma(directAddress(values));
-        return await requestForwardedFleetTellWait({
-            directory: channel.directory,
-            target: addressed.id,
-            body: values.body,
-            timeoutMs: values.timeoutMs,
-            ...(input.schema === undefined ? {} : { schema: input.schema }),
-            ...(input.interrupt === true ? { interrupt: true } : {}),
-            ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
-            ...(callerSignal === undefined ? {} : { signal: callerSignal }),
-        });
-    }
-    const addressed = await addressAkuma(directAddress(values));
-    return await executeTellWaitAkuma({
-        path: addressed.path,
-        id: addressed.id,
-        body: values.body,
-        timeoutMs: values.timeoutMs,
-        ...(input.schema === undefined ? {} : { schemaJson: schemaJsonText(input.schema) }),
-        ...(input.interrupt === true ? { interrupt: true } : {}),
-        ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
-        ...(input.observe === undefined ? {} : { onObserve: input.observe }),
-        ...(callerSignal === undefined ? {} : { signal: callerSignal }),
-    });
-}
-export async function interruptAkuma(input) {
-    const values = requireInput(input, "Akumas.interrupt input");
-    for (const key of Object.keys(values)) {
-        if (!["path", "akuma", "body", "repo", "initiator", "signal"].includes(key)) {
-            throw new TypeError(`Akumas.interrupt input has unknown field: ${key}`);
-        }
-    }
-    if (typeof values.body !== "string")
-        throw new TypeError("body must be a string");
-    const callerSignal = signal(values.signal);
-    const addressed = await addressAkuma(directAddress(values));
-    const handle = source(addressed.path).selectHandle({ id: addressed.id });
-    const receipt = await handle.interrupt(values.body, {
-        ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
-        ...(callerSignal === undefined ? {} : { signal: callerSignal }),
-    });
-    const observation = await observeAkumaStage(addressed.path, addressed.id, values.repo);
-    return { id: addressed.id, receipt, observation };
+export async function askAkumaOn(seam, input) {
+    const values = requireInput(input, "Akumas.ask input");
+    validateAskInput(values);
+    return await seam.ask(await seam.addressOne(directAddress(values)), input, signal(values.signal));
 }
 function validateHistoryInput(values) {
     for (const key of Object.keys(values)) {
@@ -374,7 +391,7 @@ export async function historyAkuma(input) {
     validateHistoryInput(values);
     const addressed = await addressAkuma(directAddress(values));
     try {
-        const handle = source(addressed.path).selectHandle({ id: addressed.id });
+        const handle = new AkumaOwner(addressed.id, addressed.path);
         const contract = await dispatchAssociation(values.repo, addressed.id);
         if (values.last === true) {
             const answer = await handle.lastAnswer();

package/build/src/plugin/public.d.ts

@@ -29,6 +29,7 @@ export type PluginSignalMap = Readonly<{
         bodySequence: number;
         turnSequence: number;
         initiator?: string;
+        participants?: readonly string[];
         outcome: PluginOutcome;
         contractId?: string;
     }>;
@@ -37,6 +38,7 @@ export type PluginSignalMap = Readonly<{
         bodySequence: number;
         end: PluginBodyEnd;
         initiator?: string;
+        participants?: readonly string[];
         diagnostic?: string;
         contractId?: string;
     }>;

package/build/src/protocol/abandon.d.ts

@@ -1,4 +1,4 @@
-import { type AbandonRefusal } from "../core/verbs/abandon.js";
+import type { ActiveContractRefusal } from "../core/facts/observation.js";
 import type { GitTreeSelection } from "../git/read-observation.js";
 import type { CompanionDecorator } from "./run.js";
 import type { IntentOutcome, MutationOperationInput } from "./operations.js";
@@ -6,4 +6,4 @@ export declare function abandonOperation(input: MutationOperationInput & Readonl
     note?: string;
     decorateOffer?: CompanionDecorator;
     observationSelection?: GitTreeSelection;
-}>): Promise<IntentOutcome<void, AbandonRefusal>>;
+}>): Promise<IntentOutcome<void, ActiveContractRefusal>>;

package/build/src/protocol/abandon.js

@@ -11,5 +11,6 @@ export async function abandonOperation(input) {
     }, decideAbandon, {
         ...(input.decorateOffer === undefined ? {} : { decorateOffer: input.decorateOffer }),
         ...(input.observationSelection === undefined ? {} : { observationSelection: input.observationSelection }),
+        ...(input.progress === undefined ? {} : { progress: input.progress }),
     }), undefined);
 }

package/build/src/protocol/amend.js

@@ -70,6 +70,7 @@ export async function amendOperation(input) {
                 attempt: attempts[index],
                 offer: decision.offer,
                 primaryContract: input.contractId,
+                ...(input.progress === undefined ? {} : { progress: input.progress }),
             });
             if (admission.kind === "accepted") {
                 if (amendment === undefined)

package/build/src/protocol/arc.d.ts

@@ -1,6 +1,8 @@
-import type { ArcData } from "../core/facts/types.js";
-import { type ArcRefusal } from "../core/verbs/arc.js";
+import type { ActiveContractRefusal } from "../core/facts/observation.js";
 import type { IntentOutcome, MutationOperationInput } from "./operations.js";
 export declare function arcOperation(input: MutationOperationInput & Readonly<{
-    chapter: Omit<ArcData, "seq">;
-}>): Promise<IntentOutcome<void, ArcRefusal>>;
+    chapter: Readonly<{
+        title: string;
+        body: string;
+    }>;
+}>): Promise<IntentOutcome<void, ActiveContractRefusal>>;

package/build/src/protocol/attempt.d.ts

@@ -1,4 +1,5 @@
-import type { ExecutionProgress } from "./progress.js";
+import { z } from "zod";
+import type { ProtocolProgress } from "./progress.js";
 import { type PublicationFailed } from "../git/admission.js";
 import { type GitDecisionObservation } from "../git/observe.js";
 import { type PrivateStatePublicationSeat, type PrivateStateSeatCloseLag } from "../git/private-state-seat.js";
@@ -8,6 +9,7 @@ import type { GitRepository } from "../git/process.js";
 import type { AttemptContext } from "../core/decide.js";
 import type { Offer } from "../core/facts/offer.js";
 import { type ContractId, type ContractState, type EntryUlid, type JournalEntry } from "../core/facts/types.js";
+export declare const entryUlidSchema: z.ZodPipe<z.ZodString, z.ZodTransform<EntryUlid, string>>;
 export declare function mintEntryUlids(count: number): readonly EntryUlid[];
 export declare function mintAttempts(input: Readonly<{
     entryCount: number;
@@ -53,7 +55,7 @@ export declare function admitDecidedOffer<Refusal = never>(input: Readonly<{
     primaryContract: ContractId;
     assertions?: readonly GitRefAssertion[];
     validateAdmission?: (observation: GitDecisionObservation) => Refusal | undefined | Promise<Refusal | undefined>;
-    progress?: ExecutionProgress;
+    progress?: ProtocolProgress;
 }>): Promise<DecidedOfferResult<Refusal>>;
 /** Classify an unknown atomic-publication outcome using only a captured Git observation. */
 export declare function classifyUnknownAttempt(observation: Readonly<{

package/build/src/protocol/attempt.js

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import { randomBytes } from "node:crypto";
 import { encodeEntry } from "../core/facts/codec.js";
 import { admit } from "../git/admission.js";
@@ -8,6 +9,15 @@ import { GIT_REF, readRefs } from "../git/repository.js";
 import { foldJournal } from "../core/facts/fold.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { entryUlid, } from "../core/facts/types.js";
+export const entryUlidSchema = z.string().transform((value, context) => {
+    try {
+        return entryUlid(value);
+    }
+    catch {
+        context.addIssue({ code: "custom", message: "invalid entryUlid" });
+        return z.NEVER;
+    }
+});
 const ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
 const MAX_SEMANTIC_ATTEMPTS = 3;
 function nextEntryUlid() {