@nicia-ai/typegraph 0.67.1 → 0.68.1

package/dist/graph-merge/index.d.cts

@@ -922,6 +922,12 @@ declare const MERGE_ERROR_CODES: {
     readonly evidence: "GRAPH_MERGE_EVIDENCE";
     readonly candidateWriteSet: "GRAPH_MERGE_CANDIDATE_WRITE_SET";
     readonly review: "GRAPH_MERGE_REVIEW";
+    readonly operation: "GRAPH_MERGE_OPERATION";
+    readonly operationRequest: "GRAPH_MERGE_OPERATION_REQUEST";
+    readonly operationConflict: "GRAPH_MERGE_OPERATION_CONFLICT";
+    readonly operationUnsupported: "GRAPH_MERGE_OPERATION_UNSUPPORTED";
+    readonly operationEvidence: "GRAPH_MERGE_OPERATION_EVIDENCE";
+    readonly operationUndelivered: "GRAPH_MERGE_OPERATION_UNDELIVERED";
 };
 /**
  * Options shared by every merge error. Mirrors the relevant subset of
@@ -1074,6 +1080,58 @@ declare class MatchEvidenceError extends MergeError {
     readonly code: "GRAPH_MERGE_EVIDENCE";
     constructor(message: string, options?: MergeErrorOptions);
 }
+/**
+ * Generic operational failure raised while orchestrating a durable-branch
+ * operation, such as a strategy transport or host failure.
+ */
+declare class DurableOperationError extends MergeError {
+    readonly code: string;
+    constructor(message: string, options?: MergeErrorOptions);
+}
+/** Raised when a durable-operation request or descriptor is invalid. */
+declare class DurableOperationRequestError extends DurableOperationError {
+    protected static readonly errorCategory = "user";
+    readonly code: "GRAPH_MERGE_OPERATION_REQUEST";
+    constructor(message: string, options?: MergeErrorOptions);
+}
+/**
+ * Raised when an idempotency key is reused with a different operation digest.
+ * The previously committed operation is returned untouched; the new request is
+ * refused before any graph mutation or evidence write.
+ */
+declare class DurableOperationConflictError extends DurableOperationError {
+    protected static readonly errorCategory = "constraint";
+    readonly code: "GRAPH_MERGE_OPERATION_CONFLICT";
+    constructor(message: string, options?: MergeErrorOptions);
+}
+/**
+ * Raised when a host cannot provide the atomic mutation-plus-evidence
+ * guarantee. It carries the dimensions the host cannot honor. The portable
+ * fallback is refusal; TypeGraph never emulates atomicity with callbacks or
+ * best effort.
+ */
+declare class DurableOperationUnsupportedError extends DurableOperationError {
+    protected static readonly errorCategory = "user";
+    readonly code: "GRAPH_MERGE_OPERATION_UNSUPPORTED";
+    constructor(message: string, options?: MergeErrorOptions);
+}
+/** Raised when a host returns malformed or request-inconsistent evidence. */
+declare class DurableOperationEvidenceError extends DurableOperationError {
+    readonly code: "GRAPH_MERGE_OPERATION_EVIDENCE";
+    constructor(message: string, options?: MergeErrorOptions);
+}
+/**
+ * Raised when archive/destroy is fenced by undelivered operation evidence.
+ *
+ * Extends {@link BranchError} so the established `destroyDurableBranch` result
+ * type already transports it: a strategy that refuses destruction while
+ * undelivered evidence remains preserves that refusal to the caller instead of
+ * having it flattened into a generic branch failure.
+ */
+declare class DurableEvidenceUndeliveredError extends BranchError {
+    readonly code: "GRAPH_MERGE_OPERATION_UNDELIVERED";
+    constructor(message: string, options?: MergeErrorOptions);
+}
 
 /**
  * Pluggable working-copy strategy: how `branch()` produces an isolated,
@@ -1112,6 +1170,14 @@ declare class MatchEvidenceError extends MergeError {
  * identical reads on the base for any instant between the row's real
  * creation and the clone.
  *
+ * Undeclared properties are the same class of stored live state.
+ * `validateStore()` treats them as healthy semi-structured data. The clone
+ * therefore imports with `onUnknownProperty: "allow"` — interchange's
+ * fidelity-preserving strategy — so those keys survive the round trip.
+ * `"error"` would refuse to branch a graph analysis already reports as clean.
+ * `"strip"` would drop the keys on the fork, and the merge diff against the
+ * original base would invent deletions the caller never made.
+ *
  * Logical-namespace (copy-on-write within one backend, no full data copy) is a
  * future strategy slot — see the `WorkingCopyStrategy` interface — deferred past
  * P0.
@@ -1177,14 +1243,17 @@ type MakeBackend = () => Promise<GraphBackend>;
  *      base's live state.
  *   2. Create a fresh store over the caller-provided backend with the SAME graph
  *      definition via `createStoreWithSchema`.
- *   3. `importGraphStream(freshStore, data, { onConflict: "error", ... })` — ids are
- *      preserved so the diff engine can key on them. `onConflict: "error"`
- *      requires the backend to be EMPTY: a pre-existing row is a contract
- *      violation that must surface loudly, never be silently skipped (a skipped
- *      row would leave the clone diverging from the base, so the fork's diff would
- *      report phantom modifications/deletions). `importGraphStream` RETURNS
- *      `{ success, errors }` rather than throwing on a per-row rejection, so its
- *      result is checked and any failure fails the branch.
+ *   3. `importGraphStream(freshStore, data, { onConflict: "error",
+ *      onUnknownProperty: "allow", ... })` — ids are preserved so the diff
+ *      engine can key on them. `onConflict: "error"` requires the backend to be
+ *      EMPTY: a pre-existing row is a contract violation that must surface
+ *      loudly, never be silently skipped (a skipped row would leave the clone
+ *      diverging from the base, so the fork's diff would report phantom
+ *      modifications/deletions). `onUnknownProperty: "allow"` carries undeclared
+ *      properties through (see the fidelity note above). A streamed chunk that
+ *      reports per-row errors throws (default `onStreamChunkError: "abort"`); a
+ *      materialized import returns `{ success, errors }`. Either failure fails
+ *      the branch.
  *
  * The backend `makeBackend()` returns is opened here, so any failure AFTER it is
  * created closes it before rethrowing — only the success path hands the backend
@@ -1780,6 +1849,230 @@ declare function planCandidateWriteSetReview<G extends GraphDef>(args: PlanCandi
  */
 declare function revalidateCandidateWriteSetReview<G extends GraphDef>(args: RevalidateCandidateWriteSetReviewArgs<G>): Promise<Result<MergeReviewRevalidation, MergeError>>;
 
+/**
+ * Durable-branch operations: a generic, backend-neutral facility for a durable
+ * host to combine an opaque graph mutation with immutable operation evidence in
+ * ONE host transaction.
+ *
+ * The facility is deliberately the same shape as the optional host-native merge
+ * command ({@link import("./durable-merge").applyDurableMergePlan}): TypeGraph
+ * owns descriptor validation, sealed-origin attestation, request
+ * canonicalization, and evidence validation; the host owns the database
+ * mechanics. A strategy that cannot combine the mutation and its evidence in a
+ * single atomic unit returns `unsupported` BEFORE touching the host, and
+ * TypeGraph refuses rather than emulating atomicity with callbacks or best
+ * effort.
+ *
+ * WHAT IS OPAQUE. Both `metadata` and `mutation` are JSON-safe host values.
+ * TypeGraph never interprets their application fields; it canonicalizes them to
+ * derive {@link DurableBranchOperation.operationDigest} and otherwise carries
+ * them through untouched. `metadata` is retained as evidence; `mutation` is the
+ * host's own description of the graph change it must apply (for example a
+ * serialized statement or a host-defined command) atomically with the evidence
+ * row.
+ *
+ * IDEMPOTENCY. The digest is derived from the complete request content
+ * (`mutation` plus `metadata`) with the repository's canonical JSON serializer.
+ * The strategy is handed the digest and MUST treat `(idempotencyKey)` as the
+ * unique key: identical key AND digest returns the previously committed
+ * evidence without re-applying; identical key with a different digest fails
+ * with {@link DurableOperationConflictError} and mutates nothing.
+ *
+ * DELIVERY AND DESTRUCTION. Evidence is delivered explicitly via
+ * {@link markDurableOperationDelivered}. Archive/destroy is fenced on
+ * undelivered evidence: a strategy MUST refuse destruction while undelivered
+ * evidence remains, and the refusal is preserved through
+ * {@link import("./durable-branch").destroyDurableBranch} as a
+ * {@link DurableEvidenceUndeliveredError}. Concurrent `operate` and `destroy`
+ * are serialized by the host's own transaction: either the operation commits
+ * first (destroy observes undelivered evidence and refuses) or destroy commits
+ * first (the operation fails against the removed allocation). No partial state
+ * is ever observable.
+ *
+ * CURSORS. {@link scanDurableOperations} returns evidence in a stable total
+ * order the strategy defines (commit order, ties broken deterministically).
+ * `cursor` is an opaque continuation token; pass it back as `after` to resume.
+ * A missing `cursor` means the scan reached the end.
+ */
+
+/** Default page size for {@link scanDurableOperations}. */
+declare const DURABLE_OPERATION_SCAN_DEFAULT_LIMIT = 100;
+/** Largest page a single {@link scanDurableOperations} call may request. */
+declare const DURABLE_OPERATION_SCAN_MAX_LIMIT = 1000;
+/**
+ * The dimensions whose absence a strategy reports through the `unsupported`
+ * outcome. Each names a guarantee TypeGraph will not fake.
+ */
+type DurableOperationUnsupportedDimension = "atomicMutation" | "evidenceStore" | "host";
+/**
+ * The caller's operation request. `idempotencyKey` identifies the operation;
+ * `mutation` is the host's opaque, JSON-safe description of the graph change;
+ * `metadata` is opaque, JSON-safe host evidence TypeGraph never interprets.
+ */
+type DurableBranchOperationRequest = Readonly<{
+    idempotencyKey: string;
+    metadata: JsonValue;
+    mutation: JsonValue;
+}>;
+/**
+ * The canonical operation handed to the strategy: the request plus the
+ * TypeGraph-derived digest the strategy must use for idempotency.
+ */
+type DurableBranchOperation = Readonly<{
+    idempotencyKey: string;
+    operationDigest: string;
+    metadata: JsonValue;
+    mutation: JsonValue;
+}>;
+/**
+ * A branch's content coordinates at one point. `base` is the
+ * merge-visible base-version fingerprint (as produced by
+ * `computeBaseVersion`); `revision` is the engine revision when the working
+ * copy resolves lineage.
+ */
+type DurableBranchCoordinates = Readonly<{
+    base: BaseVersion;
+    revision?: EngineRevision | undefined;
+}>;
+/**
+ * Immutable evidence of one committed operation. `delivered` is the only
+ * mutating dimension, and it moves in one direction (`false` → `true`) under
+ * {@link DurableOperationCapability.markDelivered}. A newly `applied`
+ * operation must return `false`; an exact `replayed` operation returns its
+ * current committed delivery state.
+ */
+type DurableBranchOperationEvidence = Readonly<{
+    idempotencyKey: string;
+    operationDigest: string;
+    metadata: JsonValue;
+    mutation: JsonValue;
+    before: DurableBranchCoordinates;
+    after: DurableBranchCoordinates;
+    delivered: boolean;
+}>;
+/** One stable-order page of evidence returned by {@link scanDurableOperations}. */
+type DurableOperationScan = Readonly<{
+    operations: readonly DurableBranchOperationEvidence[];
+    /** Opaque continuation token; absent when the scan reached the end. */
+    cursor?: string | undefined;
+}>;
+/** Outcome of an atomic operation attempt. */
+type DurableOperationOutcome = Readonly<{
+    outcome: "applied" | "replayed";
+    evidence: DurableBranchOperationEvidence;
+}> | Readonly<{
+    outcome: "unsupported";
+    dimensions: readonly [
+        DurableOperationUnsupportedDimension,
+        ...DurableOperationUnsupportedDimension[]
+    ];
+}>;
+/**
+ * The optional host capability behind `DurableWorkingCopyStrategy.operations`.
+ *
+ * Every member receives the opaque locator AND the caller's expected origin, so
+ * the host attests the sealed origin exactly as it does for reopen, destroy,
+ * and native merge. TypeGraph validates the descriptor before any member is
+ * called.
+ */
+type DurableOperationCapability<TStoreDescriptor extends DurableStoreDescriptor = DurableStoreDescriptor> = Readonly<{
+    /**
+     * Atomically applies `request.mutation` and records evidence, or returns
+     * `unsupported` having executed no host SQL or mutation.
+     *
+     * The host MUST:
+     *   1. attest `expectedOrigin` against the allocation `descriptor` names;
+     *   2. return the previously committed evidence unchanged when
+     *      `(idempotencyKey, operationDigest)` matches a committed operation,
+     *      applying nothing;
+     *   3. refuse with {@link DurableOperationConflictError} when the key exists
+     *      with a different digest, applying nothing; and
+     *   4. otherwise apply the mutation and undelivered evidence in ONE
+     *      transaction, returning `outcome: "applied"` with `delivered: false`.
+     */
+    operate: (args: Readonly<{
+        descriptor: TStoreDescriptor;
+        expectedOrigin: DurableBranchOrigin;
+        request: DurableBranchOperation;
+    }>) => Promise<DurableOperationOutcome>;
+    /** Reads one operation's evidence, or `undefined` when never committed. */
+    get: (args: Readonly<{
+        descriptor: TStoreDescriptor;
+        expectedOrigin: DurableBranchOrigin;
+        idempotencyKey: string;
+    }>) => Promise<DurableBranchOperationEvidence | undefined>;
+    /**
+     * Reads evidence in the strategy's stable total order. `after` resumes from
+     * a previous page's `cursor`; `limit` bounds the page.
+     */
+    scan: (args: Readonly<{
+        descriptor: TStoreDescriptor;
+        expectedOrigin: DurableBranchOrigin;
+        after?: string | undefined;
+        limit: number;
+    }>) => Promise<DurableOperationScan>;
+    /**
+     * Marks one operation delivered. MUST be idempotent: marking an
+     * already-delivered operation returns the same evidence and writes nothing.
+     * Returns `undefined` when the operation does not exist.
+     */
+    markDelivered: (args: Readonly<{
+        descriptor: TStoreDescriptor;
+        expectedOrigin: DurableBranchOrigin;
+        idempotencyKey: string;
+    }>) => Promise<DurableBranchOperationEvidence | undefined>;
+    /** Whether any committed evidence is still undelivered. */
+    hasUndelivered: (args: Readonly<{
+        descriptor: TStoreDescriptor;
+        expectedOrigin: DurableBranchOrigin;
+    }>) => Promise<boolean>;
+}>;
+/**
+ * Derives the operation digest from its canonical content. The digest covers
+ * the complete request except the idempotency key, so reusing a key with a
+ * different mutation OR different metadata conflicts.
+ */
+declare function computeDurableOperationDigest(request: DurableBranchOperationRequest): Promise<string>;
+/**
+ * Atomically applies an opaque graph mutation and commits its evidence through
+ * the strategy's optional `operations.operate` capability.
+ *
+ * Descriptor format/type/version validation and the sealed-origin attestation
+ * are exactly those of reopen, destroy, and native merge: TypeGraph validates
+ * the envelope and hands the caller's expected origin to the host, which
+ * attests it inside its own transaction. A strategy without the capability
+ * yields the `unsupported` outcome with no host call.
+ */
+declare function operateDurableBranch<G extends GraphDef, TStoreDescriptor extends DurableStoreDescriptor = DurableStoreDescriptor>(descriptor: DurableBranchDescriptor<TStoreDescriptor>, strategy: DurableWorkingCopyStrategy<G, TStoreDescriptor>, request: DurableBranchOperationRequest): Promise<Result<DurableOperationOutcome, DurableOperationError>>;
+/**
+ * Reads one operation's evidence. Returns `undefined` when the operation was
+ * never committed. A strategy without evidence access is an explicit typed
+ * refusal.
+ */
+declare function getDurableOperation<G extends GraphDef, TStoreDescriptor extends DurableStoreDescriptor = DurableStoreDescriptor>(descriptor: DurableBranchDescriptor<TStoreDescriptor>, strategy: DurableWorkingCopyStrategy<G, TStoreDescriptor>, idempotencyKey: string): Promise<Result<DurableBranchOperationEvidence | undefined, DurableOperationError>>;
+/**
+ * Reads evidence in a stable order. `after` resumes from a previous page's
+ * `cursor`; `limit` defaults to {@link DURABLE_OPERATION_SCAN_DEFAULT_LIMIT}
+ * and may not exceed {@link DURABLE_OPERATION_SCAN_MAX_LIMIT}. The returned
+ * `cursor` is absent at the end of the scan.
+ */
+declare function scanDurableOperations<G extends GraphDef, TStoreDescriptor extends DurableStoreDescriptor = DurableStoreDescriptor>(descriptor: DurableBranchDescriptor<TStoreDescriptor>, strategy: DurableWorkingCopyStrategy<G, TStoreDescriptor>, options?: Readonly<{
+    after?: string | undefined;
+    limit?: number | undefined;
+}>): Promise<Result<DurableOperationScan, DurableOperationError>>;
+/**
+ * Marks one operation delivered, idempotently. Marking an already-delivered
+ * operation returns the same evidence without writing. Returns `undefined` when
+ * the operation does not exist.
+ */
+declare function markDurableOperationDelivered<G extends GraphDef, TStoreDescriptor extends DurableStoreDescriptor = DurableStoreDescriptor>(descriptor: DurableBranchDescriptor<TStoreDescriptor>, strategy: DurableWorkingCopyStrategy<G, TStoreDescriptor>, idempotencyKey: string): Promise<Result<DurableBranchOperationEvidence | undefined, DurableOperationError>>;
+/**
+ * Reports whether any committed evidence is still undelivered. Archive/destroy
+ * must fence on this; the strategy enforces the fence atomically, this is the
+ * queryable half.
+ */
+declare function durableBranchHasUndeliveredEvidence<G extends GraphDef, TStoreDescriptor extends DurableStoreDescriptor = DurableStoreDescriptor>(descriptor: DurableBranchDescriptor<TStoreDescriptor>, strategy: DurableWorkingCopyStrategy<G, TStoreDescriptor>): Promise<Result<boolean, DurableOperationError>>;
+
 /**
  * Durable working-copy branches: a JSON-serializable descriptor for a
  * PERSISTENT working copy plus reopen / destroy operations over it.
@@ -2056,6 +2349,21 @@ type DurableWorkingCopyStrategy<G extends GraphDef, TStoreDescriptor extends Dur
         expectedOrigin: DurableBranchOrigin;
         plan: MergePlanArtifactV1;
     }>) => Promise<NativeDurableMergeResult>) | undefined;
+    /**
+     * Optional atomic operation + evidence capability.
+     *
+     * When present, {@link import("./durable-operation").operateDurableBranch}
+     * commits the host's opaque graph mutation and its immutable evidence in one
+     * host transaction, keyed by idempotency. `destroy` MUST additionally refuse
+     * to remove the allocation while undelivered evidence remains, throwing
+     * {@link DurableEvidenceUndeliveredError}; closing a branch handle still only
+     * releases the connection.
+     *
+     * A strategy that cannot provide the atomic guarantee MUST omit this
+     * capability (or return `unsupported` from `operate`) rather than emulating
+     * atomicity with callbacks or best effort. See `durable-operation.ts`.
+     */
+    operations?: DurableOperationCapability<TStoreDescriptor> | undefined;
 }>;
 /**
  * A normal {@link GraphBranch} paired with the serializable descriptor that
@@ -2623,4 +2931,4 @@ type KeylessConfig = Readonly<{
     sortFields: readonly string[];
 }>;
 
-export { type ApplyDurableMergePlanArgs, type BaseAmbiguity, type BaseNodeLookup, type BaseVersion, BaseVersionMismatchError, BranchError, type BranchId, type BranchOptions, type BranchProvenance, CANDIDATE_WRITE_SET_FORMAT_VERSION, type CandidateDiagnostic, type CandidateDiagnostics, type CandidateDiagnosticsOptions, type CandidateSource, CandidateSourceError, type CandidateWriteSet, CandidateWriteSetError, CandidateWriteSetSchema, type CandidateWriteSetTarget, CandidateWriteSetTargetSchema, type ComparisonCeilingPolicy, type ConflictingValue, type DeleteModifyConflict, type DeleteModifyPolicy, type DroppedItem, type DurableBranch, type DurableBranchDescriptor, type DurableBranchOrigin, type DurableStoreDescriptor, type DurableWorkingCopyAccess, type DurableWorkingCopyStrategy, type Embedder, type EntityRef, type EntityResolution, type ForkHandle, type ForkedWorkingCopyOptions, type GraphBranch, IdentityAssertionWriteFacade, IdentityMergeConflictError, type IngestionBranch, IngestionImportTarget, type IngestionNodeCollections, InvalidMergeOptionsError, InvalidMergePlanError, type KeylessConfig, MERGE_ERROR_CODES, MERGE_OPTION_DEFAULTS, MERGE_PLAN_DIGEST_ALGORITHM, MERGE_PLAN_FORMAT_VERSION, MERGE_REVIEW_FORMAT_VERSION, type MakeBackend, type MatchEvidence, MatchEvidenceError, type MatchSource, type MatchStrategy, type MergeBranch, MergeConflictError, MergeConstraintConflictError, type MergeConstraintConflictErrorDetails, MergeError, type MergeIncrementalArgs, type MergeOptions, type MergePlanAnchors, type MergePlanApplied, type MergePlanApplyOptions, type MergePlanArtifact, type MergePlanArtifactV1, type MergePlanArtifactV1Input, type MergePlanBranchAnchor, type MergePlanCandidateDiagnostic, type MergePlanCanonicalMapping, MergePlanCapabilityError, type MergePlanDiagnostics, type MergePlanDigest, MergePlanDigestMismatchError, type MergePlanEdgeDelete, type MergePlanEdgeUpsert, type MergePlanEntityRef, type MergePlanEntityResolution, type MergePlanGuards, type MergePlanIdentityAssertion, type MergePlanMatchEvidence, type MergePlanMatchSource, type MergePlanNodeDelete, type MergePlanNodeUpsert, MergePlanOriginMismatchError, type MergePlanProposedSummary, type MergePlanProvenanceOptions, type MergePlanReadContext, type MergePlanRetype, type MergePlanReview, type MergePlanRevisionFence, type MergePlanSchemaFence, MergePlanSchemaMismatchError, type MergePlanSimilarityStrategy, type MergePlanTargetFence, MergePlanTargetMismatchError, type MergePlanTypeReconciliation, type MergePlanWrites, MergePlanningStaleError, type MergeReport, type MergeReviewArtifact, type MergeReviewBaseline, type MergeReviewDifference, MergeReviewError, type MergeReviewPolicy, type MergeReviewRevalidation, type MergeReviewRow, type MergedCounts, type NativeDurableMergeResult, type NativeDurableMergeUnsupportedDimension, type NormalizedMergeOptions, type PlanCandidateWriteSetArgs, type PlanCandidateWriteSetForEvolutionArgs, type PlanCandidateWriteSetReviewArgs, type PropertyConflict, type PropertyConflictPolicy, type ProvenanceGraph, type ProvenanceIndex, type ProvenanceNode, type ProvenanceQuery, type ProvenanceRecord, type ReconcileTypesMode, type ResolveConfig, type ResolveMap, type ResolvedCluster, Result, type RevalidateCandidateWriteSetReviewArgs, type SimilarityStrategy, SimilarityUnavailableError, type SourceScope, StaleMergePlanError, type TypeReconciliation, UnsupportedMergePlanVersionError, VALIDITY_END_TARGET_PRECEDENCE, type ValidityEndResolution, type WorkingCopyStrategy, 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 { type ApplyDurableMergePlanArgs, type BaseAmbiguity, type BaseNodeLookup, type BaseVersion, BaseVersionMismatchError, BranchError, type BranchId, type BranchOptions, type BranchProvenance, CANDIDATE_WRITE_SET_FORMAT_VERSION, type CandidateDiagnostic, type CandidateDiagnostics, type CandidateDiagnosticsOptions, type CandidateSource, CandidateSourceError, type CandidateWriteSet, CandidateWriteSetError, CandidateWriteSetSchema, type CandidateWriteSetTarget, CandidateWriteSetTargetSchema, type ComparisonCeilingPolicy, type ConflictingValue, DURABLE_OPERATION_SCAN_DEFAULT_LIMIT, DURABLE_OPERATION_SCAN_MAX_LIMIT, type DeleteModifyConflict, type DeleteModifyPolicy, type DroppedItem, type DurableBranch, type DurableBranchCoordinates, type DurableBranchDescriptor, type DurableBranchOperation, type DurableBranchOperationEvidence, type DurableBranchOperationRequest, type DurableBranchOrigin, DurableEvidenceUndeliveredError, type DurableOperationCapability, DurableOperationConflictError, DurableOperationError, DurableOperationEvidenceError, type DurableOperationOutcome, DurableOperationRequestError, type DurableOperationScan, type DurableOperationUnsupportedDimension, DurableOperationUnsupportedError, type DurableStoreDescriptor, type DurableWorkingCopyAccess, type DurableWorkingCopyStrategy, type Embedder, type EntityRef, type EntityResolution, type ForkHandle, type ForkedWorkingCopyOptions, type GraphBranch, IdentityAssertionWriteFacade, IdentityMergeConflictError, type IngestionBranch, IngestionImportTarget, type IngestionNodeCollections, InvalidMergeOptionsError, InvalidMergePlanError, type KeylessConfig, MERGE_ERROR_CODES, MERGE_OPTION_DEFAULTS, MERGE_PLAN_DIGEST_ALGORITHM, MERGE_PLAN_FORMAT_VERSION, MERGE_REVIEW_FORMAT_VERSION, type MakeBackend, type MatchEvidence, MatchEvidenceError, type MatchSource, type MatchStrategy, type MergeBranch, MergeConflictError, MergeConstraintConflictError, type MergeConstraintConflictErrorDetails, MergeError, type MergeIncrementalArgs, type MergeOptions, type MergePlanAnchors, type MergePlanApplied, type MergePlanApplyOptions, type MergePlanArtifact, type MergePlanArtifactV1, type MergePlanArtifactV1Input, type MergePlanBranchAnchor, type MergePlanCandidateDiagnostic, type MergePlanCanonicalMapping, MergePlanCapabilityError, type MergePlanDiagnostics, type MergePlanDigest, MergePlanDigestMismatchError, type MergePlanEdgeDelete, type MergePlanEdgeUpsert, type MergePlanEntityRef, type MergePlanEntityResolution, type MergePlanGuards, type MergePlanIdentityAssertion, type MergePlanMatchEvidence, type MergePlanMatchSource, type MergePlanNodeDelete, type MergePlanNodeUpsert, MergePlanOriginMismatchError, type MergePlanProposedSummary, type MergePlanProvenanceOptions, type MergePlanReadContext, type MergePlanRetype, type MergePlanReview, type MergePlanRevisionFence, type MergePlanSchemaFence, MergePlanSchemaMismatchError, type MergePlanSimilarityStrategy, type MergePlanTargetFence, MergePlanTargetMismatchError, type MergePlanTypeReconciliation, type MergePlanWrites, MergePlanningStaleError, type MergeReport, type MergeReviewArtifact, type MergeReviewBaseline, type MergeReviewDifference, MergeReviewError, type MergeReviewPolicy, type MergeReviewRevalidation, type MergeReviewRow, type MergedCounts, type NativeDurableMergeResult, type NativeDurableMergeUnsupportedDimension, type NormalizedMergeOptions, type PlanCandidateWriteSetArgs, type PlanCandidateWriteSetForEvolutionArgs, type PlanCandidateWriteSetReviewArgs, type PropertyConflict, type PropertyConflictPolicy, type ProvenanceGraph, type ProvenanceIndex, type ProvenanceNode, type ProvenanceQuery, type ProvenanceRecord, type ReconcileTypesMode, type ResolveConfig, type ResolveMap, type ResolvedCluster, Result, type RevalidateCandidateWriteSetReviewArgs, type SimilarityStrategy, SimilarityUnavailableError, type SourceScope, StaleMergePlanError, type TypeReconciliation, UnsupportedMergePlanVersionError, VALIDITY_END_TARGET_PRECEDENCE, type ValidityEndResolution, type WorkingCopyStrategy, 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 };