@yielded/agent-storage-cloudflare 0.1.0-beta.173 → 0.1.0-beta.175

package/src/DoThreadStore.ts

@@ -18,7 +18,6 @@ import { ThreadImport } from "@yielded/agent/thread-import";
 import {
   type ThreadExportRequest,
   AppendConflict,
-  AppendResult,
   CheckpointRejected,
   ThreadCheckpoint,
   ThreadMaterialization,
@@ -104,6 +103,11 @@ const isDoCheckpointConflict = Schema.is(DoCheckpointConflict);
 const ThreadCheckpointJson = Schema.fromJsonString(ThreadCheckpoint);
 const decodeCanonicalRecord = decodeExportRecordJson;
 
+const decodeThreadMaterializationType = Schema.decodeEffect(Schema.toType(ThreadMaterialization));
+const decodeThreadReadRequestType = Schema.decodeEffect(Schema.toType(ThreadReadRequest));
+const decodeThreadTailRequestType = Schema.decodeEffect(Schema.toType(ThreadTailRequest));
+const decodeStorageConfig = Schema.decodeEffect(DoStorageConfigValue);
+
 const storeError = (
   operation: string,
   error: { readonly message: string; readonly diagnostic?: ThreadStoreDiagnostic },
@@ -126,19 +130,6 @@ const schemaStoreError = (operation: string, error: Schema.SchemaError) =>
     }),
   });
 
-const makeOffset = (
-  threadId: ThreadMaterialization["threadId"],
-  sequence: number,
-): Effect.Effect<ObservationOffset, ThreadStoreError> =>
-  Schema.decodeEffect(CanonicalSequence)(sequence).pipe(
-    Effect.flatMap((validatedSequence) =>
-      Schema.decodeEffect(ObservationOffset)(
-        `${DO_OFFSET_PREFIX}${encodeURIComponent(threadId)}:${validatedSequence}`,
-      ),
-    ),
-    Effect.mapError((error) => schemaStoreError("encode observation offset", error)),
-  );
-
 const parseOffset = Effect.fnUntraced(function* (
   threadId: ThreadMaterialization["threadId"],
   offset: ObservationOffset | undefined,
@@ -179,8 +170,8 @@ const encodeCheckpoint = (checkpoint: ThreadCheckpoint): Effect.Effect<string, T
 const envelopes = new WeakMap<object, CanonicalRecordEnvelope>();
 
 const decodeEnvelope = Effect.fnUntraced(function* (row: {
-  readonly batch_id: string;
-  readonly thread_id: string;
+  readonly batch_id: CanonicalRecordEnvelope["batchId"];
+  readonly thread_id: CanonicalRecordEnvelope["threadId"];
   readonly record_json: string;
   readonly sequence: CanonicalSequence;
 }) {
@@ -213,17 +204,13 @@ const decodeEnvelope = Effect.fnUntraced(function* (row: {
     ),
   );
 
-  const threadId = yield* Schema.decodeEffect(CanonicalRecordEnvelope.fields.threadId)(
-    row.thread_id,
-  ).pipe(Effect.mapError((error) => schemaStoreError("decode thread identity", error)));
+  const { thread_id: threadId, batch_id: batchId } = row;
 
-  const offset = yield* makeOffset(threadId, row.sequence);
-
-  const batchId = yield* Schema.decodeEffect(CanonicalRecordEnvelope.fields.batchId)(
-    row.batch_id,
-  ).pipe(Effect.mapError((error) => schemaStoreError("decode batch identity", error)));
+  const offset = ObservationOffset.make(
+    `${DO_OFFSET_PREFIX}${encodeURIComponent(threadId)}:${row.sequence}`,
+  );
 
-  const envelope = new CanonicalRecordEnvelope(
+  const envelope = CanonicalRecordEnvelope.make(
     { threadId, batchId, sequence: row.sequence, offset, record },
     { disableChecks: true },
   );
@@ -317,9 +304,9 @@ const makeServices = Effect.fnUntraced(function* () {
   const materialize: ThreadStore["Service"]["materialize"] = Effect.fnUntraced(function* (
     request: ThreadMaterialization,
   ) {
-    const validated = yield* Schema.decodeEffect(Schema.toType(ThreadMaterialization))(
-      request,
-    ).pipe(Effect.mapError((error) => schemaStoreError("validate materialization", error)));
+    const validated = yield* decodeThreadMaterializationType(request).pipe(
+      Effect.mapError((error) => schemaStoreError("validate materialization", error)),
+    );
 
     const now = yield* Clock.currentTimeMillis;
 
@@ -362,11 +349,6 @@ const makeServices = Effect.fnUntraced(function* () {
 
             return storeError("append canonical batch", error);
           }),
-          Effect.flatMap((result) =>
-            Schema.decodeEffect(AppendResult)(result).pipe(
-              Effect.mapError((error) => schemaStoreError("decode append result", error)),
-            ),
-          ),
         );
 
       yield* hitFailpoint("append:after");
@@ -391,7 +373,7 @@ const makeServices = Effect.fnUntraced(function* () {
   });
 
   const readEffect = Effect.fnUntraced(function* (request: ThreadReadRequest) {
-    const validated = yield* Schema.decodeEffect(Schema.toType(ThreadReadRequest))(request).pipe(
+    const validated = yield* decodeThreadReadRequestType(request).pipe(
       Effect.mapError((error) => schemaStoreError("validate thread read", error)),
     );
 
@@ -473,17 +455,20 @@ const makeServices = Effect.fnUntraced(function* () {
     offsetPrefix: DO_OFFSET_PREFIX,
     maxValueBytes: config.maxStoredValueBytes,
     // Import establishes a new sequence space; discard derivatives in this same transaction.
-    afterImport: ({ result }) =>
-      Effect.gen(function* () {
+    afterImport: Effect.fnUntraced(
+      function* ({ result }) {
         const prefix = promptCheckpointPrefix(result.threadId);
 
         yield* sql`DELETE FROM effect_agent_meta WHERE key >= ${prefix} AND key < ${prefix + "~"}`;
         // Closed imported history must not emit historical lifecycle notifications again.
         if (journal.lifecycle !== undefined)
           yield* sql`INSERT INTO effect_agent_lifecycle_cursors(thread_id, through_sequence) VALUES (${result.threadId}, ${result.tailSequence})`;
-      }).pipe(
-        Effect.catchTag("SqlError", (cause) => storeError("rebuild imported derivatives", cause)),
-      ),
+      },
+      (effect) =>
+        effect.pipe(
+          Effect.catchTag("SqlError", (cause) => storeError("rebuild imported derivatives", cause)),
+        ),
+    ),
     afterThreadRead: hitFailpoint("export:after-thread-read"),
     read: (body) =>
       journal.owner.transaction(body).pipe(
@@ -500,7 +485,7 @@ const makeServices = Effect.fnUntraced(function* () {
   const inspectTail: ThreadStore["Service"]["inspectTail"] = Effect.fnUntraced(function* (
     request: ThreadTailRequest,
   ) {
-    const validated = yield* Schema.decodeEffect(Schema.toType(ThreadTailRequest))(request).pipe(
+    const validated = yield* decodeThreadTailRequestType(request).pipe(
       Effect.mapError((error) => schemaStoreError("validate tail inspection", error)),
     );
 
@@ -599,15 +584,7 @@ const makeServices = Effect.fnUntraced(function* () {
       snapshot: journal.state.read,
       tail: (threadId) =>
         journal.getThread(threadId).pipe(
-          Effect.flatMap((rows) =>
-            Schema.decodeEffect(
-              Schema.UndefinedOr(
-                Schema.Struct({
-                  tail_sequence: CanonicalSequence,
-                }),
-              ),
-            )(rows[0]),
-          ),
+          Effect.map((rows) => rows[0]),
           Effect.mapError((error) => storeError("native thread tail", error)),
         ),
     }),
@@ -665,7 +642,7 @@ export const storageConfigLayer = (
   options: DoStorageOptions,
 ): Layer.Layer<DoStorageConfig, DoStorageError> =>
   Layer.effect(DoStorageConfig)(
-    Schema.decodeEffect(DoStorageConfigValue)({
+    decodeStorageConfig({
       observationPollInterval: options.observationPollInterval ?? 25,
       maxStoredValueBytes: options.maxStoredValueBytes ?? DEFAULT_MAX_STORED_VALUE_BYTES,
       verifyOnOpen: options.verifyOnOpen ?? false,

package/src/PortRouting.ts

@@ -570,9 +570,9 @@ const makeRoutedLedgerServices = Effect.fnUntraced(function* (options: RoutedPor
   const routed = SubmissionLedger.of({
     capabilities: local.capabilities,
 
-    admit: (request) =>
+    admit: (request, admissionOptions) =>
       options.ownsThread(request.threadId)
-        ? local.admit(request)
+        ? local.admit(request, admissionOptions)
         : foreignLedgerCall(
             "ledger admit",
             request.threadId,
@@ -824,6 +824,7 @@ const makeRoutedLedgerServices = Effect.fnUntraced(function* (options: RoutedPor
 
     // The local scan IS the whole worklist: one Thread per Object (durability §5).
     scanNonterminal: local.scanNonterminal,
+    ...(local.listNonterminal === undefined ? {} : { listNonterminal: local.listNonterminal }),
 
     readAbortIntent: (request) =>
       submissionTarget("ledger read abort intent", request.submissionId).pipe(
@@ -1046,6 +1047,13 @@ const makeRoutedStoreServices = Effect.fnUntraced(function* (options: RoutedPort
             ).pipe(Effect.map((reply) => reply.range)),
     },
     work: {
+      isOnlyFreshAdmission: (request) => {
+        const prove = local.work?.isOnlyFreshAdmission;
+
+        return prove !== undefined && options.ownsThread(request.threadId)
+          ? prove(request)
+          : Effect.succeed(false);
+      },
       threads: (request) =>
         Effect.flatMap(CurrentNativeSource, (nativeSource) =>
           nativeSource && local.work !== undefined

package/src/internal/canonical-append.ts

@@ -7,7 +7,7 @@ export const DO_OFFSET_PREFIX = "effect-agent-do@1:";
 
 /** Prepare the publisher's privately captured canonical request before the writer. */
 export const prepareCanonicalAppend = Effect.fnUntraced(function* (input: AppendRequest) {
-  const request = yield* PreparedAppend.capture(input);
+  const request: PreparedAppend = yield* PreparedAppend.capture(input);
 
   const raw = yield* prepareSqlAppend(request, DO_OFFSET_PREFIX);