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

package/src/DoSubmissionLedger.ts

@@ -1,5 +1,8 @@
-import { MessageAdmission } from "@effect-agent/core/Messaging";
-import { EMPTY_TAIL_DIGEST } from "@effect-agent/thread/Digest";
+import { BrowserCrypto } from "@effect/platform-browser";
+import { SqliteClient } from "@effect/sql-sqlite-do";
+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 { BrowserCrypto } from "@effect/platform-browser";
-import { SqliteClient } from "@effect/sql-sqlite-do";
-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";
 
@@ -516,9 +516,9 @@ const makeServices = Effect.fn("DoSubmissionLedger.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 });
     }
@@ -1041,9 +1041,9 @@ const makeServices = Effect.fn("DoSubmissionLedger.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)),
@@ -1075,7 +1075,7 @@ const makeServices = Effect.fn("DoSubmissionLedger.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)));
 
@@ -1161,10 +1161,10 @@ const makeServices = Effect.fn("DoSubmissionLedger.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)));
 
@@ -1181,8 +1181,8 @@ const makeServices = Effect.fn("DoSubmissionLedger.makeServices")(function* () {
                 retainedWorkerAdmission,
                 validated.workerAdmission,
               ) ||
-              !Schema.toEquivalence(Schema.optional(MessageAdmission))(
-                retainedMessageAdmission,
+              !Schema.toEquivalence(Schema.optional(InputMessage))(
+                retainedInputMessage,
                 validated.messageAdmission,
               ) ||
               !Schema.toEquivalence(Schema.optional(AdmissionFence))(
@@ -1340,9 +1340,9 @@ const makeServices = Effect.fn("DoSubmissionLedger.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(
@@ -1367,9 +1367,9 @@ const makeServices = Effect.fn("DoSubmissionLedger.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);
@@ -1416,7 +1416,7 @@ const makeServices = Effect.fn("DoSubmissionLedger.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)));
 
@@ -1453,9 +1453,9 @@ const makeServices = Effect.fn("DoSubmissionLedger.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 = `attempt-${yield* mintUuid(operation)}`;
       const ownershipToken = `owner-${yield* mintUuid(operation)}`;
@@ -1630,7 +1630,7 @@ const makeServices = Effect.fn("DoSubmissionLedger.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)));
 
@@ -1668,7 +1668,7 @@ const makeServices = Effect.fn("DoSubmissionLedger.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)));
 
@@ -1700,7 +1700,7 @@ const makeServices = Effect.fn("DoSubmissionLedger.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)));
 
@@ -1747,7 +1747,7 @@ const makeServices = Effect.fn("DoSubmissionLedger.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)));
 
@@ -1963,7 +1963,7 @@ const makeServices = Effect.fn("DoSubmissionLedger.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)));
 
@@ -2070,7 +2070,7 @@ const makeServices = Effect.fn("DoSubmissionLedger.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)),
     );
 
@@ -2170,9 +2170,9 @@ const makeServices = Effect.fn("DoSubmissionLedger.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);
 
@@ -2258,9 +2258,9 @@ const makeServices = Effect.fn("DoSubmissionLedger.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(
@@ -2318,9 +2318,9 @@ const makeServices = Effect.fn("DoSubmissionLedger.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(
@@ -2345,9 +2345,9 @@ const makeServices = Effect.fn("DoSubmissionLedger.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)),
@@ -2492,7 +2492,7 @@ const makeServices = Effect.fn("DoSubmissionLedger.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)));
 
@@ -2576,9 +2576,9 @@ const makeServices = Effect.fn("DoSubmissionLedger.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(
@@ -2643,7 +2643,7 @@ const makeServices = Effect.fn("DoSubmissionLedger.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)));
 
@@ -2764,7 +2764,7 @@ const makeServices = Effect.fn("DoSubmissionLedger.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)));
 
@@ -2885,9 +2885,9 @@ const makeServices = Effect.fn("DoSubmissionLedger.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)),
@@ -2997,9 +2997,9 @@ const makeServices = Effect.fn("DoSubmissionLedger.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);
 
@@ -3070,9 +3070,9 @@ const makeServices = Effect.fn("DoSubmissionLedger.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)),
@@ -3147,7 +3147,7 @@ const makeServices = Effect.fn("DoSubmissionLedger.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)));
 
@@ -3265,9 +3265,9 @@ const makeServices = Effect.fn("DoSubmissionLedger.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);
 
@@ -3336,7 +3336,7 @@ const makeServices = Effect.fn("DoSubmissionLedger.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)));
 
@@ -3385,7 +3385,7 @@ const makeServices = Effect.fn("DoSubmissionLedger.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/DoSubscriptionStore.ts

@@ -1,17 +1,17 @@
-import { upgradeV2Subscriptions } from "@effect-agent/thread/SqlStorageV2Upgrade";
+import { BrowserCrypto } from "@effect/platform-browser";
+import { Context, Effect, Layer, Schema } from "effect";
+import { upgradeV2Subscriptions } from "effect-agent/sql-storage-v2-upgrade";
 import {
   makeSqlSubscriptionStore,
   SqlSubscriptionTransaction,
-} from "@effect-agent/thread/SqlSubscriptionStore";
+} from "effect-agent/sql-subscription-store";
 import {
   SourcePartition,
   SubscriptionError,
   SubscriptionFailpoint,
   type SubscriptionFailpointError,
   SubscriptionStore,
-} from "@effect-agent/thread/Subscription";
-import { BrowserCrypto } from "@effect/platform-browser";
-import { Context, Effect, Layer, Schema } from "effect";
+} from "effect-agent/subscription";
 import * as SqlClientService from "effect/unstable/sql/SqlClient";
 import type { SqlError } from "effect/unstable/sql/SqlError";
 
@@ -299,7 +299,7 @@ const makeSubscriptionStore = Effect.fn("DoSubscriptionStore.make")(function* (
 
   const store = yield* makeSqlSubscriptionStore(partition, {
     maxStoredJsonLength: 1_900_000,
-  }).pipe(Effect.provide(Layer.succeed(SqlSubscriptionTransaction)({ run: transact })));
+  }).pipe(Effect.provideService(SqlSubscriptionTransaction, { run: transact }));
 
   const prearm = Effect.fn("DoSubscriptionStore.prearm")(function* (deadlineAtMillis: number) {
     yield* transactions.run((replace) => replaceAlarm(replace, deadlineAtMillis));

package/src/DoThreadStore.ts

@@ -1,4 +1,18 @@
-import { digestCanonicalBatch, EMPTY_TAIL_DIGEST } from "@effect-agent/thread/Digest";
+import { BrowserCrypto } from "@effect/platform-browser";
+import { SqliteClient } from "@effect/sql-sqlite-do";
+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 { BrowserCrypto } from "@effect/platform-browser";
-import { SqliteClient } from "@effect/sql-sqlite-do";
-import {
-  Clock,
-  Context,
-  Crypto,
-  Duration,
-  Effect,
-  Layer,
-  Option,
-  Ref,
-  Schema,
-  Stream,
-} from "effect";
+} from "effect-agent/thread-store";
 import * as SqlClientService from "effect/unstable/sql/SqlClient";
 
 import {
@@ -81,7 +81,7 @@ export interface DoStorageOptions {
   readonly observationPollInterval?: 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;
   /**
@@ -129,9 +129,9 @@ const makeOffset = Effect.fn(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)(
         `${DO_OFFSET_PREFIX}${encodeURIComponent(threadId)}:${validatedSequence}`,
       ),
     ),
@@ -145,7 +145,7 @@ const parseOffset = Effect.fn(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)),
   );
 
@@ -166,7 +166,7 @@ const parseOffset = Effect.fn(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)),
   );
 });
@@ -219,13 +219,13 @@ const decodeEnvelope = Effect.fn(function* (row: {
     ),
   );
 
-  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)));
 
@@ -279,7 +279,7 @@ const tailDigestAt = Effect.fn("DoThreadStore.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)),
   );
 });
@@ -520,7 +520,7 @@ const makeServices = Effect.fn("DoThreadStore.makeServices")(function* () {
 
   const materialize: ThreadStore["Service"]["materialize"] = Effect.fn("DoThreadStore.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)));
 
@@ -548,9 +548,9 @@ const makeServices = Effect.fn("DoThreadStore.makeServices")(function* () {
   const append: ThreadStore["Service"]["append"] = Effect.fn("DoThreadStore.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);
 
@@ -569,7 +569,7 @@ const makeServices = Effect.fn("DoThreadStore.makeServices")(function* () {
       ),
     );
 
-    const rawRequest = yield* Schema.decodeUnknownEffect(RawAppendRequest)({
+    const rawRequest = yield* Schema.decodeEffect(RawAppendRequest)({
       threadId: validated.threadId,
       batchId: validated.batch.batchId,
       batchDigest: tailDigest,
@@ -607,7 +607,7 @@ const makeServices = Effect.fn("DoThreadStore.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)),
         ),
       ),
@@ -633,7 +633,7 @@ const makeServices = Effect.fn("DoThreadStore.makeServices")(function* () {
   });
 
   const readEffect = Effect.fn("DoThreadStore.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)),
     );
 
@@ -653,9 +653,9 @@ const makeServices = Effect.fn("DoThreadStore.makeServices")(function* () {
   const read: ThreadStore["Service"]["read"] = (request) => Stream.unwrap(readEffect(request));
 
   const observeEffect = Effect.fn("DoThreadStore.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);
@@ -689,7 +689,7 @@ const makeServices = Effect.fn("DoThreadStore.makeServices")(function* () {
 
   const exportThread: ThreadStore["Service"]["export"] = Effect.fn("DoThreadStore.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)));
 
@@ -708,9 +708,9 @@ const makeServices = Effect.fn("DoThreadStore.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",
@@ -724,13 +724,13 @@ const makeServices = Effect.fn("DoThreadStore.makeServices")(function* () {
 
   const inspectTail: ThreadStore["Service"]["inspectTail"] = Effect.fn("DoThreadStore.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)),
       );
 
@@ -745,7 +745,7 @@ const makeServices = Effect.fn("DoThreadStore.makeServices")(function* () {
 
   const saveCheckpoint: ThreadCheckpoints["save"] = Effect.fn("DoThreadStore.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)));
 
@@ -796,7 +796,7 @@ const makeServices = Effect.fn("DoThreadStore.makeServices")(function* () {
 
   const loadCheckpoint: ThreadCheckpoints["load"] = Effect.fn("DoThreadStore.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)));
 
@@ -848,11 +848,9 @@ const makeServices = Effect.fn("DoThreadStore.makeServices")(function* () {
   const saveRecoveryCheckpoint: ThreadRecoveryCheckpoints["save"] = Effect.fn(
     "DoThreadStore.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);
 
@@ -872,7 +870,7 @@ const makeServices = Effect.fn("DoThreadStore.makeServices")(function* () {
   const loadRecoveryCheckpoint: ThreadRecoveryCheckpoints["load"] = Effect.fn(
     "DoThreadStore.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)),
@@ -964,7 +962,7 @@ export const storageConfigLayer = (
   options: DoStorageOptions,
 ): Layer.Layer<DoStorageConfig, DoStorageError> =>
   Layer.effect(DoStorageConfig)(
-    Schema.decodeUnknownEffect(DoStorageConfigValue)({
+    Schema.decodeEffect(DoStorageConfigValue)({
       observationPollInterval: options.observationPollInterval ?? 25,
       ownershipLeaseDuration:
         options.ownershipLeaseDuration ?? Duration.toMillis(DEFAULT_OWNERSHIP_LEASE_DURATION),