@vercel/factory 0.0.14 → 0.0.16

package/dist/store/slack-pr-notifications.d.mts

@@ -0,0 +1,44 @@
+import { RepositorySlug } from "../schema/repository.mjs";
+import { StoreDriver } from "./driver.mjs";
+import { SlackPrNotifications } from "../schema/slack-pr-notifications.mjs";
+import { z } from "zod";
+//#region src/store/slack-pr-notifications.d.ts
+declare const commandSchema: z.ZodObject<{
+  operationId: z.ZodString;
+  actor: z.ZodString;
+  preference: z.ZodUnion<readonly [z.ZodReadonly<z.ZodObject<{
+    channelId: z.ZodString;
+    mentionUserIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+  }, z.core.$strict>>, z.ZodNull, z.ZodLiteral<"config">]>;
+}, z.core.$strict>;
+/** Effective PR notification settings and the source of the current choice. */
+interface SlackPrNotificationSnapshot {
+  readonly revision: number;
+  readonly source: "config" | "slack";
+  readonly settings: SlackPrNotifications | null;
+  readonly updatedBy?: string;
+  readonly updatedAt?: string;
+}
+/** A trusted Slack command: an object enables notifications, null disables them, and config resets. */
+type UpdateSlackPrNotificationsInput = z.infer<typeof commandSchema>;
+/** Durable PR notification preferences scoped to a connector, workspace, and optional repository. */
+interface SlackPrNotificationStore {
+  get(): Promise<SlackPrNotificationSnapshot>;
+  /** The caller authenticates the operator; operationId must identify the original Slack message. */
+  update(input: UpdateSlackPrNotificationsInput): Promise<SlackPrNotificationSnapshot>;
+}
+/** Persistence scope and Git-configured fallback for PR notification preferences. */
+interface SlackPrNotificationStoreOptions {
+  readonly driver: StoreDriver;
+  readonly connector: string;
+  readonly workspaceId: string;
+  /** Omit for the factory-wide default; supply a slug to isolate one repository's preferences. */
+  readonly repository?: RepositorySlug;
+  readonly defaults?: SlackPrNotifications | null;
+  readonly now?: () => string;
+}
+/** Creates directly addressed settings with immutable command intents and compare-and-swap updates. */
+declare function createSlackPrNotificationStore({ driver, connector, workspaceId, repository, defaults, now }: SlackPrNotificationStoreOptions): SlackPrNotificationStore;
+//#endregion
+export { SlackPrNotificationSnapshot, SlackPrNotificationStore, SlackPrNotificationStoreOptions, UpdateSlackPrNotificationsInput, createSlackPrNotificationStore };
+//# sourceMappingURL=slack-pr-notifications.d.mts.map

package/dist/store/slack-pr-notifications.mjs

@@ -0,0 +1,121 @@
+import { repositorySlugSchema } from "../schema/repository.mjs";
+import { slackPrNotificationsSchema } from "../schema/slack-pr-notifications.mjs";
+import { createHash } from "node:crypto";
+import { z } from "zod";
+//#region src/store/slack-pr-notifications.ts
+const preferenceSchema = z.union([
+	slackPrNotificationsSchema,
+	z.null(),
+	z.literal("config")
+]);
+const commandSchema = z.strictObject({
+	operationId: z.string().min(1).max(512).describe("Stable identity of the authenticated Slack message."),
+	actor: z.string().regex(/^slack:T[A-Z0-9]+:[UW][A-Z0-9]+$/u).describe("Authenticated Slack operator making this choice."),
+	preference: preferenceSchema.describe("Destination override, null to disable, or config to restore the file default.")
+});
+const recordSchema = commandSchema.extend({
+	schemaVersion: z.literal(1).describe("Persisted settings format version."),
+	expectedRevision: z.number().int().nonnegative().describe("Settings revision observed when this command was first recorded."),
+	updatedAt: z.iso.datetime().describe("Time the command was first recorded.")
+});
+function isConflict(error, ...names) {
+	return error instanceof Error && names.includes(error.name);
+}
+/** Creates directly addressed settings with immutable command intents and compare-and-swap updates. */
+function createSlackPrNotificationStore({ driver, connector, workspaceId, repository, defaults, now = () => (/* @__PURE__ */ new Date()).toISOString() }) {
+	z.string().regex(/^slack\/[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/u).parse(connector);
+	z.string().regex(/^T[A-Z0-9]+$/u).parse(workspaceId);
+	if (repository !== void 0) repositorySlugSchema.parse(repository);
+	const fallback = defaults == null ? null : slackPrNotificationsSchema.parse(defaults);
+	const hash = (value) => createHash("sha256").update(value).digest("hex");
+	const id = `slack-pr-${hash(JSON.stringify(repository === void 0 ? [connector, workspaceId] : [
+		connector,
+		workspaceId,
+		repository
+	]))}`;
+	const collection = "communicationSettings";
+	async function read() {
+		const record = await driver.get(collection, id);
+		return record === null ? null : {
+			version: record.version,
+			value: recordSchema.parse(record.value)
+		};
+	}
+	function snapshot(record) {
+		const preference = record === null ? "config" : record.value.preference;
+		return {
+			revision: record?.version ?? 0,
+			source: preference === "config" ? "config" : "slack",
+			settings: preference === "config" ? fallback : preference,
+			...record && {
+				updatedBy: record.value.actor,
+				updatedAt: record.value.updatedAt
+			}
+		};
+	}
+	async function update(value) {
+		const input = commandSchema.parse(value);
+		if (!input.actor.startsWith(`slack:${workspaceId}:`)) throw new Error("PR notification operator belongs to another Slack workspace.");
+		const commandId = `${id}-command-${hash(input.operationId)}`;
+		let command = await driver.get(collection, commandId);
+		if (command === null) {
+			const current = await read();
+			const intent = recordSchema.parse({
+				...input,
+				schemaVersion: 1,
+				expectedRevision: current?.version ?? 0,
+				updatedAt: now()
+			});
+			try {
+				await driver.insert({
+					collection,
+					id: commandId,
+					value: intent
+				});
+			} catch (error) {
+				if (!isConflict(error, "RecordExistsError")) throw error;
+			}
+			command = await driver.get(collection, commandId);
+		}
+		if (command === null) throw new Error("PR notification command was not saved.");
+		const intent = recordSchema.parse(command.value);
+		if (JSON.stringify({
+			operationId: intent.operationId,
+			actor: intent.actor,
+			preference: intent.preference
+		}) !== JSON.stringify(input)) throw new Error("This Slack message already requested different PR notification settings.");
+		const current = await read();
+		if (current?.value.operationId === input.operationId) return snapshot(current);
+		if ((current?.version ?? 0) !== intent.expectedRevision) throw new Error("PR notification settings changed after this command. Send a new Slack message to change them again.");
+		try {
+			if (current === null) await driver.insert({
+				collection,
+				id,
+				value: intent
+			});
+			else await driver.update({
+				collection,
+				id,
+				value: intent,
+				expectedVersion: current.version
+			});
+		} catch (error) {
+			if (!isConflict(error, "RecordExistsError", "VersionConflictError")) throw error;
+			const winner = await read();
+			if (winner?.value.operationId === input.operationId) return snapshot(winner);
+			throw new Error("Another command changed PR notification settings. Send a new Slack message to change them again.", { cause: error });
+		}
+		return snapshot({
+			value: intent,
+			version: intent.expectedRevision + 1
+		});
+	}
+	return {
+		get: async () => snapshot(await read()),
+		update
+	};
+}
+//#endregion
+export { createSlackPrNotificationStore };
+
+//# sourceMappingURL=slack-pr-notifications.mjs.map

package/dist/store/slack-pr-notifications.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"slack-pr-notifications.mjs","names":[],"sources":["../../src/store/slack-pr-notifications.ts"],"sourcesContent":["import { createHash } from \"node:crypto\";\nimport { z } from \"zod\";\nimport {\n  slackPrNotificationsSchema,\n  type SlackPrNotifications,\n} from \"../schema/slack-pr-notifications\";\nimport type { StoreDriver } from \"./driver\";\nimport { repositorySlugSchema, type RepositorySlug } from \"../schema/repository\";\n\nconst preferenceSchema = z.union([slackPrNotificationsSchema, z.null(), z.literal(\"config\")]);\nconst commandSchema = z.strictObject({\n  operationId: z\n    .string()\n    .min(1)\n    .max(512)\n    .describe(\"Stable identity of the authenticated Slack message.\"),\n  actor: z\n    .string()\n    .regex(/^slack:T[A-Z0-9]+:[UW][A-Z0-9]+$/u)\n    .describe(\"Authenticated Slack operator making this choice.\"),\n  preference: preferenceSchema.describe(\n    \"Destination override, null to disable, or config to restore the file default.\",\n  ),\n});\nconst recordSchema = commandSchema.extend({\n  schemaVersion: z.literal(1).describe(\"Persisted settings format version.\"),\n  expectedRevision: z\n    .number()\n    .int()\n    .nonnegative()\n    .describe(\"Settings revision observed when this command was first recorded.\"),\n  updatedAt: z.iso.datetime().describe(\"Time the command was first recorded.\"),\n});\n\n// Drivers loaded through separate package entry points have distinct error constructors.\nfunction isConflict(error: unknown, ...names: string[]): boolean {\n  return error instanceof Error && names.includes(error.name);\n}\n\n/** Effective PR notification settings and the source of the current choice. */\nexport interface SlackPrNotificationSnapshot {\n  readonly revision: number;\n  readonly source: \"config\" | \"slack\";\n  readonly settings: SlackPrNotifications | null;\n  readonly updatedBy?: string;\n  readonly updatedAt?: string;\n}\n\n/** A trusted Slack command: an object enables notifications, null disables them, and config resets. */\nexport type UpdateSlackPrNotificationsInput = z.infer<typeof commandSchema>;\n\n/** Durable PR notification preferences scoped to a connector, workspace, and optional repository. */\nexport interface SlackPrNotificationStore {\n  get(): Promise<SlackPrNotificationSnapshot>;\n  /** The caller authenticates the operator; operationId must identify the original Slack message. */\n  update(input: UpdateSlackPrNotificationsInput): Promise<SlackPrNotificationSnapshot>;\n}\n\n/** Persistence scope and Git-configured fallback for PR notification preferences. */\nexport interface SlackPrNotificationStoreOptions {\n  readonly driver: StoreDriver;\n  readonly connector: string;\n  readonly workspaceId: string;\n  /** Omit for the factory-wide default; supply a slug to isolate one repository's preferences. */\n  readonly repository?: RepositorySlug;\n  readonly defaults?: SlackPrNotifications | null;\n  readonly now?: () => string;\n}\n\n/** Creates directly addressed settings with immutable command intents and compare-and-swap updates. */\nexport function createSlackPrNotificationStore({\n  driver,\n  connector,\n  workspaceId,\n  repository,\n  defaults,\n  now = () => new Date().toISOString(),\n}: SlackPrNotificationStoreOptions): SlackPrNotificationStore {\n  z.string()\n    .regex(/^slack\\/[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/u)\n    .parse(connector);\n  z.string()\n    .regex(/^T[A-Z0-9]+$/u)\n    .parse(workspaceId);\n  if (repository !== undefined) repositorySlugSchema.parse(repository);\n  const fallback = defaults == null ? null : slackPrNotificationsSchema.parse(defaults);\n  const hash = (value: string) => createHash(\"sha256\").update(value).digest(\"hex\");\n  const scope =\n    repository === undefined ? [connector, workspaceId] : [connector, workspaceId, repository];\n  const id = `slack-pr-${hash(JSON.stringify(scope))}`;\n  const collection = \"communicationSettings\";\n\n  async function read() {\n    const record = await driver.get(collection, id);\n    return record === null\n      ? null\n      : { version: record.version, value: recordSchema.parse(record.value) };\n  }\n\n  function snapshot(record: Awaited<ReturnType<typeof read>>): SlackPrNotificationSnapshot {\n    const preference = record === null ? \"config\" : record.value.preference;\n    return {\n      revision: record?.version ?? 0,\n      source: preference === \"config\" ? \"config\" : \"slack\",\n      settings: preference === \"config\" ? fallback : preference,\n      ...(record && { updatedBy: record.value.actor, updatedAt: record.value.updatedAt }),\n    };\n  }\n\n  async function update(value: UpdateSlackPrNotificationsInput) {\n    const input = commandSchema.parse(value);\n    if (!input.actor.startsWith(`slack:${workspaceId}:`))\n      throw new Error(\"PR notification operator belongs to another Slack workspace.\");\n    const commandId = `${id}-command-${hash(input.operationId)}`;\n    let command = await driver.get(collection, commandId);\n    if (command === null) {\n      const current = await read();\n      const intent = recordSchema.parse({\n        ...input,\n        schemaVersion: 1,\n        expectedRevision: current?.version ?? 0,\n        updatedAt: now(),\n      });\n      try {\n        await driver.insert({ collection, id: commandId, value: intent });\n      } catch (error) {\n        if (!isConflict(error, \"RecordExistsError\")) throw error;\n      }\n      command = await driver.get(collection, commandId);\n    }\n    if (command === null) throw new Error(\"PR notification command was not saved.\");\n    const intent = recordSchema.parse(command.value);\n    if (\n      JSON.stringify({\n        operationId: intent.operationId,\n        actor: intent.actor,\n        preference: intent.preference,\n      }) !== JSON.stringify(input)\n    )\n      throw new Error(\"This Slack message already requested different PR notification settings.\");\n\n    const current = await read();\n    if (current?.value.operationId === input.operationId) return snapshot(current);\n    if ((current?.version ?? 0) !== intent.expectedRevision)\n      throw new Error(\n        \"PR notification settings changed after this command. Send a new Slack message to change them again.\",\n      );\n    try {\n      if (current === null) await driver.insert({ collection, id, value: intent });\n      else await driver.update({ collection, id, value: intent, expectedVersion: current.version });\n    } catch (error) {\n      if (!isConflict(error, \"RecordExistsError\", \"VersionConflictError\")) throw error;\n      const winner = await read();\n      if (winner?.value.operationId === input.operationId) return snapshot(winner);\n      throw new Error(\n        \"Another command changed PR notification settings. Send a new Slack message to change them again.\",\n        { cause: error },\n      );\n    }\n    return snapshot({ value: intent, version: intent.expectedRevision + 1 });\n  }\n\n  return { get: async () => snapshot(await read()), update };\n}\n"],"mappings":"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"}

package/dist/store/task-effects.d.mts

@@ -0,0 +1,38 @@
+import { TaskId } from "../schema/id.mjs";
+import { Task } from "../schema/task.mjs";
+import { IsoDateTimeClock } from "../schema/common.mjs";
+import { StoreDriver } from "./driver.mjs";
+import { TaskEffect, TaskEffectKey, TaskEffectReference } from "../schema/task-effect.mjs";
+//#region src/store/task-effects.d.ts
+/** Persistence, clock, and Task lookup dependencies for the Task effect store. */
+interface CreateTaskEffectStoreOptions {
+  driver: StoreDriver;
+  now: IsoDateTimeClock;
+  getTask: (id: TaskId) => Promise<Task | null>;
+}
+/** Task identity and namespaced key identifying one durable external effect. */
+interface TaskEffectLookupInput {
+  readonly taskId: TaskId;
+  readonly key: TaskEffectKey;
+}
+/** Task-scoped effect key and first external-resource reference to record. */
+interface RecordTaskEffectInput extends TaskEffectLookupInput {
+  readonly reference: TaskEffectReference;
+}
+/** Task-scoped effect key and optional explicit resolution timestamp. */
+interface ResolveTaskEffectInput extends TaskEffectLookupInput {
+  readonly at?: string;
+}
+/** Durable, Task-scoped external-resource references and write-once resolution stamps. */
+interface TaskEffectStore {
+  get(input: TaskEffectLookupInput): Promise<TaskEffect | null>;
+  /** Record the first external resource created for this key. Replays return that first record. */
+  record(input: RecordTaskEffectInput): Promise<TaskEffect>;
+  /** Stamp the effect resolved once, including when no external resource was found. */
+  resolve(input: ResolveTaskEffectInput): Promise<TaskEffect>;
+}
+/** Creates a CAS-protected store for idempotent Task effect reconciliation. */
+declare function createTaskEffectStore(options: CreateTaskEffectStoreOptions): TaskEffectStore;
+//#endregion
+export { CreateTaskEffectStoreOptions, RecordTaskEffectInput, ResolveTaskEffectInput, TaskEffectLookupInput, TaskEffectStore, createTaskEffectStore };
+//# sourceMappingURL=task-effects.d.mts.map

package/dist/store/task-effects.mjs

@@ -0,0 +1,118 @@
+import { taskIdSchema } from "../schema/id.mjs";
+import { isoDateTimeSchema } from "../schema/common.mjs";
+import { RecordExistsError, RecordNotFoundError, VersionConflictError } from "./driver.mjs";
+import { taskEffectKeySchema, taskEffectReferenceSchema, taskEffectSchema } from "../schema/task-effect.mjs";
+import { createHash } from "node:crypto";
+//#region src/store/task-effects.ts
+function recordId(taskId, key) {
+	return `effect_${createHash("sha256").update(JSON.stringify([
+		taskId,
+		key.namespace,
+		key.name
+	])).digest("hex").slice(0, 32)}`;
+}
+/** Creates a CAS-protected store for idempotent Task effect reconciliation. */
+function createTaskEffectStore(options) {
+	async function assertTask(taskId) {
+		if (await options.getTask(taskId) === null) throw new RecordNotFoundError("tasks", taskId);
+	}
+	async function read(taskId, key) {
+		const id = recordId(taskId, key);
+		const stored = await options.driver.get("taskEffects", id);
+		if (stored === null) return null;
+		const effect = taskEffectSchema.parse(stored.value);
+		if (effect.taskId !== taskId || effect.key.namespace !== key.namespace || effect.key.name !== key.name) throw new Error(`Task effect ${id} does not match its storage key`);
+		return {
+			effect,
+			id,
+			version: stored.version
+		};
+	}
+	return {
+		async get(input) {
+			return (await read(taskIdSchema.parse(input.taskId), taskEffectKeySchema.parse(input.key)))?.effect ?? null;
+		},
+		async record(input) {
+			const taskId = taskIdSchema.parse(input.taskId);
+			const key = taskEffectKeySchema.parse(input.key);
+			const reference = taskEffectReferenceSchema.parse(input.reference);
+			await assertTask(taskId);
+			for (;;) {
+				const existing = await read(taskId, key);
+				if (existing?.effect.reference !== void 0) return existing.effect;
+				const timestamp = options.now();
+				const next = taskEffectSchema.parse(existing === null ? {
+					schemaVersion: 1,
+					taskId,
+					key,
+					reference,
+					createdAt: timestamp,
+					updatedAt: timestamp
+				} : {
+					...existing.effect,
+					reference,
+					updatedAt: timestamp
+				});
+				try {
+					if (existing === null) await options.driver.insert({
+						collection: "taskEffects",
+						id: recordId(taskId, key),
+						value: next
+					});
+					else await options.driver.update({
+						collection: "taskEffects",
+						id: existing.id,
+						value: next,
+						expectedVersion: existing.version
+					});
+					return next;
+				} catch (error) {
+					if (!(error instanceof RecordExistsError || error instanceof VersionConflictError)) throw error;
+				}
+			}
+		},
+		async resolve(input) {
+			const taskId = taskIdSchema.parse(input.taskId);
+			const key = taskEffectKeySchema.parse(input.key);
+			const resolvedAt = isoDateTimeSchema.parse(input.at ?? options.now());
+			await assertTask(taskId);
+			for (;;) {
+				const existing = await read(taskId, key);
+				if (existing?.effect.resolvedAt !== void 0) return existing.effect;
+				const timestamp = options.now();
+				const next = taskEffectSchema.parse(existing === null ? {
+					schemaVersion: 1,
+					taskId,
+					key,
+					resolvedAt,
+					createdAt: timestamp,
+					updatedAt: timestamp
+				} : {
+					...existing.effect,
+					resolvedAt,
+					updatedAt: timestamp
+				});
+				try {
+					if (existing === null) await options.driver.insert({
+						collection: "taskEffects",
+						id: recordId(taskId, key),
+						value: next
+					});
+					else await options.driver.update({
+						collection: "taskEffects",
+						id: existing.id,
+						value: next,
+						expectedVersion: existing.version
+					});
+					return next;
+				} catch (error) {
+					if (!(error instanceof RecordExistsError || error instanceof VersionConflictError)) throw error;
+				}
+			}
+		}
+	};
+}
+//#endregion
+export { createTaskEffectStore };
+
+//# sourceMappingURL=task-effects.mjs.map

package/dist/store/task-effects.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-effects.mjs","names":[],"sources":["../../src/store/task-effects.ts"],"sourcesContent":["import { createHash } from \"node:crypto\";\nimport { SCHEMA_VERSION, isoDateTimeSchema, type IsoDateTimeClock } from \"../schema/common\";\nimport { taskIdSchema, type TaskId } from \"../schema/id\";\nimport type { Task } from \"../schema/task\";\nimport {\n  taskEffectKeySchema,\n  taskEffectReferenceSchema,\n  taskEffectSchema,\n  type TaskEffect,\n  type TaskEffectKey,\n  type TaskEffectReference,\n} from \"../schema/task-effect\";\nimport {\n  RecordExistsError,\n  RecordNotFoundError,\n  VersionConflictError,\n  type StoreDriver,\n} from \"./driver\";\n\n/** Persistence, clock, and Task lookup dependencies for the Task effect store. */\nexport interface CreateTaskEffectStoreOptions {\n  driver: StoreDriver;\n  now: IsoDateTimeClock;\n  getTask: (id: TaskId) => Promise<Task | null>;\n}\n\n/** Task identity and namespaced key identifying one durable external effect. */\nexport interface TaskEffectLookupInput {\n  readonly taskId: TaskId;\n  readonly key: TaskEffectKey;\n}\n\n/** Task-scoped effect key and first external-resource reference to record. */\nexport interface RecordTaskEffectInput extends TaskEffectLookupInput {\n  readonly reference: TaskEffectReference;\n}\n\n/** Task-scoped effect key and optional explicit resolution timestamp. */\nexport interface ResolveTaskEffectInput extends TaskEffectLookupInput {\n  readonly at?: string;\n}\n\n/** Durable, Task-scoped external-resource references and write-once resolution stamps. */\nexport interface TaskEffectStore {\n  get(input: TaskEffectLookupInput): Promise<TaskEffect | null>;\n  /** Record the first external resource created for this key. Replays return that first record. */\n  record(input: RecordTaskEffectInput): Promise<TaskEffect>;\n  /** Stamp the effect resolved once, including when no external resource was found. */\n  resolve(input: ResolveTaskEffectInput): Promise<TaskEffect>;\n}\n\nfunction recordId(taskId: TaskId, key: TaskEffectKey): string {\n  const digest = createHash(\"sha256\")\n    .update(JSON.stringify([taskId, key.namespace, key.name]))\n    .digest(\"hex\");\n  return `effect_${digest.slice(0, 32)}`;\n}\n\n/** Creates a CAS-protected store for idempotent Task effect reconciliation. */\nexport function createTaskEffectStore(options: CreateTaskEffectStoreOptions): TaskEffectStore {\n  async function assertTask(taskId: TaskId): Promise<void> {\n    if ((await options.getTask(taskId)) === null) throw new RecordNotFoundError(\"tasks\", taskId);\n  }\n\n  async function read(taskId: TaskId, key: TaskEffectKey) {\n    const id = recordId(taskId, key);\n    const stored = await options.driver.get(\"taskEffects\", id);\n    if (stored === null) return null;\n    const effect = taskEffectSchema.parse(stored.value);\n    if (\n      effect.taskId !== taskId ||\n      effect.key.namespace !== key.namespace ||\n      effect.key.name !== key.name\n    ) {\n      throw new Error(`Task effect ${id} does not match its storage key`);\n    }\n    return { effect, id, version: stored.version };\n  }\n\n  return {\n    async get(input) {\n      const taskId = taskIdSchema.parse(input.taskId);\n      const key = taskEffectKeySchema.parse(input.key);\n      return (await read(taskId, key))?.effect ?? null;\n    },\n\n    async record(input) {\n      const taskId = taskIdSchema.parse(input.taskId);\n      const key = taskEffectKeySchema.parse(input.key);\n      const reference = taskEffectReferenceSchema.parse(input.reference);\n      await assertTask(taskId);\n      for (;;) {\n        const existing = await read(taskId, key);\n        if (existing?.effect.reference !== undefined) return existing.effect;\n        const timestamp = options.now();\n        const next = taskEffectSchema.parse(\n          existing === null\n            ? {\n                schemaVersion: SCHEMA_VERSION,\n                taskId,\n                key,\n                reference,\n                createdAt: timestamp,\n                updatedAt: timestamp,\n              }\n            : { ...existing.effect, reference, updatedAt: timestamp },\n        );\n        try {\n          if (existing === null)\n            await options.driver.insert({\n              collection: \"taskEffects\",\n              id: recordId(taskId, key),\n              value: next,\n            });\n          else\n            await options.driver.update({\n              collection: \"taskEffects\",\n              id: existing.id,\n              value: next,\n              expectedVersion: existing.version,\n            });\n          return next;\n        } catch (error) {\n          if (!(error instanceof RecordExistsError || error instanceof VersionConflictError))\n            throw error;\n        }\n      }\n    },\n\n    async resolve(input) {\n      const taskId = taskIdSchema.parse(input.taskId);\n      const key = taskEffectKeySchema.parse(input.key);\n      const resolvedAt = isoDateTimeSchema.parse(input.at ?? options.now());\n      await assertTask(taskId);\n      for (;;) {\n        const existing = await read(taskId, key);\n        if (existing?.effect.resolvedAt !== undefined) return existing.effect;\n        const timestamp = options.now();\n        const next = taskEffectSchema.parse(\n          existing === null\n            ? {\n                schemaVersion: SCHEMA_VERSION,\n                taskId,\n                key,\n                resolvedAt,\n                createdAt: timestamp,\n                updatedAt: timestamp,\n              }\n            : { ...existing.effect, resolvedAt, updatedAt: timestamp },\n        );\n        try {\n          if (existing === null)\n            await options.driver.insert({\n              collection: \"taskEffects\",\n              id: recordId(taskId, key),\n              value: next,\n            });\n          else\n            await options.driver.update({\n              collection: \"taskEffects\",\n              id: existing.id,\n              value: next,\n              expectedVersion: existing.version,\n            });\n          return next;\n        } catch (error) {\n          if (!(error instanceof RecordExistsError || error instanceof VersionConflictError))\n            throw error;\n        }\n      }\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/store/task-graphs.d.mts

@@ -0,0 +1,60 @@
+import { TaskId } from "../schema/id.mjs";
+import { Task } from "../schema/task.mjs";
+import { WorkNotification } from "./work-notifications.mjs";
+import { IsoDateTimeClock } from "../schema/common.mjs";
+import { StoreDriver } from "./driver.mjs";
+import { TaskGraph } from "../schema/task-graph.mjs";
+//#region src/store/task-graphs.d.ts
+/** Engine-owned persistence and validation dependencies for canonical Task graphs. */
+interface CreateTaskGraphStoreOptions {
+  driver: StoreDriver;
+  now: IsoDateTimeClock;
+  getTask: (id: TaskId) => Promise<Task | null>;
+  validateTask: (task: Task) => void;
+  notify?: (event: WorkNotification) => Promise<void>;
+}
+/** Canonical bounded graph store for Task membership, ownership, and dependency edges. */
+interface TaskGraphStore {
+  admit(input: AdmitTaskGraphInput): Promise<void>;
+  get(rootTaskId: TaskId): Promise<TaskGraph | null>;
+  setDependencies(input: SetTaskGraphDependenciesInput): Promise<TaskGraph>;
+  dependenciesSatisfied(input: TaskGraphNodeRef): Promise<boolean>;
+  /** Call before every Task transition to running. First admission freezes edges, even if launch fails. */
+  seal(input: TaskGraphNodeRef): Promise<void>;
+}
+/** Canonical Task snapshot and initial dependency edges admitted atomically to its graph. */
+interface AdmitTaskGraphInput {
+  task: Task;
+  dependencies?: readonly TaskId[];
+}
+/** Identifies one Task within its canonical root graph. */
+interface TaskGraphNodeRef {
+  rootTaskId: TaskId;
+  taskId: TaskId;
+}
+/** Revision-fenced replacement of one queued Task's graph dependencies. */
+interface SetTaskGraphDependenciesInput extends TaskGraphNodeRef {
+  dependencies: readonly TaskId[];
+  expectedRevision: number;
+}
+/** Error raised when a creation retry differs from immutable graph admission intent. */
+declare class TaskGraphConflictError extends Error {
+  constructor(taskId: TaskId);
+}
+/** Canonical Task and immutable graph admission snapshot to compare. */
+interface AssertTaskAdmissionInput {
+  task: Task;
+  admission: Task;
+}
+/** Verifies that a canonical Task preserves the immutable identity admitted to its graph. */
+declare function assertTaskAdmission({ task, admission }: AssertTaskAdmissionInput): void;
+/**
+ * Trusted engine/workflow capability, not an agent tool or HTTP boundary: callers own
+ * authentication and workflow binding validation. The engine seals dependencies before
+ * transitioning to running; sealing survives a failed launch and rechecks prerequisites
+ * on retries. Succeeded prerequisites are terminal under the engine's transition rules.
+ */
+declare function createTaskGraphStore({ driver, now, getTask, validateTask, notify }: CreateTaskGraphStoreOptions): TaskGraphStore;
+//#endregion
+export { AdmitTaskGraphInput, AssertTaskAdmissionInput, CreateTaskGraphStoreOptions, SetTaskGraphDependenciesInput, TaskGraphConflictError, TaskGraphNodeRef, TaskGraphStore, assertTaskAdmission, createTaskGraphStore };
+//# sourceMappingURL=task-graphs.d.mts.map

package/dist/store/task-graphs.mjs

@@ -0,0 +1,212 @@
+import { taskIdSchema } from "../schema/id.mjs";
+import "../schema/common.mjs";
+import { taskSchema } from "../schema/task.mjs";
+import { RecordExistsError, RecordNotFoundError, VersionConflictError } from "./driver.mjs";
+import { taskGraphAdmissionSchema, taskGraphDependenciesSchema, taskGraphSchema } from "../schema/task-graph.mjs";
+import { z } from "zod";
+import { isDeepStrictEqual } from "node:util";
+//#region src/store/task-graphs.ts
+/** Error raised when a creation retry differs from immutable graph admission intent. */
+var TaskGraphConflictError = class extends Error {
+	constructor(taskId) {
+		super(`Task ${taskId} conflicts with its immutable graph admission; reuse the original creation intent`);
+		this.name = "TaskGraphConflictError";
+	}
+};
+function immutableTaskIdentity(task) {
+	const { id, rootTaskId, parentTaskId, repositoryIds, work, kind, origin, replyTo, area } = task;
+	return JSON.parse(JSON.stringify({
+		id,
+		rootTaskId,
+		parentTaskId,
+		repositoryIds,
+		work,
+		kind,
+		origin,
+		replyTo,
+		area
+	}));
+}
+/** Verifies that a canonical Task preserves the immutable identity admitted to its graph. */
+function assertTaskAdmission({ task, admission }) {
+	if (!isDeepStrictEqual(immutableTaskIdentity(task), immutableTaskIdentity(admission))) throw new TaskGraphConflictError(admission.id);
+}
+function creationIntent({ createdAt: _createdAt, updatedAt: _updatedAt, ...intent }) {
+	return JSON.parse(JSON.stringify(intent));
+}
+/**
+* Trusted engine/workflow capability, not an agent tool or HTTP boundary: callers own
+* authentication and workflow binding validation. The engine seals dependencies before
+* transitioning to running; sealing survives a failed launch and rechecks prerequisites
+* on retries. Succeeded prerequisites are terminal under the engine's transition rules.
+*/
+function createTaskGraphStore({ driver, now, getTask, validateTask, notify }) {
+	async function read(rootTaskId) {
+		taskIdSchema.parse(rootTaskId);
+		const record = await driver.get("taskGraphs", rootTaskId);
+		if (!record) return null;
+		const graph = taskGraphSchema.parse(record.value);
+		for (const node of graph.nodes) validateTask(node.admission);
+		if (graph.rootTaskId !== rootTaskId) throw new Error("Stored graph root does not match its storage key");
+		return {
+			graph,
+			version: record.version
+		};
+	}
+	async function canonical(node) {
+		const value = await getTask(node.taskId);
+		if (value === null) return null;
+		const task = taskSchema.parse(value);
+		validateTask(task);
+		assertTaskAdmission({
+			task,
+			admission: node.admission
+		});
+		return task;
+	}
+	async function satisfied(graph, node) {
+		for (const id of node.dependencies) {
+			const dependency = graph.nodes.find((entry) => entry.taskId === id);
+			if (!dependency || (await canonical(dependency))?.state !== "succeeded") return false;
+		}
+		return true;
+	}
+	return {
+		async admit(input) {
+			const task = structuredClone(taskGraphAdmissionSchema.parse(input.task));
+			validateTask(task);
+			const initialDependencies = taskGraphDependenciesSchema.parse(input.dependencies ?? []);
+			const rootTaskId = taskIdSchema.parse(task.rootTaskId);
+			const node = {
+				taskId: task.id,
+				...task.parentTaskId === void 0 ? {} : { parentTaskId: task.parentTaskId },
+				dependencies: initialDependencies,
+				sealed: false,
+				admissionDependencies: [...initialDependencies],
+				admission: task
+			};
+			await canonical(node);
+			for (;;) {
+				const current = await read(rootTaskId);
+				const existing = current?.graph.nodes.find((entry) => entry.taskId === task.id);
+				if (existing) {
+					if (!isDeepStrictEqual(creationIntent(existing.admission), creationIntent(task)) || !isDeepStrictEqual(existing.admissionDependencies, initialDependencies)) throw new TaskGraphConflictError(task.id);
+					return;
+				}
+				const timestamp = now();
+				const graph = taskGraphSchema.parse(current ? {
+					...current.graph,
+					revision: current.graph.revision + 1,
+					nodes: [...current.graph.nodes, node],
+					updatedAt: timestamp
+				} : {
+					schemaVersion: 1,
+					rootTaskId,
+					revision: 1,
+					nodes: [node],
+					createdAt: timestamp,
+					updatedAt: timestamp
+				});
+				try {
+					if (current) await driver.update({
+						collection: "taskGraphs",
+						id: rootTaskId,
+						value: graph,
+						expectedVersion: current.version
+					});
+					else await driver.insert({
+						collection: "taskGraphs",
+						id: rootTaskId,
+						value: graph
+					});
+					return;
+				} catch (error) {
+					if (!(error instanceof RecordExistsError || error instanceof VersionConflictError)) throw error;
+				}
+			}
+		},
+		async get(rootTaskId) {
+			return (await read(rootTaskId))?.graph ?? null;
+		},
+		async setDependencies(input) {
+			const { rootTaskId, taskId, dependencies, expectedRevision } = input;
+			taskIdSchema.parse(taskId);
+			z.number().int().positive().parse(expectedRevision);
+			const edges = taskGraphDependenciesSchema.parse(dependencies);
+			const current = await read(rootTaskId);
+			if (!current) throw new RecordNotFoundError("taskGraphs", rootTaskId);
+			if (current.graph.revision !== expectedRevision) throw new VersionConflictError("taskGraphs", rootTaskId, expectedRevision);
+			const node = current.graph.nodes.find((entry) => entry.taskId === taskId);
+			if (!node) throw new Error(`Task ${taskId} is not registered in graph ${rootTaskId}`);
+			if (node.sealed) throw new Error(`Task ${taskId} dependencies are sealed by first execution admission and cannot be changed`);
+			const task = await canonical(node);
+			if (!task) throw new RecordNotFoundError("tasks", taskId);
+			if (task.state !== "queued") throw new Error(`Task ${taskId} must be queued to change dependencies; current state is ${task.state}`);
+			const graph = taskGraphSchema.parse({
+				...current.graph,
+				revision: current.graph.revision + 1,
+				nodes: current.graph.nodes.map((entry) => entry.taskId === taskId ? {
+					...entry,
+					dependencies: edges
+				} : entry),
+				updatedAt: now()
+			});
+			await driver.update({
+				collection: "taskGraphs",
+				id: rootTaskId,
+				value: graph,
+				expectedVersion: current.version
+			});
+			await notify?.({
+				rootTaskId,
+				key: `dependencies:${rootTaskId}:${graph.revision}`
+			});
+			return graph;
+		},
+		async dependenciesSatisfied({ rootTaskId, taskId }) {
+			taskIdSchema.parse(taskId);
+			const current = await read(rootTaskId);
+			const node = current?.graph.nodes.find((entry) => entry.taskId === taskId);
+			if (!current || !node || !await canonical(node)) return false;
+			return satisfied(current.graph, node);
+		},
+		async seal({ rootTaskId, taskId }) {
+			taskIdSchema.parse(taskId);
+			for (;;) {
+				const current = await read(rootTaskId);
+				if (!current) throw new RecordNotFoundError("taskGraphs", rootTaskId);
+				const node = current.graph.nodes.find((entry) => entry.taskId === taskId);
+				if (!node) throw new Error(`Task ${taskId} is not registered in graph ${rootTaskId}`);
+				const task = await canonical(node);
+				if (!task) throw new RecordNotFoundError("tasks", taskId);
+				if (!node.sealed && task.state !== "queued") throw new Error(`Task ${taskId} must be queued for first execution admission; current state is ${task.state}`);
+				if (!await satisfied(current.graph, node)) throw new Error(`Task ${taskId} dependencies must all be succeeded before execution admission`);
+				if (node.sealed) return;
+				const graph = taskGraphSchema.parse({
+					...current.graph,
+					revision: current.graph.revision + 1,
+					nodes: current.graph.nodes.map((entry) => entry.taskId === taskId ? {
+						...entry,
+						sealed: true
+					} : entry),
+					updatedAt: now()
+				});
+				try {
+					await driver.update({
+						collection: "taskGraphs",
+						id: rootTaskId,
+						value: graph,
+						expectedVersion: current.version
+					});
+					return;
+				} catch (error) {
+					if (!(error instanceof VersionConflictError)) throw error;
+				}
+			}
+		}
+	};
+}
+//#endregion
+export { TaskGraphConflictError, assertTaskAdmission, createTaskGraphStore };
+
+//# sourceMappingURL=task-graphs.mjs.map