@nicia-ai/typegraph 0.66.0 → 0.67.0

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

@@ -1,4 +1,4 @@
-import { gy as NodeId, a5 as NodeType, d0 as JsonValue, fy as EdgeId, e as GraphDef, b_ as EngineRevision, gB as NodeKinds, fX as GetNodeType, G as GraphIdentityConfig, aN as TypeGraphError, hd as TypeGraphErrorOptions, g as GraphBackend, fZ as GraphAnnotations, d1 as KindAnnotations, gr as MetaEdge, a4 as AnyEdgeType, bB as DeleteBehavior, e3 as TemporalMode, I as IndexDeclaration, cC as GraphExtensionVersion, c9 as ExtensionNodeDef, c3 as ExtensionEdgeDef, ce as ExtensionOntologyRelation, c7 as ExtensionIndex } from '../types-BynPp5kU.js';
+import { gy as NodeId, a5 as NodeType, d0 as JsonValue, e as GraphDef, b_ as EngineRevision, fy as EdgeId, gB as NodeKinds, fX as GetNodeType, G as GraphIdentityConfig, aN as TypeGraphError, hd as TypeGraphErrorOptions, g as GraphBackend, fZ as GraphAnnotations, d1 as KindAnnotations, gr as MetaEdge, a4 as AnyEdgeType, bB as DeleteBehavior, e3 as TemporalMode, I as IndexDeclaration, cC as GraphExtensionVersion, c9 as ExtensionNodeDef, c3 as ExtensionEdgeDef, ce as ExtensionOntologyRelation, c7 as ExtensionIndex } from '../types-BynPp5kU.js';
 export { C as ContributionDiagnostic, a as ContributionDiagnosticState, b as ContributionRepairEntry, c as ContributionRepairResult } from '../types-BynPp5kU.js';
 import { b as Store, bn as IdentityAssertionWriteFacade, bL as Node, dL as TransactionContext, ek as EDGE_TEMPORAL_READ_NAMES, g as IdentityFacade, el as IDENTITY_READ_NAMES, E as EvolutionPlan, dT as UniqueIntrospection } from '../store-C8ZPl7OW.js';
 export { B as BatchReadBuilder, C as CompiledOneStatementRead } from '../store-C8ZPl7OW.js';
@@ -1780,6 +1780,388 @@ declare function planCandidateWriteSetReview<G extends GraphDef>(args: PlanCandi
  */
 declare function revalidateCandidateWriteSetReview<G extends GraphDef>(args: RevalidateCandidateWriteSetReviewArgs<G>): Promise<Result<MergeReviewRevalidation, MergeError>>;
 
+/**
+ * Durable working-copy branches: a JSON-serializable descriptor for a
+ * PERSISTENT working copy plus reopen / destroy operations over it.
+ *
+ * `branch()` produces an {@link GraphBranch} whose store/close handle lives
+ * only in the process that minted it. A durable branch instead pairs the normal
+ * {@link GraphBranch} with a {@link DurableBranchDescriptor} — a plain JSON
+ * document the caller can store anywhere — so a LATER process can reconnect to
+ * the SAME mutated working copy without cloning the base and without keeping an
+ * in-memory map of open handles.
+ *
+ * The descriptor has two halves:
+ *
+ *   - TypeGraph-owned fences: `kind`/`version`, the owning `graphId`, the
+ *     branch id, the `base@V` token the working copy forked from, the at-fork
+ *     schema anchor (explicitly absent for an unmanaged store), and the
+ *     at-fork engine revision when the working copy resolved `lineage`.
+ *   - An opaque, strategy-defined `store` locator. TypeGraph never interprets
+ *     it and never assumes a database URL, product, or dialect.
+ *
+ * TAMPER MODEL: the descriptor is a document the caller stores and later hands
+ * back, so every TypeGraph-owned fence in it is UNTRUSTED. The durable host is
+ * the authority: at seal time it persists the {@link DurableBranchOrigin} that
+ * TypeGraph captured at the fork, and at reopen it ATTESTS the complete origin
+ * it holds. Reopen refuses unless every descriptor fence equals the attested
+ * origin — a tampered `graphId`/`definitionHash`/`base`/`branchId`/
+ * `forkRevision`/`schemaAnchor`, including DELETING `schemaAnchor` from the
+ * envelope, cannot relabel a fork, because the host's own record is the
+ * reference. `destroy` is verified the same way before it deletes (see
+ * {@link DurableWorkingCopyStrategy.destroy}), so swapping one working copy's
+ * locator for another's cannot destroy the wrong allocation.
+ *
+ * DEFINITION IDENTITY is part of that origin and is INDEPENDENT of the optional
+ * committed `schemaAnchor`: the host attests the `graphId` AND a version-blind
+ * {@link getGraphDefinitionHash} of the caller's fork-time definition. An
+ * unmanaged working copy (one that committed no schema row, so its
+ * `schemaAnchor` is absent) therefore still refuses descriptor `graphId`
+ * relabeling, reopening with a different `graphId`, and — the case a missing
+ * anchor used to let through — a SAME-ID graph whose definition hashes
+ * differently. Definition identity is the fork-time caller definition; the
+ * branch's CURRENT committed schema may legitimately evolve after forking, so
+ * reopen never compares the live schema row to the fork-time identity.
+ *
+ * The host lifecycle is split deliberately. `GraphBranch.close()` releases the
+ * process's CONNECTION to the working copy — it must never delete it. Explicit
+ * teardown is a separate strategy operation, {@link DurableWorkingCopyStrategy.destroy},
+ * surfaced through {@link destroyDurableBranch}. This keeps the ephemeral
+ * {@link ForkHandle.dispose}-deletes-the-fork contract out of the durable path,
+ * where "the process closed its connection" and "the working copy is gone" are
+ * different events.
+ *
+ * The at-fork schema anchor is IMMUTABLE FORK METADATA, never a statement about
+ * the working copy's CURRENT schema: a branch may legitimately evolve its
+ * committed schema after forking, and reopen must still succeed. Reopen therefore
+ * never compares the live schema row to the anchor; it compares the descriptor's
+ * anchor to the host's, and the caller's graph definition to the attested
+ * definition hash. The merge path separately refuses a branch whose LIVE schema
+ * moved (see `merge.ts`'s at-fork drift guard); reopen is not that gate.
+ *
+ * Backend-specific mechanics remain entirely within the strategy.
+ */
+
+/**
+ * A strategy-defined, JSON-serializable locator for one PERSISTENT working
+ * copy. TypeGraph treats it as opaque data: it is carried inside a
+ * {@link DurableBranchDescriptor} and handed back to the strategy on reopen and
+ * destroy, never inspected. It must survive `JSON.parse(JSON.stringify(...))`
+ * unchanged. It MUST be a non-secret identifier: TypeGraph returns it to the
+ * caller. Connection strings, credentials, bearer tokens, and other secrets do
+ * not belong here; keep those in strategy-owned configuration and resolve this
+ * locator there. TypeGraph deliberately omits it from cleanup error details.
+ */
+type DurableStoreDescriptor = JsonValue;
+/**
+ * The write-access guarantee a strategy acquired for one opened working copy.
+ *
+ * `engine-fenced` means the database provides sound cross-client isolation and
+ * change fencing for the full Store planning/apply access pattern, across every
+ * connection and process that could mutate the working copy.
+ * `exclusive` means the host acquired an allocation-wide writer lease before
+ * returning. That lease MUST exclude every other process and backend instance,
+ * not merely serialize calls through one in-memory queue. TypeGraph releases it
+ * after the Store backend closes; a failed release is retried by the next
+ * `GraphBranch.close()` call.
+ *
+ * A backend that provides only `caller-serialized` access MUST use `exclusive`:
+ * each backend instance owns a different in-process queue, so that declaration
+ * alone does not serialize two durable reopen handles or two processes.
+ */
+type DurableWorkingCopyAccess = Readonly<{
+    kind: "engine-fenced";
+}> | Readonly<{
+    kind: "exclusive";
+    leaseId: string;
+    release: () => Promise<void>;
+}>;
+/** Why an authoritative native merge attempt could not safely run. */
+type NativeDurableMergeUnsupportedDimension = "branchOrigin" | "graphScope" | "nativeConflicts" | "planSemantics" | "targetFence";
+/**
+ * Result of a host-native merge optimization attempt.
+ *
+ * `unsupported` proves that NO native merge SQL or host mutation ran; TypeGraph
+ * then executes the complete portable plan application. `applied` proves the
+ * strategy atomically validated every dimension named by
+ * {@link DurableWorkingCopyStrategy.merge} and applied exactly the approved
+ * plan. A refusal or uncertain/partial execution throws instead of returning
+ * `unsupported`, because falling back after a possible native write would
+ * double-apply the plan.
+ */
+type NativeDurableMergeResult = Readonly<{
+    outcome: "applied";
+    merged: MergedCounts;
+    warnings?: readonly string[] | undefined;
+}> | Readonly<{
+    outcome: "unsupported";
+    dimensions: readonly [
+        NativeDurableMergeUnsupportedDimension,
+        ...NativeDurableMergeUnsupportedDimension[]
+    ];
+}>;
+/**
+ * The complete immutable TypeGraph origin of one durable working copy — every
+ * TypeGraph-owned fork fence, with NO dependence on the descriptor: the graph
+ * id and version-blind graph-definition hash identifying the fork-time caller
+ * definition, the branch id, the `base@V` token it forked from, the at-fork
+ * schema anchor (`undefined` meaning the working copy committed no schema row —
+ * an EXPLICIT absent, so a descriptor that simply omits the field still
+ * disagrees with a host that persisted one), and the at-fork engine revision
+ * (`undefined` when the working copy resolved no lineage).
+ *
+ * `graphId` and `definitionHash` are REQUIRED and carry the definition identity
+ * even when `schemaAnchor` is absent: an unmanaged working copy still has to
+ * reject relabeling and same-id divergent definitions. The host persists this
+ * at seal time and attests it at reopen/destroy; it is the reference every
+ * descriptor fence is compared against.
+ */
+type DurableBranchOrigin = Readonly<{
+    graphId: string;
+    definitionHash: string;
+    branchId: BranchId;
+    base: BaseVersion;
+    schemaAnchor: Readonly<{
+        version: number;
+        hash: string;
+    }> | undefined;
+    forkRevision: EngineRevision | undefined;
+}>;
+/**
+ * The durable envelope for a branch: the TypeGraph-owned fences a reopen
+ * re-validates plus the strategy's opaque store locator.
+ *
+ * `kind`/`version` identify the strategy's descriptor FORMAT. `graphId` and
+ * `definitionHash` bind the descriptor to one fork-time graph definition, and
+ * `branchId` to one working copy. `base`, `schemaAnchor` and `forkRevision` are
+ * the same at-fork fences a live {@link GraphBranch} carries, captured when the
+ * branch was created.
+ *
+ * The fences are untrusted on reopen — see the module doc's tamper model.
+ * `schemaAnchor` is PRESENT with value `undefined` when the working copy
+ * committed no schema row (an unmanaged store), mirroring `branch()`'s own
+ * representation; JSON storage drops the key, and the host's own attestation
+ * restores the distinction on reopen.
+ */
+type DurableBranchDescriptor<TStoreDescriptor extends DurableStoreDescriptor = DurableStoreDescriptor> = Readonly<{
+    /** Stable strategy type tag; must equal the reopening strategy's `type`. */
+    kind: string;
+    /** Strategy descriptor format version; must equal the strategy's `version`. */
+    version: number;
+    /** The graph id the working copy belongs to. */
+    graphId: string;
+    /**
+     * The version-blind graph-definition hash of the caller's fork-time
+     * definition. Attested by the host, so it fences a same-id divergent
+     * definition even for an unmanaged working copy with no `schemaAnchor`.
+     */
+    definitionHash: string;
+    /** The TypeGraph branch id the working copy is identified by. */
+    branchId: BranchId;
+    /** The immutable `base@V` token the working copy forked from. */
+    base: BaseVersion;
+    /** The strategy's opaque, JSON-serializable locator for the working copy. */
+    store: TStoreDescriptor;
+    /** The at-fork committed schema `(version, hash)`; `undefined` when unmanaged. */
+    schemaAnchor?: Readonly<{
+        version: number;
+        hash: string;
+    }> | undefined;
+    /** The at-fork engine revision, when the working copy resolves `lineage`. */
+    forkRevision?: EngineRevision | undefined;
+}>;
+/**
+ * The host-owned half of a durable working copy: how a persistent working copy
+ * is allocated, sealed, reconnected to, and explicitly destroyed.
+ *
+ * The create -> seal/abort protocol has explicit ownership:
+ *
+ *   1. `create` allocates the persistent working copy and returns a mutable
+ *      {@link Store} over it plus the opaque locator. Once `create` resolves,
+ *      TypeGraph owns the allocation and the returned store.
+ *   2. TypeGraph captures the fork state off the store and calls `seal` with
+ *      the complete {@link DurableBranchOrigin}. The host MUST persist that
+ *      origin durably before `seal` resolves — it is what later attestations
+ *      compare a descriptor against.
+ *   3. If capturing OR sealing fails, TypeGraph calls `abort`: the host releases
+ *      the just-created allocation (deleting it) so no orphan survives. `abort`
+ *      is only ever called on an allocation this same `create` produced, so it
+ *      need not verify identity; it MUST tolerate a partially-sealed allocation.
+ *      An `abort` failure does NOT mask the original capture/seal failure:
+ *      TypeGraph returns a {@link BranchError} preserving that original failure
+ *      as its `cause` and reports `details.allocationAborted: false`. The opaque
+ *      locator and raw cleanup error are deliberately NOT copied into error
+ *      details, where application logging could disclose host credentials or
+ *      other strategy-private data. Operator tooling can use the safe TypeGraph
+ *      branch id supplied to `create` to identify the orphan.
+ *
+ * `reopen` reconnects to an EXISTING working copy identified by `descriptor`
+ * without cloning, and returns the complete origin the host PERSISTED for that
+ * locator. TypeGraph refuses when any descriptor fence disagrees with that
+ * attested origin. A reopen failure (missing or deleted store, unreachable
+ * host) throws; the strategy must not leave an opened backend behind when it
+ * throws.
+ *
+ * `destroy` is the ONLY operation that may delete or archive the persistent
+ * working copy. It receives the locator AND the caller's expected origin and
+ * MUST verify, atomically with respect to its own persistence, that the origin
+ * stored for that locator equals `expectedOrigin` before deleting — otherwise a
+ * descriptor whose locator was swapped for another working copy's would destroy
+ * the wrong allocation. A mismatch refuses without deleting. Closing the
+ * returned branch's `close()` releases just the connection and must leave the
+ * working copy reopenable.
+ */
+type DurableWorkingCopyStrategy<G extends GraphDef, TStoreDescriptor extends DurableStoreDescriptor = DurableStoreDescriptor> = Readonly<{
+    type: string;
+    version: number;
+    create: (baseStore: Store<G>, base: BaseVersion, branchId: BranchId) => Promise<Readonly<{
+        store: Store<G>;
+        descriptor: TStoreDescriptor;
+        access: DurableWorkingCopyAccess;
+    }>>;
+    seal: (descriptor: TStoreDescriptor, origin: DurableBranchOrigin) => Promise<void>;
+    abort: (descriptor: TStoreDescriptor) => Promise<void>;
+    reopen: (graph: G, descriptor: TStoreDescriptor) => Promise<Readonly<{
+        store: Store<G>;
+        origin: DurableBranchOrigin;
+        access: DurableWorkingCopyAccess;
+    }>>;
+    destroy: (descriptor: TStoreDescriptor, expectedOrigin: DurableBranchOrigin) => Promise<void>;
+    /**
+     * Optional authoritative host-native merge optimization.
+     *
+     * Before returning `applied`, the strategy MUST, atomically with the native
+     * merge operation:
+     *
+     * 1. attest `expectedOrigin` against the same allocation `branch.store` is
+     *    connected to;
+     * 2. validate `plan.target` on the exact target branch/session the host will
+     *    merge into;
+     * 3. prove the host-native diff contains exactly `plan.writes`, including all
+     *    TypeGraph sidecars and no rows belonging to another graph or application;
+     * 4. prove the plan needs no canonicalization, repointing, identity, callback,
+     *    provenance, or other semantic work the native merge would bypass; and
+     * 5. report the actual applied counts.
+     *
+     * A whole-database merge primitive therefore qualifies only for an allocation
+     * whose complete physical diff is owned by this graph and is byte-for-byte
+     * equivalent to the approved TypeGraph plan. If any dimension cannot be
+     * proven, return `unsupported` BEFORE executing host SQL; TypeGraph will apply
+     * the plan through its portable transaction path.
+     */
+    merge?: ((args: Readonly<{
+        target: Store<G>;
+        branch: GraphBranch<G>;
+        descriptor: TStoreDescriptor;
+        expectedOrigin: DurableBranchOrigin;
+        plan: MergePlanArtifactV1;
+    }>) => Promise<NativeDurableMergeResult>) | undefined;
+}>;
+/**
+ * A normal {@link GraphBranch} paired with the serializable descriptor that
+ * lets a later process reopen the SAME working copy. `branch` behaves exactly
+ * like a `branch()` result — plan/merge APIs and `close()` are unchanged.
+ */
+type DurableBranch<G extends GraphDef, TStoreDescriptor extends DurableStoreDescriptor = DurableStoreDescriptor> = Readonly<{
+    branch: GraphBranch<G>;
+    descriptor: DurableBranchDescriptor<TStoreDescriptor>;
+}>;
+/**
+ * Creates a durable working-copy branch of `baseStore`.
+ *
+ * Stamps the `base@V` token off the base, mints (or accepts) a {@link BranchId},
+ * delegates materialization to `strategy.create`, captures the graph id and
+ * version-blind definition hash, the at-fork schema anchor, and the engine
+ * revision, then SEALS the complete origin into the host before returning the
+ * normal {@link GraphBranch} together with its JSON-serializable
+ * {@link DurableBranchDescriptor}.
+ *
+ * Returns a {@link Result}; any failure is wrapped in a {@link BranchError}.
+ * Once `strategy.create` resolves, the working copy's store and persistent
+ * allocation belong to this function: a capture or seal failure closes the
+ * store and calls `strategy.abort`, so this never returns an unrecoverable
+ * success and never leaves an orphan.
+ *
+ * @param baseStore - The store to fork. Remains untouched.
+ * @param strategy - The durable working-copy strategy owning the host mechanics.
+ * @param options - Optional `{ id }` to set an explicit branch id.
+ */
+declare function branchDurable<G extends GraphDef, TStoreDescriptor extends DurableStoreDescriptor = DurableStoreDescriptor>(baseStore: Store<G>, strategy: DurableWorkingCopyStrategy<G, TStoreDescriptor>, options?: BranchOptions): Promise<Result<DurableBranch<G, TStoreDescriptor>, BranchError>>;
+/**
+ * Reconnects to an existing durable working copy and reconstructs the normal
+ * {@link GraphBranch} for it.
+ *
+ * Validates, in order: descriptor shape/type/version, graph id agreement,
+ * strategy reconnect, store graph id, and — the load-bearing step — every
+ * descriptor fence against the complete origin the host attests. A tampered
+ * `graphId`/`definitionHash`/`branchId`/`base`/`schemaAnchor`/`forkRevision`,
+ * including a DELETED `schemaAnchor`, is refused here; the host's persisted
+ * record is the reference, never the descriptor. Finally the caller's graph
+ * definition must hash to the attested fork-time definition AND agree on graph
+ * id (a different graph definition, even one reusing the graph id, is not the
+ * branch that was forked). Because the definition identity is attested
+ * independently of `schemaAnchor`, this holds for an unmanaged working copy
+ * with no committed schema row.
+ *
+ * The working copy's CURRENT committed schema is deliberately NOT compared to
+ * the anchor: a branch may evolve its schema after forking and must remain
+ * reopenable — the anchor is immutable fork metadata, not current schema.
+ *
+ * Every refusal is a typed {@link BranchError}, and any backend the strategy
+ * opened is closed before the refusal is returned. The persistent working copy
+ * is NEVER deleted here.
+ *
+ * @param graph - The graph definition the working copy was built with.
+ * @param descriptor - The serialized descriptor returned by {@link branchDurable}.
+ * @param strategy - The SAME strategy that produced `descriptor`.
+ */
+declare function reopenDurableBranch<G extends GraphDef, TStoreDescriptor extends DurableStoreDescriptor = DurableStoreDescriptor>(graph: G, descriptor: DurableBranchDescriptor<TStoreDescriptor>, strategy: DurableWorkingCopyStrategy<G, TStoreDescriptor>): Promise<Result<GraphBranch<G>, BranchError>>;
+/**
+ * Explicitly destroys (deletes or archives) the persistent working copy the
+ * descriptor names. This is the ONLY operation that may do so; closing a
+ * reopened branch's `close()` never reaches here.
+ *
+ * The complete descriptor origin is passed to the strategy alongside the
+ * locator and MUST be verified against the host's persisted origin before
+ * deletion, so a descriptor whose locator was swapped for another working
+ * copy's cannot destroy the wrong allocation.
+ *
+ * Returns a {@link Result}: a malformed/wrong-strategy descriptor or a strategy
+ * failure (including an identity mismatch) is a typed {@link BranchError}. After
+ * a successful destroy, reopening the same descriptor fails.
+ */
+declare function destroyDurableBranch<G extends GraphDef, TStoreDescriptor extends DurableStoreDescriptor = DurableStoreDescriptor>(descriptor: DurableBranchDescriptor<TStoreDescriptor>, strategy: DurableWorkingCopyStrategy<G, TStoreDescriptor>): Promise<Result<void, BranchError>>;
+
+/**
+ * Applies an approved merge plan through an optional host-native merge command,
+ * with the ordinary portable applier as the complete fallback.
+ *
+ * The native command is an optimization attempt, never a second source of merge
+ * semantics. TypeGraph validates the serialized plan and durable envelope first.
+ * The strategy may return `applied` only after atomically proving and honoring
+ * every dimension in `DurableWorkingCopyStrategy.merge`; `unsupported` means it
+ * executed no host mutation, so the full portable plan is safe to run.
+ */
+
+/** Arguments for {@link applyDurableMergePlan}. */
+type ApplyDurableMergePlanArgs<G extends GraphDef, TStoreDescriptor extends DurableStoreDescriptor = DurableStoreDescriptor> = Readonly<{
+    target: Store<G>;
+    branch: GraphBranch<G>;
+    descriptor: DurableBranchDescriptor<TStoreDescriptor>;
+    strategy: DurableWorkingCopyStrategy<G, TStoreDescriptor>;
+    plan: MergePlanArtifact;
+    options?: MergePlanApplyOptions<NoInfer<G>> | undefined;
+}>;
+/**
+ * Applies an approved durable-branch plan, preferring a proven-equivalent
+ * host-native merge and otherwise using {@link applyMergePlan} unchanged.
+ *
+ * Native merge is deliberately skipped when callbacks or persisted provenance
+ * are requested. Those dimensions belong to TypeGraph's transaction and
+ * sidecar owners; a raw database branch merge cannot silently drop them.
+ */
+declare function applyDurableMergePlan<G extends GraphDef, TStoreDescriptor extends DurableStoreDescriptor = DurableStoreDescriptor>(args: ApplyDurableMergePlanArgs<G, TStoreDescriptor>): Promise<Result<MergeReport<G>, MergeError>>;
+
 /**
  * Forks an isolated branch from an evolution plan's resulting graph, before
  * the caller opens its schema-write transaction. The original Store remains
@@ -2241,4 +2623,4 @@ type KeylessConfig = Readonly<{
     sortFields: readonly string[];
 }>;
 
-export { 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 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 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, applyMergePlan, applyMergePlanInTransaction, asBaseVersion, asBranchId, branch, branchForEvolution, captureCandidateWriteSetTarget, captureCandidateWriteSetTargetForEvolution, cloneWorkingCopyStrategy, computeBaseVersion, forkedWorkingCopyStrategy, ingestionBranch, merge, mergeIncremental, normalizeMergeOptions, openProvenanceStore, persistProvenanceRecords, planCandidateWriteSet, planCandidateWriteSetForEvolution, planCandidateWriteSetReview, planMerge, planMergeForEvolution, planMergeIncremental, provenanceGraphId, readProvenance, 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, 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 };