@yielded/agent-storage-cloudflare 0.1.0-beta.174 → 0.1.0-beta.176

package/src/internal/do-journal.ts

@@ -1,3 +1,4 @@
+import { SqliteClient } from "@effect/sql-sqlite-do";
 import {
   makeCanonicalStorage,
   recordBatchId,
@@ -21,17 +22,33 @@ import {
   LifecyclePublicationFact,
   LifecyclePublicationError,
 } from "@yielded/agent/lifecycle-publication";
-import { CanonicalRecord, CanonicalSequence } from "@yielded/agent/records";
+import { BatchId, CanonicalRecord, CanonicalSequence } from "@yielded/agent/records";
 import { SqlStorageOwner } from "@yielded/agent/sql-memory-store";
 import {
   type AppendConflict,
+  AppendResult,
   ThreadStoreDiagnostic,
   ThreadStoreError,
 } from "@yielded/agent/thread-store";
-import { Cause, Clock, Effect, Option, Schema, Stream } from "effect";
+import {
+  Cause,
+  Clock,
+  Context,
+  Effect,
+  Layer,
+  Option,
+  Predicate,
+  References,
+  Result,
+  Schema,
+  Stream,
+  Tracer,
+} from "effect";
 import * as SqlClient from "effect/sql/SqlClient";
-import { SqlError } from "effect/sql/SqlError";
+import { classifySqliteError, SqlError } from "effect/sql/SqlError";
+import { CurrentTransformer, type Statement } from "effect/sql/Statement";
 
+import { DoStorageConfig } from "../DoStorageConfig.ts";
 import {
   type DoStorageFailpointError,
   DoAppendConflict,
@@ -41,6 +58,7 @@ import {
   DoValueBoundExceeded,
   type DoStorageFailpointLocation,
 } from "../DoStorageError.ts";
+import { DoStorageFailpoint, isDefaultDoStorageFailpoint } from "../DoStorageFailpoint.ts";
 import { ensureDoStorageLayout } from "./migrations.ts";
 import { ownedState, ownedRows, type OwnedState } from "./owned-state.ts";
 import {
@@ -68,6 +86,12 @@ const MAX_RECORD_CACHE_ENTRIES = 4_096;
 const MAX_BOUND_PARAMETERS = 100;
 const isSqlError = Schema.is(SqlError);
 
+const isNativeClient = Schema.is(
+  Schema.declare<SqliteClient.SqliteClient>((value): value is SqliteClient.SqliteClient =>
+    Predicate.hasProperty(value, SqliteClient.TypeId),
+  ),
+);
+
 const storedTextBytes = (value: string): number => new TextEncoder().encode(value).byteLength;
 
 const chunked = <A>(values: ReadonlyArray<A>, size: number): Array<ReadonlyArray<A>> => {
@@ -94,8 +118,8 @@ const threadRows = ownedRows(
 );
 
 class RecordRow extends Schema.Class<RecordRow>("RecordRow")({
-  batch_id: Schema.fromJsonString(BoundedIdentifier),
-  thread_id: BoundedIdentifier,
+  batch_id: Schema.fromJsonString(BatchId.check(Schema.isMaxLength(MAX_IDENTIFIER_LENGTH))),
+  thread_id: ThreadId.check(Schema.isMaxLength(MAX_IDENTIFIER_LENGTH)),
   record_id: Schema.fromJsonString(BoundedIdentifier),
   record_json: BoundedStoredText,
   sequence: CanonicalSequence,
@@ -200,14 +224,6 @@ const initializedLifecycleSources = new WeakSet<OwnedState>();
 
 export type { RawAppendRequest } from "@yielded/agent-storage-sql/sql-journal";
 
-export class RawAppendResult extends Schema.Class<RawAppendResult>(
-  "@effect-agent/storage-cloudflare/RawAppendResult",
-)({
-  firstSequence: CanonicalSequence,
-  lastSequence: CanonicalSequence,
-  replayed: Schema.Boolean,
-}) {}
-
 export class RawReadRequest extends Schema.Class<RawReadRequest>(
   "@effect-agent/storage-cloudflare/RawReadRequest",
 )({
@@ -317,10 +333,14 @@ const ensureCurrentStorage = Effect.fnUntraced(function* (
   failpoint: DoJournalFailpoint = noFailpoint,
   maxStoredValueBytes: number,
 ) {
-  yield* ensureDoStorageLayout().pipe(Effect.provideService(SqlClient.SqlClient, sql));
-
   const state = yield* ownedState(sql);
   const owner = (yield* SqlStorageOwner) ?? state;
+
+  yield* ensureDoStorageLayout().pipe(
+    Effect.provideService(SqlStorageOwner, owner),
+    Effect.provideService(SqlClient.SqlClient, sql),
+  );
+
   let journal: DoJournal | undefined;
 
   const lifecycle = yield* makeSqlLifecyclePublication(undefined, maxStoredValueBytes).pipe(
@@ -366,6 +386,14 @@ const makeJournal = Effect.fnUntraced(function* (
   const owner = (yield* SqlStorageOwner) ?? state;
   const progress = yield* SqlStorageProgress;
 
+  const nativeDb =
+    isNativeClient(sql) &&
+    sql.config.transformQueryNames === undefined &&
+    sql.config.transformResultNames === undefined &&
+    isDefaultDoStorageFailpoint(failpoint)
+      ? sql.config.storage?.sql
+      : undefined;
+
   const work = yield* makeSqlThreadWork({
     read: (body) => state.read(body),
     write: (body) =>
@@ -473,18 +501,36 @@ const makeJournal = Effect.fnUntraced(function* (
    * transaction. Expected outcomes may be captured only when every such refusal precedes
    * mutation; real faults still roll back. Successful preflight reads never authorize a write.
    */
-  const withWriteTransaction =
-    (operation: string, expected: (error: { readonly _tag: string }) => boolean = () => false) =>
-    <A, E extends { readonly _tag: string }>(
+  const withWriteTransaction = (
+    operation: string,
+    expected?: (error: { readonly _tag: string }) => boolean,
+  ) => {
+    const transaction = <A, E extends { readonly _tag: string }>(
       effect: Effect.Effect<A, E>,
     ): Effect.Effect<A, E | DoStorageError> =>
-      state.owner.withMutation(owner.transaction(storageResult(effect, expected))).pipe(
-        Effect.provideService(SqlClient.SqlClient, sql),
-        Effect.mapError((error) => (isSqlError(error) ? storageError(operation)(error) : error)),
-        Effect.tapError(annotateStorageError),
-        Effect.withSpan("DoJournal.withWriteTransaction", { attributes: { operation } }),
-        Effect.flatMap(Effect.fromResult),
-      );
+      Effect.withFiber((fiber) => {
+        const body = state.owner.withMutation(owner.transaction(effect)).pipe(
+          Effect.provideService(SqlClient.SqlClient, sql),
+          Effect.mapError((error) => (isSqlError(error) ? storageError(operation)(error) : error)),
+        );
+
+        const traced =
+          fiber.getRef(References.TracerEnabled) &&
+          fiber.getRef(Tracer.Tracer) !== Tracer.nativeTracer;
+
+        return traced
+          ? body.pipe(
+              Effect.tapError(annotateStorageError),
+              Effect.withSpan("DoJournal.withWriteTransaction", { attributes: { operation } }),
+            )
+          : body;
+      });
+
+    return <A, E extends { readonly _tag: string }>(effect: Effect.Effect<A, E>) =>
+      expected === undefined
+        ? transaction(effect)
+        : transaction(storageResult(effect, expected)).pipe(Effect.flatMap(Effect.fromResult));
+  };
 
   const materialize = Effect.fnUntraced(function* (
     threadId: string,
@@ -620,9 +666,152 @@ const makeJournal = Effect.fnUntraced(function* (
     return request;
   });
 
+  // Replay and progress validation precede this body in the same owner transaction.
+  // A miss makes no native change; the ordinary path reuses any tentative batch.
+  // After advancing the frontier, failures must roll back rather than fall back.
+  const appendNativeBody = Effect.fnUntraced(function* (
+    request: RawAppendRequest,
+    first: CanonicalSequence,
+    last: CanonicalSequence,
+    batchInserted: boolean,
+  ) {
+    const db = nativeDb;
+
+    // Effectful statement transformers and exported SQL spans retain the ordinary path.
+    const ordinaryStatement = yield* Effect.withFiber((fiber) =>
+      Effect.succeed(
+        fiber.getRef(CurrentTransformer) !== undefined ||
+          (fiber.getRef(References.TracerEnabled) &&
+            fiber.getRef(Tracer.Tracer) !== Tracer.nativeTracer),
+      ),
+    );
+
+    if (ordinaryStatement) return false;
+    if (
+      db === undefined ||
+      request.executionWrites.length !== 1 ||
+      request.executionWrites[0]?.update.retire ||
+      request.executionWrites[0]?.update.facts.length !== 0
+    )
+      return false;
+
+    const workPlan = yield* work.prepareClosedPair(
+      request.threadId,
+      first,
+      last,
+      request.records.map((record) => record.canonical),
+    );
+
+    if (workPlan === undefined) return false;
+
+    const native = yield* Effect.suspend(() => {
+      const query = (statement: Statement<object>, operation: string) =>
+        Result.try({
+          try: () => {
+            const [text, parameters] = statement.compile();
+
+            return db.exec(text, ...parameters).toArray();
+          },
+          catch: (cause) =>
+            storageError(operation)(
+              SqlError.make({
+                reason: classifySqliteError(cause, {
+                  operation,
+                  message: "Native canonical statement failed",
+                }),
+              }),
+            ),
+        });
+
+      return Effect.fromResult(
+        Result.gen(function* () {
+          const captured = physical.cachedRecords(request.threadId, first, request.records);
+
+          if (captured === undefined) return undefined;
+          const physicalRecords = yield* captured;
+          const rows = yield* query(workPlan.advance, "advance native work frontier");
+
+          // A zero-row predicate miss has made no change. A successful update
+          // must never fall back: every later refusal rolls back this transaction.
+          if (rows.length === 0) return undefined;
+          const executionPlans = executions.prepareCommit(request);
+
+          if (!batchInserted)
+            yield* query(
+              sql`INSERT INTO effect_agent_canonical_batches
+            (thread_id, batch_id, first_sequence, last_sequence, producer_id_json)
+            VALUES (${request.threadId}, ${JSON.stringify(request.batchId)}, ${first}, ${last}, ${request.producerIdJson})`,
+              "insert canonical batch",
+            );
+
+          const inserted = yield* query(
+            sql`INSERT INTO effect_agent_canonical_records ${sql.insert(physicalRecords.map((row) => row.columns))}
+            ON CONFLICT(thread_id, record_id) DO NOTHING RETURNING 1`,
+            "insert canonical records",
+          );
+
+          if (inserted.length !== request.records.length)
+            return yield* Result.fail(
+              DoAppendConflict.make({
+                message: "A canonical record ID already exists.",
+                reason: "record-identity",
+              }),
+            );
+          const memberships = physicalRecords.flatMap((row) => row.memberships);
+
+          for (const group of chunked(memberships, Math.floor(MAX_BOUND_PARAMETERS / 3)))
+            yield* query(
+              sql`INSERT INTO effect_agent_record_runs ${sql.insert(group)}`,
+              "index canonical Run membership",
+            );
+          for (const pointer of workPlan.pointers)
+            yield* query(pointer, "index canonical pointers");
+
+          for (const plan of executionPlans) {
+            const changed = yield* query(plan.statement, "commit active execution");
+            const accepted = plan.accept(changed);
+
+            if (Result.isFailure(accepted))
+              return yield* Result.fail(
+                DoAppendConflict.make({
+                  reason: accepted.failure.reason,
+                  message: "Active execution conflicts with the captured commit",
+                  ...(accepted.failure.actualTailSequence === undefined
+                    ? {}
+                    : { actualTailSequence: accepted.failure.actualTailSequence }),
+                }),
+              );
+          }
+          for (let index = 0; index < request.records.length; index++) {
+            const record = request.records[index]!;
+
+            recordCache.put(
+              RecordRow.make({
+                ...physicalRecords[index]!.columns,
+                thread_id: request.threadId,
+                record_id: record.recordId,
+                batch_id: request.batchId,
+                record_json: record.recordJson,
+                sequence: CanonicalSequence.make(first + index),
+              }),
+              record.recordBytes,
+            );
+          }
+
+          return rows;
+        }),
+      );
+    });
+
+    if (native === undefined) return false;
+    yield* threads.write(Effect.succeed(native));
+
+    return true;
+  });
+
   const appendPrepared = Effect.fnUntraced(function* (
     request: RawAppendRequest,
-  ): Effect.fn.Return<RawAppendResult, AppendError> {
+  ): Effect.fn.Return<AppendResult, AppendError> {
     const threadRows = yield* getThread(request.threadId);
 
     const thread = threadRows.length === 1 ? threadRows[0] : undefined;
@@ -634,30 +823,62 @@ const makeJournal = Effect.fnUntraced(function* (
         message: `Expected exactly one row but found ${threadRows.length}.`,
       });
 
-    const prefix = recordCache.prefix(request.threadId, thread.tail_sequence);
+    // A fresh canonical batch key and absence of an active receipt prove the two
+    // negative replay lookups in the same statement that retains the batch header.
+    // Keep the read-first path for stale/overflowed coordinates so exact retries
+    // still precede sequence and tail refusals.
+    const canInsert =
+      request.records.length > 0 &&
+      request.expectedTailSequence === thread.tail_sequence &&
+      Number.isSafeInteger(thread.tail_sequence + request.records.length);
+
+    const inserted = canInsert
+      ? yield* sql`INSERT INTO effect_agent_canonical_batches
+            (thread_id, batch_id, first_sequence, last_sequence, producer_id_json)
+            SELECT ${request.threadId}, ${JSON.stringify(request.batchId)},
+              ${thread.tail_sequence + 1}, ${thread.tail_sequence + request.records.length},
+              ${request.producerIdJson}
+            WHERE NOT EXISTS (
+              SELECT 1 FROM effect_agent_executions
+              WHERE thread_id=${request.threadId} AND last_commit_id=${request.batchId}
+            )
+            ON CONFLICT(thread_id, batch_id) DO NOTHING RETURNING 1`.pipe(
+          Effect.mapError(storageError("insert canonical batch")),
+        )
+      : [];
+
+    if (inserted.length === 0) {
+      const replay = yield* executionConflict(executions.replay(request));
 
-    const replay = yield* executionConflict(executions.replay(request));
+      if (replay !== undefined) return AppendResult.make(replay);
 
-    if (replay !== undefined) return RawAppendResult.make(replay);
+      const prefix = recordCache.prefix(request.threadId, thread.tail_sequence);
 
-    const existing =
-      prefix !== undefined && !prefix.some((row) => row.batch_id === request.batchId)
-        ? undefined
-        : yield* archives.replay(request.threadId, request.batchId);
+      const existing =
+        prefix !== undefined && !prefix.some((row) => row.batch_id === request.batchId)
+          ? undefined
+          : yield* archives.replay(request.threadId, request.batchId);
 
-    if (existing !== undefined) {
-      if (existing.batch_json !== request.batchJson) {
-        return yield* DoAppendConflict.make({
-          message: `Batch ${request.batchId} already exists with different canonical content.`,
-          reason: "batch-content",
+      if (existing !== undefined) {
+        if (existing.batch_json !== request.batchJson) {
+          return yield* DoAppendConflict.make({
+            message: `Batch ${request.batchId} already exists with different canonical content.`,
+            reason: "batch-content",
+          });
+        }
+
+        return AppendResult.make({
+          firstSequence: existing.first_sequence,
+          lastSequence: existing.last_sequence,
+          replayed: true,
         });
       }
-
-      return RawAppendResult.make({
-        firstSequence: existing.first_sequence,
-        lastSequence: existing.last_sequence,
-        replayed: true,
-      });
+      if (canInsert)
+        return yield* DoStorageCorruptionError.make({
+          table: "effect_agent_canonical_batches",
+          rowKey: request.threadId,
+          message: "Batch insertion conflicted without a durable replay receipt.",
+        });
     }
 
     yield* executionConflict(executions.rejectSuperseded(request));
@@ -671,9 +892,11 @@ const makeJournal = Effect.fnUntraced(function* (
       });
     }
 
-    const firstSequence = yield* Schema.decodeEffect(CanonicalSequence)(
-      thread.tail_sequence + (request.records.length === 0 ? 0 : 1),
-    ).pipe(
+    const result = yield* Schema.decodeEffect(AppendResult)({
+      firstSequence: thread.tail_sequence + (request.records.length === 0 ? 0 : 1),
+      lastSequence: thread.tail_sequence + request.records.length,
+      replayed: false,
+    }).pipe(
       Effect.mapError((error) =>
         DoStorageError.make({
           cause: error,
@@ -683,27 +906,29 @@ const makeJournal = Effect.fnUntraced(function* (
       ),
     );
 
-    const lastSequence = yield* Schema.decodeEffect(CanonicalSequence)(
-      thread.tail_sequence + request.records.length,
-    ).pipe(
-      Effect.mapError((error) =>
-        DoStorageError.make({
-          cause: error,
-          operation: "append canonical batch",
-          message: error.message,
-        }),
-      ),
-    );
+    const { firstSequence, lastSequence } = result;
 
     yield* executionConflict(executions.validate(request));
 
-    const result = RawAppendResult.make({
-      firstSequence,
-      lastSequence,
-      replayed: false,
-    });
+    if (yield* appendNativeBody(request, firstSequence, lastSequence, inserted.length > 0)) {
+      yield* progress.committed("canonical").pipe(
+        Effect.catchCause((cause) =>
+          Effect.failCause(
+            Cause.map(cause, (error) =>
+              DoStorageError.make({
+                operation: "enroll canonical progress",
+                message: error.message,
+                cause: error,
+              }),
+            ),
+          ),
+        ),
+      );
 
-    if (request.records.length > 0) {
+      return result;
+    }
+
+    if (request.records.length > 0 && inserted.length === 0) {
       yield* sql`
           INSERT INTO effect_agent_canonical_batches (
             thread_id,
@@ -760,6 +985,7 @@ const makeJournal = Effect.fnUntraced(function* (
         recordCache.put(
           RecordRow.make({
             ...row,
+            thread_id: request.threadId,
             record_id: record.recordId,
             batch_id: request.batchId,
             record_json: record.recordJson,
@@ -874,7 +1100,7 @@ const makeJournal = Effect.fnUntraced(function* (
     function* (
       request: RawAppendRequest,
       observed: ThreadRow,
-    ): Effect.fn.Return<RawAppendResult, AppendError> {
+    ): Effect.fn.Return<AppendResult, AppendError> {
       yield* prepareAppend(request);
       // The facade already read this tail. Reject a known stale writer without opening a
       // transaction; a matching tail is still checked atomically below. Replays precede tail
@@ -898,10 +1124,9 @@ const makeJournal = Effect.fnUntraced(function* (
         }
       }
 
-      return yield* withWriteTransaction(
-        "append transaction",
-        isAppendContention,
-      )(appendPrepared(request));
+      // Receipt arbitration may have tentatively inserted a batch. Even typed
+      // contention must roll back before leaving the owner mutation gate.
+      return yield* withWriteTransaction("append transaction")(appendPrepared(request));
     },
     withStorageSpan("DoJournal.append", isAppendContention),
   );
@@ -1348,4 +1573,27 @@ const makeJournal = Effect.fnUntraced(function* (
 
 export type DoJournal = Effect.Success<ReturnType<typeof makeJournal>>;
 
-export const initializeDoJournal = ensureCurrentStorage;
+const InitializedDoJournal = Context.Reference<DoJournal | undefined>(
+  "@effect-agent/storage-cloudflare/InitializedDoJournal",
+  { defaultValue: () => undefined },
+);
+
+/** Build once in the common owner, SQL, configuration, failpoint and lifecycle context. */
+export const initializedDoJournalLayer = Layer.effect(InitializedDoJournal)(
+  Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    const config = yield* DoStorageConfig;
+    const failpoint = yield* DoStorageFailpoint;
+
+    return yield* ensureCurrentStorage(sql, failpoint.hit, config.maxStoredValueBytes);
+  }),
+);
+
+export const initializeDoJournal = (
+  sql: SqlClient.SqlClient,
+  failpoint: DoJournalFailpoint,
+  maxStoredValueBytes: number,
+) =>
+  Effect.filterOrElse(InitializedDoJournal, Predicate.isNotUndefined, () =>
+    ensureCurrentStorage(sql, failpoint, maxStoredValueBytes),
+  );

package/src/internal/migrations.ts

@@ -6,7 +6,8 @@ import {
 import { createSqlThreadWorkTables } from "@yielded/agent-storage-sql/sql-thread-work";
 import { makeSqliteLayoutInspection } from "@yielded/agent-storage-sql/sqlite-layout-inspection";
 import { CURRENT_RECORD_FORMAT } from "@yielded/agent/records";
-import { Effect, Schema } from "effect";
+import { SqlStorageOwner } from "@yielded/agent/sql-memory-store";
+import { Effect, Option, Schema } from "effect";
 import * as SqlClient from "effect/sql/SqlClient";
 import type { SqlError } from "effect/sql/SqlError";
 
@@ -16,7 +17,7 @@ import {
   DoStorageError,
 } from "../DoStorageError.ts";
 
-export const CurrentDoStorageVersion = 27;
+export const CurrentDoStorageVersion = 28;
 
 /** Fresh layout only. Unsupported stores are rejected before these statements execute. */
 const layoutStatements = [
@@ -70,7 +71,6 @@ const layoutStatements = [
   "CREATE TABLE effect_agent_archive_batches (thread_id TEXT NOT NULL, batch_id TEXT NOT NULL, range_first_sequence INTEGER NOT NULL, batch_json TEXT NOT NULL, PRIMARY KEY (thread_id, batch_id), FOREIGN KEY (thread_id, batch_id) REFERENCES effect_agent_canonical_batches(thread_id, batch_id) ON DELETE RESTRICT, CONSTRAINT effect_agent_archive_batches_range_fkey FOREIGN KEY (thread_id, range_first_sequence) REFERENCES effect_agent_journal_ranges(thread_id, first_sequence) ON DELETE RESTRICT)",
   "CREATE TABLE effect_agent_archive_records (thread_id TEXT NOT NULL, sequence INTEGER NOT NULL, range_first_sequence INTEGER NOT NULL, record_json TEXT NOT NULL, PRIMARY KEY (thread_id, sequence), FOREIGN KEY (thread_id, sequence) REFERENCES effect_agent_canonical_records(thread_id, sequence) ON DELETE RESTRICT, CONSTRAINT effect_agent_archive_records_range_fkey FOREIGN KEY (thread_id, range_first_sequence) REFERENCES effect_agent_journal_ranges(thread_id, first_sequence) ON DELETE RESTRICT)",
   "CREATE UNIQUE INDEX effect_agent_canonical_batches_sequence ON effect_agent_canonical_batches(thread_id, first_sequence)",
-  "CREATE INDEX effect_agent_canonical_batches_last ON effect_agent_canonical_batches(thread_id, last_sequence)",
   "CREATE TABLE effect_agent_live_child_reservations (reservation_id TEXT PRIMARY KEY NOT NULL, thread_id TEXT NOT NULL)",
   "CREATE INDEX effect_agent_live_child_reservations_thread ON effect_agent_live_child_reservations(thread_id, reservation_id)",
   // Compact native positions keep accepted identities out of bounded export cursors.
@@ -141,10 +141,15 @@ const inspection = (version: number, statements: ReadonlyArray<string>) =>
 // Released predecessors retain the same record format and canonical tables.
 const addedIndexes = new Set(["effect_agent_message_deliveries_peer_retained"]);
 
-const layout25Statements = layoutObjects(layoutStatements)
+const layout27Statements = [
+  ...layoutStatements,
+  "CREATE INDEX effect_agent_canonical_batches_last ON effect_agent_canonical_batches(thread_id, last_sequence)",
+];
+
+const layout25Statements = layoutObjects(layout27Statements)
   .filter(([, name]) => !addedIndexes.has(name))
   .map(([, , index]) =>
-    layoutStatements[index]
+    layout27Statements[index]
       .replace(", peer_retained_until_millis INTEGER", "")
       .replace(
         "'$.envelope.messageAdmission.peerName') IS NOT NULL",
@@ -154,7 +159,8 @@ const layout25Statements = layoutObjects(layoutStatements)
 
 const { decode, readObjects, readHeader } = inspection(CurrentDoStorageVersion, layoutStatements);
 const layout25 = inspection(25, layout25Statements);
-const layout26 = inspection(26, layoutStatements);
+const layout26 = inspection(26, layout27Statements);
+const layout27 = inspection(27, layout27Statements);
 
 const inspectStorage = Effect.fnUntraced(function* (
   allowUpgrade = false,
@@ -185,10 +191,10 @@ const inspectStorage = Effect.fnUntraced(function* (
 
   const version = legacy.value;
 
-  if (allowUpgrade && (version === 25 || version === 26)) {
+  if (allowUpgrade && (version === 25 || version === 26 || version === 27)) {
     if (version === 25 && objects.some(({ name }) => addedIndexes.has(name)))
       return yield* incompatible(version, "Mixed layout 25 and 26 objects.");
-    const predecessor = version === 25 ? layout25 : layout26;
+    const predecessor = version === 25 ? layout25 : version === 26 ? layout26 : layout27;
     const header = yield* predecessor.readHeader(objects, version);
 
     yield* predecessor.readManagedTriggers(true);
@@ -209,8 +215,8 @@ export const readDoStorageHeader = Effect.fnUntraced(function* () {
   return header;
 });
 
-/** Initialize fresh storage or atomically upgrade the exact released layouts 25 and 26. */
-export const ensureDoStorageLayout = Effect.fn("DoStorage.initializeLayout")(function* () {
+/** Initialize fresh storage or atomically upgrade the exact released layouts 25–27. */
+const initializeDoStorageLayout = Effect.fn("DoStorage.initializeLayout")(function* () {
   const sql = (yield* SqlClient.SqlClient).withoutTransforms();
 
   return yield* sql
@@ -244,6 +250,9 @@ export const ensureDoStorageLayout = Effect.fn("DoStorage.initializeLayout")(fun
               }),
             ),
           );
+        }
+        if (header !== undefined && header.layoutVersion < CurrentDoStorageVersion) {
+          yield* sql`DROP INDEX effect_agent_canonical_batches_last`;
           yield* sql`UPDATE effect_agent_schema SET layout_version=${CurrentDoStorageVersion} WHERE singleton=1`;
           yield* sql`UPDATE effect_agent_meta SET value=${String(CurrentDoStorageVersion)} WHERE key='storage_version'`;
 
@@ -269,3 +278,36 @@ export const ensureDoStorageLayout = Effect.fn("DoStorage.initializeLayout")(fun
     )
     .pipe(Effect.catchTag("SqlError", storageError));
 });
+
+const initializedLayouts = new WeakMap<object, DoStorageHeader>();
+
+/** Share committed inspection within one live Object owner; maintenance invalidates it. */
+export const ensureDoStorageLayout = Effect.fnUntraced(function* () {
+  const sql = yield* SqlClient.SqlClient;
+  const owner = yield* SqlStorageOwner;
+
+  // A caller-owned transaction can still roll back after this initializer returns.
+  if (owner === undefined || Option.isSome(yield* Effect.serviceOption(sql.transactionService)))
+    return yield* initializeDoStorageLayout();
+
+  const identity = owner.identity ?? owner;
+
+  return yield* owner.read(
+    Effect.gen(function* () {
+      const previous = initializedLayouts.get(identity);
+
+      if (previous !== undefined) return previous;
+      const header = yield* initializeDoStorageLayout();
+
+      const invalidate = () => {
+        initializedLayouts.delete(identity);
+        owner.invalidators.delete(invalidate);
+      };
+
+      initializedLayouts.set(identity, header);
+      owner.invalidators.add(invalidate);
+
+      return header;
+    }),
+  );
+});

package/src/internal/owned-state.ts

@@ -156,7 +156,7 @@ export const ownedRows = <A, I>(
 
     const decode = (rows: unknown) =>
       decodeRows(rows).pipe(
-        Effect.mapError(() =>
+        Effect.mapErrorEager(() =>
           DoStorageCorruptionError.make({
             table,
             rowKey: "owned-state",
@@ -200,9 +200,8 @@ export const ownedRows = <A, I>(
 
           if (view !== undefined) return Effect.succeed(view.rows);
 
-          return query.pipe(
-            Effect.flatMap(decode),
-            Effect.map((rows) => {
+          return Effect.flatMap(query, (rows) =>
+            Effect.mapEager(decode(rows), (rows) => {
               retain(id, matches, rows, maxRows);
 
               return rows;
@@ -277,6 +276,14 @@ export const ownedRows = <A, I>(
           return rows;
         });
 
-    return { by, byFields, matching, seed, write: apply(false), remove: apply(true) };
+    return {
+      by,
+      byFields,
+      matching,
+      seed,
+      seedMatching: retain,
+      write: apply(false),
+      remove: apply(true),
+    };
   };
 };