effect-cf 0.40.0 → 0.40.2

package/dist/DurableObjectState-DJ0K-zyd.d.mts

@@ -1,244 +0,0 @@
-import { i as WorkerContextWaitUntilOptions } from "./Worker-gV4mDqIs.mjs";
-import { Cause, Context, Duration, Effect, Option, Schema } from "effect";
-declare namespace DurableObjectStorage_d_exports {
-  export { DurableObjectStorage, DurableObjectTransaction, SchemaBackedSyncKvStorage, SqlCursor, SqlStorage, SqlStorageValue, StorageOperationError, SyncKvDefinition, SyncKvStorage, fromDurableObjectStorage };
-}
-type SqlStorageValue = globalThis.SqlStorageValue;
-declare const StorageOperationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
-  readonly _tag: "StorageOperationError";
-} & Readonly<A>;
-declare class StorageOperationError extends StorageOperationError_base<{
-  readonly operation: string;
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-type StorageEffect<A> = Effect.Effect<A, StorageOperationError>;
-interface SqlCursor<T extends Record<string, SqlStorageValue>> {
-  next(): StorageEffect<{
-    done?: false;
-    value: T;
-  } | {
-    done: true;
-    value?: never;
-  }>;
-  toArray(): StorageEffect<Array<T>>;
-  one(): StorageEffect<T>;
-  raw<U extends Array<SqlStorageValue>>(): StorageEffect<IterableIterator<U>>;
-  readonly columnNames: Array<string>;
-  readonly rowsRead: StorageEffect<number>;
-  readonly rowsWritten: StorageEffect<number>;
-}
-interface SqlStorage {
-  exec<T extends Record<string, SqlStorageValue>>(query: string, ...bindings: Array<SqlStorageValue>): StorageEffect<SqlCursor<T>>;
-  readonly databaseSize: number;
-}
-interface SyncKvDefinition<Key, Value, EncodedValue> {
-  readonly key: Schema.Codec<Key, string>;
-  readonly value: Schema.Codec<Value, EncodedValue>;
-}
-/**
- * Sync KV wrapper that transparently encodes keys/values through Effect Schema.
- */
-interface SchemaBackedSyncKvStorage<Key, Value> {
-  get(key: Key): Effect.Effect<Option.Option<Value>, unknown>;
-  put(key: Key, value: Value): Effect.Effect<void, unknown>;
-  delete(key: Key): Effect.Effect<boolean, unknown>;
-  list(options?: globalThis.SyncKvListOptions): Effect.Effect<Array<[Key, Value]>, unknown>;
-}
-interface SyncKvStorage {
-  get<T = unknown>(key: string): StorageEffect<T | undefined>;
-  put<T>(key: string, value: T): StorageEffect<void>;
-  delete(key: string): StorageEffect<boolean>;
-  list<T = unknown>(options?: globalThis.SyncKvListOptions): StorageEffect<Array<[string, T]>>;
-  schema<Key, Value, EncodedValue>(definition: SyncKvDefinition<Key, Value, EncodedValue>): SchemaBackedSyncKvStorage<Key, Value>;
-}
-/**
- * Effect wrapper around Cloudflare transaction callbacks.
- */
-interface DurableObjectTransaction {
-  get<T = unknown>(key: string, options?: globalThis.DurableObjectGetOptions): StorageEffect<T | undefined>;
-  get<T = unknown>(keys: Array<string>, options?: globalThis.DurableObjectGetOptions): StorageEffect<Map<string, T>>;
-  list<T = unknown>(options?: globalThis.DurableObjectListOptions): StorageEffect<Map<string, T>>;
-  put<T>(key: string, value: T, options?: globalThis.DurableObjectPutOptions): StorageEffect<void>;
-  put<T>(entries: Record<string, T>, options?: globalThis.DurableObjectPutOptions): StorageEffect<void>;
-  delete(key: string, options?: globalThis.DurableObjectPutOptions): StorageEffect<boolean>;
-  delete(keys: Array<string>, options?: globalThis.DurableObjectPutOptions): StorageEffect<number>;
-  rollback(): StorageEffect<void>;
-  getAlarm(options?: globalThis.DurableObjectGetAlarmOptions): StorageEffect<number | null>;
-  setAlarm(scheduledTime: number | Date, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
-  setAlarmAfter(delay: Duration.Input, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
-  deleteAlarm(options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
-}
-interface DurableObjectStorage {
-  get<T = unknown>(key: string, options?: globalThis.DurableObjectGetOptions): StorageEffect<T | undefined>;
-  put<T>(key: string, value: T, options?: globalThis.DurableObjectPutOptions): StorageEffect<void>;
-  delete(key: string, options?: globalThis.DurableObjectPutOptions): StorageEffect<boolean>;
-  /**
-   * Deletes all stored data. On compatibility dates before 2026-02-24, Cloudflare
-   * documents that active alarms must be deleted separately with `deleteAlarm()`.
-   */
-  deleteAll(options?: globalThis.DurableObjectPutOptions): StorageEffect<void>;
-  getAlarm(options?: globalThis.DurableObjectGetAlarmOptions): StorageEffect<number | null>;
-  setAlarm(scheduledTime: number | Date, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
-  setAlarmAfter(delay: Duration.Input, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
-  deleteAlarm(options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
-  /**
-   * SQLite-backed Durable Object storage only.
-   *
-   * The callback Effect must complete synchronously. If it requires asynchronous
-   * work, use `transaction` instead so Cloudflare can run the async transaction
-   * callback under the platform's transaction contract.
-   */
-  transactionSync<A, E, R>(closure: () => Effect.Effect<A, E, R>): Effect.Effect<A, E | StorageOperationError, R>;
-  /**
-   * Runs an async transaction and exposes a typed transaction wrapper.
-   */
-  transaction<A, E, R>(closure: (txn: DurableObjectTransaction) => Effect.Effect<A, E, R>): Effect.Effect<A, E | StorageOperationError, R>;
-  /** Flushes pending writes to disk. */
-  sync(): StorageEffect<void>;
-  /** Requires SQLite-backed Durable Object storage. */
-  getCurrentBookmark(): StorageEffect<string>;
-  /** Requires SQLite-backed Durable Object storage. */
-  onNextSessionRestoreBookmark(bookmark: string): StorageEffect<string>;
-  readonly sql: SqlStorage;
-  readonly kv: SyncKvStorage;
-}
-declare const fromDurableObjectStorage: (storage: globalThis.DurableObjectStorage) => DurableObjectStorage;
-declare namespace DurableObjectWebSocket_d_exports {
-  export { AcceptUpgradeOptions, AcceptedUpgrade, AttachmentInvalidPolicy, AttachmentRehydrateOptions, DurableWebSocket, DurableWebSocketAttachment, DurableWebSocketAttachmentError, DurableWebSocketCloseError, DurableWebSocketHandlers, DurableWebSocketSendData, DurableWebSocketSendError, RehydratedDurableWebSocket, acceptUpgrade, attachment, fromWebSocket, handlers };
-}
-type DurableWebSocketSendData = string | ArrayBuffer | ArrayBufferView;
-declare const DurableWebSocketSendError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-  readonly _tag: "DurableWebSocketSendError";
-} & Readonly<A>;
-declare class DurableWebSocketSendError extends DurableWebSocketSendError_base<{
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-declare const DurableWebSocketCloseError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-  readonly _tag: "DurableWebSocketCloseError";
-} & Readonly<A>;
-declare class DurableWebSocketCloseError extends DurableWebSocketCloseError_base<{
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-declare const DurableWebSocketAttachmentError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-  readonly _tag: "DurableWebSocketAttachmentError";
-} & Readonly<A>;
-/** Error raised when serializing or deserializing a websocket attachment fails. */
-declare class DurableWebSocketAttachmentError extends DurableWebSocketAttachmentError_base<{
-  readonly operation: "serialize" | "deserialize";
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-interface DurableWebSocket<Attachment = unknown> {
-  readonly raw: WebSocket;
-  send(data: DurableWebSocketSendData): Effect.Effect<void, DurableWebSocketSendError>;
-  close(code?: number, reason?: string): Effect.Effect<void, DurableWebSocketCloseError>;
-  /** Serializes hibernation attachment metadata onto the socket. */
-  serializeAttachment<A extends Attachment = Attachment>(value: A): Effect.Effect<void, DurableWebSocketAttachmentError>;
-  /** Deserializes hibernation attachment metadata from the socket. */
-  readonly deserializeAttachment: Effect.Effect<unknown, DurableWebSocketAttachmentError>;
-}
-declare const fromWebSocket: <Attachment = unknown>(raw: WebSocket) => DurableWebSocket<Attachment>;
-interface AcceptUpgradeOptions<Attachment = unknown> {
-  readonly tags?: ReadonlyArray<string> | undefined;
-  /** Optional attachment serialized onto the server socket. */
-  readonly attachment?: Attachment | undefined;
-}
-interface AcceptedUpgrade<Attachment = unknown> {
-  readonly client: WebSocket;
-  readonly server: DurableWebSocket<Attachment>;
-  readonly response: Response;
-}
-declare const acceptUpgrade: <Attachment = unknown>(options?: AcceptUpgradeOptions<Attachment> | undefined) => Effect.Effect<AcceptedUpgrade<Attachment>, DurableWebSocketAttachmentError, DurableObjectState>;
-type AttachmentInvalidPolicy = "ignore" | "ignore-and-close" | "fail";
-interface AttachmentRehydrateOptions {
-  readonly tag?: string | undefined;
-  readonly onInvalid?: AttachmentInvalidPolicy | undefined;
-}
-interface RehydratedDurableWebSocket<Attachment> {
-  readonly socket: DurableWebSocket<Attachment>;
-  readonly attachment: Attachment;
-}
-interface DurableWebSocketAttachment<Attachment, Encoded> {
-  serialize(socket: DurableWebSocket<unknown>, value: Attachment): Effect.Effect<void, DurableWebSocketAttachmentError>;
-  deserialize(socket: DurableWebSocket<unknown>): Effect.Effect<Option.Option<Attachment>, DurableWebSocketAttachmentError>;
-  rehydrate(options?: AttachmentRehydrateOptions): Effect.Effect<Array<RehydratedDurableWebSocket<Attachment>>, DurableWebSocketAttachmentError, DurableObjectState>;
-  readonly schema: Schema.Codec<Attachment, Encoded, never, never>;
-}
-declare const attachment: <const AttachmentSchema extends Schema.Codec<any, any, never, never>>(schema: AttachmentSchema) => DurableWebSocketAttachment<Schema.Schema.Type<AttachmentSchema>, Schema.Codec.Encoded<AttachmentSchema>>;
-interface DurableWebSocketHandlers<R = never, E = unknown> {
-  readonly message?: (socket: DurableWebSocket, message: string | ArrayBuffer) => Effect.Effect<void, E, R>;
-  readonly close?: (socket: DurableWebSocket, code: number, reason: string, wasClean: boolean) => Effect.Effect<void, E, R>;
-  readonly error?: (socket: DurableWebSocket, cause: unknown) => Effect.Effect<void, E, R>;
-}
-declare const handlers: <R = never, E = unknown>(options: DurableWebSocketHandlers<R, E>) => {
-  webSocketMessage: ((socket: DurableWebSocket, message: string | ArrayBuffer) => Effect.Effect<void, E, R>) | undefined;
-  webSocketClose: ((socket: DurableWebSocket, code: number, reason: string, wasClean: boolean) => Effect.Effect<void, E, R>) | undefined;
-  webSocketError: ((socket: DurableWebSocket, cause: unknown) => Effect.Effect<void, E, R>) | undefined;
-};
-declare namespace DurableObjectState_d_exports {
-  export { DurableObjectState, DurableObjectStateService, fromDurableObjectState };
-}
-/**
- * Effect-friendly wrapper around Cloudflare `DurableObjectState`.
- */
-interface DurableObjectStateService {
-  readonly raw: globalThis.DurableObjectState;
-  readonly id: globalThis.DurableObjectId;
-  readonly storage: DurableObjectStorage;
-  waitUntil(promise: Promise<unknown>): Effect.Effect<void>;
-  /**
-   * Runs a background Effect via Cloudflare's `waitUntil` with the caller's
-   * Effect context, mirroring `WorkerContext.waitUntil` failure modes:
-   * `"observe"` (default) logs or routes failures to `onFailure`, while
-   * `"propagate"` also rejects the native `waitUntil` promise.
-   */
-  waitUntil<A, E, R, R2 = never>(effect: Effect.Effect<A, E, R>, options?: WorkerContextWaitUntilOptions<E, R2>): Effect.Effect<void, never, R | R2>;
-  /**
-   * Runs an Effect inside Cloudflare's `blockConcurrencyWhile` gate.
-   *
-   * Cloudflare resets a Durable Object if the callback throws/rejects, or if the
-   * callback exceeds the platform timeout (currently documented as 30 seconds).
-   * This safe default resolves the callback with the Effect `Exit` for typed
-   * Effect failures and resumes that `Exit` afterward, so typed failures remain
-   * ordinary Effect failures instead of resetting the Durable Object. Defects
-   * and interruptions still reject the callback.
-   */
-  blockConcurrencyWhile<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>;
-  /**
-   * Runs an Effect inside Cloudflare's `blockConcurrencyWhile` gate and lets
-   * Effect failures reject the callback.
-   *
-   * Use this only when Cloudflare's reset-on-throw behavior is intentional. The
-   * platform also resets the Durable Object if the callback exceeds the
-   * documented timeout (currently 30 seconds).
-   */
-  blockConcurrencyWhileOrReset<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>;
-  acceptWebSocket(ws: DurableWebSocket, tags?: Array<string>): Effect.Effect<void>;
-  getWebSockets(tag?: string): Effect.Effect<Array<DurableWebSocket>>;
-  setWebSocketAutoResponse(pair?: WebSocketRequestResponsePair): Effect.Effect<void>;
-  getWebSocketAutoResponse: Effect.Effect<WebSocketRequestResponsePair | null>;
-  getWebSocketAutoResponseTimestamp(ws: DurableWebSocket): Effect.Effect<Date | null>;
-  setHibernatableWebSocketEventTimeout(timeoutMs?: number): Effect.Effect<void>;
-  getHibernatableWebSocketEventTimeout: Effect.Effect<number | null>;
-  getTags(ws: DurableWebSocket): Effect.Effect<Array<string>>;
-  /**
-   * Forcibly resets the Durable Object. Cloudflare logs an uncaught Error using
-   * the optional reason, and the method is not available in `wrangler dev` local
-   * development according to the Durable Object State docs. Set
-   * `retryAlarm: false` to prevent the current alarm invocation from retrying;
-   * this option has no effect outside an alarm handler.
-   */
-  abort(reason?: string, options?: globalThis.DurableObjectAbortOptions): Effect.Effect<void>;
-}
-declare const DurableObjectState_base: Context.ServiceClass<DurableObjectState, "effect-cf/DurableObjectState", DurableObjectStateService>;
-declare class DurableObjectState extends DurableObjectState_base {}
-declare const fromDurableObjectState: (state: globalThis.DurableObjectState) => DurableObjectStateService;
-//#endregion
-export { AcceptedUpgrade as a, DurableWebSocketAttachmentError as c, AcceptUpgradeOptions as i, DurableObjectStorage_d_exports as l, DurableObjectStateService as n, DurableObjectWebSocket_d_exports as o, DurableObjectState_d_exports as r, DurableWebSocket as s, DurableObjectState as t, StorageOperationError as u };