@agen-ai/agent-orchestration 0.0.0-stage → 0.4.0

package/dist/store/memory.js

@@ -0,0 +1,215 @@
+import { createDelegationId, delegationDataBytes, delegationInputDigest, delegationSubordinateId } from "../shared/identity.js";
+import { freezeDelegationData } from "../shared/immutable.js";
+import { parseDelegationLimits } from "../shared/limits.js";
+import { failDelegation } from "../shared/operational-errors.js";
+import { delegationSchemaError, invalidDelegationData } from "../shared/errors.js";
+import { captureDelegationRecord, copyBoundedDelegationData } from "../shared/bounds.js";
+import { parseDelegationOwnerToken } from "../tasks/parse.js";
+import { StoreIdSchema } from "../tasks/schemas.js";
+import { planDelegationStoreCommit } from "../store-adapter/plan.js";
+import { criticalKinds } from "../store-adapter/context.js";
+import { parseDelegationStoreCommand, parseDelegationStoreReadInput, parseDelegationStoreScanInput } from "./parse.js";
+import { pageDelegationRows, summarizeDelegationRun } from "./pages.js";
+function operationKey(parent, operationId) {
+  return JSON.stringify([parent.parentId, parent.scopeId, operationId]);
+}
+function observationKey(runId, index) {
+  return `${runId}:${index}`;
+}
+function runKey(run) {
+  return `${run.createdAt}:${run.runId}`;
+}
+function createInMemoryDelegationStore(options = {}) {
+  const capturedOptions = captureDelegationRecord(options);
+  if (Object.keys(capturedOptions).some((key) => key !== "limits" && key !== "storeId")) {
+    invalidDelegationData("invalid_data", [], "Volatile store options contain an unknown property.");
+  }
+  const limits = parseDelegationLimits(capturedOptions.limits ?? {});
+  const capturedStoreId = copyBoundedDelegationData(capturedOptions.storeId ?? createDelegationId());
+  const parsedStoreId = StoreIdSchema.safeParse(capturedStoreId);
+  if (!parsedStoreId.success) return delegationSchemaError(parsedStoreId.error, capturedStoreId);
+  const storeId = parsedStoreId.data;
+  let owner;
+  let epoch = 0;
+  let capacity = Object.freeze({
+    tasks: 0,
+    runs: 0,
+    activeRuns: 0,
+    queuedRuns: 0,
+    retainedInputBytes: 0,
+    observationBytes: 0,
+    ordinaryOperations: 0,
+    reservedBytes: 0,
+    criticalSlots: 0
+  });
+  const tasks = /* @__PURE__ */ new Map();
+  const runs = /* @__PURE__ */ new Map();
+  const operations = /* @__PURE__ */ new Map();
+  const observations = /* @__PURE__ */ new Map();
+  const notifications = /* @__PURE__ */ new Map();
+  const ceilings = /* @__PURE__ */ new Map();
+  const runOperations = (runId) => [...operations.values()].filter((operation) => operation.runId === runId);
+  const runObservations = (runId) => [...observations.values()].filter((observation) => observation.runId === runId);
+  const page = (query, rows, key, input, envelopeBytes = 0) => pageDelegationRows({ storeId, query, rows, key, limits, ...input, envelopeBytes });
+  return Object.freeze({
+    contractVersion: 3,
+    persistence: "volatile",
+    storeId,
+    limits,
+    async acquireOwner() {
+      if (owner) failDelegation("owner_lost", "This volatile store already has an active owner.");
+      owner = parseDelegationOwnerToken({ storeId, epoch: ++epoch, nonce: createDelegationId() });
+      return owner;
+    },
+    async releaseOwner(input) {
+      if (!owner || input.storeId !== storeId || input.epoch !== owner.epoch || input.nonce !== owner.nonce) {
+        failDelegation("owner_lost", "The store owner fence is no longer current.");
+      }
+      owner = void 0;
+    },
+    async commit(input) {
+      const command = parseDelegationStoreCommand(input);
+      const task = tasks.get(command.taskId);
+      const parent = command.kind === "admit" ? command.admission.parent : task?.parent;
+      const runId = command.kind === "admit" ? command.admission.runId : command.runId;
+      const notificationId = command.kind === "delivery_claim" || command.kind === "delivery_receipt" ? command.notificationId : runId ? delegationSubordinateId(runId, "notification") : void 0;
+      const taskRuns = [...runs.values()].filter((run) => run.taskId === command.taskId);
+      const selectedOperations = runId ? runOperations(runId) : [];
+      const selectedObservations = command.kind === "observe" ? runObservations(command.observation.runId) : [];
+      const plan = planDelegationStoreCommit({ command, current: {
+        storeId,
+        owner,
+        limits,
+        capacity,
+        task,
+        runs: taskRuns,
+        operation: parent ? operations.get(operationKey(parent, command.operationId)) : void 0,
+        criticalOperations: selectedOperations.filter((operation) => criticalKinds.has(operation.kind)),
+        notification: notificationId ? notifications.get(notificationId) : void 0,
+        ceiling: command.kind === "admit" ? ceilings.get(command.admission.policyCeiling.ceilingId) : void 0,
+        observation: command.kind === "observe" ? observations.get(observationKey(command.observation.runId, command.observation.index)) : void 0,
+        omissionObservation: selectedObservations.find((observation) => observation.kind === "omitted"),
+        runIdExists: command.kind === "admit" && runs.has(command.admission.runId)
+      } });
+      for (const mutation of plan.mutations) {
+        switch (mutation.kind) {
+          case "task":
+            tasks.set(mutation.value.taskId, mutation.value);
+            break;
+          case "run":
+            runs.set(mutation.value.runId, mutation.value);
+            break;
+          case "operation":
+            operations.set(operationKey(mutation.value.parent, mutation.value.operationId), mutation.value);
+            break;
+          case "observation":
+            observations.set(observationKey(mutation.value.runId, mutation.value.index), mutation.value);
+            break;
+          case "notification":
+            notifications.set(mutation.value.envelope.notificationId, mutation.value);
+            break;
+          case "ceiling":
+            ceilings.set(mutation.value.ceilingId, mutation.value);
+            break;
+          case "capacity":
+            capacity = mutation.value;
+            break;
+        }
+      }
+      return plan.receipt;
+    },
+    async read(input) {
+      const query = parseDelegationStoreReadInput(input);
+      let result;
+      switch (query.kind) {
+        case "capacity":
+          result = { kind: query.kind, capacity };
+          break;
+        case "task": {
+          const task = tasks.get(query.taskId);
+          result = { kind: query.kind, ...task ? { view: { task, runs: page(
+            { kind: query.kind, taskId: query.taskId },
+            [...runs.values()].filter((run) => run.taskId === task.taskId).map(summarizeDelegationRun),
+            (run) => `${String(run.ordinal).padStart(16, "0")}:${run.runId}`,
+            query,
+            delegationDataBytes(task)
+          ) } } : {} };
+          break;
+        }
+        case "run": {
+          const run = runs.get(query.runId);
+          result = { kind: query.kind, ...run?.taskId === query.taskId ? { run } : {} };
+          break;
+        }
+        case "operation": {
+          const operation = operations.get(operationKey(query.parent, query.operationId));
+          result = { kind: query.kind, ...operation ? { operation } : {} };
+          break;
+        }
+        case "operations":
+          result = { kind: query.kind, page: page(
+            { kind: query.kind, taskId: query.taskId, runId: query.runId },
+            runs.get(query.runId)?.taskId === query.taskId ? runOperations(query.runId) : [],
+            (operation) => operation.operationId,
+            query
+          ) };
+          break;
+        case "observations": {
+          const run = runs.get(query.runId);
+          const found = run?.taskId === query.taskId;
+          result = {
+            kind: query.kind,
+            page: page(
+              { kind: query.kind, taskId: query.taskId, runId: query.runId },
+              found ? runObservations(query.runId) : [],
+              (observation) => String(observation.index).padStart(16, "0"),
+              query
+            ),
+            latestIndex: found ? run.observationIndex : 0,
+            gap: found ? run.omittedObservations > 0 : false
+          };
+          break;
+        }
+        case "notification": {
+          const notification = notifications.get(query.notificationId);
+          result = { kind: query.kind, ...notification ? { notification } : {} };
+          break;
+        }
+        case "ceiling": {
+          const ceiling = ceilings.get(query.ceilingId);
+          result = {
+            kind: query.kind,
+            ceilingId: query.ceilingId,
+            ...ceiling ? { origin: ceiling.origin } : {},
+            page: page(
+              { kind: query.kind, ceilingId: query.ceilingId },
+              ceiling?.targets ?? [],
+              delegationInputDigest,
+              query,
+              512
+            )
+          };
+          break;
+        }
+      }
+      return freezeDelegationData(result);
+    },
+    async scan(input) {
+      const query = parseDelegationStoreScanInput(input);
+      if (query.kind === "eligible_notifications") return freezeDelegationData({
+        kind: query.kind,
+        page: page(
+          { kind: query.kind },
+          [...notifications.values()].filter((notification) => notification.state === "pending" || notification.state === "claimed" && notification.claim?.ownerEpoch !== owner?.epoch),
+          (notification) => notification.envelope.notificationId,
+          query
+        )
+      });
+      const selected = [...runs.values()].filter((run) => query.kind === "queued" ? run.phase === "queued" : run.phase !== "settled" && run.ownerEpoch !== owner?.epoch);
+      return freezeDelegationData({ kind: query.kind, page: page({ kind: query.kind }, selected, runKey, query) });
+    }
+  });
+}
+export {
+  createInMemoryDelegationStore
+};

package/dist/store/pages.d.ts

@@ -0,0 +1,16 @@
+import type { DelegationLimits } from "../shared/limits.js";
+import type { DelegationPage, DelegationRunRecord, DelegationRunSummary } from "../tasks/types.js";
+export declare function summarizeDelegationRun(run: DelegationRunRecord): DelegationRunSummary;
+export declare function delegationCursorPrefix(storeId: string, query: unknown): string;
+export declare function parseDelegationPageCursor(storeId: string, query: unknown, cursor?: string): string | undefined;
+export declare function pageDelegationRows<Value>(input: {
+    readonly storeId: string;
+    readonly query: unknown;
+    readonly rows: readonly Value[];
+    readonly key: (value: Value) => string;
+    readonly limits: DelegationLimits;
+    readonly cursor?: string;
+    readonly limit?: number;
+    readonly envelopeBytes?: number;
+}): DelegationPage<Value>;
+//# sourceMappingURL=pages.d.ts.map

package/dist/store/pages.js

@@ -0,0 +1,46 @@
+import { failDelegation } from "../shared/operational-errors.js";
+import { delegationDataBytes, delegationInputDigest } from "../shared/identity.js";
+function summarizeDelegationRun(run) {
+  const { input: _input, ...summary } = run;
+  return summary;
+}
+function delegationCursorPrefix(storeId, query) {
+  return `${storeId}:${delegationInputDigest(query).slice(0, 16)}:`;
+}
+function parseDelegationPageCursor(storeId, query, cursor) {
+  if (cursor === void 0) return void 0;
+  const prefix = delegationCursorPrefix(storeId, query);
+  if (!cursor.startsWith(prefix)) failDelegation("stale_revision", "The cursor belongs to a different store query.");
+  const key = cursor.slice(prefix.length);
+  if (!key || key.length > 128) failDelegation("stale_revision", "The retained cursor is invalid.");
+  return key;
+}
+function pageDelegationRows(input) {
+  const after = parseDelegationPageCursor(input.storeId, input.query, input.cursor);
+  const limit = Math.min(input.limit ?? input.limits.maxPageRecords, input.limits.maxPageRecords);
+  const rows = [...input.rows].sort((left, right) => {
+    const a = input.key(left), b = input.key(right);
+    return a < b ? -1 : a > b ? 1 : 0;
+  });
+  const items = [];
+  let bytes = (input.envelopeBytes ?? 0) + 512;
+  let hasMore = false;
+  for (const row of rows) {
+    if (after !== void 0 && input.key(row) <= after) continue;
+    const size = delegationDataBytes(row) + 1;
+    if (items.length >= limit || bytes + size > input.limits.maxPageBytes) {
+      if (items.length === 0) failDelegation("capacity_exceeded", "A complete record exceeds this read page budget.");
+      hasMore = true;
+      break;
+    }
+    items.push(row);
+    bytes += size;
+  }
+  return { items, ...hasMore ? { cursor: `${delegationCursorPrefix(input.storeId, input.query)}${input.key(items.at(-1))}` } : {} };
+}
+export {
+  delegationCursorPrefix,
+  pageDelegationRows,
+  parseDelegationPageCursor,
+  summarizeDelegationRun
+};

package/dist/store/parse.d.ts

@@ -0,0 +1,5 @@
+import type { DelegationStoreCommand, DelegationStoreReadInput, DelegationStoreScanInput } from "./types.js";
+export declare function parseDelegationStoreCommand(input: unknown): DelegationStoreCommand;
+export declare const parseDelegationStoreReadInput: (input: unknown) => DelegationStoreReadInput;
+export declare const parseDelegationStoreScanInput: (input: unknown) => DelegationStoreScanInput;
+//# sourceMappingURL=parse.d.ts.map

package/dist/store/parse.js

@@ -0,0 +1,137 @@
+import { AgentTurnInputContentSchema } from "@agen-ai/agent-protocol/zod";
+import { z } from "zod/v4";
+import { copyBoundedDelegationData } from "../shared/bounds.js";
+import { delegationSchemaError } from "../shared/errors.js";
+import { freezeDelegationData } from "../shared/immutable.js";
+import { parseDelegationPolicyCeiling } from "../tasks/parse.js";
+import {
+  AtSchema,
+  CompletionPolicySchema,
+  CountSchema,
+  DigestSchema,
+  HistoricalRequestSchema,
+  ObservationSchema,
+  OpaqueIdSchema,
+  OwnerTokenSchema,
+  ParentScopeSchema,
+  PolicyCeilingSchema,
+  RunOutcomeSchema,
+  StoreIdSchema,
+  TargetReferenceSchema
+} from "../tasks/schemas.js";
+const fence = {
+  owner: OwnerTokenSchema,
+  operationId: StoreIdSchema,
+  inputDigest: DigestSchema,
+  taskId: StoreIdSchema,
+  expectedTaskRevision: CountSchema,
+  runId: StoreIdSchema.optional(),
+  expectedRunRevision: CountSchema.optional()
+};
+const admission = z.strictObject({
+  parent: ParentScopeSchema,
+  ancestorTaskId: StoreIdSchema.optional(),
+  depth: z.number().int().positive(),
+  policyCeiling: PolicyCeilingSchema,
+  completionPolicy: CompletionPolicySchema,
+  runId: StoreIdSchema,
+  previousRunId: StoreIdSchema.optional(),
+  continuationMode: z.enum(["next_turn", "follow_up"]).optional(),
+  target: TargetReferenceSchema,
+  policyRevision: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  originPolicyRevision: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  input: AgentTurnInputContentSchema,
+  createdAt: AtSchema,
+  deadlineAt: AtSchema,
+  queuedStartDeadlineAt: AtSchema
+}).refine((value) => value.previousRunId !== void 0 === (value.continuationMode !== void 0), {
+  path: ["continuationMode"],
+  message: "A continuation mode requires exactly one previous run reference."
+});
+const deliveryResult = z.discriminatedUnion("status", [
+  z.strictObject({ status: z.literal("accepted"), inboxId: OpaqueIdSchema, acceptedAt: AtSchema }),
+  z.strictObject({ status: z.literal("blocked"), reason: z.enum(["busy", "authority_unavailable", "capacity"]), retryAt: AtSchema }),
+  z.strictObject({ status: z.literal("uncertain"), retryAt: AtSchema }),
+  z.strictObject({ status: z.enum(["rejected", "expired", "dismissed"]), reason: z.string().max(1e3) })
+]);
+const commandSchema = z.discriminatedUnion("kind", [
+  z.strictObject({ ...fence, kind: z.literal("admit"), admission }),
+  z.strictObject({
+    ...fence,
+    kind: z.literal("dispatch_intent"),
+    operationKind: z.enum(["prepare", "configure", "turn", "steer", "request_resolution", "interrupt", "session_close", "binding_cleanup"]),
+    at: AtSchema,
+    appliedTarget: TargetReferenceSchema.optional(),
+    attempt: z.union([z.literal(1), z.literal(2)]).optional()
+  }),
+  z.strictObject({
+    ...fence,
+    kind: z.literal("operation_receipt"),
+    disposition: z.enum(["delegated", "delivered", "rejected", "interruption_requested", "uncertain", "completed"]),
+    at: AtSchema,
+    message: z.string().max(1e3).optional(),
+    requestState: z.enum(["pending", "unavailable"]).optional()
+  }),
+  z.strictObject({ ...fence, kind: z.literal("observe"), observation: ObservationSchema }),
+  z.strictObject({
+    ...fence,
+    kind: z.literal("request_state"),
+    state: z.enum(["opened", "resolution_intended", "resolved", "unavailable"]),
+    request: HistoricalRequestSchema,
+    at: AtSchema
+  }),
+  z.strictObject({ ...fence, kind: z.literal("cancel"), at: AtSchema, reason: z.string().min(1).max(1e3) }),
+  z.strictObject({ ...fence, kind: z.literal("settle"), outcome: RunOutcomeSchema, at: AtSchema }),
+  z.strictObject({
+    ...fence,
+    kind: z.literal("delivery_claim"),
+    notificationId: StoreIdSchema,
+    expectedNotificationRevision: CountSchema,
+    attemptId: StoreIdSchema,
+    at: AtSchema
+  }),
+  z.strictObject({
+    ...fence,
+    kind: z.literal("delivery_receipt"),
+    notificationId: StoreIdSchema,
+    expectedNotificationRevision: CountSchema,
+    attemptId: StoreIdSchema,
+    result: deliveryResult,
+    at: AtSchema
+  }),
+  z.strictObject({ ...fence, kind: z.literal("retire_recovery"), reason: z.string().min(1).max(1e3), at: AtSchema })
+]);
+const page = { cursor: z.string().max(256).optional(), limit: z.number().int().positive().max(100).optional() };
+const readSchema = z.discriminatedUnion("kind", [
+  z.strictObject({ kind: z.literal("task"), taskId: StoreIdSchema, ...page }),
+  z.strictObject({ kind: z.literal("run"), taskId: StoreIdSchema, runId: StoreIdSchema }),
+  z.strictObject({ kind: z.literal("operation"), parent: ParentScopeSchema, operationId: StoreIdSchema }),
+  z.strictObject({ kind: z.literal("operations"), taskId: StoreIdSchema, runId: StoreIdSchema, ...page }),
+  z.strictObject({ kind: z.literal("observations"), taskId: StoreIdSchema, runId: StoreIdSchema, ...page }),
+  z.strictObject({ kind: z.literal("notification"), notificationId: StoreIdSchema }),
+  z.strictObject({ kind: z.literal("ceiling"), ceilingId: DigestSchema, ...page }),
+  z.strictObject({ kind: z.literal("capacity") })
+]);
+const scanSchema = z.strictObject({
+  kind: z.enum(["queued", "recoverable_runs", "eligible_notifications"]),
+  at: AtSchema,
+  ...page
+});
+function parse(schema, input) {
+  const captured = copyBoundedDelegationData(input);
+  const parsed = schema.safeParse(captured);
+  if (!parsed.success) return delegationSchemaError(parsed.error, captured);
+  return freezeDelegationData(parsed.data);
+}
+function parseDelegationStoreCommand(input) {
+  const value = parse(commandSchema, input);
+  if (value.kind === "admit") parseDelegationPolicyCeiling(value.admission.policyCeiling);
+  return value;
+}
+const parseDelegationStoreReadInput = (input) => parse(readSchema, input);
+const parseDelegationStoreScanInput = (input) => parse(scanSchema, input);
+export {
+  parseDelegationStoreCommand,
+  parseDelegationStoreReadInput,
+  parseDelegationStoreScanInput
+};

package/dist/store/types.d.ts

@@ -0,0 +1,219 @@
+import type { AgentTurnInputContent } from "@agen-ai/agent-protocol";
+import type { DelegationTargetReference } from "../catalog/types.js";
+import type { DelegationLimits } from "../shared/limits.js";
+import type { DelegationCompletionPolicy, DelegationHistoricalRequest, DelegationNotificationRecord, DelegationOwnerToken, DelegationPage, DelegationParentScope, DelegationPersistence, DelegationPolicyCeiling, DelegationRunOutcome, DelegationRunRecord, DelegationTaskObservation, DelegationTaskView } from "../tasks/types.js";
+export type DelegationOperationKind = "admit" | "prepare" | "configure" | "turn" | "steer" | "request_resolution" | "cancel" | "interrupt" | "session_close" | "binding_cleanup";
+export type DelegationCriticalSlot = "cancel" | "interrupt" | "session_close" | "binding_cleanup";
+export type DelegationOperationDisposition = "intent" | "delegated" | "delivered" | "rejected" | "interruption_requested" | "uncertain" | "completed";
+export interface DelegationCommitReceipt {
+    readonly duplicate: boolean;
+    readonly status: "queued" | "preparing" | "running" | "waiting" | "settled" | "recorded" | "omitted" | "retired";
+    readonly taskId: string;
+    readonly taskRevision: number;
+    readonly runId?: string;
+    readonly runRevision?: number;
+    readonly operationId?: string;
+    readonly notificationId?: string;
+}
+export interface DelegationOperationRecord {
+    readonly operationId: string;
+    readonly parent: DelegationParentScope;
+    readonly taskId: string;
+    readonly runId: string;
+    readonly kind: DelegationOperationKind;
+    readonly inputDigest: string;
+    readonly ownerEpoch: number;
+    readonly disposition: DelegationOperationDisposition;
+    readonly attempts: number;
+    readonly at: string;
+    readonly message?: string;
+    readonly request?: Readonly<Pick<DelegationHistoricalRequest, "requestId" | "requestKind">>;
+    readonly requestState?: "pending" | "unavailable";
+    readonly receipt: DelegationCommitReceipt;
+}
+export interface DelegationStoreCapacity {
+    readonly tasks: number;
+    readonly runs: number;
+    readonly activeRuns: number;
+    readonly queuedRuns: number;
+    readonly retainedInputBytes: number;
+    readonly observationBytes: number;
+    readonly ordinaryOperations: number;
+    readonly reservedBytes: number;
+    readonly criticalSlots: number;
+}
+export interface DelegationMutationFence {
+    readonly owner: DelegationOwnerToken;
+    readonly operationId: string;
+    readonly inputDigest: string;
+    readonly taskId: string;
+    readonly expectedTaskRevision: number;
+    readonly runId?: string;
+    readonly expectedRunRevision?: number;
+}
+export interface DelegationRunAdmission {
+    readonly parent: DelegationParentScope;
+    readonly ancestorTaskId?: string;
+    readonly depth: number;
+    readonly policyCeiling: DelegationPolicyCeiling;
+    readonly completionPolicy: DelegationCompletionPolicy;
+    readonly runId: string;
+    readonly previousRunId?: string;
+    readonly continuationMode?: "next_turn" | "follow_up";
+    readonly target: DelegationTargetReference;
+    readonly policyRevision: number;
+    readonly originPolicyRevision: number;
+    readonly input: AgentTurnInputContent;
+    readonly createdAt: string;
+    readonly deadlineAt: string;
+    readonly queuedStartDeadlineAt: string;
+}
+export type DelegationDeliveryResult = Readonly<{
+    status: "accepted";
+    inboxId: string;
+    acceptedAt: string;
+}> | Readonly<{
+    status: "blocked";
+    reason: "busy" | "authority_unavailable" | "capacity";
+    retryAt: string;
+}> | Readonly<{
+    status: "uncertain";
+    retryAt: string;
+}> | Readonly<{
+    status: "rejected" | "expired" | "dismissed";
+    reason: string;
+}>;
+export type DelegationStoreCommand = DelegationMutationFence & (Readonly<{
+    kind: "admit";
+    admission: DelegationRunAdmission;
+}> | Readonly<{
+    kind: "dispatch_intent";
+    operationKind: Exclude<DelegationOperationKind, "admit" | "cancel">;
+    at: string;
+    appliedTarget?: DelegationTargetReference;
+    attempt?: 1 | 2;
+}> | Readonly<{
+    kind: "operation_receipt";
+    disposition: Exclude<DelegationOperationDisposition, "intent">;
+    at: string;
+    message?: string;
+    requestState?: "pending" | "unavailable";
+}> | Readonly<{
+    kind: "observe";
+    observation: DelegationTaskObservation;
+}> | Readonly<{
+    kind: "request_state";
+    state: "opened" | "resolution_intended" | "resolved" | "unavailable";
+    request: DelegationHistoricalRequest;
+    at: string;
+}> | Readonly<{
+    kind: "cancel";
+    at: string;
+    reason: string;
+}> | Readonly<{
+    kind: "settle";
+    outcome: DelegationRunOutcome;
+    at: string;
+}> | Readonly<{
+    kind: "delivery_claim";
+    notificationId: string;
+    expectedNotificationRevision: number;
+    attemptId: string;
+    at: string;
+}> | Readonly<{
+    kind: "delivery_receipt";
+    notificationId: string;
+    expectedNotificationRevision: number;
+    attemptId: string;
+    result: DelegationDeliveryResult;
+    at: string;
+}> | Readonly<{
+    kind: "retire_recovery";
+    reason: string;
+    at: string;
+}>);
+interface DelegationPageInput {
+    readonly cursor?: string;
+    readonly limit?: number;
+}
+export type DelegationStoreReadInput = (Readonly<{
+    kind: "task";
+    taskId: string;
+}> & DelegationPageInput) | Readonly<{
+    kind: "run";
+    taskId: string;
+    runId: string;
+}> | Readonly<{
+    kind: "operation";
+    parent: DelegationParentScope;
+    operationId: string;
+}> | (Readonly<{
+    kind: "operations";
+    taskId: string;
+    runId: string;
+}> & DelegationPageInput) | (Readonly<{
+    kind: "observations";
+    taskId: string;
+    runId: string;
+}> & DelegationPageInput) | Readonly<{
+    kind: "notification";
+    notificationId: string;
+}> | (Readonly<{
+    kind: "ceiling";
+    ceilingId: string;
+}> & DelegationPageInput) | Readonly<{
+    kind: "capacity";
+}>;
+export type DelegationStoreReadPage = Readonly<{
+    kind: "task";
+    view?: DelegationTaskView;
+}> | Readonly<{
+    kind: "run";
+    run?: DelegationRunRecord;
+}> | Readonly<{
+    kind: "operation";
+    operation?: DelegationOperationRecord;
+}> | Readonly<{
+    kind: "operations";
+    page: DelegationPage<DelegationOperationRecord>;
+}> | Readonly<{
+    kind: "observations";
+    page: DelegationPage<DelegationTaskObservation>;
+    latestIndex: number;
+    gap: boolean;
+}> | Readonly<{
+    kind: "notification";
+    notification?: DelegationNotificationRecord;
+}> | Readonly<{
+    kind: "ceiling";
+    ceilingId: string;
+    origin?: DelegationParentScope;
+    page: DelegationPage<DelegationTargetReference>;
+}> | Readonly<{
+    kind: "capacity";
+    capacity: DelegationStoreCapacity;
+}>;
+export type DelegationStoreScanInput = DelegationPageInput & Readonly<{
+    kind: "queued" | "recoverable_runs" | "eligible_notifications";
+    at: string;
+}>;
+export type DelegationStoreScanPage = Readonly<{
+    kind: "queued" | "recoverable_runs";
+    page: DelegationPage<DelegationRunRecord>;
+}> | Readonly<{
+    kind: "eligible_notifications";
+    page: DelegationPage<DelegationNotificationRecord>;
+}>;
+export interface DelegationStore {
+    readonly contractVersion: 3;
+    readonly persistence: DelegationPersistence;
+    readonly storeId: string;
+    readonly limits: DelegationLimits;
+    acquireOwner(): Promise<DelegationOwnerToken>;
+    commit(command: DelegationStoreCommand): Promise<DelegationCommitReceipt>;
+    read(input: DelegationStoreReadInput): Promise<DelegationStoreReadPage>;
+    scan(input: DelegationStoreScanInput): Promise<DelegationStoreScanPage>;
+    releaseOwner(owner: DelegationOwnerToken): Promise<void>;
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/store-adapter/admission.d.ts

@@ -0,0 +1,6 @@
+import type { DelegationStoreCommand } from "../store/types.js";
+import { type CommitContext } from "./context.js";
+export declare function admitRun(context: CommitContext, command: Extract<DelegationStoreCommand, {
+    kind: "admit";
+}>): void;
+//# sourceMappingURL=admission.d.ts.map