@effect-agent/storage-cloudflare 0.1.0-beta.36 → 0.1.0-beta.38

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { AbortCommand, AbortIntent, AdmissionAdmitted, AdmissionConflict, AdmissionIndeterminate, AdmissionNotAdmitted, AdmissionRequest, AdmissionResolution, AdmissionResult, AppendConflict, AppendResult, ApprovalConflict, ApprovalDecision, ApprovalDecisionCommand, ApprovalDecisionIntent, AttachChildToReservationRequest, BeginChildBudgetReleaseRequest, CanonicalBatch, CanonicalRecord, CanonicalRecordEnvelope, CanonicalSequence, CheckpointRejected, ChildAttachmentSnapshot, ChildBudgetReservationRequest, ChildBudgetReservationSnapshot, ChildReservationConflict, ChildReservationStatus, ChildSettledNotification, ChildSettledOutcome, Claim, ClaimJoiningRequest, ClaimRequest, ConversationCheckpoint, ConversationExport, ConversationExportRequest, ConversationMaterialization, ConversationNotMaterialized, ConversationObservation, ConversationRead, ConversationStore, ConversationStoreError, ConversationTail, ConversationTailRequest, DEFAULT_OWNERSHIP_LEASE_DURATION, DefinitionDigests, Digest, EMPTY_TAIL_DIGEST, FenceRejected, FencedAppendRequest, InputAppliedMarker, JoinSnapshot, JoinedToHost, JoiningClaim, LedgerCapabilities, LedgerError, LoadCheckpointRequest, MarkInputAppliedRequest, MarkJoinedRequest, MarkReadyRequest, MarkUnknownRequest, ObservationOffset, OwnershipLost, OwnershipRenewal, OwnershipSnapshot, ParentLinkage, PersistedJson, ProducerEpoch, QueueSequence, RecordEnvelope, RecoverySnapshot, RecoverySnapshotRequest, ReleaseChildBudgetRequest, ReleaseOwnershipRequest, RenewOwnershipRequest, ReservedChildBudget, ReservedSettlement, RevertJoiningRequest, SaveCheckpointRequest, Settlement, SettlementConflict, SettlementFinalization, SettlementOutcome, SettlementReservation, SettlementReservationSnapshot, SubmissionLedger, SubmissionLookup, SubmissionLookupById, SubmissionLookupByKey, SubmissionSnapshot, SubmissionState, SuspendRequest, SuspensionReason, SuspensionSnapshot, UnknownResolution, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, digestCanonicalBatch, settlementFailureFromRecord, submissionAbortRecordId } from "@effect-agent/session";
-import { Clock, Context, Crypto, DateTime, Duration, Effect, Layer, Option, Predicate, Ref, Schema, Stream } from "effect";
+import { AbortCommand, AbortIntent, AdmissionAdmitted, AdmissionConflict, AdmissionIndeterminate, AdmissionNotAdmitted, AdmissionRequest, AdmissionResolution, AdmissionResult, AppendConflict, AppendResult, ApprovalConflict, ApprovalDecision, ApprovalDecisionCommand, ApprovalDecisionIntent, AttachChildToReservationRequest, BeginChildBudgetReleaseRequest, CanonicalBatch, CanonicalRecord, CanonicalRecordEnvelope, CanonicalSequence, CheckpointRejected, ChildAttachmentSnapshot, ChildBudgetReservationRequest, ChildBudgetReservationSnapshot, ChildReservationConflict, ChildReservationStatus, ChildSettledNotification, ChildSettledOutcome, Claim, ClaimJoiningRequest, ClaimRequest, ConversationCheckpoint, ConversationExport, ConversationExportRequest, ConversationMaterialization, ConversationNotMaterialized, ConversationObservation, ConversationRead, ConversationStore, ConversationStoreError, ConversationTail, ConversationTailRequest, DEFAULT_OWNERSHIP_LEASE_DURATION, DefinitionDigests, Digest, EMPTY_TAIL_DIGEST, FenceRejected, FencedAppendRequest, InputAppliedMarker, JoinSnapshot, JoinedToHost, JoiningClaim, LedgerCapabilities, LedgerError, LoadCheckpointRequest, MarkInputAppliedRequest, MarkJoinedRequest, MarkReadyRequest, MarkUnknownRequest, ObservationOffset, OwnershipLost, OwnershipRenewal, OwnershipSnapshot, ParentLinkage, PersistedJson, ProducerEpoch, QueueSequence, RecordEnvelope, RecoverySnapshot, RecoverySnapshotRequest, ReleaseChildBudgetRequest, ReleaseOwnershipRequest, RenewOwnershipRequest, ReservedChildBudget, ReservedSettlement, RevertJoiningRequest, SaveCheckpointRequest, ScheduleCapacityError, ScheduleChange, ScheduleConflict, ScheduleDueCursor, ScheduleFailpoint, ScheduleId, ScheduleInstant, ScheduleKey, ScheduleNotFound, ScheduleOwner, SchedulePageRequest, ScheduleRecord, ScheduleStorageError, ScheduleStore, Settlement, SettlementConflict, SettlementFinalization, SettlementOutcome, SettlementReservation, SettlementReservationSnapshot, SubmissionLedger, SubmissionLookup, SubmissionLookupById, SubmissionLookupByKey, SubmissionSnapshot, SubmissionState, SuspendRequest, SuspensionReason, SuspensionSnapshot, UnknownResolution, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, applyScheduleChange, defaultSchedulingLimits, digestCanonicalBatch, scheduleDeadline, scheduleUsesCapacity, settlementFailureFromRecord, submissionAbortRecordId } from "@effect-agent/session";
+import { Clock, Context, Crypto, DateTime, Duration, Effect, Layer, Option, Predicate, Ref, Result, Schema, Stream } from "effect";
 import { SqliteClient, SqliteMigrator } from "@effect/sql-sqlite-do";
 import * as SqlClient from "effect/unstable/sql/SqlClient";
 import { BrowserCrypto } from "@effect/platform-browser";
@@ -477,13 +477,13 @@ const storageError = (operation) => (error) => DoStorageError.make({
 	message: error.message
 });
 /** Decode raw Durable Object SQLite rows against a Schema, reporting failures as typed corruption. */
-const decodeRows = Effect.fn((schema, table, rowKey, rows) => Schema.decodeUnknownEffect(schema)(rows).pipe(Effect.mapError((error) => DoStorageCorruptionError.make({
+const decodeRows$1 = Effect.fn((schema, table, rowKey, rows) => Schema.decodeUnknownEffect(schema)(rows).pipe(Effect.mapError((error) => DoStorageCorruptionError.make({
 	table,
 	rowKey,
 	message: String(error)
 }))));
 /** Decode exactly one raw row against a Schema, reporting failures as typed corruption. */
-const decodeSingleRow = Effect.fn((schema, table, rowKey, rows) => decodeRows(schema, table, rowKey, rows).pipe(Effect.flatMap((decoded) => decoded.length === 1 ? Effect.succeed(decoded[0]) : Effect.fail(DoStorageCorruptionError.make({
+const decodeSingleRow = Effect.fn((schema, table, rowKey, rows) => decodeRows$1(schema, table, rowKey, rows).pipe(Effect.flatMap((decoded) => decoded.length === 1 ? Effect.succeed(decoded[0]) : Effect.fail(DoStorageCorruptionError.make({
 	table,
 	rowKey,
 	message: `Expected exactly one row but found ${decoded.length}.`
@@ -518,7 +518,7 @@ const ensureCurrentStorage = Effect.fn("DoJournal.ensureCurrentStorage")(functio
     WHERE type = 'table'
       AND name = 'effect_agent_meta'
   `.pipe(Effect.mapError(storageError("read storage version table")));
-	if ((yield* decodeRows(Schema.Array(DoNameRow), "sqlite_master", "effect_agent_meta", metaTableRows)).length === 0) {
+	if ((yield* decodeRows$1(Schema.Array(DoNameRow), "sqlite_master", "effect_agent_meta", metaTableRows)).length === 0) {
 		const existingRows = yield* sql`
       SELECT name
       FROM sqlite_master
@@ -526,7 +526,7 @@ const ensureCurrentStorage = Effect.fn("DoJournal.ensureCurrentStorage")(functio
         AND name LIKE 'effect_agent_%'
       ORDER BY name
     `.pipe(Effect.mapError(storageError("inspect unversioned storage")));
-		if ((yield* decodeRows(Schema.Array(DoNameRow), "sqlite_master", "effect_agent_%", existingRows)).length > 0) return yield* DoStorageCompatibilityError.make({
+		if ((yield* decodeRows$1(Schema.Array(DoNameRow), "sqlite_master", "effect_agent_%", existingRows)).length > 0) return yield* DoStorageCompatibilityError.make({
 			actualVersion: 0,
 			supportedVersion: 1,
 			message: "The Durable Object contains unversioned Effect Agent tables. Reset the development namespace explicitly; refusing to mutate ambiguous stored data."
@@ -559,7 +559,7 @@ const ensureCurrentStorage = Effect.fn("DoJournal.ensureCurrentStorage")(functio
       AND name IN ${sql.in([...REQUIRED_TABLES])}
     ORDER BY name
   `.pipe(Effect.mapError(storageError("verify storage tables")));
-	if ((yield* decodeRows(Schema.Array(DoNameRow), "sqlite_master", "required_tables", requiredRows)).length !== REQUIRED_TABLES.length) return yield* DoStorageCompatibilityError.make({
+	if ((yield* decodeRows$1(Schema.Array(DoNameRow), "sqlite_master", "required_tables", requiredRows)).length !== REQUIRED_TABLES.length) return yield* DoStorageCompatibilityError.make({
 		actualVersion: 1,
 		supportedVersion: 1,
 		message: "The Durable Object claims the current format but is missing required tables. Reset the corrupt private-development data."
@@ -606,7 +606,7 @@ const makeJournal = (sql, failpoint, maxStoredValueBytes) => {
           FROM effect_agent_conversations
           WHERE conversation_id = ${conversationId}
         `.pipe(Effect.mapError(storageError("read materialized conversation")));
-			const existing = yield* decodeRows(Schema.Array(ConversationRow), "effect_agent_conversations", conversationId, existingRows);
+			const existing = yield* decodeRows$1(Schema.Array(ConversationRow), "effect_agent_conversations", conversationId, existingRows);
 			if (existing.length > 1) return yield* DoStorageCorruptionError.make({
 				table: "effect_agent_conversations",
 				rowKey: conversationId,
@@ -653,7 +653,7 @@ const makeJournal = (sql, failpoint, maxStoredValueBytes) => {
       FROM effect_agent_conversations
       WHERE conversation_id = ${conversationId}
     `.pipe(Effect.mapError(storageError("read conversation")));
-		return yield* decodeRows(Schema.Array(ConversationRow), "effect_agent_conversations", conversationId, rows);
+		return yield* decodeRows$1(Schema.Array(ConversationRow), "effect_agent_conversations", conversationId, rows);
 	});
 	const append = Effect.fn("DoJournal.append")(function* (request) {
 		if (request.conversationId.length > MAX_IDENTIFIER_LENGTH$1 || request.batchId.length > MAX_IDENTIFIER_LENGTH$1 || request.records.some((record) => record.recordId.length > MAX_IDENTIFIER_LENGTH$1)) return yield* DoStorageError.make({
@@ -699,7 +699,7 @@ const makeJournal = (sql, failpoint, maxStoredValueBytes) => {
           WHERE conversation_id = ${request.conversationId}
             AND batch_id = ${request.batchId}
         `.pipe(Effect.mapError(storageError("read idempotent batch")));
-			const batches = yield* decodeRows(Schema.Array(BatchRow), "effect_agent_canonical_batches", `${request.conversationId}/${request.batchId}`, batchRows);
+			const batches = yield* decodeRows$1(Schema.Array(BatchRow), "effect_agent_canonical_batches", `${request.conversationId}/${request.batchId}`, batchRows);
 			if (batches.length > 1) return yield* DoStorageCorruptionError.make({
 				table: "effect_agent_canonical_batches",
 				rowKey: `${request.conversationId}/${request.batchId}`,
@@ -742,7 +742,7 @@ const makeJournal = (sql, failpoint, maxStoredValueBytes) => {
               AND record_id IN ${sql.in([...chunk])}
             ORDER BY sequence
           `.pipe(Effect.mapError(storageError("check canonical record identities")));
-				existingRecords.push(...yield* decodeRows(Schema.Array(RecordRow), "effect_agent_canonical_records", `${request.conversationId}/record_ids`, existingRecordRows));
+				existingRecords.push(...yield* decodeRows$1(Schema.Array(RecordRow), "effect_agent_canonical_records", `${request.conversationId}/record_ids`, existingRecordRows));
 			}
 			if (existingRecords.length > 0) return yield* DoAppendConflict.make({
 				message: `Canonical record ID ${existingRecords[0].record_id} already exists.`,
@@ -827,7 +827,7 @@ const makeJournal = (sql, failpoint, maxStoredValueBytes) => {
       ORDER BY sequence
       LIMIT ${request.limit}
     `.pipe(Effect.mapError(storageError("read canonical records")));
-		return yield* decodeRows(Schema.Array(RecordRow), "effect_agent_canonical_records", `${request.conversationId}>${request.fromSequenceExclusive}`, rows);
+		return yield* decodeRows$1(Schema.Array(RecordRow), "effect_agent_canonical_records", `${request.conversationId}>${request.fromSequenceExclusive}`, rows);
 	});
 	const exportConversation = Effect.fn("DoJournal.exportConversation")(function* (conversationId) {
 		return yield* sql.withTransaction(Effect.gen(function* () {
@@ -879,9 +879,9 @@ const makeJournal = (sql, failpoint, maxStoredValueBytes) => {
           `.pipe(Effect.mapError(storageError("export checkpoints")));
 			return RawConversationExport.make({
 				conversation,
-				batches: yield* decodeRows(Schema.Array(BatchRow), "effect_agent_canonical_batches", conversationId, batchRows),
-				records: yield* decodeRows(Schema.Array(RecordRow), "effect_agent_canonical_records", conversationId, recordRows),
-				checkpoints: yield* decodeRows(Schema.Array(CheckpointRow), "effect_agent_checkpoints", conversationId, checkpointRows)
+				batches: yield* decodeRows$1(Schema.Array(BatchRow), "effect_agent_canonical_batches", conversationId, batchRows),
+				records: yield* decodeRows$1(Schema.Array(RecordRow), "effect_agent_canonical_records", conversationId, recordRows),
+				checkpoints: yield* decodeRows$1(Schema.Array(CheckpointRow), "effect_agent_checkpoints", conversationId, checkpointRows)
 			});
 		})).pipe(Effect.catchTag("SqlError", (error) => Effect.fail(storageError("export transaction")(error))));
 	});
@@ -914,7 +914,7 @@ const makeJournal = (sql, failpoint, maxStoredValueBytes) => {
           WHERE conversation_id = ${checkpoint.conversationId}
             AND through_sequence = ${checkpoint.throughSequence}
         `.pipe(Effect.mapError(storageError("read idempotent checkpoint")));
-			const existing = yield* decodeRows(Schema.Array(CheckpointRow), "effect_agent_checkpoints", `${checkpoint.conversationId}/${checkpoint.throughSequence}`, checkpointRows);
+			const existing = yield* decodeRows$1(Schema.Array(CheckpointRow), "effect_agent_checkpoints", `${checkpoint.conversationId}/${checkpoint.throughSequence}`, checkpointRows);
 			if (existing.length > 1) return yield* DoStorageCorruptionError.make({
 				table: "effect_agent_checkpoints",
 				rowKey: `${checkpoint.conversationId}/${checkpoint.throughSequence}`,
@@ -952,7 +952,7 @@ const makeJournal = (sql, failpoint, maxStoredValueBytes) => {
       ORDER BY through_sequence DESC
       LIMIT 1
     `.pipe(Effect.mapError(storageError("load checkpoint")));
-		return yield* decodeRows(Schema.Array(CheckpointRow), "effect_agent_checkpoints", `${conversationId}<=${atOrBeforeSequence}`, rows);
+		return yield* decodeRows$1(Schema.Array(CheckpointRow), "effect_agent_checkpoints", `${conversationId}<=${atOrBeforeSequence}`, rows);
 	});
 	return {
 		append,
@@ -977,7 +977,7 @@ const makeJournal = (sql, failpoint, maxStoredValueBytes) => {
       WHERE conversation_id = ${conversationId}
         AND last_sequence = ${sequence}
     `.pipe(Effect.mapError(storageError("read canonical digest at sequence")));
-			return (yield* decodeRows(Schema.Array(BatchRow), "effect_agent_canonical_batches", `${conversationId}/${sequence}`, rows)).map((batch) => batch.tail_digest);
+			return (yield* decodeRows$1(Schema.Array(BatchRow), "effect_agent_canonical_batches", `${conversationId}/${sequence}`, rows)).map((batch) => batch.tail_digest);
 		}),
 		loadCheckpoint,
 		materialize,
@@ -1027,10 +1027,10 @@ const makeJournal = (sql, failpoint, maxStoredValueBytes) => {
             ORDER BY conversation_id, through_sequence
           `.pipe(Effect.mapError(storageError("scan checkpoints")));
 				return {
-					conversations: yield* decodeRows(Schema.Array(ConversationRow), "effect_agent_conversations", "startup_scan", conversations),
-					batches: yield* decodeRows(Schema.Array(BatchRow), "effect_agent_canonical_batches", "startup_scan", batches),
-					records: yield* decodeRows(Schema.Array(RecordRow), "effect_agent_canonical_records", "startup_scan", records),
-					checkpoints: yield* decodeRows(Schema.Array(CheckpointRow), "effect_agent_checkpoints", "startup_scan", checkpoints)
+					conversations: yield* decodeRows$1(Schema.Array(ConversationRow), "effect_agent_conversations", "startup_scan", conversations),
+					batches: yield* decodeRows$1(Schema.Array(BatchRow), "effect_agent_canonical_batches", "startup_scan", batches),
+					records: yield* decodeRows$1(Schema.Array(RecordRow), "effect_agent_canonical_records", "startup_scan", records),
+					checkpoints: yield* decodeRows$1(Schema.Array(CheckpointRow), "effect_agent_checkpoints", "startup_scan", checkpoints)
 				};
 			})).pipe(Effect.catchTag("SqlError", (error) => Effect.fail(storageError("startup scan transaction")(error))));
 		}),
@@ -1313,7 +1313,7 @@ const decodeStartupPayloads = Effect.fn("DoConversationStore.decodeStartupPayloa
 		message: "Canonical rows exist without a materialized Conversation."
 	});
 });
-const makeServices$1 = Effect.fn("DoConversationStore.makeServices")(function* () {
+const makeServices$2 = Effect.fn("DoConversationStore.makeServices")(function* () {
 	const config = yield* DoStorageConfig;
 	const failpoint = yield* DoStorageFailpoint;
 	const sql = yield* SqlClient.SqlClient;
@@ -1491,7 +1491,7 @@ const makeServices$1 = Effect.fn("DoConversationStore.makeServices")(function* (
 * Durable Object Conversation Store implementation with configuration, failpoint, SQL, and
 * Crypto authority kept visible in its input channel.
 */
-const conversationStoreLayer = Layer.effectContext(makeServices$1());
+const conversationStoreLayer = Layer.effectContext(makeServices$2());
 /**
 * Validated Durable Object storage configuration Layer with the documented defaults applied.
 * Shared by the ConversationStore and SubmissionLedger convenience layers so their defaults
@@ -1717,7 +1717,7 @@ const corruptionFailure = (operation, table, rowKey, message) => internalFailure
 	rowKey,
 	message
 }));
-const makeServices = Effect.fn("DoSubmissionLedger.makeServices")(function* () {
+const makeServices$1 = Effect.fn("DoSubmissionLedger.makeServices")(function* () {
 	const config = yield* DoStorageConfig;
 	const failpoint = yield* DoStorageFailpoint;
 	const sql = yield* SqlClient.SqlClient;
@@ -1736,7 +1736,7 @@ const makeServices = Effect.fn("DoSubmissionLedger.makeServices")(function* () {
 		iso: new Date(millis).toISOString()
 	}));
 	const timestampMillis = (operation, rowKey) => (timestamp) => decodeUtcInstant(timestamp).pipe(Effect.map(DateTime.toEpochMillis), Effect.mapError((error) => corruptionFailure(operation, "effect_agent_submission_ownership", rowKey, error.message)));
-	const decodeSubmissionRows = (operation, rowKey, rows) => decodeRows(Schema.Array(SubmissionRow), "effect_agent_submissions", rowKey, rows).pipe(Effect.mapError(internalFailure(operation)));
+	const decodeSubmissionRows = (operation, rowKey, rows) => decodeRows$1(Schema.Array(SubmissionRow), "effect_agent_submissions", rowKey, rows).pipe(Effect.mapError(internalFailure(operation)));
 	const readSubmission = Effect.fn("DoSubmissionLedger.readSubmission")(function* (operation, submissionId) {
 		const rows = yield* sql`
       SELECT ${sql.literal(SUBMISSION_COLUMNS)}
@@ -1767,7 +1767,7 @@ const makeServices = Effect.fn("DoSubmissionLedger.makeServices")(function* () {
       FROM effect_agent_submission_ownership
       WHERE submission_id = ${submissionId}
     `.pipe(Effect.mapError(sqlFailure(operation)));
-		const decoded = yield* decodeRows(Schema.Array(OwnershipRow), "effect_agent_submission_ownership", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
+		const decoded = yield* decodeRows$1(Schema.Array(OwnershipRow), "effect_agent_submission_ownership", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
 		if (decoded.length > 1) return yield* corruptionFailure(operation, "effect_agent_submission_ownership", submissionId, "An ownership primary key returned more than one row.");
 		return decoded.length === 0 ? Option.none() : Option.some(decoded[0]);
 	});
@@ -1832,7 +1832,7 @@ const makeServices = Effect.fn("DoSubmissionLedger.makeServices")(function* () {
       FROM effect_agent_settlement_reservations
       WHERE submission_id = ${submissionId}
     `.pipe(Effect.mapError(sqlFailure(operation)));
-		const decoded = yield* decodeRows(Schema.Array(ReservationRow), "effect_agent_settlement_reservations", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
+		const decoded = yield* decodeRows$1(Schema.Array(ReservationRow), "effect_agent_settlement_reservations", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
 		if (decoded.length > 1) return yield* corruptionFailure(operation, "effect_agent_settlement_reservations", submissionId, "A settlement reservation primary key returned more than one row.");
 		return decoded.length === 0 ? Option.none() : Option.some(decoded[0]);
 	});
@@ -1847,7 +1847,7 @@ const makeServices = Effect.fn("DoSubmissionLedger.makeServices")(function* () {
       FROM effect_agent_abort_intents
       WHERE submission_id = ${submissionId}
     `.pipe(Effect.mapError(sqlFailure(operation)));
-		const decoded = yield* decodeRows(Schema.Array(AbortIntentRow), "effect_agent_abort_intents", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
+		const decoded = yield* decodeRows$1(Schema.Array(AbortIntentRow), "effect_agent_abort_intents", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
 		if (decoded.length > 1) return yield* corruptionFailure(operation, "effect_agent_abort_intents", submissionId, "An abort intent primary key returned more than one row.");
 		return decoded.length === 0 ? Option.none() : Option.some(decoded[0]);
 	});
@@ -1867,7 +1867,7 @@ const makeServices = Effect.fn("DoSubmissionLedger.makeServices")(function* () {
         WHERE parent_submission_id = ${parentSubmissionId}
         ORDER BY child_submission_id ASC
       `.pipe(Effect.mapError(sqlFailure(operation)));
-		return yield* decodeRows(Schema.Array(ChildSettlementMarkerRow), "effect_agent_child_settlements", parentSubmissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
+		return yield* decodeRows$1(Schema.Array(ChildSettlementMarkerRow), "effect_agent_child_settlements", parentSubmissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
 	});
 	/**
 	* Whether one listed child is provably settled from THIS store: either its own row lives
@@ -1880,7 +1880,7 @@ const makeServices = Effect.fn("DoSubmissionLedger.makeServices")(function* () {
 		const childRow = yield* readSubmission(operation, childSubmissionId);
 		return Option.isSome(childRow) && childRow.value.state === "settled";
 	});
-	const decodeChildReservationRows = (operation, rowKey, rows) => decodeRows(Schema.Array(ChildReservationRow), "effect_agent_child_reservations", rowKey, rows).pipe(Effect.mapError(internalFailure(operation)));
+	const decodeChildReservationRows = (operation, rowKey, rows) => decodeRows$1(Schema.Array(ChildReservationRow), "effect_agent_child_reservations", rowKey, rows).pipe(Effect.mapError(internalFailure(operation)));
 	const readChildReservation = Effect.fn("DoSubmissionLedger.readChildReservation")(function* (operation, reservationId) {
 		const rows = yield* sql`
       SELECT ${sql.literal(CHILD_RESERVATION_COLUMNS)}
@@ -1933,7 +1933,7 @@ const makeServices = Effect.fn("DoSubmissionLedger.makeServices")(function* () {
       WHERE submission_id = ${submissionId}
       ORDER BY tool_call_id ASC
     `.pipe(Effect.mapError(sqlFailure(operation)));
-		return yield* decodeRows(Schema.Array(ApprovalDecisionRow), "effect_agent_approval_decisions", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
+		return yield* decodeRows$1(Schema.Array(ApprovalDecisionRow), "effect_agent_approval_decisions", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
 	});
 	const approvalIntentFromRow = Effect.fn("DoSubmissionLedger.approvalIntentFromRow")(function* (operation, row) {
 		return yield* decodeApprovalDecisionIntent({
@@ -1958,7 +1958,7 @@ const makeServices = Effect.fn("DoSubmissionLedger.makeServices")(function* () {
       WHERE submission_id = ${submissionId}
       ORDER BY tool_call_id ASC
     `.pipe(Effect.mapError(sqlFailure(operation)));
-		return yield* decodeRows(Schema.Array(UnknownResolutionRow), "effect_agent_unknown_resolutions", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
+		return yield* decodeRows$1(Schema.Array(UnknownResolutionRow), "effect_agent_unknown_resolutions", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
 	});
 	const unknownResolutionIntentFromRow = Effect.fn("DoSubmissionLedger.unknownResolutionIntentFromRow")(function* (operation, row) {
 		const resolution = yield* parseStoredJsonText(row.resolution_json).pipe(Effect.mapError((error) => corruptionFailure(operation, "effect_agent_unknown_resolutions", `${row.submission_id}/${row.tool_call_id}`, error.message)));
@@ -1989,7 +1989,7 @@ const makeServices = Effect.fn("DoSubmissionLedger.makeServices")(function* () {
       WHERE conversation_id = ${conversationId}
         AND record_id = ${recordId}
     `.pipe(Effect.mapError(sqlFailure(operation)));
-		return (yield* decodeRows(Schema.Array(CanonicalRecordIdRow), "effect_agent_canonical_records", `${conversationId}/${recordId}`, rows).pipe(Effect.mapError(internalFailure(operation)))).length === 0 ? void 0 : recordId;
+		return (yield* decodeRows$1(Schema.Array(CanonicalRecordIdRow), "effect_agent_canonical_records", `${conversationId}/${recordId}`, rows).pipe(Effect.mapError(internalFailure(operation)))).length === 0 ? void 0 : recordId;
 	});
 	const abortIntentFromRow = Effect.fn("DoSubmissionLedger.abortIntentFromRow")(function* (operation, submission, submissionId, row) {
 		const canonicalRecordId = yield* canonicalAbortRecordId(operation, submission.conversation_id, submissionId);
@@ -2048,7 +2048,7 @@ const makeServices = Effect.fn("DoSubmissionLedger.makeServices")(function* () {
             FROM effect_agent_submissions
             WHERE conversation_id = ${validated.conversationId}
           `.pipe(Effect.mapError(sqlFailure(operation)));
-			const decodedMax = yield* decodeRows(Schema.Array(MaxQueueSequenceRow), "effect_agent_submissions", validated.conversationId, maxRows).pipe(Effect.mapError(internalFailure(operation)));
+			const decodedMax = yield* decodeRows$1(Schema.Array(MaxQueueSequenceRow), "effect_agent_submissions", validated.conversationId, maxRows).pipe(Effect.mapError(internalFailure(operation)));
 			const queueSequence = yield* decodeQueueSequence((decodedMax[0]?.max_queue_sequence ?? 0) + 1).pipe(Effect.mapError(internalFailure(operation)));
 			const now = yield* currentInstant;
 			yield* sql`
@@ -3208,13 +3208,369 @@ const makeServices = Effect.fn("DoSubmissionLedger.makeServices")(function* () {
 * database, storage-backed transaction discipline, and producer-epoch fencing substrate.
 * Configuration, failpoint, SQL, and Crypto authority stay visible in the input channel.
 */
-const submissionLedgerLayer = Layer.effectContext(makeServices());
+const submissionLedgerLayer = Layer.effectContext(makeServices$1());
 /**
 * A composition-root convenience Layer for the durable Submission Ledger. Point it at the
 * same `ctx.storage` as the ConversationStore so claims fence the same producer epochs.
 */
 const ledgerLayer = (options) => Layer.unwrap(Effect.map(DoStorageConfig, (config) => submissionLedgerLayer.pipe(Layer.provide(Layer.mergeAll(Layer.succeed(DoStorageConfig)(config), storageFailpointLayer(options), SqliteClient.layer({ storage: options.storage }), BrowserCrypto.layer))))).pipe(Layer.provide(storageConfigLayer(options)));
 //#endregion
+//#region src/do-schedule-store.ts
+const CURRENT_SCHEDULE_STORE_VERSION = 1;
+const StoredScheduleJson = Schema.String.check(Schema.isMaxLength(19e5));
+const StoredDeadline = Schema.NullOr(ScheduleInstant);
+var ScheduleRow = class extends Schema.Class("@effect-agent/storage-cloudflare/ScheduleRow")({
+	tenant_id: ScheduleOwner.fields.tenantId,
+	owner_id: ScheduleOwner.fields.ownerId,
+	schedule_id: ScheduleId,
+	deadline_at_millis: StoredDeadline,
+	record_json: StoredScheduleJson
+}) {};
+const ScheduleDueRow = Schema.Struct({
+	tenant_id: ScheduleOwner.fields.tenantId,
+	owner_id: ScheduleOwner.fields.ownerId,
+	schedule_id: ScheduleId,
+	deadline_at_millis: ScheduleInstant
+});
+var ScheduleCountRow = class extends Schema.Class("@effect-agent/storage-cloudflare/ScheduleCountRow")({ schedule_count: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)) }) {};
+var ScheduleDeadlineRow = class extends Schema.Class("@effect-agent/storage-cloudflare/ScheduleDeadlineRow")({ deadline_at_millis: StoredDeadline }) {};
+var ScheduleStoreStateRow = class extends Schema.Class("@effect-agent/storage-cloudflare/ScheduleStoreStateRow")({
+	storage_version: Schema.Int.check(Schema.isGreaterThan(0)),
+	alarm_generation: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))
+}) {};
+var ScheduleTableNameRow = class extends Schema.Class("@effect-agent/storage-cloudflare/ScheduleTableNameRow")({ name: Schema.String }) {};
+/**
+* Platform-owned transaction boundary for schedule SQL and logical alarm mutation. The callback
+* and its `replaceAlarm` capability belong to one fiber and must not escape or fork.
+*/
+var DoScheduleTransaction = class extends Context.Service()("@effect-agent/storage-cloudflare/DoScheduleTransaction") {};
+/** Platform driver operations that use the same schedule-state and alarm transaction. */
+var DoScheduleAlarmControl = class extends Context.Service()("@effect-agent/storage-cloudflare/DoScheduleAlarmControl") {};
+const unavailable = (operation) => ScheduleStorageError.make({
+	operation,
+	reason: "unavailable"
+});
+const corrupt = (operation) => ScheduleStorageError.make({
+	operation,
+	reason: "corrupt"
+});
+const decodeRows = Effect.fn("DoScheduleStore.decodeRows")(function* (schema, rows, operation) {
+	return yield* Schema.decodeUnknownEffect(schema)(rows).pipe(Effect.mapError(() => corrupt(operation)));
+});
+const decodeBoundary = (schema, value, operation) => Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError(() => corrupt(operation)));
+const decodeRecord = Effect.fn("DoScheduleStore.decodeRecord")(function* (row) {
+	const record = yield* Schema.decodeEffect(Schema.fromJsonString(ScheduleRecord))(row.record_json).pipe(Effect.mapError(() => corrupt("decode schedule")));
+	if (record.owner.tenantId !== row.tenant_id || record.owner.ownerId !== row.owner_id || record.scheduleId !== row.schedule_id || scheduleDeadline(record) !== row.deadline_at_millis) return yield* corrupt("decode schedule index");
+	return record;
+});
+const encodeRecord = Effect.fn("DoScheduleStore.encodeRecord")(function* (record) {
+	const encoded = yield* Schema.encodeEffect(Schema.fromJsonString(ScheduleRecord))(record).pipe(Effect.mapError(() => corrupt("encode schedule")));
+	return yield* Schema.decodeUnknownEffect(StoredScheduleJson)(encoded).pipe(Effect.mapError(() => corrupt("encode schedule bounds")));
+});
+const initializeScheduleStore = Effect.fn("DoScheduleStore.initialize")(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	const operation = "initialize schedule store";
+	const rawTables = yield* sql`
+    SELECT name
+    FROM sqlite_master
+    WHERE type = 'table'
+      AND name IN (
+        'effect_agent_schedule_store_state',
+        'effect_agent_schedules'
+      )
+    ORDER BY name
+  `.pipe(Effect.mapError(() => unavailable(operation)));
+	const tables = yield* decodeRows(Schema.Array(ScheduleTableNameRow), rawTables, operation);
+	const hasState = tables.some((row) => row.name === "effect_agent_schedule_store_state");
+	const hasSchedules = tables.some((row) => row.name === "effect_agent_schedules");
+	if (!hasState) {
+		if (hasSchedules) return yield* corrupt(operation);
+		yield* sql.withTransaction(Effect.gen(function* () {
+			yield* sql`
+            CREATE TABLE effect_agent_schedule_store_state (
+              singleton INTEGER PRIMARY KEY NOT NULL CHECK (singleton = 1),
+              storage_version INTEGER NOT NULL,
+              alarm_generation INTEGER NOT NULL
+            )
+          `.withoutTransform;
+			yield* sql`
+            CREATE TABLE effect_agent_schedules (
+              tenant_id TEXT NOT NULL,
+              owner_id TEXT NOT NULL,
+              schedule_id TEXT NOT NULL,
+              deadline_at_millis INTEGER,
+              record_json TEXT NOT NULL,
+              PRIMARY KEY (tenant_id, owner_id, schedule_id)
+            )
+          `.withoutTransform;
+			yield* sql`
+            CREATE INDEX effect_agent_schedules_deadline
+              ON effect_agent_schedules (deadline_at_millis, tenant_id, owner_id, schedule_id)
+              WHERE deadline_at_millis IS NOT NULL
+          `.withoutTransform;
+			yield* sql`
+            CREATE INDEX effect_agent_schedules_owner_deadline
+              ON effect_agent_schedules (tenant_id, owner_id, deadline_at_millis, schedule_id)
+              WHERE deadline_at_millis IS NOT NULL
+          `.withoutTransform;
+			yield* sql`
+            INSERT INTO effect_agent_schedule_store_state (
+              singleton, storage_version, alarm_generation
+            ) VALUES (1, ${CURRENT_SCHEDULE_STORE_VERSION}, 0)
+          `.withoutTransform;
+		})).pipe(Effect.mapError(() => unavailable(operation)));
+		return;
+	}
+	if (!hasSchedules) return yield* corrupt(operation);
+	const rawState = yield* sql`
+    SELECT storage_version, alarm_generation
+    FROM effect_agent_schedule_store_state
+    WHERE singleton = 1
+  `.pipe(Effect.mapError(() => unavailable(operation)));
+	const state = yield* decodeRows(Schema.Array(ScheduleStoreStateRow), rawState, operation);
+	if (state.length !== 1 || state[0].storage_version !== CURRENT_SCHEDULE_STORE_VERSION) return yield* corrupt(operation);
+});
+const makeServices = Effect.gen(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	const transactions = yield* DoScheduleTransaction;
+	const scheduleFailpoint = yield* ScheduleFailpoint;
+	yield* initializeScheduleStore();
+	const readRows = Effect.fn("DoScheduleStore.readRows")(function* (key, operation) {
+		const rows = yield* sql`
+      SELECT tenant_id, owner_id, schedule_id, deadline_at_millis, record_json
+      FROM effect_agent_schedules
+      WHERE tenant_id = ${key.owner.tenantId}
+        AND owner_id = ${key.owner.ownerId}
+        AND schedule_id = ${key.scheduleId}
+    `.pipe(Effect.mapError(() => unavailable(operation)));
+		return yield* decodeRows(Schema.Array(ScheduleRow), rows, operation);
+	});
+	const readOne = Effect.fn("DoScheduleStore.readOne")(function* (key, operation) {
+		const rows = yield* readRows(key, operation);
+		if (rows.length === 0) return null;
+		if (rows.length !== 1) return yield* corrupt(operation);
+		return yield* decodeRecord(rows[0]);
+	});
+	const readNextDeadline = Effect.fn("DoScheduleStore.readNextDeadline")(function* (owner, operation) {
+		const rows = owner === void 0 ? yield* sql`
+            SELECT MIN(deadline_at_millis) AS deadline_at_millis
+            FROM effect_agent_schedules
+            WHERE deadline_at_millis IS NOT NULL
+          `.pipe(Effect.mapError(() => unavailable(operation))) : yield* sql`
+            SELECT MIN(deadline_at_millis) AS deadline_at_millis
+            FROM effect_agent_schedules
+            WHERE tenant_id = ${owner.tenantId}
+              AND owner_id = ${owner.ownerId}
+              AND deadline_at_millis IS NOT NULL
+          `.pipe(Effect.mapError(() => unavailable(operation)));
+		const decoded = yield* decodeRows(Schema.Array(ScheduleDeadlineRow), rows, operation);
+		if (decoded.length !== 1) return yield* corrupt(operation);
+		return decoded[0].deadline_at_millis;
+	});
+	const replaceAlarm = Effect.fn("DoScheduleStore.replaceAlarm")(function* (replace, deadlineAtMillis, operation) {
+		const rawState = yield* sql`
+      UPDATE effect_agent_schedule_store_state
+      SET alarm_generation = alarm_generation + 1
+      WHERE singleton = 1
+      RETURNING storage_version, alarm_generation
+    `.pipe(Effect.mapError(() => unavailable(operation)));
+		const state = yield* decodeRows(Schema.Array(ScheduleStoreStateRow), rawState, operation);
+		if (state.length !== 1 || state[0].storage_version !== CURRENT_SCHEDULE_STORE_VERSION) return yield* corrupt(operation);
+		yield* scheduleFailpoint.hit("schedule:alarm:before");
+		yield* replace({
+			deadlineAtMillis,
+			generation: state[0].alarm_generation
+		});
+		yield* scheduleFailpoint.hit("schedule:alarm:after");
+	});
+	const insert = Effect.fn("DoScheduleStore.insert")(function* (record, ownerLimit) {
+		const operation = "insert schedule";
+		const canonical = yield* decodeBoundary(ScheduleRecord, record, operation);
+		const recordJson = yield* encodeRecord(canonical);
+		const result = yield* transactions.run((replace) => Effect.gen(function* () {
+			const existing = yield* readOne(canonical, operation);
+			if (existing !== null) {
+				if (existing.creationFingerprint === canonical.creationFingerprint) return {
+					record: existing,
+					inserted: false
+				};
+				return yield* ScheduleConflict.make({
+					reason: "creation",
+					key: canonical
+				});
+			}
+			const rawCounts = yield* sql`
+            SELECT COUNT(*) AS schedule_count
+            FROM effect_agent_schedules
+            WHERE tenant_id = ${canonical.owner.tenantId}
+              AND owner_id = ${canonical.owner.ownerId}
+              AND (json_extract(record_json, '$.pending') IS NOT NULL OR
+                (json_extract(record_json, '$.state') != 'cancelled' AND json_extract(record_json, '$.nextAtMillis') IS NOT NULL))
+          `.pipe(Effect.mapError(() => unavailable(operation)));
+			const counts = yield* decodeRows(Schema.Array(ScheduleCountRow), rawCounts, operation);
+			if (counts.length !== 1) return yield* corrupt(operation);
+			if (counts[0].schedule_count >= ownerLimit) return yield* ScheduleCapacityError.make({ limit: ownerLimit });
+			yield* scheduleFailpoint.hit("schedule:insert:before");
+			yield* sql`
+            INSERT INTO effect_agent_schedules (
+              tenant_id, owner_id, schedule_id, deadline_at_millis, record_json
+            ) VALUES (
+              ${canonical.owner.tenantId},
+              ${canonical.owner.ownerId},
+              ${canonical.scheduleId},
+              ${scheduleDeadline(canonical)},
+              ${recordJson}
+            )
+          `.pipe(Effect.mapError(() => unavailable(operation)));
+			const deadline = yield* readNextDeadline(void 0, operation);
+			yield* replaceAlarm(replace, deadline, operation);
+			return {
+				record: canonical,
+				inserted: true
+			};
+		}));
+		if (result.inserted) yield* scheduleFailpoint.hit("schedule:insert:after");
+		return result.record;
+	});
+	const get = Effect.fn("DoScheduleStore.get")(function* (key) {
+		const canonical = yield* decodeBoundary(ScheduleKey, key, "get schedule");
+		return yield* readOne(canonical, "get schedule");
+	});
+	const list = Effect.fn("DoScheduleStore.list")(function* (requestValue) {
+		const operation = "list schedules";
+		const request = yield* decodeBoundary(SchedulePageRequest, requestValue, operation);
+		const rows = request.after === void 0 ? yield* sql`
+            SELECT tenant_id, owner_id, schedule_id, deadline_at_millis, record_json
+            FROM effect_agent_schedules
+            WHERE tenant_id = ${request.owner.tenantId}
+              AND owner_id = ${request.owner.ownerId}
+            ORDER BY schedule_id
+            LIMIT ${request.limit + 1}
+          `.pipe(Effect.mapError(() => unavailable(operation))) : yield* sql`
+            SELECT tenant_id, owner_id, schedule_id, deadline_at_millis, record_json
+            FROM effect_agent_schedules
+            WHERE tenant_id = ${request.owner.tenantId}
+              AND owner_id = ${request.owner.ownerId}
+              AND schedule_id > ${request.after}
+            ORDER BY schedule_id
+            LIMIT ${request.limit + 1}
+          `.pipe(Effect.mapError(() => unavailable(operation)));
+		const decoded = yield* decodeRows(Schema.Array(ScheduleRow), rows, operation);
+		const records = yield* Effect.forEach(decoded, decodeRecord);
+		const hasNext = records.length > request.limit;
+		const items = hasNext ? records.slice(0, request.limit) : records;
+		return {
+			items,
+			next: hasNext ? items.at(-1)?.scheduleId ?? null : null
+		};
+	});
+	const change = Effect.fn("DoScheduleStore.change")(function* (key, change, ownerLimit = defaultSchedulingLimits.maxSchedulesPerOwner) {
+		const operation = "change schedule";
+		const canonicalKey = yield* decodeBoundary(ScheduleKey, key, operation);
+		const canonicalChange = yield* decodeBoundary(ScheduleChange, change, operation);
+		const result = yield* transactions.run((replace) => Effect.gen(function* () {
+			const current = yield* readOne(canonicalKey, operation);
+			if (current === null) return yield* ScheduleNotFound.make({ key: canonicalKey });
+			const transition = applyScheduleChange(current, canonicalChange);
+			if (Result.isFailure(transition)) return yield* transition.failure;
+			const next = transition.success;
+			if (!scheduleUsesCapacity(current) && scheduleUsesCapacity(next)) {
+				const rawCounts = yield* sql`
+              SELECT COUNT(*) AS schedule_count FROM effect_agent_schedules
+              WHERE tenant_id = ${key.owner.tenantId} AND owner_id = ${key.owner.ownerId}
+                AND (json_extract(record_json, '$.pending') IS NOT NULL OR
+                  (json_extract(record_json, '$.state') != 'cancelled' AND json_extract(record_json, '$.nextAtMillis') IS NOT NULL))
+            `.pipe(Effect.mapError(() => unavailable(operation)));
+				const counts = yield* decodeRows(Schema.Array(ScheduleCountRow), rawCounts, operation);
+				if (counts.length !== 1) return yield* corrupt(operation);
+				if (counts[0].schedule_count >= ownerLimit) return yield* ScheduleCapacityError.make({ limit: ownerLimit });
+			}
+			if (next === current) return {
+				record: current,
+				changed: false
+			};
+			const recordJson = yield* encodeRecord(next);
+			yield* scheduleFailpoint.hit(`schedule:${canonicalChange._tag.toLowerCase()}:before`);
+			yield* sql`
+            UPDATE effect_agent_schedules
+            SET deadline_at_millis = ${scheduleDeadline(next)}, record_json = ${recordJson}
+            WHERE tenant_id = ${canonicalKey.owner.tenantId}
+              AND owner_id = ${canonicalKey.owner.ownerId}
+              AND schedule_id = ${canonicalKey.scheduleId}
+          `.pipe(Effect.mapError(() => unavailable(operation)));
+			const deadline = yield* readNextDeadline(void 0, operation);
+			yield* replaceAlarm(replace, deadline, operation);
+			return {
+				record: next,
+				changed: true
+			};
+		}));
+		if (result.changed) yield* scheduleFailpoint.hit(`schedule:${canonicalChange._tag.toLowerCase()}:after`);
+		return result.record;
+	});
+	const due = Effect.fn("DoScheduleStore.due")(function* (nowMillis, limit, owner, after) {
+		const operation = "query due schedules";
+		const cursor = after === void 0 ? void 0 : yield* Schema.decodeUnknownEffect(ScheduleDueCursor)(after).pipe(Effect.mapError(() => corrupt(operation)));
+		const continuation = cursor === void 0 ? sql`1 = 1` : sql`
+      (deadline_at_millis, tenant_id, owner_id, schedule_id) >
+      (${cursor.deadlineAtMillis}, ${cursor.owner.tenantId}, ${cursor.owner.ownerId}, ${cursor.scheduleId})`;
+		const rows = owner === void 0 ? yield* sql`
+            SELECT tenant_id, owner_id, schedule_id, deadline_at_millis
+            FROM effect_agent_schedules
+            WHERE deadline_at_millis <= ${nowMillis} AND ${continuation}
+            ORDER BY deadline_at_millis, tenant_id, owner_id, schedule_id
+            LIMIT ${limit}
+          `.pipe(Effect.mapError(() => unavailable(operation))) : yield* sql`
+            SELECT tenant_id, owner_id, schedule_id, deadline_at_millis
+            FROM effect_agent_schedules
+            WHERE tenant_id = ${owner.tenantId}
+              AND owner_id = ${owner.ownerId}
+              AND deadline_at_millis <= ${nowMillis} AND ${continuation}
+            ORDER BY deadline_at_millis, schedule_id
+            LIMIT ${limit}
+          `.pipe(Effect.mapError(() => unavailable(operation)));
+		return (yield* decodeRows(Schema.Array(ScheduleDueRow), rows, operation)).map((row) => ({
+			owner: {
+				tenantId: row.tenant_id,
+				ownerId: row.owner_id
+			},
+			scheduleId: row.schedule_id,
+			deadlineAtMillis: row.deadline_at_millis
+		}));
+	});
+	const nextDeadline = Effect.fn("DoScheduleStore.nextDeadline")(function* (owner) {
+		return yield* readNextDeadline(owner, "query next schedule deadline");
+	});
+	const prearm = Effect.fn("DoScheduleStore.prearm")(function* (deadlineAtMillis) {
+		yield* decodeBoundary(ScheduleInstant, deadlineAtMillis, "pre-arm schedule recovery");
+		yield* transactions.run((replace) => replaceAlarm(replace, deadlineAtMillis, "pre-arm schedule recovery"));
+		yield* scheduleFailpoint.hit("schedule:prearm:after");
+	});
+	const reconcile = Effect.gen(function* () {
+		yield* transactions.run((replace) => Effect.gen(function* () {
+			const deadline = yield* readNextDeadline(void 0, "reconcile schedule alarm");
+			yield* replaceAlarm(replace, deadline, "reconcile schedule alarm");
+		}));
+		yield* scheduleFailpoint.hit("schedule:reconcile:after");
+	});
+	return Context.make(ScheduleStore, {
+		insert,
+		get,
+		list,
+		change,
+		due,
+		nextDeadline
+	}).pipe(Context.add(DoScheduleAlarmControl, {
+		prearm,
+		reconcile
+	}));
+});
+/**
+* Durable Object SQLite ScheduleStore. Platform code supplies the one transaction owner that
+* combines these SQL mutations with its logical and native alarm lifecycle.
+*/
+const scheduleStoreLayer = Layer.effectContext(makeServices);
+//#endregion
 //#region src/port-protocol.ts
 /**
 * The cross-Durable-Object port protocol (plan §1.3, D-P6-3): Schema request/response/error
@@ -3727,6 +4083,6 @@ const handleEncodedPortRequest = Effect.fn("DoPortRouting.handleEncodedPortReque
 	return yield* encodePortResponse(yield* decodePortRequest(encoded).pipe(Effect.flatMap(executePortRequest), Effect.catch((error) => Effect.succeed(PortFailed.make({ failure: PortProtocolError.make({ message: boundPortDiagnostic(`The port request could not be decoded: ${error.message}`) }) }))))).pipe(Effect.catch((error) => Effect.succeed(encodedProtocolFailure(`The port response could not be encoded: ${error.message}`))));
 });
 //#endregion
-export { ConversationPortTransport, CurrentDoStorageVersion, DEFAULT_MAX_STORED_VALUE_BYTES, DoAppendConflict, DoCheckpointConflict, DoFenceRejected, DoLedgerError, DoStorageCompatibilityError, DoStorageConfig, DoStorageConfigValue, DoStorageCorruptionError, DoStorageError, DoStorageFailpoint, DoStorageFailpointError, DoStorageFailpointLocation, DoStorageFailpointTestControl, DoValueBoundExceeded, LedgerAdmitCall, LedgerAdmitResult, LedgerLookupCall, LedgerLookupResult, LedgerMarkReadyCall, LedgerMarkReadyResult, LedgerRecordChildSettledCall, LedgerRecordChildSettledResult, LedgerRequestAbortCall, LedgerRequestAbortResult, LedgerResolveAdmissionCall, LedgerResolveAdmissionResult, MAX_PORT_DIAGNOSTIC_LENGTH, PortFailed, PortFailure, PortProtocolError, PortRequest, PortResponse, PortResult, PortSucceeded, PortTransportError, StoreAppendCall, StoreAppendResult, StoreExportCall, StoreExportResult, StoreInspectTailCall, StoreInspectTailResult, StoreMaterializeCall, StoreMaterializeResult, StoreReadPageCall, StoreReadPageResult, boundPortDiagnostic, conversationStoreLayer, decodePortRequest, decodePortResponse, doMigrations, encodePortRequest, encodePortResponse, evictionFailpointHandler, executePortRequest, handleEncodedPortRequest, layer, ledgerLayer, observationOffsetAt, portTransportFailure, routedConversationStoreLayer, routedSubmissionLedgerLayer, storageConfigLayer, storageFailpointLayer, submissionLedgerLayer };
+export { ConversationPortTransport, CurrentDoStorageVersion, DEFAULT_MAX_STORED_VALUE_BYTES, DoAppendConflict, DoCheckpointConflict, DoFenceRejected, DoLedgerError, DoScheduleAlarmControl, DoScheduleTransaction, DoStorageCompatibilityError, DoStorageConfig, DoStorageConfigValue, DoStorageCorruptionError, DoStorageError, DoStorageFailpoint, DoStorageFailpointError, DoStorageFailpointLocation, DoStorageFailpointTestControl, DoValueBoundExceeded, LedgerAdmitCall, LedgerAdmitResult, LedgerLookupCall, LedgerLookupResult, LedgerMarkReadyCall, LedgerMarkReadyResult, LedgerRecordChildSettledCall, LedgerRecordChildSettledResult, LedgerRequestAbortCall, LedgerRequestAbortResult, LedgerResolveAdmissionCall, LedgerResolveAdmissionResult, MAX_PORT_DIAGNOSTIC_LENGTH, PortFailed, PortFailure, PortProtocolError, PortRequest, PortResponse, PortResult, PortSucceeded, PortTransportError, StoreAppendCall, StoreAppendResult, StoreExportCall, StoreExportResult, StoreInspectTailCall, StoreInspectTailResult, StoreMaterializeCall, StoreMaterializeResult, StoreReadPageCall, StoreReadPageResult, boundPortDiagnostic, conversationStoreLayer, decodePortRequest, decodePortResponse, doMigrations, encodePortRequest, encodePortResponse, evictionFailpointHandler, executePortRequest, handleEncodedPortRequest, layer, ledgerLayer, observationOffsetAt, portTransportFailure, routedConversationStoreLayer, routedSubmissionLedgerLayer, scheduleStoreLayer, storageConfigLayer, storageFailpointLayer, submissionLedgerLayer };
 
 //# sourceMappingURL=index.mjs.map