@snoai/memory 0.0.0-stage → 1.0.0

package/dist/internal/engine/telemetry/observe-ledger.js

@@ -0,0 +1,111 @@
+import { z } from "zod";
+import { createLogger } from "@snoai/utils/logger";
+import { dirname, join } from "node:path";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+//#region src/engine/telemetry/observe-ledger.ts
+const log = createLogger("sno-station-mem:observe-ledger");
+const rowSchema = z.object({
+	ts_ms: z.number().int().nonnegative(),
+	event_type: z.string(),
+	lane: z.string(),
+	project_id: z.string().min(1).optional(),
+	payload: z.record(z.string(), z.json())
+});
+function observeLedgerPath(profileDir) {
+	return join(profileDir, "observe", "ledger.jsonl");
+}
+function observeLedgerSyncedPath(profileDir) {
+	return join(profileDir, "observe", "ledger.synced");
+}
+function appendObserveLedgerRows(profileDir, rows) {
+	if (rows.length === 0) return;
+	const path = observeLedgerPath(profileDir);
+	mkdirSync(dirname(path), {
+		recursive: true,
+		mode: 448
+	});
+	appendFileSync(path, rows.map((row) => `${JSON.stringify(row)}\n`).join(""), { mode: 384 });
+}
+function warn(observe, message) {
+	if (observe.logger) observe.logger.warn(message);
+	else log.warn(message, void 0, {
+		event_name: "observe.ledger.failed",
+		file: "packages/memory/src/engine/telemetry/observe-ledger.ts",
+		function: "forwardObserveLedger",
+		site_id: "observe.ledger.failed"
+	});
+}
+async function reportRowFailure(observe, kind, row, error) {
+	const message = `observe.ledger:${kind} bytes ${row.start}-${row.end}: ${String(error)}`;
+	warn(observe, message);
+	try {
+		await observe.emitError?.(`observe.ledger:${kind}`, new Error(message));
+	} catch (reportError) {
+		warn(observe, `observe.ledger:error bytes ${row.start}-${row.end}: ${String(reportError)}`);
+	}
+}
+function consumeRows(profileDir, observe, batchSize) {
+	const syncedPath = observeLedgerSyncedPath(profileDir);
+	let offset = existsSync(syncedPath) ? Number(readFileSync(syncedPath, "utf8").trim()) : 0;
+	const path = observeLedgerPath(profileDir);
+	const rows = [];
+	if (!existsSync(path)) return {
+		rows,
+		offset
+	};
+	const ledger = readFileSync(path);
+	if (offset > ledger.length) {
+		warn(observe, `offset beyond ledger: ${offset} > ${ledger.length}`);
+		return {
+			rows,
+			offset
+		};
+	}
+	while (rows.length < batchSize) {
+		const newline = ledger.indexOf(10, offset);
+		if (newline === -1) break;
+		rows.push({
+			start: offset,
+			end: newline + 1,
+			text: ledger.toString("utf8", offset, newline)
+		});
+		offset = newline + 1;
+	}
+	if (rows.length) writeFileSync(syncedPath, String(offset), { mode: 384 });
+	return {
+		rows,
+		offset
+	};
+}
+async function forwardObserveLedger(options) {
+	const { profileDir, observe } = options;
+	const { rows, offset } = consumeRows(profileDir, observe, Math.min(50, Math.max(1, Math.trunc(options.batchSize ?? 50))));
+	let forwarded = 0;
+	for (const line of rows) {
+		let row;
+		try {
+			row = rowSchema.parse(JSON.parse(line.text));
+		} catch (error) {
+			await reportRowFailure(observe, "parse", line, error);
+			continue;
+		}
+		try {
+			if (await observe.tryEmit({
+				eventType: row.event_type,
+				payload: row.payload,
+				tsEdgeMs: row.ts_ms,
+				...row.project_id ? { scope: { project_id: row.project_id } } : {}
+			})) forwarded++;
+			else await reportRowFailure(observe, "rejected", line, "tryEmit returned false");
+		} catch (error) {
+			await reportRowFailure(observe, "throw", line, error);
+		}
+	}
+	return {
+		status: rows.length === 0 ? "idle" : forwarded ? "forwarded" : "failed",
+		forwarded,
+		offset
+	};
+}
+//#endregion
+export { appendObserveLedgerRows, forwardObserveLedger, observeLedgerPath, observeLedgerSyncedPath };

package/dist/internal/model/agent-llm-port.d.ts

@@ -0,0 +1,2 @@
+import { n as AgentLlmPort, r as AgentLlmRequest, t as AgentLlmCompletion } from "../../agent-llm-port-5oXgBpzJ.js";
+export { AgentLlmCompletion, AgentLlmPort, AgentLlmRequest };

package/dist/internal/model/agent-llm-port.js

@@ -0,0 +1 @@
+export {};

package/dist/internal/model/llm-client.d.ts

@@ -0,0 +1,3 @@
+import { a as LlmPreset, c as ResolvedLlmConfig, i as LlmClientConfig, o as LlmProvider, r as LlmClient, s as MemoryLlmRequest } from "../../plugin-config-schema-C0UUbOmG.js";
+import { a as isTerminalLlmFailure, i as createLlmClient, n as LlmClientTerminalError, o as extractJsonFromResponse, r as ModelCallRefusedError, s as repairCommonJson, t as JSON_SYSTEM_CONTENT } from "../../llm-client-DOTSGzhe.js";
+export { JSON_SYSTEM_CONTENT, type LlmClient, type LlmClientConfig, LlmClientTerminalError, type LlmPreset, type LlmProvider, type MemoryLlmRequest, ModelCallRefusedError, type ResolvedLlmConfig, createLlmClient, extractJsonFromResponse, isTerminalLlmFailure, repairCommonJson };

package/dist/internal/model/llm-client.js

@@ -0,0 +1,3 @@
+import { a as isTerminalLlmFailure, i as createLlmClient, n as LlmClientTerminalError, r as ModelCallRefusedError, t as JSON_SYSTEM_CONTENT } from "../../llm-client-B7Xoxqou.js";
+import { a as repairCommonJson, r as extractJsonFromResponse } from "../../model-reply-text-CKopStP2.js";
+export { JSON_SYSTEM_CONTENT, LlmClientTerminalError, ModelCallRefusedError, createLlmClient, extractJsonFromResponse, isTerminalLlmFailure, repairCommonJson };

package/dist/internal/model/llm-failure.d.ts

@@ -0,0 +1,26 @@
+//#region src/model/llm-failure.d.ts
+/** @file llm-failure.ts
+ * @purpose The one place that decides what a failed LLM / host-model call means.
+ * @boundary Every caller that sees an HTTP status or error message from a model endpoint
+ * classifies it here; no other module compares status codes or error text itself.
+ */
+export type LlmFailureCategory = "auth" | "credential-expired" | "credential-revoked" | "exhausted" | "throttle" | "transport" | "unknown";
+export interface LlmFailure {
+  category: LlmFailureCategory;
+  /** Retrying the same endpoint with the same credential cannot succeed. */
+  terminal: boolean;
+  /** The endpoint itself is gone or refuses the caller; a fallback tier may not substitute. */
+  endpointRefused: boolean;
+}
+export declare function readErrorStatus(error: unknown): number | undefined;
+export declare function readErrorMessage(error: unknown): string;
+/** Classifies one failed model call from whatever the transport surfaced: a status, a message, or both. */
+export declare function classifyLlmFailure(input: {
+  status?: number;
+  message?: string;
+}): LlmFailure;
+export declare function isCredentialFailure(category: LlmFailureCategory): boolean;
+export declare function isTerminalLlmFailure(category: LlmFailureCategory): boolean;
+/** A status worth one more attempt against the same endpoint. */
+export declare function isTransientLlmStatus(status: number): boolean;
+//#endregion

package/dist/internal/model/llm-failure.js

@@ -0,0 +1,63 @@
+//#region src/model/llm-failure.ts
+const CREDENTIAL_CATEGORIES = /* @__PURE__ */ new Set([
+	"auth",
+	"credential-expired",
+	"credential-revoked"
+]);
+const TERMINAL_CATEGORIES = /* @__PURE__ */ new Set([...CREDENTIAL_CATEGORIES, "exhausted"]);
+function readErrorStatus(error) {
+	if (typeof error !== "object" || error === null) return void 0;
+	if ("status" in error && typeof error.status === "number") return error.status;
+	if ("statusCode" in error && typeof error.statusCode === "number") return error.statusCode;
+}
+function readErrorMessage(error) {
+	if (error instanceof Error) return error.message;
+	if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") return error.message;
+	return String(error);
+}
+function isCredentialRevokedMessage(message) {
+	return /oauth token refresh failed for openai:.*\binvalid_grant\b.*\btoken revoked\b/i.test(message);
+}
+function isCredentialExpiredMessage(message) {
+	return /\bexpired access token\b/i.test(message);
+}
+function isAuthMessage(message) {
+	return /\b(?:401|403)\b/.test(message) || /unauthori[sz]ed/i.test(message) || /no api key found/i.test(message) || /(?:invalid|incorrect) api[- ]?key/i.test(message) || /(?:invalid|expired) (?:access |oauth )?token/i.test(message) || /(?:api[- ]?key|token).*(?:invalid|expired|rejected)/i.test(message) || /credential (?:is )?(?:invalid|expired|rejected)/i.test(message) || /no (?:valid )?credential (?:found|available|configured)/i.test(message) || /re-?authenticate/i.test(message) || /no authentication configured/i.test(message);
+}
+function isExhaustedMessage(message) {
+	return /you(?:'|’)ve reached your codex subscription usage limit/i.test(message);
+}
+function isThrottleMessage(message) {
+	return /\b429\b/.test(message) || /rate.?limit/i.test(message) || /quota/i.test(message);
+}
+function categoryOf(status, message) {
+	if (isCredentialRevokedMessage(message)) return "credential-revoked";
+	if (isCredentialExpiredMessage(message)) return "credential-expired";
+	if (status === 401 || status === 403 || isAuthMessage(message)) return "auth";
+	if (isExhaustedMessage(message)) return "exhausted";
+	if (status === 429 || isThrottleMessage(message)) return "throttle";
+	if (status !== void 0 && (status === 404 || status === 408 || status >= 500)) return "transport";
+	return "unknown";
+}
+/** Classifies one failed model call from whatever the transport surfaced: a status, a message, or both. */
+function classifyLlmFailure(input) {
+	const category = categoryOf(input.status, input.message ?? "");
+	const terminal = TERMINAL_CATEGORIES.has(category);
+	return {
+		category,
+		terminal,
+		endpointRefused: terminal || input.status === 404 || input.status === 503
+	};
+}
+function isCredentialFailure(category) {
+	return CREDENTIAL_CATEGORIES.has(category);
+}
+function isTerminalLlmFailure(category) {
+	return TERMINAL_CATEGORIES.has(category);
+}
+/** A status worth one more attempt against the same endpoint. */
+function isTransientLlmStatus(status) {
+	return status === 408 || status === 429 || status >= 500;
+}
+//#endregion
+export { classifyLlmFailure, isCredentialFailure, isTerminalLlmFailure, isTransientLlmStatus, readErrorMessage, readErrorStatus };

package/dist/internal/model/llm-mode-routing.d.ts

@@ -0,0 +1,22 @@
+import { l as ModelCallId, m as LlmRoutingConfigInput, p as LlmRoutingConfig } from "../../plugin-config-schema-C0UUbOmG.js";
+//#region src/model/llm-mode-routing.d.ts
+export type LlmTransport = "chat-completions" | "raw-completions" | "agent-host-seam";
+export type LlmParser = "json" | "json-or-single-token-verdict" | "single-token-verdict" | "text";
+export type LlmRouteTarget = {
+  tier: "agent" | "snoRemMem";
+  destination: "host" | "sno-gpu";
+  transport: LlmTransport;
+  parser: LlmParser;
+};
+export type LlmRouteOff = {
+  off: true;
+  reason: "configured-off";
+};
+export type LlmRouteDecision = LlmRouteTarget | LlmRouteOff;
+export declare function pickLlmRoutingConfig(config: LlmRoutingConfigInput): LlmRoutingConfig;
+export declare function resolveLlmRoute(input: {
+  callId: ModelCallId;
+  config: LlmRoutingConfigInput;
+}): LlmRouteDecision;
+//#endregion
+export type { LlmRoutingConfig };

package/dist/internal/model/llm-mode-routing.js

@@ -0,0 +1,37 @@
+import { llmRoutingConfigSchema } from "../config/product-mode.js";
+import { n as modelCallDestination, t as MODEL_CALLS } from "../../model-call-table-CspopkBg.js";
+//#region src/model/llm-mode-routing.ts
+/** @file llm-mode-routing.ts
+* @purpose Resolve one model call id to its configured destination and transport.
+*/
+function pickLlmRoutingConfig(config) {
+	return llmRoutingConfigSchema.parse({
+		mode: config.mode,
+		language: config.language,
+		modelCalls: config.modelCalls
+	});
+}
+function resolveLlmRoute(input) {
+	const routing = pickLlmRoutingConfig(input.config);
+	const call = MODEL_CALLS[input.callId];
+	if (!routing.modelCalls) throw new Error("modelCalls unavailable");
+	const destination = modelCallDestination(input.callId, routing.mode, routing.modelCalls);
+	if (destination === "off") return {
+		off: true,
+		reason: "configured-off"
+	};
+	if (destination === "host") return {
+		tier: "agent",
+		destination,
+		transport: call.transport.host,
+		parser: call.replyParser.host
+	};
+	return {
+		tier: "snoRemMem",
+		destination,
+		transport: call.transport.snoGpu,
+		parser: call.replyParser.snoGpu
+	};
+}
+//#endregion
+export { pickLlmRoutingConfig, resolveLlmRoute };

package/dist/internal/store/atomic-memory-cutover-sql.d.ts

@@ -0,0 +1,13 @@
+import { r as SqliteDatabaseLike } from "../../sqlite-runtime-L_ywirTm.js";
+//#region src/store/atomic-memory-cutover-sql.d.ts
+export declare const ATOMIC_MEMORY_TEXT_IMMUTABILITY_TRIGGER = "nodix_memories_text_immutable";
+export declare const ATOMIC_MEMORY_VALID_INTERVAL_CHECK_SQL = "valid_until IS NULL OR (valid_from IS NOT NULL AND valid_until > valid_from)";
+export declare const CREATE_ATOMIC_MEMORY_TEXT_IMMUTABILITY_TRIGGER_SQL: string;
+export declare const ATOMIC_MEMORY_ROW_CONSTRAINTS: ReadonlyArray<{
+  name: string;
+  predicate: string;
+}>;
+export declare const CREATE_ATOMIC_MEMORY_CUTOVER_TABLE_SQL: string;
+export declare function installAtomicMemoryTextImmutabilityTrigger(database: SqliteDatabaseLike): void;
+export declare function applyAtomicMemoryCutoverMigration(database: SqliteDatabaseLike): void;
+//#endregion

package/dist/internal/store/atomic-memory-cutover-sql.js

@@ -0,0 +1,237 @@
+import { MEMORY_CATEGORIES } from "../engine/shared/types.js";
+import { StorageError } from "../engine/shared/errors.js";
+import "../../memory-store-shared-DeIDkhLj.js";
+//#region src/store/atomic-memory-cutover-sql.ts
+/** @file atomic-memory-cutover-sql.ts
+* @purpose Holds the text-immutability trigger until the ordered Phase F cutover activates it.
+* @boundary Exported SQL only; importing this module never changes a store.
+*/
+const ATOMIC_MEMORY_TEXT_IMMUTABILITY_TRIGGER = "nodix_memories_text_immutable";
+const ATOMIC_MEMORY_VALID_INTERVAL_CHECK_SQL = "valid_until IS NULL OR (valid_from IS NOT NULL AND valid_until > valid_from)";
+const CREATE_ATOMIC_MEMORY_TEXT_IMMUTABILITY_TRIGGER_SQL = `
+CREATE TRIGGER ${ATOMIC_MEMORY_TEXT_IMMUTABILITY_TRIGGER}
+BEFORE UPDATE OF text ON nodix_memories
+WHEN NEW.text IS NOT OLD.text
+BEGIN
+	SELECT RAISE(ABORT, 'nodix_memories.text is immutable; create a new card');
+END;
+`;
+const ATOMIC_MEMORY_ROW_CONSTRAINTS = [
+	{
+		name: "text",
+		predicate: "text IS NOT NULL"
+	},
+	{
+		name: "category_not_null",
+		predicate: "category IS NOT NULL"
+	},
+	{
+		name: "category",
+		predicate: `category IN (${[...MEMORY_CATEGORIES, "foresight"].map((category) => `'${category}'`).join(", ")})`
+	},
+	{
+		name: "project_id",
+		predicate: "project_id IS NOT NULL"
+	},
+	{
+		name: "importance",
+		predicate: "importance IS NOT NULL AND importance >= 0.0 AND importance <= 1.0"
+	},
+	{
+		name: "timestamp",
+		predicate: "timestamp IS NOT NULL"
+	},
+	{
+		name: "content_hash",
+		predicate: "content_hash IS NOT NULL"
+	},
+	{
+		name: "lane",
+		predicate: "lane IS NOT NULL AND lane IN ('active', 'parked', 'quarantined')"
+	},
+	{
+		name: "timezone",
+		predicate: "timezone IS NOT NULL"
+	},
+	{
+		name: "maturity",
+		predicate: "maturity IS NOT NULL AND maturity IN ('extracted', 'distilled', 'compiled')"
+	},
+	{
+		name: "source",
+		predicate: "source IS NOT NULL AND source IN ('edge', 'cloud', 'manual')"
+	},
+	{
+		name: "extractor_version",
+		predicate: "extractor_version IS NOT NULL"
+	},
+	{
+		name: "valid_interval",
+		predicate: ATOMIC_MEMORY_VALID_INTERVAL_CHECK_SQL
+	},
+	{
+		name: "maturity_derived_from",
+		predicate: "maturity = 'extracted' OR (derived_from IS NOT NULL AND length(trim(derived_from)) > 0)"
+	},
+	{
+		name: "compiled_category",
+		predicate: "maturity != 'compiled' OR category = 'lesson'"
+	},
+	{
+		name: "foresight_source",
+		predicate: "category != 'foresight' OR source = 'cloud'"
+	},
+	{
+		name: "persona_subject",
+		predicate: "category != 'persona' OR (subject IS NOT NULL AND subject = 'agent')"
+	},
+	{
+		name: "lesson_subject",
+		predicate: "category != 'lesson' OR subject IS NULL OR subject = 'agent'"
+	},
+	{
+		name: "state_subject_metadata",
+		predicate: `category != 'state'
+		OR (
+			subject IS NOT NULL
+			AND subject GLOB 'entity:*'
+			AND length(subject) > length('entity:')
+			AND json_valid(metadata)
+			AND json_type(metadata, '$.event_at') IS NULL
+		)`
+	},
+	{
+		name: "foresight_subject",
+		predicate: `category != 'foresight'
+		OR (
+			subject IS NOT NULL
+			AND (
+				subject = 'user'
+				OR (subject GLOB 'entity:*' AND length(subject) > length('entity:'))
+			)
+		)`
+	},
+	{
+		name: "foresight_interval",
+		predicate: `category != 'foresight'
+		OR (
+			valid_from IS NOT NULL
+			AND valid_until IS NOT NULL
+			AND valid_from > timestamp
+			AND valid_until > valid_from
+		)`
+	}
+];
+const CREATE_ATOMIC_MEMORY_CUTOVER_TABLE_SQL = `
+CREATE TABLE nodix_memories_cutover (
+	id TEXT PRIMARY KEY,
+	text TEXT,
+	category TEXT,
+	project_id TEXT,
+	importance REAL DEFAULT 0.7,
+	timestamp INTEGER,
+	metadata TEXT DEFAULT '{}',
+	content_hash TEXT,
+	fact_id TEXT,
+	derived_from TEXT,
+	consolidation_epoch_id TEXT,
+	confidence_source TEXT,
+	lane TEXT DEFAULT 'active',
+	raw_candidate_json TEXT,
+	disposition_reason TEXT,
+	dispositioned_at_ms INTEGER,
+	timezone TEXT DEFAULT '__missing_timezone__',
+	subject TEXT,
+	attribute TEXT,
+	valid_from INTEGER,
+	valid_until INTEGER,
+	maturity TEXT,
+	source TEXT,
+	extractor_version TEXT,
+	${ATOMIC_MEMORY_ROW_CONSTRAINTS.map(({ predicate }) => `CHECK (${predicate})`).join(",\n	")}
+);
+`;
+const ATOMIC_MEMORY_CUTOVER_SCHEMA_SQL = `
+${CREATE_ATOMIC_MEMORY_CUTOVER_TABLE_SQL}
+
+DROP TABLE nodix_memories;
+ALTER TABLE nodix_memories_cutover RENAME TO nodix_memories;
+
+CREATE INDEX nodix_idx_memories_content_hash ON nodix_memories(content_hash);
+CREATE UNIQUE INDEX nodix_idx_memories_project_content_hash
+	ON nodix_memories(project_id, content_hash, category);
+CREATE INDEX nodix_idx_memories_category ON nodix_memories(category);
+CREATE INDEX nodix_idx_memories_project_timestamp ON nodix_memories(project_id, timestamp DESC);
+CREATE INDEX nodix_idx_memories_fact_id ON nodix_memories(fact_id);
+CREATE INDEX nodix_idx_memories_reflection_items ON nodix_memories(timestamp DESC)
+	WHERE json_valid(metadata) AND json_extract(metadata, '$.type') = 'memory-reflection-item';
+CREATE INDEX nodix_idx_memories_idempotency_key
+	ON nodix_memories(project_id, json_extract(metadata, '$.idempotency_key'))
+	WHERE json_valid(metadata) AND json_extract(metadata, '$.idempotency_key') IS NOT NULL;
+CREATE INDEX nodix_idx_memories_lane_project ON nodix_memories(lane, project_id);
+CREATE INDEX nodix_idx_memories_project_subject_attribute
+	ON nodix_memories(project_id, subject, attribute);
+CREATE INDEX nodix_idx_memories_project_valid_time
+	ON nodix_memories(project_id, valid_from, valid_until);
+CREATE INDEX nodix_idx_memories_project_maturity ON nodix_memories(project_id, maturity);
+CREATE INDEX nodix_idx_memories_project_source ON nodix_memories(project_id, source);
+CREATE INDEX nodix_idx_memories_project_extractor_version
+	ON nodix_memories(project_id, extractor_version);
+CREATE INDEX nodix_idx_memories_project_derived_from ON nodix_memories(project_id, derived_from);
+CREATE INDEX nodix_idx_memories_project_importance ON nodix_memories(project_id, importance);
+
+CREATE TRIGGER nodix_memories_fact_id_insert_guard
+BEFORE INSERT ON nodix_memories
+WHEN NEW.fact_id IS NULL
+BEGIN SELECT RAISE(ABORT, 'nodix_memories.fact_id is required'); END;
+
+CREATE TRIGGER nodix_memories_fact_id_update_guard
+BEFORE UPDATE ON nodix_memories
+WHEN NEW.fact_id IS NULL
+BEGIN SELECT RAISE(ABORT, 'nodix_memories.fact_id is required'); END;
+
+CREATE TRIGGER nodix_memories_timezone_required_before_insert
+BEFORE INSERT ON nodix_memories
+WHEN NEW.timezone = '__missing_timezone__' OR trim(NEW.timezone) = ''
+BEGIN SELECT RAISE(ABORT, 'timezone is required'); END;
+
+CREATE TRIGGER nodix_memories_timezone_required_before_update
+BEFORE UPDATE OF timezone ON nodix_memories
+WHEN NEW.timezone = '__missing_timezone__' OR trim(NEW.timezone) = ''
+BEGIN SELECT RAISE(ABORT, 'timezone is required'); END;
+
+CREATE TRIGGER rem_memory_facets_after_insert
+AFTER INSERT ON nodix_memories
+BEGIN
+	INSERT INTO nodix_rem_memory_facets (memory_id, facet, text, updated_at_ms)
+		VALUES (NEW.id, 'current', NEW.text, NEW.timestamp);
+END;
+
+CREATE TRIGGER rem_memory_facets_after_text_update
+AFTER UPDATE OF text ON nodix_memories
+BEGIN
+	INSERT INTO nodix_rem_memory_facets (memory_id, facet, text, updated_at_ms)
+		VALUES (NEW.id, 'current', NEW.text, NEW.timestamp)
+	ON CONFLICT(memory_id, facet) DO UPDATE SET
+		text = excluded.text, updated_at_ms = excluded.updated_at_ms;
+END;
+
+${CREATE_ATOMIC_MEMORY_TEXT_IMMUTABILITY_TRIGGER_SQL}
+`;
+function installAtomicMemoryTextImmutabilityTrigger(database) {
+	database.exec(CREATE_ATOMIC_MEMORY_TEXT_IMMUTABILITY_TRIGGER_SQL);
+}
+function applyAtomicMemoryCutoverMigration(database) {
+	database.exec("PRAGMA foreign_keys = OFF");
+	try {
+		database.transaction(() => {
+			const row = database.prepare("SELECT COUNT(*) AS count FROM nodix_memories").get();
+			if (row?.count !== 0) throw new StorageError(`Atomic memory cutover requires zero stored memories; found ${String(row?.count ?? "unknown")}`);
+			database.exec(ATOMIC_MEMORY_CUTOVER_SCHEMA_SQL);
+		}).immediate();
+	} finally {
+		database.exec("PRAGMA foreign_keys = ON");
+	}
+}
+//#endregion
+export { ATOMIC_MEMORY_ROW_CONSTRAINTS, ATOMIC_MEMORY_TEXT_IMMUTABILITY_TRIGGER, ATOMIC_MEMORY_VALID_INTERVAL_CHECK_SQL, CREATE_ATOMIC_MEMORY_CUTOVER_TABLE_SQL, CREATE_ATOMIC_MEMORY_TEXT_IMMUTABILITY_TRIGGER_SQL, applyAtomicMemoryCutoverMigration, installAtomicMemoryTextImmutabilityTrigger };

package/dist/internal/store/connection.d.ts

@@ -0,0 +1,2 @@
+import { a as initDb, c as readChunkVecTableDimension, d as validateStoragePath, i as closeDb, l as readChunkVecTableState, n as VecTableState, o as loadStorageExtensions, r as assertNoLegacyBoundarySchema, s as parseVecTableDimension, t as DrizzleDB, u as vecTableDdlHasPartitionKey } from "../../connection-DAbzki8K.js";
+export { DrizzleDB, VecTableState, assertNoLegacyBoundarySchema, closeDb, initDb, loadStorageExtensions, parseVecTableDimension, readChunkVecTableDimension, readChunkVecTableState, validateStoragePath, vecTableDdlHasPartitionKey };

package/dist/internal/store/connection.js

@@ -0,0 +1,2 @@
+import { a as parseVecTableDimension, c as vecTableDdlHasPartitionKey, i as loadStorageExtensions, l as validateStoragePath, n as closeDb, o as readChunkVecTableDimension, r as initDb, s as readChunkVecTableState, t as assertNoLegacyBoundarySchema } from "../../connection-DliCOBB2.js";
+export { assertNoLegacyBoundarySchema, closeDb, initDb, loadStorageExtensions, parseVecTableDimension, readChunkVecTableDimension, readChunkVecTableState, validateStoragePath, vecTableDdlHasPartitionKey };

package/dist/internal/store/data-bootstrap.d.ts

@@ -0,0 +1,2 @@
+import { n as bootstrapDataLayout, t as BootstrapResult } from "../../data-bootstrap-CcJUwkqf.js";
+export { BootstrapResult, bootstrapDataLayout };

package/dist/internal/store/data-bootstrap.js

@@ -0,0 +1,2 @@
+import { t as bootstrapDataLayout } from "../../data-bootstrap-CYniFp8b.js";
+export { bootstrapDataLayout };

package/dist/internal/store/data-paths.d.ts

@@ -0,0 +1,2 @@
+import { a as getCostLogPath, c as getSnoStationMemDataDir, i as getBackupsDir, n as assertLocalFilesystem, o as getInstallManifestPath, r as getAuditLogPath, s as getKillswitchPath, t as NonLocalFilesystemError } from "../../data-paths-C7sNdqvP.js";
+export { NonLocalFilesystemError, assertLocalFilesystem, getAuditLogPath, getBackupsDir, getCostLogPath, getInstallManifestPath, getKillswitchPath, getSnoStationMemDataDir };

package/dist/internal/store/data-paths.js

@@ -0,0 +1,65 @@
+import { getSnoStationMemStateDir } from "../contract/profile.js";
+import { join } from "node:path";
+import { statfsSync } from "node:fs";
+//#region src/store/data-paths.ts
+/** @file data-paths.ts
+* @purpose Resolve the safe-uninstall data directory layout for
+*   `@snoai/memory`: persistent user data under
+*   `<profile root>/sno-station-mem/data/`, separate from service state. POSIX only.
+* @boundary Path resolution + filesystem-class assertion. No I/O beyond
+*   a single `statfs` probe in `assertLocalFilesystem`.
+*/
+/** File-system kinds that DO NOT guarantee atomic POSIX rename. */
+const NON_LOCAL_FS_TYPES = /* @__PURE__ */ new Set([
+	26985,
+	4283649346,
+	4266872130,
+	20859,
+	1702057286
+]);
+/** Typed boundary error for refuse-to-operate when data dir is on NFS/SMB/FUSE. */
+var NonLocalFilesystemError = class extends Error {
+	dir;
+	fsType;
+	kind = "NonLocalFilesystemError";
+	constructor(dir, fsType) {
+		super(`Refusing to operate on non-local filesystem (type=0x${fsType.toString(16)}) at ${dir}. Atomic rename is not guaranteed at ${dir}.`);
+		this.dir = dir;
+		this.fsType = fsType;
+		this.name = "NonLocalFilesystemError";
+	}
+};
+function getSnoStationMemDataDir() {
+	return join(getSnoStationMemStateDir(), "data");
+}
+function getInstallManifestPath() {
+	return join(getSnoStationMemDataDir(), "install.json");
+}
+function getAuditLogPath() {
+	return join(getSnoStationMemDataDir(), "audit.jsonl");
+}
+function getCostLogPath() {
+	return join(getSnoStationMemDataDir(), "cost.jsonl");
+}
+function getKillswitchPath() {
+	return join(getSnoStationMemDataDir(), "killswitch");
+}
+function getBackupsDir() {
+	return join(getSnoStationMemDataDir(), "backups");
+}
+/**
+* `statfs(2)`-based check: throws `NonLocalFilesystemError` when `dir` sits on
+* NFS / SMB / FUSE (which includes iCloud-Drive-watched directories). POSIX
+* only — Windows is out of v1 projectId.
+*/
+function assertLocalFilesystem(dir) {
+	let info;
+	try {
+		info = statfsSync(dir);
+	} catch {
+		return;
+	}
+	if (NON_LOCAL_FS_TYPES.has(info.type)) throw new NonLocalFilesystemError(dir, info.type);
+}
+//#endregion
+export { NonLocalFilesystemError, assertLocalFilesystem, getAuditLogPath, getBackupsDir, getCostLogPath, getInstallManifestPath, getKillswitchPath, getSnoStationMemDataDir };