@effect-agent/storage-sqlite 0.1.0-beta.84 → 0.1.0-beta.86

package/src/SqliteSubmissionLedger.ts

@@ -1,5 +1,8 @@
-import { MessageAdmission } from "@effect-agent/core/Messaging";
-import { EMPTY_TAIL_DIGEST } from "@effect-agent/thread/Digest";
+import { NodeCrypto } from "@effect/platform-node";
+import { SqliteClient } from "@effect/sql-sqlite-node";
+import { Clock, Context, Crypto, DateTime, Effect, Layer, Option, Schema, Stream } from "effect";
+import { EMPTY_TAIL_DIGEST } from "effect-agent/digest";
+import { InputMessage } from "effect-agent/messaging";
 import {
   ApprovalDecision,
   CanonicalSequence,
@@ -10,7 +13,7 @@ import {
   ProducerEpoch,
   RecordEnvelope,
   SettlementOutcome,
-} from "@effect-agent/thread/Records";
+} from "effect-agent/records";
 import {
   AbortCommand,
   AbortIntent,
@@ -82,10 +85,7 @@ import {
   submissionAbortRecordId,
   type ChildSettledOutcome,
   type SuspensionOutcome,
-} from "@effect-agent/thread/SubmissionLedger";
-import { NodeCrypto } from "@effect/platform-node";
-import { SqliteClient } from "@effect/sql-sqlite-node";
-import { Clock, Context, Crypto, DateTime, Effect, Layer, Option, Schema, Stream } from "effect";
+} from "effect-agent/submission-ledger";
 import * as SqlClientService from "effect/unstable/sql/SqlClient";
 import type { SqlError } from "effect/unstable/sql/SqlError";
 
@@ -514,9 +514,9 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
     if (Option.isNone(ownership) || ownership.value.ownership_token !== ownershipToken) {
       const actualEpoch = yield* threadEpoch(operation, submission.thread_id);
 
-      const submissionId = yield* Schema.decodeUnknownEffect(
-        SubmissionSnapshot.fields.submissionId,
-      )(submission.submission_id).pipe(Effect.mapError(internalFailure(operation)));
+      const submissionId = yield* Schema.decodeEffect(SubmissionSnapshot.fields.submissionId)(
+        submission.submission_id,
+      ).pipe(Effect.mapError(internalFailure(operation)));
 
       return yield* OwnershipLost.make({ submissionId, actualEpoch });
     }
@@ -995,9 +995,9 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
     function* (request: AdmissionRequest) {
       const operation = "ledger admit";
 
-      const validated = yield* Schema.decodeUnknownEffect(Schema.toType(AdmissionRequest))(
-        request,
-      ).pipe(Effect.mapError(internalFailure(operation)));
+      const validated = yield* Schema.decodeEffect(Schema.toType(AdmissionRequest))(request).pipe(
+        Effect.mapError(internalFailure(operation)),
+      );
 
       const inputJson = yield* encodePersistedJsonText(validated.inputPayload).pipe(
         Effect.mapError(internalFailure(operation)),
@@ -1023,7 +1023,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
       const messageAdmissionJson =
         validated.messageAdmission === undefined
           ? null
-          : yield* Schema.encodeEffect(Schema.fromJsonString(MessageAdmission))(
+          : yield* Schema.encodeEffect(Schema.fromJsonString(InputMessage))(
               validated.messageAdmission,
             ).pipe(Effect.mapError(internalFailure(operation)));
 
@@ -1096,10 +1096,10 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
                     existing[0].worker_admission_json,
                   ).pipe(Effect.mapError(internalFailure(operation)));
 
-            const retainedMessageAdmission =
+            const retainedInputMessage =
               existing[0].message_admission_json === null
                 ? undefined
-                : yield* Schema.decodeEffect(Schema.fromJsonString(MessageAdmission))(
+                : yield* Schema.decodeEffect(Schema.fromJsonString(InputMessage))(
                     existing[0].message_admission_json,
                   ).pipe(Effect.mapError(internalFailure(operation)));
 
@@ -1116,8 +1116,8 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
                 retainedWorkerAdmission,
                 validated.workerAdmission,
               ) ||
-              !Schema.toEquivalence(Schema.optional(MessageAdmission))(
-                retainedMessageAdmission,
+              !Schema.toEquivalence(Schema.optional(InputMessage))(
+                retainedInputMessage,
                 validated.messageAdmission,
               ) ||
               !Schema.toEquivalence(Schema.optional(AdmissionFence))(
@@ -1275,9 +1275,9 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
   )(function* (request: MarkReadyRequest) {
     const operation = "ledger mark ready";
 
-    const validated = yield* Schema.decodeUnknownEffect(Schema.toType(MarkReadyRequest))(
-      request,
-    ).pipe(Effect.mapError(internalFailure(operation)));
+    const validated = yield* Schema.decodeEffect(Schema.toType(MarkReadyRequest))(request).pipe(
+      Effect.mapError(internalFailure(operation)),
+    );
 
     yield* hitFailpoint("ledger:mark-ready:before", operation);
     yield* inWriteTransaction(
@@ -1302,9 +1302,9 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
     function* (request: SubmissionLookup) {
       const operation = "ledger lookup";
 
-      const validated = yield* Schema.decodeUnknownEffect(Schema.toType(SubmissionLookup))(
-        request,
-      ).pipe(Effect.mapError(internalFailure(operation)));
+      const validated = yield* Schema.decodeEffect(Schema.toType(SubmissionLookup))(request).pipe(
+        Effect.mapError(internalFailure(operation)),
+      );
 
       if (validated._tag === "SubmissionLookupById") {
         const row = yield* readSubmission(operation, validated.submissionId);
@@ -1350,7 +1350,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
   )(function* (request: SubmissionLookupByKey) {
     const operation = "ledger resolve admission";
 
-    const validated = yield* Schema.decodeUnknownEffect(Schema.toType(SubmissionLookupByKey))(
+    const validated = yield* Schema.decodeEffect(Schema.toType(SubmissionLookupByKey))(
       request,
     ).pipe(Effect.mapError(internalFailure(operation)));
 
@@ -1387,9 +1387,9 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
     function* (request: ClaimRequest) {
       const operation = "ledger claim";
 
-      const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ClaimRequest))(
-        request,
-      ).pipe(Effect.mapError(internalFailure(operation)));
+      const validated = yield* Schema.decodeEffect(Schema.toType(ClaimRequest))(request).pipe(
+        Effect.mapError(internalFailure(operation)),
+      );
 
       const attemptId = yield* mintIdentifier("attempt", operation);
       const ownershipToken = yield* mintIdentifier("owner", operation);
@@ -1563,7 +1563,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
   )(function* (request: RenewOwnershipRequest) {
     const operation = "ledger renew ownership";
 
-    const validated = yield* Schema.decodeUnknownEffect(Schema.toType(RenewOwnershipRequest))(
+    const validated = yield* Schema.decodeEffect(Schema.toType(RenewOwnershipRequest))(
       request,
     ).pipe(Effect.mapError(internalFailure(operation)));
 
@@ -1601,7 +1601,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
   )(function* (request: ReleaseOwnershipRequest) {
     const operation = "ledger release ownership";
 
-    const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ReleaseOwnershipRequest))(
+    const validated = yield* Schema.decodeEffect(Schema.toType(ReleaseOwnershipRequest))(
       request,
     ).pipe(Effect.mapError(internalFailure(operation)));
 
@@ -1633,7 +1633,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
   )(function* (request: MarkInputAppliedRequest) {
     const operation = "ledger mark input applied";
 
-    const validated = yield* Schema.decodeUnknownEffect(Schema.toType(MarkInputAppliedRequest))(
+    const validated = yield* Schema.decodeEffect(Schema.toType(MarkInputAppliedRequest))(
       request,
     ).pipe(Effect.mapError(internalFailure(operation)));
 
@@ -1680,7 +1680,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
   )(function* (request: SettlementReservation) {
     const operation = "ledger reserve settlement";
 
-    const validated = yield* Schema.decodeUnknownEffect(Schema.toType(SettlementReservation))(
+    const validated = yield* Schema.decodeEffect(Schema.toType(SettlementReservation))(
       request,
     ).pipe(Effect.mapError(internalFailure(operation)));
 
@@ -1891,7 +1891,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
   )(function* (request: SettlementFinalization) {
     const operation = "ledger finalize settlement";
 
-    const validated = yield* Schema.decodeUnknownEffect(Schema.toType(SettlementFinalization))(
+    const validated = yield* Schema.decodeEffect(Schema.toType(SettlementFinalization))(
       request,
     ).pipe(Effect.mapError(internalFailure(operation)));
 
@@ -1998,7 +1998,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
   )(function* (request: AbortCommand) {
     const operation = "ledger request abort";
 
-    const validated = yield* Schema.decodeUnknownEffect(Schema.toType(AbortCommand))(request).pipe(
+    const validated = yield* Schema.decodeEffect(Schema.toType(AbortCommand))(request).pipe(
       Effect.mapError(internalFailure(operation)),
     );
 
@@ -2098,9 +2098,9 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
   )(function* (request: ClaimJoiningRequest) {
     const operation = "ledger claim joining";
 
-    const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ClaimJoiningRequest))(
-      request,
-    ).pipe(Effect.mapError(internalFailure(operation)));
+    const validated = yield* Schema.decodeEffect(Schema.toType(ClaimJoiningRequest))(request).pipe(
+      Effect.mapError(internalFailure(operation)),
+    );
 
     yield* hitFailpoint("ledger:claim-joining:before", operation);
 
@@ -2186,9 +2186,9 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
   )(function* (request: MarkJoinedRequest) {
     const operation = "ledger mark joined";
 
-    const validated = yield* Schema.decodeUnknownEffect(Schema.toType(MarkJoinedRequest))(
-      request,
-    ).pipe(Effect.mapError(internalFailure(operation)));
+    const validated = yield* Schema.decodeEffect(Schema.toType(MarkJoinedRequest))(request).pipe(
+      Effect.mapError(internalFailure(operation)),
+    );
 
     yield* hitFailpoint("ledger:mark-joined:before", operation);
     yield* inWriteTransaction(
@@ -2246,9 +2246,9 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
   )(function* (request: RevertJoiningRequest) {
     const operation = "ledger revert joining";
 
-    const validated = yield* Schema.decodeUnknownEffect(Schema.toType(RevertJoiningRequest))(
-      request,
-    ).pipe(Effect.mapError(internalFailure(operation)));
+    const validated = yield* Schema.decodeEffect(Schema.toType(RevertJoiningRequest))(request).pipe(
+      Effect.mapError(internalFailure(operation)),
+    );
 
     yield* hitFailpoint("ledger:revert-joining:before", operation);
     yield* inWriteTransaction(
@@ -2274,9 +2274,9 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
   )(function* (request: SuspendRequest) {
     const operation = "ledger suspend";
 
-    const validated = yield* Schema.decodeUnknownEffect(Schema.toType(SuspendRequest))(
-      request,
-    ).pipe(Effect.mapError(internalFailure(operation)));
+    const validated = yield* Schema.decodeEffect(Schema.toType(SuspendRequest))(request).pipe(
+      Effect.mapError(internalFailure(operation)),
+    );
 
     const reasonJson = yield* encodeSuspensionReasonText(validated.reason).pipe(
       Effect.mapError(internalFailure(operation)),
@@ -2410,7 +2410,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
   )(function* (command: ApprovalDecisionCommand) {
     const operation = "ledger record approval decision";
 
-    const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ApprovalDecisionCommand))(
+    const validated = yield* Schema.decodeEffect(Schema.toType(ApprovalDecisionCommand))(
       command,
     ).pipe(Effect.mapError(internalFailure(operation)));
 
@@ -2494,9 +2494,9 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
   )(function* (request: MarkUnknownRequest) {
     const operation = "ledger mark unknown";
 
-    const validated = yield* Schema.decodeUnknownEffect(Schema.toType(MarkUnknownRequest))(
-      request,
-    ).pipe(Effect.mapError(internalFailure(operation)));
+    const validated = yield* Schema.decodeEffect(Schema.toType(MarkUnknownRequest))(request).pipe(
+      Effect.mapError(internalFailure(operation)),
+    );
 
     yield* hitFailpoint("ledger:mark-unknown:before", operation);
     yield* inWriteTransaction(
@@ -2561,7 +2561,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
   )(function* (command: UnknownResolutionCommand) {
     const operation = "ledger record unknown resolution";
 
-    const validated = yield* Schema.decodeUnknownEffect(Schema.toType(UnknownResolutionCommand))(
+    const validated = yield* Schema.decodeEffect(Schema.toType(UnknownResolutionCommand))(
       command,
     ).pipe(Effect.mapError(internalFailure(operation)));
 
@@ -2682,7 +2682,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
   )(function* (request: ChildSettledNotification) {
     const operation = "ledger record child settled";
 
-    const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ChildSettledNotification))(
+    const validated = yield* Schema.decodeEffect(Schema.toType(ChildSettledNotification))(
       request,
     ).pipe(Effect.mapError(internalFailure(operation)));
 
@@ -2772,9 +2772,9 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
   )(function* (request: ChildBudgetReservationRequest) {
     const operation = "ledger reserve child budget";
 
-    const validated = yield* Schema.decodeUnknownEffect(
-      Schema.toType(ChildBudgetReservationRequest),
-    )(request).pipe(Effect.mapError(internalFailure(operation)));
+    const validated = yield* Schema.decodeEffect(Schema.toType(ChildBudgetReservationRequest))(
+      request,
+    ).pipe(Effect.mapError(internalFailure(operation)));
 
     const allocationJson = yield* encodePersistedJsonText(validated.allocation).pipe(
       Effect.mapError(internalFailure(operation)),
@@ -2884,9 +2884,9 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
     ) {
       const operation = "ledger attach child to reservation";
 
-      const validated = yield* Schema.decodeUnknownEffect(
-        Schema.toType(AttachChildToReservationRequest),
-      )(request).pipe(Effect.mapError(internalFailure(operation)));
+      const validated = yield* Schema.decodeEffect(Schema.toType(AttachChildToReservationRequest))(
+        request,
+      ).pipe(Effect.mapError(internalFailure(operation)));
 
       yield* hitFailpoint("ledger:child-attach:before", operation);
 
@@ -2963,9 +2963,9 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
   )(function* (request: BeginChildBudgetReleaseRequest) {
     const operation = "ledger begin child budget release";
 
-    const validated = yield* Schema.decodeUnknownEffect(
-      Schema.toType(BeginChildBudgetReleaseRequest),
-    )(request).pipe(Effect.mapError(internalFailure(operation)));
+    const validated = yield* Schema.decodeEffect(Schema.toType(BeginChildBudgetReleaseRequest))(
+      request,
+    ).pipe(Effect.mapError(internalFailure(operation)));
 
     const accountingJson = yield* encodePersistedJsonText(validated.accounting).pipe(
       Effect.mapError(internalFailure(operation)),
@@ -3040,7 +3040,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
   )(function* (request: ReleaseChildBudgetRequest) {
     const operation = "ledger release child budget";
 
-    const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ReleaseChildBudgetRequest))(
+    const validated = yield* Schema.decodeEffect(Schema.toType(ReleaseChildBudgetRequest))(
       request,
     ).pipe(Effect.mapError(internalFailure(operation)));
 
@@ -3158,9 +3158,9 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
   )(function* (request) {
     const operation = "ledger read abort intent";
 
-    const validated = yield* Schema.decodeUnknownEffect(Schema.toType(AbortIntentRequest))(
-      request,
-    ).pipe(Effect.mapError(internalFailure(operation)));
+    const validated = yield* Schema.decodeEffect(Schema.toType(AbortIntentRequest))(request).pipe(
+      Effect.mapError(internalFailure(operation)),
+    );
 
     const recordId = submissionAbortRecordId(validated.submissionId);
 
@@ -3229,7 +3229,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
   )(function* (request: RecoverySnapshotRequest) {
     const operation = "ledger load recovery snapshot";
 
-    const validated = yield* Schema.decodeUnknownEffect(Schema.toType(RecoverySnapshotRequest))(
+    const validated = yield* Schema.decodeEffect(Schema.toType(RecoverySnapshotRequest))(
       request,
     ).pipe(Effect.mapError(internalFailure(operation)));
 
@@ -3278,7 +3278,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
               ),
             );
 
-            const settlementId = yield* Schema.decodeUnknownEffect(
+            const settlementId = yield* Schema.decodeEffect(
               SettlementReservationSnapshot.fields.settlementId,
             )(reservationRow.value.settlement_id).pipe(Effect.mapError(internalFailure(operation)));
 

package/src/SqliteSubscriptionStore.ts

@@ -1,13 +1,9 @@
+import { Effect, Layer, Schema } from "effect";
 import {
   makeSqlSubscriptionStore,
   SqlSubscriptionTransaction,
-} from "@effect-agent/thread/SqlSubscriptionStore";
-import {
-  SourcePartition,
-  SubscriptionError,
-  SubscriptionStore,
-} from "@effect-agent/thread/Subscription";
-import { Effect, Layer, Schema } from "effect";
+} from "effect-agent/sql-subscription-store";
+import { SourcePartition, SubscriptionError, SubscriptionStore } from "effect-agent/subscription";
 import * as SqlClientService from "effect/unstable/sql/SqlClient";
 
 import { initializeSqliteJournal } from "./internal/sqlite-journal.ts";
@@ -36,7 +32,7 @@ const transactionLayer = Layer.effect(
 const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function* (
   owned: SourcePartition,
 ) {
-  const partition = yield* Schema.decodeUnknownEffect(SourcePartition)(owned).pipe(
+  const partition = yield* Schema.decodeEffect(SourcePartition)(owned).pipe(
     Effect.mapError(() => SubscriptionError.make({ reason: "validation", code: "partition" })),
   );
 

package/src/SqliteThreadStore.ts

@@ -1,4 +1,18 @@
-import { digestCanonicalBatch, EMPTY_TAIL_DIGEST } from "@effect-agent/thread/Digest";
+import { NodeCrypto } from "@effect/platform-node";
+import { SqliteClient } from "@effect/sql-sqlite-node";
+import {
+  Clock,
+  Context,
+  Crypto,
+  Duration,
+  Effect,
+  Layer,
+  Option,
+  Ref,
+  Schema,
+  Stream,
+} from "effect";
+import { digestCanonicalBatch, EMPTY_TAIL_DIGEST } from "effect-agent/digest";
 import {
   CanonicalBatch,
   CanonicalRecord,
@@ -6,8 +20,8 @@ import {
   CanonicalSequence,
   Digest,
   ObservationOffset,
-} from "@effect-agent/thread/Records";
-import { DEFAULT_OWNERSHIP_LEASE_DURATION } from "@effect-agent/thread/SubmissionLedger";
+} from "effect-agent/records";
+import { DEFAULT_OWNERSHIP_LEASE_DURATION } from "effect-agent/submission-ledger";
 import {
   AppendConflict,
   AppendResult,
@@ -31,21 +45,7 @@ import {
   SaveRecoveryCheckpointRequest,
   MAX_THREAD_EXPORT_RECORDS,
   type ThreadRecoveryCheckpoints,
-} from "@effect-agent/thread/ThreadStore";
-import { NodeCrypto } from "@effect/platform-node";
-import { SqliteClient } from "@effect/sql-sqlite-node";
-import {
-  Clock,
-  Context,
-  Crypto,
-  Duration,
-  Effect,
-  Layer,
-  Option,
-  Ref,
-  Schema,
-  Stream,
-} from "effect";
+} from "effect-agent/thread-store";
 import type * as SqlClientService from "effect/unstable/sql/SqlClient";
 
 import {
@@ -77,7 +77,7 @@ export interface SqliteStorageOptions {
   readonly busyTimeout?: number | undefined;
   /**
    * Submission ownership lease duration in milliseconds (D5). Defaults to
-   * `DEFAULT_OWNERSHIP_LEASE_DURATION` from `@effect-agent/thread`.
+   * `DEFAULT_OWNERSHIP_LEASE_DURATION` from `effect-agent/submission-ledger`.
    */
   readonly ownershipLeaseDuration?: number | undefined;
   /**
@@ -120,9 +120,9 @@ const makeOffset = Effect.fn("SqliteThreadStore.makeOffset")(function* (
   threadId: ThreadMaterialization["threadId"],
   sequence: number,
 ): Effect.fn.Return<ObservationOffset, ThreadStoreError> {
-  return yield* Schema.decodeUnknownEffect(CanonicalSequence)(sequence).pipe(
+  return yield* Schema.decodeEffect(CanonicalSequence)(sequence).pipe(
     Effect.flatMap((validatedSequence) =>
-      Schema.decodeUnknownEffect(ObservationOffset)(
+      Schema.decodeEffect(ObservationOffset)(
         `${SQLITE_OFFSET_PREFIX}${encodeURIComponent(threadId)}:${validatedSequence}`,
       ),
     ),
@@ -136,7 +136,7 @@ const parseOffset = Effect.fn("SqliteThreadStore.parseOffset")(function* (
 ): Effect.fn.Return<CanonicalSequence, ThreadStoreError> {
   if (offset === undefined) return ZERO_CANONICAL_SEQUENCE;
 
-  const text = yield* Schema.decodeUnknownEffect(OffsetText)(offset).pipe(
+  const text = yield* Schema.decodeEffect(OffsetText)(offset).pipe(
     Effect.mapError((error) => schemaStoreError("decode observation offset", error)),
   );
 
@@ -157,7 +157,7 @@ const parseOffset = Effect.fn("SqliteThreadStore.parseOffset")(function* (
     });
   }
 
-  return yield* Schema.decodeUnknownEffect(CanonicalSequence)(Number(sequenceText)).pipe(
+  return yield* Schema.decodeEffect(CanonicalSequence)(Number(sequenceText)).pipe(
     Effect.mapError((error) => schemaStoreError("decode observation offset", error)),
   );
 });
@@ -210,13 +210,13 @@ const decodeEnvelope = Effect.fn("SqliteThreadStore.decodeEnvelope")(function* (
     ),
   );
 
-  const threadId = yield* Schema.decodeUnknownEffect(CanonicalRecordEnvelope.fields.threadId)(
+  const threadId = yield* Schema.decodeEffect(CanonicalRecordEnvelope.fields.threadId)(
     row.thread_id,
   ).pipe(Effect.mapError((error) => schemaStoreError("decode thread identity", error)));
 
   const offset = yield* makeOffset(threadId, row.sequence);
 
-  const batchId = yield* Schema.decodeUnknownEffect(CanonicalRecordEnvelope.fields.batchId)(
+  const batchId = yield* Schema.decodeEffect(CanonicalRecordEnvelope.fields.batchId)(
     row.batch_id,
   ).pipe(Effect.mapError((error) => schemaStoreError("decode batch identity", error)));
 
@@ -270,7 +270,7 @@ const tailDigestAt = Effect.fn("SqliteThreadStore.tailDigestAt")(function* (
     });
   }
 
-  return yield* Schema.decodeUnknownEffect(Digest)(digests[0]).pipe(
+  return yield* Schema.decodeEffect(Digest)(digests[0]).pipe(
     Effect.mapError((error) => schemaStoreError("decode checkpoint digest", error)),
   );
 });
@@ -511,7 +511,7 @@ const makeServices = Effect.fn("SqliteThreadStore.makeServices")(function* () {
   const materialize: ThreadStore["Service"]["materialize"] = Effect.fn(
     "SqliteThreadStore.materialize",
   )(function* (request: ThreadMaterialization) {
-    const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ThreadMaterialization))(
+    const validated = yield* Schema.decodeEffect(Schema.toType(ThreadMaterialization))(
       request,
     ).pipe(Effect.mapError((error) => schemaStoreError("validate materialization", error)));
 
@@ -538,9 +538,9 @@ const makeServices = Effect.fn("SqliteThreadStore.makeServices")(function* () {
   const append: ThreadStore["Service"]["append"] = Effect.fn("SqliteThreadStore.append")(function* (
     request: FencedAppendRequest,
   ) {
-    const validated = yield* Schema.decodeUnknownEffect(Schema.toType(FencedAppendRequest))(
-      request,
-    ).pipe(Effect.mapError((error) => schemaStoreError("validate canonical append", error)));
+    const validated = yield* Schema.decodeEffect(Schema.toType(FencedAppendRequest))(request).pipe(
+      Effect.mapError((error) => schemaStoreError("validate canonical append", error)),
+    );
 
     yield* requireThread(journal, validated.threadId);
 
@@ -559,7 +559,7 @@ const makeServices = Effect.fn("SqliteThreadStore.makeServices")(function* () {
       ),
     );
 
-    const rawRequest = yield* Schema.decodeUnknownEffect(RawAppendRequest)({
+    const rawRequest = yield* Schema.decodeEffect(RawAppendRequest)({
       threadId: validated.threadId,
       batchId: validated.batch.batchId,
       batchDigest: tailDigest,
@@ -597,7 +597,7 @@ const makeServices = Effect.fn("SqliteThreadStore.makeServices")(function* () {
         return storeError("append canonical batch", error);
       }),
       Effect.flatMap((result) =>
-        Schema.decodeUnknownEffect(AppendResult)(result).pipe(
+        Schema.decodeEffect(AppendResult)(result).pipe(
           Effect.mapError((error) => schemaStoreError("decode append result", error)),
         ),
       ),
@@ -619,7 +619,7 @@ const makeServices = Effect.fn("SqliteThreadStore.makeServices")(function* () {
   });
 
   const readEffect = Effect.fn("SqliteThreadStore.read")(function* (request: ThreadRead) {
-    const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ThreadRead))(request).pipe(
+    const validated = yield* Schema.decodeEffect(Schema.toType(ThreadRead))(request).pipe(
       Effect.mapError((error) => schemaStoreError("validate thread read", error)),
     );
 
@@ -641,9 +641,9 @@ const makeServices = Effect.fn("SqliteThreadStore.makeServices")(function* () {
   const observeEffect = Effect.fn("SqliteThreadStore.observe")(function* (
     request: ThreadObservation,
   ) {
-    const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ThreadObservation))(
-      request,
-    ).pipe(Effect.mapError((error) => schemaStoreError("validate thread observation", error)));
+    const validated = yield* Schema.decodeEffect(Schema.toType(ThreadObservation))(request).pipe(
+      Effect.mapError((error) => schemaStoreError("validate thread observation", error)),
+    );
 
     yield* requireThread(journal, validated.threadId);
     const initialSequence = yield* parseOffset(validated.threadId, validated.afterOffset);
@@ -678,7 +678,7 @@ const makeServices = Effect.fn("SqliteThreadStore.makeServices")(function* () {
 
   const exportThread: ThreadStore["Service"]["export"] = Effect.fn("SqliteThreadStore.export")(
     function* (request: ThreadExportRequest) {
-      const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ThreadExportRequest))(
+      const validated = yield* Schema.decodeEffect(Schema.toType(ThreadExportRequest))(
         request,
       ).pipe(Effect.mapError((error) => schemaStoreError("validate thread export", error)));
 
@@ -697,9 +697,9 @@ const makeServices = Effect.fn("SqliteThreadStore.makeServices")(function* () {
         });
       }
 
-      const tailDigest = yield* Schema.decodeUnknownEffect(Digest)(
-        exported.thread.tail_digest,
-      ).pipe(Effect.mapError((error) => schemaStoreError("decode export tail digest", error)));
+      const tailDigest = yield* Schema.decodeEffect(Digest)(exported.thread.tail_digest).pipe(
+        Effect.mapError((error) => schemaStoreError("decode export tail digest", error)),
+      );
 
       return ThreadExport.make({
         format: "effect-agent/thread@1",
@@ -714,13 +714,13 @@ const makeServices = Effect.fn("SqliteThreadStore.makeServices")(function* () {
   const inspectTail: ThreadStore["Service"]["inspectTail"] = Effect.fn(
     "SqliteThreadStore.inspectTail",
   )(function* (request: ThreadTailRequest) {
-    const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ThreadTailRequest))(
-      request,
-    ).pipe(Effect.mapError((error) => schemaStoreError("validate tail inspection", error)));
+    const validated = yield* Schema.decodeEffect(Schema.toType(ThreadTailRequest))(request).pipe(
+      Effect.mapError((error) => schemaStoreError("validate tail inspection", error)),
+    );
 
     const thread = yield* requireThread(journal, validated.threadId);
 
-    const tailDigest = yield* Schema.decodeUnknownEffect(Digest)(thread.tail_digest).pipe(
+    const tailDigest = yield* Schema.decodeEffect(Digest)(thread.tail_digest).pipe(
       Effect.mapError((error) => schemaStoreError("decode tail digest", error)),
     );
 
@@ -734,7 +734,7 @@ const makeServices = Effect.fn("SqliteThreadStore.makeServices")(function* () {
 
   const saveCheckpoint: ThreadCheckpoints["save"] = Effect.fn("SqliteThreadStore.saveCheckpoint")(
     function* (request: SaveCheckpointRequest) {
-      const validated = yield* Schema.decodeUnknownEffect(Schema.toType(SaveCheckpointRequest))(
+      const validated = yield* Schema.decodeEffect(Schema.toType(SaveCheckpointRequest))(
         request,
       ).pipe(Effect.mapError((error) => schemaStoreError("validate checkpoint", error)));
 
@@ -785,7 +785,7 @@ const makeServices = Effect.fn("SqliteThreadStore.makeServices")(function* () {
 
   const loadCheckpoint: ThreadCheckpoints["load"] = Effect.fn("SqliteThreadStore.loadCheckpoint")(
     function* (request: LoadCheckpointRequest) {
-      const validated = yield* Schema.decodeUnknownEffect(Schema.toType(LoadCheckpointRequest))(
+      const validated = yield* Schema.decodeEffect(Schema.toType(LoadCheckpointRequest))(
         request,
       ).pipe(Effect.mapError((error) => schemaStoreError("validate checkpoint lookup", error)));
 
@@ -837,11 +837,9 @@ const makeServices = Effect.fn("SqliteThreadStore.makeServices")(function* () {
   const saveRecoveryCheckpoint: ThreadRecoveryCheckpoints["save"] = Effect.fn(
     "SqliteThreadStore.saveRecoveryCheckpoint",
   )(function* (request) {
-    const validated = yield* Schema.decodeUnknownEffect(
-      Schema.toType(SaveRecoveryCheckpointRequest),
-    )(request).pipe(
-      Effect.mapError((error) => schemaStoreError("validate recovery checkpoint", error)),
-    );
+    const validated = yield* Schema.decodeEffect(Schema.toType(SaveRecoveryCheckpointRequest))(
+      request,
+    ).pipe(Effect.mapError((error) => schemaStoreError("validate recovery checkpoint", error)));
 
     const checkpointJson = yield* encodeCheckpoint(validated.checkpoint);
 
@@ -861,7 +859,7 @@ const makeServices = Effect.fn("SqliteThreadStore.makeServices")(function* () {
   const loadRecoveryCheckpoint: ThreadRecoveryCheckpoints["load"] = Effect.fn(
     "SqliteThreadStore.loadRecoveryCheckpoint",
   )(function* (request) {
-    const validated = yield* Schema.decodeUnknownEffect(Schema.toType(LoadCheckpointRequest))(
+    const validated = yield* Schema.decodeEffect(Schema.toType(LoadCheckpointRequest))(
       request,
     ).pipe(
       Effect.mapError((error) => schemaStoreError("validate recovery checkpoint lookup", error)),
@@ -953,7 +951,7 @@ export const storageConfigLayer = (
   options: SqliteStorageOptions,
 ): Layer.Layer<SqliteStorageConfig, SqliteStorageError> =>
   Layer.effect(SqliteStorageConfig)(
-    Schema.decodeUnknownEffect(SqliteStorageConfigValue)({
+    Schema.decodeEffect(SqliteStorageConfigValue)({
       observationPollInterval: options.observationPollInterval ?? 25,
       busyTimeout: options.busyTimeout ?? 5_000,
       ownershipLeaseDuration: