@distilled.cloud/cloudflare 0.8.0 → 0.9.0

package/lib/services/workers.d.ts

@@ -9,85 +9,85 @@ import type * as HttpClient from "effect/unstable/http/HttpClient";
 import * as API from "../client/api.ts";
 import type { Credentials } from "../credentials.ts";
 import { type DefaultErrors } from "../errors.ts";
-declare const ContentTypeRequired_base: Schema.ErrorClass<ContentTypeRequired, Schema.TaggedStruct<"ContentTypeRequired", {
+declare const ContentTypeRequired_base: Schema.Class<ContentTypeRequired, Schema.TaggedStruct<"ContentTypeRequired", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class ContentTypeRequired extends ContentTypeRequired_base {
 }
-declare const DeploymentNotFound_base: Schema.ErrorClass<DeploymentNotFound, Schema.TaggedStruct<"DeploymentNotFound", {
+declare const DeploymentNotFound_base: Schema.Class<DeploymentNotFound, Schema.TaggedStruct<"DeploymentNotFound", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class DeploymentNotFound extends DeploymentNotFound_base {
 }
-declare const DomainNotFound_base: Schema.ErrorClass<DomainNotFound, Schema.TaggedStruct<"DomainNotFound", {
+declare const DomainNotFound_base: Schema.Class<DomainNotFound, Schema.TaggedStruct<"DomainNotFound", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class DomainNotFound extends DomainNotFound_base {
 }
-declare const DurableObjectMustBeSqlite_base: Schema.ErrorClass<DurableObjectMustBeSqlite, Schema.TaggedStruct<"DurableObjectMustBeSqlite", {
+declare const DurableObjectMustBeSqlite_base: Schema.Class<DurableObjectMustBeSqlite, Schema.TaggedStruct<"DurableObjectMustBeSqlite", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class DurableObjectMustBeSqlite extends DurableObjectMustBeSqlite_base {
 }
-declare const InvalidRoute_base: Schema.ErrorClass<InvalidRoute, Schema.TaggedStruct<"InvalidRoute", {
+declare const InvalidRoute_base: Schema.Class<InvalidRoute, Schema.TaggedStruct<"InvalidRoute", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidRoute extends InvalidRoute_base {
 }
-declare const InvalidRoutePattern_base: Schema.ErrorClass<InvalidRoutePattern, Schema.TaggedStruct<"InvalidRoutePattern", {
+declare const InvalidRoutePattern_base: Schema.Class<InvalidRoutePattern, Schema.TaggedStruct<"InvalidRoutePattern", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidRoutePattern extends InvalidRoutePattern_base {
 }
-declare const InvalidWorkerScript_base: Schema.ErrorClass<InvalidWorkerScript, Schema.TaggedStruct<"InvalidWorkerScript", {
+declare const InvalidWorkerScript_base: Schema.Class<InvalidWorkerScript, Schema.TaggedStruct<"InvalidWorkerScript", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidWorkerScript extends InvalidWorkerScript_base {
 }
-declare const QueueConsumerConflict_base: Schema.ErrorClass<QueueConsumerConflict, Schema.TaggedStruct<"QueueConsumerConflict", {
+declare const QueueConsumerConflict_base: Schema.Class<QueueConsumerConflict, Schema.TaggedStruct<"QueueConsumerConflict", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class QueueConsumerConflict extends QueueConsumerConflict_base {
 }
-declare const RouteNotFound_base: Schema.ErrorClass<RouteNotFound, Schema.TaggedStruct<"RouteNotFound", {
+declare const RouteNotFound_base: Schema.Class<RouteNotFound, Schema.TaggedStruct<"RouteNotFound", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class RouteNotFound extends RouteNotFound_base {
 }
-declare const SecretNotFound_base: Schema.ErrorClass<SecretNotFound, Schema.TaggedStruct<"SecretNotFound", {
+declare const SecretNotFound_base: Schema.Class<SecretNotFound, Schema.TaggedStruct<"SecretNotFound", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class SecretNotFound extends SecretNotFound_base {
 }
-declare const ServiceBindingConflict_base: Schema.ErrorClass<ServiceBindingConflict, Schema.TaggedStruct<"ServiceBindingConflict", {
+declare const ServiceBindingConflict_base: Schema.Class<ServiceBindingConflict, Schema.TaggedStruct<"ServiceBindingConflict", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class ServiceBindingConflict extends ServiceBindingConflict_base {
 }
-declare const VersionNotFound_base: Schema.ErrorClass<VersionNotFound, Schema.TaggedStruct<"VersionNotFound", {
+declare const VersionNotFound_base: Schema.Class<VersionNotFound, Schema.TaggedStruct<"VersionNotFound", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class VersionNotFound extends VersionNotFound_base {
 }
-declare const WorkerNotFound_base: Schema.ErrorClass<WorkerNotFound, Schema.TaggedStruct<"WorkerNotFound", {
+declare const WorkerNotFound_base: Schema.Class<WorkerNotFound, Schema.TaggedStruct<"WorkerNotFound", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class WorkerNotFound extends WorkerNotFound_base {
 }
-declare const WorkerVersionNotFound_base: Schema.ErrorClass<WorkerVersionNotFound, Schema.TaggedStruct<"WorkerVersionNotFound", {
+declare const WorkerVersionNotFound_base: Schema.Class<WorkerVersionNotFound, Schema.TaggedStruct<"WorkerVersionNotFound", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;

package/lib/services/workflows.d.ts

@@ -9,43 +9,43 @@ import type * as HttpClient from "effect/unstable/http/HttpClient";
 import * as API from "../client/api.ts";
 import type { Credentials } from "../credentials.ts";
 import { type DefaultErrors } from "../errors.ts";
-declare const InstanceCannotTerminate_base: Schema.ErrorClass<InstanceCannotTerminate, Schema.TaggedStruct<"InstanceCannotTerminate", {
+declare const InstanceCannotTerminate_base: Schema.Class<InstanceCannotTerminate, Schema.TaggedStruct<"InstanceCannotTerminate", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InstanceCannotTerminate extends InstanceCannotTerminate_base {
 }
-declare const InstanceNotFound_base: Schema.ErrorClass<InstanceNotFound, Schema.TaggedStruct<"InstanceNotFound", {
+declare const InstanceNotFound_base: Schema.Class<InstanceNotFound, Schema.TaggedStruct<"InstanceNotFound", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InstanceNotFound extends InstanceNotFound_base {
 }
-declare const InvalidBody_base: Schema.ErrorClass<InvalidBody, Schema.TaggedStruct<"InvalidBody", {
+declare const InvalidBody_base: Schema.Class<InvalidBody, Schema.TaggedStruct<"InvalidBody", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidBody extends InvalidBody_base {
 }
-declare const InvalidRoute_base: Schema.ErrorClass<InvalidRoute, Schema.TaggedStruct<"InvalidRoute", {
+declare const InvalidRoute_base: Schema.Class<InvalidRoute, Schema.TaggedStruct<"InvalidRoute", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidRoute extends InvalidRoute_base {
 }
-declare const VersionNotFound_base: Schema.ErrorClass<VersionNotFound, Schema.TaggedStruct<"VersionNotFound", {
+declare const VersionNotFound_base: Schema.Class<VersionNotFound, Schema.TaggedStruct<"VersionNotFound", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class VersionNotFound extends VersionNotFound_base {
 }
-declare const WorkflowInternalError_base: Schema.ErrorClass<WorkflowInternalError, Schema.TaggedStruct<"WorkflowInternalError", {
+declare const WorkflowInternalError_base: Schema.Class<WorkflowInternalError, Schema.TaggedStruct<"WorkflowInternalError", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class WorkflowInternalError extends WorkflowInternalError_base {
 }
-declare const WorkflowNotFound_base: Schema.ErrorClass<WorkflowNotFound, Schema.TaggedStruct<"WorkflowNotFound", {
+declare const WorkflowNotFound_base: Schema.Class<WorkflowNotFound, Schema.TaggedStruct<"WorkflowNotFound", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@distilled.cloud/cloudflare",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/alchemy-run/distilled",
@@ -63,12 +63,12 @@
     "specs:update": "git -C specs/cloudflare-typescript fetch && git -C specs/cloudflare-typescript checkout main && git -C specs/cloudflare-typescript pull"
   },
   "dependencies": {
-    "@distilled.cloud/core": "0.8.0",
-    "effect": "4.0.0-beta.43"
+    "@distilled.cloud/core": "0.9.0",
+    "effect": "4.0.0-beta.46"
   },
   "devDependencies": {
-    "@effect/platform-node": "4.0.0-beta.43",
-    "@effect/vitest": "4.0.0-beta.43",
+    "@effect/platform-node": "4.0.0-beta.46",
+    "@effect/vitest": "4.0.0-beta.46",
     "@types/bun": "^1.3.0",
     "@types/node": "^25.3.5",
     "dotenv": "^16.5.0",
@@ -77,6 +77,6 @@
     "vitest": "^3.2.3"
   },
   "peerDependencies": {
-    "effect": "4.0.0-beta.43"
+    "effect": "4.0.0-beta.46"
   }
 }

package/src/credentials.ts

@@ -5,7 +5,7 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Redacted from "effect/Redacted";
-import * as ServiceMap from "effect/ServiceMap";
+import * as Context from "effect/Context";
 
 export const DEFAULT_API_BASE_URL = "https://api.cloudflare.com/client/v4";
 
@@ -71,7 +71,7 @@ export class OAuthRefreshError extends Data.TaggedError(
 
 export type CredentialsError = ConfigError | OAuthRefreshError;
 
-export class Credentials extends ServiceMap.Service<
+export class Credentials extends Context.Service<
   Credentials,
   Effect.Effect<ResolvedCredentials, CredentialsError, any>
 >()("CloudflareCredentials") {}

package/src/retry.ts

@@ -1,6 +1,6 @@
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import * as ServiceMap from "effect/ServiceMap";
+import * as Context from "effect/Context";
 export {
   type Options,
   type Factory,
@@ -17,7 +17,7 @@ import {
   transientOptions,
 } from "@distilled.cloud/core/retry";
 
-export class Retry extends ServiceMap.Service<Retry, Policy>()(
+export class Retry extends Context.Service<Retry, Policy>()(
   "CloudflareRetry",
 ) {}