effect-cf 0.46.0 → 0.47.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # effect-cf
 
+## 0.47.0
+
+### Minor Changes
+
+- [#190](https://github.com/danieljvdm/effect-cf/pull/190) [`a3ae008`](https://github.com/danieljvdm/effect-cf/commit/a3ae008af959d08eec649042edc9309982354a0d) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Add `RpcWebSocketClient.layer` and the browser-safe `effect-cf/rpc-websocket-client` entrypoint. Provide a typed client service and its WebSocket connection for an application or session without requiring callers to wrap client construction in `Effect.scoped`. The layer closes the connection when its lifetime ends.
+
+  Persist the RPC serializer's content type in Durable Object WebSocket attachments and reset restored connections whose saved content type differs from the server's, preventing incompatible frames from reaching RPC handlers after a deployment. Existing attachments without serializer metadata remain supported.
+
+  Acknowledge WebSocket close events and ignore late messages on closed connections so client scope cleanup completes the close handshake.
+
+## 0.46.1
+
+### Patch Changes
+
+- [#188](https://github.com/danieljvdm/effect-cf/pull/188) [`731938e`](https://github.com/danieljvdm/effect-cf/commit/731938ec635355c769f451b6153f8eb806ad98c1) Thanks [@limwa](https://github.com/limwa)! - Fix declaration portability by referencing consumer-provided Cloudflare Workers globals instead of importing `@cloudflare/workers-types`.
+
 ## 0.46.0
 
 ### Minor Changes

package/README.md

@@ -10,6 +10,8 @@ The repository tests against workerd `1.20260825.1` and `@cloudflare/workers-typ
 
 See the [runtime performance guide](https://github.com/danieljvdm/effect-cf/blob/main/docs/runtime-performance.md) for measured alarm batching and telemetry configuration guidance.
 
+For typed WebSocket RPC clients whose connection lifetime is owned by an Effect layer, see the [WebSocket RPC guide](https://github.com/danieljvdm/effect-cf/blob/main/docs/websocket-rpc.md).
+
 ## Worker
 
 ```ts

package/dist/AiGateway.d.mts

@@ -3,7 +3,6 @@ import { BindingNotFoundError, BindingValidationError } from "./Binding.mjs";
 import { WorkersAiBinding, isWorkersAiBinding } from "./WorkersAi.mjs";
 import * as Context$1 from "effect/Context";
 import * as Effect from "effect/Effect";
-import { AiGateway } from "@cloudflare/workers-types";
 import { Layer } from "effect";
 declare namespace AiGateway_d_exports {
   export { AiGatewayBinding, AiGatewayClient, AiGatewayDefinition, AiGatewayFetchOptions, AiGatewayHeaders, AiGatewayLog, AiGatewayOperationError, AiGatewayPatchLog, AiGatewayProvider, AiGatewayRunOptions, AiGatewayService, AiGatewayUniversalRequest, BindingNotFoundError, BindingValidationError, LayerOptions, Tag, TagClass, isAiGatewayBinding, layer, make, makeClient, makeClientFromAi, makeHttpClient };
@@ -30,7 +29,7 @@ type AiGatewayLog = Awaited<ReturnType<AiGatewayBinding["getLog"]>>;
 type AiGatewayProvider = NonNullable<Parameters<AiGatewayBinding["getUrl"]>[0]>;
 type AiGatewayUniversalRequest = Exclude<AiGatewayRunData, ReadonlyArray<unknown>>;
 type AiGatewayHeaders = NonNullable<AiGatewayUniversalRequest["headers"]>;
-type AiGatewayRunOptions = Parameters<AiGateway["run"]>[1];
+type AiGatewayRunOptions = Parameters<AiGatewayBinding["run"]>[1];
 type AiGatewayBindingCandidate = Parameters<typeof isWorkersAiBinding>[0];
 interface AiGatewayFetchOptions {
   readonly provider?: AiGatewayProvider;
@@ -64,15 +63,15 @@ interface TagClass<Self, Id extends string> extends Context$1.ServiceClass<Self,
 declare const isAiGatewayBinding: (value: AiGatewayBindingCandidate) => value is WorkersAiBinding;
 declare const makeClient: (definition: AiGatewayDefinition, gateway: AiGatewayBinding) => {
   definition: AiGatewayDefinition;
-  run: (data: import("@cloudflare/workers-types").AIGatewayUniversalRequest | readonly import("@cloudflare/workers-types").AIGatewayUniversalRequest[], options?: {
-    gateway?: import("@cloudflare/workers-types").UniversalGatewayOptions;
+  run: (data: AIGatewayUniversalRequest | readonly AIGatewayUniversalRequest[], options?: {
+    gateway?: UniversalGatewayOptions;
     extraHeaders?: object;
-    signal?: import("@cloudflare/workers-types").AbortSignal;
-  } | undefined) => Effect.Effect<import("@cloudflare/workers-types").Response, AiGatewayOperationError, never>;
+    signal?: AbortSignal;
+  } | undefined) => Effect.Effect<Response, AiGatewayOperationError, never>;
   getUrl: (provider?: string | undefined) => Effect.Effect<string, AiGatewayOperationError, never>;
   fetch: (options: AiGatewayFetchOptions) => Effect.Effect<Response, AiGatewayOperationError, never>;
-  patchLog: (logId: string, data: import("@cloudflare/workers-types").AiGatewayPatchLog) => Effect.Effect<void, AiGatewayOperationError, never>;
-  getLog: (logId: string) => Effect.Effect<import("@cloudflare/workers-types").AiGatewayLog, AiGatewayOperationError, never>;
+  patchLog: (logId: string, data: globalThis.AiGatewayPatchLog) => Effect.Effect<void, AiGatewayOperationError, never>;
+  getLog: (logId: string) => Effect.Effect<globalThis.AiGatewayLog, AiGatewayOperationError, never>;
   rawUnsafe: Effect.Effect<AiGateway, never, never>;
 };
 declare const makeClientFromAi: (definition: AiGatewayDefinition, ai: WorkersAiBinding) => AiGatewayClient;

package/dist/AnalyticsEngine.d.mts

@@ -7,11 +7,10 @@ import * as Layer$1 from "effect/Layer";
 import * as Config$1 from "effect/Config";
 import * as Option from "effect/Option";
 import * as HttpClient from "effect/unstable/http/HttpClient";
-import { AnalyticsEngineDataPoint, AnalyticsEngineDataset } from "@cloudflare/workers-types";
 import { Redacted } from "effect";
 import { Headers, HttpClientResponse } from "effect/unstable/http";
 declare namespace AnalyticsEngine_d_exports {
-  export { AnalyticsEngineBinding, AnalyticsEngineClient, AnalyticsEngineDataPoint$1 as AnalyticsEngineDataPoint, AnalyticsEngineDataPointSchema, AnalyticsEngineDefinition, AnalyticsEngineFieldValue, AnalyticsEngineFieldValueSchema, AnalyticsEngineInvalidWritePolicy, AnalyticsEngineOperationError, AnalyticsEngineQueryClient, AnalyticsEngineQueryColumn, AnalyticsEngineQueryDefinition, AnalyticsEngineQueryError, AnalyticsEngineQueryOptions, AnalyticsEngineQueryResult, AnalyticsEngineQueryRow, AnalyticsEngineQueryService, AnalyticsEngineService, AnalyticsEngineWriteError, AnalyticsEngineWriteOptions, AnalyticsEngineWritePolicy, AnalyticsEngineWriteValidationError, AnalyticsEngineWriteViolation, BindingNotFoundError, BindingValidationError, LayerOptions, QueryConfigOptions, QueryTag, QueryTagClass, Tag, TagClass, isAnalyticsEngineDataset, layer, layerFetch, layerFetchConfig, make, makeClient, makeQuery, makeQueryClient, queryConfig, queryLayer, queryLayerConfig, writeLimits };
+  export { AnalyticsEngineBinding, AnalyticsEngineClient, AnalyticsEngineDataPoint, AnalyticsEngineDataPointSchema, AnalyticsEngineDefinition, AnalyticsEngineFieldValue, AnalyticsEngineFieldValueSchema, AnalyticsEngineInvalidWritePolicy, AnalyticsEngineOperationError, AnalyticsEngineQueryClient, AnalyticsEngineQueryColumn, AnalyticsEngineQueryDefinition, AnalyticsEngineQueryError, AnalyticsEngineQueryOptions, AnalyticsEngineQueryResult, AnalyticsEngineQueryRow, AnalyticsEngineQueryService, AnalyticsEngineService, AnalyticsEngineWriteError, AnalyticsEngineWriteOptions, AnalyticsEngineWritePolicy, AnalyticsEngineWriteValidationError, AnalyticsEngineWriteViolation, BindingNotFoundError, BindingValidationError, LayerOptions, QueryConfigOptions, QueryTag, QueryTagClass, Tag, TagClass, isAnalyticsEngineDataset, layer, layerFetch, layerFetchConfig, make, makeClient, makeQuery, makeQueryClient, queryConfig, queryLayer, queryLayerConfig, writeLimits };
 }
 declare const writeLimits: {
   readonly maxBlobs: 20;
@@ -74,7 +73,7 @@ interface AnalyticsEngineDefinition {
   readonly binding: string;
 }
 type AnalyticsEngineBinding = AnalyticsEngineDataset;
-type AnalyticsEngineDataPoint$1 = AnalyticsEngineDataPoint;
+type AnalyticsEngineDataPoint = globalThis.AnalyticsEngineDataPoint;
 type AnalyticsEngineFieldValue = ArrayBuffer | string | null;
 type AnalyticsEngineWriteError = AnalyticsEngineOperationError | AnalyticsEngineWriteValidationError;
 type AnalyticsEngineInvalidWritePolicy = "error" | "drop";
@@ -104,8 +103,8 @@ interface AnalyticsEngineQueryOptions {
   readonly headers?: Headers.Input;
 }
 interface AnalyticsEngineClient {
-  readonly writeDataPoint: (dataPoint?: AnalyticsEngineDataPoint$1, options?: AnalyticsEngineWriteOptions) => Effect.Effect<void, AnalyticsEngineWriteError>;
-  readonly writeDataPoints: (dataPoints: ReadonlyArray<AnalyticsEngineDataPoint$1>, options?: AnalyticsEngineWriteOptions) => Effect.Effect<void, AnalyticsEngineWriteError>;
+  readonly writeDataPoint: (dataPoint?: AnalyticsEngineDataPoint, options?: AnalyticsEngineWriteOptions) => Effect.Effect<void, AnalyticsEngineWriteError>;
+  readonly writeDataPoints: (dataPoints: ReadonlyArray<AnalyticsEngineDataPoint>, options?: AnalyticsEngineWriteOptions) => Effect.Effect<void, AnalyticsEngineWriteError>;
   readonly rawUnsafe: Effect.Effect<AnalyticsEngineBinding>;
   readonly definition: AnalyticsEngineDefinition;
 }
@@ -168,4 +167,4 @@ declare const makeQuery: <Id extends string>(id: Id) => QueryTagClass<AnalyticsE
 declare const Tag: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
 declare const QueryTag: <Self>() => <Id extends string>(id: Id) => QueryTagClass<Self, Id>;
 //#endregion
-export { AnalyticsEngineBinding, AnalyticsEngineClient, AnalyticsEngineDataPoint$1 as AnalyticsEngineDataPoint, AnalyticsEngineDataPointSchema, AnalyticsEngineDefinition, AnalyticsEngineFieldValue, AnalyticsEngineFieldValueSchema, AnalyticsEngineInvalidWritePolicy, AnalyticsEngineOperationError, AnalyticsEngineQueryClient, AnalyticsEngineQueryColumn, AnalyticsEngineQueryDefinition, AnalyticsEngineQueryError, AnalyticsEngineQueryOptions, AnalyticsEngineQueryResult, AnalyticsEngineQueryRow, AnalyticsEngineQueryService, AnalyticsEngineService, AnalyticsEngineWriteError, AnalyticsEngineWriteOptions, AnalyticsEngineWritePolicy, AnalyticsEngineWriteValidationError, AnalyticsEngineWriteViolation, AnalyticsEngine_d_exports, type BindingNotFoundError, type BindingValidationError, LayerOptions, QueryConfigOptions, QueryTag, QueryTagClass, Tag, TagClass, isAnalyticsEngineDataset, layer, layerFetch, layerFetchConfig, make, makeClient, makeQuery, makeQueryClient, queryConfig, queryLayer, queryLayerConfig, writeLimits };
+export { AnalyticsEngineBinding, AnalyticsEngineClient, AnalyticsEngineDataPoint, AnalyticsEngineDataPointSchema, AnalyticsEngineDefinition, AnalyticsEngineFieldValue, AnalyticsEngineFieldValueSchema, AnalyticsEngineInvalidWritePolicy, AnalyticsEngineOperationError, AnalyticsEngineQueryClient, AnalyticsEngineQueryColumn, AnalyticsEngineQueryDefinition, AnalyticsEngineQueryError, AnalyticsEngineQueryOptions, AnalyticsEngineQueryResult, AnalyticsEngineQueryRow, AnalyticsEngineQueryService, AnalyticsEngineService, AnalyticsEngineWriteError, AnalyticsEngineWriteOptions, AnalyticsEngineWritePolicy, AnalyticsEngineWriteValidationError, AnalyticsEngineWriteViolation, AnalyticsEngine_d_exports, type BindingNotFoundError, type BindingValidationError, LayerOptions, QueryConfigOptions, QueryTag, QueryTagClass, Tag, TagClass, isAnalyticsEngineDataset, layer, layerFetch, layerFetchConfig, make, makeClient, makeQuery, makeQueryClient, queryConfig, queryLayer, queryLayerConfig, writeLimits };

package/dist/Artifacts.d.mts

@@ -2,10 +2,9 @@ import { WorkerEnvironment } from "./Environment.mjs";
 import { BindingNotFoundError, BindingValidationError } from "./Binding.mjs";
 import * as Context$1 from "effect/Context";
 import * as Effect from "effect/Effect";
-import { ArtifactsCreateRepoResult, ArtifactsCreateTokenResult, ArtifactsErrorCode, ArtifactsRepoInfo, ArtifactsTokenInfo, ArtifactsTokenListResult } from "@cloudflare/workers-types";
 import { Layer } from "effect";
 declare namespace Artifacts_d_exports {
-  export { ArtifactsBinding, ArtifactsClient, ArtifactsCommit, ArtifactsCommitIdentity, ArtifactsCreateOptions, ArtifactsCreateRepoResult$1 as ArtifactsCreateRepoResult, ArtifactsCreateTokenResult$1 as ArtifactsCreateTokenResult, ArtifactsDefinition, ArtifactsErrorCode$1 as ArtifactsErrorCode, ArtifactsForkOptions, ArtifactsImportParams, ArtifactsImportSource, ArtifactsImportTarget, ArtifactsImportTargetOptions, ArtifactsListOptions, ArtifactsLogOptions, ArtifactsLogResult, ArtifactsOperation, ArtifactsOperationError, ArtifactsRepoBinding, ArtifactsRepoClient, ArtifactsRepoInfo$1 as ArtifactsRepoInfo, ArtifactsRepoListEntry, ArtifactsRepoListResult, ArtifactsRepoStatus, ArtifactsService, ArtifactsTokenInfo$1 as ArtifactsTokenInfo, ArtifactsTokenListResult$1 as ArtifactsTokenListResult, ArtifactsTokenScope, ArtifactsTokenState, ArtifactsTree, BindingNotFoundError, BindingValidationError, Cursor, LayerOptions, RepoName, Tag, TagClass, artifactsErrorCodes, artifactsErrorNumericCodes, isArtifactsBinding, isArtifactsRepoBinding, layer, make, makeClient };
+  export { ArtifactsBinding, ArtifactsClient, ArtifactsCommit, ArtifactsCommitIdentity, ArtifactsCreateOptions, ArtifactsCreateRepoResult, ArtifactsCreateTokenResult, ArtifactsDefinition, ArtifactsErrorCode, ArtifactsForkOptions, ArtifactsImportParams, ArtifactsImportSource, ArtifactsImportTarget, ArtifactsImportTargetOptions, ArtifactsListOptions, ArtifactsLogOptions, ArtifactsLogResult, ArtifactsOperation, ArtifactsOperationError, ArtifactsRepoBinding, ArtifactsRepoClient, ArtifactsRepoInfo, ArtifactsRepoListEntry, ArtifactsRepoListResult, ArtifactsRepoStatus, ArtifactsService, ArtifactsTokenInfo, ArtifactsTokenListResult, ArtifactsTokenScope, ArtifactsTokenState, ArtifactsTree, BindingNotFoundError, BindingValidationError, Cursor, LayerOptions, RepoName, Tag, TagClass, artifactsErrorCodes, artifactsErrorNumericCodes, isArtifactsBinding, isArtifactsRepoBinding, layer, make, makeClient };
 }
 type ArtifactsOperation = "createClient" | "create" | "get" | "import" | "list" | "delete" | "createToken" | "listTokens" | "getToken" | "revokeToken" | "fork" | "info" | "log" | "readCommit" | "readTree" | "cli";
 declare const artifactsErrorCodes: readonly ["ALREADY_EXISTS", "NOT_FOUND", "IMPORT_IN_PROGRESS", "FORK_IN_PROGRESS", "INVALID_INPUT", "INVALID_REPO_NAME", "INVALID_TTL", "INVALID_URL", "REMOTE_AUTH_REQUIRED", "UPSTREAM_UNAVAILABLE", "MEMORY_LIMIT", "INTERNAL_ERROR"];
@@ -23,7 +22,7 @@ declare const artifactsErrorNumericCodes: {
   readonly MEMORY_LIMIT: 10402;
   readonly INTERNAL_ERROR: 10400;
 };
-type ArtifactsErrorCode$1 = ArtifactsErrorCode;
+type ArtifactsErrorCode = globalThis.ArtifactsErrorCode;
 declare const ArtifactsOperationError_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: "ArtifactsOperationError";
 } & Readonly<A>;
@@ -31,7 +30,7 @@ declare class ArtifactsOperationError extends ArtifactsOperationError_base<{
   readonly binding: string;
   readonly operation: ArtifactsOperation;
   readonly cause: unknown;
-  readonly code?: ArtifactsErrorCode$1 | (string & {});
+  readonly code?: ArtifactsErrorCode | (string & {});
   readonly numericCode?: number;
 }> {
   get message(): string;
@@ -46,9 +45,9 @@ type ArtifactsTokenScope = "read" | "write";
 /** Lifecycle state of a repository token. */
 type ArtifactsTokenState = "active" | "expired" | "revoked";
 type ArtifactsRepoStatus = "ready" | "importing" | "forking";
-type ArtifactsRepoInfo$1 = ArtifactsRepoInfo;
-type ArtifactsCreateRepoResult$1 = Readonly<ArtifactsCreateRepoResult>;
-interface ArtifactsRepoListEntry extends ArtifactsRepoInfo$1 {
+type ArtifactsRepoInfo = globalThis.ArtifactsRepoInfo;
+type ArtifactsCreateRepoResult = Readonly<globalThis.ArtifactsCreateRepoResult>;
+interface ArtifactsRepoListEntry extends ArtifactsRepoInfo {
   readonly status: ArtifactsRepoStatus;
 }
 interface ArtifactsRepoListResult {
@@ -57,11 +56,11 @@ interface ArtifactsRepoListResult {
   readonly cursor?: Cursor;
 }
 /** Result of creating a repository token. */
-type ArtifactsCreateTokenResult$1 = ArtifactsCreateTokenResult;
+type ArtifactsCreateTokenResult = globalThis.ArtifactsCreateTokenResult;
 /** Repository token metadata, excluding its plaintext secret. */
-type ArtifactsTokenInfo$1 = ArtifactsTokenInfo;
+type ArtifactsTokenInfo = globalThis.ArtifactsTokenInfo;
 /** Repository token list result. */
-type ArtifactsTokenListResult$1 = ArtifactsTokenListResult;
+type ArtifactsTokenListResult = globalThis.ArtifactsTokenListResult;
 /** Identity recorded for a Git commit author or committer. */
 interface ArtifactsCommitIdentity {
   readonly name: string;
@@ -126,7 +125,7 @@ interface ArtifactsLogOptions {
   readonly limit?: number;
   readonly offset?: number;
 }
-interface ArtifactsRepoBinding extends Partial<ArtifactsRepoInfo$1> {
+interface ArtifactsRepoBinding extends Partial<ArtifactsRepoInfo> {
   /**
    * Read repository metadata.
    *
@@ -134,49 +133,49 @@ interface ArtifactsRepoBinding extends Partial<ArtifactsRepoInfo$1> {
    * through this method. It is optional solely for compatibility with older
    * local handles that expose metadata as data properties.
    */
-  readonly info?: () => Promise<ArtifactsRepoInfo$1>;
+  readonly info?: () => Promise<ArtifactsRepoInfo>;
   /**
    * Create a Git token for the repository.
    *
    * Scope defaults to `"write"`. TTL is measured in seconds, defaults to
    * 86,400, and must be between 60 and 31,536,000.
    */
-  readonly createToken: (scope?: ArtifactsTokenScope, ttl?: number) => Promise<ArtifactsCreateTokenResult$1>;
-  readonly listTokens: () => Promise<ArtifactsTokenListResult$1>;
+  readonly createToken: (scope?: ArtifactsTokenScope, ttl?: number) => Promise<ArtifactsCreateTokenResult>;
+  readonly listTokens: () => Promise<ArtifactsTokenListResult>;
   readonly revokeToken: (tokenOrId: string) => Promise<boolean>;
-  readonly fork: (name: RepoName, options?: ArtifactsForkOptions) => Promise<ArtifactsCreateRepoResult$1>;
+  readonly fork: (name: RepoName, options?: ArtifactsForkOptions) => Promise<ArtifactsCreateRepoResult>;
   readonly log: (options?: ArtifactsLogOptions) => Promise<ArtifactsLogResult>;
   readonly readCommit: (hash: string) => Promise<ArtifactsCommit>;
   readonly readTree: (hash: string) => Promise<ArtifactsTree>;
 }
 interface ArtifactsBinding {
-  readonly create: (name: RepoName, options?: ArtifactsCreateOptions) => Promise<ArtifactsCreateRepoResult$1>;
+  readonly create: (name: RepoName, options?: ArtifactsCreateOptions) => Promise<ArtifactsCreateRepoResult>;
   readonly get: (name: RepoName) => Promise<ArtifactsRepoBinding>;
-  readonly import: (params: ArtifactsImportParams) => Promise<ArtifactsCreateRepoResult$1>;
+  readonly import: (params: ArtifactsImportParams) => Promise<ArtifactsCreateRepoResult>;
   readonly list: (options?: ArtifactsListOptions) => Promise<ArtifactsRepoListResult>;
   readonly delete: (name: RepoName) => Promise<boolean>;
 }
-interface ArtifactsRepoClient extends ArtifactsRepoInfo$1 {
-  readonly info: () => Effect.Effect<ArtifactsRepoInfo$1, ArtifactsOperationError>;
+interface ArtifactsRepoClient extends ArtifactsRepoInfo {
+  readonly info: () => Effect.Effect<ArtifactsRepoInfo, ArtifactsOperationError>;
   /**
    * Create a Git token for the repository.
    *
    * Scope defaults to `"write"`. TTL is measured in seconds, defaults to
    * 86,400, and must be between 60 and 31,536,000.
    */
-  readonly createToken: (scope?: ArtifactsTokenScope, ttl?: number) => Effect.Effect<ArtifactsCreateTokenResult$1, ArtifactsOperationError>;
-  readonly listTokens: Effect.Effect<ArtifactsTokenListResult$1, ArtifactsOperationError>;
+  readonly createToken: (scope?: ArtifactsTokenScope, ttl?: number) => Effect.Effect<ArtifactsCreateTokenResult, ArtifactsOperationError>;
+  readonly listTokens: Effect.Effect<ArtifactsTokenListResult, ArtifactsOperationError>;
   readonly revokeToken: (tokenOrId: string) => Effect.Effect<boolean, ArtifactsOperationError>;
-  readonly fork: (name: RepoName, options?: ArtifactsForkOptions) => Effect.Effect<ArtifactsCreateRepoResult$1, ArtifactsOperationError>;
+  readonly fork: (name: RepoName, options?: ArtifactsForkOptions) => Effect.Effect<ArtifactsCreateRepoResult, ArtifactsOperationError>;
   readonly log: (options?: ArtifactsLogOptions) => Effect.Effect<ArtifactsLogResult, ArtifactsOperationError>;
   readonly readCommit: (hash: string) => Effect.Effect<ArtifactsCommit, ArtifactsOperationError>;
   readonly readTree: (hash: string) => Effect.Effect<ArtifactsTree, ArtifactsOperationError>;
   readonly raw: ArtifactsRepoBinding;
 }
 interface ArtifactsClient {
-  readonly create: (name: RepoName, options?: ArtifactsCreateOptions) => Effect.Effect<ArtifactsCreateRepoResult$1, ArtifactsOperationError>;
+  readonly create: (name: RepoName, options?: ArtifactsCreateOptions) => Effect.Effect<ArtifactsCreateRepoResult, ArtifactsOperationError>;
   readonly get: (name: RepoName) => Effect.Effect<ArtifactsRepoClient, ArtifactsOperationError>;
-  readonly import: (params: ArtifactsImportParams) => Effect.Effect<ArtifactsCreateRepoResult$1, ArtifactsOperationError>;
+  readonly import: (params: ArtifactsImportParams) => Effect.Effect<ArtifactsCreateRepoResult, ArtifactsOperationError>;
   readonly list: (options?: ArtifactsListOptions) => Effect.Effect<ArtifactsRepoListResult, ArtifactsOperationError>;
   readonly delete: (name: RepoName) => Effect.Effect<boolean, ArtifactsOperationError>;
   readonly rawUnsafe: Effect.Effect<ArtifactsBinding>;
@@ -202,4 +201,4 @@ declare const layer: <Self>(tag: Context$1.Service<Self, ArtifactsClient>, defin
 declare const make: <Id extends string>(id: Id) => TagClass<ArtifactsService<Id>, Id>;
 declare const Tag: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
 //#endregion
-export { ArtifactsBinding, ArtifactsClient, ArtifactsCommit, ArtifactsCommitIdentity, ArtifactsCreateOptions, ArtifactsCreateRepoResult$1 as ArtifactsCreateRepoResult, ArtifactsCreateTokenResult$1 as ArtifactsCreateTokenResult, ArtifactsDefinition, ArtifactsErrorCode$1 as ArtifactsErrorCode, ArtifactsForkOptions, ArtifactsImportParams, ArtifactsImportSource, ArtifactsImportTarget, ArtifactsImportTargetOptions, ArtifactsListOptions, ArtifactsLogOptions, ArtifactsLogResult, ArtifactsOperation, ArtifactsOperationError, ArtifactsRepoBinding, ArtifactsRepoClient, ArtifactsRepoInfo$1 as ArtifactsRepoInfo, ArtifactsRepoListEntry, ArtifactsRepoListResult, ArtifactsRepoStatus, ArtifactsService, ArtifactsTokenInfo$1 as ArtifactsTokenInfo, ArtifactsTokenListResult$1 as ArtifactsTokenListResult, ArtifactsTokenScope, ArtifactsTokenState, ArtifactsTree, Artifacts_d_exports, type BindingNotFoundError, type BindingValidationError, Cursor, LayerOptions, RepoName, Tag, TagClass, artifactsErrorCodes, artifactsErrorNumericCodes, isArtifactsBinding, isArtifactsRepoBinding, layer, make, makeClient };
+export { ArtifactsBinding, ArtifactsClient, ArtifactsCommit, ArtifactsCommitIdentity, ArtifactsCreateOptions, ArtifactsCreateRepoResult, ArtifactsCreateTokenResult, ArtifactsDefinition, ArtifactsErrorCode, ArtifactsForkOptions, ArtifactsImportParams, ArtifactsImportSource, ArtifactsImportTarget, ArtifactsImportTargetOptions, ArtifactsListOptions, ArtifactsLogOptions, ArtifactsLogResult, ArtifactsOperation, ArtifactsOperationError, ArtifactsRepoBinding, ArtifactsRepoClient, ArtifactsRepoInfo, ArtifactsRepoListEntry, ArtifactsRepoListResult, ArtifactsRepoStatus, ArtifactsService, ArtifactsTokenInfo, ArtifactsTokenListResult, ArtifactsTokenScope, ArtifactsTokenState, ArtifactsTree, Artifacts_d_exports, type BindingNotFoundError, type BindingValidationError, Cursor, LayerOptions, RepoName, Tag, TagClass, artifactsErrorCodes, artifactsErrorNumericCodes, isArtifactsBinding, isArtifactsRepoBinding, layer, make, makeClient };

package/dist/Cache.d.mts

@@ -2,12 +2,11 @@ import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
-import { Cache, CacheQueryOptions, CacheStorage, RequestInfo } from "@cloudflare/workers-types";
 declare namespace Cache_d_exports {
-  export { CacheClient, CacheOperation, CacheOperationError, CacheQueryOptions$1 as CacheQueryOptions, CacheRequest, CacheStorage$1 as CacheStorage, CacheStorageClient, layer, layerFrom, makeCacheClient, makeClient };
+  export { CacheClient, CacheOperation, CacheOperationError, CacheQueryOptions, CacheRequest, CacheStorage, CacheStorageClient, layer, layerFrom, makeCacheClient, makeClient };
 }
 type CacheRequest = RequestInfo | URL;
-type CacheQueryOptions$1 = CacheQueryOptions;
+type CacheQueryOptions = globalThis.CacheQueryOptions;
 type CacheOperation = "open" | "match" | "put" | "delete";
 declare const CacheOperationError_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: "CacheOperationError";
@@ -21,21 +20,21 @@ declare class CacheOperationError extends CacheOperationError_base<{
 }
 interface CacheClient {
   readonly name: string;
-  readonly match: (request: CacheRequest, options?: CacheQueryOptions$1) => Effect.Effect<Option.Option<Response>, CacheOperationError>;
+  readonly match: (request: CacheRequest, options?: CacheQueryOptions) => Effect.Effect<Option.Option<Response>, CacheOperationError>;
   readonly put: (request: CacheRequest, response: Response) => Effect.Effect<void, CacheOperationError>;
-  readonly delete: (request: CacheRequest, options?: CacheQueryOptions$1) => Effect.Effect<boolean, CacheOperationError>;
+  readonly delete: (request: CacheRequest, options?: CacheQueryOptions) => Effect.Effect<boolean, CacheOperationError>;
   readonly rawUnsafe: Effect.Effect<Cache>;
 }
 interface CacheStorageClient {
   readonly default: CacheClient;
   readonly open: (name: string) => Effect.Effect<CacheClient, CacheOperationError>;
-  readonly rawUnsafe: Effect.Effect<CacheStorage>;
+  readonly rawUnsafe: Effect.Effect<globalThis.CacheStorage>;
 }
-declare const CacheStorage_base: Context.ServiceClass<CacheStorage$1, "effect-cf/CacheStorage", CacheStorageClient>;
-declare class CacheStorage$1 extends CacheStorage_base {}
+declare const CacheStorage_base: Context.ServiceClass<CacheStorage, "effect-cf/CacheStorage", CacheStorageClient>;
+declare class CacheStorage extends CacheStorage_base {}
 declare const makeCacheClient: (cache: Cache, name?: string) => CacheClient;
-declare const makeClient: (storage: CacheStorage) => CacheStorageClient;
-declare const layerFrom: (storage: CacheStorage) => Layer.Layer<CacheStorage$1>;
-declare const layer: Layer.Layer<CacheStorage$1>;
+declare const makeClient: (storage: globalThis.CacheStorage) => CacheStorageClient;
+declare const layerFrom: (storage: globalThis.CacheStorage) => Layer.Layer<CacheStorage>;
+declare const layer: Layer.Layer<CacheStorage>;
 //#endregion
-export { CacheClient, CacheOperation, CacheOperationError, CacheQueryOptions$1 as CacheQueryOptions, CacheRequest, CacheStorage$1 as CacheStorage, CacheStorageClient, Cache_d_exports, layer, layerFrom, makeCacheClient, makeClient };
+export { CacheClient, CacheOperation, CacheOperationError, CacheQueryOptions, CacheRequest, CacheStorage, CacheStorageClient, Cache_d_exports, layer, layerFrom, makeCacheClient, makeClient };

package/dist/DurableObjectRpcWebSocket.mjs

@@ -40,7 +40,8 @@ const ResumableAttachmentMetadataSchema = Schema.Struct({
 	clientId: Schema.Finite,
 	hasPendingRequests: Schema.Boolean,
 	hasNonResumableRequests: Schema.Boolean,
-	subscriptions: Schema.Array(PersistedSubscriptionSchema)
+	subscriptions: Schema.Array(PersistedSubscriptionSchema),
+	serialization: Schema.optionalKey(Schema.String)
 });
 const decodeResumableAttachment = Schema.decodeUnknownOption(ResumableAttachmentMetadataSchema);
 var DurableObjectRpcWebSocket = class extends Context.Service()("effect-cf/DurableObjectRpcWebSocket") {};
@@ -83,7 +84,8 @@ const layer = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 		const created = {
 			version: legacyAttachmentVersion,
 			clientId: id,
-			hasPendingRequests: false
+			hasPendingRequests: false,
+			serialization: serialization.contentType
 		};
 		writeAttachment(socket.raw, attachmentKey, created);
 		return created;
@@ -143,7 +145,8 @@ const layer = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 					writeAttachment(connection.socket.raw, attachmentKey, {
 						version: legacyAttachmentVersion,
 						clientId: connection.id,
-						hasPendingRequests: connection.requestIds.size > 0
+						hasPendingRequests: connection.requestIds.size > 0,
+						serialization: serialization.contentType
 					});
 					return;
 				}
@@ -153,7 +156,8 @@ const layer = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 					clientId: connection.id,
 					hasPendingRequests: connection.requestIds.size > 0,
 					hasNonResumableRequests: connection.nonResumableRequestIds.size > 0,
-					subscriptions
+					subscriptions,
+					serialization: serialization.contentType
 				});
 			},
 			catch: (cause) => new DurableWebSocketAttachmentError({
@@ -249,6 +253,10 @@ const layer = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 			continue;
 		}
 		const metadata = attachment.metadata;
+		if (metadata.serialization !== void 0 && metadata.serialization !== serialization.contentType) {
+			yield* resetSocket(socket);
+			continue;
+		}
 		if (metadata.version === legacyAttachmentVersion) {
 			if (metadata.hasPendingRequests) yield* resetSocket(socket);
 			else if (connectionsById.has(metadata.clientId)) yield* resetSocket(socket);
@@ -476,7 +484,10 @@ const layer = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 			const connection = register(socket);
 			return Predicate.isTagged(cause, "MaxBufferSizeExceeded") ? Effect.ignore(connection.socket.close(1009, String(cause))) : send(connection, RpcMessage.ResponseDefectEncoded(encodeDefect(cause)));
 		})),
-		close: unregister,
+		close: (socket) => Effect.gen(function* () {
+			resetSockets.add(socket.raw);
+			yield* socket.close(1e3).pipe(Effect.ignore);
+		}).pipe(Effect.ensuring(unregister(socket)), Effect.uninterruptible),
 		error: resetSocket,
 		checkpoint
 	});
@@ -506,12 +517,14 @@ const readAttachment = (socket, key) => {
 		} : { _tag: "Invalid" };
 	}
 	const hasPendingRequests = Predicate.hasProperty(metadata, "hasPendingRequests") ? metadata.hasPendingRequests : false;
-	if ((!Predicate.hasProperty(metadata, "version") || metadata.version === legacyAttachmentVersion) && Predicate.hasProperty(metadata, "clientId") && Predicate.isNumber(metadata.clientId) && isClientId(metadata.clientId) && Predicate.isBoolean(hasPendingRequests)) return {
+	const serialization = Predicate.hasProperty(metadata, "serialization") ? metadata.serialization : void 0;
+	if ((!Predicate.hasProperty(metadata, "version") || metadata.version === legacyAttachmentVersion) && Predicate.hasProperty(metadata, "clientId") && Predicate.isNumber(metadata.clientId) && isClientId(metadata.clientId) && Predicate.isBoolean(hasPendingRequests) && (serialization === void 0 || Predicate.isString(serialization))) return {
 		_tag: "Valid",
 		metadata: {
 			version: legacyAttachmentVersion,
 			clientId: metadata.clientId,
-			hasPendingRequests
+			hasPendingRequests,
+			serialization
 		}
 	};
 	return { _tag: "Invalid" };

package/dist/Email.d.mts

@@ -2,10 +2,9 @@ import { WorkerEnvironment } from "./Environment.mjs";
 import { BindingNotFoundError, BindingValidationError } from "./Binding.mjs";
 import * as Context$1 from "effect/Context";
 import * as Effect from "effect/Effect";
-import { EmailAddress, EmailAttachment, EmailSendResult, SendEmail } from "@cloudflare/workers-types";
 import { Layer } from "effect";
 declare namespace Email_d_exports {
-  export { BindingNotFoundError, BindingValidationError, EmailAddress$1 as EmailAddress, EmailAttachment$1 as EmailAttachment, EmailBinding, EmailClient, EmailDefinition, EmailErrorCode, EmailMessageBuilder, EmailOperationError, EmailRecipients, EmailSendError, EmailSendOptions, EmailSendResult$1 as EmailSendResult, EmailService, EmailValidationError, EmailViolation, LayerOptions, Tag, TagClass, emailErrorCodes, isEmailBinding, layer, make, makeClient, sendLimits, validateMessage };
+  export { BindingNotFoundError, BindingValidationError, EmailAddress, EmailAttachment, EmailBinding, EmailClient, EmailDefinition, EmailErrorCode, EmailMessageBuilder, EmailOperationError, EmailRecipients, EmailSendError, EmailSendOptions, EmailSendResult, EmailService, EmailValidationError, EmailViolation, LayerOptions, Tag, TagClass, emailErrorCodes, isEmailBinding, layer, make, makeClient, sendLimits, validateMessage };
 }
 declare const sendLimits: {
   readonly maxRecipients: 50;
@@ -63,18 +62,18 @@ declare class EmailValidationError extends EmailValidationError_base<{
 interface EmailDefinition {
   readonly binding: string;
 }
-type EmailAddress$1 = EmailAddress;
-type EmailAttachment$1 = EmailAttachment;
+type EmailAddress = globalThis.EmailAddress;
+type EmailAttachment = globalThis.EmailAttachment;
+type EmailSendResult = globalThis.EmailSendResult;
 type EmailMessageBuilder = Parameters<SendEmail["send"]>[0];
-type EmailSendResult$1 = EmailSendResult;
 type EmailBinding = SendEmail;
-type EmailRecipients = string | EmailAddress$1 | ReadonlyArray<string | EmailAddress$1>;
+type EmailRecipients = string | EmailAddress | ReadonlyArray<string | EmailAddress>;
 type EmailSendError = EmailOperationError | EmailValidationError;
 interface EmailSendOptions {
   readonly validate?: boolean;
 }
 interface EmailClient {
-  readonly send: (message: EmailMessageBuilder) => Effect.Effect<EmailSendResult$1, EmailSendError>;
+  readonly send: (message: EmailMessageBuilder) => Effect.Effect<EmailSendResult, EmailSendError>;
   readonly rawUnsafe: Effect.Effect<EmailBinding>;
   readonly definition: EmailDefinition;
 }
@@ -104,4 +103,4 @@ declare const layer: <Self>(tag: Context$1.Service<Self, EmailClient>, definitio
 declare const make: <Id extends string>(id: Id) => TagClass<EmailService<Id>, Id>;
 declare const Tag: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
 //#endregion
-export { type BindingNotFoundError, type BindingValidationError, EmailAddress$1 as EmailAddress, EmailAttachment$1 as EmailAttachment, EmailBinding, EmailClient, EmailDefinition, EmailErrorCode, EmailMessageBuilder, EmailOperationError, EmailRecipients, EmailSendError, EmailSendOptions, EmailSendResult$1 as EmailSendResult, EmailService, EmailValidationError, EmailViolation, Email_d_exports, LayerOptions, Tag, TagClass, emailErrorCodes, isEmailBinding, layer, make, makeClient, sendLimits, validateMessage };
+export { type BindingNotFoundError, type BindingValidationError, EmailAddress, EmailAttachment, EmailBinding, EmailClient, EmailDefinition, EmailErrorCode, EmailMessageBuilder, EmailOperationError, EmailRecipients, EmailSendError, EmailSendOptions, EmailSendResult, EmailService, EmailValidationError, EmailViolation, Email_d_exports, LayerOptions, Tag, TagClass, emailErrorCodes, isEmailBinding, layer, make, makeClient, sendLimits, validateMessage };