@vercel/factory 0.0.13 → 0.0.15

package/dist/schema/task-graph.mjs

@@ -0,0 +1,97 @@
+import { taskIdSchema } from "./id.mjs";
+import { isoDateTimeSchema, schemaVersionSchema } from "./common.mjs";
+import { taskSchema } from "./task.mjs";
+import { z } from "zod";
+//#region src/schema/task-graph.ts
+/** Maximum number of Tasks admitted to one canonical root graph. */
+const MAX_TASK_GRAPH_NODES = 256;
+/** Maximum explicit dependencies allowed on one Task graph node. */
+const MAX_TASK_GRAPH_DEPENDENCIES = 255;
+/** Validates a bounded, duplicate-free list of canonical Task dependencies. */
+const taskGraphDependenciesSchema = z.array(taskIdSchema).max(255).refine((ids) => new Set(ids).size === ids.length, "Duplicate dependencies are not allowed").describe("Distinct registered dependency Task IDs; at most 255, excluding self and relatives.").readonly();
+/** Validates the immutable queued Task snapshot retained for creation recovery. */
+const taskGraphAdmissionSchema = taskSchema.refine((task) => task.state === "queued", "Graph admission requires a queued creation snapshot").describe("Immutable queued Task creation snapshot, retained for interrupted creation recovery.");
+/** Validates one Task's membership, ownership, dependencies, and admission intent. */
+const taskGraphNodeSchema = z.strictObject({
+	taskId: taskIdSchema.describe("Task registered in this graph."),
+	parentTaskId: taskIdSchema.optional().describe("Single owning parent; absent only on the root."),
+	dependencies: taskGraphDependenciesSchema.describe("Current dependency edges, separate from the Task snapshot."),
+	sealed: z.boolean().describe("Dependencies permanently frozen at first execution admission, including failed launches; persisted explicitly on writes."),
+	admission: taskGraphAdmissionSchema,
+	admissionDependencies: taskGraphDependenciesSchema.describe("Immutable original admission dependencies used to compare creation retries.")
+});
+function hasCycle(edges) {
+	const incoming = new Map([...edges.keys()].map((id) => [id, 0]));
+	for (const targets of edges.values()) for (const id of targets) incoming.set(id, (incoming.get(id) ?? 0) + 1);
+	const ready = [...incoming].filter(([, count]) => count === 0).map(([id]) => id);
+	for (let index = 0; index < ready.length; index++) for (const id of edges.get(ready[index]) ?? []) {
+		const count = (incoming.get(id) ?? 0) - 1;
+		incoming.set(id, count);
+		if (count === 0) ready.push(id);
+	}
+	return ready.length !== edges.size;
+}
+/** Validates a bounded, acyclic canonical Task graph owned by one root Task. */
+const taskGraphSchema = z.strictObject({
+	schemaVersion: schemaVersionSchema,
+	rootTaskId: taskIdSchema.describe("Root Task ID and directly addressed storage key."),
+	revision: z.number().int().positive().describe("Graph revision; starts at 1 and increments on every mutation."),
+	nodes: z.array(taskGraphNodeSchema).min(1).max(256).describe("Bounded graph membership, including its one root; at most 256 nodes.").readonly(),
+	createdAt: isoDateTimeSchema.describe("When the graph was first admitted."),
+	updatedAt: isoDateTimeSchema.describe("When graph membership or edges last changed.")
+}).superRefine((graph, ctx) => {
+	const issue = (message) => ctx.addIssue({
+		code: "custom",
+		message
+	});
+	if (graph.nodes.length > 256) return;
+	const nodes = new Map(graph.nodes.map((node) => [node.taskId, node]));
+	if (nodes.size !== graph.nodes.length) issue("Duplicate Task membership is not allowed");
+	if (!nodes.has(graph.rootTaskId)) issue("Graph must contain its root Task");
+	const parents = /* @__PURE__ */ new Map();
+	for (const node of graph.nodes) {
+		const task = node.admission;
+		if (task.id !== node.taskId || task.rootTaskId !== graph.rootTaskId || task.parentTaskId !== node.parentTaskId) issue(`Task ${node.taskId} admission must match graph root and parent membership`);
+		parents.set(node.taskId, node.parentTaskId ? [node.parentTaskId] : []);
+		if (node.taskId === graph.rootTaskId) {
+			if (node.parentTaskId !== void 0) issue("Root Task cannot have a parent");
+		} else {
+			const parent = node.parentTaskId ? nodes.get(node.parentTaskId) : void 0;
+			if (!parent) issue(`Task ${node.taskId} requires a registered parent in the same graph`);
+			else if (!task.repositoryIds.every((id) => parent.admission.repositoryIds.includes(id))) issue(`Task ${node.taskId} repository scope must be a subset of its parent`);
+		}
+	}
+	if (hasCycle(parents)) {
+		issue("Parent tree contains a cycle or unknown parent");
+		return;
+	}
+	const ancestors = /* @__PURE__ */ new Map();
+	for (const node of graph.nodes) {
+		const ids = /* @__PURE__ */ new Set();
+		let parent = node.parentTaskId;
+		while (parent !== void 0 && !ids.has(parent)) {
+			ids.add(parent);
+			parent = nodes.get(parent)?.parentTaskId;
+		}
+		ancestors.set(node.taskId, ids);
+	}
+	for (const field of ["dependencies", "admissionDependencies"]) {
+		const edges = /* @__PURE__ */ new Map();
+		for (const node of graph.nodes) {
+			edges.set(node.taskId, [...node[field]]);
+			for (const dependency of node[field]) {
+				if (!nodes.has(dependency)) issue(`Unknown dependency ${dependency}; dependencies must be registered in the same graph`);
+				if (dependency === node.taskId) issue(`Task ${node.taskId} cannot depend on itself`);
+				if (ancestors.get(node.taskId)?.has(dependency) || ancestors.get(dependency)?.has(node.taskId)) issue(`Task ${node.taskId} cannot depend on an ancestor or descendant`);
+			}
+		}
+		if (field === "admissionDependencies") continue;
+		if (hasCycle(edges)) issue(`${field} contains a cycle or unknown dependency`);
+		for (const node of graph.nodes) if (node.parentTaskId) edges.get(node.parentTaskId)?.push(node.taskId);
+		if (hasCycle(edges)) issue(`${field} creates a dependency/parent waiting cycle`);
+	}
+}).describe("Single per-root CAS record owning Task membership and dependency edges.");
+//#endregion
+export { MAX_TASK_GRAPH_DEPENDENCIES, MAX_TASK_GRAPH_NODES, taskGraphAdmissionSchema, taskGraphDependenciesSchema, taskGraphNodeSchema, taskGraphSchema };
+
+//# sourceMappingURL=task-graph.mjs.map

package/dist/schema/task-graph.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-graph.mjs","names":[],"sources":["../../src/schema/task-graph.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { isoDateTimeSchema, schemaVersionSchema } from \"./common\";\nimport { taskIdSchema } from \"./id\";\nimport { taskSchema } from \"./task\";\n\n/** Maximum number of Tasks admitted to one canonical root graph. */\nexport const MAX_TASK_GRAPH_NODES = 256;\n/** Maximum explicit dependencies allowed on one Task graph node. */\nexport const MAX_TASK_GRAPH_DEPENDENCIES = MAX_TASK_GRAPH_NODES - 1;\n\n/** Validates a bounded, duplicate-free list of canonical Task dependencies. */\nexport const taskGraphDependenciesSchema = z\n  .array(taskIdSchema)\n  .max(MAX_TASK_GRAPH_DEPENDENCIES)\n  .refine((ids) => new Set(ids).size === ids.length, \"Duplicate dependencies are not allowed\")\n  .describe(\"Distinct registered dependency Task IDs; at most 255, excluding self and relatives.\")\n  .readonly();\n\n/** Validates the immutable queued Task snapshot retained for creation recovery. */\nexport const taskGraphAdmissionSchema = taskSchema\n  .refine((task) => task.state === \"queued\", \"Graph admission requires a queued creation snapshot\")\n  .describe(\"Immutable queued Task creation snapshot, retained for interrupted creation recovery.\");\n\n/** Validates one Task's membership, ownership, dependencies, and admission intent. */\nexport const taskGraphNodeSchema = z.strictObject({\n  taskId: taskIdSchema.describe(\"Task registered in this graph.\"),\n  parentTaskId: taskIdSchema.optional().describe(\"Single owning parent; absent only on the root.\"),\n  dependencies: taskGraphDependenciesSchema.describe(\n    \"Current dependency edges, separate from the Task snapshot.\",\n  ),\n  sealed: z\n    .boolean()\n    .describe(\n      \"Dependencies permanently frozen at first execution admission, including failed launches; persisted explicitly on writes.\",\n    ),\n  admission: taskGraphAdmissionSchema,\n  admissionDependencies: taskGraphDependenciesSchema.describe(\n    \"Immutable original admission dependencies used to compare creation retries.\",\n  ),\n});\n\n/** Canonical graph membership and dependency record for one Task. */\nexport type TaskGraphNode = z.infer<typeof taskGraphNodeSchema>;\n\nfunction hasCycle(edges: ReadonlyMap<string, readonly string[]>): boolean {\n  const incoming = new Map([...edges.keys()].map((id) => [id, 0]));\n  for (const targets of edges.values()) {\n    for (const id of targets) incoming.set(id, (incoming.get(id) ?? 0) + 1);\n  }\n  const ready = [...incoming].filter(([, count]) => count === 0).map(([id]) => id);\n  for (let index = 0; index < ready.length; index++) {\n    for (const id of edges.get(ready[index]) ?? []) {\n      const count = (incoming.get(id) ?? 0) - 1;\n      incoming.set(id, count);\n      if (count === 0) ready.push(id);\n    }\n  }\n  return ready.length !== edges.size;\n}\n\n/** Validates a bounded, acyclic canonical Task graph owned by one root Task. */\nexport const taskGraphSchema = z\n  .strictObject({\n    schemaVersion: schemaVersionSchema,\n    rootTaskId: taskIdSchema.describe(\"Root Task ID and directly addressed storage key.\"),\n    revision: z\n      .number()\n      .int()\n      .positive()\n      .describe(\"Graph revision; starts at 1 and increments on every mutation.\"),\n    nodes: z\n      .array(taskGraphNodeSchema)\n      .min(1)\n      .max(MAX_TASK_GRAPH_NODES)\n      .describe(\"Bounded graph membership, including its one root; at most 256 nodes.\")\n      .readonly(),\n    createdAt: isoDateTimeSchema.describe(\"When the graph was first admitted.\"),\n    updatedAt: isoDateTimeSchema.describe(\"When graph membership or edges last changed.\"),\n  })\n  .superRefine((graph, ctx) => {\n    const issue = (message: string) => ctx.addIssue({ code: \"custom\", message });\n    // Stop before graph traversal if a persisted record exceeds the explicit bound.\n    if (graph.nodes.length > MAX_TASK_GRAPH_NODES) return;\n    const nodes = new Map(graph.nodes.map((node) => [node.taskId, node]));\n    if (nodes.size !== graph.nodes.length) issue(\"Duplicate Task membership is not allowed\");\n    if (!nodes.has(graph.rootTaskId)) issue(\"Graph must contain its root Task\");\n    const parents = new Map<string, string[]>();\n    for (const node of graph.nodes) {\n      const task = node.admission;\n      if (\n        task.id !== node.taskId ||\n        task.rootTaskId !== graph.rootTaskId ||\n        task.parentTaskId !== node.parentTaskId\n      ) {\n        issue(`Task ${node.taskId} admission must match graph root and parent membership`);\n      }\n      parents.set(node.taskId, node.parentTaskId ? [node.parentTaskId] : []);\n      if (node.taskId === graph.rootTaskId) {\n        if (node.parentTaskId !== undefined) issue(\"Root Task cannot have a parent\");\n      } else {\n        const parent = node.parentTaskId ? nodes.get(node.parentTaskId) : undefined;\n        if (!parent) issue(`Task ${node.taskId} requires a registered parent in the same graph`);\n        else if (!task.repositoryIds.every((id) => parent.admission.repositoryIds.includes(id))) {\n          issue(`Task ${node.taskId} repository scope must be a subset of its parent`);\n        }\n      }\n    }\n    if (hasCycle(parents)) {\n      issue(\"Parent tree contains a cycle or unknown parent\");\n      return;\n    }\n    const ancestors = new Map<string, Set<string>>();\n    for (const node of graph.nodes) {\n      const ids = new Set<string>();\n      let parent = node.parentTaskId;\n      while (parent !== undefined && !ids.has(parent)) {\n        ids.add(parent);\n        parent = nodes.get(parent)?.parentTaskId;\n      }\n      ancestors.set(node.taskId, ids);\n    }\n    for (const field of [\"dependencies\", \"admissionDependencies\"] as const) {\n      const edges = new Map<string, string[]>();\n      for (const node of graph.nodes) {\n        edges.set(node.taskId, [...node[field]]);\n        for (const dependency of node[field]) {\n          if (!nodes.has(dependency))\n            issue(\n              `Unknown dependency ${dependency}; dependencies must be registered in the same graph`,\n            );\n          if (dependency === node.taskId) issue(`Task ${node.taskId} cannot depend on itself`);\n          if (\n            ancestors.get(node.taskId)?.has(dependency) ||\n            ancestors.get(dependency)?.has(node.taskId)\n          ) {\n            issue(`Task ${node.taskId} cannot depend on an ancestor or descendant`);\n          }\n        }\n      }\n      // Historical admission edges are retry evidence, not simultaneous active waits.\n      if (field === \"admissionDependencies\") continue;\n      if (hasCycle(edges)) issue(`${field} contains a cycle or unknown dependency`);\n      // Parents may wait for children: include those implicit waits to reject cross-subtree deadlocks.\n      for (const node of graph.nodes) {\n        if (node.parentTaskId) edges.get(node.parentTaskId)?.push(node.taskId);\n      }\n      if (hasCycle(edges)) issue(`${field} creates a dependency/parent waiting cycle`);\n    }\n  })\n  .describe(\"Single per-root CAS record owning Task membership and dependency edges.\");\n\n/** Directly addressed CAS snapshot owning one root's Task membership and dependencies. */\nexport type TaskGraph = z.infer<typeof taskGraphSchema>;\n"],"mappings":"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"}

package/dist/schema/task-message.d.mts

@@ -0,0 +1,254 @@
+import { JsonValue } from "./work.mjs";
+import { z } from "zod";
+//#region src/schema/task-message.d.ts
+/** Maximum number of unacknowledged envelopes retained in one Task inbox. */
+declare const MAX_TASK_INBOX_PENDING = 256;
+/** Validates the content-derived identity of an immutable Task message. */
+declare const taskMessageIdSchema: z.ZodType<`msg_${string}`, string>;
+/** Validates an exact registered Task-message protocol identity and version. */
+declare const taskMessageProtocolBindingSchema: z.core.$ZodBranded<z.ZodObject<{
+  id: z.ZodString;
+  version: z.ZodNumber;
+}, z.core.$strict>, "TaskMessageProtocolBinding", "out">;
+declare const taskMessagePayloadType: unique symbol;
+declare const taskMessageStoredPayloadType: unique symbol;
+/** Exact Task-message protocol identity carrying its accepted and canonical stored payload types. */
+type TaskMessageProtocolBinding<Payload extends JsonValue = JsonValue, Id extends string = string, Version extends number = number, StoredPayload extends JsonValue = Payload> = z.infer<typeof taskMessageProtocolBindingSchema> & {
+  readonly id: Id;
+  readonly version: Version;
+  readonly [taskMessagePayloadType]?: Payload;
+  readonly [taskMessageStoredPayloadType]?: StoredPayload;
+};
+/** Plain identifier and version accepted when constructing a Task-message protocol binding. */
+interface TaskMessageProtocolBindingInput<Id extends string = string, Version extends number = number> {
+  readonly id: Id;
+  readonly version: Version;
+}
+/** Validates and brands an exact Task-message protocol binding while preserving literal identity. */
+declare function parseTaskMessageProtocolBinding<const Input extends TaskMessageProtocolBindingInput>(input: Input): TaskMessageProtocolBinding<JsonValue, Input["id"], Input["version"]>;
+/** Validates a stable caller operation identity scoped to one source Task. */
+declare const taskMessageOperationIdSchema: z.ZodString;
+/** Validates an application-authenticated principal and optional trusted Task binding. */
+declare const taskMessagePrincipalSchema: z.ZodObject<{
+  id: z.ZodString;
+  taskId: z.ZodOptional<z.ZodType<`task_${string}`, string, z.core.$ZodTypeInternals<`task_${string}`, string>>>;
+}, z.core.$strict>;
+/** Validates an idempotent, attempt-fenced request to send a Task message. */
+declare const sendTaskMessageInputSchema: z.ZodObject<{
+  operationId: z.ZodString;
+  fromTaskId: z.ZodType<`task_${string}`, string, z.core.$ZodTypeInternals<`task_${string}`, string>>;
+  toTaskId: z.ZodType<`task_${string}`, string, z.core.$ZodTypeInternals<`task_${string}`, string>>;
+  type: z.core.$ZodBranded<z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodNumber;
+  }, z.core.$strict>, "TaskMessageProtocolBinding", "out">;
+  payload: z.ZodCustom<JsonValue, JsonValue>;
+  causationId: z.ZodOptional<z.ZodType<`msg_${string}`, string, z.core.$ZodTypeInternals<`msg_${string}`, string>>>;
+  expectAttempt: z.ZodNumber;
+}, z.core.$strict>;
+/** Validates an immutable, protocol-versioned Task message envelope. */
+declare const taskMessageSchema: z.ZodObject<{
+  operationId: z.ZodString;
+  fromTaskId: z.ZodType<`task_${string}`, string, z.core.$ZodTypeInternals<`task_${string}`, string>>;
+  toTaskId: z.ZodType<`task_${string}`, string, z.core.$ZodTypeInternals<`task_${string}`, string>>;
+  type: z.core.$ZodBranded<z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodNumber;
+  }, z.core.$strict>, "TaskMessageProtocolBinding", "out">;
+  payload: z.ZodCustom<JsonValue, JsonValue>;
+  causationId: z.ZodOptional<z.ZodType<`msg_${string}`, string, z.core.$ZodTypeInternals<`msg_${string}`, string>>>;
+  expectAttempt: z.ZodNumber;
+  schemaVersion: z.ZodLiteral<1>;
+  id: z.ZodType<`msg_${string}`, string, z.core.$ZodTypeInternals<`msg_${string}`, string>>;
+  createdAt: z.ZodISODateTime;
+  delivery: z.ZodOptional<z.ZodLiteral<"result">>;
+}, z.core.$strict>;
+/** Validates a time-bounded claim on the current head of a Task inbox. */
+declare const taskMessageClaimSchema: z.ZodObject<{
+  messageId: z.ZodType<`msg_${string}`, string, z.core.$ZodTypeInternals<`msg_${string}`, string>>;
+  toTaskId: z.ZodType<`task_${string}`, string, z.core.$ZodTypeInternals<`task_${string}`, string>>;
+  generation: z.ZodNumber;
+  principalId: z.ZodString;
+  attempt: z.ZodNumber;
+  expiresAt: z.ZodISODateTime;
+}, z.core.$strict>;
+/** Validates the immutable acknowledgment that a claimed message's effects committed. */
+declare const taskMessageProcessingSchema: z.ZodObject<{
+  messageId: z.ZodType<`msg_${string}`, string, z.core.$ZodTypeInternals<`msg_${string}`, string>>;
+  toTaskId: z.ZodType<`task_${string}`, string, z.core.$ZodTypeInternals<`task_${string}`, string>>;
+  generation: z.ZodNumber;
+  principalId: z.ZodString;
+  attempt: z.ZodNumber;
+  expiresAt: z.ZodISODateTime;
+  schemaVersion: z.ZodLiteral<1>;
+  effectsCommitted: z.ZodLiteral<true>;
+  completedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+/** Validates an explicitly authorized discard of an unleased inbox head. */
+declare const taskMessageDiscardSchema: z.ZodObject<{
+  schemaVersion: z.ZodLiteral<1>;
+  messageId: z.ZodType<`msg_${string}`, string, z.core.$ZodTypeInternals<`msg_${string}`, string>>;
+  toTaskId: z.ZodType<`task_${string}`, string, z.core.$ZodTypeInternals<`task_${string}`, string>>;
+  reason: z.ZodString;
+  by: z.ZodObject<{
+    id: z.ZodString;
+    taskId: z.ZodOptional<z.ZodType<`task_${string}`, string, z.core.$ZodTypeInternals<`task_${string}`, string>>>;
+  }, z.core.$strict>;
+  discardedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+/** Validates immutable send intent reserved before inbox and envelope persistence complete. */
+declare const taskMessageReservationSchema: z.ZodObject<{
+  schemaVersion: z.ZodLiteral<1>;
+  message: z.ZodObject<{
+    operationId: z.ZodString;
+    fromTaskId: z.ZodType<`task_${string}`, string, z.core.$ZodTypeInternals<`task_${string}`, string>>;
+    toTaskId: z.ZodType<`task_${string}`, string, z.core.$ZodTypeInternals<`task_${string}`, string>>;
+    type: z.core.$ZodBranded<z.ZodObject<{
+      id: z.ZodString;
+      version: z.ZodNumber;
+    }, z.core.$strict>, "TaskMessageProtocolBinding", "out">;
+    payload: z.ZodCustom<JsonValue, JsonValue>;
+    causationId: z.ZodOptional<z.ZodType<`msg_${string}`, string, z.core.$ZodTypeInternals<`msg_${string}`, string>>>;
+    expectAttempt: z.ZodNumber;
+    schemaVersion: z.ZodLiteral<1>;
+    id: z.ZodType<`msg_${string}`, string, z.core.$ZodTypeInternals<`msg_${string}`, string>>;
+    createdAt: z.ZodISODateTime;
+    delivery: z.ZodOptional<z.ZodLiteral<"result">>;
+  }, z.core.$strict>;
+  expectAttempt: z.ZodNumber;
+}, z.core.$strict>;
+/** Validates the bounded, directly addressed processing queue for one recipient Task. */
+declare const taskInboxSchema: z.ZodObject<{
+  schemaVersion: z.ZodLiteral<1>;
+  toTaskId: z.ZodType<`task_${string}`, string, z.core.$ZodTypeInternals<`task_${string}`, string>>;
+  generation: z.ZodNumber;
+  pending: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+    operationId: z.ZodString;
+    fromTaskId: z.ZodType<`task_${string}`, string, z.core.$ZodTypeInternals<`task_${string}`, string>>;
+    toTaskId: z.ZodType<`task_${string}`, string, z.core.$ZodTypeInternals<`task_${string}`, string>>;
+    type: z.core.$ZodBranded<z.ZodObject<{
+      id: z.ZodString;
+      version: z.ZodNumber;
+    }, z.core.$strict>, "TaskMessageProtocolBinding", "out">;
+    payload: z.ZodCustom<JsonValue, JsonValue>;
+    causationId: z.ZodOptional<z.ZodType<`msg_${string}`, string, z.core.$ZodTypeInternals<`msg_${string}`, string>>>;
+    expectAttempt: z.ZodNumber;
+    schemaVersion: z.ZodLiteral<1>;
+    id: z.ZodType<`msg_${string}`, string, z.core.$ZodTypeInternals<`msg_${string}`, string>>;
+    createdAt: z.ZodISODateTime;
+    delivery: z.ZodOptional<z.ZodLiteral<"result">>;
+  }, z.core.$strict>>>;
+  lease: z.ZodOptional<z.ZodObject<{
+    messageId: z.ZodType<`msg_${string}`, string, z.core.$ZodTypeInternals<`msg_${string}`, string>>;
+    toTaskId: z.ZodType<`task_${string}`, string, z.core.$ZodTypeInternals<`task_${string}`, string>>;
+    generation: z.ZodNumber;
+    principalId: z.ZodString;
+    attempt: z.ZodNumber;
+    expiresAt: z.ZodISODateTime;
+  }, z.core.$strict>>;
+  completion: z.ZodOptional<z.ZodObject<{
+    messageId: z.ZodType<`msg_${string}`, string, z.core.$ZodTypeInternals<`msg_${string}`, string>>;
+    toTaskId: z.ZodType<`task_${string}`, string, z.core.$ZodTypeInternals<`task_${string}`, string>>;
+    generation: z.ZodNumber;
+    principalId: z.ZodString;
+    attempt: z.ZodNumber;
+    expiresAt: z.ZodISODateTime;
+    schemaVersion: z.ZodLiteral<1>;
+    effectsCommitted: z.ZodLiteral<true>;
+    completedAt: z.ZodISODateTime;
+  }, z.core.$strict>>;
+  rejection: z.ZodOptional<z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    messageId: z.ZodType<`msg_${string}`, string, z.core.$ZodTypeInternals<`msg_${string}`, string>>;
+    toTaskId: z.ZodType<`task_${string}`, string, z.core.$ZodTypeInternals<`task_${string}`, string>>;
+    reason: z.ZodString;
+    by: z.ZodObject<{
+      id: z.ZodString;
+      taskId: z.ZodOptional<z.ZodType<`task_${string}`, string, z.core.$ZodTypeInternals<`task_${string}`, string>>>;
+    }, z.core.$strict>;
+    discardedAt: z.ZodISODateTime;
+  }, z.core.$strict>>;
+}, z.core.$strict>;
+/** Content-derived identity of an immutable Task message. */
+type TaskMessageId = z.infer<typeof taskMessageIdSchema>;
+/** Stable caller operation identity scoped to one source Task. */
+type TaskMessageOperationId = z.infer<typeof taskMessageOperationIdSchema>;
+/** Input payload accepted by one exact Task-message protocol binding. */
+type TaskMessageProtocolInputPayload<Type extends TaskMessageProtocolBinding> = Type extends TaskMessageProtocolBinding<infer Payload, infer _Id, infer _Version, infer _StoredPayload> ? Payload : JsonValue;
+/** Canonical payload stored by one exact Task-message protocol binding. */
+type TaskMessageProtocolStoredPayload<Type extends TaskMessageProtocolBinding> = Type extends TaskMessageProtocolBinding<infer _Payload, infer _Id, infer _Version, infer StoredPayload> ? StoredPayload : JsonValue;
+/** Caller-supplied idempotent intent with a payload correlated to its protocol binding. */
+type SendTaskMessageInput<Type extends TaskMessageProtocolBinding = TaskMessageProtocolBinding> = Readonly<Omit<z.infer<typeof sendTaskMessageInputSchema>, "type" | "payload">> & {
+  readonly type: Type;
+  readonly payload: NoInfer<TaskMessageProtocolInputPayload<Type>>;
+};
+/** Immutable versioned-protocol envelope exchanged by authorized Tasks in one graph. */
+type TaskMessage<Type extends TaskMessageProtocolBinding = TaskMessageProtocolBinding> = Readonly<Omit<z.infer<typeof taskMessageSchema>, "type" | "payload">> & {
+  readonly type: Type;
+  readonly payload: TaskMessageProtocolStoredPayload<Type>;
+};
+/** Application-authenticated identity used to authorize Task message operations. */
+type TaskMessagePrincipal = Readonly<z.infer<typeof taskMessagePrincipalSchema>>;
+/** Time-bounded, generation-fenced claim on a recipient's inbox head. */
+type TaskMessageClaim = Readonly<z.infer<typeof taskMessageClaimSchema>>;
+/** Immutable evidence that a claimed message's effects were committed and acknowledged. */
+type TaskMessageProcessing = Readonly<z.infer<typeof taskMessageProcessingSchema>>;
+/** Immutable evidence that an inbox head was explicitly discarded without applying effects. */
+type TaskMessageDiscard = Readonly<z.infer<typeof taskMessageDiscardSchema>>;
+/** Bounded durable queue and current processing state for one recipient Task. */
+type TaskInbox = z.infer<typeof taskInboxSchema>;
+/** Caller input accepted when defining one exact Task-message protocol. */
+interface TaskMessageProtocolInput<Payload extends z.ZodType = z.ZodType, Id extends string = string, Version extends number = number> {
+  readonly id: Id;
+  readonly version: Version;
+  readonly payload: Payload;
+  /** Required when the input transform changes shape. Stored validation must preserve the canonical JSON. */
+  readonly storedPayload?: z.ZodType<NoInfer<z.output<Payload>>>;
+  /** Defaults to attempt; task scope is an explicit trusted workflow initial/reconcile capability. */
+  readonly sourceFence?: "attempt" | "task";
+}
+type TaskMessageJsonPayload<Value> = Value extends JsonValue ? Value : Value & JsonValue;
+/** Exact protocol contract with a typed binding for constructing message input. */
+interface TaskMessageProtocol<Payload extends z.ZodType = z.ZodType, Id extends string = string, Version extends number = number> extends TaskMessageProtocolInput<Payload, Id, Version> {
+  readonly binding: TaskMessageProtocolBinding<TaskMessageJsonPayload<z.input<Payload>>, Id, Version, TaskMessageJsonPayload<z.output<Payload>>>;
+}
+/** Immutable message envelope validated against one exact Task-message protocol. */
+type TaskMessageForProtocol<Protocol extends TaskMessageProtocol> = Protocol extends TaskMessageProtocol ? TaskMessage<Protocol["binding"]> : never;
+type TaskMessageProtocolForBinding<Protocol extends TaskMessageProtocol, Binding extends TaskMessageProtocolBinding> = Protocol extends TaskMessageProtocol ? Binding extends {
+  readonly id: Protocol["id"];
+  readonly version: Protocol["version"];
+} ? Protocol : Protocol extends {
+  readonly id: Binding["id"];
+  readonly version: Binding["version"];
+} ? Protocol : never : never;
+/** Immutable registry of exact Task message protocol versions. */
+interface TaskMessageProtocols<Protocol extends TaskMessageProtocol = TaskMessageProtocol> {
+  readonly definitions: readonly Readonly<Protocol>[];
+  resolve<const Binding extends TaskMessageProtocolBinding>(type: Binding): Readonly<TaskMessageProtocolForBinding<Protocol, Binding>>;
+  sourceFence(type: TaskMessageProtocolBinding): "attempt" | "task";
+  validate<const Binding extends TaskMessageProtocolBinding>(type: Binding, payload: unknown): TaskMessageProtocolStoredPayload<Binding>;
+  validateStored<const Binding extends TaskMessageProtocolBinding>(type: Binding, payload: unknown): TaskMessageProtocolStoredPayload<Binding>;
+}
+/** Validates a Task-message protocol definition before it is registered. */
+declare const taskMessageProtocolSchema: z.ZodObject<{
+  payload: z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+  storedPayload: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+  sourceFence: z.ZodDefault<z.ZodEnum<{
+    task: "task";
+    attempt: "attempt";
+  }>>;
+  id: z.ZodString;
+  version: z.ZodNumber;
+}, z.core.$strict>;
+type RegisteredTaskMessageProtocol<Definition extends TaskMessageProtocolInput> = Definition extends TaskMessageProtocolInput<infer Payload, infer Id, infer Version> ? TaskMessageProtocol<Payload, Id, Version> : never;
+/** Validates, snapshots, and freezes one exact Task-message protocol definition. */
+declare function defineTaskMessageProtocol<Payload extends z.ZodType, const Id extends string, const Version extends number>(definition: TaskMessageProtocolInput<Payload, Id, Version>): Readonly<TaskMessageProtocol<Payload, Id, Version>>;
+/** Builds an exact-version protocol registry and rejects duplicate definitions. */
+declare function defineTaskMessageProtocols<const Definition extends TaskMessageProtocolInput>(definitions: readonly Definition[]): TaskMessageProtocols<RegisteredTaskMessageProtocol<Definition>>;
+/** Constructs a send intent whose payload is checked against its protocol schema type. */
+declare function taskMessageInput<Payload extends z.ZodType, const Id extends string, const Version extends number>(protocol: TaskMessageProtocol<Payload, Id, Version>, input: Omit<SendTaskMessageInput, "type" | "payload"> & {
+  readonly payload: NoInfer<TaskMessageJsonPayload<z.input<Payload>>>;
+}): SendTaskMessageInput<TaskMessageProtocolBinding<TaskMessageJsonPayload<z.input<Payload>>, Id, Version, TaskMessageJsonPayload<z.output<Payload>>>>;
+//#endregion
+export { MAX_TASK_INBOX_PENDING, SendTaskMessageInput, TaskInbox, TaskMessage, TaskMessageClaim, TaskMessageDiscard, TaskMessageForProtocol, TaskMessageId, TaskMessageOperationId, TaskMessagePrincipal, TaskMessageProcessing, TaskMessageProtocol, TaskMessageProtocolBinding, TaskMessageProtocolBindingInput, TaskMessageProtocolInput, TaskMessageProtocolInputPayload, TaskMessageProtocolStoredPayload, TaskMessageProtocols, defineTaskMessageProtocol, defineTaskMessageProtocols, parseTaskMessageProtocolBinding, sendTaskMessageInputSchema, taskInboxSchema, taskMessageClaimSchema, taskMessageDiscardSchema, taskMessageIdSchema, taskMessageInput, taskMessageOperationIdSchema, taskMessagePrincipalSchema, taskMessageProcessingSchema, taskMessageProtocolBindingSchema, taskMessageProtocolSchema, taskMessageReservationSchema, taskMessageSchema };
+//# sourceMappingURL=task-message.d.mts.map

package/dist/schema/task-message.mjs

@@ -0,0 +1,189 @@
+import { taskIdSchema } from "./id.mjs";
+import { isoDateTimeSchema, schemaVersionSchema } from "./common.mjs";
+import { jsonValueSchema } from "./work.mjs";
+import { z } from "zod";
+import { isDeepStrictEqual } from "node:util";
+//#region src/schema/task-message.ts
+/** Maximum number of unacknowledged envelopes retained in one Task inbox. */
+const MAX_TASK_INBOX_PENDING = 256;
+/** Validates the content-derived identity of an immutable Task message. */
+const taskMessageIdSchema = z.string().regex(/^msg_[a-f0-9]{64}$/u, "Expected msg_ followed by exactly 64 lowercase hexadecimal characters").describe("Source Task and operation ID SHA-256 identity.");
+/** Validates an exact Task-message protocol identity and version. */
+const taskMessageProtocolBindingFields = {
+	id: z.string().max(64).regex(/^[a-z][a-z0-9]*(?:[-_][a-z0-9]+)*$/, "Expected a lowercase hyphenated or snake_case protocol name").describe("Registered Task-message protocol name."),
+	version: z.number().int().positive().describe("Exact positive integer version of the registered protocol.")
+};
+/** Validates an exact registered Task-message protocol identity and version. */
+const taskMessageProtocolBindingSchema = z.strictObject(taskMessageProtocolBindingFields).describe("Exact registered Task-message protocol identity and version.").brand();
+/** Validates and brands an exact Task-message protocol binding while preserving literal identity. */
+function parseTaskMessageProtocolBinding(input) {
+	return taskMessageProtocolBindingSchema.parse(input);
+}
+/** Validates a stable caller operation identity scoped to one source Task. */
+const taskMessageOperationIdSchema = z.string().min(1).max(256).describe("Stable caller operation ID, scoped to the source Task.");
+/** Validates an application-authenticated principal and optional trusted Task binding. */
+const taskMessagePrincipalSchema = z.strictObject({
+	id: z.string().min(1).max(256).describe("Identity authenticated by the trusted application, not by this store."),
+	taskId: taskIdSchema.optional().describe("Optional trusted Task binding; never derived from a payload.")
+});
+/** Validates an idempotent, attempt-fenced request to send a Task message. */
+const sendTaskMessageInputSchema = z.strictObject({
+	operationId: taskMessageOperationIdSchema,
+	fromTaskId: taskIdSchema.describe("Task sending the message."),
+	toTaskId: taskIdSchema.describe("Recipient in the same root Task graph."),
+	type: taskMessageProtocolBindingSchema,
+	payload: jsonValueSchema.describe("Protocol input; validated as bounded JSON before and after transformation."),
+	causationId: taskMessageIdSchema.optional().describe("Optional preceding message in this Task graph."),
+	expectAttempt: z.number().int().positive().describe("Source attempt retained in the immutable envelope for consumer fencing; Task lifecycle checks and inbox writes are not atomic.")
+});
+/** Validates an immutable, protocol-versioned Task message envelope. */
+const taskMessageSchema = sendTaskMessageInputSchema.extend({
+	schemaVersion: schemaVersionSchema,
+	id: taskMessageIdSchema,
+	createdAt: isoDateTimeSchema.describe("Engine timestamp fixed at operation reservation."),
+	delivery: z.literal("result").optional().describe("Engine-controlled delivery from a terminal source Task under explicit workflow authorization.")
+});
+/** Validates a time-bounded claim on the current head of a Task inbox. */
+const taskMessageClaimSchema = z.strictObject({
+	messageId: taskMessageIdSchema,
+	toTaskId: taskIdSchema.describe("Recipient whose processing is serialized by this lease."),
+	generation: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).describe("Monotonically increasing inbox CAS fence, not an authorization credential."),
+	principalId: taskMessagePrincipalSchema.shape.id,
+	attempt: z.number().int().positive().describe("Recipient attempt when the lease was claimed."),
+	expiresAt: isoDateTimeSchema.describe("Completion must be accepted before this engine timestamp.")
+});
+/** Validates the immutable acknowledgment that a claimed message's effects committed. */
+const taskMessageProcessingSchema = taskMessageClaimSchema.extend({
+	schemaVersion: schemaVersionSchema,
+	effectsCommitted: z.literal(true).describe("Caller attests its effects committed before processing acknowledgment; not exactly-once execution."),
+	completedAt: isoDateTimeSchema.describe("Time the inbox CAS durably accepted the acknowledgment.")
+});
+/** Validates an explicitly authorized discard of an unleased inbox head. */
+const taskMessageDiscardSchema = z.strictObject({
+	schemaVersion: schemaVersionSchema,
+	messageId: taskMessageIdSchema,
+	toTaskId: taskIdSchema.describe("Recipient whose pending head was discarded."),
+	reason: z.string().trim().min(1).max(2048).describe("Explicit authorized recovery reason, at most 2048 characters."),
+	by: taskMessagePrincipalSchema.describe("Trusted application principal that authorized discarding, never payload identity."),
+	discardedAt: isoDateTimeSchema.describe("Time the inbox CAS accepted the discard intent, not an effects acknowledgment.")
+});
+/** Validates immutable send intent reserved before inbox and envelope persistence complete. */
+const taskMessageReservationSchema = z.strictObject({
+	schemaVersion: schemaVersionSchema,
+	message: taskMessageSchema.describe("Immutable reserved intent; delivery exists only after inbox enqueue and envelope insertion."),
+	expectAttempt: sendTaskMessageInputSchema.shape.expectAttempt
+}).refine((reservation) => reservation.expectAttempt === reservation.message.expectAttempt, { message: "Reservation and immutable envelope must retain the same source attempt" });
+/** Validates the bounded, directly addressed processing queue for one recipient Task. */
+const taskInboxSchema = z.strictObject({
+	schemaVersion: schemaVersionSchema,
+	toTaskId: taskIdSchema.describe("Directly addressed recipient inbox identity."),
+	generation: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).describe("Last allocated lease generation; never reset when the inbox drains."),
+	pending: z.array(taskMessageSchema).max(256).readonly().describe("Bounded durable envelope intents, retained until processing acknowledgment or explicit authorized discard."),
+	lease: taskMessageClaimSchema.optional().describe("At most one active recipient processing claim."),
+	completion: taskMessageProcessingSchema.optional().describe("CAS-accepted completion awaiting immutable processing-record repair."),
+	rejection: taskMessageDiscardSchema.optional().describe("CAS-accepted discard awaiting immutable discard-record repair; excludes active leases and completion.")
+}).superRefine((inbox, context) => {
+	if (new Set(inbox.pending.map((message) => message.id)).size !== inbox.pending.length || inbox.pending.some((message) => message.toTaskId !== inbox.toTaskId)) context.addIssue({
+		code: "custom",
+		message: "Inbox intents must have unique IDs and match the recipient"
+	});
+	if (inbox.lease && (inbox.lease.toTaskId !== inbox.toTaskId || inbox.lease.generation !== inbox.generation || inbox.lease.messageId !== inbox.pending[0]?.id)) context.addIssue({
+		code: "custom",
+		message: "Inbox lease must fence its first pending message at the current generation"
+	});
+	if (inbox.rejection && (inbox.lease || inbox.completion || inbox.rejection.toTaskId !== inbox.toTaskId || inbox.rejection.messageId !== inbox.pending[0]?.id)) context.addIssue({
+		code: "custom",
+		message: "Discard must identify the pending head and exclude leases and processing completion"
+	});
+	if (inbox.completion) {
+		const { schemaVersion: _schemaVersion, effectsCommitted: _effectsCommitted, completedAt: _completedAt, ...lease } = inbox.completion;
+		if (!isDeepStrictEqual(lease, inbox.lease)) context.addIssue({
+			code: "custom",
+			message: "Completion must match the active lease"
+		});
+	}
+});
+/** Validates a Task-message protocol definition before it is registered. */
+const taskMessageProtocolSchema = z.strictObject({
+	...taskMessageProtocolBindingFields,
+	payload: z.instanceof(z.ZodType).describe("Zod schema validating protocol input."),
+	storedPayload: z.instanceof(z.ZodType).optional().describe("Canonical-preserving Zod schema validating stored payloads."),
+	sourceFence: z.enum(["attempt", "task"]).default("attempt").describe("Source attempt fence; task scope requires explicit trusted workflow configuration.")
+});
+const cloneProtocol = (definition) => Object.freeze({
+	...definition,
+	binding: Object.freeze(parseTaskMessageProtocolBinding({
+		id: definition.binding.id,
+		version: definition.binding.version
+	})),
+	payload: definition.payload.clone(),
+	...definition.storedPayload === void 0 ? {} : { storedPayload: definition.storedPayload.clone() }
+});
+/** Validates, snapshots, and freezes one exact Task-message protocol definition. */
+function defineTaskMessageProtocol(definition) {
+	const input = "binding" in definition ? (({ binding: _binding, ...rest }) => rest)(definition) : definition;
+	const parsed = taskMessageProtocolSchema.parse(input);
+	const protocol = {
+		id: definition.id,
+		version: definition.version,
+		binding: Object.freeze(parseTaskMessageProtocolBinding({
+			id: definition.id,
+			version: definition.version
+		})),
+		payload: definition.payload,
+		...definition.storedPayload === void 0 ? {} : { storedPayload: definition.storedPayload },
+		sourceFence: parsed.sourceFence
+	};
+	return cloneProtocol(protocol);
+}
+/** Builds an exact-version protocol registry and rejects duplicate definitions. */
+function defineTaskMessageProtocols(definitions) {
+	const registry = /* @__PURE__ */ new Map();
+	for (const definition of definitions) {
+		const protocol = defineTaskMessageProtocol(definition);
+		const key = `${protocol.id}@${protocol.version}`;
+		if (registry.has(key)) throw new Error(`Duplicate message protocol ${key}`);
+		registry.set(key, protocol);
+	}
+	function resolve(type) {
+		const { id, version } = taskMessageProtocolBindingSchema.parse(type);
+		const definition = registry.get(`${id}@${version}`);
+		if (!definition) throw new Error(`Unknown message protocol ${id}@${version}. Registered protocols: ${[...registry.keys()].join(", ") || "none"}`);
+		return definition;
+	}
+	const validateStored = (type, payload) => {
+		const definition = resolve(type);
+		const json = jsonValueSchema.parse(payload);
+		const validated = jsonValueSchema.parse((definition.storedPayload ?? definition.payload).parse(structuredClone(json)));
+		if (!isDeepStrictEqual(json, validated)) throw new Error("Stored message protocol validation must preserve canonical JSON; provide storedPayload for transforming protocols");
+		return structuredClone(validated);
+	};
+	const resolveSnapshot = (type) => cloneProtocol(resolve(type));
+	return Object.freeze({
+		get definitions() {
+			return Object.freeze([...registry.values()].map(cloneProtocol));
+		},
+		resolve: resolveSnapshot,
+		sourceFence(type) {
+			return resolve(type).sourceFence ?? "attempt";
+		},
+		validateStored,
+		validate(type, payload) {
+			const json = jsonValueSchema.parse(payload);
+			return validateStored(type, jsonValueSchema.parse(resolve(type).payload.parse(structuredClone(json))));
+		}
+	});
+}
+/** Constructs a send intent whose payload is checked against its protocol schema type. */
+function taskMessageInput(protocol, input) {
+	const value = {
+		...input,
+		type: protocol.binding
+	};
+	sendTaskMessageInputSchema.parse(value);
+	return structuredClone(value);
+}
+//#endregion
+export { MAX_TASK_INBOX_PENDING, defineTaskMessageProtocol, defineTaskMessageProtocols, parseTaskMessageProtocolBinding, sendTaskMessageInputSchema, taskInboxSchema, taskMessageClaimSchema, taskMessageDiscardSchema, taskMessageIdSchema, taskMessageInput, taskMessageOperationIdSchema, taskMessagePrincipalSchema, taskMessageProcessingSchema, taskMessageProtocolBindingSchema, taskMessageProtocolSchema, taskMessageReservationSchema, taskMessageSchema };
+
+//# sourceMappingURL=task-message.mjs.map

package/dist/schema/task-message.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-message.mjs","names":[],"sources":["../../src/schema/task-message.ts"],"sourcesContent":["import { isDeepStrictEqual } from \"node:util\";\nimport { z } from \"zod\";\nimport { isoDateTimeSchema, schemaVersionSchema } from \"./common\";\nimport { taskIdSchema } from \"./id\";\nimport { jsonValueSchema, type JsonValue } from \"./work\";\n\n/** Maximum number of unacknowledged envelopes retained in one Task inbox. */\nexport const MAX_TASK_INBOX_PENDING = 256;\n/** Validates the content-derived identity of an immutable Task message. */\nexport const taskMessageIdSchema = z\n  .string()\n  .regex(\n    /^msg_[a-f0-9]{64}$/u,\n    \"Expected msg_ followed by exactly 64 lowercase hexadecimal characters\",\n  )\n  .describe(\"Source Task and operation ID SHA-256 identity.\") as z.ZodType<`msg_${string}`, string>;\n/** Validates an exact Task-message protocol identity and version. */\nconst taskMessageProtocolBindingFields = {\n  id: z\n    .string()\n    .max(64)\n    .regex(\n      /^[a-z][a-z0-9]*(?:[-_][a-z0-9]+)*$/,\n      \"Expected a lowercase hyphenated or snake_case protocol name\",\n    )\n    .describe(\"Registered Task-message protocol name.\"),\n  version: z\n    .number()\n    .int()\n    .positive()\n    .describe(\"Exact positive integer version of the registered protocol.\"),\n} as const;\n/** Validates an exact registered Task-message protocol identity and version. */\nexport const taskMessageProtocolBindingSchema = z\n  .strictObject(taskMessageProtocolBindingFields)\n  .describe(\"Exact registered Task-message protocol identity and version.\")\n  .brand<\"TaskMessageProtocolBinding\">();\ndeclare const taskMessagePayloadType: unique symbol;\ndeclare const taskMessageStoredPayloadType: unique symbol;\n\n/** Exact Task-message protocol identity carrying its accepted and canonical stored payload types. */\nexport type TaskMessageProtocolBinding<\n  Payload extends JsonValue = JsonValue,\n  Id extends string = string,\n  Version extends number = number,\n  StoredPayload extends JsonValue = Payload,\n> = z.infer<typeof taskMessageProtocolBindingSchema> & {\n  readonly id: Id;\n  readonly version: Version;\n  readonly [taskMessagePayloadType]?: Payload;\n  readonly [taskMessageStoredPayloadType]?: StoredPayload;\n};\n\n/** Plain identifier and version accepted when constructing a Task-message protocol binding. */\nexport interface TaskMessageProtocolBindingInput<\n  Id extends string = string,\n  Version extends number = number,\n> {\n  readonly id: Id;\n  readonly version: Version;\n}\n\n/** Validates and brands an exact Task-message protocol binding while preserving literal identity. */\nexport function parseTaskMessageProtocolBinding<\n  const Input extends TaskMessageProtocolBindingInput,\n>(input: Input): TaskMessageProtocolBinding<JsonValue, Input[\"id\"], Input[\"version\"]> {\n  return taskMessageProtocolBindingSchema.parse(input) as TaskMessageProtocolBinding<\n    JsonValue,\n    Input[\"id\"],\n    Input[\"version\"]\n  >;\n}\n\n/** Validates a stable caller operation identity scoped to one source Task. */\nexport const taskMessageOperationIdSchema = z\n  .string()\n  .min(1)\n  .max(256)\n  .describe(\"Stable caller operation ID, scoped to the source Task.\");\n/** Validates an application-authenticated principal and optional trusted Task binding. */\nexport const taskMessagePrincipalSchema = z.strictObject({\n  id: z\n    .string()\n    .min(1)\n    .max(256)\n    .describe(\"Identity authenticated by the trusted application, not by this store.\"),\n  taskId: taskIdSchema\n    .optional()\n    .describe(\"Optional trusted Task binding; never derived from a payload.\"),\n});\n/** Validates an idempotent, attempt-fenced request to send a Task message. */\nexport const sendTaskMessageInputSchema = z.strictObject({\n  operationId: taskMessageOperationIdSchema,\n  fromTaskId: taskIdSchema.describe(\"Task sending the message.\"),\n  toTaskId: taskIdSchema.describe(\"Recipient in the same root Task graph.\"),\n  type: taskMessageProtocolBindingSchema,\n  payload: jsonValueSchema.describe(\n    \"Protocol input; validated as bounded JSON before and after transformation.\",\n  ),\n  causationId: taskMessageIdSchema\n    .optional()\n    .describe(\"Optional preceding message in this Task graph.\"),\n  expectAttempt: z\n    .number()\n    .int()\n    .positive()\n    .describe(\n      \"Source attempt retained in the immutable envelope for consumer fencing; Task lifecycle checks and inbox writes are not atomic.\",\n    ),\n});\n/** Validates an immutable, protocol-versioned Task message envelope. */\nexport const taskMessageSchema = sendTaskMessageInputSchema.extend({\n  schemaVersion: schemaVersionSchema,\n  id: taskMessageIdSchema,\n  createdAt: isoDateTimeSchema.describe(\"Engine timestamp fixed at operation reservation.\"),\n  delivery: z\n    .literal(\"result\")\n    .optional()\n    .describe(\n      \"Engine-controlled delivery from a terminal source Task under explicit workflow authorization.\",\n    ),\n});\n/** Validates a time-bounded claim on the current head of a Task inbox. */\nexport const taskMessageClaimSchema = z.strictObject({\n  messageId: taskMessageIdSchema,\n  toTaskId: taskIdSchema.describe(\"Recipient whose processing is serialized by this lease.\"),\n  generation: z\n    .number()\n    .int()\n    .positive()\n    .max(Number.MAX_SAFE_INTEGER)\n    .describe(\"Monotonically increasing inbox CAS fence, not an authorization credential.\"),\n  principalId: taskMessagePrincipalSchema.shape.id,\n  attempt: z.number().int().positive().describe(\"Recipient attempt when the lease was claimed.\"),\n  expiresAt: isoDateTimeSchema.describe(\n    \"Completion must be accepted before this engine timestamp.\",\n  ),\n});\n/** Validates the immutable acknowledgment that a claimed message's effects committed. */\nexport const taskMessageProcessingSchema = taskMessageClaimSchema.extend({\n  schemaVersion: schemaVersionSchema,\n  effectsCommitted: z\n    .literal(true)\n    .describe(\n      \"Caller attests its effects committed before processing acknowledgment; not exactly-once execution.\",\n    ),\n  completedAt: isoDateTimeSchema.describe(\n    \"Time the inbox CAS durably accepted the acknowledgment.\",\n  ),\n});\n/** Validates an explicitly authorized discard of an unleased inbox head. */\nexport const taskMessageDiscardSchema = z.strictObject({\n  schemaVersion: schemaVersionSchema,\n  messageId: taskMessageIdSchema,\n  toTaskId: taskIdSchema.describe(\"Recipient whose pending head was discarded.\"),\n  reason: z\n    .string()\n    .trim()\n    .min(1)\n    .max(2048)\n    .describe(\"Explicit authorized recovery reason, at most 2048 characters.\"),\n  by: taskMessagePrincipalSchema.describe(\n    \"Trusted application principal that authorized discarding, never payload identity.\",\n  ),\n  discardedAt: isoDateTimeSchema.describe(\n    \"Time the inbox CAS accepted the discard intent, not an effects acknowledgment.\",\n  ),\n});\n/** Validates immutable send intent reserved before inbox and envelope persistence complete. */\nexport const taskMessageReservationSchema = z\n  .strictObject({\n    schemaVersion: schemaVersionSchema,\n    message: taskMessageSchema.describe(\n      \"Immutable reserved intent; delivery exists only after inbox enqueue and envelope insertion.\",\n    ),\n    expectAttempt: sendTaskMessageInputSchema.shape.expectAttempt,\n  })\n  .refine((reservation) => reservation.expectAttempt === reservation.message.expectAttempt, {\n    message: \"Reservation and immutable envelope must retain the same source attempt\",\n  });\n/** Validates the bounded, directly addressed processing queue for one recipient Task. */\nexport const taskInboxSchema = z\n  .strictObject({\n    schemaVersion: schemaVersionSchema,\n    toTaskId: taskIdSchema.describe(\"Directly addressed recipient inbox identity.\"),\n    generation: z\n      .number()\n      .int()\n      .nonnegative()\n      .max(Number.MAX_SAFE_INTEGER)\n      .describe(\"Last allocated lease generation; never reset when the inbox drains.\"),\n    pending: z\n      .array(taskMessageSchema)\n      .max(MAX_TASK_INBOX_PENDING)\n      .readonly()\n      .describe(\n        \"Bounded durable envelope intents, retained until processing acknowledgment or explicit authorized discard.\",\n      ),\n    lease: taskMessageClaimSchema\n      .optional()\n      .describe(\"At most one active recipient processing claim.\"),\n    completion: taskMessageProcessingSchema\n      .optional()\n      .describe(\"CAS-accepted completion awaiting immutable processing-record repair.\"),\n    rejection: taskMessageDiscardSchema\n      .optional()\n      .describe(\n        \"CAS-accepted discard awaiting immutable discard-record repair; excludes active leases and completion.\",\n      ),\n  })\n  .superRefine((inbox, context) => {\n    const ids = new Set(inbox.pending.map((message) => message.id));\n    if (\n      ids.size !== inbox.pending.length ||\n      inbox.pending.some((message) => message.toTaskId !== inbox.toTaskId)\n    ) {\n      context.addIssue({\n        code: \"custom\",\n        message: \"Inbox intents must have unique IDs and match the recipient\",\n      });\n    }\n    if (\n      inbox.lease &&\n      (inbox.lease.toTaskId !== inbox.toTaskId ||\n        inbox.lease.generation !== inbox.generation ||\n        inbox.lease.messageId !== inbox.pending[0]?.id)\n    ) {\n      context.addIssue({\n        code: \"custom\",\n        message: \"Inbox lease must fence its first pending message at the current generation\",\n      });\n    }\n    if (\n      inbox.rejection &&\n      (inbox.lease ||\n        inbox.completion ||\n        inbox.rejection.toTaskId !== inbox.toTaskId ||\n        inbox.rejection.messageId !== inbox.pending[0]?.id)\n    ) {\n      context.addIssue({\n        code: \"custom\",\n        message:\n          \"Discard must identify the pending head and exclude leases and processing completion\",\n      });\n    }\n    if (inbox.completion) {\n      const {\n        schemaVersion: _schemaVersion,\n        effectsCommitted: _effectsCommitted,\n        completedAt: _completedAt,\n        ...lease\n      } = inbox.completion;\n      if (!isDeepStrictEqual(lease, inbox.lease))\n        context.addIssue({ code: \"custom\", message: \"Completion must match the active lease\" });\n    }\n  });\n\n/** Content-derived identity of an immutable Task message. */\nexport type TaskMessageId = z.infer<typeof taskMessageIdSchema>;\n/** Stable caller operation identity scoped to one source Task. */\nexport type TaskMessageOperationId = z.infer<typeof taskMessageOperationIdSchema>;\n/** Input payload accepted by one exact Task-message protocol binding. */\nexport type TaskMessageProtocolInputPayload<Type extends TaskMessageProtocolBinding> =\n  Type extends TaskMessageProtocolBinding<\n    infer Payload,\n    infer _Id,\n    infer _Version,\n    infer _StoredPayload\n  >\n    ? Payload\n    : JsonValue;\n/** Canonical payload stored by one exact Task-message protocol binding. */\nexport type TaskMessageProtocolStoredPayload<Type extends TaskMessageProtocolBinding> =\n  Type extends TaskMessageProtocolBinding<\n    infer _Payload,\n    infer _Id,\n    infer _Version,\n    infer StoredPayload\n  >\n    ? StoredPayload\n    : JsonValue;\n/** Caller-supplied idempotent intent with a payload correlated to its protocol binding. */\nexport type SendTaskMessageInput<\n  Type extends TaskMessageProtocolBinding = TaskMessageProtocolBinding,\n> = Readonly<Omit<z.infer<typeof sendTaskMessageInputSchema>, \"type\" | \"payload\">> & {\n  readonly type: Type;\n  readonly payload: NoInfer<TaskMessageProtocolInputPayload<Type>>;\n};\n/** Immutable versioned-protocol envelope exchanged by authorized Tasks in one graph. */\nexport type TaskMessage<Type extends TaskMessageProtocolBinding = TaskMessageProtocolBinding> =\n  Readonly<Omit<z.infer<typeof taskMessageSchema>, \"type\" | \"payload\">> & {\n    readonly type: Type;\n    readonly payload: TaskMessageProtocolStoredPayload<Type>;\n  };\n/** Application-authenticated identity used to authorize Task message operations. */\nexport type TaskMessagePrincipal = Readonly<z.infer<typeof taskMessagePrincipalSchema>>;\n/** Time-bounded, generation-fenced claim on a recipient's inbox head. */\nexport type TaskMessageClaim = Readonly<z.infer<typeof taskMessageClaimSchema>>;\n/** Immutable evidence that a claimed message's effects were committed and acknowledged. */\nexport type TaskMessageProcessing = Readonly<z.infer<typeof taskMessageProcessingSchema>>;\n/** Immutable evidence that an inbox head was explicitly discarded without applying effects. */\nexport type TaskMessageDiscard = Readonly<z.infer<typeof taskMessageDiscardSchema>>;\n/** Bounded durable queue and current processing state for one recipient Task. */\nexport type TaskInbox = z.infer<typeof taskInboxSchema>;\n\n/** Caller input accepted when defining one exact Task-message protocol. */\nexport interface TaskMessageProtocolInput<\n  Payload extends z.ZodType = z.ZodType,\n  Id extends string = string,\n  Version extends number = number,\n> {\n  readonly id: Id;\n  readonly version: Version;\n  readonly payload: Payload;\n  /** Required when the input transform changes shape. Stored validation must preserve the canonical JSON. */\n  readonly storedPayload?: z.ZodType<NoInfer<z.output<Payload>>>;\n  /** Defaults to attempt; task scope is an explicit trusted workflow initial/reconcile capability. */\n  readonly sourceFence?: \"attempt\" | \"task\";\n}\ntype TaskMessageJsonPayload<Value> = Value extends JsonValue ? Value : Value & JsonValue;\n\n/** Exact protocol contract with a typed binding for constructing message input. */\nexport interface TaskMessageProtocol<\n  Payload extends z.ZodType = z.ZodType,\n  Id extends string = string,\n  Version extends number = number,\n> extends TaskMessageProtocolInput<Payload, Id, Version> {\n  readonly binding: TaskMessageProtocolBinding<\n    TaskMessageJsonPayload<z.input<Payload>>,\n    Id,\n    Version,\n    TaskMessageJsonPayload<z.output<Payload>>\n  >;\n}\n/** Immutable message envelope validated against one exact Task-message protocol. */\nexport type TaskMessageForProtocol<Protocol extends TaskMessageProtocol> =\n  Protocol extends TaskMessageProtocol ? TaskMessage<Protocol[\"binding\"]> : never;\ntype TaskMessageProtocolForBinding<\n  Protocol extends TaskMessageProtocol,\n  Binding extends TaskMessageProtocolBinding,\n> = Protocol extends TaskMessageProtocol\n  ? Binding extends {\n      readonly id: Protocol[\"id\"];\n      readonly version: Protocol[\"version\"];\n    }\n    ? Protocol\n    : Protocol extends {\n          readonly id: Binding[\"id\"];\n          readonly version: Binding[\"version\"];\n        }\n      ? Protocol\n      : never\n  : never;\n/** Immutable registry of exact Task message protocol versions. */\nexport interface TaskMessageProtocols<Protocol extends TaskMessageProtocol = TaskMessageProtocol> {\n  readonly definitions: readonly Readonly<Protocol>[];\n  resolve<const Binding extends TaskMessageProtocolBinding>(\n    type: Binding,\n  ): Readonly<TaskMessageProtocolForBinding<Protocol, Binding>>;\n  sourceFence(type: TaskMessageProtocolBinding): \"attempt\" | \"task\";\n  validate<const Binding extends TaskMessageProtocolBinding>(\n    type: Binding,\n    payload: unknown,\n  ): TaskMessageProtocolStoredPayload<Binding>;\n  validateStored<const Binding extends TaskMessageProtocolBinding>(\n    type: Binding,\n    payload: unknown,\n  ): TaskMessageProtocolStoredPayload<Binding>;\n}\n\n/** Validates a Task-message protocol definition before it is registered. */\nexport const taskMessageProtocolSchema = z.strictObject({\n  ...taskMessageProtocolBindingFields,\n  payload: z.instanceof(z.ZodType).describe(\"Zod schema validating protocol input.\"),\n  storedPayload: z\n    .instanceof(z.ZodType)\n    .optional()\n    .describe(\"Canonical-preserving Zod schema validating stored payloads.\"),\n  sourceFence: z\n    .enum([\"attempt\", \"task\"])\n    .default(\"attempt\")\n    .describe(\"Source attempt fence; task scope requires explicit trusted workflow configuration.\"),\n});\ntype RegisteredTaskMessageProtocol<Definition extends TaskMessageProtocolInput> =\n  Definition extends TaskMessageProtocolInput<infer Payload, infer Id, infer Version>\n    ? TaskMessageProtocol<Payload, Id, Version>\n    : never;\n\nconst cloneProtocol = <Protocol extends TaskMessageProtocol>(\n  definition: Protocol,\n): Readonly<Protocol> =>\n  Object.freeze({\n    ...definition,\n    binding: Object.freeze(\n      parseTaskMessageProtocolBinding({\n        id: definition.binding.id,\n        version: definition.binding.version,\n      }),\n    ),\n    payload: definition.payload.clone(),\n    ...(definition.storedPayload === undefined\n      ? {}\n      : { storedPayload: definition.storedPayload.clone() }),\n  }) as Readonly<Protocol>;\n\n/** Validates, snapshots, and freezes one exact Task-message protocol definition. */\nexport function defineTaskMessageProtocol<\n  Payload extends z.ZodType,\n  const Id extends string,\n  const Version extends number,\n>(\n  definition: TaskMessageProtocolInput<Payload, Id, Version>,\n): Readonly<TaskMessageProtocol<Payload, Id, Version>> {\n  const input =\n    \"binding\" in definition ? (({ binding: _binding, ...rest }) => rest)(definition) : definition;\n  const parsed = taskMessageProtocolSchema.parse(input);\n  const protocol: TaskMessageProtocol<Payload, Id, Version> = {\n    id: definition.id,\n    version: definition.version,\n    binding: Object.freeze(\n      parseTaskMessageProtocolBinding({\n        id: definition.id,\n        version: definition.version,\n      }),\n    ) as TaskMessageProtocolBinding<\n      TaskMessageJsonPayload<z.input<Payload>>,\n      Id,\n      Version,\n      TaskMessageJsonPayload<z.output<Payload>>\n    >,\n    payload: definition.payload,\n    ...(definition.storedPayload === undefined ? {} : { storedPayload: definition.storedPayload }),\n    sourceFence: parsed.sourceFence,\n  };\n  return cloneProtocol(protocol);\n}\n\n/** Builds an exact-version protocol registry and rejects duplicate definitions. */\nexport function defineTaskMessageProtocols<const Definition extends TaskMessageProtocolInput>(\n  definitions: readonly Definition[],\n): TaskMessageProtocols<RegisteredTaskMessageProtocol<Definition>> {\n  type Protocol = RegisteredTaskMessageProtocol<Definition>;\n  const registry = new Map<string, Readonly<Protocol>>();\n  for (const definition of definitions) {\n    const protocol = defineTaskMessageProtocol(definition) as unknown as Readonly<Protocol>;\n    const key = `${protocol.id}@${protocol.version}`;\n    if (registry.has(key)) throw new Error(`Duplicate message protocol ${key}`);\n    registry.set(key, protocol);\n  }\n  function resolve<const Binding extends TaskMessageProtocolBinding>(\n    type: Binding,\n  ): Readonly<TaskMessageProtocolForBinding<Protocol, Binding>>;\n  function resolve(type: TaskMessageProtocolBinding): Readonly<Protocol> {\n    const { id, version } = taskMessageProtocolBindingSchema.parse(type);\n    const definition = registry.get(`${id}@${version}`);\n    if (!definition)\n      throw new Error(\n        `Unknown message protocol ${id}@${version}. Registered protocols: ${[...registry.keys()].join(\", \") || \"none\"}`,\n      );\n    return definition;\n  }\n  const validateStored = <const Binding extends TaskMessageProtocolBinding>(\n    type: Binding,\n    payload: unknown,\n  ): TaskMessageProtocolStoredPayload<Binding> => {\n    const definition = resolve(type);\n    const json = jsonValueSchema.parse(payload);\n    const validated = jsonValueSchema.parse(\n      (definition.storedPayload ?? definition.payload).parse(structuredClone(json)),\n    );\n    if (!isDeepStrictEqual(json, validated))\n      throw new Error(\n        \"Stored message protocol validation must preserve canonical JSON; provide storedPayload for transforming protocols\",\n      );\n    return structuredClone(validated) as TaskMessageProtocolStoredPayload<Binding>;\n  };\n  const resolveSnapshot = <const Binding extends TaskMessageProtocolBinding>(\n    type: Binding,\n  ): Readonly<TaskMessageProtocolForBinding<Protocol, Binding>> => cloneProtocol(resolve(type));\n  return Object.freeze({\n    get definitions() {\n      return Object.freeze([...registry.values()].map(cloneProtocol));\n    },\n    resolve: resolveSnapshot,\n    sourceFence(type: TaskMessageProtocolBinding): \"attempt\" | \"task\" {\n      return resolve(type).sourceFence ?? \"attempt\";\n    },\n    validateStored,\n    validate<const Binding extends TaskMessageProtocolBinding>(\n      type: Binding,\n      payload: unknown,\n    ): TaskMessageProtocolStoredPayload<Binding> {\n      const json = jsonValueSchema.parse(payload);\n      return validateStored(\n        type,\n        jsonValueSchema.parse(resolve(type).payload.parse(structuredClone(json))),\n      );\n    },\n  });\n}\n\n/** Constructs a send intent whose payload is checked against its protocol schema type. */\nexport function taskMessageInput<\n  Payload extends z.ZodType,\n  const Id extends string,\n  const Version extends number,\n>(\n  protocol: TaskMessageProtocol<Payload, Id, Version>,\n  input: Omit<SendTaskMessageInput, \"type\" | \"payload\"> & {\n    readonly payload: NoInfer<TaskMessageJsonPayload<z.input<Payload>>>;\n  },\n): SendTaskMessageInput<\n  TaskMessageProtocolBinding<\n    TaskMessageJsonPayload<z.input<Payload>>,\n    Id,\n    Version,\n    TaskMessageJsonPayload<z.output<Payload>>\n  >\n> {\n  const value = { ...input, type: protocol.binding };\n  sendTaskMessageInputSchema.parse(value);\n  return structuredClone(value) as SendTaskMessageInput<\n    TaskMessageProtocolBinding<\n      TaskMessageJsonPayload<z.input<Payload>>,\n      Id,\n      Version,\n      TaskMessageJsonPayload<z.output<Payload>>\n    >\n  >;\n}\n"],"mappings":"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"}