maka-agent 0.2.0-dev.6.20260830 → 0.2.0-dev.64.20260929

package/node_modules/@maka/storage/dist/sqlite-artifact-metadata.js

@@ -16,7 +16,6 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { createHash } from 'node:crypto';
 import { resolve } from 'node:path';
 import { decodeArtifactRecordJsons } from './artifact-metadata-codec.js';
 import { acquireOperationalStateDatabase, } from './operational-state-store.js';
@@ -29,41 +28,79 @@ class SqliteArtifactMetadataRepository {
     constructor(workspaceRoot) {
         this.#lease = acquireOperationalStateDatabase(resolve(workspaceRoot));
     }
-    ready() {
-        this.assertOpen();
-        return Promise.resolve();
-    }
     readAll() {
         this.assertOpen();
         const rows = this.#lease.database
             .prepare(`
         SELECT record_json
         FROM artifact_records
-        ORDER BY created_at, storage_key
+        ORDER BY created_at, artifact_id
       `)
             .all();
         return decodeRows(rows);
     }
-    replaceAll(records) {
+    applyChanges(changes) {
         this.assertOpen();
         this.#lease.transaction('write', () => {
-            this.#lease.database.prepare('DELETE FROM artifact_records').run();
-            const insert = this.#lease.database.prepare(`
+            const remove = this.#lease.database.prepare('DELETE FROM artifact_records WHERE artifact_id = ?');
+            for (const id of changes.deleteIds ?? [])
+                remove.run(id);
+            const upsert = this.#lease.database.prepare(`
         INSERT INTO artifact_records(
-          storage_key,
           artifact_id,
           session_id,
           created_at,
-          status,
           relative_path,
           record_json
-        ) VALUES (?, ?, ?, ?, ?, ?, ?)
+        ) VALUES (?, ?, ?, ?, ?)
+        ON CONFLICT(artifact_id) DO UPDATE SET
+          session_id = excluded.session_id,
+          created_at = excluded.created_at,
+          relative_path = excluded.relative_path,
+          record_json = excluded.record_json
+        WHERE session_id IS NOT excluded.session_id
+           OR created_at IS NOT excluded.created_at
+           OR relative_path IS NOT excluded.relative_path
+           OR record_json IS NOT excluded.record_json
       `);
-            for (const record of records) {
-                insert.run(artifactIdentityKey(record.id), record.id, record.sessionId, record.createdAt, record.status, record.relativePath, JSON.stringify(record));
+            for (const record of changes.upserts ?? []) {
+                upsert.run(record.id, record.sessionId, record.createdAt, record.relativePath, JSON.stringify(record));
             }
         });
     }
+    readUpgradeOrphanPaths(after, limit) {
+        this.assertOpen();
+        const rows = this.#lease.database
+            .prepare(`SELECT relative_path FROM artifact_upgrade_orphan_paths
+        WHERE relative_path > ? ORDER BY relative_path LIMIT ?`)
+            .all(after, limit);
+        return rows.map((row) => row.relative_path);
+    }
+    hasRelativePath(relativePath) {
+        this.assertOpen();
+        return Boolean(this.#lease.database
+            .prepare('SELECT 1 FROM artifact_records WHERE relative_path = ?')
+            .get(relativePath));
+    }
+    readRelativePathsByCaseFoldedArtifactIds(artifactIds) {
+        this.assertOpen();
+        if (artifactIds.length === 0)
+            return [];
+        const placeholders = artifactIds.map(() => '?').join(', ');
+        const rows = this.#lease.database
+            .prepare(`SELECT relative_path FROM artifact_records
+          WHERE artifact_id COLLATE NOCASE IN (${placeholders})`)
+            .all(...artifactIds);
+        return rows.map((row) => row.relative_path);
+    }
+    forgetUpgradeOrphanPaths(relativePaths) {
+        this.assertOpen();
+        this.#lease.transaction('write', () => {
+            const forget = this.#lease.database.prepare('DELETE FROM artifact_upgrade_orphan_paths WHERE relative_path = ?');
+            for (const relativePath of relativePaths)
+                forget.run(relativePath);
+        });
+    }
     close() {
         if (this.#closed)
             return;
@@ -78,6 +115,3 @@ class SqliteArtifactMetadataRepository {
 function decodeRows(rows) {
     return decodeArtifactRecordJsons(rows.map((row) => row.record_json));
 }
-function artifactIdentityKey(id) {
-    return createHash('sha256').update(JSON.stringify(id)).digest('hex');
-}

package/node_modules/@maka/storage/dist/sqlite-artifact-schema.js

@@ -16,23 +16,73 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-export const SQLITE_ARTIFACT_SCHEMA_VERSION = 1;
+import { decodeArtifactRecordJsons, isSafeRelativeArtifactPath, } from './artifact-metadata-codec.js';
+export const SQLITE_ARTIFACT_SCHEMA_VERSION = 3;
 export function migrateSqliteArtifactDatabase(db) {
+    const columns = db.prepare('PRAGMA table_info(artifact_records)').all();
+    const retained = [];
+    // Every path the old table named. Whatever is not carried over is a file no
+    // catalog will name again, and this is the last moment anything knows it is
+    // there. Unlinking here is not an option: a rollback after one would be
+    // unrecoverable, so the paths are recorded for the store to reclaim later.
+    const scanned = [];
+    const hasStatusColumn = columns.some(({ name }) => name === 'status');
+    if (hasStatusColumn || columns.some(({ name }) => name === 'storage_key')) {
+        const rows = db.prepare('SELECT * FROM artifact_records').all();
+        for (const row of rows) {
+            if (typeof row.relative_path === 'string' && isSafeRelativeArtifactPath(row.relative_path)) {
+                scanned.push(row.relative_path);
+            }
+            try {
+                const parsed = JSON.parse(String(row.record_json));
+                if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+                    continue;
+                if (parsed.id !== row.artifact_id ||
+                    parsed.sessionId !== row.session_id ||
+                    parsed.createdAt !== row.created_at ||
+                    parsed.relativePath !== row.relative_path)
+                    continue;
+                if ([hasStatusColumn ? row.status : undefined, parsed.status].some((value) => value !== undefined && value !== null && value !== 'live'))
+                    continue;
+                delete parsed.status;
+                retained.push(JSON.stringify(parsed));
+            }
+            catch { }
+        }
+        db.exec('DROP TABLE artifact_records');
+    }
     db.exec(`
     CREATE TABLE IF NOT EXISTS artifact_records (
-      storage_key TEXT PRIMARY KEY,
-      artifact_id TEXT NOT NULL,
+      artifact_id TEXT PRIMARY KEY,
       session_id TEXT NOT NULL,
       created_at INTEGER NOT NULL CHECK (created_at >= 0),
-      status TEXT NOT NULL CHECK (status IN ('live', 'deleted')),
       relative_path TEXT NOT NULL,
       record_json TEXT NOT NULL
     );
 
     CREATE INDEX IF NOT EXISTS artifact_records_session_order
-      ON artifact_records(session_id, created_at, storage_key);
+      ON artifact_records(session_id, created_at, artifact_id);
 
     CREATE UNIQUE INDEX IF NOT EXISTS artifact_records_relative_path
       ON artifact_records(relative_path);
+
+    CREATE TABLE IF NOT EXISTS artifact_upgrade_orphan_paths (
+      relative_path TEXT PRIMARY KEY
+    );
+  `);
+    const carried = decodeArtifactRecordJsons(retained);
+    const kept = new Set(carried.map((record) => record.relativePath));
+    const orphan = db.prepare(`
+    INSERT INTO artifact_upgrade_orphan_paths VALUES (?)
+    ON CONFLICT(relative_path) DO NOTHING
+  `);
+    for (const relativePath of scanned)
+        if (!kept.has(relativePath))
+            orphan.run(relativePath);
+    const insert = db.prepare(`
+    INSERT INTO artifact_records VALUES (?, ?, ?, ?, ?)
   `);
+    for (const record of carried) {
+        insert.run(record.id, record.sessionId, record.createdAt, record.relativePath, JSON.stringify(record));
+    }
 }

package/node_modules/@maka/storage/dist/sqlite-context-offload-store.js

@@ -24,6 +24,7 @@ import { dirname, isAbsolute, join, relative, sep } from 'node:path';
 import { CONTEXT_OFFLOAD_ID_MAX_CODE_POINTS, } from '@maka/core/context-offload';
 import { configureSqliteContextOffloadDatabase, migrateSqliteContextOffloadDatabase, } from './sqlite-context-offload-schema.js';
 import { readStableBoundedFile, syncDirectory, syncDirectoryChain, syncFile, } from './stable-storage.js';
+import { runWithContextValueMutation } from './context-value-mutation-gate.js';
 const MAX_MEDIA_TYPE_CODE_POINTS = 256;
 const SHA256_PATTERN = /^[0-9a-f]{64}$/;
 const MANAGED_FILE_LOCATOR_PATTERN = /^sha256\/([0-9a-f]{2})\/([0-9a-f]{64})$/;
@@ -40,7 +41,7 @@ export class SqliteContextOffloadStore {
     #onUnavailable;
     #storageRoot;
     #valueRoot;
-    #managedValueMutationTail = Promise.resolve();
+    #mutationGateKey;
     #closed = false;
     constructor(path, options) {
         if (!path)
@@ -57,6 +58,11 @@ export class SqliteContextOffloadStore {
         this.#valueRoot = this.#storageRoot
             ? join(this.#storageRoot, CONTEXT_OFFLOAD_VALUES_DIRECTORY_NAME)
             : undefined;
+        // The canonical root is the key, so every writer of these files -- this
+        // Store and an importer publishing into the same workspace -- queues in one
+        // place. A Store with no durable root holds no managed files, so it queues
+        // against itself alone and keeps the behaviour it had.
+        this.#mutationGateKey = this.#storageRoot ?? `memory:${randomUUID()}`;
         const Database = loadDatabaseSync();
         this.#database = new Database(path);
         try {
@@ -253,7 +259,7 @@ export class SqliteContextOffloadStore {
         return this.#runManagedValueMutation(async () => {
             this.#assertOpen();
             if (this.#hasPendingFileDeletions()) {
-                await this.#drainPendingFileDeletions(input.maxBlobs);
+                await this.#drainPendingFileDeletions(input.maxBlobs, input.maxBytes);
                 return {
                     deletedBlobs: 0,
                     deletedBytes: 0,
@@ -262,7 +268,7 @@ export class SqliteContextOffloadStore {
             }
             const collected = this.#writeTransaction(() => {
                 const rows = this.#database
-                    .prepare(`SELECT c.blob_id, b.size_bytes, b.storage_kind, b.payload
+                    .prepare(`SELECT c.blob_id, b.size_bytes, b.storage_kind
            FROM context_gc_candidates c INDEXED BY context_gc_candidates_eligible
            JOIN context_blobs b ON b.blob_id = c.blob_id
            WHERE c.unreferenced_at < ?
@@ -272,6 +278,8 @@ export class SqliteContextOffloadStore {
                 const selected = [];
                 let deletedBytes = 0;
                 let inlineDeletedBytes = 0;
+                // Admit by metadata before SQLite materializes legacy inline BLOBs.
+                const readValue = this.#database.prepare('SELECT storage_kind, size_bytes, payload FROM context_blobs WHERE blob_id = ?');
                 for (const row of rows) {
                     if (selected.length === input.maxBlobs)
                         break;
@@ -279,15 +287,21 @@ export class SqliteContextOffloadStore {
                     if (!blobId || !isNonNegativeSafeInteger(row.size_bytes)) {
                         throw new Error('Invalid context garbage candidate');
                     }
-                    const value = decodeBlobValue(row, Buffer.from(blobId).toString('hex'));
-                    if (!value)
-                        throw new Error('Invalid context garbage candidate value');
                     if (exceedsLimit(deletedBytes, row.size_bytes, input.maxBytes)) {
                         if (selected.length === 0) {
                             throw new Error(`Context garbage byte limit ${input.maxBytes} cannot fit eligible blob of ${row.size_bytes} bytes`);
                         }
                         break;
                     }
+                    const stored = readValue.get(blobId);
+                    if (!stored ||
+                        stored.size_bytes !== row.size_bytes ||
+                        stored.storage_kind !== row.storage_kind) {
+                        throw new Error('Invalid context garbage candidate metadata');
+                    }
+                    const value = decodeBlobValue(stored, Buffer.from(blobId).toString('hex'));
+                    if (!value)
+                        throw new Error('Invalid context garbage candidate value');
                     deletedBytes = addSafeInteger(deletedBytes, row.size_bytes, 'Collected context bytes');
                     selected.push({
                         blobId,
@@ -329,7 +343,7 @@ export class SqliteContextOffloadStore {
                     hasMore: rows.length > selected.length,
                 };
             });
-            await this.#drainPendingFileDeletions(input.maxBlobs);
+            await this.#drainPendingFileDeletions(input.maxBlobs, input.maxBytes);
             return {
                 ...collected,
                 hasMore: collected.hasMore || this.#hasPendingFileDeletions(),
@@ -714,11 +728,19 @@ export class SqliteContextOffloadStore {
             }
         });
     }
-    async #drainPendingFileDeletions(limit) {
+    async #drainPendingFileDeletions(limit, maxBytes) {
         const rows = this.#database
-            .prepare('SELECT locator FROM context_file_deletions ORDER BY enqueued_at, locator LIMIT ?')
+            .prepare('SELECT locator, size_bytes FROM context_file_deletions ORDER BY enqueued_at, locator LIMIT ?')
             .all(limit);
+        let bytes = 0;
         for (const row of rows) {
+            const size = readNonNegativeInteger(row.size_bytes, 'Pending context file deletion bytes');
+            if (exceedsLimit(bytes, size, maxBytes)) {
+                if (bytes === 0)
+                    throw new Error('Context garbage byte limit cannot fit pending file');
+                break;
+            }
+            bytes += size;
             const locator = decodeManagedFileLocator(row.locator);
             if (!locator)
                 throw new Error('Invalid pending context file deletion locator');
@@ -858,10 +880,18 @@ export class SqliteContextOffloadStore {
         }
         return join(valueRoot, 'sha256', match[1], blobId);
     }
+    /**
+     * Takes a turn in the Storage Root's context mutation queue.
+     *
+     * This used to be a promise tail private to the instance, which serialised
+     * this Store's publication against its own collection and fenced nothing
+     * else. An importer publishing payloads into a live workspace has to take the
+     * same turn: these operations read database state, await, and only then act
+     * on files, so anything interleaving at that await acts on a decision that is
+     * no longer true.
+     */
     #runManagedValueMutation(operation) {
-        const pending = this.#managedValueMutationTail.then(operation, operation);
-        this.#managedValueMutationTail = pending.then(() => undefined, () => undefined);
-        return pending;
+        return runWithContextValueMutation(this.#mutationGateKey, operation);
     }
     #markBlobUnreferencedIfEligible(blobId, unreferencedAt) {
         this.#database

package/node_modules/@maka/storage/dist/sqlite-core-execution-schema.js

@@ -16,14 +16,14 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-export const SQLITE_CORE_EXECUTION_SCHEMA_VERSION = 6;
+export const SQLITE_CORE_EXECUTION_SCHEMA_VERSION = 9;
+export const MODEL_PROJECTION_TARGET_SQL = "CASE WHEN json_valid(record_json) THEN CASE WHEN json_type(record_json, '$.data.transition.target.runtimeEventId') = 'text' THEN nullif(json_extract(record_json, '$.data.transition.target.runtimeEventId'), '') WHEN json_type(record_json, '$.data.runtimeEventId') = 'text' THEN nullif(json_extract(record_json, '$.data.runtimeEventId'), '') END END";
 export function migrateSqliteCoreExecutionDatabase(db) {
     db.exec(`
     CREATE TABLE IF NOT EXISTS core_agent_runs (
       session_id TEXT NOT NULL,
       run_id TEXT NOT NULL,
       created_at INTEGER NOT NULL,
-      record_json TEXT NOT NULL,
       latest_model_call_sequence INTEGER CHECK (latest_model_call_sequence >= 0),
       PRIMARY KEY (session_id, run_id)
     );
@@ -51,6 +51,11 @@ export function migrateSqliteCoreExecutionDatabase(db) {
     CREATE INDEX IF NOT EXISTS core_agent_run_events_type_sequence
       ON core_agent_run_events(event_type, session_id, run_id, sequence);
 
+    CREATE INDEX IF NOT EXISTS core_model_projection_target
+      ON core_agent_run_events(session_id,
+        ${MODEL_PROJECTION_TARGET_SQL}
+      ) WHERE event_type = 'model_projection_transition_recorded';
+
     CREATE TABLE IF NOT EXISTS core_agent_run_projections (
       session_id TEXT NOT NULL,
       event_type TEXT NOT NULL,
@@ -108,6 +113,25 @@ export function migrateSqliteCoreExecutionDatabase(db) {
         ON DELETE CASCADE
     );
 
+    CREATE TABLE IF NOT EXISTS core_client_capability_session_grants (
+      session_id TEXT NOT NULL,
+      provider_id TEXT NOT NULL,
+      contract_id TEXT NOT NULL,
+      server_id TEXT NOT NULL,
+      tool_name TEXT NOT NULL,
+      capability TEXT NOT NULL,
+      scope_kind TEXT NOT NULL,
+      scope_value TEXT NOT NULL,
+      granted_at INTEGER NOT NULL,
+      record_json TEXT NOT NULL,
+      PRIMARY KEY (
+        session_id, provider_id, contract_id, capability, scope_kind, scope_value
+      )
+    );
+
+    CREATE INDEX IF NOT EXISTS core_client_capability_session_grants_session
+      ON core_client_capability_session_grants(session_id, granted_at);
+
     CREATE TABLE IF NOT EXISTS core_shell_runs (
       session_id TEXT NOT NULL,
       shell_run_id TEXT NOT NULL,
@@ -120,6 +144,9 @@ export function migrateSqliteCoreExecutionDatabase(db) {
       ON core_shell_runs(session_id, started_at, shell_run_id);
   `);
     ensureColumn(db, 'core_agent_runs', 'latest_model_call_sequence', 'INTEGER CHECK (latest_model_call_sequence >= 0)');
+    // The runtime migration runs first and has already turned every stored Run header into an
+    // invocation opening fact, so the row keeps only what the ledger needs to hang its events on.
+    dropColumn(db, 'core_agent_runs', 'record_json');
     db.exec(`
     UPDATE core_agent_runs
     SET latest_model_call_sequence = (
@@ -142,7 +169,18 @@ export function migrateSqliteCoreExecutionDatabase(db) {
       ON core_agent_runs(session_id, latest_model_call_sequence, run_id)
       WHERE latest_model_call_sequence IS NOT NULL;
 
+    DROP INDEX IF EXISTS core_root_turn_continuation_source;
+
+    CREATE INDEX IF NOT EXISTS core_root_turn_continuation_source_v2
+      ON core_root_turn_admissions(
+        session_id,
+        json_extract(record_json, '$.execution.sourceTurnId'),
+        json_extract(record_json, '$.execution.sourceRunId')
+      )
+      WHERE json_extract(record_json, '$.execution.kind') = 'safe_boundary_continuation';
+
     DROP INDEX IF EXISTS core_agent_runs_identity;
+    DROP INDEX IF EXISTS core_interaction_requests_by_turn;
 
     DROP TABLE IF EXISTS core_message_receipts;
     DROP TABLE IF EXISTS core_message_host_epochs;
@@ -154,3 +192,9 @@ function ensureColumn(db, table, column, definition) {
         return;
     db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
 }
+function dropColumn(db, table, column) {
+    const columns = db.prepare(`PRAGMA table_info(${table})`).all();
+    if (!columns.some((candidate) => candidate.name === column))
+        return;
+    db.exec(`ALTER TABLE ${table} DROP COLUMN ${column}`);
+}

package/node_modules/@maka/storage/dist/sqlite-long-term-memory-store.js

@@ -555,14 +555,12 @@ export class SqliteMemoryItemStore {
         });
         return this.#readSnapshot(() => {
             const rows = this.#database.prepare(query.sql).all(...query.parameters);
-            return rows.map((row) => {
+            const itemIds = rows.map((row) => {
                 if (typeof row.item_id !== 'string')
                     throw new Error('Invalid Memory Item search result');
-                const record = this.#readItemRecord(row.item_id);
-                if (!record)
-                    throw new Error(`Memory Item ${row.item_id} disappeared during read`);
-                return record;
+                return row.item_id;
             });
+            return this.#readItemRecords(itemIds);
         });
     }
     async readOperation(operationId) {
@@ -685,13 +683,55 @@ export class SqliteMemoryItemStore {
          FROM memory_item_sources WHERE item_id = ? ORDER BY event_id ASC
          LIMIT ${MAX_SOURCES_PER_ITEM + 1}`)
             .all(itemId);
-        assertChildCardinality('keys', keys.length, MAX_KEYS_PER_ITEM);
-        assertChildCardinality('sources', sources.length, MAX_SOURCES_PER_ITEM);
-        return {
-            item: decodeItem(row),
-            keys: keys.map(decodeKey),
-            sources: sources.map(decodeSource),
-        };
+        return decodeItemRecord(row, keys, sources);
+    }
+    #readItemRecords(itemIds) {
+        if (itemIds.length === 0)
+            return [];
+        if (itemIds.length === 1) {
+            const record = this.#readItemRecord(itemIds[0]);
+            if (!record)
+                throw new Error(`Memory Item ${itemIds[0]} disappeared during read`);
+            return [record];
+        }
+        const rows = this.#database
+            .prepare(`SELECT * FROM memory_items WHERE item_id IN (${placeholders(itemIds.length)})`)
+            .all(...itemIds);
+        const items = new Map(rows.map((row) => [row.item_id, row]));
+        const keys = this.#readItemChildren('keys', itemIds, ([, key_text, normalized_key, key_type, key_origin]) => ({
+            key_text,
+            normalized_key,
+            key_type,
+            key_origin,
+        }));
+        const sources = this.#readItemChildren('sources', itemIds, ([, session_id, run_id, turn_id, event_id]) => ({ session_id, run_id, turn_id, event_id }));
+        // IN queries need not return search order; preserve the ranked ID sequence.
+        return itemIds.map((itemId) => {
+            const row = items.get(itemId);
+            if (!row)
+                throw new Error(`Memory Item ${itemId} disappeared during read`);
+            return decodeItemRecord(row, keys.get(itemId) ?? [], sources.get(itemId) ?? []);
+        });
+    }
+    #readItemChildren(child, itemIds, toRow) {
+        const statement = this.#database.prepare(buildMemoryChildBatchQuery(child, itemIds.length));
+        // Native array results avoid SQLite's per-column object property construction
+        // for as many as 25,700 sources. Column validation still happens in search order.
+        statement.setReturnArrays(true);
+        const rows = statement.all(...itemIds);
+        const grouped = new Map();
+        let previousItemId;
+        let children;
+        for (const row of rows) {
+            const itemId = row[0];
+            if (!children || itemId !== previousItemId) {
+                children = [];
+                grouped.set(itemId, children);
+                previousItemId = itemId;
+            }
+            children.push(toRow(row));
+        }
+        return grouped;
     }
     #requireItemRecord(itemId) {
         const record = this.#readItemRecord(itemId);
@@ -796,6 +836,31 @@ export function buildSqliteMemoryKeySearchQuery(input) {
         parameters,
     };
 }
+function buildMemoryChildBatchQuery(child, itemCount) {
+    const table = child === 'keys' ? 'memory_item_keys' : 'memory_item_sources';
+    const orderColumn = child === 'keys' ? 'normalized_key' : 'event_id';
+    const columns = child === 'keys'
+        ? 'c.key_text, c.normalized_key, c.key_type, c.key_origin'
+        : 'c.session_id, c.run_id, c.turn_id, c.event_id';
+    const maximum = child === 'keys' ? MAX_KEYS_PER_ITEM : MAX_SOURCES_PER_ITEM;
+    // Each composite primary key supplies at most maximum + 1 children per Item,
+    // including the overflow sentinel used by cardinality validation. A missing
+    // sentinel falls back to the last child, keeping corrupt child sets bounded.
+    // Fix Items as the outer loop so both indexes supply order without a temp sort.
+    return `
+    SELECT i.item_id, ${columns}
+    FROM memory_items i
+    CROSS JOIN ${table} c
+      ON c.item_id = i.item_id
+      AND c.${orderColumn} <= COALESCE(
+        (SELECT ${orderColumn} FROM ${table}
+         WHERE item_id = i.item_id ORDER BY ${orderColumn} ASC LIMIT 1 OFFSET ${maximum}),
+        (SELECT ${orderColumn} FROM ${table}
+         WHERE item_id = i.item_id ORDER BY ${orderColumn} DESC LIMIT 1)
+      )
+    WHERE i.item_id IN (${placeholders(itemCount)})
+    ORDER BY i.item_id ASC, c.${orderColumn} ASC`;
+}
 function normalizeMutations(mutations) {
     if (!Array.isArray(mutations) || mutations.length === 0) {
         throw new Error('Memory operation requires at least one mutation');
@@ -1108,6 +1173,15 @@ function mutationResult(mutationIndex, mutationType, item, outcome) {
         outcome,
     };
 }
+function decodeItemRecord(row, keys, sources) {
+    assertChildCardinality('keys', keys.length, MAX_KEYS_PER_ITEM);
+    assertChildCardinality('sources', sources.length, MAX_SOURCES_PER_ITEM);
+    return {
+        item: decodeItem(row),
+        keys: keys.map(decodeKey),
+        sources: sources.map(decodeSource),
+    };
+}
 function decodeItem(row) {
     const kind = requiredString(row.kind, 'kind');
     const statementType = requiredString(row.statement_type, 'statement_type');