@nicia-ai/typegraph 0.67.1 → 0.68.0

package/dist/graph-merge/index.js

@@ -39,7 +39,7 @@ import '../chunk-PC2UBAUB.js';
 import { ok, err, isErr, computeTransitiveClosure, isReachable } from '../chunk-YIB2EVIL.js';
 export { isErr, isOk, unwrap } from '../chunk-YIB2EVIL.js';
 import { META_EDGE_EQUIVALENT_TO, META_EDGE_SAME_AS } from '../chunk-JXXDZTMN.js';
-import '../chunk-OTJNUB6M.js';
+import { assertJsonValue } from '../chunk-OTJNUB6M.js';
 import { compareStrings, compareCodePoints } from '../chunk-CRVSZ7PA.js';
 import '../chunk-LOVRELYJ.js';
 import { createDataKeyedBag, hasOwnKey, requireDefined, readOwnProperty } from '../chunk-QD2JFTSL.js';
@@ -134,7 +134,13 @@ var MERGE_ERROR_CODES = {
   candidateSource: "GRAPH_MERGE_CANDIDATE_SOURCE",
   evidence: "GRAPH_MERGE_EVIDENCE",
   candidateWriteSet: "GRAPH_MERGE_CANDIDATE_WRITE_SET",
-  review: "GRAPH_MERGE_REVIEW"
+  review: "GRAPH_MERGE_REVIEW",
+  operation: "GRAPH_MERGE_OPERATION",
+  operationRequest: "GRAPH_MERGE_OPERATION_REQUEST",
+  operationConflict: "GRAPH_MERGE_OPERATION_CONFLICT",
+  operationUnsupported: "GRAPH_MERGE_OPERATION_UNSUPPORTED",
+  operationEvidence: "GRAPH_MERGE_OPERATION_EVIDENCE",
+  operationUndelivered: "GRAPH_MERGE_OPERATION_UNDELIVERED"
 };
 function toTypeGraphErrorOptions(category, options) {
   return {
@@ -341,6 +347,51 @@ var MatchEvidenceError = class extends MergeError {
     this.name = "MatchEvidenceError";
   }
 };
+var DurableOperationError = class extends MergeError {
+  code = MERGE_ERROR_CODES.operation;
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "DurableOperationError";
+  }
+};
+var DurableOperationRequestError = class extends DurableOperationError {
+  static errorCategory = "user";
+  code = MERGE_ERROR_CODES.operationRequest;
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "DurableOperationRequestError";
+  }
+};
+var DurableOperationConflictError = class extends DurableOperationError {
+  static errorCategory = "constraint";
+  code = MERGE_ERROR_CODES.operationConflict;
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "DurableOperationConflictError";
+  }
+};
+var DurableOperationUnsupportedError = class extends DurableOperationError {
+  static errorCategory = "user";
+  code = MERGE_ERROR_CODES.operationUnsupported;
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "DurableOperationUnsupportedError";
+  }
+};
+var DurableOperationEvidenceError = class extends DurableOperationError {
+  code = MERGE_ERROR_CODES.operationEvidence;
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "DurableOperationEvidenceError";
+  }
+};
+var DurableEvidenceUndeliveredError = class extends BranchError {
+  code = MERGE_ERROR_CODES.operationUndelivered;
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "DurableEvidenceUndeliveredError";
+  }
+};
 function describeCause(cause) {
   return cause instanceof Error ? cause.message : String(cause);
 }
@@ -10478,6 +10529,7 @@ async function destroyDurableBranch(descriptor, strategy) {
     );
     return ok(void 0);
   } catch (error) {
+    if (error instanceof DurableEvidenceUndeliveredError) return err(error);
     return err(
       new BranchError(
         `Failed to destroy durable working copy for branch "${descriptor.branchId}": ${describeCause(error)}`,
@@ -10732,6 +10784,458 @@ async function applyDurableMergePlan(args) {
   );
 }
 
+// src/graph-merge/durable-operation.ts
+var DURABLE_OPERATION_SCAN_DEFAULT_LIMIT = 100;
+var DURABLE_OPERATION_SCAN_MAX_LIMIT = 1e3;
+var OPERATION_DIGEST_BYTE_LENGTH = 16;
+async function computeDurableOperationDigest(request) {
+  const canonical = canonicalValueKey({
+    metadata: request.metadata,
+    mutation: request.mutation
+  });
+  return sha256Hex(canonical, OPERATION_DIGEST_BYTE_LENGTH);
+}
+function requireDescriptorOwner(descriptor, strategy) {
+  const refusal = durableDescriptorRefusal(descriptor, strategy);
+  if (refusal !== void 0) {
+    return {
+      ok: false,
+      error: new DurableOperationRequestError(
+        "Durable operation descriptor validation failed.",
+        { cause: refusal }
+      )
+    };
+  }
+  return { ok: true, origin: durableOriginOfDescriptor(descriptor) };
+}
+async function normalizeOperationRequest(request) {
+  const rawRequest = request;
+  if (typeof rawRequest !== "object" || rawRequest === null || Array.isArray(rawRequest)) {
+    return err(
+      new DurableOperationRequestError(
+        "Durable operation request must be a JSON object."
+      )
+    );
+  }
+  if (typeof request.idempotencyKey !== "string" || request.idempotencyKey.length === 0) {
+    return err(
+      new DurableOperationRequestError(
+        "Durable operation request is malformed: idempotencyKey must be a non-empty string.",
+        { details: { idempotencyKey: request.idempotencyKey } }
+      )
+    );
+  }
+  try {
+    assertJsonValue(request.metadata, "metadata", "Durable operation");
+    assertJsonValue(request.mutation, "mutation", "Durable operation");
+  } catch (error) {
+    return err(
+      new DurableOperationRequestError(
+        `Durable operation request is not JSON-safe: ${describeCause(error)}`,
+        { cause: error, details: { idempotencyKey: request.idempotencyKey } }
+      )
+    );
+  }
+  return ok({
+    idempotencyKey: request.idempotencyKey,
+    metadata: request.metadata,
+    mutation: request.mutation,
+    operationDigest: await computeDurableOperationDigest(request)
+  });
+}
+async function normalizeStoredEvidence(evidence, expectedIdempotencyKey) {
+  if (typeof evidence !== "object" || evidence === null || Array.isArray(evidence)) {
+    return err(
+      new DurableOperationEvidenceError(
+        "Durable operation evidence must be a JSON object.",
+        { details: { idempotencyKey: expectedIdempotencyKey } }
+      )
+    );
+  }
+  const record = evidence;
+  if (typeof record["idempotencyKey"] !== "string" || record["idempotencyKey"].length === 0) {
+    return err(
+      new DurableOperationEvidenceError(
+        "Durable operation evidence needs a non-empty idempotency key.",
+        { details: { expectedKey: expectedIdempotencyKey } }
+      )
+    );
+  }
+  if (expectedIdempotencyKey !== void 0 && record["idempotencyKey"] !== expectedIdempotencyKey) {
+    return err(
+      new DurableOperationEvidenceError(
+        "Durable operation evidence does not carry the requested idempotency key.",
+        {
+          details: {
+            expectedKey: expectedIdempotencyKey,
+            receivedKey: record["idempotencyKey"]
+          }
+        }
+      )
+    );
+  }
+  if (typeof record["operationDigest"] !== "string" || record["operationDigest"].length === 0) {
+    return err(
+      new DurableOperationEvidenceError(
+        "Durable operation evidence needs a non-empty operation digest.",
+        { details: { idempotencyKey: record["idempotencyKey"] } }
+      )
+    );
+  }
+  try {
+    assertJsonValue(
+      record["metadata"],
+      "metadata",
+      "Durable operation evidence"
+    );
+    assertJsonValue(
+      record["mutation"],
+      "mutation",
+      "Durable operation evidence"
+    );
+  } catch (error) {
+    return err(
+      new DurableOperationEvidenceError(
+        `Durable operation evidence content is not JSON-safe: ${describeCause(error)}`,
+        { cause: error, details: { idempotencyKey: record["idempotencyKey"] } }
+      )
+    );
+  }
+  const refusal = validateCoordinates(record["before"], record, "before") ?? validateCoordinates(record["after"], record, "after") ?? (typeof record["delivered"] === "boolean" ? void 0 : new DurableOperationEvidenceError(
+    "Durable operation evidence is missing its delivered flag.",
+    { details: { idempotencyKey: record["idempotencyKey"] } }
+  ));
+  if (refusal !== void 0) return err(refusal);
+  const normalized = evidence;
+  const canonicalDigest = await computeDurableOperationDigest(normalized);
+  if (normalized.operationDigest !== canonicalDigest) {
+    return err(
+      new DurableOperationEvidenceError(
+        "Durable operation evidence digest disagrees with its canonical content.",
+        {
+          details: {
+            idempotencyKey: normalized.idempotencyKey,
+            expectedDigest: canonicalDigest,
+            receivedDigest: normalized.operationDigest
+          }
+        }
+      )
+    );
+  }
+  return ok(normalized);
+}
+async function validateEvidenceForOperation(evidence, expected) {
+  const normalized = await normalizeStoredEvidence(
+    evidence,
+    expected.idempotencyKey
+  );
+  if (isErr(normalized)) return normalized;
+  if (normalized.data.operationDigest !== expected.operationDigest) {
+    return err(
+      new DurableOperationEvidenceError(
+        "Durable operation evidence digest disagrees with the canonical request digest.",
+        {
+          details: {
+            idempotencyKey: expected.idempotencyKey,
+            expectedDigest: expected.operationDigest,
+            receivedDigest: normalized.data.operationDigest
+          }
+        }
+      )
+    );
+  }
+  if (canonicalValueKey(normalized.data.metadata) !== canonicalValueKey(expected.metadata) || canonicalValueKey(normalized.data.mutation) !== canonicalValueKey(expected.mutation)) {
+    return err(
+      new DurableOperationEvidenceError(
+        "Durable operation evidence does not echo the canonical request content.",
+        { details: { idempotencyKey: expected.idempotencyKey } }
+      )
+    );
+  }
+  return normalized;
+}
+var DURABLE_OPERATION_UNSUPPORTED_DIMENSIONS = /* @__PURE__ */ new Set([
+  "atomicMutation",
+  "evidenceStore",
+  "host"
+]);
+function isDurableOperationUnsupportedDimension(value) {
+  return typeof value === "string" && DURABLE_OPERATION_UNSUPPORTED_DIMENSIONS.has(
+    value
+  );
+}
+async function normalizeOperationOutcome(outcome, expected) {
+  if (typeof outcome !== "object" || outcome === null || Array.isArray(outcome)) {
+    return err(
+      new DurableOperationEvidenceError(
+        "Durable operation host returned a malformed outcome envelope.",
+        { details: { idempotencyKey: expected.idempotencyKey } }
+      )
+    );
+  }
+  const record = outcome;
+  const outcomeKind = record["outcome"];
+  if (outcomeKind === "unsupported") {
+    const dimensions = record["dimensions"];
+    const normalizedDimensions = Array.isArray(dimensions) ? dimensions.filter(
+      (dimension) => isDurableOperationUnsupportedDimension(dimension)
+    ) : [];
+    const [firstDimension, ...remainingDimensions] = normalizedDimensions;
+    if (!Array.isArray(dimensions) || firstDimension === void 0 || normalizedDimensions.length !== dimensions.length || new Set(normalizedDimensions).size !== normalizedDimensions.length) {
+      return err(
+        new DurableOperationEvidenceError(
+          "Durable operation host returned malformed unsupported dimensions.",
+          { details: { idempotencyKey: expected.idempotencyKey } }
+        )
+      );
+    }
+    return ok({
+      outcome: "unsupported",
+      dimensions: [firstDimension, ...remainingDimensions]
+    });
+  }
+  if (outcomeKind !== "applied" && outcomeKind !== "replayed") {
+    return err(
+      new DurableOperationEvidenceError(
+        "Durable operation host returned an unknown outcome.",
+        {
+          details: {
+            idempotencyKey: expected.idempotencyKey,
+            outcome: outcomeKind
+          }
+        }
+      )
+    );
+  }
+  const evidence = await validateEvidenceForOperation(
+    record["evidence"],
+    expected
+  );
+  if (isErr(evidence)) return evidence;
+  if (outcomeKind === "applied" && evidence.data.delivered) {
+    return err(
+      new DurableOperationEvidenceError(
+        "Newly applied durable operation evidence must be undelivered.",
+        { details: { idempotencyKey: expected.idempotencyKey } }
+      )
+    );
+  }
+  return ok({ outcome: outcomeKind, evidence: evidence.data });
+}
+function validateCoordinates(coordinates, evidence, side) {
+  const idempotencyKey = evidence["idempotencyKey"];
+  if (typeof coordinates !== "object" || coordinates === null || Array.isArray(coordinates)) {
+    return new DurableOperationEvidenceError(
+      `Durable operation evidence ${side} coordinates are malformed.`,
+      { details: { idempotencyKey, side } }
+    );
+  }
+  const record = coordinates;
+  if (typeof record["base"] !== "string" || record["base"].length === 0) {
+    return new DurableOperationEvidenceError(
+      `Durable operation evidence ${side} coordinates need a non-empty base.`,
+      { details: { idempotencyKey, side } }
+    );
+  }
+  if (record["revision"] !== void 0 && (typeof record["revision"] !== "string" || record["revision"].length === 0)) {
+    return new DurableOperationEvidenceError(
+      `Durable operation evidence ${side} coordinates revision must be a non-empty string.`,
+      { details: { idempotencyKey, side } }
+    );
+  }
+  return void 0;
+}
+function unsupportedError(member, strategyType) {
+  return new DurableOperationUnsupportedError(
+    `Durable strategy "${strategyType}" does not provide the "${member}" operation capability.`,
+    {
+      details: { strategyType, member },
+      suggestion: "Use a strategy whose `operations` capability provides atomic mutation-plus-evidence and evidence access; TypeGraph never emulates the atomic guarantee."
+    }
+  );
+}
+async function operateDurableBranch(descriptor, strategy, request) {
+  const owner = requireDescriptorOwner(descriptor, strategy);
+  if (!owner.ok) return err(owner.error);
+  const normalized = await normalizeOperationRequest(request);
+  if (isErr(normalized)) return normalized;
+  if (strategy.operations === void 0) {
+    return ok({
+      outcome: "unsupported",
+      dimensions: ["atomicMutation"]
+    });
+  }
+  try {
+    const outcome = await strategy.operations.operate({
+      descriptor: descriptor.store,
+      expectedOrigin: owner.origin,
+      request: normalized.data
+    });
+    return await normalizeOperationOutcome(outcome, normalized.data);
+  } catch (error) {
+    return err(
+      error instanceof DurableOperationError ? error : new DurableOperationError(
+        `Durable operation failed: ${describeCause(error)}`,
+        {
+          cause: error,
+          details: { idempotencyKey: request.idempotencyKey }
+        }
+      )
+    );
+  }
+}
+async function getDurableOperation(descriptor, strategy, idempotencyKey) {
+  const owner = requireDescriptorOwner(descriptor, strategy);
+  if (!owner.ok) return err(owner.error);
+  if (strategy.operations === void 0) {
+    return err(unsupportedError("get", strategy.type));
+  }
+  try {
+    const evidence = await strategy.operations.get({
+      descriptor: descriptor.store,
+      expectedOrigin: owner.origin,
+      idempotencyKey
+    });
+    if (evidence === void 0) return ok(void 0);
+    return await normalizeStoredEvidence(evidence, idempotencyKey);
+  } catch (error) {
+    return err(
+      error instanceof DurableOperationError ? error : new DurableOperationError(
+        `Failed to read durable operation "${idempotencyKey}": ${describeCause(error)}`,
+        { cause: error, details: { idempotencyKey } }
+      )
+    );
+  }
+}
+async function scanDurableOperations(descriptor, strategy, options = {}) {
+  const owner = requireDescriptorOwner(descriptor, strategy);
+  if (!owner.ok) return err(owner.error);
+  const limit = options.limit ?? DURABLE_OPERATION_SCAN_DEFAULT_LIMIT;
+  if (!Number.isInteger(limit) || limit < 1) {
+    return err(
+      new DurableOperationRequestError(
+        "Durable operation scan limit must be a positive integer.",
+        { details: { limit } }
+      )
+    );
+  }
+  if (limit > DURABLE_OPERATION_SCAN_MAX_LIMIT) {
+    return err(
+      new DurableOperationRequestError(
+        `Durable operation scan limit ${limit} exceeds the maximum of ${DURABLE_OPERATION_SCAN_MAX_LIMIT}.`,
+        {
+          details: { limit, max: DURABLE_OPERATION_SCAN_MAX_LIMIT },
+          suggestion: `Request at most ${DURABLE_OPERATION_SCAN_MAX_LIMIT} operations per page and page with the returned cursor.`
+        }
+      )
+    );
+  }
+  if (strategy.operations === void 0) {
+    return err(unsupportedError("scan", strategy.type));
+  }
+  try {
+    const rawPage = await strategy.operations.scan({
+      descriptor: descriptor.store,
+      expectedOrigin: owner.origin,
+      after: options.after,
+      limit
+    });
+    if (typeof rawPage !== "object" || rawPage === null || Array.isArray(rawPage)) {
+      return err(
+        new DurableOperationEvidenceError(
+          "Durable operation scan returned a malformed page.",
+          { details: { limit } }
+        )
+      );
+    }
+    const page = rawPage;
+    const rawOperations = page["operations"];
+    const cursor = page["cursor"];
+    if (!Array.isArray(rawOperations) || rawOperations.length > limit || cursor !== void 0 && (typeof cursor !== "string" || cursor.length === 0)) {
+      return err(
+        new DurableOperationEvidenceError(
+          "Durable operation scan returned a malformed page.",
+          { details: { limit } }
+        )
+      );
+    }
+    const operations = [];
+    for (const evidence of rawOperations) {
+      const normalized = await normalizeStoredEvidence(evidence);
+      if (isErr(normalized)) return normalized;
+      operations.push(normalized.data);
+    }
+    return ok(
+      cursor === void 0 ? { operations } : { operations, cursor }
+    );
+  } catch (error) {
+    return err(
+      error instanceof DurableOperationError ? error : new DurableOperationError(
+        `Failed to scan durable operations: ${describeCause(error)}`,
+        { cause: error, details: { limit } }
+      )
+    );
+  }
+}
+async function markDurableOperationDelivered(descriptor, strategy, idempotencyKey) {
+  const owner = requireDescriptorOwner(descriptor, strategy);
+  if (!owner.ok) return err(owner.error);
+  if (strategy.operations === void 0) {
+    return err(unsupportedError("markDelivered", strategy.type));
+  }
+  try {
+    const evidence = await strategy.operations.markDelivered({
+      descriptor: descriptor.store,
+      expectedOrigin: owner.origin,
+      idempotencyKey
+    });
+    if (evidence === void 0) return ok(void 0);
+    const normalized = await normalizeStoredEvidence(evidence, idempotencyKey);
+    if (isErr(normalized)) return normalized;
+    if (!normalized.data.delivered) {
+      return err(
+        new DurableOperationEvidenceError(
+          "Durable operation delivery marking returned undelivered evidence.",
+          { details: { idempotencyKey } }
+        )
+      );
+    }
+    return normalized;
+  } catch (error) {
+    return err(
+      error instanceof DurableOperationError ? error : new DurableOperationError(
+        `Failed to mark durable operation "${idempotencyKey}" delivered: ${describeCause(error)}`,
+        { cause: error, details: { idempotencyKey } }
+      )
+    );
+  }
+}
+async function durableBranchHasUndeliveredEvidence(descriptor, strategy) {
+  const owner = requireDescriptorOwner(descriptor, strategy);
+  if (!owner.ok) return err(owner.error);
+  if (strategy.operations === void 0) {
+    return err(unsupportedError("hasUndelivered", strategy.type));
+  }
+  try {
+    const hasUndelivered = await strategy.operations.hasUndelivered({
+      descriptor: descriptor.store,
+      expectedOrigin: owner.origin
+    });
+    return typeof hasUndelivered === "boolean" ? ok(hasUndelivered) : err(
+      new DurableOperationEvidenceError(
+        "Durable operation undelivered query returned a non-boolean value."
+      )
+    );
+  } catch (error) {
+    return err(
+      error instanceof DurableOperationError ? error : new DurableOperationError(
+        `Failed to query undelivered durable evidence: ${describeCause(error)}`,
+        { cause: error }
+      )
+    );
+  }
+}
+
 // src/graph-merge/evolution-branch.ts
 async function branchForEvolution(store, plan, makeBackend, options) {
   try {
@@ -10749,6 +11253,6 @@ async function branchForEvolution(store, plan, makeBackend, options) {
   }
 }
 
-export { BaseVersionMismatchError, BranchError, CANDIDATE_WRITE_SET_FORMAT_VERSION, CandidateSourceError, CandidateWriteSetError, CandidateWriteSetSchema, CandidateWriteSetTargetSchema, IdentityMergeConflictError, InvalidMergeOptionsError, InvalidMergePlanError, MERGE_ERROR_CODES, MERGE_OPTION_DEFAULTS, MERGE_PLAN_DIGEST_ALGORITHM, MERGE_PLAN_FORMAT_VERSION, MERGE_REVIEW_FORMAT_VERSION, MatchEvidenceError, MergeConflictError, MergeConstraintConflictError, MergeError, MergePlanCapabilityError, MergePlanDigestMismatchError, MergePlanOriginMismatchError, MergePlanSchemaMismatchError, MergePlanTargetMismatchError, MergePlanningStaleError, MergeReviewError, SimilarityUnavailableError, StaleMergePlanError, UnsupportedMergePlanVersionError, VALIDITY_END_TARGET_PRECEDENCE, applyDurableMergePlan, applyMergePlan, applyMergePlanInTransaction, asBaseVersion, asBranchId, branch, branchDurable, branchForEvolution, captureCandidateWriteSetTarget, captureCandidateWriteSetTargetForEvolution, cloneWorkingCopyStrategy, computeBaseVersion, destroyDurableBranch, forkedWorkingCopyStrategy, ingestionBranch, merge, mergeIncremental, normalizeMergeOptions, openProvenanceStore, persistProvenanceRecords, planCandidateWriteSet, planCandidateWriteSetForEvolution, planCandidateWriteSetReview, planMerge, planMergeForEvolution, planMergeIncremental, provenanceGraphId, readProvenance, reopenDurableBranch, revalidateCandidateWriteSetReview };
+export { BaseVersionMismatchError, BranchError, CANDIDATE_WRITE_SET_FORMAT_VERSION, CandidateSourceError, CandidateWriteSetError, CandidateWriteSetSchema, CandidateWriteSetTargetSchema, DURABLE_OPERATION_SCAN_DEFAULT_LIMIT, DURABLE_OPERATION_SCAN_MAX_LIMIT, DurableEvidenceUndeliveredError, DurableOperationConflictError, DurableOperationError, DurableOperationEvidenceError, DurableOperationRequestError, DurableOperationUnsupportedError, IdentityMergeConflictError, InvalidMergeOptionsError, InvalidMergePlanError, MERGE_ERROR_CODES, MERGE_OPTION_DEFAULTS, MERGE_PLAN_DIGEST_ALGORITHM, MERGE_PLAN_FORMAT_VERSION, MERGE_REVIEW_FORMAT_VERSION, MatchEvidenceError, MergeConflictError, MergeConstraintConflictError, MergeError, MergePlanCapabilityError, MergePlanDigestMismatchError, MergePlanOriginMismatchError, MergePlanSchemaMismatchError, MergePlanTargetMismatchError, MergePlanningStaleError, MergeReviewError, SimilarityUnavailableError, StaleMergePlanError, UnsupportedMergePlanVersionError, VALIDITY_END_TARGET_PRECEDENCE, applyDurableMergePlan, applyMergePlan, applyMergePlanInTransaction, asBaseVersion, asBranchId, branch, branchDurable, branchForEvolution, captureCandidateWriteSetTarget, captureCandidateWriteSetTargetForEvolution, cloneWorkingCopyStrategy, computeBaseVersion, computeDurableOperationDigest, destroyDurableBranch, durableBranchHasUndeliveredEvidence, forkedWorkingCopyStrategy, getDurableOperation, ingestionBranch, markDurableOperationDelivered, merge, mergeIncremental, normalizeMergeOptions, openProvenanceStore, operateDurableBranch, persistProvenanceRecords, planCandidateWriteSet, planCandidateWriteSetForEvolution, planCandidateWriteSetReview, planMerge, planMergeForEvolution, planMergeIncremental, provenanceGraphId, readProvenance, reopenDurableBranch, revalidateCandidateWriteSetReview, scanDurableOperations };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map