@effect-agent/storage-cloudflare 0.1.0-beta.8 → 0.1.0-beta.81

package/dist/DoMemoryStore.d.mts

@@ -0,0 +1,29 @@
+import { Layer, Schema } from "effect";
+import { SqliteClient } from "@effect/sql-sqlite-do";
+import { MemoryMutationFailpoint } from "@effect-agent/core/MemoryStore";
+declare namespace DoMemoryStore_d_exports {
+  export { DoMemoryStorageLimits, defaultDoMemoryStorageLimits, doMemoryStoreLayer, doMemoryStoreLayerWithFailpoints };
+}
+declare const DoMemoryStorageLimits_base: Schema.Class<DoMemoryStorageLimits, Schema.Struct<{
+  readonly maxRowBytes: Schema.Int;
+  readonly maxStorageBytes: Schema.Int;
+  readonly maxDocuments: Schema.Int;
+  readonly maxReceipts: Schema.Int;
+  readonly reservedWithdrawalBytes: Schema.optional<Schema.Natural>;
+  readonly reservedWithdrawalReceipts: Schema.optional<Schema.Natural>;
+}>, {}>;
+declare class DoMemoryStorageLimits extends DoMemoryStorageLimits_base {}
+declare const defaultDoMemoryStorageLimits: DoMemoryStorageLimits;
+/**
+ * Local memory only, without Thread tables. Keep one SQL client per owner and pass the
+ * full storage handle: sql-only handles cannot provide atomic receipts and revisions.
+ * Byte limits conservatively count encoded rows, not SQLite page/index overhead.
+ * Optional withdrawal reserves default to zero and stay within hard byte/receipt limits.
+ * Ordinary Put cannot consume them. Deploy exclusively upgraded writers before relying
+ * on reserves; the SQL accounting migration preserves older writers and their receipts.
+ */
+declare const doMemoryStoreLayerWithFailpoints: (storage: NonNullable<SqliteClient.SqliteClientConfig["storage"]>, limits?: DoMemoryStorageLimits) => Layer.Layer<import("@effect-agent/core/MemoryStore").MemoryReader | import("@effect-agent/core/MemoryStore").MemoryWriter, import("@effect-agent/thread/SqlMemoryStore").SqliteMemoryInitializationError, MemoryMutationFailpoint>;
+declare const doMemoryStoreLayer: (storage: NonNullable<SqliteClient.SqliteClientConfig["storage"]>, limits?: DoMemoryStorageLimits) => Layer.Layer<import("@effect-agent/core/MemoryStore").MemoryReader | import("@effect-agent/core/MemoryStore").MemoryWriter, import("@effect-agent/thread/SqlMemoryStore").SqliteMemoryInitializationError, never>;
+//#endregion
+export { DoMemoryStorageLimits, defaultDoMemoryStorageLimits, doMemoryStoreLayer, doMemoryStoreLayerWithFailpoints, DoMemoryStore_d_exports as t };
+//# sourceMappingURL=DoMemoryStore.d.mts.map

package/dist/DoMemoryStore.mjs

@@ -0,0 +1,55 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { Effect, Layer, Schema } from "effect";
+import { SqliteClient } from "@effect/sql-sqlite-do";
+import { MemoryMutationFailpoint, MemoryStorageError } from "@effect-agent/core/MemoryStore";
+import { SqlMemoryLimits, memoryStoreLayerWithFailpoints } from "@effect-agent/thread/SqlMemoryStore";
+//#region src/DoMemoryStore.ts
+var DoMemoryStore_exports = /* @__PURE__ */ __exportAll({
+	DoMemoryStorageLimits: () => DoMemoryStorageLimits,
+	defaultDoMemoryStorageLimits: () => defaultDoMemoryStorageLimits,
+	doMemoryStoreLayer: () => doMemoryStoreLayer,
+	doMemoryStoreLayerWithFailpoints: () => doMemoryStoreLayerWithFailpoints
+});
+var DoMemoryStorageLimits = class extends Schema.Class("@effect-agent/storage-cloudflare/DoMemoryStorageLimits")({
+	maxRowBytes: Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 19e5
+	})),
+	maxStorageBytes: Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 536870912
+	})),
+	maxDocuments: Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 1e5
+	})),
+	maxReceipts: Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 1e6
+	})),
+	reservedWithdrawalBytes: Schema.optional(Schema.Natural),
+	reservedWithdrawalReceipts: Schema.optional(Schema.Natural)
+}) {};
+const defaultDoMemoryStorageLimits = DoMemoryStorageLimits.make({
+	maxRowBytes: 19e5,
+	maxStorageBytes: 536870912,
+	maxDocuments: 1e4,
+	maxReceipts: 1e5
+});
+/**
+* Local memory only, without Thread tables. Keep one SQL client per owner and pass the
+* full storage handle: sql-only handles cannot provide atomic receipts and revisions.
+* Byte limits conservatively count encoded rows, not SQLite page/index overhead.
+* Optional withdrawal reserves default to zero and stay within hard byte/receipt limits.
+* Ordinary Put cannot consume them. Deploy exclusively upgraded writers before relying
+* on reserves; the SQL accounting migration preserves older writers and their receipts.
+*/
+const doMemoryStoreLayerWithFailpoints = (storage, limits = defaultDoMemoryStorageLimits) => Layer.unwrap(Schema.decodeUnknownEffect(DoMemoryStorageLimits)(limits).pipe(Effect.mapError(() => MemoryStorageError.make({
+	operation: "memory storage limits",
+	reason: "invalid-input"
+})), Effect.map((validated) => memoryStoreLayerWithFailpoints.pipe(Layer.provide(Layer.succeed(SqlMemoryLimits, validated)), Layer.provide(SqliteClient.layer({ storage }))))));
+const doMemoryStoreLayer = (storage, limits = defaultDoMemoryStorageLimits) => doMemoryStoreLayerWithFailpoints(storage, limits).pipe(Layer.provide(MemoryMutationFailpoint.layer));
+//#endregion
+export { DoMemoryStorageLimits, defaultDoMemoryStorageLimits, doMemoryStoreLayer, doMemoryStoreLayerWithFailpoints, DoMemoryStore_exports as t };
+
+//# sourceMappingURL=DoMemoryStore.mjs.map

package/dist/DoMemoryStore.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"DoMemoryStore.mjs","names":[],"sources":["../src/DoMemoryStore.ts"],"sourcesContent":["import { MemoryStorageError, MemoryMutationFailpoint } from \"@effect-agent/core/MemoryStore\";\nimport {\n  memoryStoreLayerWithFailpoints,\n  SqlMemoryLimits,\n} from \"@effect-agent/thread/SqlMemoryStore\";\nimport { SqliteClient } from \"@effect/sql-sqlite-do\";\nimport { Effect, Layer, Schema } from \"effect\";\n\nexport class DoMemoryStorageLimits extends Schema.Class<DoMemoryStorageLimits>(\n  \"@effect-agent/storage-cloudflare/DoMemoryStorageLimits\",\n)({\n  maxRowBytes: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 1_900_000 })),\n  maxStorageBytes: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 536_870_912 })),\n  maxDocuments: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 100_000 })),\n  maxReceipts: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 1_000_000 })),\n  reservedWithdrawalBytes: Schema.optional(Schema.Natural),\n  reservedWithdrawalReceipts: Schema.optional(Schema.Natural),\n}) {}\n\nexport const defaultDoMemoryStorageLimits = DoMemoryStorageLimits.make({\n  maxRowBytes: 1_900_000,\n  maxStorageBytes: 536_870_912,\n  maxDocuments: 10_000,\n  maxReceipts: 100_000,\n});\n\n/**\n * Local memory only, without Thread tables. Keep one SQL client per owner and pass the\n * full storage handle: sql-only handles cannot provide atomic receipts and revisions.\n * Byte limits conservatively count encoded rows, not SQLite page/index overhead.\n * Optional withdrawal reserves default to zero and stay within hard byte/receipt limits.\n * Ordinary Put cannot consume them. Deploy exclusively upgraded writers before relying\n * on reserves; the SQL accounting migration preserves older writers and their receipts.\n */\nexport const doMemoryStoreLayerWithFailpoints = (\n  storage: NonNullable<SqliteClient.SqliteClientConfig[\"storage\"]>,\n  limits: DoMemoryStorageLimits = defaultDoMemoryStorageLimits,\n) =>\n  Layer.unwrap(\n    Schema.decodeUnknownEffect(DoMemoryStorageLimits)(limits).pipe(\n      Effect.mapError(() =>\n        MemoryStorageError.make({ operation: \"memory storage limits\", reason: \"invalid-input\" }),\n      ),\n      Effect.map((validated) =>\n        memoryStoreLayerWithFailpoints.pipe(\n          Layer.provide(Layer.succeed(SqlMemoryLimits, validated)),\n          Layer.provide(SqliteClient.layer({ storage })),\n        ),\n      ),\n    ),\n  );\n\nexport const doMemoryStoreLayer = (\n  storage: NonNullable<SqliteClient.SqliteClientConfig[\"storage\"]>,\n  limits: DoMemoryStorageLimits = defaultDoMemoryStorageLimits,\n) =>\n  doMemoryStoreLayerWithFailpoints(storage, limits).pipe(\n    Layer.provide(MemoryMutationFailpoint.layer),\n  );\n"],"mappings":";;;;;;;;;;;;AAQA,IAAa,wBAAb,cAA2C,OAAO,MAChD,wDACF,CAAC,CAAC;CACA,aAAa,OAAO,IAAI,MAAM,OAAO,UAAU;EAAE,SAAS;EAAG,SAAS;CAAU,CAAC,CAAC;CAClF,iBAAiB,OAAO,IAAI,MAAM,OAAO,UAAU;EAAE,SAAS;EAAG,SAAS;CAAY,CAAC,CAAC;CACxF,cAAc,OAAO,IAAI,MAAM,OAAO,UAAU;EAAE,SAAS;EAAG,SAAS;CAAQ,CAAC,CAAC;CACjF,aAAa,OAAO,IAAI,MAAM,OAAO,UAAU;EAAE,SAAS;EAAG,SAAS;CAAU,CAAC,CAAC;CAClF,yBAAyB,OAAO,SAAS,OAAO,OAAO;CACvD,4BAA4B,OAAO,SAAS,OAAO,OAAO;AAC5D,CAAC,CAAC,CAAC,CAAC;AAEJ,MAAa,+BAA+B,sBAAsB,KAAK;CACrE,aAAa;CACb,iBAAiB;CACjB,cAAc;CACd,aAAa;AACf,CAAC;;;;;;;;;AAUD,MAAa,oCACX,SACA,SAAgC,iCAEhC,MAAM,OACJ,OAAO,oBAAoB,qBAAqB,CAAC,CAAC,MAAM,CAAC,CAAC,KACxD,OAAO,eACL,mBAAmB,KAAK;CAAE,WAAW;CAAyB,QAAQ;AAAgB,CAAC,CACzF,GACA,OAAO,KAAK,cACV,+BAA+B,KAC7B,MAAM,QAAQ,MAAM,QAAQ,iBAAiB,SAAS,CAAC,GACvD,MAAM,QAAQ,aAAa,MAAM,EAAE,QAAQ,CAAC,CAAC,CAC/C,CACF,CACF,CACF;AAEF,MAAa,sBACX,SACA,SAAgC,iCAEhC,iCAAiC,SAAS,MAAM,CAAC,CAAC,KAChD,MAAM,QAAQ,wBAAwB,KAAK,CAC7C"}

package/dist/DoMessageDeliveryStore.d.mts

@@ -0,0 +1,17 @@
+import { a as DoStorageCompatibilityError, o as DoStorageCorruptionError, s as DoStorageError } from "./DoStorageError-Cmhvl4TQ.mjs";
+import { DoStorageConfig } from "./DoStorageConfig.mjs";
+import { DoStorageFailpoint } from "./DoStorageFailpoint.mjs";
+import { MessageDeliveryError, MessageDeliveryStore, MessageDeliveryStoreLimits } from "@effect-agent/thread/MessageDelivery";
+import { Layer } from "effect";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+declare namespace DoMessageDeliveryStore_d_exports {
+  export { doMessageDeliveryStoreLayer };
+}
+/**
+ * Message obligations in a Thread Object's own SQL storage. The platform must prearm
+ * maintenance before insertion and retain its alarm while nextDeadline is present.
+ */
+declare const doMessageDeliveryStoreLayer: (limits?: MessageDeliveryStoreLimits) => Layer.Layer<MessageDeliveryStore, DoStorageCompatibilityError | DoStorageCorruptionError | DoStorageError | MessageDeliveryError, DoStorageConfig | DoStorageFailpoint | SqlClient.SqlClient>;
+//#endregion
+export { doMessageDeliveryStoreLayer, DoMessageDeliveryStore_d_exports as t };
+//# sourceMappingURL=DoMessageDeliveryStore.d.mts.map

package/dist/DoMessageDeliveryStore.mjs

@@ -0,0 +1,32 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { DoStorageConfig } from "./DoStorageConfig.mjs";
+import { DoStorageFailpoint } from "./DoStorageFailpoint.mjs";
+import { a as initializeDoJournal } from "./do-journal-DHqCQeBU.mjs";
+import { MessageDeliveryError, MessageDeliveryStore } from "@effect-agent/thread/MessageDelivery";
+import { SqlMessageDeliveryTransaction, makeSqlMessageDeliveryStore } from "@effect-agent/thread/SqlMessageDeliveryStore";
+import { Effect, Layer } from "effect";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+//#region src/DoMessageDeliveryStore.ts
+var DoMessageDeliveryStore_exports = /* @__PURE__ */ __exportAll({ doMessageDeliveryStoreLayer: () => doMessageDeliveryStoreLayer });
+const transactions = Layer.effect(SqlMessageDeliveryTransaction, Effect.gen(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	return SqlMessageDeliveryTransaction.of({ run: (body) => sql.withTransaction(body).pipe(Effect.catchTag("SqlError", () => MessageDeliveryError.make({
+		reason: "storage",
+		operation: "transaction"
+	}))) });
+}));
+/**
+* Message obligations in a Thread Object's own SQL storage. The platform must prearm
+* maintenance before insertion and retain its alarm while nextDeadline is present.
+*/
+const doMessageDeliveryStoreLayer = (limits) => Layer.effect(MessageDeliveryStore, Effect.gen(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	const config = yield* DoStorageConfig;
+	const failpoint = yield* DoStorageFailpoint;
+	yield* initializeDoJournal(sql, failpoint.hit, config.maxStoredValueBytes);
+	return yield* makeSqlMessageDeliveryStore(limits, { maxStoredValueBytes: config.maxStoredValueBytes });
+})).pipe(Layer.provide(transactions));
+//#endregion
+export { doMessageDeliveryStoreLayer, DoMessageDeliveryStore_exports as t };
+
+//# sourceMappingURL=DoMessageDeliveryStore.mjs.map

package/dist/DoMessageDeliveryStore.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"DoMessageDeliveryStore.mjs","names":[],"sources":["../src/DoMessageDeliveryStore.ts"],"sourcesContent":["import {\n  MessageDeliveryError,\n  MessageDeliveryStore,\n  type MessageDeliveryStoreLimits,\n} from \"@effect-agent/thread/MessageDelivery\";\nimport {\n  makeSqlMessageDeliveryStore,\n  SqlMessageDeliveryTransaction,\n} from \"@effect-agent/thread/SqlMessageDeliveryStore\";\nimport { Effect, Layer } from \"effect\";\nimport * as SqlClient from \"effect/unstable/sql/SqlClient\";\n\nimport { DoStorageConfig } from \"./DoStorageConfig.ts\";\nimport { DoStorageFailpoint } from \"./DoStorageFailpoint.ts\";\nimport { initializeDoJournal } from \"./internal/do-journal.ts\";\n\nconst transactions = Layer.effect(\n  SqlMessageDeliveryTransaction,\n  Effect.gen(function* () {\n    const sql = yield* SqlClient.SqlClient;\n\n    return SqlMessageDeliveryTransaction.of({\n      run: (body) =>\n        sql\n          .withTransaction(body)\n          .pipe(\n            Effect.catchTag(\"SqlError\", () =>\n              MessageDeliveryError.make({ reason: \"storage\", operation: \"transaction\" }),\n            ),\n          ),\n    });\n  }),\n);\n\n/**\n * Message obligations in a Thread Object's own SQL storage. The platform must prearm\n * maintenance before insertion and retain its alarm while nextDeadline is present.\n */\nexport const doMessageDeliveryStoreLayer = (limits?: MessageDeliveryStoreLimits) =>\n  Layer.effect(\n    MessageDeliveryStore,\n    Effect.gen(function* () {\n      const sql = yield* SqlClient.SqlClient;\n      const config = yield* DoStorageConfig;\n      const failpoint = yield* DoStorageFailpoint;\n\n      yield* initializeDoJournal(sql, failpoint.hit, config.maxStoredValueBytes);\n\n      return yield* makeSqlMessageDeliveryStore(limits, {\n        maxStoredValueBytes: config.maxStoredValueBytes,\n      });\n    }),\n  ).pipe(Layer.provide(transactions));\n"],"mappings":";;;;;;;;;;AAgBA,MAAM,eAAe,MAAM,OACzB,+BACA,OAAO,IAAI,aAAa;CACtB,MAAM,MAAM,OAAO,UAAU;CAE7B,OAAO,8BAA8B,GAAG,EACtC,MAAM,SACJ,IACG,gBAAgB,IAAI,CAAC,CACrB,KACC,OAAO,SAAS,kBACd,qBAAqB,KAAK;EAAE,QAAQ;EAAW,WAAW;CAAc,CAAC,CAC3E,CACF,EACN,CAAC;AACH,CAAC,CACH;;;;;AAMA,MAAa,+BAA+B,WAC1C,MAAM,OACJ,sBACA,OAAO,IAAI,aAAa;CACtB,MAAM,MAAM,OAAO,UAAU;CAC7B,MAAM,SAAS,OAAO;CACtB,MAAM,YAAY,OAAO;CAEzB,OAAO,oBAAoB,KAAK,UAAU,KAAK,OAAO,mBAAmB;CAEzE,OAAO,OAAO,4BAA4B,QAAQ,EAChD,qBAAqB,OAAO,oBAC9B,CAAC;AACH,CAAC,CACH,CAAC,CAAC,KAAK,MAAM,QAAQ,YAAY,CAAC"}

package/dist/DoScheduleStore.d.mts

@@ -0,0 +1,36 @@
+import { Context, Effect, Layer } from "effect";
+import * as SqlClientService from "effect/unstable/sql/SqlClient";
+import { ScheduleFailpointError, ScheduleStorageError, ScheduleStore } from "@effect-agent/thread/Schedule";
+declare namespace DoScheduleStore_d_exports {
+  export { DoScheduleAlarmControl, DoScheduleAlarmReplacement, DoScheduleReplaceAlarm, DoScheduleTransaction, scheduleStoreLayer };
+}
+interface DoScheduleAlarmReplacement {
+  readonly deadlineAtMillis: number | null;
+  /** Included in every logical alarm payload so equal-time replacement stays distinguishable. */
+  readonly generation: number;
+}
+type DoScheduleReplaceAlarm = (replacement: DoScheduleAlarmReplacement) => Effect.Effect<void, ScheduleStorageError>;
+declare const DoScheduleTransaction_base: Context.ServiceClass<DoScheduleTransaction, "@effect-agent/storage-cloudflare/DoScheduleTransaction", {
+  readonly run: <A, E, R>(body: (replaceAlarm: DoScheduleReplaceAlarm) => Effect.Effect<A, E, R>) => Effect.Effect<A, E | ScheduleStorageError, R>;
+}>;
+/**
+ * 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.
+ */
+declare class DoScheduleTransaction extends DoScheduleTransaction_base {}
+declare const DoScheduleAlarmControl_base: Context.ServiceClass<DoScheduleAlarmControl, "@effect-agent/storage-cloudflare/DoScheduleAlarmControl", {
+  /** Establish a future recovery wake before cross-Object admission starts. */
+  readonly prearm: (deadlineAtMillis: number) => Effect.Effect<void, ScheduleStorageError | ScheduleFailpointError>;
+  /** Replace or cancel the wake from the object's authoritative indexed deadline. */
+  readonly reconcile: Effect.Effect<void, ScheduleStorageError | ScheduleFailpointError>;
+}>;
+/** Platform driver operations that use the same schedule-state and alarm transaction. */
+declare class DoScheduleAlarmControl extends DoScheduleAlarmControl_base {}
+/**
+ * Durable Object SQLite ScheduleStore. Platform code supplies the one transaction owner that
+ * combines these SQL mutations with its logical and native alarm lifecycle.
+ */
+declare const scheduleStoreLayer: Layer.Layer<ScheduleStore | DoScheduleAlarmControl, ScheduleStorageError, SqlClientService.SqlClient | DoScheduleTransaction>;
+//#endregion
+export { DoScheduleAlarmControl, DoScheduleAlarmReplacement, DoScheduleReplaceAlarm, DoScheduleTransaction, scheduleStoreLayer, DoScheduleStore_d_exports as t };
+//# sourceMappingURL=DoScheduleStore.d.mts.map

package/dist/DoScheduleStore.mjs

@@ -0,0 +1,388 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { Context, Effect, Layer, Result, Schema } from "effect";
+import * as SqlClientService from "effect/unstable/sql/SqlClient";
+import { upgradeV2Schedules } from "@effect-agent/thread/SqlStorageV2Upgrade";
+import { ScheduleCapacityError, ScheduleChange, ScheduleConflict, ScheduleDueCursor, ScheduleFailpoint, ScheduleId, ScheduleInstant, ScheduleKey, ScheduleNotFound, ScheduleOwner, SchedulePageRequest, ScheduleRecord, ScheduleStorageError, ScheduleStore, defaultSchedulingLimits } from "@effect-agent/thread/Schedule";
+import { applyScheduleChange, scheduleDeadline, scheduleUsesCapacity } from "@effect-agent/thread/ScheduleTransition";
+//#region src/DoScheduleStore.ts
+var DoScheduleStore_exports = /* @__PURE__ */ __exportAll({
+	DoScheduleAlarmControl: () => DoScheduleAlarmControl,
+	DoScheduleTransaction: () => DoScheduleTransaction,
+	scheduleStoreLayer: () => scheduleStoreLayer
+});
+const CURRENT_SCHEDULE_STORE_VERSION = 3;
+const MAX_STORED_SCHEDULE_BYTES = 19e5;
+const StoredScheduleJson = Schema.String.check(Schema.isMaxLength(MAX_STORED_SCHEDULE_BYTES));
+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* SqlClientService.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 === 2) {
+		const failpoint = yield* ScheduleFailpoint;
+		yield* sql.withTransaction(Effect.gen(function* () {
+			const current = yield* sql`SELECT storage_version FROM effect_agent_schedule_store_state WHERE singleton=1`;
+			if (current.length === 1 && current[0].storage_version === 3) return;
+			if (current.length !== 1 || current[0].storage_version !== 2) return yield* corrupt("schedule version changed during upgrade");
+			yield* upgradeV2Schedules(MAX_STORED_SCHEDULE_BYTES);
+			yield* failpoint.hit("upgrade:before-version");
+			yield* sql`UPDATE effect_agent_schedule_store_state SET storage_version=3 WHERE singleton=1`;
+			yield* failpoint.hit("upgrade:after-version");
+		})).pipe(Effect.catchTag("StorageUpgradeError", (error) => ScheduleStorageError.make({
+			reason: "corrupt",
+			operation: "upgrade v2 schedules",
+			cause: error
+		})), Effect.catchTag("SqlError", () => unavailable("upgrade v2 schedules")), Effect.catchTag("ScheduleFailpointError", () => unavailable("upgrade v2 schedules failpoint")));
+		return;
+	}
+	if (state.length !== 1 || state[0].storage_version !== CURRENT_SCHEDULE_STORE_VERSION) return yield* corrupt(state.length === 1 ? `${operation}: incompatible storage version ${state[0].storage_version}; expected ${CURRENT_SCHEDULE_STORE_VERSION}` : `${operation}: invalid storage version row`);
+});
+const makeServices = Effect.gen(function* () {
+	const sql = yield* SqlClientService.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
+export { DoScheduleAlarmControl, DoScheduleTransaction, scheduleStoreLayer, DoScheduleStore_exports as t };
+
+//# sourceMappingURL=DoScheduleStore.mjs.map