arborkit 1.0.0

package/dist/delta.d.ts

@@ -0,0 +1,55 @@
+import { ArtifactTree, TreeDeps } from './artifact-tree.js';
+import { MutationEvent, EventLog } from './event-log.js';
+import { Mutator } from './mutator.js';
+import { VectorIndexPort } from './vector-index-port.js';
+import { DeltaStoragePort } from './delta-storage.js';
+import './types.js';
+import './ids.js';
+import './clock.js';
+import './decompose.js';
+import './addressing.js';
+import './errors.js';
+import './storage.js';
+
+/**
+ * Re-apply ONE recorded event FORWARD onto a live tree via the `Mutator`, addressed by
+ * the event's stable path(s). The inverse of replay's `reverseApplyValue`: set→`after`,
+ * insert→insert `after`, remove→remove, move→to. Goes through the Mutator so
+ * decomposition, typing (via `e.nodeType`), and the index hooks run exactly as in normal
+ * operation. Node ids for touched subtrees are regenerated; replay/revert are path-addressed and
+ * unaffected, but id-addressed views (e.g. toolset `history`, which filters by targetId)
+ * may not see a regenerated node's pre-restore history. Malformed/pre-M7 events (missing
+ * paths) are skipped.
+ */
+declare function applyEventForward(mutator: Mutator, e: MutationEvent): void;
+/** Forward-apply a sequence of events, in order. */
+declare function replayForward(mutator: Mutator, events: readonly MutationEvent[]): void;
+/**
+ * Append every event newer than `sinceSeq` to the journal (the cheap, common save).
+ * Returns the new high-water seq to pass next time. No-op if nothing is new.
+ * Throws if events in `[sinceSeq, baseSeq)` were compacted away before being journaled
+ * (that history is unrecoverable) — compact only right before `persistCheckpoint`.
+ */
+declare function persistDelta(store: DeltaStoragePort, log: EventLog, sinceSeq: number): Promise<number>;
+/**
+ * Write a full checkpoint (replacing the prior one and clearing the journal) and return
+ * its high-water seq. Pair with M12 `log.compactTo(...)` BEFORE calling to keep the
+ * checkpoint's embedded event window small.
+ */
+declare function persistCheckpoint(store: DeltaStoragePort, tree: ArtifactTree, log: EventLog, vectors: VectorIndexPort): Promise<number>;
+/**
+ * Restore a tree + log from a checkpoint plus its journaled deltas. Returns null if no
+ * checkpoint has been written yet. Forward-replays the journal through a `Mutator` so node
+ * TYPES are preserved (via each event's `nodeType`) and UNCHANGED nodes keep their ids and
+ * checkpoint vectors; touched nodes are re-decomposed and marked `embedding.state: "stale"`
+ * for the consumer's `SemanticIndex` reindex, and removed/orphaned nodes' vectors are
+ * dropped. `vectors` should be a fresh index (the checkpoint's vectors are upserted into it).
+ * Restore must use the same `decompose` decision as the original run (journal-touched nodes
+ * are re-decomposed); replay does not re-validate.
+ */
+declare function restoreFromDelta(store: DeltaStoragePort, deps: TreeDeps, vectors: VectorIndexPort): Promise<{
+    tree: ArtifactTree;
+    log: EventLog;
+} | null>;
+
+export { applyEventForward, persistCheckpoint, persistDelta, replayForward, restoreFromDelta };