effect-durable-agent-cloudflare 0.1.0-alpha.22 → 0.1.0-alpha.24

package/dist/durable-object-storage-D3muKtpz.d.ts

@@ -0,0 +1,115 @@
+import { SequenceNumber, SessionId } from "effect-durable-agent/types/core";
+import { CommittedDurableEvent } from "effect-durable-agent/services/session-store";
+import { TranscriptLogIncarnation, TranscriptMaintenanceConfig, TranscriptVersion, TranscriptVersionMeta } from "effect-durable-agent/transcript";
+//#region src/durable-object-transcript-tables.d.ts
+/**
+ * A host's existing synchronous key/value incarnation to adopt (Gia: `gia.log_incarnation` in the
+ * Durable Object's `ctx.storage.kv`). The adapter adopts the host's value when one exists and
+ * otherwise writes the value it mints there too, so host and adapter always name the same log.
+ */
+interface AdoptedLogIncarnation {
+  readonly key: string;
+  readonly kv: {
+    readonly get: (key: string) => unknown;
+    readonly put: (key: string, value: string) => void;
+  };
+}
+//#endregion
+//#region src/durable-object-transcript-maintenance.d.ts
+/**
+ * Something an operator must look at, raised after the transaction that caused it commits.
+ *
+ * - `ProjectionFailed`: a version froze at its last good cursor (§5.2). On the active version
+ *   readers see a degraded tail until a new definition rebuilds it; on a building version the
+ *   active version keeps serving and the backfill reports it.
+ * - `MissedSession`: the active version is one this release no longer carries, so its history is
+ *   frozen behind the log and `current` is being built at once (§7 safety net).
+ */
+type TranscriptAlert = {
+  readonly _tag: "ProjectionFailed";
+  readonly version: TranscriptVersion;
+  readonly role: "active" | "building";
+  readonly failedAtSeq: SequenceNumber;
+  readonly error: string;
+} | {
+  readonly _tag: "MissedSession";
+  readonly activeVersion: TranscriptVersion;
+  readonly currentVersion: TranscriptVersion;
+};
+/**
+ * Host hooks for transcript maintenance. Every hook runs only after the transaction that caused
+ * it has committed, so nothing observed here can be rolled back afterwards.
+ */
+interface DurableObjectTranscriptObserver {
+  readonly onAlert?: (alert: TranscriptAlert) => void;
+  /** A built version became active; connected clients need a window replacement (§9.4). */
+  readonly onActivated?: (activation: {
+    readonly version: TranscriptVersion;
+    readonly previousVersion: TranscriptVersion | undefined;
+  }) => void;
+  /** Bounded builder or cleanup work is pending; the host schedules a slice. */
+  readonly onPendingWork?: () => void;
+}
+/** Bounds on one builder slice. */
+interface DurableObjectTranscriptSliceLimits {
+  /** Log events projected into the building version per slice. */
+  readonly maxEvents: number;
+  /** Events decoded and planned together; matches the store's bounded event read page. */
+  readonly pageEvents: number;
+  /** Rows of retired versions deleted per slice. */
+  readonly maxDeletedRows: number;
+}
+/** Transcript maintenance configuration of one session store. */
+interface DurableObjectTranscriptOptions {
+  /** The definitions this release carries; supplied by the host. */
+  readonly definitions: TranscriptMaintenanceConfig;
+  /** Adopt a host's existing log incarnation instead of minting a new one. */
+  readonly adoptIncarnation?: AdoptedLogIncarnation;
+  readonly observer?: DurableObjectTranscriptObserver;
+  readonly sliceLimits?: Partial<DurableObjectTranscriptSliceLimits>;
+}
+//#endregion
+//#region src/durable-object-storage.d.ts
+/**
+ * Minimal synchronous SQL cursor surface used by Cloudflare Durable Object storage.
+ *
+ * This type is host-only on purpose: framework services should depend on
+ * `EDASessionStore`, not Cloudflare's SQL API.
+ */
+interface DurableObjectSqlCursor<Row> {
+  readonly one: () => Row;
+  readonly toArray: () => Array<Row>;
+}
+/** Minimal synchronous SQL executor surface used by Cloudflare Durable Object storage. */
+interface DurableObjectSqlStorage {
+  readonly exec: <Row = Record<string, unknown>>(query: string, ...bindings: ReadonlyArray<unknown>) => DurableObjectSqlCursor<Row>;
+}
+/**
+ * Durable Object storage capabilities needed by EDA SQL adapters.
+ *
+ * The `transactionSync` callback must remain purely synchronous. Adapter code
+ * may run SQL here; model calls, live publish, and Effect suspension must stay
+ * outside the callback.
+ */
+interface DurableObjectSessionStorage {
+  readonly sql: DurableObjectSqlStorage;
+  readonly transactionSync: <A>(closure: () => A) => A;
+}
+/**
+ * Construction options for one session-scoped Durable Object session store.
+ *
+ * One Durable Object SQLite database represents one EDA session, so `sessionId`
+ * is fixed at layer construction and not a method parameter.
+ */
+interface DurableObjectSessionStoreOptions {
+  readonly sessionId: SessionId;
+  readonly storage: DurableObjectSessionStorage;
+  /**
+   * Transcript definitions to maintain inside every append. Without it the store maintains no
+   * transcript; the Durable Object host always supplies one.
+   */
+  readonly transcript?: DurableObjectTranscriptOptions;
+}
+//#endregion
+export { DurableObjectTranscriptObserver as a, TranscriptAlert as c, DurableObjectSqlStorage as i, AdoptedLogIncarnation as l, DurableObjectSessionStoreOptions as n, DurableObjectTranscriptOptions as o, DurableObjectSqlCursor as r, DurableObjectTranscriptSliceLimits as s, DurableObjectSessionStorage as t };
+//# sourceMappingURL=durable-object-storage-D3muKtpz.d.ts.map