@loomwork/ui-lineage 0.0.0-stage → 0.1.1

package/dist/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAA2B,MAAM,mBAAmB,CAAC;AACvE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAmBxB,eAAO,MAAM,mBAAmB,wBAAwB,CAAC;AACzD,eAAO,MAAM,mBAAmB,wBAAwB,CAAC;AACzD,eAAO,MAAM,mBAAmB,wBAAwB,CAAC;AACzD,eAAO,MAAM,mBAAmB,wBAAwB,CAAC;AAEzD,MAAM,MAAM,gBAAgB,GACxB,OAAO,mBAAmB,GAC1B,OAAO,mBAAmB,GAC1B,OAAO,mBAAmB,GAC1B,OAAO,mBAAmB,CAAC;AAoB/B,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAG1B;;;;;OAKG;;IAEH;;;;;OAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEH,CAAC;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA4C,CAAC;AACzE,eAAO,MAAM,eAAe;;;;;;;;;;;IAG1B,kGAAkG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAElG,CAAC;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK1B,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAC9D,MAAM,MAAM,YAAY,GAAG,WAAW,CAAC,eAAe,CAAC,cAAc,CAAC,CAAC,CAAC;AACxE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAC9D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAC9D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAnC1B;;;;;WAKG;;QAEH;;;;;WAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAOH,kGAAkG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqB1F,CAAC;AAEX,eAAO,MAAM,kBAAkB,GAAI,GAAG,MAAM,KAAG,CAAC,IAAI,gBACjB,CAAC;AAEpC;;;;;;;;;GASG;AACH,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,MAAM,CAAC,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC,CAKzF,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE;IACnD,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAAC;CACtE,GAAG,IAAI,CAGP"}

package/dist/events.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LINEAGE_SENSITIVE_PATHS = exports.isLineageEventType = exports.PAYLOAD_SCHEMAS = exports.PromotedPayload = exports.BranchedPayload = exports.RevertedPayload = exports.ComposedPayload = exports.EXPERIENCE_PROMOTED = exports.EXPERIENCE_BRANCHED = exports.EXPERIENCE_REVERTED = exports.EXPERIENCE_COMPOSED = void 0;
+exports.registerLineageSensitivePaths = registerLineageSensitivePaths;
+const ui_core_1 = require("@loomwork/ui-core");
+const zod_1 = require("zod");
+// ── The lineage event protocol ────────────────────────────────────────────────
+// A lineage is the append-only log of ONE experience's versions. Every entry is an event whose
+// type names what happened and whose payload carries the content address (`ref`) of the stored
+// artifact plus enough to VERIFY it without trusting the blob:
+//
+//   EXPERIENCE_COMPOSED  a version produced by ops folded onto its parent (or the genesis, ops [])
+//   EXPERIENCE_REVERTED  a version that restores an older artifact's content as a NEW version
+//   EXPERIENCE_BRANCHED  the first version of a NEW lineage forked from a version of another
+//   EXPERIENCE_PROMOTED  the app chose to SHOW a version (head is "latest", promoted is "shown")
+//
+// `EXPERIENCE_COMPOSED` is the same name and `{ ref, parents, ops }` core's `log.ts` declared as a
+// userspace convention; here it gains a producer, a consumer and a validator. The extra fields
+// (`experienceId`, `versionHash`, `by`) are additive. `EXPERIENCE_PROMOTED` is redeclared (not
+// imported) because importing it from `@loomwork/ui-planner` would put the planner's whole graph —
+// hydration, the sandbox — into a server-side store package; `lineage.test.ts` asserts the two
+// spellings never drift.
+exports.EXPERIENCE_COMPOSED = "EXPERIENCE_COMPOSED";
+exports.EXPERIENCE_REVERTED = "EXPERIENCE_REVERTED";
+exports.EXPERIENCE_BRANCHED = "EXPERIENCE_BRANCHED";
+exports.EXPERIENCE_PROMOTED = "EXPERIENCE_PROMOTED";
+const ContentRefSchema = zod_1.z.object({ __loomContent: zod_1.z.string().min(1) });
+const Hash = zod_1.z.string().min(1);
+const RecordedOperationSchema = zod_1.z.object({
+    op: ui_core_1.Operation,
+    baseVersion: zod_1.z.string().optional(),
+    by: ui_core_1.Provenance,
+    at: zod_1.z.string(),
+});
+const Common = {
+    experienceId: zod_1.z.string().min(1),
+    versionHash: Hash,
+    ref: ContentRefSchema,
+    parents: zod_1.z.array(Hash),
+    by: ui_core_1.Provenance,
+};
+exports.ComposedPayload = zod_1.z.object({
+    ...Common,
+    ops: zod_1.z.array(RecordedOperationSchema),
+    /**
+     * What the author said about the change (U7): UNTRUSTED text (a planner's model text), bounded
+     * and stripped by `boundSummary` on the way in AND on the way out of the fold, since the log is
+     * untrusted input. Optional, so every version written before it replays unchanged; it is not in
+     * the content address (nothing here is).
+     */
+    summary: zod_1.z.string().optional(),
+    /**
+     * The strictest class of everything the author READ to write `summary` (the experience, tool
+     * samples, caller context), stamped by the host at compose. A summary is judged against it (and
+     * against the version's own class floor) before a viewer is shown it. Recorded on the event, not
+     * in the content address. Absent = unknown, and the floor alone gates the summary.
+     */
+    summaryClass: ui_core_1.Sensitivity.optional(),
+});
+exports.RevertedPayload = zod_1.z.object({ ...Common, revertedTo: Hash });
+exports.BranchedPayload = zod_1.z.object({
+    ...Common,
+    from: zod_1.z.object({ experienceId: zod_1.z.string().min(1), versionHash: Hash }),
+    /** The version of the SOURCE line whose sticky classes were carried in (its head at the fork). */
+    carriedFrom: Hash,
+});
+exports.PromotedPayload = zod_1.z.object({
+    ref: ContentRefSchema,
+    experienceId: zod_1.z.string().min(1),
+    versionHash: Hash,
+    by: ui_core_1.Provenance,
+});
+exports.PAYLOAD_SCHEMAS = {
+    [exports.EXPERIENCE_COMPOSED]: exports.ComposedPayload,
+    [exports.EXPERIENCE_REVERTED]: exports.RevertedPayload,
+    [exports.EXPERIENCE_BRANCHED]: exports.BranchedPayload,
+    [exports.EXPERIENCE_PROMOTED]: exports.PromotedPayload,
+};
+const isLineageEventType = (t) => Object.hasOwn(exports.PAYLOAD_SCHEMAS, t);
+exports.isLineageEventType = isLineageEventType;
+/**
+ * The payload paths that carry host or model TEXT, per event type: the op props and labels, the
+ * author's `summary` and the `by` provenance (a user's own words and ids). These are what a host
+ * seals under its owner's key so erasing the owner makes the line unreadable
+ * (`registerLineageSensitivePaths`). Everything else on an event is an identifier (`experienceId`,
+ * `versionHash`, `ref`, `parents`, `from`, `carriedFrom`, `revertedTo`) or a class
+ * (`summaryClass`), and stays plain so the log's structure survives the key.
+ *
+ * `ops` is one path: it covers every nested op's `by`, props, labels and prompt text.
+ */
+exports.LINEAGE_SENSITIVE_PATHS = {
+    [exports.EXPERIENCE_COMPOSED]: ["ops", "summary", "by"],
+    [exports.EXPERIENCE_REVERTED]: ["by"],
+    [exports.EXPERIENCE_BRANCHED]: ["by"],
+    [exports.EXPERIENCE_PROMOTED]: ["by"],
+};
+/**
+ * Register {@link LINEAGE_SENSITIVE_PATHS} on a crypto event store (`EncryptingEventStore`'s
+ * `registerSensitive`). Call it once at composition, before the first lineage write: what was
+ * written before stays plaintext.
+ */
+function registerLineageSensitivePaths(store) {
+    for (const [type, paths] of Object.entries(exports.LINEAGE_SENSITIVE_PATHS))
+        store.registerSensitive(type, paths);
+}
+//# sourceMappingURL=events.js.map

package/dist/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+export { LineErasedError, LineUnreadableError, Lineage, classifyLineFailure } from "./lineage";
+export type { LineBlockedError, PinsExtra } from "./lineage";
+export type { Committed, HeadMoved, LineageOptions, LineageResult, PromotedMoved, Refusal, Refused, } from "./lineage";
+export { branchArtifact, revertArtifact } from "./derive";
+export type { Authored } from "./derive";
+export { BranchedPayload, ComposedPayload, EXPERIENCE_BRANCHED, EXPERIENCE_COMPOSED, EXPERIENCE_PROMOTED, EXPERIENCE_REVERTED, LINEAGE_SENSITIVE_PATHS, PromotedPayload, RevertedPayload, registerLineageSensitivePaths, } from "./events";
+export type { LineageEventType, SummaryClass } from "./events";
+export { foldLineage } from "./state";
+export type { Fold, LineageState, VersionKind, VersionRecord } from "./state";
+export { InMemoryLineageStore, LINEAGE_STREAM_PREFIX, LINEAGE_WORKFLOW_ID, LOOM_UI_STREAM_NAMESPACE, eventStoreLineageStore, } from "./store";
+export type { AppendOutcome, LineageRecord, LineageStore, PrefixedLineageStore, StoredLineageRecord, } from "./store";
+export { checkLineageStoreConformance } from "./conformance";
+export { DEFAULT_MAX_SEEN_VIEWS, DEFAULT_MAX_SKEW_MS, MAX_SEEN_READ, SEEN_STREAM_PREFIX, SEEN_WORKFLOW_ID, SeenLog, VIEWER_ERASED, VIEWS_RETAINED, VIEW_RECORDED, ViewRecordPayload, seenStoreOptions, seenStreamKey, } from "./seen";
+export type { SeenLogOptions, SeenRefusal, SeenResult, SeenRetention, SeenUnreadable, SeenView, } from "./seen";
+export { InMemorySeenKeyStore, SEALED_REF_BLOCK, checkSeenKeyStoreConformance, seenKeySubject, } from "./seenCrypto";
+export type { SeenKeyStore } from "./seenCrypto";
+export { collectSeenGarbage, collectSeenRoots } from "./seenGc";
+export type { SeenGcOptions, SeenGcReport, SeenGcResult } from "./seenGc";
+export { DEFAULT_KEEP_LAST, retainedVersions, validateRetentionPolicy } from "./retention";
+export type { Retained, RetentionPolicy } from "./retention";
+export { rootsFor } from "./rootsFor";
+export type { RootsForOptions } from "./rootsFor";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,mBAAmB,EAAE,OAAO,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAC/F,YAAY,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAC7D,YAAY,EACV,SAAS,EACT,SAAS,EACT,cAAc,EACd,aAAa,EACb,aAAa,EACb,OAAO,EACP,OAAO,GACR,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1D,YAAY,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EACL,eAAe,EACf,eAAe,EACf,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACnB,uBAAuB,EACvB,eAAe,EACf,eAAe,EACf,6BAA6B,GAC9B,MAAM,UAAU,CAAC;AAClB,YAAY,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AACtC,YAAY,EAAE,IAAI,EAAE,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAC9E,OAAO,EACL,oBAAoB,EACpB,qBAAqB,EACrB,mBAAmB,EACnB,wBAAwB,EACxB,sBAAsB,GACvB,MAAM,SAAS,CAAC;AACjB,YAAY,EACV,aAAa,EACb,aAAa,EACb,YAAY,EACZ,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,4BAA4B,EAAE,MAAM,eAAe,CAAC;AAC7D,OAAO,EACL,sBAAsB,EACtB,mBAAmB,EACnB,aAAa,EACb,kBAAkB,EAClB,gBAAgB,EAChB,OAAO,EACP,aAAa,EACb,cAAc,EACd,aAAa,EACb,iBAAiB,EACjB,gBAAgB,EAChB,aAAa,GACd,MAAM,QAAQ,CAAC;AAChB,YAAY,EACV,cAAc,EACd,WAAW,EACX,UAAU,EACV,aAAa,EACb,cAAc,EACd,QAAQ,GACT,MAAM,QAAQ,CAAC;AAChB,OAAO,EACL,oBAAoB,EACpB,gBAAgB,EAChB,4BAA4B,EAC5B,cAAc,GACf,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAChE,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE1E,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAC3F,YAAY,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC7D,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,YAAY,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rootsFor = exports.validateRetentionPolicy = exports.retainedVersions = exports.DEFAULT_KEEP_LAST = exports.collectSeenRoots = exports.collectSeenGarbage = exports.seenKeySubject = exports.checkSeenKeyStoreConformance = exports.SEALED_REF_BLOCK = exports.InMemorySeenKeyStore = exports.seenStreamKey = exports.seenStoreOptions = exports.ViewRecordPayload = exports.VIEW_RECORDED = exports.VIEWS_RETAINED = exports.VIEWER_ERASED = exports.SeenLog = exports.SEEN_WORKFLOW_ID = exports.SEEN_STREAM_PREFIX = exports.MAX_SEEN_READ = exports.DEFAULT_MAX_SKEW_MS = exports.DEFAULT_MAX_SEEN_VIEWS = exports.checkLineageStoreConformance = exports.eventStoreLineageStore = exports.LOOM_UI_STREAM_NAMESPACE = exports.LINEAGE_WORKFLOW_ID = exports.LINEAGE_STREAM_PREFIX = exports.InMemoryLineageStore = exports.foldLineage = exports.registerLineageSensitivePaths = exports.RevertedPayload = exports.PromotedPayload = exports.LINEAGE_SENSITIVE_PATHS = exports.EXPERIENCE_REVERTED = exports.EXPERIENCE_PROMOTED = exports.EXPERIENCE_COMPOSED = exports.EXPERIENCE_BRANCHED = exports.ComposedPayload = exports.BranchedPayload = exports.revertArtifact = exports.branchArtifact = exports.classifyLineFailure = exports.Lineage = exports.LineUnreadableError = exports.LineErasedError = void 0;
+var lineage_1 = require("./lineage");
+Object.defineProperty(exports, "LineErasedError", { enumerable: true, get: function () { return lineage_1.LineErasedError; } });
+Object.defineProperty(exports, "LineUnreadableError", { enumerable: true, get: function () { return lineage_1.LineUnreadableError; } });
+Object.defineProperty(exports, "Lineage", { enumerable: true, get: function () { return lineage_1.Lineage; } });
+Object.defineProperty(exports, "classifyLineFailure", { enumerable: true, get: function () { return lineage_1.classifyLineFailure; } });
+var derive_1 = require("./derive");
+Object.defineProperty(exports, "branchArtifact", { enumerable: true, get: function () { return derive_1.branchArtifact; } });
+Object.defineProperty(exports, "revertArtifact", { enumerable: true, get: function () { return derive_1.revertArtifact; } });
+var events_1 = require("./events");
+Object.defineProperty(exports, "BranchedPayload", { enumerable: true, get: function () { return events_1.BranchedPayload; } });
+Object.defineProperty(exports, "ComposedPayload", { enumerable: true, get: function () { return events_1.ComposedPayload; } });
+Object.defineProperty(exports, "EXPERIENCE_BRANCHED", { enumerable: true, get: function () { return events_1.EXPERIENCE_BRANCHED; } });
+Object.defineProperty(exports, "EXPERIENCE_COMPOSED", { enumerable: true, get: function () { return events_1.EXPERIENCE_COMPOSED; } });
+Object.defineProperty(exports, "EXPERIENCE_PROMOTED", { enumerable: true, get: function () { return events_1.EXPERIENCE_PROMOTED; } });
+Object.defineProperty(exports, "EXPERIENCE_REVERTED", { enumerable: true, get: function () { return events_1.EXPERIENCE_REVERTED; } });
+Object.defineProperty(exports, "LINEAGE_SENSITIVE_PATHS", { enumerable: true, get: function () { return events_1.LINEAGE_SENSITIVE_PATHS; } });
+Object.defineProperty(exports, "PromotedPayload", { enumerable: true, get: function () { return events_1.PromotedPayload; } });
+Object.defineProperty(exports, "RevertedPayload", { enumerable: true, get: function () { return events_1.RevertedPayload; } });
+Object.defineProperty(exports, "registerLineageSensitivePaths", { enumerable: true, get: function () { return events_1.registerLineageSensitivePaths; } });
+var state_1 = require("./state");
+Object.defineProperty(exports, "foldLineage", { enumerable: true, get: function () { return state_1.foldLineage; } });
+var store_1 = require("./store");
+Object.defineProperty(exports, "InMemoryLineageStore", { enumerable: true, get: function () { return store_1.InMemoryLineageStore; } });
+Object.defineProperty(exports, "LINEAGE_STREAM_PREFIX", { enumerable: true, get: function () { return store_1.LINEAGE_STREAM_PREFIX; } });
+Object.defineProperty(exports, "LINEAGE_WORKFLOW_ID", { enumerable: true, get: function () { return store_1.LINEAGE_WORKFLOW_ID; } });
+Object.defineProperty(exports, "LOOM_UI_STREAM_NAMESPACE", { enumerable: true, get: function () { return store_1.LOOM_UI_STREAM_NAMESPACE; } });
+Object.defineProperty(exports, "eventStoreLineageStore", { enumerable: true, get: function () { return store_1.eventStoreLineageStore; } });
+var conformance_1 = require("./conformance");
+Object.defineProperty(exports, "checkLineageStoreConformance", { enumerable: true, get: function () { return conformance_1.checkLineageStoreConformance; } });
+var seen_1 = require("./seen");
+Object.defineProperty(exports, "DEFAULT_MAX_SEEN_VIEWS", { enumerable: true, get: function () { return seen_1.DEFAULT_MAX_SEEN_VIEWS; } });
+Object.defineProperty(exports, "DEFAULT_MAX_SKEW_MS", { enumerable: true, get: function () { return seen_1.DEFAULT_MAX_SKEW_MS; } });
+Object.defineProperty(exports, "MAX_SEEN_READ", { enumerable: true, get: function () { return seen_1.MAX_SEEN_READ; } });
+Object.defineProperty(exports, "SEEN_STREAM_PREFIX", { enumerable: true, get: function () { return seen_1.SEEN_STREAM_PREFIX; } });
+Object.defineProperty(exports, "SEEN_WORKFLOW_ID", { enumerable: true, get: function () { return seen_1.SEEN_WORKFLOW_ID; } });
+Object.defineProperty(exports, "SeenLog", { enumerable: true, get: function () { return seen_1.SeenLog; } });
+Object.defineProperty(exports, "VIEWER_ERASED", { enumerable: true, get: function () { return seen_1.VIEWER_ERASED; } });
+Object.defineProperty(exports, "VIEWS_RETAINED", { enumerable: true, get: function () { return seen_1.VIEWS_RETAINED; } });
+Object.defineProperty(exports, "VIEW_RECORDED", { enumerable: true, get: function () { return seen_1.VIEW_RECORDED; } });
+Object.defineProperty(exports, "ViewRecordPayload", { enumerable: true, get: function () { return seen_1.ViewRecordPayload; } });
+Object.defineProperty(exports, "seenStoreOptions", { enumerable: true, get: function () { return seen_1.seenStoreOptions; } });
+Object.defineProperty(exports, "seenStreamKey", { enumerable: true, get: function () { return seen_1.seenStreamKey; } });
+var seenCrypto_1 = require("./seenCrypto");
+Object.defineProperty(exports, "InMemorySeenKeyStore", { enumerable: true, get: function () { return seenCrypto_1.InMemorySeenKeyStore; } });
+Object.defineProperty(exports, "SEALED_REF_BLOCK", { enumerable: true, get: function () { return seenCrypto_1.SEALED_REF_BLOCK; } });
+Object.defineProperty(exports, "checkSeenKeyStoreConformance", { enumerable: true, get: function () { return seenCrypto_1.checkSeenKeyStoreConformance; } });
+Object.defineProperty(exports, "seenKeySubject", { enumerable: true, get: function () { return seenCrypto_1.seenKeySubject; } });
+var seenGc_1 = require("./seenGc");
+Object.defineProperty(exports, "collectSeenGarbage", { enumerable: true, get: function () { return seenGc_1.collectSeenGarbage; } });
+Object.defineProperty(exports, "collectSeenRoots", { enumerable: true, get: function () { return seenGc_1.collectSeenRoots; } });
+var retention_1 = require("./retention");
+Object.defineProperty(exports, "DEFAULT_KEEP_LAST", { enumerable: true, get: function () { return retention_1.DEFAULT_KEEP_LAST; } });
+Object.defineProperty(exports, "retainedVersions", { enumerable: true, get: function () { return retention_1.retainedVersions; } });
+Object.defineProperty(exports, "validateRetentionPolicy", { enumerable: true, get: function () { return retention_1.validateRetentionPolicy; } });
+var rootsFor_1 = require("./rootsFor");
+Object.defineProperty(exports, "rootsFor", { enumerable: true, get: function () { return rootsFor_1.rootsFor; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,qCAA+F;AAAtF,0GAAA,eAAe,OAAA;AAAE,8GAAA,mBAAmB,OAAA;AAAE,kGAAA,OAAO,OAAA;AAAE,8GAAA,mBAAmB,OAAA;AAW3E,mCAA0D;AAAjD,wGAAA,cAAc,OAAA;AAAE,wGAAA,cAAc,OAAA;AAEvC,mCAWkB;AAVhB,yGAAA,eAAe,OAAA;AACf,yGAAA,eAAe,OAAA;AACf,6GAAA,mBAAmB,OAAA;AACnB,6GAAA,mBAAmB,OAAA;AACnB,6GAAA,mBAAmB,OAAA;AACnB,6GAAA,mBAAmB,OAAA;AACnB,iHAAA,uBAAuB,OAAA;AACvB,yGAAA,eAAe,OAAA;AACf,yGAAA,eAAe,OAAA;AACf,uHAAA,6BAA6B,OAAA;AAG/B,iCAAsC;AAA7B,oGAAA,WAAW,OAAA;AAEpB,iCAMiB;AALf,6GAAA,oBAAoB,OAAA;AACpB,8GAAA,qBAAqB,OAAA;AACrB,4GAAA,mBAAmB,OAAA;AACnB,iHAAA,wBAAwB,OAAA;AACxB,+GAAA,sBAAsB,OAAA;AASxB,6CAA6D;AAApD,2HAAA,4BAA4B,OAAA;AACrC,+BAagB;AAZd,8GAAA,sBAAsB,OAAA;AACtB,2GAAA,mBAAmB,OAAA;AACnB,qGAAA,aAAa,OAAA;AACb,0GAAA,kBAAkB,OAAA;AAClB,wGAAA,gBAAgB,OAAA;AAChB,+FAAA,OAAO,OAAA;AACP,qGAAA,aAAa,OAAA;AACb,sGAAA,cAAc,OAAA;AACd,qGAAA,aAAa,OAAA;AACb,yGAAA,iBAAiB,OAAA;AACjB,wGAAA,gBAAgB,OAAA;AAChB,qGAAA,aAAa,OAAA;AAUf,2CAKsB;AAJpB,kHAAA,oBAAoB,OAAA;AACpB,8GAAA,gBAAgB,OAAA;AAChB,0HAAA,4BAA4B,OAAA;AAC5B,4GAAA,cAAc,OAAA;AAGhB,mCAAgE;AAAvD,4GAAA,kBAAkB,OAAA;AAAE,0GAAA,gBAAgB,OAAA;AAG7C,yCAA2F;AAAlF,8GAAA,iBAAiB,OAAA;AAAE,6GAAA,gBAAgB,OAAA;AAAE,oHAAA,uBAAuB,OAAA;AAErE,uCAAsC;AAA7B,oGAAA,QAAQ,OAAA"}

package/dist/lineage.d.ts

@@ -0,0 +1,394 @@
+import type { ContentStore } from "@loomwork/plugin-content";
+import { type Audience, type DeclaredToolClasses, type Experience, type Finding, type NodeExplanation, type ProjectionCatalog, type Provenance, type ProvenanceLedger, type ReadPolicy, type RecordedOperation, type UndeclaredToolPolicy, type Viewer } from "@loomwork/ui-core";
+import { type SummaryClass } from "./events";
+import { type RetentionPolicy } from "./retention";
+import { type LineageState, type VersionRecord } from "./state";
+import { type LineageStore } from "./store";
+export type HeadMoved = {
+    readonly kind: "head-moved";
+    readonly expectedHead: string | null;
+    readonly actualHead: string | null;
+};
+export type PromotedMoved = {
+    readonly kind: "promoted-moved";
+    readonly expectedPromoted: string | null;
+    readonly actualPromoted: string | null;
+};
+export type Refused = {
+    readonly kind: "refused";
+    readonly finding: Finding;
+};
+/** Why a write did not happen. A lost race is typed (`head-moved`) and carries the winner. */
+export type Refusal = HeadMoved | PromotedMoved | Refused;
+export type LineageResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    refusal: Refusal;
+};
+export interface Committed {
+    readonly experience: Experience;
+    readonly version: VersionRecord;
+}
+export interface LineageOptions {
+    readonly events: LineageStore;
+    readonly content: ContentStore;
+    /** Clock for event times; injectable so a test (or a replaying host) is deterministic. */
+    readonly now?: () => string;
+    /**
+     * The host's read policy, bound ONCE: every read this lineage serves under a viewer (`explain`)
+     * applies it, and a `SeenLog` or `LineageChangeFeed` built over this lineage inherits it. A
+     * per-call value may only ADD to it (`mergeReadPolicy`). Absent = no policy (the experience's own
+     * classes only).
+     */
+    readonly readPolicy?: ReadPolicy;
+    /**
+     * Host hook: has this line's erasure been CONFIRMED? A read that hits a sealed line whose key is
+     * unavailable (`isKeyUnavailable`) or whose blob is shredded (`isPayloadShredded`) cannot tell an
+     * erasure from "the key is not on this node" or "the ciphertext does not open" (loom says so
+     * itself). The line is reported `line-erased` ONLY when this returns true, else `line-unreadable`.
+     * Implement it with your KeyStore: `(id) => keys.wasDestroyed(subjectOf({ executionId: stream(id) }))`.
+     * Absent = nothing is ever confirmed. A throwing hook counts as "not confirmed". Both outcomes
+     * fail closed; only a confirmed erasure is skipped by the GC root walks.
+     */
+    readonly confirmErased?: (experienceId: string) => Promise<boolean>;
+}
+/**
+ * Thrown by the reads that return plain values (`forEachContentRef`, `pins` and so `rootsFor`) when
+ * a line's key is gone AND the host confirmed the erasure (`LineageOptions.confirmErased`). Those
+ * reads SKIP a confirmed-erased line (it contributes no roots), so this reaches a caller only from a
+ * single-line read; every method that returns a `LineageResult` (or `verify`'s findings) reports the
+ * same condition as a `refused` result with code `line-erased` instead of throwing.
+ */
+export declare class LineErasedError extends Error {
+    readonly experienceId: string;
+    readonly name = "LineErasedError";
+    readonly code: "line-erased";
+    readonly confirmed: true;
+    constructor(experienceId: string, options?: {
+        readonly cause?: unknown;
+    });
+}
+/**
+ * The line's key is unavailable on this node, or its ciphertext / artifact does not open, and the
+ * erasure is NOT confirmed (no `confirmErased` hook, or it said no). Could be a destroyed key, a key
+ * this node does not hold, a tampered event, a drifted `subjectOf`, or an artifact written before an
+ * `EncryptingContentStore` was composed (`reason: "artifact-unsealed"`). Fail closed, but not an
+ * erasure: GC refuses rather than guess, and a read says so. `reason` is also the refusal's finding code.
+ */
+export declare class LineUnreadableError extends Error {
+    readonly experienceId: string;
+    readonly name = "LineUnreadableError";
+    readonly code: "line-unreadable";
+    readonly confirmed: false;
+    readonly reason: "line-unreadable" | "artifact-unsealed";
+    constructor(experienceId: string, options?: {
+        readonly cause?: unknown;
+        readonly reason?: "line-unreadable" | "artifact-unsealed";
+    });
+}
+export type LineBlockedError = LineErasedError | LineUnreadableError;
+/**
+ * Classify a read failure of one line: `undefined` when it is not an unreadable-line failure
+ * (rethrow it), else a typed error. ONE rule: `line-erased` iff the host's `confirmErased` says so;
+ * `isPayloadShredded` alone is not confirmation. An undecryptable blob is never an erasure.
+ */
+export declare function classifyLineFailure(experienceId: string, err: unknown, confirmErased?: (experienceId: string) => Promise<boolean>): Promise<LineBlockedError | undefined>;
+/** What else uses the lineage's content store, for {@link Lineage.pins}. */
+export interface PinsExtra {
+    /** Versions to retain whatever the policy says (e.g. the ones a seen log still records views of). */
+    readonly keepVersions?: Iterable<{
+        readonly experienceId: string;
+        readonly versionHash: string;
+    }>;
+    /** Addresses of other users of the same store (e.g. a seen log's sealed value blobs). */
+    readonly keepAddresses?: Iterable<string> | AsyncIterable<string>;
+    /**
+     * How many retained artifacts of ONE line are read at once, to find the refs inside their bytes.
+     * Default 8; a positive integer (anything else throws). 1 reads strictly one after another.
+     */
+    readonly concurrency?: number;
+}
+export declare class Lineage {
+    private readonly events;
+    private readonly content;
+    private readonly now;
+    private readonly policy;
+    private readonly streamPrefix;
+    private readonly workflowId;
+    private readonly confirmErased;
+    constructor(opts: LineageOptions);
+    /**
+     * The `ContentAccess` of one line's artifact blobs: the line's STREAM id (the id its events live
+     * under) and the lineage workflow id. A content store that seals by owner (`EncryptingContentStore`)
+     * resolves it through the host's `subjectOf`, the same mapping its event store applies to the
+     * stream, so one mapping covers a line's events and blobs. A plain store ignores it.
+     */
+    private accessFor;
+    /**
+     * Classify a read failure of `experienceId` with this lineage's `confirmErased` hook: a typed
+     * {@link LineErasedError} (confirmed) or {@link LineUnreadableError}, or `undefined` when `err` is
+     * not an unreadable-line failure. Readers built over this lineage (the change feed) use it.
+     */
+    block(experienceId: string, err: unknown): Promise<LineBlockedError | undefined>;
+    /** Every record of a line; an unreadable line THROWS a {@link LineBlockedError}, anything else propagates. */
+    private readLine;
+    private confirms;
+    /**
+     * A write step failed with `err`: a typed refusal when the line is (now) unreadable, else rethrow.
+     * The re-read catches a key destroyed between `state()` and the append, whose own error is untyped.
+     */
+    private failedWrite;
+    /** The read policy bound at construction (empty when none); readers built over this lineage inherit it. */
+    get readPolicy(): ReadPolicy;
+    /**
+     * Whether `other` is this lineage's own store, or may write under a stream prefix that overlaps its
+     * own (`a.startsWith(b) || b.startsWith(a)`: `x:` and `x:y:` collide). A `SeenLog` refuses such a
+     * store: a viewer's record must never share streams with the line it describes.
+     *
+     * FAIL-CLOSED: the vetted store's `streamPrefix` must be readable (the package's prefixed stores
+     * and `InMemoryLineageStore` are). A decorator that HIDES `streamPrefix` cannot be told apart from a
+     * colliding store, so it is refused: re-expose `streamPrefix` on the wrapper (copied from the inner
+     * store) if it is legitimate. The reverse is a documented limit: if THIS lineage's store is such a
+     * wrapper its prefix is assumed to be the default (`LINEAGE_STREAM_PREFIX`).
+     */
+    sharesStreamsWith(other: LineageStore): boolean;
+    /**
+     * Call `visit` with every content address any version of any line cites (artifacts, op payloads,
+     * anything stored as a content ref in an event), CONSERVATIVELY: any `__loomContent` string found
+     * anywhere in a payload counts, claim-check envelopes included. This is the lineage's half of the
+     * root set a content collector marks. One line is held in memory at a time. Throws if the store
+     * cannot enumerate its lines (`listStreams`): a collector must refuse then, never guess.
+     */
+    forEachContentRef(visit: (address: string) => void): Promise<void>;
+    /**
+     * U17 — the content addresses a collector must KEEP, as the `roots` of loom's `sweepUnpinnedContent`:
+     * for every line, the artifact of each version `policy` retains (`retainedVersions`: the newest N,
+     * the head, the promoted version, the genesis, every fork's source) plus every OTHER content ref the
+     * line's events cite (anything an op carries) plus every content ref found INSIDE a retained
+     * artifact's own bytes (a node whose props hold a media ref: the sweep does not read blobs, so
+     * nothing else would root it). The artifact ref of a version the policy does not keep is
+     * deliberately absent, so that blob becomes reclaimable.
+     *
+     * USE IT INSTEAD OF scanning the lineage's streams, never as well: a scanned stream pins every
+     * version's artifact for ever (a bare ref is load-bearing to loom's sweep), so pass the lineage's
+     * `LineageStore` to neither `eventStores` nor `snapshotStores`. Mind the consequence: a reclaimed
+     * version's event stays in the log, `get` of it reports the missing artifact, and `verify` of a line
+     * that has had versions reclaimed reports them (and the versions derived from them) until the line
+     * is verified from a retained checkpoint. Reclaim only versions nobody needs to re-open.
+     *
+     * THE ROOT SET MUST BE COMPLETE. With `reclaimOrphans: { completeScan: true }` loom erases every
+     * blob in the store that no root names. The lineage is only ONE user of its content store: pass
+     * the others through `extra` (a {@link SeenLog} sharing the store: `collectSeenRoots(log)`), and
+     * add any other lineage's `pins()` and loom's own execution scan to the same `roots`. A
+     * version a viewer's recorded view still names is kept via `extra.keepVersions`.
+     *
+     * RACES. A promote, a branch (and a seen-log record) TOUCH the artifact they newly cite
+     * (`ContentStore.touch`, SPI 1.4.0, ADR 0055 D6 amendment 2), so a sweep whose roots were computed
+     * a moment earlier still refuses to delete it. That also covers a fork made between this method's
+     * two passes. It needs a store with `touch`; loom's sweep refuses to erase through one without it.
+     *
+     * COST. Linear in the number of RETAINED, DISTINCT artifacts, and each one is read in full: the
+     * refs a version cites (media, blobs) live only inside its artifact's bytes, and neither the version
+     * event nor the store records which artifacts hold any, so there is nothing to skip on without
+     * reading. The reads are bounded, not avoided: a retention policy that keeps fewer versions reads
+     * fewer artifacts, artifacts shared by versions or forks are read once per call, and `extra.concurrency`
+     * sets how many of a line are in flight. Run it from the collector, not on a request path. (Skipping
+     * ref-free artifacts would need a "cites refs" flag stamped on the version event at write time: a
+     * lineage event-schema change, not done here.)
+     *
+     * Two passes, one line in memory at a time. Throws if the store cannot enumerate its lines, if
+     * any line fails to fold, if a retained artifact cannot be read for a reason other than being
+     * already gone, or on a malformed policy (a collector must refuse, never guess).
+     */
+    pins(policy?: RetentionPolicy, extra?: PinsExtra): AsyncGenerator<string, void, undefined>;
+    /**
+     * Tell the content store that `versionHashes` of `experienceId` were JUST re-cited (by a promote,
+     * a branch, a recorded view): `ContentStore.touch` on their artifacts, so a collector's
+     * conditional delete spares them (loom ADR 0055 D6 amendment 2). A store without `touch` is
+     * left alone (loom's sweep will not erase through one). Refuses when an artifact is already gone.
+     */
+    cite(experienceId: string, versionHashes: readonly string[]): Promise<LineageResult<void>>;
+    /** The folded state of a line (empty state for an unknown one). A malformed log is a finding. */
+    state(experienceId: string): Promise<LineageResult<LineageState>>;
+    /** The latest version's hash, or null for a line with no version. */
+    head(experienceId: string): Promise<LineageResult<string | null>>;
+    /** Every version, oldest first. */
+    versions(experienceId: string): Promise<LineageResult<readonly VersionRecord[]>>;
+    /**
+     * `from` (default the head) and its ancestors WITHIN this line, newest first, following
+     * `parents`. A branch's first version stops the walk (its parent is in another line; see
+     * `VersionRecord.from`). Iterative with a visited set: a forged cycle cannot loop it.
+     */
+    walk(experienceId: string, from?: string): Promise<LineageResult<readonly VersionRecord[]>>;
+    /** One version's artifact, hash-verified (`getExperience`). */
+    get(experienceId: string, versionHash: string): Promise<LineageResult<Experience>>;
+    /** The latest version's artifact. */
+    resolveLatest(experienceId: string): Promise<LineageResult<Experience>>;
+    /** The promoted (shown) version's artifact, or refused when nothing is promoted. */
+    resolvePromoted(experienceId: string): Promise<LineageResult<Experience>>;
+    private load;
+    /**
+     * The per-node ledger of version `versionHash` (default the head): which recorded op created and
+     * last changed each node, derived from the log alone (no artifact is read, nothing is stored).
+     * A revert has the ledger of the version it restores; a branch starts from its source version's.
+     * Bounded: a chain of reverts or branches deeper than `MAX_VERIFY_DEPTH` ends in an unknown
+     * origin rather than recursing without limit.
+     */
+    provenance(experienceId: string, versionHash?: string): Promise<LineageResult<ProvenanceLedger>>;
+    private ledgerAt;
+    /**
+     * Why is `nodeId` in version `versionHash` (default the head), FOR `viewer`? The ledger of that
+     * version read through core's `explainNode`: unknown, restricted and unreadable all answer the
+     * same bare `{ available: false }`. The creating version's summary and the request that prompted
+     * it are shown only when the viewer may see the strictest class of the viewed version, of the
+     * version that wrote them, and of what the planner read (`summaryClass`); a version that cannot be
+     * read counts as `secret`. Performs no authorization: `viewer` is the host's claim.
+     */
+    explain(experienceId: string, nodeId: string, opts?: {
+        readonly viewer?: Viewer;
+        /** The surface's audience: `"broadcast"` explains as a viewer with no clearance. */
+        readonly audience?: Audience;
+        readonly versionHash?: string;
+        readonly projections?: ProjectionCatalog;
+        readonly hydrationProjectionId?: string;
+        readonly declaredToolClasses?: DeclaredToolClasses;
+        readonly undeclared?: UndeclaredToolPolicy;
+    }): Promise<LineageResult<NodeExplanation>>;
+    /**
+     * The line state and record of version `hash`, on this line or on a line it was branched from
+     * (breadth-first through `branched` versions, at most `MAX_VERIFY_DEPTH` lines, each visited once).
+     */
+    private findVersion;
+    /**
+     * Several versions' artifacts from ONE fold of the line (`get` refolds the whole log per call).
+     * A version that is unknown or cannot be read maps to `undefined`.
+     */
+    getMany(experienceId: string, versionHashes: readonly string[]): Promise<LineageResult<ReadonlyMap<string, Experience | undefined>>>;
+    /** Begin a line: the genesis artifact becomes its first version. Refused when the line exists. */
+    start(genesis: Experience, by: Provenance): Promise<LineageResult<Committed>>;
+    /**
+     * Advance the head to `artifact`, which `ops` produce from the version `expectedHead`.
+     *
+     * REFUSES, writing nothing, when: `expectedHead` is not the head (`head-moved`, carrying the real
+     * one — the caller re-reads and re-authors; nothing is ever silently overwritten); the artifact
+     * does not name `expectedHead` as its only parent; or replaying `ops` from the parent does not
+     * reproduce the artifact's content address (`ops-artifact-mismatch`), including an op the host
+     * will not allow or one declared against a different base. `ops` is empty only for the first
+     * version of a line. The artifact may arrive unsealed.
+     */
+    advance(input: {
+        readonly experienceId: string;
+        readonly expectedHead: string | null;
+        readonly artifact: Experience;
+        readonly ops: readonly RecordedOperation[];
+        readonly by: Provenance;
+        /**
+         * Whether a recorded `declassify*` op may be replayed. Per call and HOST-ONLY: it lowers a
+         * class, so the code that authored the ops (never a planner's output, never stored config)
+         * passes it for this one write. Default false. `verify` does not need it (see there).
+         */
+        readonly allowDeclassify?: boolean;
+        /** What the author said about the change (a planner's `PlanResult.summary`): untrusted, bounded on the way in. */
+        readonly summary?: string;
+        /**
+         * The strictest class of everything the author read to write `summary` (the planner's inputs,
+         * context and samples included). HOST-STAMPED; a viewer sees the summary only when cleared for
+         * it AND for the version's own class floor. Absent: only the floor gates it, so a host whose
+         * planner saw classified context MUST pass it. Refused when it is not a known class.
+         */
+        readonly summaryClass?: SummaryClass;
+    }): Promise<LineageResult<Committed>>;
+    /**
+     * The concurrent-author path: fold `ops` onto the head yourself. The first op is applied with
+     * `applyAt`, so one that declares a `baseVersion` other than the head is refused
+     * (`stale-base-version`) instead of landing on a surface its author never saw; then the result is
+     * committed through {@link advance}'s verification, so what is recorded is exactly what replays.
+     */
+    compose(input: {
+        readonly experienceId: string;
+        readonly expectedHead: string;
+        readonly ops: readonly RecordedOperation[];
+        readonly by: Provenance;
+        /** As on {@link advance}: per call, host-only, default false. */
+        readonly allowDeclassify?: boolean;
+        /** As on {@link advance}. */
+        readonly summary?: string;
+        /** As on {@link advance}. */
+        readonly summaryClass?: SummaryClass;
+    }): Promise<LineageResult<Committed>>;
+    /**
+     * Restore the content of version `to` as a NEW version on top of `expectedHead` — history is
+     * never rewritten, and the revert itself can be reverted. Sticky classes the line learned since
+     * `to` are carried forward (never lowered; see derive.ts). `to` may be any version of the line
+     * except the head (which would restore nothing).
+     */
+    revert(input: {
+        readonly experienceId: string;
+        readonly expectedHead: string;
+        readonly to: string;
+        readonly by: Provenance;
+    }): Promise<LineageResult<Committed>>;
+    /** Undo: revert to the head's parent, as a new version. Redo is `revert` to the hash you left. */
+    undo(input: {
+        readonly experienceId: string;
+        readonly expectedHead: string;
+        readonly by: Provenance;
+    }): Promise<LineageResult<Committed>>;
+    /**
+     * Fork version `from` of one line into a NEW line `experienceId`. The new line's first version
+     * has `from` as its (cross-line) parent and carries the sticky classes of the source line's head
+     * at the fork, so branching an old version never launders a class the source learned later.
+     * Refused when the new line already exists.
+     */
+    branch(input: {
+        readonly from: {
+            readonly experienceId: string;
+            readonly versionHash: string;
+        };
+        readonly experienceId: string;
+        readonly by: Provenance;
+    }): Promise<LineageResult<Committed>>;
+    /**
+     * Mark version `versionHash` as the one the app SHOWS (an agent's ops yield a new version; showing
+     * it is this separate act). Compare-and-set on the promoted pointer: `expectedPromoted` is what
+     * the caller saw (null = nothing promoted yet).
+     */
+    promote(input: {
+        readonly experienceId: string;
+        readonly versionHash: string;
+        readonly expectedPromoted: string | null;
+        readonly by: Provenance;
+    }): Promise<LineageResult<{
+        readonly promoted: string;
+        readonly sequence: number;
+    }>>;
+    /**
+     * Rebuild a whole line from its log and compare it to what is stored — the consumer of
+     * `EXPERIENCE_COMPOSED`. Starting from the genesis artifact (attested by its address alone: there
+     * is nothing before it to replay from), each version is REBUILT, never read back from its blob:
+     * a composed version by replaying its ops on the rebuilt parent, a revert or branch by recomputing
+     * it from the rebuilt artifacts it names. The rebuilt content address must equal the logged one
+     * and the stored blob must hash to it. Returns every finding; `[]` = the line is consistent.
+     *
+     * A branch is only as sound as its source: `verify` also verifies the source line up to the
+     * version the fork carried classes from (`carriedFrom`), recursively (a visited set and a depth
+     * bound stop a forged cycle), and reports what it finds on the branch, prefixed with the source
+     * line; `carriedFrom` must be the forked version or a descendant of it on the source line. A
+     * version whose parent could not be rebuilt is reported, not skipped silently. Ops replay with
+     * `declassify*` ALLOWED: this checks that addresses reproduce, and the write path is the gate.
+     */
+    verify(experienceId: string): Promise<Finding[]>;
+    /** Verify `experienceId` from its start through version `upTo` (null = the whole line). */
+    private verifyLine;
+    /**
+     * The one write path: check `expectedHead` against the head, let `prepare` verify and build the
+     * version, store its bytes, then append at the log's tip. A lost append re-reads: if the head is
+     * still `expectedHead` (only a promotion slipped in) it retries at the new tip; otherwise it is
+     * `head-moved`. The blob is written BEFORE the event and is content-addressed, so a lost race
+     * leaves an unreferenced, harmless blob — never a log entry without bytes.
+     */
+    private commit;
+}
+//# sourceMappingURL=lineage.d.ts.map

package/dist/lineage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lineage.d.ts","sourceRoot":"","sources":["../src/lineage.ts"],"names":[],"mappings":"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"}