@iworkforces/tracelattice 2.0.3

package/dist/persistence/PersistenceCodec.js

@@ -0,0 +1,97 @@
+import { asBranchId, asEdgeId, asSessionId, asSuspensionToken, asThoughtId } from "../contracts/ids.js";
+import { SummarySchema } from "../core/compression/Summary.js";
+import { EdgeSchema, SequentialThinkingSchema } from "../schema.js";
+import { PersistenceCompatibilityError } from "../errors.js";
+import { parsePersistenceBranchId } from "./PersistenceScope.js";
+import * as __rspack_external_valibot from "valibot";
+function parseToolRecommendation(recommendation, sourcePath) {
+    if (void 0 === recommendation.confidence || void 0 === recommendation.rationale || void 0 === recommendation.priority) throw new PersistenceCompatibilityError(sourcePath, 'tool recommendation defaults are absent');
+    return {
+        ...recommendation,
+        confidence: recommendation.confidence,
+        rationale: recommendation.rationale,
+        priority: recommendation.priority
+    };
+}
+function parseSkillRecommendation(recommendation, sourcePath) {
+    if (void 0 === recommendation.confidence || void 0 === recommendation.rationale || void 0 === recommendation.priority) throw new PersistenceCompatibilityError(sourcePath, 'skill recommendation defaults are absent');
+    return {
+        ...recommendation,
+        confidence: recommendation.confidence,
+        rationale: recommendation.rationale,
+        priority: recommendation.priority
+    };
+}
+function parseStepRecommendation(step, sourcePath) {
+    if (void 0 === step.step_description || void 0 === step.expected_outcome) throw new PersistenceCompatibilityError(sourcePath, 'step recommendation defaults are absent');
+    const { recommended_tools, recommended_skills, ...fields } = step;
+    return {
+        ...fields,
+        step_description: step.step_description,
+        expected_outcome: step.expected_outcome,
+        recommended_tools: recommended_tools.map((tool)=>parseToolRecommendation(tool, sourcePath)),
+        ...void 0 === recommended_skills ? {} : {
+            recommended_skills: recommended_skills.map((skill)=>parseSkillRecommendation(skill, sourcePath))
+        }
+    };
+}
+function parseThoughtData(raw, sourcePath) {
+    const parsed = __rspack_external_valibot.parse(SequentialThinkingSchema, raw);
+    const { id, session_id, branch_id, merge_branch_ids, continuation_token, current_step, previous_steps, ...thought } = parsed;
+    return {
+        ...thought,
+        ...void 0 === id ? {} : {
+            id: asThoughtId(id)
+        },
+        ...void 0 === session_id ? {} : {
+            session_id: asSessionId(session_id)
+        },
+        ...void 0 === branch_id ? {} : {
+            branch_id: parsePersistenceBranchId(branch_id, sourcePath)
+        },
+        ...void 0 === merge_branch_ids ? {} : {
+            merge_branch_ids: merge_branch_ids.map(asBranchId)
+        },
+        ...void 0 === continuation_token ? {} : {
+            continuation_token: asSuspensionToken(continuation_token)
+        },
+        ...void 0 === current_step ? {} : {
+            current_step: parseStepRecommendation(current_step, sourcePath)
+        },
+        ...void 0 === previous_steps ? {} : {
+            previous_steps: previous_steps.map((step)=>parseStepRecommendation(step, sourcePath))
+        }
+    };
+}
+function parseEdge(raw) {
+    const parsed = __rspack_external_valibot.parse(EdgeSchema, raw);
+    return {
+        ...parsed,
+        id: asEdgeId(parsed.id),
+        from: asThoughtId(parsed.from),
+        to: asThoughtId(parsed.to),
+        sessionId: asSessionId(parsed.sessionId)
+    };
+}
+function parseSummary(raw, sourcePath) {
+    const parsed = __rspack_external_valibot.parse(SummarySchema, raw);
+    const { branchId, sessionId, rootThoughtId, coveredIds, coveredRange, ...summary } = parsed;
+    const [rangeStart, rangeEnd] = coveredRange;
+    if (void 0 === rangeStart || void 0 === rangeEnd) throw new PersistenceCompatibilityError(sourcePath, 'summary coveredRange must contain two values');
+    return {
+        ...summary,
+        sessionId: asSessionId(sessionId),
+        ...void 0 === branchId ? {} : {
+            branchId: parsePersistenceBranchId(branchId, sourcePath)
+        },
+        rootThoughtId: asThoughtId(rootThoughtId),
+        coveredIds: coveredIds.map(asThoughtId),
+        coveredRange: [
+            rangeStart,
+            rangeEnd
+        ]
+    };
+}
+export { parseEdge, parseSummary, parseThoughtData };
+
+//# sourceMappingURL=PersistenceCodec.js.map

package/dist/persistence/PersistenceCodec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence/PersistenceCodec.js","sources":["../../src/persistence/PersistenceCodec.ts"],"sourcesContent":["import * as v from 'valibot';\nimport {\n\tasBranchId,\n\tasEdgeId,\n\tasSessionId,\n\tasSuspensionToken,\n\tasThoughtId,\n} from '../contracts/ids.js';\nimport type { Summary } from '../core/compression/Summary.js';\nimport { SummarySchema } from '../core/compression/Summary.js';\nimport type { Edge } from '../core/graph/Edge.js';\nimport type { ThoughtData } from '../core/thought.js';\nimport type { StepRecommendation } from '../core/step.js';\nimport { EdgeSchema, SequentialThinkingSchema } from '../schema.js';\nimport { PersistenceCompatibilityError } from '../errors.js';\nimport { parsePersistenceBranchId } from './PersistenceScope.js';\n\ntype PersistedToolRecommendation = {\n\treadonly tool_name: string;\n\treadonly confidence?: number;\n\treadonly rationale?: string;\n\treadonly priority?: number;\n\treadonly suggested_inputs?: Record<string, string | number | boolean | null>;\n\treadonly alternatives?: string[];\n};\n\ntype PersistedSkillRecommendation = {\n\treadonly skill_name: string;\n\treadonly confidence?: number;\n\treadonly rationale?: string;\n\treadonly priority?: number;\n\treadonly alternatives?: string[];\n\treadonly allowed_tools?: string[];\n\treadonly user_invocable?: boolean;\n};\n\ntype PersistedStepRecommendation = {\n\treadonly step_description?: string;\n\treadonly recommended_tools: readonly PersistedToolRecommendation[];\n\treadonly recommended_skills?: readonly PersistedSkillRecommendation[];\n\treadonly expected_outcome?: string;\n\treadonly next_step_conditions?: string[];\n};\n\nfunction parseToolRecommendation(recommendation: PersistedToolRecommendation, sourcePath: string) {\n\tif (\n\t\trecommendation.confidence === undefined ||\n\t\trecommendation.rationale === undefined ||\n\t\trecommendation.priority === undefined\n\t) {\n\t\tthrow new PersistenceCompatibilityError(sourcePath, 'tool recommendation defaults are absent');\n\t}\n\treturn {\n\t\t...recommendation,\n\t\tconfidence: recommendation.confidence,\n\t\trationale: recommendation.rationale,\n\t\tpriority: recommendation.priority,\n\t};\n}\n\nfunction parseSkillRecommendation(\n\trecommendation: PersistedSkillRecommendation,\n\tsourcePath: string\n) {\n\tif (\n\t\trecommendation.confidence === undefined ||\n\t\trecommendation.rationale === undefined ||\n\t\trecommendation.priority === undefined\n\t) {\n\t\tthrow new PersistenceCompatibilityError(sourcePath, 'skill recommendation defaults are absent');\n\t}\n\treturn {\n\t\t...recommendation,\n\t\tconfidence: recommendation.confidence,\n\t\trationale: recommendation.rationale,\n\t\tpriority: recommendation.priority,\n\t};\n}\n\nfunction parseStepRecommendation(\n\tstep: PersistedStepRecommendation,\n\tsourcePath: string\n): StepRecommendation {\n\tif (step.step_description === undefined || step.expected_outcome === undefined) {\n\t\tthrow new PersistenceCompatibilityError(sourcePath, 'step recommendation defaults are absent');\n\t}\n\tconst { recommended_tools, recommended_skills, ...fields } = step;\n\treturn {\n\t\t...fields,\n\t\tstep_description: step.step_description,\n\t\texpected_outcome: step.expected_outcome,\n\t\trecommended_tools: recommended_tools.map((tool) => parseToolRecommendation(tool, sourcePath)),\n\t\t...(recommended_skills === undefined\n\t\t\t? {}\n\t\t\t: {\n\t\t\t\t\trecommended_skills: recommended_skills.map((skill) =>\n\t\t\t\t\t\tparseSkillRecommendation(skill, sourcePath)\n\t\t\t\t\t),\n\t\t\t\t}),\n\t};\n}\n\nexport function parseThoughtData(raw: unknown, sourcePath: string): ThoughtData {\n\tconst parsed = v.parse(SequentialThinkingSchema, raw);\n\tconst {\n\t\tid,\n\t\tsession_id,\n\t\tbranch_id,\n\t\tmerge_branch_ids,\n\t\tcontinuation_token,\n\t\tcurrent_step,\n\t\tprevious_steps,\n\t\t...thought\n\t} = parsed;\n\treturn {\n\t\t...thought,\n\t\t...(id === undefined ? {} : { id: asThoughtId(id) }),\n\t\t...(session_id === undefined ? {} : { session_id: asSessionId(session_id) }),\n\t\t...(branch_id === undefined\n\t\t\t? {}\n\t\t\t: { branch_id: parsePersistenceBranchId(branch_id, sourcePath) }),\n\t\t...(merge_branch_ids === undefined\n\t\t\t? {}\n\t\t\t: { merge_branch_ids: merge_branch_ids.map(asBranchId) }),\n\t\t...(continuation_token === undefined\n\t\t\t? {}\n\t\t\t: { continuation_token: asSuspensionToken(continuation_token) }),\n\t\t...(current_step === undefined\n\t\t\t? {}\n\t\t\t: { current_step: parseStepRecommendation(current_step, sourcePath) }),\n\t\t...(previous_steps === undefined\n\t\t\t? {}\n\t\t\t: {\n\t\t\t\t\tprevious_steps: previous_steps.map((step) => parseStepRecommendation(step, sourcePath)),\n\t\t\t\t}),\n\t};\n}\n\nexport function parseEdge(raw: unknown): Edge {\n\tconst parsed = v.parse(EdgeSchema, raw);\n\treturn {\n\t\t...parsed,\n\t\tid: asEdgeId(parsed.id),\n\t\tfrom: asThoughtId(parsed.from),\n\t\tto: asThoughtId(parsed.to),\n\t\tsessionId: asSessionId(parsed.sessionId),\n\t};\n}\n\nexport function parseSummary(raw: unknown, sourcePath: string): Summary {\n\tconst parsed = v.parse(SummarySchema, raw);\n\tconst { branchId, sessionId, rootThoughtId, coveredIds, coveredRange, ...summary } = parsed;\n\tconst [rangeStart, rangeEnd] = coveredRange;\n\tif (rangeStart === undefined || rangeEnd === undefined) {\n\t\tthrow new PersistenceCompatibilityError(\n\t\t\tsourcePath,\n\t\t\t'summary coveredRange must contain two values'\n\t\t);\n\t}\n\treturn {\n\t\t...summary,\n\t\tsessionId: asSessionId(sessionId),\n\t\t...(branchId === undefined ? {} : { branchId: parsePersistenceBranchId(branchId, sourcePath) }),\n\t\trootThoughtId: asThoughtId(rootThoughtId),\n\t\tcoveredIds: coveredIds.map(asThoughtId),\n\t\tcoveredRange: [rangeStart, rangeEnd],\n\t};\n}\n"],"names":["parseToolRecommendation","recommendation","sourcePath","undefined","PersistenceCompatibilityError","parseSkillRecommendation","parseStepRecommendation","step","recommended_tools","recommended_skills","fields","tool","skill","parseThoughtData","raw","parsed","v","SequentialThinkingSchema","id","session_id","branch_id","merge_branch_ids","continuation_token","current_step","previous_steps","thought","asThoughtId","asSessionId","parsePersistenceBranchId","asBranchId","asSuspensionToken","parseEdge","EdgeSchema","asEdgeId","parseSummary","SummarySchema","branchId","sessionId","rootThoughtId","coveredIds","coveredRange","summary","rangeStart","rangeEnd"],"mappings":"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"}

package/dist/persistence/PersistenceErrors.d.ts

@@ -0,0 +1,23 @@
+import type { SessionScopedPersistenceOperation } from '../contracts/PersistenceBackend.js';
+import type { BranchId, SessionId } from '../contracts/ids.js';
+import { SequentialThinkingError } from '../errors.js';
+/** Durable namespace associated with a persistence write. */
+export type PersistenceScope = {
+    readonly sessionId: SessionId;
+    readonly branchId?: BranchId;
+};
+/** Operations whose payload ownership is validated before mutation. */
+export type PersistenceWriteOperation = 'saveThought' | 'saveThoughtForSession' | 'saveBranch' | 'saveBranchForSession' | 'saveEdges' | 'saveSummaries';
+/** Error raised when a custom backend lacks the complete scoped capability. */
+export declare class PersistenceCapabilityError extends SequentialThinkingError {
+    readonly operation: SessionScopedPersistenceOperation;
+    constructor(operation: SessionScopedPersistenceOperation);
+}
+/** Error raised before a write whose payload belongs to another namespace. */
+export declare class PersistenceScopeMismatchError extends SequentialThinkingError {
+    readonly operation: PersistenceWriteOperation;
+    readonly expectedScope: PersistenceScope;
+    readonly actualScopes: readonly PersistenceScope[];
+    constructor(operation: PersistenceWriteOperation, expectedScope: PersistenceScope, actualScopes: readonly PersistenceScope[]);
+}
+//# sourceMappingURL=PersistenceErrors.d.ts.map

package/dist/persistence/PersistenceErrors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersistenceErrors.d.ts","sourceRoot":"","sources":["../../src/persistence/PersistenceErrors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,oCAAoC,CAAC;AAC5F,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,EAAe,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAEpE,6DAA6D;AAC7D,MAAM,MAAM,gBAAgB,GAAG;IAC9B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;CAC7B,CAAC;AAEF,uEAAuE;AACvE,MAAM,MAAM,yBAAyB,GAClC,aAAa,GACb,uBAAuB,GACvB,YAAY,GACZ,sBAAsB,GACtB,WAAW,GACX,eAAe,CAAC;AAEnB,+EAA+E;AAC/E,qBAAa,0BAA2B,SAAQ,uBAAuB;IACtE,SAAgB,SAAS,EAAE,iCAAiC,CAAC;gBAEjD,SAAS,EAAE,iCAAiC;CAQxD;AAED,8EAA8E;AAC9E,qBAAa,6BAA8B,SAAQ,uBAAuB;IACzE,SAAgB,SAAS,EAAE,yBAAyB,CAAC;IACrD,SAAgB,aAAa,EAAE,gBAAgB,CAAC;IAChD,SAAgB,YAAY,EAAE,SAAS,gBAAgB,EAAE,CAAC;gBAGzD,SAAS,EAAE,yBAAyB,EACpC,aAAa,EAAE,gBAAgB,EAC/B,YAAY,EAAE,SAAS,gBAAgB,EAAE;CAW1C"}

package/dist/persistence/PersistenceErrors.js

@@ -0,0 +1,26 @@
+import { ERROR_CODES, SequentialThinkingError } from "../errors.js";
+class PersistenceCapabilityError extends SequentialThinkingError {
+    operation;
+    constructor(operation){
+        super(`Persistence backend does not support required session operation '${operation}'`, ERROR_CODES.PERSISTENCE_CAPABILITY_UNSUPPORTED);
+        this.name = 'PersistenceCapabilityError';
+        this.operation = operation;
+    }
+}
+class PersistenceScopeMismatchError extends SequentialThinkingError {
+    operation;
+    expectedScope;
+    actualScopes;
+    constructor(operation, expectedScope, actualScopes){
+        super(`Persistence payload scope does not match '${expectedScope.sessionId}' for ${operation}`, ERROR_CODES.PERSISTENCE_SCOPE_MISMATCH);
+        this.name = 'PersistenceScopeMismatchError';
+        this.operation = operation;
+        this.expectedScope = expectedScope;
+        this.actualScopes = [
+            ...actualScopes
+        ];
+    }
+}
+export { PersistenceCapabilityError, PersistenceScopeMismatchError };
+
+//# sourceMappingURL=PersistenceErrors.js.map

package/dist/persistence/PersistenceErrors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence/PersistenceErrors.js","sources":["../../src/persistence/PersistenceErrors.ts"],"sourcesContent":["import type { SessionScopedPersistenceOperation } from '../contracts/PersistenceBackend.js';\nimport type { BranchId, SessionId } from '../contracts/ids.js';\nimport { ERROR_CODES, SequentialThinkingError } from '../errors.js';\n\n/** Durable namespace associated with a persistence write. */\nexport type PersistenceScope = {\n\treadonly sessionId: SessionId;\n\treadonly branchId?: BranchId;\n};\n\n/** Operations whose payload ownership is validated before mutation. */\nexport type PersistenceWriteOperation =\n\t| 'saveThought'\n\t| 'saveThoughtForSession'\n\t| 'saveBranch'\n\t| 'saveBranchForSession'\n\t| 'saveEdges'\n\t| 'saveSummaries';\n\n/** Error raised when a custom backend lacks the complete scoped capability. */\nexport class PersistenceCapabilityError extends SequentialThinkingError {\n\tpublic readonly operation: SessionScopedPersistenceOperation;\n\n\tconstructor(operation: SessionScopedPersistenceOperation) {\n\t\tsuper(\n\t\t\t`Persistence backend does not support required session operation '${operation}'`,\n\t\t\tERROR_CODES.PERSISTENCE_CAPABILITY_UNSUPPORTED\n\t\t);\n\t\tthis.name = 'PersistenceCapabilityError';\n\t\tthis.operation = operation;\n\t}\n}\n\n/** Error raised before a write whose payload belongs to another namespace. */\nexport class PersistenceScopeMismatchError extends SequentialThinkingError {\n\tpublic readonly operation: PersistenceWriteOperation;\n\tpublic readonly expectedScope: PersistenceScope;\n\tpublic readonly actualScopes: readonly PersistenceScope[];\n\n\tconstructor(\n\t\toperation: PersistenceWriteOperation,\n\t\texpectedScope: PersistenceScope,\n\t\tactualScopes: readonly PersistenceScope[]\n\t) {\n\t\tsuper(\n\t\t\t`Persistence payload scope does not match '${expectedScope.sessionId}' for ${operation}`,\n\t\t\tERROR_CODES.PERSISTENCE_SCOPE_MISMATCH\n\t\t);\n\t\tthis.name = 'PersistenceScopeMismatchError';\n\t\tthis.operation = operation;\n\t\tthis.expectedScope = expectedScope;\n\t\tthis.actualScopes = [...actualScopes];\n\t}\n}\n"],"names":["PersistenceCapabilityError","SequentialThinkingError","operation","ERROR_CODES","PersistenceScopeMismatchError","expectedScope","actualScopes"],"mappings":";AAoBO,MAAMA,mCAAmCC;IAC/B,UAA6C;IAE7D,YAAYC,SAA4C,CAAE;QACzD,KAAK,CACJ,CAAC,iEAAiE,EAAEA,UAAU,CAAC,CAAC,EAChFC,YAAY,kCAAkC;QAE/C,IAAI,CAAC,IAAI,GAAG;QACZ,IAAI,CAAC,SAAS,GAAGD;IAClB;AACD;AAGO,MAAME,sCAAsCH;IAClC,UAAqC;IACrC,cAAgC;IAChC,aAA0C;IAE1D,YACCC,SAAoC,EACpCG,aAA+B,EAC/BC,YAAyC,CACxC;QACD,KAAK,CACJ,CAAC,0CAA0C,EAAED,cAAc,SAAS,CAAC,MAAM,EAAEH,WAAW,EACxFC,YAAY,0BAA0B;QAEvC,IAAI,CAAC,IAAI,GAAG;QACZ,IAAI,CAAC,SAAS,GAAGD;QACjB,IAAI,CAAC,aAAa,GAAGG;QACrB,IAAI,CAAC,YAAY,GAAG;eAAIC;SAAa;IACtC;AACD"}

package/dist/persistence/PersistenceFactory.d.ts

@@ -0,0 +1,21 @@
+import type { PersistenceBackend, PersistenceConfig } from '../contracts/PersistenceBackend.js';
+/**
+ * Create a persistence backend based on the provided configuration.
+ *
+ * Uses dynamic imports to avoid loading unused backends,
+ * keeping the factory decoupled from concrete implementations.
+ *
+ * @param config - Persistence configuration
+ * @returns A configured persistence backend, or null if disabled
+ *
+ * @example
+ * ```typescript
+ * const backend = createPersistenceBackend({
+ *   enabled: true,
+ *   backend: 'file',
+ *   options: { dataDir: './data' }
+ * });
+ * ```
+ */
+export declare function createPersistenceBackend(config: PersistenceConfig): Promise<PersistenceBackend | null>;
+//# sourceMappingURL=PersistenceFactory.d.ts.map

package/dist/persistence/PersistenceFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersistenceFactory.d.ts","sourceRoot":"","sources":["../../src/persistence/PersistenceFactory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AAEhG;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,wBAAwB,CAC7C,MAAM,EAAE,iBAAiB,GACvB,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CA2BpC"}

package/dist/persistence/PersistenceFactory.js

@@ -0,0 +1,28 @@
+async function createPersistenceBackend(config) {
+    if (!config.enabled) return null;
+    switch(config.backend){
+        case 'file':
+            {
+                const { FilePersistence } = await import("./FilePersistence.js");
+                return await FilePersistence.create(config.options);
+            }
+        case 'sqlite':
+            {
+                const { SqlitePersistence } = await import("./SqlitePersistence.js");
+                return await SqlitePersistence.create(config.options);
+            }
+        case 'memory':
+            {
+                const { MemoryPersistence } = await import("./MemoryPersistence.js");
+                return new MemoryPersistence({
+                    maxHistorySize: config.options?.maxHistorySize,
+                    persistBranches: config.options?.persistBranches
+                });
+            }
+        default:
+            throw new Error(`Unknown persistence backend: ${config.backend}`);
+    }
+}
+export { createPersistenceBackend };
+
+//# sourceMappingURL=PersistenceFactory.js.map

package/dist/persistence/PersistenceFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence/PersistenceFactory.js","sources":["../../src/persistence/PersistenceFactory.ts"],"sourcesContent":["import type { PersistenceBackend, PersistenceConfig } from '../contracts/PersistenceBackend.js';\n\n/**\n * Create a persistence backend based on the provided configuration.\n *\n * Uses dynamic imports to avoid loading unused backends,\n * keeping the factory decoupled from concrete implementations.\n *\n * @param config - Persistence configuration\n * @returns A configured persistence backend, or null if disabled\n *\n * @example\n * ```typescript\n * const backend = createPersistenceBackend({\n *   enabled: true,\n *   backend: 'file',\n *   options: { dataDir: './data' }\n * });\n * ```\n */\nexport async function createPersistenceBackend(\n\tconfig: PersistenceConfig\n): Promise<PersistenceBackend | null> {\n\tif (!config.enabled) {\n\t\treturn null;\n\t}\n\n\tswitch (config.backend) {\n\t\tcase 'file': {\n\t\t\tconst { FilePersistence } = await import('./FilePersistence.js');\n\t\t\treturn await FilePersistence.create(config.options);\n\t\t}\n\n\t\tcase 'sqlite': {\n\t\t\tconst { SqlitePersistence } = await import('./SqlitePersistence.js');\n\t\t\treturn await SqlitePersistence.create(config.options);\n\t\t}\n\n\t\tcase 'memory': {\n\t\t\tconst { MemoryPersistence } = await import('./MemoryPersistence.js');\n\t\t\treturn new MemoryPersistence({\n\t\t\t\tmaxHistorySize: config.options?.maxHistorySize,\n\t\t\t\tpersistBranches: config.options?.persistBranches,\n\t\t\t});\n\t\t}\n\n\t\tdefault:\n\t\t\tthrow new Error(`Unknown persistence backend: ${config.backend}`);\n\t}\n}\n"],"names":["createPersistenceBackend","config","FilePersistence","SqlitePersistence","MemoryPersistence","Error"],"mappings":"AAoBO,eAAeA,yBACrBC,MAAyB;IAEzB,IAAI,CAACA,OAAO,OAAO,EAClB,OAAO;IAGR,OAAQA,OAAO,OAAO;QACrB,KAAK;YAAQ;gBACZ,MAAM,EAAEC,eAAe,EAAE,GAAG,MAAM,MAAM,CAAC;gBACzC,OAAO,MAAMA,gBAAgB,MAAM,CAACD,OAAO,OAAO;YACnD;QAEA,KAAK;YAAU;gBACd,MAAM,EAAEE,iBAAiB,EAAE,GAAG,MAAM,MAAM,CAAC;gBAC3C,OAAO,MAAMA,kBAAkB,MAAM,CAACF,OAAO,OAAO;YACrD;QAEA,KAAK;YAAU;gBACd,MAAM,EAAEG,iBAAiB,EAAE,GAAG,MAAM,MAAM,CAAC;gBAC3C,OAAO,IAAIA,kBAAkB;oBAC5B,gBAAgBH,OAAO,OAAO,EAAE;oBAChC,iBAAiBA,OAAO,OAAO,EAAE;gBAClC;YACD;QAEA;YACC,MAAM,IAAII,MAAM,CAAC,6BAA6B,EAAEJ,OAAO,OAAO,EAAE;IAClE;AACD"}

package/dist/persistence/PersistenceScope.d.ts

@@ -0,0 +1,42 @@
+import type { ThoughtData } from '../core/thought.js';
+import type { Edge } from '../core/graph/Edge.js';
+import type { Summary } from '../core/compression/Summary.js';
+import { type BranchId, type SessionId } from '../contracts/ids.js';
+import { type PersistenceWriteOperation } from './PersistenceErrors.js';
+type PersistedThoughtData = ThoughtData & {
+    readonly id: string;
+};
+export interface PersistedThoughtCollection {
+    readonly sessionId: SessionId;
+    readonly thoughts: readonly ThoughtData[];
+}
+export declare function parsePersistenceBranchId(value: string, sourcePath: string): BranchId;
+export declare function assertPersistableThoughts(thoughts: readonly ThoughtData[], sourcePath: string): asserts thoughts is readonly PersistedThoughtData[];
+/**
+ * Enforces thought identity across session-tagged persisted arrays.
+ *
+ * Each array must contain unique IDs. Reuse between arrays is valid only for deeply equal
+ * payloads in the same session; equal identifiers in different sessions are independent.
+ *
+ * @param collections - History and branch arrays tagged with their owning session.
+ * @param sourcePath - Persistence location included in compatibility errors.
+ * @returns Nothing when all collection identities are compatible.
+ */
+export declare function assertPersistableThoughtCollections(collections: readonly PersistedThoughtCollection[], sourcePath: string): void;
+export declare function assertThoughtScope(operation: Extract<PersistenceWriteOperation, 'saveThought' | 'saveThoughtForSession'>, sessionId: SessionId, thought: ThoughtData): void;
+export declare function assertBranchScope(operation: Extract<PersistenceWriteOperation, 'saveBranch' | 'saveBranchForSession'>, sessionId: SessionId, branchId: BranchId, thoughts: readonly ThoughtData[]): void;
+export declare function assertEdgeScopes(sessionId: SessionId, edges: readonly Edge[]): void;
+export declare function assertSummaryScopes(sessionId: SessionId, summaries: readonly Summary[]): void;
+export declare function assertUniqueRecordIds(records: readonly {
+    readonly id: string;
+}[], sourcePath: string, recordKind: 'edge' | 'summary'): void;
+export declare function compareCodePoint(left: string, right: string): number;
+export declare function compareCreatedThenId(left: {
+    readonly createdAt: number;
+    readonly id: string;
+}, right: {
+    readonly createdAt: number;
+    readonly id: string;
+}): number;
+export {};
+//# sourceMappingURL=PersistenceScope.d.ts.map

package/dist/persistence/PersistenceScope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersistenceScope.d.ts","sourceRoot":"","sources":["../../src/persistence/PersistenceScope.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAC9D,OAAO,EAAiC,KAAK,QAAQ,EAAE,KAAK,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAInG,OAAO,EAGN,KAAK,yBAAyB,EAC9B,MAAM,wBAAwB,CAAC;AAIhC,KAAK,oBAAoB,GAAG,WAAW,GAAG;IAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAElE,MAAM,WAAW,0BAA0B;IAC1C,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,CAAC;CAC1C;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,QAAQ,CAKpF;AAED,wBAAgB,yBAAyB,CACxC,QAAQ,EAAE,SAAS,WAAW,EAAE,EAChC,UAAU,EAAE,MAAM,GAChB,OAAO,CAAC,QAAQ,IAAI,SAAS,oBAAoB,EAAE,CAWrD;AAED;;;;;;;;;GASG;AACH,wBAAgB,mCAAmC,CAClD,WAAW,EAAE,SAAS,0BAA0B,EAAE,EAClD,UAAU,EAAE,MAAM,GAChB,IAAI,CAqBN;AASD,wBAAgB,kBAAkB,CACjC,SAAS,EAAE,OAAO,CAAC,yBAAyB,EAAE,aAAa,GAAG,uBAAuB,CAAC,EACtF,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,WAAW,GAClB,IAAI,CAKN;AAED,wBAAgB,iBAAiB,CAChC,SAAS,EAAE,OAAO,CAAC,yBAAyB,EAAE,YAAY,GAAG,sBAAsB,CAAC,EACpF,SAAS,EAAE,SAAS,EACpB,QAAQ,EAAE,QAAQ,EAClB,QAAQ,EAAE,SAAS,WAAW,EAAE,GAC9B,IAAI,CAYN;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,IAAI,CAOnF;AAED,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,OAAO,EAAE,GAAG,IAAI,CAU7F;AAED,wBAAgB,qBAAqB,CACpC,OAAO,EAAE,SAAS;IAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,EAAE,EAC3C,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GAAG,SAAS,GAC5B,IAAI,CAWN;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAEpE;AAED,wBAAgB,oBAAoB,CACnC,IAAI,EAAE;IAAE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,EACzD,KAAK,EAAE;IAAE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GACxD,MAAM,CAER"}

package/dist/persistence/PersistenceScope.js

@@ -0,0 +1,93 @@
+import { isDeepStrictEqual } from "node:util";
+import { GLOBAL_SESSION_ID, asBranchId } from "../contracts/ids.js";
+import { PersistenceCompatibilityError } from "../errors.js";
+import { PersistenceScopeMismatchError } from "./PersistenceErrors.js";
+const BRANCH_ID_PATTERN = /^[A-Za-z0-9_-]{1,50}$/;
+function parsePersistenceBranchId(value, sourcePath) {
+    if (!BRANCH_ID_PATTERN.test(value)) throw new PersistenceCompatibilityError(sourcePath, `invalid branch id '${value}'`);
+    return asBranchId(value);
+}
+function assertPersistableThoughts(thoughts, sourcePath) {
+    const identifiers = new Set();
+    for (const thought of thoughts){
+        if (void 0 === thought.id || 0 === thought.id.length) throw new PersistenceCompatibilityError(sourcePath, 'persisted thoughts require an id');
+        if (identifiers.has(thought.id)) throw new PersistenceCompatibilityError(sourcePath, `duplicate thought id '${thought.id}'`);
+        identifiers.add(thought.id);
+    }
+}
+function assertPersistableThoughtCollections(collections, sourcePath) {
+    const payloadsBySession = new Map();
+    for (const collection of collections){
+        assertPersistableThoughts(collection.thoughts, sourcePath);
+        let sessionPayloads = payloadsBySession.get(collection.sessionId);
+        if (void 0 === sessionPayloads) {
+            sessionPayloads = new Map();
+            payloadsBySession.set(collection.sessionId, sessionPayloads);
+        }
+        for (const thought of collection.thoughts){
+            const identifier = thought.id;
+            const existing = sessionPayloads.get(identifier);
+            if (void 0 !== existing && !isDeepStrictEqual(existing, thought)) throw new PersistenceCompatibilityError(sourcePath, `conflicting thought id '${identifier}'`);
+            sessionPayloads.set(identifier, thought);
+        }
+    }
+}
+function thoughtScope(thought) {
+    return {
+        sessionId: thought.session_id ?? GLOBAL_SESSION_ID,
+        ...void 0 === thought.branch_id ? {} : {
+            branchId: thought.branch_id
+        }
+    };
+}
+function assertThoughtScope(operation, sessionId, thought) {
+    const actualScope = thoughtScope(thought);
+    if (actualScope.sessionId !== sessionId) throw new PersistenceScopeMismatchError(operation, {
+        sessionId
+    }, [
+        actualScope
+    ]);
+}
+function assertBranchScope(operation, sessionId, branchId, thoughts) {
+    const expectedScope = {
+        sessionId,
+        branchId
+    };
+    const mismatches = thoughts.map(thoughtScope).filter((scope)=>scope.sessionId !== expectedScope.sessionId || void 0 !== scope.branchId && scope.branchId !== expectedScope.branchId);
+    if (mismatches.length > 0) throw new PersistenceScopeMismatchError(operation, expectedScope, mismatches);
+}
+function assertEdgeScopes(sessionId, edges) {
+    const actualScopes = edges.filter((edge)=>edge.sessionId !== sessionId).map((edge)=>({
+            sessionId: edge.sessionId
+        }));
+    if (actualScopes.length > 0) throw new PersistenceScopeMismatchError('saveEdges', {
+        sessionId
+    }, actualScopes);
+}
+function assertSummaryScopes(sessionId, summaries) {
+    const actualScopes = summaries.filter((summary)=>summary.sessionId !== sessionId).map((summary)=>({
+            sessionId: summary.sessionId,
+            ...void 0 === summary.branchId ? {} : {
+                branchId: summary.branchId
+            }
+        }));
+    if (actualScopes.length > 0) throw new PersistenceScopeMismatchError('saveSummaries', {
+        sessionId
+    }, actualScopes);
+}
+function assertUniqueRecordIds(records, sourcePath, recordKind) {
+    const identifiers = new Set();
+    for (const record of records){
+        if (identifiers.has(record.id)) throw new PersistenceCompatibilityError(sourcePath, `duplicate ${recordKind} id '${record.id}'`);
+        identifiers.add(record.id);
+    }
+}
+function compareCodePoint(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function compareCreatedThenId(left, right) {
+    return left.createdAt - right.createdAt || compareCodePoint(left.id, right.id);
+}
+export { assertBranchScope, assertEdgeScopes, assertPersistableThoughtCollections, assertPersistableThoughts, assertSummaryScopes, assertThoughtScope, assertUniqueRecordIds, compareCodePoint, compareCreatedThenId, parsePersistenceBranchId };
+
+//# sourceMappingURL=PersistenceScope.js.map

package/dist/persistence/PersistenceScope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence/PersistenceScope.js","sources":["../../src/persistence/PersistenceScope.ts"],"sourcesContent":["import { isDeepStrictEqual } from 'node:util';\nimport type { ThoughtData } from '../core/thought.js';\nimport type { Edge } from '../core/graph/Edge.js';\nimport type { Summary } from '../core/compression/Summary.js';\nimport { asBranchId, GLOBAL_SESSION_ID, type BranchId, type SessionId } from '../contracts/ids.js';\nimport {\n\tPersistenceCompatibilityError,\n} from '../errors.js';\nimport {\n\tPersistenceScopeMismatchError,\n\ttype PersistenceScope,\n\ttype PersistenceWriteOperation,\n} from './PersistenceErrors.js';\n\nconst BRANCH_ID_PATTERN = /^[A-Za-z0-9_-]{1,50}$/;\n\ntype PersistedThoughtData = ThoughtData & { readonly id: string };\n\nexport interface PersistedThoughtCollection {\n\treadonly sessionId: SessionId;\n\treadonly thoughts: readonly ThoughtData[];\n}\n\nexport function parsePersistenceBranchId(value: string, sourcePath: string): BranchId {\n\tif (!BRANCH_ID_PATTERN.test(value)) {\n\t\tthrow new PersistenceCompatibilityError(sourcePath, `invalid branch id '${value}'`);\n\t}\n\treturn asBranchId(value);\n}\n\nexport function assertPersistableThoughts(\n\tthoughts: readonly ThoughtData[],\n\tsourcePath: string\n): asserts thoughts is readonly PersistedThoughtData[] {\n\tconst identifiers = new Set<string>();\n\tfor (const thought of thoughts) {\n\t\tif (thought.id === undefined || thought.id.length === 0) {\n\t\t\tthrow new PersistenceCompatibilityError(sourcePath, 'persisted thoughts require an id');\n\t\t}\n\t\tif (identifiers.has(thought.id)) {\n\t\t\tthrow new PersistenceCompatibilityError(sourcePath, `duplicate thought id '${thought.id}'`);\n\t\t}\n\t\tidentifiers.add(thought.id);\n\t}\n}\n\n/**\n * Enforces thought identity across session-tagged persisted arrays.\n *\n * Each array must contain unique IDs. Reuse between arrays is valid only for deeply equal\n * payloads in the same session; equal identifiers in different sessions are independent.\n *\n * @param collections - History and branch arrays tagged with their owning session.\n * @param sourcePath - Persistence location included in compatibility errors.\n * @returns Nothing when all collection identities are compatible.\n */\nexport function assertPersistableThoughtCollections(\n\tcollections: readonly PersistedThoughtCollection[],\n\tsourcePath: string\n): void {\n\tconst payloadsBySession = new Map<SessionId, Map<string, ThoughtData>>();\n\tfor (const collection of collections) {\n\t\tassertPersistableThoughts(collection.thoughts, sourcePath);\n\t\tlet sessionPayloads = payloadsBySession.get(collection.sessionId);\n\t\tif (sessionPayloads === undefined) {\n\t\t\tsessionPayloads = new Map<string, ThoughtData>();\n\t\t\tpayloadsBySession.set(collection.sessionId, sessionPayloads);\n\t\t}\n\t\tfor (const thought of collection.thoughts) {\n\t\t\tconst identifier = thought.id;\n\t\t\tconst existing = sessionPayloads.get(identifier);\n\t\t\tif (existing !== undefined && !isDeepStrictEqual(existing, thought)) {\n\t\t\t\tthrow new PersistenceCompatibilityError(\n\t\t\t\t\tsourcePath,\n\t\t\t\t\t`conflicting thought id '${identifier}'`\n\t\t\t\t);\n\t\t\t}\n\t\t\tsessionPayloads.set(identifier, thought);\n\t\t}\n\t}\n}\n\nfunction thoughtScope(thought: ThoughtData): PersistenceScope {\n\treturn {\n\t\tsessionId: thought.session_id ?? GLOBAL_SESSION_ID,\n\t\t...(thought.branch_id === undefined ? {} : { branchId: thought.branch_id }),\n\t};\n}\n\nexport function assertThoughtScope(\n\toperation: Extract<PersistenceWriteOperation, 'saveThought' | 'saveThoughtForSession'>,\n\tsessionId: SessionId,\n\tthought: ThoughtData\n): void {\n\tconst actualScope = thoughtScope(thought);\n\tif (actualScope.sessionId !== sessionId) {\n\t\tthrow new PersistenceScopeMismatchError(operation, { sessionId }, [actualScope]);\n\t}\n}\n\nexport function assertBranchScope(\n\toperation: Extract<PersistenceWriteOperation, 'saveBranch' | 'saveBranchForSession'>,\n\tsessionId: SessionId,\n\tbranchId: BranchId,\n\tthoughts: readonly ThoughtData[]\n): void {\n\tconst expectedScope = { sessionId, branchId } satisfies PersistenceScope;\n\tconst mismatches = thoughts\n\t\t.map(thoughtScope)\n\t\t.filter(\n\t\t\t(scope) =>\n\t\t\t\tscope.sessionId !== expectedScope.sessionId ||\n\t\t\t\t(scope.branchId !== undefined && scope.branchId !== expectedScope.branchId)\n\t\t);\n\tif (mismatches.length > 0) {\n\t\tthrow new PersistenceScopeMismatchError(operation, expectedScope, mismatches);\n\t}\n}\n\nexport function assertEdgeScopes(sessionId: SessionId, edges: readonly Edge[]): void {\n\tconst actualScopes = edges\n\t\t.filter((edge) => edge.sessionId !== sessionId)\n\t\t.map((edge) => ({ sessionId: edge.sessionId }));\n\tif (actualScopes.length > 0) {\n\t\tthrow new PersistenceScopeMismatchError('saveEdges', { sessionId }, actualScopes);\n\t}\n}\n\nexport function assertSummaryScopes(sessionId: SessionId, summaries: readonly Summary[]): void {\n\tconst actualScopes = summaries\n\t\t.filter((summary) => summary.sessionId !== sessionId)\n\t\t.map((summary) => ({\n\t\t\tsessionId: summary.sessionId,\n\t\t\t...(summary.branchId === undefined ? {} : { branchId: summary.branchId }),\n\t\t}));\n\tif (actualScopes.length > 0) {\n\t\tthrow new PersistenceScopeMismatchError('saveSummaries', { sessionId }, actualScopes);\n\t}\n}\n\nexport function assertUniqueRecordIds(\n\trecords: readonly { readonly id: string }[],\n\tsourcePath: string,\n\trecordKind: 'edge' | 'summary'\n): void {\n\tconst identifiers = new Set<string>();\n\tfor (const record of records) {\n\t\tif (identifiers.has(record.id)) {\n\t\t\tthrow new PersistenceCompatibilityError(\n\t\t\t\tsourcePath,\n\t\t\t\t`duplicate ${recordKind} id '${record.id}'`\n\t\t\t);\n\t\t}\n\t\tidentifiers.add(record.id);\n\t}\n}\n\nexport function compareCodePoint(left: string, right: string): number {\n\treturn left < right ? -1 : left > right ? 1 : 0;\n}\n\nexport function compareCreatedThenId(\n\tleft: { readonly createdAt: number; readonly id: string },\n\tright: { readonly createdAt: number; readonly id: string }\n): number {\n\treturn left.createdAt - right.createdAt || compareCodePoint(left.id, right.id);\n}\n"],"names":["BRANCH_ID_PATTERN","parsePersistenceBranchId","value","sourcePath","PersistenceCompatibilityError","asBranchId","assertPersistableThoughts","thoughts","identifiers","Set","thought","undefined","assertPersistableThoughtCollections","collections","payloadsBySession","Map","collection","sessionPayloads","identifier","existing","isDeepStrictEqual","thoughtScope","GLOBAL_SESSION_ID","assertThoughtScope","operation","sessionId","actualScope","PersistenceScopeMismatchError","assertBranchScope","branchId","expectedScope","mismatches","scope","assertEdgeScopes","edges","actualScopes","edge","assertSummaryScopes","summaries","summary","assertUniqueRecordIds","records","recordKind","record","compareCodePoint","left","right","compareCreatedThenId"],"mappings":"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"}

package/dist/persistence/SessionScopedPersistence.d.ts

@@ -0,0 +1,4 @@
+import type { PersistenceBackend, SessionScopedPersistenceBackend, SessionScopedPersistenceOperation } from '../contracts/PersistenceBackend.js';
+/** Require the complete scoped capability without falling back to legacy global operations. */
+export declare function requireSessionScopedPersistence(backend: PersistenceBackend, operation: SessionScopedPersistenceOperation): SessionScopedPersistenceBackend;
+//# sourceMappingURL=SessionScopedPersistence.d.ts.map

package/dist/persistence/SessionScopedPersistence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SessionScopedPersistence.d.ts","sourceRoot":"","sources":["../../src/persistence/SessionScopedPersistence.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,kBAAkB,EAClB,+BAA+B,EAC/B,iCAAiC,EACjC,MAAM,oCAAoC,CAAC;AAI5C,+FAA+F;AAC/F,wBAAgB,+BAA+B,CAC9C,OAAO,EAAE,kBAAkB,EAC3B,SAAS,EAAE,iCAAiC,GAC1C,+BAA+B,CAKjC"}

package/dist/persistence/SessionScopedPersistence.js

@@ -0,0 +1,9 @@
+import { supportsSessionScopedPersistence } from "../contracts/PersistenceBackend.js";
+import { PersistenceCapabilityError } from "./PersistenceErrors.js";
+function requireSessionScopedPersistence(backend, operation) {
+    if (!supportsSessionScopedPersistence(backend)) throw new PersistenceCapabilityError(operation);
+    return backend;
+}
+export { requireSessionScopedPersistence };
+
+//# sourceMappingURL=SessionScopedPersistence.js.map

package/dist/persistence/SessionScopedPersistence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence/SessionScopedPersistence.js","sources":["../../src/persistence/SessionScopedPersistence.ts"],"sourcesContent":["import type {\n\tPersistenceBackend,\n\tSessionScopedPersistenceBackend,\n\tSessionScopedPersistenceOperation,\n} from '../contracts/PersistenceBackend.js';\nimport { supportsSessionScopedPersistence } from '../contracts/PersistenceBackend.js';\nimport { PersistenceCapabilityError } from './PersistenceErrors.js';\n\n/** Require the complete scoped capability without falling back to legacy global operations. */\nexport function requireSessionScopedPersistence(\n\tbackend: PersistenceBackend,\n\toperation: SessionScopedPersistenceOperation\n): SessionScopedPersistenceBackend {\n\tif (!supportsSessionScopedPersistence(backend)) {\n\t\tthrow new PersistenceCapabilityError(operation);\n\t}\n\treturn backend;\n}\n"],"names":["requireSessionScopedPersistence","backend","operation","supportsSessionScopedPersistence","PersistenceCapabilityError"],"mappings":";;AASO,SAASA,gCACfC,OAA2B,EAC3BC,SAA4C;IAE5C,IAAI,CAACC,iCAAiCF,UACrC,MAAM,IAAIG,2BAA2BF;IAEtC,OAAOD;AACR"}

package/dist/persistence/SqliteDriver.d.ts

@@ -0,0 +1,22 @@
+export interface SqliteRunResult {
+    readonly changes: number;
+    readonly lastInsertRowid: number | bigint;
+}
+export interface SqliteStatement {
+    run(...params: readonly unknown[]): SqliteRunResult;
+    get(...params: readonly unknown[]): unknown;
+    all(...params: readonly unknown[]): unknown[];
+}
+export interface SqliteDatabase {
+    exec(sql: string): void;
+    prepare(sql: string): SqliteStatement;
+    close(): void;
+    pragma(pragma: string): unknown;
+}
+export type SqliteDatabaseConstructor = new (path: string, options?: {
+    readonly readonly?: boolean;
+    readonly fileMustExist?: boolean;
+}) => SqliteDatabase;
+export declare function runSqliteTransaction<T>(database: SqliteDatabase, operation: () => T): T;
+export declare function runSqliteReadTransaction<T>(database: SqliteDatabase, operation: () => T): T;
+//# sourceMappingURL=SqliteDriver.d.ts.map

package/dist/persistence/SqliteDriver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SqliteDriver.d.ts","sourceRoot":"","sources":["../../src/persistence/SqliteDriver.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,eAAe;IAC/B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,CAAC;CAC1C;AAED,MAAM,WAAW,eAAe;IAC/B,GAAG,CAAC,GAAG,MAAM,EAAE,SAAS,OAAO,EAAE,GAAG,eAAe,CAAC;IACpD,GAAG,CAAC,GAAG,MAAM,EAAE,SAAS,OAAO,EAAE,GAAG,OAAO,CAAC;IAC5C,GAAG,CAAC,GAAG,MAAM,EAAE,SAAS,OAAO,EAAE,GAAG,OAAO,EAAE,CAAC;CAC9C;AAED,MAAM,WAAW,cAAc;IAC9B,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,CAAC;IACtC,KAAK,IAAI,IAAI,CAAC;IACd,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;CAChC;AAED,MAAM,MAAM,yBAAyB,GAAG,KACvC,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE;IAAE,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAA;CAAE,KACvE,cAAc,CAAC;AA8BpB,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,QAAQ,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,CAAC,GAAG,CAAC,CAEvF;AAED,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,QAAQ,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,CAAC,GAAG,CAAC,CAE3F"}

package/dist/persistence/SqliteDriver.js

@@ -0,0 +1,29 @@
+function runTransaction(database, beginStatement, operation) {
+    database.exec(beginStatement);
+    try {
+        const result = operation();
+        database.exec('COMMIT');
+        return result;
+    } catch (error) {
+        try {
+            database.exec('ROLLBACK');
+        } catch (rollbackError) {
+            throw new AggregateError([
+                error,
+                rollbackError
+            ], 'SQLite operation and rollback both failed', {
+                cause: rollbackError
+            });
+        }
+        throw error;
+    }
+}
+function runSqliteTransaction(database, operation) {
+    return runTransaction(database, 'BEGIN IMMEDIATE', operation);
+}
+function runSqliteReadTransaction(database, operation) {
+    return runTransaction(database, 'BEGIN', operation);
+}
+export { runSqliteReadTransaction, runSqliteTransaction };
+
+//# sourceMappingURL=SqliteDriver.js.map

package/dist/persistence/SqliteDriver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence/SqliteDriver.js","sources":["../../src/persistence/SqliteDriver.ts"],"sourcesContent":["export interface SqliteRunResult {\n\treadonly changes: number;\n\treadonly lastInsertRowid: number | bigint;\n}\n\nexport interface SqliteStatement {\n\trun(...params: readonly unknown[]): SqliteRunResult;\n\tget(...params: readonly unknown[]): unknown;\n\tall(...params: readonly unknown[]): unknown[];\n}\n\nexport interface SqliteDatabase {\n\texec(sql: string): void;\n\tprepare(sql: string): SqliteStatement;\n\tclose(): void;\n\tpragma(pragma: string): unknown;\n}\n\nexport type SqliteDatabaseConstructor = new (\n\tpath: string,\n\toptions?: { readonly readonly?: boolean; readonly fileMustExist?: boolean }\n) => SqliteDatabase;\n\ntype SqliteBeginStatement = 'BEGIN' | 'BEGIN IMMEDIATE';\n\nfunction runTransaction<T>(\n\tdatabase: SqliteDatabase,\n\tbeginStatement: SqliteBeginStatement,\n\toperation: () => T\n): T {\n\tdatabase.exec(beginStatement);\n\ttry {\n\t\tconst result = operation();\n\t\tdatabase.exec('COMMIT');\n\t\treturn result;\n\t} catch (error) {\n\t\ttry {\n\t\t\tdatabase.exec('ROLLBACK');\n\t\t} catch (rollbackError) {\n\t\t\tthrow new AggregateError(\n\t\t\t\t[error, rollbackError],\n\t\t\t\t'SQLite operation and rollback both failed',\n\t\t\t\t{\n\t\t\t\t\tcause: rollbackError,\n\t\t\t\t}\n\t\t\t);\n\t\t}\n\t\tthrow error;\n\t}\n}\n\nexport function runSqliteTransaction<T>(database: SqliteDatabase, operation: () => T): T {\n\treturn runTransaction(database, 'BEGIN IMMEDIATE', operation);\n}\n\nexport function runSqliteReadTransaction<T>(database: SqliteDatabase, operation: () => T): T {\n\treturn runTransaction(database, 'BEGIN', operation);\n}\n"],"names":["runTransaction","database","beginStatement","operation","result","error","rollbackError","AggregateError","runSqliteTransaction","runSqliteReadTransaction"],"mappings":"AAyBA,SAASA,eACRC,QAAwB,EACxBC,cAAoC,EACpCC,SAAkB;IAElBF,SAAS,IAAI,CAACC;IACd,IAAI;QACH,MAAME,SAASD;QACfF,SAAS,IAAI,CAAC;QACd,OAAOG;IACR,EAAE,OAAOC,OAAO;QACf,IAAI;YACHJ,SAAS,IAAI,CAAC;QACf,EAAE,OAAOK,eAAe;YACvB,MAAM,IAAIC,eACT;gBAACF;gBAAOC;aAAc,EACtB,6CACA;gBACC,OAAOA;YACR;QAEF;QACA,MAAMD;IACP;AACD;AAEO,SAASG,qBAAwBP,QAAwB,EAAEE,SAAkB;IACnF,OAAOH,eAAeC,UAAU,mBAAmBE;AACpD;AAEO,SAASM,yBAA4BR,QAAwB,EAAEE,SAAkB;IACvF,OAAOH,eAAeC,UAAU,SAASE;AAC1C"}

package/dist/persistence/SqliteLegacyImport.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Imports an immutable SQLite v1 database into a separately published SQLite v2 destination.
+ *
+ * @param sourceDbPath - Existing frozen v1 source database opened read-only.
+ * @param destinationDbPath - Absent destination path atomically published after validation.
+ * @returns A promise that resolves after the validated v2 database is published.
+ *
+ * @example
+ * ```ts
+ * await importLegacySqliteV1('fixtures/legacy.db', 'output/history.db');
+ * ```
+ */
+export declare function importLegacySqliteV1(sourceDbPath: string, destinationDbPath: string): Promise<void>;
+//# sourceMappingURL=SqliteLegacyImport.d.ts.map

package/dist/persistence/SqliteLegacyImport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SqliteLegacyImport.d.ts","sourceRoot":"","sources":["../../src/persistence/SqliteLegacyImport.ts"],"names":[],"mappings":"AA6KA;;;;;;;;;;;GAWG;AACH,wBAAsB,oBAAoB,CACzC,YAAY,EAAE,MAAM,EACpB,iBAAiB,EAAE,MAAM,GACvB,OAAO,CAAC,IAAI,CAAC,CAaf"}