@jungjaehoon/mama-core 1.4.2 → 1.6.0

package/dist/db-manager.js

@@ -23,6 +23,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initDB = initDB;
+exports.assertTestProcessIsNotUsingRealDb = assertTestProcessIsNotUsingRealDb;
 exports.getDB = getDB;
 exports.getAdapter = getAdapter;
 exports.closeDB = closeDB;
@@ -43,6 +44,7 @@ exports.isTestMode = isTestMode;
 exports.fts5Search = fts5Search;
 exports.reindexEmbeddings = reindexEmbeddings;
 const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
 const debug_logger_js_1 = require("./debug-logger.js");
 const progress_indicator_js_1 = require("./progress-indicator.js");
 const index_js_1 = require("./db-adapter/index.js");
@@ -53,6 +55,7 @@ let isInitialized = false;
 let initializingPromise = null; // Single-flight guard for concurrent callers
 // Migration directory (moved to src/db/migrations for M1.2)
 const MIGRATIONS_DIR = path_1.default.join(__dirname, '..', 'db', 'migrations');
+const REAL_USER_DB_PATH = path_1.default.join(os_1.default.homedir(), '.claude', 'mama-memory.db');
 /**
  * Initialize SQLite database adapter and connect
  *
@@ -65,6 +68,7 @@ const MIGRATIONS_DIR = path_1.default.join(__dirname, '..', 'db', 'migrations');
  * @returns SQLite database connection
  */
 async function initDB() {
+    assertTestProcessIsNotUsingRealDb();
     // Already initialized - return immediately
     if (isInitialized) {
         return dbConnection;
@@ -79,6 +83,7 @@ async function initDB() {
             (0, progress_indicator_js_1.logSearching)('Initializing database...');
             // Create SQLite adapter
             dbAdapter = (0, index_js_1.createAdapter)();
+            assertTestProcessIsNotUsingRealDb(resolveAdapterDbPath(dbAdapter), 'adapter.getDbPath()');
             // Connect to database
             dbConnection = await dbAdapter.connect();
             // Run migrations (includes 012-create-checkpoints-table.sql)
@@ -104,6 +109,48 @@ async function initDB() {
     })();
     return initializingPromise;
 }
+function assertTestProcessIsNotUsingRealDb(effectivePath, effectivePathSource = 'adapter') {
+    if (!isDatabaseBoundaryTestMode()) {
+        return;
+    }
+    const configuredPaths = [
+        { name: 'MAMA_DB_PATH', value: process.env.MAMA_DB_PATH },
+        { name: 'MAMA_DATABASE_PATH', value: process.env.MAMA_DATABASE_PATH },
+    ];
+    if (effectivePath) {
+        configuredPaths.push({ name: effectivePathSource, value: effectivePath });
+    }
+    for (const configuredPath of configuredPaths) {
+        if (!configuredPath.value) {
+            continue;
+        }
+        const resolvedPath = path_1.default.resolve(expandHomePath(configuredPath.value));
+        if (resolvedPath === path_1.default.resolve(REAL_USER_DB_PATH)) {
+            throw new Error(`[db-boundary] Refusing to initDB against real DB ${REAL_USER_DB_PATH} ` +
+                `from a test process (${configuredPath.name}=${configuredPath.value}). ` +
+                'Set MAMA_DB_PATH to a temporary path before initDB.');
+        }
+    }
+}
+function resolveAdapterDbPath(adapter) {
+    if (typeof adapter.getDbPath === 'function') {
+        return adapter.getDbPath();
+    }
+    return adapter.dbPath;
+}
+function isDatabaseBoundaryTestMode() {
+    return isTestMode();
+}
+function expandHomePath(value) {
+    const home = os_1.default.homedir();
+    if (value === '~') {
+        return home;
+    }
+    if (value.startsWith('~/')) {
+        return path_1.default.join(home, value.slice(2));
+    }
+    return value.replaceAll('${HOME}', home);
+}
 /**
  * Get database connection (singleton pattern)
  *
@@ -267,6 +314,13 @@ async function insertDecisionWithEmbedding(decision) {
             throw new Error(`Invalid event_date: must be ISO 8601 YYYY-MM-DD (got: ${d})`);
         }
     }
+    if (decision.event_datetime !== null && decision.event_datetime !== undefined) {
+        if (typeof decision.event_datetime !== 'number' ||
+            !Number.isFinite(decision.event_datetime) ||
+            decision.event_datetime <= 0) {
+            throw new Error(`Invalid event_datetime: must be a positive millisecond timestamp (got: ${decision.event_datetime})`);
+        }
+    }
     try {
         // Generate embedding BEFORE transaction (required for SQLite's sync transaction)
         // Note: Redact topic for privacy - only log length
@@ -299,14 +353,15 @@ async function insertDecisionWithEmbedding(decision) {
           confidence, created_at, updated_at,
           needs_validation, validation_attempts, last_validated_at, usage_count,
           trust_context, usage_success, usage_failure, time_saved,
-          evidence, alternatives, risks, event_date
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          evidence, alternatives, risks, event_date, event_datetime,
+          agent_id, model_run_id, envelope_hash, gateway_call_id, source_refs_json, provenance_json
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       `);
             const insertResult = stmt.run(decision.id, decision.topic, decision.decision, decision.reasoning || null, decision.outcome || null, decision.failure_reason || null, decision.limitation || null, decision.user_involvement || null, decision.session_id || null, decision.supersedes || null, decision.superseded_by || null, decision.refined_from ? JSON.stringify(decision.refined_from) : null, decision.confidence !== undefined ? decision.confidence : 0.5, 
             // IMPORTANT: All timestamps are stored in milliseconds (Date.now()).
             // The schema DEFAULT uses unixepoch() (seconds) but is never used
             // since all inserts go through this function which always provides ms.
-            decision.created_at || Date.now(), decision.updated_at || Date.now(), decision.needs_validation !== undefined ? decision.needs_validation : 0, decision.validation_attempts || 0, decision.last_validated_at || null, decision.usage_count || 0, decision.trust_context || null, decision.usage_success || 0, decision.usage_failure || 0, decision.time_saved || 0, decision.evidence || null, decision.alternatives || null, decision.risks || null, decision.event_date || null);
+            decision.created_at || Date.now(), decision.updated_at || Date.now(), decision.needs_validation !== undefined ? decision.needs_validation : 0, decision.validation_attempts || 0, decision.last_validated_at || null, decision.usage_count || 0, decision.trust_context || null, decision.usage_success || 0, decision.usage_failure || 0, decision.time_saved || 0, decision.evidence || null, decision.alternatives || null, decision.risks || null, decision.event_date || null, decision.event_datetime ?? null, decision.agent_id ?? null, decision.model_run_id ?? null, decision.envelope_hash ?? null, decision.gateway_call_id ?? null, decision.source_refs_json ?? null, decision.provenance_json ?? null);
             const rowid = Number(insertResult.lastInsertRowid);
             // Insert embedding in same transaction to ensure rowid matching
             (0, debug_logger_js_1.info)(`[db-manager] Vector search enabled: ${adapter.vectorSearchEnabled}`);
@@ -668,10 +723,10 @@ function resetDBState(options = {}) {
 /**
  * Check if running in test mode
  *
- * Returns true if MAMA_TEST_MODE or VITEST env vars are set
+ * Returns true if MAMA_TEST_MODE, VITEST, or NODE_ENV=test env vars are set
  */
 function isTestMode() {
-    return !!(process.env.MAMA_TEST_MODE || process.env.VITEST);
+    return Boolean(process.env.MAMA_TEST_MODE || process.env.VITEST || process.env.NODE_ENV === 'test');
 }
 /**
  * FTS5 keyword search on decisions table.

package/dist/decision-formatter.d.ts

@@ -38,6 +38,8 @@ export interface DecisionForFormat {
     risks?: string;
     /** ISO 8601 date when the event actually occurred. Null if not set. */
     event_date?: string | null;
+    /** Source event timestamp in milliseconds when known. Null if not set. */
+    event_datetime?: number | null;
 }
 /**
  * Trust context object

package/dist/decision-formatter.js

@@ -140,7 +140,7 @@ Top ${full.length} Most Relevant Decisions:
 `.trim();
     for (let i = 0; i < full.length; i++) {
         const d = full[i];
-        const duration = calculateDuration(d.created_at);
+        const duration = calculateDuration(getDecisionTimestamp(d));
         const outcomeEmoji = getOutcomeEmoji(d.outcome ?? null);
         const relevancePercent = Math.round((d.relevanceScore || 0) * 100);
         context += `\n\n${i + 1}. ${d.decision} (${duration}, relevance: ${relevancePercent}%) ${outcomeEmoji}`;
@@ -166,7 +166,7 @@ Top ${full.length} Most Relevant Decisions:
  * Format small decision history (3 or fewer)
  */
 function formatSmallHistory(current, history) {
-    const duration = calculateDuration(current.created_at);
+    const duration = calculateDuration(getDecisionTimestamp(current));
     let context = `
 🧠 DECISION HISTORY: ${current.topic}
 
@@ -284,6 +284,9 @@ function calculateDuration(timestamp) {
     }
     return `${diffDays} day${diffDays !== 1 ? 's' : ''} ago`;
 }
+function getDecisionTimestamp(decision) {
+    return decision.event_datetime ?? decision.created_at;
+}
 /**
  * Calculate duration between two timestamps in days
  */
@@ -560,7 +563,7 @@ function formatTeaserList(decisions, topN = 3) {
         output += `\n   "${preview}"`;
         // Recency metadata (NEW - Gaussian Decay)
         if (d.recency_age_days !== undefined && d.created_at) {
-            const timeAgo = calculateDuration(d.created_at);
+            const timeAgo = calculateDuration(getDecisionTimestamp(d));
             const recencyScore = d.recency_score ? Math.round(d.recency_score * 100) : null;
             const finalScore = d.final_score ? Math.round(d.final_score * 100) : null;
             output += `\n   ⏰ ${timeAgo}`;
@@ -582,7 +585,7 @@ function formatTeaser(decision) {
     if (!decision) {
         return null;
     }
-    const timeAgo = calculateDuration(decision.created_at);
+    const timeAgo = calculateDuration(getDecisionTimestamp(decision));
     // Extract preview (first 60 chars)
     const preview = decision.decision.length > 60 ? decision.decision.substring(0, 60) + '...' : decision.decision;
     // Extract files from trust_context or show generic
@@ -633,7 +636,7 @@ function formatRecall(decisions, semanticEdges = null) {
  * Format single decision with full detail
  */
 function formatSingleDecision(decision) {
-    const timeAgo = calculateDuration(decision.created_at);
+    const timeAgo = calculateDuration(getDecisionTimestamp(decision));
     const confidencePercent = Math.round((decision.confidence || 0) * 100);
     const outcomeEmoji = getOutcomeEmoji(decision.outcome ?? null);
     const outcomeText = decision.outcome || 'Not yet tracked';
@@ -725,7 +728,7 @@ function formatDecisionHistory(decisions, semanticEdges = null) {
 📋 Decision History: ${topic}
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-Latest Decision (${calculateDuration(latest.created_at)}):
+Latest Decision (${calculateDuration(getDecisionTimestamp(latest))}):
 ${latest.decision}
 `.trim();
     // Show brief reasoning if available
@@ -777,7 +780,7 @@ ${latest.decision}
         output += `\nPrevious Decisions (${older.length}):\n`;
         for (let i = 0; i < Math.min(older.length, 5); i++) {
             const d = older[i];
-            const timeAgo = calculateDuration(d.created_at);
+            const timeAgo = calculateDuration(getDecisionTimestamp(d));
             const emoji = getOutcomeEmoji(d.outcome ?? null);
             output += `\n${i + 2}. ${d.decision} (${timeAgo}) ${emoji}`;
             if (d.outcome === 'FAILED' && d.failure_reason) {
@@ -876,7 +879,7 @@ function formatList(decisions, options = {}) {
     output += '━'.repeat(60) + '\n';
     for (let i = 0; i < items.length; i++) {
         const d = items[i];
-        const timeAgo = calculateDuration(d.created_at);
+        const timeAgo = calculateDuration(getDecisionTimestamp(d));
         const type = d.user_involvement === 'approved' ? '👤 User' : '🤖 Assistant';
         const status = d.outcome ? getOutcomeEmoji(d.outcome) + ' ' + d.outcome : '⏳ Pending';
         const confidence = Math.round((d.confidence || 0) * 100);

package/dist/edges/ref-validation.d.ts

@@ -0,0 +1,8 @@
+import type { DatabaseAdapter } from '../db-manager.js';
+import type { ListVisibleTwinEdgesOptions, TwinEdgeRecord, TwinRef, TwinScopeRef, TwinVisibility } from './types.js';
+type TwinRefVisibilityAdapter = Pick<DatabaseAdapter, 'prepare'>;
+export declare function assertTwinRefsVisible(adapter: TwinRefVisibilityAdapter, refs: readonly TwinRef[], visibility?: TwinVisibility): void;
+export declare function assertTwinRefsVisibleToScopes(adapter: TwinRefVisibilityAdapter, refs: readonly TwinRef[], scopes?: TwinScopeRef[]): void;
+export declare function listVisibleTwinEdgesForRefs(adapter: TwinRefVisibilityAdapter, refs: readonly TwinRef[], options?: ListVisibleTwinEdgesOptions): TwinEdgeRecord[];
+export {};
+//# sourceMappingURL=ref-validation.d.ts.map

package/dist/edges/ref-validation.js

@@ -0,0 +1,262 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertTwinRefsVisible = assertTwinRefsVisible;
+exports.assertTwinRefsVisibleToScopes = assertTwinRefsVisibleToScopes;
+exports.listVisibleTwinEdgesForRefs = listVisibleTwinEdgesForRefs;
+const store_js_1 = require("./store.js");
+const TABLE_COLUMN_PRAGMAS = {
+    decisions: 'PRAGMA table_info(decisions)',
+    case_truth: 'PRAGMA table_info(case_truth)',
+};
+const tableColumnCache = new WeakMap();
+function scopeKey(scope) {
+    return `${scope.kind}\0${scope.id}`;
+}
+function hasScopes(scopes) {
+    return Array.isArray(scopes) && scopes.length > 0;
+}
+function hasConnectors(connectors) {
+    return Array.isArray(connectors) && connectors.length > 0;
+}
+function hasProjectRefs(projectRefs) {
+    return Array.isArray(projectRefs) && projectRefs.length > 0;
+}
+function visibilityFromScopes(scopes) {
+    return { scopes: scopes ? [...scopes] : undefined };
+}
+function asOfMs(visibility) {
+    return typeof visibility.asOfMs === 'number' ? visibility.asOfMs : null;
+}
+function isAtOrBeforeAsOf(value, visibility) {
+    const asOf = asOfMs(visibility);
+    return asOf === null || (typeof value === 'number' && value <= asOf);
+}
+function parseTimestamp(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return Math.floor(value);
+    }
+    if (typeof value === 'string') {
+        const parsed = Date.parse(value);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+}
+function tableColumns(adapter, table) {
+    const pragma = TABLE_COLUMN_PRAGMAS[table];
+    if (!pragma) {
+        throw new Error(`Unsupported table for column introspection: ${table}`);
+    }
+    let adapterCache = tableColumnCache.get(adapter);
+    if (!adapterCache) {
+        adapterCache = new Map();
+        tableColumnCache.set(adapter, adapterCache);
+    }
+    const cached = adapterCache.get(table);
+    if (cached) {
+        return cached;
+    }
+    const rows = adapter.prepare(pragma).all();
+    const columns = new Set(rows.map((row) => row.name));
+    adapterCache.set(table, columns);
+    return columns;
+}
+function isMemoryVisible(adapter, id, visibility) {
+    const row = adapter
+        .prepare(`
+        SELECT created_at, event_datetime
+        FROM decisions
+        WHERE id = ?
+        LIMIT 1
+      `)
+        .get(id);
+    if (!row) {
+        return false;
+    }
+    if (!isAtOrBeforeAsOf(row.event_datetime ?? row.created_at, visibility)) {
+        return false;
+    }
+    const scopes = visibility.scopes;
+    if (!hasScopes(scopes)) {
+        return true;
+    }
+    const scopeClauses = scopes.map(() => '(ms.kind = ? AND ms.external_id = ?)').join(' OR ');
+    const params = scopes.flatMap((scope) => [scope.kind, scope.id]);
+    const bindingRow = adapter
+        .prepare(`
+        SELECT 1 AS ok
+        FROM memory_scope_bindings msb
+        JOIN memory_scopes ms ON ms.id = msb.scope_id
+        WHERE msb.memory_id = ?
+          AND (${scopeClauses})
+        LIMIT 1
+      `)
+        .get(id, ...params);
+    if (bindingRow?.ok) {
+        return true;
+    }
+    const columns = tableColumns(adapter, 'decisions');
+    if (columns.has('memory_scope_kind') && columns.has('memory_scope_id')) {
+        const row = adapter
+            .prepare(`
+          SELECT 1 AS ok
+          FROM decisions
+          WHERE id = ?
+            AND (${scopes.map(() => '(memory_scope_kind = ? AND memory_scope_id = ?)').join(' OR ')})
+          LIMIT 1
+        `)
+            .get(id, ...params);
+        return Boolean(row?.ok);
+    }
+    return false;
+}
+function parseCaseScopeRefs(scopeRefs) {
+    if (typeof scopeRefs !== 'string' || scopeRefs.length === 0) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(scopeRefs);
+        if (!Array.isArray(parsed)) {
+            return [];
+        }
+        return parsed.filter((item) => item !== null &&
+            typeof item === 'object' &&
+            typeof item.kind === 'string' &&
+            typeof item.id === 'string');
+    }
+    catch {
+        return [];
+    }
+}
+function isCaseVisible(adapter, id, visibility) {
+    const row = adapter.prepare('SELECT * FROM case_truth WHERE case_id = ? LIMIT 1').get(id);
+    if (!row) {
+        return false;
+    }
+    const timestamp = parseTimestamp(row.last_activity_at) ?? parseTimestamp(row.updated_at);
+    if (!isAtOrBeforeAsOf(timestamp, visibility)) {
+        return false;
+    }
+    const scopes = visibility.scopes;
+    if (!hasScopes(scopes)) {
+        return true;
+    }
+    const requested = new Set(scopes.map(scopeKey));
+    const scopeRefs = parseCaseScopeRefs(row.scope_refs);
+    if (scopeRefs.some((scope) => requested.has(scopeKey(scope)))) {
+        return true;
+    }
+    const columns = tableColumns(adapter, 'case_truth');
+    if (columns.has('memory_scope_kind') && columns.has('memory_scope_id')) {
+        return scopes.some((scope) => row.memory_scope_kind === scope.kind && row.memory_scope_id === scope.id);
+    }
+    return false;
+}
+function isRawVisible(adapter, id, visibility) {
+    const row = adapter
+        .prepare('SELECT * FROM connector_event_index WHERE event_index_id = ? LIMIT 1')
+        .get(id);
+    if (!row) {
+        return false;
+    }
+    if (hasConnectors(visibility.connectors) &&
+        !visibility.connectors.includes(String(row.source_connector))) {
+        return false;
+    }
+    if (hasProjectRefs(visibility.projectRefs) &&
+        !visibility.projectRefs.some((project) => project.id === row.project_id)) {
+        return false;
+    }
+    if (typeof visibility.tenantId === 'string' &&
+        visibility.tenantId.length > 0 &&
+        row.tenant_id !== visibility.tenantId) {
+        return false;
+    }
+    if (!isAtOrBeforeAsOf(Number(row.event_datetime ?? row.source_timestamp_ms), visibility)) {
+        return false;
+    }
+    if (!hasScopes(visibility.scopes)) {
+        return true;
+    }
+    return visibility.scopes.some((scope) => row.memory_scope_kind === scope.kind && row.memory_scope_id === scope.id);
+}
+function isEntityVisible(adapter, id, visibility) {
+    const row = adapter
+        .prepare('SELECT scope_kind, scope_id, created_at FROM entity_nodes WHERE id = ? AND status = ? LIMIT 1')
+        .get(id, 'active');
+    if (!row) {
+        return false;
+    }
+    if (!isAtOrBeforeAsOf(row.created_at, visibility)) {
+        return false;
+    }
+    const scopes = visibility.scopes;
+    if (!hasScopes(scopes)) {
+        return true;
+    }
+    return scopes.some((scope) => row.scope_kind === scope.kind && row.scope_id === scope.id);
+}
+function isTwinRefVisible(adapter, ref, visibility, visitedEdges, edgeCache) {
+    if (ref.kind === 'entity') {
+        return isEntityVisible(adapter, ref.id, visibility);
+    }
+    if (ref.kind === 'report') {
+        return !hasScopes(visibility.scopes);
+    }
+    if (ref.kind === 'memory') {
+        return isMemoryVisible(adapter, ref.id, visibility);
+    }
+    if (ref.kind === 'case') {
+        return isCaseVisible(adapter, ref.id, visibility);
+    }
+    if (ref.kind === 'raw') {
+        return isRawVisible(adapter, ref.id, visibility);
+    }
+    if (visitedEdges.has(ref.id)) {
+        return false;
+    }
+    let edge = edgeCache.get(ref.id);
+    if (edge === undefined) {
+        edge = (0, store_js_1.getTwinEdge)(adapter, ref.id);
+        edgeCache.set(ref.id, edge);
+    }
+    if (!edge) {
+        return false;
+    }
+    if (!isAtOrBeforeAsOf(edge.created_at, visibility)) {
+        return false;
+    }
+    const pathWithCurrent = new Set(visitedEdges);
+    pathWithCurrent.add(ref.id);
+    return (isTwinRefVisible(adapter, edge.subject_ref, visibility, new Set(pathWithCurrent), edgeCache) &&
+        isTwinRefVisible(adapter, edge.object_ref, visibility, new Set(pathWithCurrent), edgeCache));
+}
+function assertTwinRefsVisible(adapter, refs, visibility = {}) {
+    const edgeCache = new Map();
+    for (const ref of refs) {
+        if (!isTwinRefVisible(adapter, ref, visibility, new Set(), edgeCache)) {
+            throw new Error(`Twin ref is not visible to requested visibility: ${ref.kind}:${ref.id}`);
+        }
+    }
+}
+function assertTwinRefsVisibleToScopes(adapter, refs, scopes) {
+    assertTwinRefsVisible(adapter, refs, visibilityFromScopes(scopes));
+}
+function listVisibleTwinEdgesForRefs(adapter, refs, options = {}) {
+    const edgeCache = new Map();
+    const edgeTypes = normalizeEdgeTypes(options.edgeTypes);
+    const edges = (0, store_js_1.listTwinEdgesForRefs)(adapter, refs).filter((edge) => (edgeTypes.size === 0 || edgeTypes.has(edge.edge_type)) &&
+        (typeof options.asOfMs !== 'number' || edge.created_at <= options.asOfMs) &&
+        isTwinRefVisible(adapter, edge.subject_ref, options, new Set(), edgeCache) &&
+        isTwinRefVisible(adapter, edge.object_ref, options, new Set(), edgeCache));
+    const limit = typeof options.limit === 'number' && Number.isFinite(options.limit)
+        ? Math.max(0, Math.floor(options.limit))
+        : edges.length;
+    return edges.slice(0, limit);
+}
+function normalizeEdgeTypes(edgeTypes) {
+    if (!Array.isArray(edgeTypes) || edgeTypes.length === 0) {
+        return new Set();
+    }
+    return new Set(edgeTypes);
+}
+//# sourceMappingURL=ref-validation.js.map

package/dist/edges/store.d.ts

@@ -0,0 +1,10 @@
+import type { DatabaseAdapter } from '../db-manager.js';
+import { type InsertTwinEdgeInput, type TwinEdgeRecord, type TwinRef } from './types.js';
+type TwinEdgeReadAdapter = Pick<DatabaseAdapter, 'prepare'>;
+type TwinEdgeAdapter = Pick<DatabaseAdapter, 'prepare' | 'transaction'>;
+export declare function mapTwinEdgeRow(row: Record<string, unknown>): TwinEdgeRecord;
+export declare function getTwinEdge(adapter: TwinEdgeReadAdapter, edgeId: string): TwinEdgeRecord | null;
+export declare function listTwinEdgesForRefs(adapter: TwinEdgeReadAdapter, refs: readonly TwinRef[]): TwinEdgeRecord[];
+export declare function insertTwinEdge(adapter: TwinEdgeAdapter, input: InsertTwinEdgeInput): TwinEdgeRecord;
+export {};
+//# sourceMappingURL=store.d.ts.map