@dbsp/core 3.3.0 → 4.0.0

package/dist/chunk-AQN7HBYD.js

@@ -0,0 +1,1740 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+
+// src/transition/canonical-json.ts
+import { createHash } from "crypto";
+var CanonicalJsonError = class extends TypeError {
+  constructor(path, detail, options) {
+    super(`canonical JSON refuses ${path}: ${detail}`, options);
+    this.name = "CanonicalJsonError";
+  }
+};
+function canonicalJson(value) {
+  return encodeCanonicalJson(value, "$");
+}
+function canonicalJsonDigest(value) {
+  return createHash("sha256").update(canonicalJson(value)).digest("hex");
+}
+var MAX_RENDERED_PATH_KEY = 160;
+function memberPath(path, key) {
+  const rendered = key.length <= MAX_RENDERED_PATH_KEY ? key : `${key.slice(0, MAX_RENDERED_PATH_KEY)}\u2026<truncated>`;
+  return `${path}[${JSON.stringify(rendered)}]`;
+}
+function scalar(value, path) {
+  if (value === null) return "null";
+  switch (typeof value) {
+    case "string":
+    case "boolean":
+      return JSON.stringify(value);
+    case "number":
+      if (!Number.isFinite(value))
+        throw new CanonicalJsonError(
+          path,
+          "numbers must be finite JSON numbers"
+        );
+      return JSON.stringify(value);
+    case "undefined":
+      throw new CanonicalJsonError(path, "undefined is not a JSON value");
+    case "bigint":
+    case "function":
+    case "symbol":
+      throw new CanonicalJsonError(path, `${typeof value} is not a JSON value`);
+    case "object":
+      return void 0;
+  }
+}
+function captureReflection(path, capture) {
+  try {
+    return capture();
+  } catch (error) {
+    throw new CanonicalJsonError(path, "reflection failed", { cause: error });
+  }
+}
+function encodeCanonicalJson(value, path) {
+  const output = [];
+  const active = /* @__PURE__ */ new WeakSet();
+  const tasks = [{ kind: "value", value, path }];
+  while (tasks.length > 0) {
+    const task = tasks.pop();
+    if (!task) continue;
+    if (task.kind === "text") {
+      output.push(task.text);
+      continue;
+    }
+    if (task.kind === "close") {
+      active.delete(task.value);
+      output.push(task.text);
+      continue;
+    }
+    const encoded = scalar(task.value, task.path);
+    if (encoded !== void 0) {
+      output.push(encoded);
+      continue;
+    }
+    const object = task.value;
+    if (active.has(object))
+      throw new CanonicalJsonError(
+        task.path,
+        "cyclic values are not JSON values"
+      );
+    active.add(object);
+    const isArray = captureReflection(task.path, () => Array.isArray(object));
+    if (isArray) {
+      if (captureReflection(task.path, () => Object.getPrototypeOf(object)) !== Array.prototype)
+        throw new CanonicalJsonError(
+          task.path,
+          "arrays require Array.prototype"
+        );
+      if (captureReflection(task.path, () => Object.getOwnPropertySymbols(object)).length > 0)
+        throw new CanonicalJsonError(
+          task.path,
+          "symbol-keyed members are not JSON members"
+        );
+      for (const key of captureReflection(
+        task.path,
+        () => Object.getOwnPropertyNames(object)
+      )) {
+        if (key === "length") continue;
+        if (!/^(?:0|[1-9][0-9]*)$/u.test(key))
+          throw new CanonicalJsonError(
+            task.path,
+            "array non-index members are not JSON members"
+          );
+        if (BigInt(key) > 4294967294n)
+          throw new CanonicalJsonError(
+            task.path,
+            "array non-index members are not JSON members"
+          );
+      }
+      output.push("[");
+      tasks.push({ kind: "close", value: object, text: "]" });
+      const length = captureReflection(
+        task.path,
+        () => object.length
+      );
+      for (let index = length - 1; index >= 0; index -= 1) {
+        const itemPath = `${task.path}[${index}]`;
+        const descriptor = captureReflection(
+          itemPath,
+          () => Object.getOwnPropertyDescriptor(object, String(index))
+        );
+        if (!descriptor)
+          throw new CanonicalJsonError(
+            itemPath,
+            "array holes are not JSON values"
+          );
+        if (!descriptor.enumerable || !("value" in descriptor))
+          throw new CanonicalJsonError(
+            itemPath,
+            "array members must be enumerable data properties"
+          );
+        if (index < length - 1) tasks.push({ kind: "text", text: "," });
+        tasks.push({ kind: "value", value: descriptor.value, path: itemPath });
+      }
+      continue;
+    }
+    const prototype = captureReflection(
+      task.path,
+      () => Object.getPrototypeOf(object)
+    );
+    if (prototype !== Object.prototype && prototype !== null)
+      throw new CanonicalJsonError(
+        task.path,
+        "only plain objects are JSON objects"
+      );
+    if (captureReflection(task.path, () => Object.getOwnPropertySymbols(object)).length > 0)
+      throw new CanonicalJsonError(
+        task.path,
+        "symbol-keyed members are not JSON members"
+      );
+    const entries = Object.entries(
+      captureReflection(
+        task.path,
+        () => Object.getOwnPropertyDescriptors(object)
+      )
+    );
+    for (const [key, descriptor] of entries) {
+      const keyPath = memberPath(task.path, key);
+      if (!descriptor.enumerable)
+        throw new CanonicalJsonError(
+          keyPath,
+          "non-enumerable members are not JSON members"
+        );
+      if (!("value" in descriptor))
+        throw new CanonicalJsonError(
+          keyPath,
+          "accessor members are not JSON values"
+        );
+      if (descriptor.value === void 0)
+        throw new CanonicalJsonError(keyPath, "undefined is not a JSON value");
+    }
+    entries.sort(
+      ([left], [right]) => left < right ? -1 : left > right ? 1 : 0
+    );
+    output.push("{");
+    tasks.push({ kind: "close", value: object, text: "}" });
+    for (let index = entries.length - 1; index >= 0; index -= 1) {
+      const entry = entries[index];
+      if (!entry) continue;
+      const [key, descriptor] = entry;
+      if (index < entries.length - 1) tasks.push({ kind: "text", text: "," });
+      tasks.push({
+        kind: "value",
+        value: descriptor.value,
+        path: memberPath(task.path, key)
+      });
+      tasks.push({ kind: "text", text: `${JSON.stringify(key)}:` });
+    }
+  }
+  return output.join("");
+}
+
+// src/transition/durably-loaded-run.ts
+var durablyLoadedRuns = /* @__PURE__ */ new WeakSet();
+function frozenMetadata(run) {
+  return Object.freeze({ ...run });
+}
+function mintDurablyLoadedRun(run) {
+  const witness = Object.freeze({
+    metadata: frozenMetadata(run)
+  });
+  durablyLoadedRuns.add(witness);
+  return witness;
+}
+function isDurablyLoadedRun(value) {
+  return value != null && (typeof value === "object" || typeof value === "function") && durablyLoadedRuns.has(value);
+}
+
+// src/transition/transition-lessor.ts
+var TRANSITION_LESSOR_BRAND = /* @__PURE__ */ Symbol.for("dbsp.transition.lessor");
+var TRANSITION_LESSOR_PROTOCOL_VERSION = 2;
+var TRANSITION_LESSOR_REJECTION = "transition target must be a core-minted lessor";
+var TRANSITION_LESSOR_REJECTION_DETAIL = "The supplied transition target was refused because it is not a core-minted protocol-v2 lessor carrying a revocation capability.";
+var TransitionLessorContractRejection = class extends Error {
+  constructor(detail) {
+    super(detail);
+    this.name = "TransitionLessorContractRejection";
+  }
+};
+async function captureLease(value) {
+  const { query, queryPlanOperation, release } = leaseMembers(value);
+  if (typeof query !== "function" || typeof release !== "function") {
+    const rejection = new TransitionLessorContractRejection(
+      "A transition lessor must acquire a lease exposing query() and release(). This acquisition returned an unusable member pair."
+    );
+    releaseMalformedAcquisition(value, release, rejection);
+    throw rejection;
+  }
+  return {
+    raw: value,
+    query,
+    queryPlanOperation: typeof queryPlanOperation === "function" ? queryPlanOperation : void 0,
+    release
+  };
+}
+function transitionLessorRejectionDetail(error) {
+  try {
+    return error instanceof TransitionLessorContractRejection ? error.message : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var planOperationQueries = /* @__PURE__ */ new WeakMap();
+var transitionSessionRevocations = /* @__PURE__ */ new WeakMap();
+var transitionSessionLatches = /* @__PURE__ */ new WeakMap();
+var physicalSessionRevocationLatches = /* @__PURE__ */ new WeakMap();
+var remintedLessorStates = /* @__PURE__ */ new WeakMap();
+function mintTransitionSessionRevocationLatch() {
+  return { compromised: false };
+}
+function resolvePhysicalSessionRevocationLatch(physicalSession) {
+  const existing = physicalSessionRevocationLatches.get(physicalSession);
+  if (existing) return existing;
+  const latch = mintTransitionSessionRevocationLatch();
+  physicalSessionRevocationLatches.set(physicalSession, latch);
+  return latch;
+}
+function mintTransitionSessionRevocationPropagation() {
+  return Object.freeze({
+    compromise() {
+      if (!isObject(this)) return;
+      resolvePhysicalSessionRevocationLatch(this).compromised = true;
+    },
+    isCompromised() {
+      return isObject(this) && resolvePhysicalSessionRevocationLatch(this).compromised;
+    }
+  });
+}
+function mintTransitionSessionRevocation(latch, physicalSession, propagation) {
+  return Object.freeze({
+    compromise() {
+      latch.compromised = true;
+      try {
+        propagation.compromise.call(physicalSession);
+      } catch {
+      }
+    },
+    isCompromised() {
+      if (latch.compromised) return true;
+      try {
+        return propagation.isCompromised.call(physicalSession) === true;
+      } catch {
+        return false;
+      }
+    }
+  });
+}
+function revocationForTransitionSession(session) {
+  const revocation = transitionSessionRevocations.get(session);
+  if (!revocation)
+    throw new Error(
+      "transition session was not minted by the transition lessor"
+    );
+  return revocation;
+}
+function latchForTransitionSession(session) {
+  const latch = transitionSessionLatches.get(session);
+  if (!latch)
+    throw new Error(
+      "transition session was not minted by the transition lessor"
+    );
+  return latch;
+}
+function mintTransitionSession(revocation, latch, query) {
+  const session = Object.freeze({
+    query: (sql, params) => query(session, sql, params)
+  });
+  transitionSessionRevocations.set(session, revocation);
+  transitionSessionLatches.set(session, latch);
+  return session;
+}
+function transitionSessionIsCompromised(session) {
+  return revocationForTransitionSession(session).isCompromised();
+}
+function transitionPhysicalSessionIsCompromised(physicalSession) {
+  return physicalSessionRevocationLatches.get(physicalSession)?.compromised === true;
+}
+function compromisedTransitionSessionError() {
+  return new Error("transition execution marked its leased client compromised");
+}
+function markTransitionClientCompromised(session) {
+  revocationForTransitionSession(session).compromise();
+}
+function planOperationSession(session) {
+  const query = planOperationQueries.get(session);
+  if (!query) return session;
+  const revocation = revocationForTransitionSession(session);
+  const latch = latchForTransitionSession(session);
+  return mintTransitionSession(
+    revocation,
+    latch,
+    (planSession, sql, params) => {
+      if (transitionSessionIsCompromised(planSession)) {
+        return Promise.reject(compromisedTransitionSessionError());
+      }
+      return query(sql, params);
+    }
+  );
+}
+var exclusiveTargets = /* @__PURE__ */ new WeakMap();
+function createExclusiveTransitionTarget(target, isLive) {
+  if (!isTransitionLessor(target)) {
+    throw new Error(
+      "exclusive transition target requires a core-minted lessor"
+    );
+  }
+  const exclusive = Object.freeze({});
+  exclusiveTargets.set(exclusive, { target, isLive });
+  return exclusive;
+}
+function isExclusiveTransitionTarget(value) {
+  return value != null && (typeof value === "object" || typeof value === "function") && exclusiveTargets.has(value);
+}
+async function acquireExclusiveTransitionLease(target) {
+  const state = exclusiveTargets.get(target);
+  if (!state?.isLive()) {
+    throw new Error(
+      "exclusive transition target is only valid while its adapter lock callback is running"
+    );
+  }
+  const lease = await acquireTransitionLease(state.target);
+  if (!state.isLive()) {
+    await lease.release({
+      error: new Error(
+        "exclusive transition target ended while acquiring its lease"
+      )
+    });
+    throw new Error(
+      "exclusive transition target ended while acquiring its lease"
+    );
+  }
+  return lease;
+}
+function acquireTransitionTargetLease(target) {
+  return isTransitionLessor(target) ? acquireTransitionLease(target) : acquireExclusiveTransitionLease(target);
+}
+async function acquireTransitionLease(target) {
+  if (!isTransitionLessor(target)) {
+    throw new Error(TRANSITION_LESSOR_REJECTION);
+  }
+  const captured = await captureLease(await target.acquire());
+  const { raw, query, release } = captured;
+  const physicalSession = raw;
+  const reminted = remintedLessorStates.get(target);
+  const latch = reminted?.latch ?? resolvePhysicalSessionRevocationLatch(physicalSession);
+  if (reminted) {
+    physicalSessionRevocationLatches.set(physicalSession, reminted.latch);
+  }
+  const revocation = reminted?.revocation ?? mintTransitionSessionRevocation(
+    latch,
+    physicalSession,
+    lessorBrand(target).revocation
+  );
+  let closed = false;
+  const session = mintTransitionSession(
+    revocation,
+    latch,
+    (leasedSession, sql, params) => {
+      if (closed) {
+        return Promise.reject(
+          new Error("transition lease was already given back")
+        );
+      }
+      if (transitionSessionIsCompromised(leasedSession)) {
+        return Promise.reject(compromisedTransitionSessionError());
+      }
+      return query.call(raw, sql, params);
+    }
+  );
+  if (captured.queryPlanOperation) {
+    planOperationQueries.set(
+      session,
+      (sql, params) => Promise.resolve(
+        captured.queryPlanOperation?.call(captured.raw, sql, params)
+      )
+    );
+  }
+  const releaseLease = (failure) => {
+    if (closed) {
+      return Promise.resolve();
+    }
+    closed = true;
+    try {
+      const effectiveFailure = failure ?? (transitionSessionIsCompromised(session) ? {
+        error: new Error(
+          "transition execution marked its leased client compromised"
+        )
+      } : void 0);
+      const returned = effectiveFailure ? release.call(raw, releaseArgument(effectiveFailure)) : release.call(raw);
+      void Promise.resolve(returned).catch(() => void 0);
+    } catch {
+    }
+    return Promise.resolve();
+  };
+  return Object.freeze({
+    session,
+    release: releaseLease
+  });
+}
+function leaseMembers(value) {
+  if (value == null || typeof value !== "object" && typeof value !== "function") {
+    return {
+      query: void 0,
+      queryPlanOperation: void 0,
+      release: void 0
+    };
+  }
+  const release = readMember(value, "release");
+  return {
+    query: readMember(value, "query"),
+    queryPlanOperation: readMember(value, "queryPlanOperation"),
+    release
+  };
+}
+function readMember(value, member) {
+  try {
+    return value[member];
+  } catch {
+    return void 0;
+  }
+}
+function releaseMalformedAcquisition(value, release, rejection) {
+  if (typeof release !== "function") {
+    return;
+  }
+  try {
+    void Promise.resolve(release.call(value, rejection)).catch(() => void 0);
+  } catch {
+  }
+}
+function createTransitionLessor(acquire) {
+  return mintTransitionLessor(acquire);
+}
+function remintTransitionLessorFromSession(session, acquire) {
+  return mintTransitionLessor(acquire, {
+    latch: latchForTransitionSession(session),
+    revocation: revocationForTransitionSession(session)
+  });
+}
+function mintTransitionLessor(acquire, reminted) {
+  const lessor = { acquire };
+  Object.defineProperty(lessor, TRANSITION_LESSOR_BRAND, {
+    value: Object.freeze({
+      protocolVersion: TRANSITION_LESSOR_PROTOCOL_VERSION,
+      revocation: reminted?.revocation ?? mintTransitionSessionRevocationPropagation()
+    }),
+    writable: false,
+    configurable: false
+  });
+  const frozenLessor = Object.freeze(lessor);
+  if (reminted) {
+    remintedLessorStates.set(frozenLessor, reminted);
+  }
+  return frozenLessor;
+}
+function isTransitionLessor(value) {
+  try {
+    if (value == null || typeof value !== "object" && typeof value !== "function" || Array.isArray(value)) {
+      return false;
+    }
+    const brand = value[TRANSITION_LESSOR_BRAND];
+    return brand != null && typeof brand === "object" && brand.protocolVersion === TRANSITION_LESSOR_PROTOCOL_VERSION && isTransitionSessionRevocationCapability(
+      brand.revocation
+    ) && typeof value.acquire === "function";
+  } catch {
+    return false;
+  }
+}
+function lessorBrand(target) {
+  const brand = target[TRANSITION_LESSOR_BRAND];
+  if (!brand) throw new Error(TRANSITION_LESSOR_REJECTION);
+  return brand;
+}
+function isTransitionSessionRevocationCapability(value) {
+  return value != null && typeof value === "object" && Object.isFrozen(value) && typeof value.compromise === "function" && typeof value.isCompromised === "function";
+}
+function isObject(value) {
+  return value != null && (typeof value === "object" || typeof value === "function");
+}
+var TransitionLeaseFailureError = class extends Error {
+  constructor(cause) {
+    super("transition lease released after a failure", { cause });
+    this.name = "TransitionLeaseFailureError";
+  }
+};
+function releaseArgument(failure) {
+  return failure.error ? failure.error : new TransitionLeaseFailureError(failure.error);
+}
+function transitionLessorRejectionAssessment(artifact, lifecycle = "planned", detail = TRANSITION_LESSOR_REJECTION_DETAIL) {
+  return {
+    decision: "blocked",
+    assurance: "unproven",
+    lifecycle,
+    continuation: "human-intervention-required",
+    reasons: [
+      {
+        code: "context-mismatch",
+        artifact,
+        fact: {
+          key: "transition-lessor",
+          value: TRANSITION_LESSOR_REJECTION
+        },
+        detail,
+        scope: []
+      }
+    ]
+  };
+}
+
+// src/transition/declaration.ts
+import { canonicalResourceParent } from "@dbsp/types";
+
+// src/transition/minting.ts
+var minted = /* @__PURE__ */ new WeakSet();
+function isObject2(value) {
+  return typeof value === "object" && value !== null || typeof value === "function";
+}
+function childPath(parent, key) {
+  if (typeof key === "symbol") {
+    return `${parent}[${String(key)}]`;
+  }
+  if (/^(0|[1-9]\d*)$/.test(key)) {
+    return `${parent}[${key}]`;
+  }
+  if (/^[A-Za-z_$][\w$]*$/.test(key)) {
+    return `${parent}.${key}`;
+  }
+  return `${parent}[${JSON.stringify(key)}]`;
+}
+function kindOf(value) {
+  if (typeof value === "function") {
+    return "function";
+  }
+  if (value instanceof Map) {
+    return "Map";
+  }
+  if (value instanceof Set) {
+    return "Set";
+  }
+  if (value instanceof Date) {
+    return "Date";
+  }
+  if (value instanceof RegExp) {
+    return "RegExp";
+  }
+  if (ArrayBuffer.isView(value)) {
+    return "typed array";
+  }
+  if (value instanceof ArrayBuffer) {
+    return "ArrayBuffer";
+  }
+  return value.constructor?.name ?? "object";
+}
+function plainDataError(kind, path) {
+  return new Error(
+    `a minted plan must be plain data; found ${kind} at ${path}`
+  );
+}
+function isVisibleArrayIndex(value, key) {
+  const index = Number(key);
+  return String(index) === key && Number.isInteger(index) && index >= 0 && index < value.length;
+}
+function assertPlainDataAndFreeze(value, path, seen) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "undefined") {
+    return;
+  }
+  if (typeof value === "bigint" || typeof value === "symbol") {
+    throw plainDataError(typeof value, path);
+  }
+  if (!isObject2(value)) {
+    return;
+  }
+  if (seen.has(value)) {
+    return;
+  }
+  seen.add(value);
+  if (typeof value === "function") {
+    throw plainDataError("function", path);
+  }
+  if (value instanceof Map || value instanceof Set || value instanceof Date || value instanceof RegExp || ArrayBuffer.isView(value) || value instanceof ArrayBuffer) {
+    throw plainDataError(kindOf(value), path);
+  }
+  let prototype;
+  let keys;
+  try {
+    prototype = Object.getPrototypeOf(value);
+    keys = Reflect.ownKeys(value);
+  } catch (error) {
+    throw plainDataError(
+      error instanceof Error ? `Proxy (${error.message})` : "Proxy",
+      path
+    );
+  }
+  const isPlainObject = prototype === Object.prototype;
+  const isPlainArray = Array.isArray(value) && prototype === Array.prototype;
+  if (!isPlainObject && !isPlainArray) {
+    throw plainDataError(kindOf(value), path);
+  }
+  for (const key of keys) {
+    if (typeof key === "symbol") {
+      throw plainDataError("symbol key", childPath(path, key));
+    }
+    let descriptor;
+    try {
+      descriptor = Object.getOwnPropertyDescriptor(value, key);
+    } catch (error) {
+      throw plainDataError(
+        error instanceof Error ? `Proxy (${error.message})` : "Proxy",
+        childPath(path, key)
+      );
+    }
+    if (!descriptor) {
+      continue;
+    }
+    if ("get" in descriptor || "set" in descriptor) {
+      throw plainDataError("accessor", childPath(path, key));
+    }
+    if (isPlainObject && !descriptor.enumerable) {
+      throw plainDataError("non-enumerable property", childPath(path, key));
+    }
+    if (isPlainArray && key !== "length" && !isVisibleArrayIndex(value, key)) {
+      throw plainDataError("named array property", childPath(path, key));
+    }
+    assertPlainDataAndFreeze(descriptor.value, childPath(path, key), seen);
+  }
+  try {
+    Object.freeze(value);
+  } catch (error) {
+    throw plainDataError(
+      error instanceof Error ? `Proxy (${error.message})` : "Proxy",
+      path
+    );
+  }
+}
+function mintInProcessPlan(shape) {
+  assertPlainDataAndFreeze(shape, "$", /* @__PURE__ */ new WeakSet());
+  minted.add(shape);
+  return shape;
+}
+function isMintedInProcessPlan(plan) {
+  return isObject2(plan) && minted.has(plan);
+}
+
+// src/transition/stable-json.ts
+function stableNumber(value) {
+  if (Number.isNaN(value)) {
+    return "number:NaN";
+  }
+  if (Object.is(value, -0)) {
+    return "number:-0";
+  }
+  if (value === Number.POSITIVE_INFINITY) {
+    return "number:Infinity";
+  }
+  if (value === Number.NEGATIVE_INFINITY) {
+    return "number:-Infinity";
+  }
+  return `number:${value}`;
+}
+function objectTag(value) {
+  return Object.prototype.toString.call(value);
+}
+function stableJsonInner(value, seen) {
+  if (value === null) {
+    return "null";
+  }
+  switch (typeof value) {
+    case "undefined":
+      return "undefined";
+    case "boolean":
+      return `boolean:${value ? "true" : "false"}`;
+    case "number":
+      return stableNumber(value);
+    case "bigint":
+      return `bigint:${value.toString()}`;
+    case "string":
+      return `string:${JSON.stringify(value)}`;
+    case "symbol":
+      return `symbol:${JSON.stringify(String(value.description ?? ""))}`;
+    case "function":
+      return `function:${JSON.stringify(value.name)}`;
+    case "object":
+      break;
+  }
+  if (seen.has(value)) {
+    throw new TypeError("stableJson cannot serialize cyclic structures");
+  }
+  seen.add(value);
+  try {
+    if (value instanceof Date) {
+      const time = value.getTime();
+      return Number.isNaN(time) ? "date:Invalid" : `date:${time}`;
+    }
+    if (value instanceof RegExp) {
+      return `regexp:${JSON.stringify(value.source)}/${value.flags}`;
+    }
+    if (value instanceof Map) {
+      const entries2 = [...value.entries()].map(
+        ([key, item]) => `[${stableJsonInner(key, seen)},${stableJsonInner(item, seen)}]`
+      ).sort();
+      return `map:[${entries2.join(",")}]`;
+    }
+    if (value instanceof Set) {
+      const entries2 = [...value.values()].map((item) => stableJsonInner(item, seen)).sort();
+      return `set:[${entries2.join(",")}]`;
+    }
+    if (Array.isArray(value)) {
+      const entries2 = [];
+      for (let index = 0; index < value.length; index += 1) {
+        entries2.push(
+          Object.hasOwn(value, index) ? stableJsonInner(value[index], seen) : "array-hole"
+        );
+      }
+      return `array:[${entries2.join(",")}]`;
+    }
+    const tag = objectTag(value);
+    const entries = Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(
+      ([key, item]) => `${JSON.stringify(key)}:${stableJsonInner(item, seen)}`
+    );
+    return `${tag}:{${entries.join(",")}}`;
+  } finally {
+    seen.delete(value);
+  }
+}
+function stableJson(value) {
+  return stableJsonInner(value, /* @__PURE__ */ new WeakSet());
+}
+
+// src/transition/declaration.ts
+var identityDeclarationNaming = {
+  toDatabase: (identifier) => identifier
+};
+function jsonError(path, detail) {
+  return new Error(
+    `declaration is not canonicalizable JSON at ${path}: ${detail}`
+  );
+}
+function childPath2(parent, key) {
+  if (typeof key === "number") return `${parent}[${key}]`;
+  return /^[A-Za-z_$][\w$]*$/u.test(key) ? `${parent}.${key}` : `${parent}[${JSON.stringify(key)}]`;
+}
+function assertCanonicalizableJson(value, path = "$", seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null || typeof value === "string" || typeof value === "boolean")
+    return;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw jsonError(path, "number must be finite");
+    return;
+  }
+  if (typeof value !== "object") {
+    throw jsonError(path, `found ${typeof value}`);
+  }
+  if (seen.has(value)) throw jsonError(path, "cyclic value");
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) {
+      for (let index = 0; index < value.length; index += 1) {
+        if (!Object.hasOwn(value, index))
+          throw jsonError(childPath2(path, index), "array hole");
+        assertCanonicalizableJson(value[index], childPath2(path, index), seen);
+      }
+      if (Reflect.ownKeys(value).some(
+        (key) => key !== "length" && !(typeof key === "string" && /^(0|[1-9]\d*)$/u.test(key))
+      ))
+        throw jsonError(path, "array has a non-index property");
+      return;
+    }
+    if (Object.getPrototypeOf(value) !== Object.prototype)
+      throw jsonError(
+        path,
+        `found ${value.constructor?.name ?? "non-plain object"}`
+      );
+    for (const key of Reflect.ownKeys(value)) {
+      if (typeof key !== "string") throw jsonError(path, "symbol key");
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (!descriptor || "get" in descriptor || "set" in descriptor)
+        throw jsonError(childPath2(path, key), "accessor property");
+      if (!descriptor.enumerable)
+        throw jsonError(childPath2(path, key), "non-enumerable property");
+      assertCanonicalizableJson(descriptor.value, childPath2(path, key), seen);
+    }
+  } finally {
+    seen.delete(value);
+  }
+}
+function canonicalPayload(value, path) {
+  assertCanonicalizableJson(value, path);
+  return JSON.parse(canonicalJson(value));
+}
+function digest(value) {
+  return canonicalJsonDigest(value);
+}
+function address(context, kind, name, parent, identity) {
+  return {
+    engine: context.engine,
+    database: context.database,
+    ...kind === "extension" ? {} : { schema: context.schema },
+    ...parent === void 0 ? {} : { parent: canonicalResourceParent(parent) },
+    kind,
+    name,
+    ...identity === void 0 ? {} : { catalogueIdentity: identity }
+  };
+}
+function declaration(context, kind, name, fragment, path, parent) {
+  const canonical = canonicalPayload(fragment, path);
+  return {
+    address: address(context, kind, name, parent),
+    fragment: canonical,
+    digest: digest(canonical)
+  };
+}
+function optional(key, value) {
+  return value === void 0 ? {} : { [key]: value };
+}
+function tableAddress(context, name) {
+  return address(context, "table", name);
+}
+function declarationSetFromModel(model, context, naming = identityDeclarationNaming) {
+  const declarations = [];
+  const toDatabase = (identifier) => naming.toDatabase(identifier);
+  for (const [tableKey, table] of [...model.tables].sort(
+    ([a], [b]) => a < b ? -1 : a > b ? 1 : 0
+  )) {
+    const tablePath = `schema.tables[${JSON.stringify(tableKey)}]`;
+    const tableName = toDatabase(table.name);
+    const parent = tableAddress(context, tableName);
+    declarations.push(
+      declaration(context, "table", tableName, { name: tableName }, tablePath)
+    );
+    for (const [index, column] of table.columns.entries()) {
+      const fragment = {
+        name: toDatabase(column.name),
+        type: column.type,
+        nullable: column.nullable,
+        ...optional("js", column.js),
+        ...optional("default", column.default),
+        ...optional("originalDbType", column.originalDbType),
+        ...optional("originalDbTypeSchema", column.originalDbTypeSchema),
+        ...optional(
+          "originalDbTypeSchemaScope",
+          column.originalDbTypeSchemaScope
+        ),
+        ...optional("unique", column.unique),
+        ...optional("uniqueConstraintName", column.uniqueConstraintName),
+        ...optional("autoIncrement", column.autoIncrement),
+        ...optional("collation", column.collation),
+        ...optional("identity", column.identity)
+      };
+      declarations.push(
+        declaration(
+          context,
+          "column",
+          toDatabase(column.name),
+          fragment,
+          `${tablePath}.columns[${index}]`,
+          parent
+        )
+      );
+    }
+    for (const [index, item] of table.indexes.entries()) {
+      const physicalItem = {
+        ...item,
+        ...item.name === void 0 ? {} : { name: toDatabase(item.name) },
+        columns: item.columns.map(toDatabase),
+        ...item.include === void 0 ? {} : { include: item.include.map(toDatabase) },
+        ...item.opclass === void 0 ? {} : {
+          opclass: Object.fromEntries(
+            Object.entries(item.opclass).map(([key, value]) => [
+              toDatabase(key),
+              value
+            ])
+          )
+        }
+      };
+      const name = physicalItem.name ?? `idx_${tableName}_${physicalItem.columns.join("_")}`;
+      declarations.push(
+        declaration(
+          context,
+          "index",
+          name,
+          physicalItem,
+          `${tablePath}.indexes[${index}]`,
+          parent
+        )
+      );
+    }
+    if (table.primaryKey !== void 0) {
+      const columns = typeof table.primaryKey === "string" ? toDatabase(table.primaryKey) : table.primaryKey.map(toDatabase);
+      declarations.push(
+        declaration(
+          context,
+          "constraint",
+          `pk_${tableName}`,
+          { kind: "primary-key", columns },
+          `${tablePath}.primaryKey`,
+          parent
+        )
+      );
+    }
+    for (const [index, item] of table.foreignKeys.entries()) {
+      const physicalItem = {
+        ...item,
+        columns: item.columns.map(toDatabase),
+        references: {
+          ...item.references,
+          table: toDatabase(item.references.table),
+          columns: item.references.columns.map(toDatabase)
+        }
+      };
+      declarations.push(
+        declaration(
+          context,
+          "constraint",
+          `fk_${tableName}_${physicalItem.columns.join("_")}`,
+          { kind: "foreign-key", ...physicalItem },
+          `${tablePath}.foreignKeys[${index}]`,
+          parent
+        )
+      );
+    }
+    for (const [index, item] of (table.checkConstraints ?? []).entries()) {
+      const physicalItem = { ...item, name: toDatabase(item.name) };
+      declarations.push(
+        declaration(
+          context,
+          "constraint",
+          physicalItem.name,
+          { kind: "check", ...physicalItem },
+          `${tablePath}.checkConstraints[${index}]`,
+          parent
+        )
+      );
+    }
+  }
+  for (const [name, item] of [...model.enums ?? /* @__PURE__ */ new Map()].sort(
+    ([a], [b]) => a < b ? -1 : a > b ? 1 : 0
+  )) {
+    declarations.push(
+      declaration(
+        context,
+        "enum",
+        toDatabase(name),
+        { ...item, name: toDatabase(item.name) },
+        `schema.enums[${JSON.stringify(name)}]`
+      )
+    );
+  }
+  for (const [name, item] of [...model.sequences ?? /* @__PURE__ */ new Map()].sort(
+    ([a], [b]) => a < b ? -1 : a > b ? 1 : 0
+  )) {
+    declarations.push(
+      declaration(
+        context,
+        "sequence",
+        toDatabase(name),
+        { ...item, name: toDatabase(item.name) },
+        `schema.sequences[${JSON.stringify(name)}]`
+      )
+    );
+  }
+  for (const name of [...model.extensions ?? []].sort()) {
+    declarations.push(
+      declaration(
+        context,
+        "extension",
+        name,
+        { name },
+        `schema.extensions[${JSON.stringify(name)}]`
+      )
+    );
+  }
+  const canonicalDeclarations = declarations.sort((left, right) => {
+    const a = stableJson(left.address);
+    const b = stableJson(right.address);
+    return a < b ? -1 : a > b ? 1 : 0;
+  });
+  const setValue = canonicalPayload(
+    { version: 1, declarations: canonicalDeclarations },
+    "schema.declarations"
+  );
+  return {
+    version: 1,
+    declarations: canonicalDeclarations,
+    digest: digest(setValue)
+  };
+}
+function validateDeclarationModel(model) {
+  declarationSetFromModel(model, {
+    engine: "declaration-validation",
+    database: "declaration-validation",
+    schema: "declaration-validation"
+  });
+}
+function admitRecordedIdentity(recorded, live) {
+  if (recorded.catalogueIdentity === void 0)
+    return {
+      ok: false,
+      detail: `recorded address ${recorded.kind} ${recorded.name} has no catalogue identity`
+    };
+  if (live.catalogueIdentity === void 0)
+    return {
+      ok: false,
+      detail: `live address ${live.kind} ${live.name} has no catalogue identity`
+    };
+  if (stableJson(recorded.catalogueIdentity) !== stableJson(live.catalogueIdentity))
+    return {
+      ok: false,
+      detail: `identity drift for ${recorded.kind} ${recorded.name}: recorded ${stableJson(recorded.catalogueIdentity)} does not match live ${stableJson(live.catalogueIdentity)}`
+    };
+  return { ok: true };
+}
+function bindDeclarationSet(plan, declarations) {
+  return mintInProcessPlan({ ...plan, declarations });
+}
+
+// src/transition/lifecycle-interpreter.ts
+import {
+  LEDGER_EVENT_KINDS,
+  sameLedgerAddress
+} from "@dbsp/types";
+var LEDGER_PROJECTION_CODE_VERSION = 1;
+var LEDGER_LIFECYCLE_GRAMMAR = {
+  intent: {
+    claimKind: "intent",
+    opensFrom: ["unknown", "managed", "absent"],
+    resolvesThrough: [
+      "refused",
+      "executing",
+      "observed",
+      "indeterminate",
+      "resolved"
+    ]
+  },
+  "retire-intent": {
+    claimKind: "retire-intent",
+    opensFrom: ["managed"],
+    resolvesThrough: [
+      "refused",
+      "executing",
+      "absent",
+      "indeterminate",
+      "resolved"
+    ]
+  },
+  "readdress-intent": {
+    claimKind: "readdress-intent",
+    opensFrom: ["unknown", "managed", "absent"],
+    resolvesThrough: [
+      "refused",
+      "indeterminate",
+      "readdressed-to",
+      "readdressed-from"
+    ]
+  },
+  "adopt-intent": {
+    claimKind: "adopt-intent",
+    opensFrom: ["unknown"],
+    resolvesThrough: ["refused", "adopt"]
+  }
+};
+var CLAIM_KINDS = /* @__PURE__ */ new Set([
+  "adopt-intent",
+  "intent",
+  "retire-intent",
+  "readdress-intent"
+]);
+function isLedgerEventKind(value) {
+  return LEDGER_EVENT_KINDS.includes(value);
+}
+function invalid(detail) {
+  return { kind: "invalid", detail };
+}
+function requiresReadBack(event, label) {
+  if (event.observed !== void 0) return void 0;
+  return invalid(`${label} requires its supporting read-back`);
+}
+function opensClaim(stableState, event) {
+  if (!CLAIM_KINDS.has(event.eventKind)) {
+    return invalid(`event ${event.eventKind} cannot open a claim`);
+  }
+  const claimKind = event.eventKind;
+  const column = LEDGER_LIFECYCLE_GRAMMAR[claimKind];
+  if (!column.opensFrom.includes(stableState)) {
+    return invalid(`${claimKind} cannot open from stable state ${stableState}`);
+  }
+  if (claimKind === "readdress-intent" && !event.pairId) {
+    return invalid("readdress-intent requires a pair id");
+  }
+  return {
+    kind: "ok",
+    frame: {
+      stableState,
+      openClaim: {
+        event,
+        kind: claimKind,
+        stableStateBeforeClaim: stableState,
+        phase: "claimed"
+      }
+    }
+  };
+}
+function resolveStableState(claim, event) {
+  if (claim.kind === "intent")
+    return event.observed === void 0 ? claim.stableStateBeforeClaim : "managed";
+  return event.observed === void 0 ? "absent" : "managed";
+}
+function interpretLedgerLifecycle(frame, event) {
+  if (frame.openClaim === void 0 && event.eventKind === "released") {
+    if (frame.stableState !== "managed")
+      return invalid("released requires a managed stable state");
+    return { kind: "ok", frame: { stableState: "unknown" } };
+  }
+  if (frame.openClaim === void 0)
+    return opensClaim(frame.stableState, event);
+  const claim = frame.openClaim;
+  const allowed = LEDGER_LIFECYCLE_GRAMMAR[claim.kind].resolvesThrough;
+  if (!allowed.includes(event.eventKind)) {
+    return invalid(
+      `${event.eventKind} is not in the ${claim.kind} resolution column`
+    );
+  }
+  switch (event.eventKind) {
+    case "refused":
+      if (claim.phase === "indeterminate")
+        return invalid("refused cannot close an indeterminate claim");
+      return { kind: "ok", frame: { stableState: frame.stableState } };
+    case "executing":
+      if (claim.phase !== "claimed")
+        return invalid("executing may follow only a newly opened claim");
+      return {
+        kind: "ok",
+        frame: {
+          stableState: frame.stableState,
+          openClaim: { ...claim, phase: "executing" }
+        }
+      };
+    case "observed": {
+      const readBack = requiresReadBack(event, "observed");
+      if (readBack) return readBack;
+      if (claim.phase === "indeterminate")
+        return invalid("observed cannot close an indeterminate claim");
+      return { kind: "ok", frame: { stableState: "managed" } };
+    }
+    case "absent":
+      if (claim.phase === "indeterminate")
+        return invalid("absent cannot close an indeterminate claim");
+      return { kind: "ok", frame: { stableState: "absent" } };
+    case "indeterminate":
+      if (claim.phase === "indeterminate")
+        return invalid("indeterminate may be appended only once");
+      return {
+        kind: "ok",
+        frame: {
+          stableState: frame.stableState,
+          openClaim: { ...claim, phase: "indeterminate" }
+        }
+      };
+    case "resolved": {
+      if (claim.phase !== "indeterminate")
+        return invalid("resolved closes only an indeterminate claim");
+      return {
+        kind: "ok",
+        frame: { stableState: resolveStableState(claim, event) }
+      };
+    }
+    case "adopt": {
+      const readBack = requiresReadBack(event, "adopt");
+      if (readBack) return readBack;
+      return { kind: "ok", frame: { stableState: "managed" } };
+    }
+    case "readdressed-to":
+      if (claim.stableStateBeforeClaim !== "managed")
+        return invalid("readdressed-to resolves only a managed source");
+      if (event.pairId !== claim.event.pairId)
+        return invalid("readdressed-to pair id does not match its claim");
+      return { kind: "ok", frame: { stableState: "unknown" } };
+    case "readdressed-from": {
+      const readBack = requiresReadBack(event, "readdressed-from");
+      if (readBack) return readBack;
+      if (claim.stableStateBeforeClaim === "managed")
+        return invalid("readdressed-from resolves only an unoccupied target");
+      if (event.pairId !== claim.event.pairId)
+        return invalid("readdressed-from pair id does not match its claim");
+      return { kind: "ok", frame: { stableState: "managed" } };
+    }
+    default:
+      return invalid(`${event.eventKind} cannot resolve a claim`);
+  }
+}
+function unprojectable(input, reason) {
+  return {
+    kind: "unprojectable-ledger-chain",
+    ledger: input.ledger,
+    address: input.address,
+    events: input.events,
+    reason,
+    codeVersion: LEDGER_PROJECTION_CODE_VERSION
+  };
+}
+function reportState(frame) {
+  if (frame.openClaim === void 0) return { kind: frame.stableState };
+  return frame.openClaim.phase === "indeterminate" ? {
+    kind: "blocked",
+    stableState: frame.stableState,
+    claim: frame.openClaim
+  } : {
+    kind: "pending",
+    stableState: frame.stableState,
+    claim: frame.openClaim
+  };
+}
+function projected(input, frame, declaration2, observation) {
+  return {
+    kind: "projected-ledger-chain",
+    ledger: input.ledger,
+    address: input.address,
+    events: input.events,
+    stableState: frame.stableState,
+    ...frame.openClaim === void 0 ? {} : { openClaim: frame.openClaim },
+    reportedState: reportState(frame),
+    ...declaration2 === void 0 ? {} : { declaration: declaration2 },
+    ...observation === void 0 ? {} : { observation }
+  };
+}
+function projectLedgerChain(input) {
+  const byId = /* @__PURE__ */ new Map();
+  const children = /* @__PURE__ */ new Map();
+  for (const event of input.events) {
+    if (!sameLedgerAddress(input.address, event.address))
+      return unprojectable(input, {
+        code: "address-mismatch",
+        eventId: event.eventId
+      });
+    if (!isLedgerEventKind(event.eventKind))
+      return unprojectable(input, {
+        code: "unknown-event-kind",
+        eventId: event.eventId,
+        eventKind: event.eventKind
+      });
+    if (byId.has(event.eventId))
+      return unprojectable(input, {
+        code: "duplicate-event-id",
+        eventId: event.eventId
+      });
+    byId.set(event.eventId, event);
+    const siblings = children.get(event.predecessor) ?? [];
+    siblings.push(event);
+    children.set(event.predecessor, siblings);
+  }
+  for (const event of input.events) {
+    if (event.predecessor !== void 0 && !byId.has(event.predecessor)) {
+      return unprojectable(input, {
+        code: "missing-predecessor",
+        eventId: event.eventId,
+        predecessor: event.predecessor
+      });
+    }
+  }
+  for (const [predecessor, siblings] of children) {
+    if (siblings.length > 1)
+      return unprojectable(input, {
+        code: "fork",
+        ...predecessor === void 0 ? {} : { predecessor },
+        eventIds: siblings.map((event) => event.eventId)
+      });
+  }
+  const roots = children.get(void 0) ?? [];
+  if (roots.length > 1)
+    return unprojectable(input, {
+      code: "fork",
+      eventIds: roots.map((event) => event.eventId)
+    });
+  if (input.events.length > 0 && roots.length === 0)
+    return unprojectable(input, {
+      code: "cycle",
+      eventIds: input.events.map((event) => event.eventId)
+    });
+  let frame = { stableState: "unknown" };
+  let declaration2;
+  let observation;
+  let current = roots[0];
+  const visited = /* @__PURE__ */ new Set();
+  while (current !== void 0) {
+    if (visited.has(current.eventId))
+      return unprojectable(input, {
+        code: "cycle",
+        eventIds: [...visited, current.eventId]
+      });
+    visited.add(current.eventId);
+    const step = interpretLedgerLifecycle(frame, current);
+    if (step.kind === "invalid")
+      return unprojectable(input, {
+        code: "invalid-lifecycle-edge",
+        eventId: current.eventId,
+        detail: step.detail
+      });
+    frame = step.frame;
+    if (current.declared !== void 0) declaration2 = current.declared;
+    if (current.observed !== void 0) observation = current.observed;
+    current = children.get(current.eventId)?.[0];
+  }
+  if (visited.size !== input.events.length)
+    return unprojectable(input, {
+      code: "cycle",
+      eventIds: input.events.filter((event) => !visited.has(event.eventId)).map((event) => event.eventId)
+    });
+  return projected(input, frame, declaration2, observation);
+}
+
+// src/transition/outcome-protocol.ts
+import { createHash as createHash2 } from "crypto";
+import * as transitionTypes from "@dbsp/types";
+import { refusalFor, sameLedgerAddress as sameLedgerAddress2 } from "@dbsp/types";
+var tokenRecords = /* @__PURE__ */ new WeakMap();
+var sameControllerIdentity2 = transitionTypes.sameControllerIdentity ?? ((recorded, current) => recorded.name === current.name && recorded.oid === current.oid);
+function findUniqueLedgerTerminal(events) {
+  const predecessors = /* @__PURE__ */ new Set();
+  for (const event of events) {
+    if (event.predecessor !== void 0) predecessors.add(event.predecessor);
+  }
+  let terminal;
+  for (const event of events) {
+    if (predecessors.has(event.eventId)) continue;
+    if (terminal !== void 0) return void 0;
+    terminal = event;
+  }
+  return terminal;
+}
+function outcomeClaimId(executionId, plannedClaimKey, address2, closureMemberKey) {
+  return `dbsp.transition.outcome.${createHash2("sha256").update(
+    stableJson({ executionId, plannedClaimKey, address: address2, closureMemberKey })
+  ).digest("hex")}`;
+}
+function outcomeClaimEventId(claimId, role) {
+  return `dbsp.transition.outcome.${createHash2("sha256").update(stableJson({ claimId, role })).digest("hex")}`;
+}
+function refusal(reason) {
+  return { kind: "outcome-protocol-refused", reason };
+}
+function bundleRefusal(plan) {
+  const statements = plan.statementBundle.statements;
+  if (plan.claimSpecies === "cascade-covered") {
+    if (statements.length !== 0)
+      return refusal(
+        `cascade-covered claim ${plan.claimId} has a non-empty statement bundle`
+      );
+    return void 0;
+  }
+  if (plan.claimSpecies === "adoption") {
+    if (plan.claimKind !== "adopt-intent" || statements.length !== 0)
+      return refusal(
+        `adoption claim ${plan.claimId} has an invalid statement bundle`
+      );
+    return void 0;
+  }
+  if (statements.length === 0)
+    return refusal(`claim ${plan.claimId} has an empty statement bundle`);
+  for (let index = 0; index < statements.length; index += 1) {
+    const statement = statements[index];
+    if (!statement || statement.ordinal !== index || statement.sql.length === 0)
+      return refusal(
+        `claim ${plan.claimId} has an invalid statement bundle at ordinal ${index}`
+      );
+  }
+  return void 0;
+}
+function fixedBundle(bundle) {
+  return Object.freeze({
+    statements: Object.freeze(
+      bundle.statements.map(
+        (statement) => Object.freeze({ ordinal: statement.ordinal, sql: statement.sql })
+      )
+    )
+  });
+}
+function mintClaimToken(plan) {
+  const token = Object.freeze({});
+  tokenRecords.set(token, {
+    claimId: plan.claimId,
+    bundle: fixedBundle(plan.statementBundle),
+    consumed: false
+  });
+  return token;
+}
+function claimIdForToken(token) {
+  return tokenRecords.get(token)?.claimId;
+}
+function consumeClaimToken(token, claimId, statements) {
+  const record = tokenRecords.get(token);
+  if (!record) return refusal("claim token was not minted by claim admission");
+  if (record.claimId !== claimId)
+    return refusal(
+      `claim token belongs to claim ${record.claimId}, not ${claimId}`
+    );
+  if (record.consumed)
+    return refusal(
+      `claim token for claim ${claimId} has already been consumed`
+    );
+  if (statements.length !== record.bundle.statements.length || statements.some((statement, index) => {
+    const expected = record.bundle.statements[index];
+    return expected === void 0 || expected.ordinal !== statement.ordinal || expected.sql !== statement.sql;
+  }))
+    return refusal(`statements are outside claim ${claimId}'s recorded bundle`);
+  record.consumed = true;
+  return record.bundle;
+}
+function admitOutcomeClaim(input) {
+  const { plan, projection } = input;
+  const bundleError = bundleRefusal(plan);
+  if (bundleError) return bundleError;
+  if (projection.kind !== "projected-ledger-chain")
+    return refusal(
+      `claim ${plan.claimId} refuses malformed ledger chain: ${projection.reason.code}`
+    );
+  if (!sameLedgerAddress2(plan.address, projection.address))
+    return refusal(
+      `claim ${plan.claimId} address does not match its ledger chain`
+    );
+  if (projection.openClaim !== void 0)
+    return refusal(
+      `claim ${plan.claimId} refuses open claim ${projection.openClaim.event.eventId}`
+    );
+  const column = LEDGER_LIFECYCLE_GRAMMAR[plan.claimKind];
+  if (!column.opensFrom.includes(projection.stableState))
+    return refusal(
+      `${plan.claimKind} cannot open from stable state ${projection.stableState}`
+    );
+  if (projection.stableState === "managed" && plan.requiresVacancy !== true) {
+    const terminal = findUniqueLedgerTerminal(projection.events);
+    if (!terminal)
+      return refusal(
+        `claim ${plan.claimId} refuses managed chain without terminal`
+      );
+    const currentController = input.currentController;
+    const controllerOid = terminal.controllerOid;
+    if (currentController) {
+      if (!controllerOid)
+        return refusal(
+          `claim ${plan.claimId} refuses managed controller without recorded OID`
+        );
+      if (!sameControllerIdentity2(
+        { name: terminal.controller, oid: controllerOid },
+        currentController
+      ))
+        return refusal(
+          `claim ${plan.claimId} refuses managed-by-other controller ${terminal.controller}`
+        );
+    } else
+      return refusal(
+        `claim ${plan.claimId} refuses unreadable current controller identity`
+      );
+    if (!input.liveAddress)
+      return refusal(
+        `claim ${plan.claimId} refuses missing live identity admission`
+      );
+    const recorded = terminal.catalogueIdentity ? { ...plan.address, catalogueIdentity: terminal.catalogueIdentity } : plan.address;
+    const identity = admitRecordedIdentity(recorded, input.liveAddress);
+    if (!identity.ok) return refusal(identity.detail);
+  }
+  return {
+    kind: "admitted-outcome-claim",
+    plan,
+    stableStateBeforeClaim: projection.stableState,
+    token: mintClaimToken(plan)
+  };
+}
+function recoveryPending(input, reason, reasonCode) {
+  return {
+    kind: "outcome-recovery-pending",
+    address: input.projection.address,
+    reason,
+    ...reasonCode === void 0 ? {} : { reasonCode }
+  };
+}
+function appendRecovery(input, readBack, eventKind, reason) {
+  const projection = input.projection;
+  if (projection.kind !== "projected-ledger-chain")
+    return {
+      kind: "outcome-recovery-malformed-chain",
+      address: projection.address,
+      reason: projection.reason.code
+    };
+  const claim = projection.openClaim;
+  const predecessor = findUniqueLedgerTerminal(projection.events);
+  if (!claim || !predecessor)
+    return recoveryPending(
+      input,
+      "recovery could not identify the open claim terminal"
+    );
+  return {
+    kind: "outcome-recovery-append",
+    address: projection.address,
+    resolution: {
+      eventKind,
+      predecessor: predecessor.eventId,
+      rootClaimId: claim.event.eventId,
+      reason,
+      readBack,
+      ...eventKind === "refused" ? {
+        refusal: refusalFor("ERR-11", {
+          address: projection.address,
+          state: projection.stableState
+        })
+      } : {}
+    }
+  };
+}
+async function classifyOutcomeRecovery(input) {
+  const projection = input.projection;
+  if (projection.kind !== "projected-ledger-chain")
+    return {
+      kind: "outcome-recovery-malformed-chain",
+      address: projection.address,
+      reason: projection.reason.code
+    };
+  if (projection.openClaim === void 0)
+    return {
+      kind: "outcome-recovery-no-open-claim",
+      address: projection.address
+    };
+  const claim = projection.openClaim;
+  if (claim.phase === "indeterminate") {
+    if (!input.resolveIndeterminate)
+      return {
+        kind: "outcome-recovery-blocked",
+        address: projection.address,
+        reason: "indeterminate claim remains blocked until resolved with a read-back"
+      };
+    const evidence = input.indeterminateEvidence;
+    if (evidence === void 0 || evidence.claimId !== claim.event.eventId || evidence.executionId !== claim.event.executionId || evidence.plannedClaimKey !== claim.event.plannedClaimKey || evidence.persistedBundleDigest !== evidence.admittedBundleDigest || evidence.planDigest !== evidence.externalDdlExclusion.planDigest || !sameLedgerAddress2(
+      evidence.externalDdlExclusion.address,
+      projection.address
+    ))
+      return {
+        kind: "outcome-recovery-blocked",
+        address: projection.address,
+        reason: "indeterminate claim refuses a missing or mismatched admission envelope"
+      };
+  }
+  const readBack = await input.catalogue(projection.address);
+  if (readBack.kind === "catalogue-unavailable")
+    return recoveryPending(input, readBack.reason, "catalogue-unavailable");
+  if (claim.phase === "indeterminate") {
+    if (readBack.effect !== "applied")
+      return {
+        kind: "outcome-recovery-blocked",
+        address: projection.address,
+        reason: "indeterminate claim requires an operation-specific applied read-back"
+      };
+    if (claim.kind === "intent") {
+      if (readBack.kind === "present")
+        return appendRecovery(
+          input,
+          readBack,
+          "resolved",
+          "resolved intent is supported by the catalogue read-back"
+        );
+      if (claim.stableStateBeforeClaim !== "managed")
+        return appendRecovery(
+          input,
+          readBack,
+          "resolved",
+          "resolved intent absence is supported by the catalogue read-back"
+        );
+      return {
+        kind: "outcome-recovery-blocked",
+        address: projection.address,
+        reason: "catalogue absence cannot resolve an indeterminate modify intent to managed"
+      };
+    }
+    if (claim.kind === "retire-intent")
+      return appendRecovery(
+        input,
+        readBack,
+        "resolved",
+        readBack.kind === "absent" ? "resolved retirement absence is supported by the catalogue read-back" : "resolved retirement is supported by the catalogue read-back"
+      );
+    return {
+      kind: "outcome-recovery-blocked",
+      address: projection.address,
+      reason: `indeterminate ${claim.kind} has no resolved grammar column`
+    };
+  }
+  if (claim.phase === "claimed")
+    return appendRecovery(
+      input,
+      readBack,
+      "refused",
+      "recovery read live state before refusing a claim that never reached executing"
+    );
+  if (claim.kind === "intent") {
+    if (readBack.kind === "absent")
+      return appendRecovery(
+        input,
+        readBack,
+        "refused",
+        "recovery read-back proves no effect after executing"
+      );
+    if (readBack.effect === "no-effect")
+      return appendRecovery(
+        input,
+        readBack,
+        "refused",
+        "recovery operation read-back proves no effect after executing"
+      );
+    if (readBack.effect === "unverifiable")
+      return recoveryPending(
+        input,
+        "recovery operation read-back cannot verify effect after executing"
+      );
+    if (claim.stableStateBeforeClaim === "managed" && readBack.effect !== "applied")
+      return recoveryPending(
+        input,
+        "recovery executing managed modification requires an operation-specific applied read-back"
+      );
+    if (claim.stableStateBeforeClaim !== "managed" && !input.acceptedExternalDdlExclusion)
+      return appendRecovery(
+        input,
+        readBack,
+        "indeterminate",
+        "create read-back requires claim-bound external-ddl-exclusion and operation postcondition evidence"
+      );
+    return appendRecovery(
+      input,
+      readBack,
+      "observed",
+      "recovery observed the live catalogue read-back after executing"
+    );
+  }
+  if (claim.kind === "retire-intent") {
+    if (readBack.kind === "absent")
+      return appendRecovery(
+        input,
+        readBack,
+        "absent",
+        "recovery observed retirement absence after executing"
+      );
+    return recoveryPending(
+      input,
+      "retirement remains unverifiable because the catalogue object is present"
+    );
+  }
+  return recoveryPending(
+    input,
+    `executing ${claim.kind} is not a recoverable lifecycle edge`
+  );
+}
+
+export {
+  __reExport,
+  CanonicalJsonError,
+  canonicalJson,
+  canonicalJsonDigest,
+  stableJson,
+  mintDurablyLoadedRun,
+  isDurablyLoadedRun,
+  mintInProcessPlan,
+  isMintedInProcessPlan,
+  TRANSITION_LESSOR_REJECTION,
+  transitionLessorRejectionDetail,
+  transitionPhysicalSessionIsCompromised,
+  markTransitionClientCompromised,
+  planOperationSession,
+  createExclusiveTransitionTarget,
+  isExclusiveTransitionTarget,
+  acquireExclusiveTransitionLease,
+  acquireTransitionTargetLease,
+  acquireTransitionLease,
+  createTransitionLessor,
+  remintTransitionLessorFromSession,
+  isTransitionLessor,
+  transitionLessorRejectionAssessment,
+  assertCanonicalizableJson,
+  declarationSetFromModel,
+  validateDeclarationModel,
+  admitRecordedIdentity,
+  bindDeclarationSet,
+  LEDGER_PROJECTION_CODE_VERSION,
+  LEDGER_LIFECYCLE_GRAMMAR,
+  interpretLedgerLifecycle,
+  projectLedgerChain,
+  findUniqueLedgerTerminal,
+  outcomeClaimId,
+  outcomeClaimEventId,
+  mintClaimToken,
+  claimIdForToken,
+  consumeClaimToken,
+  admitOutcomeClaim,
+  classifyOutcomeRecovery
+};
+//# sourceMappingURL=chunk-AQN7HBYD.js.map