effect-cf 0.40.0 → 0.40.1

package/dist/WorkersAi.d.mts

@@ -0,0 +1,84 @@
+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 * as S from "effect/Schema";
+import { Layer } from "effect";
+declare namespace WorkersAi_d_exports {
+  export { LayerOptions, Tag, TagClass, WorkersAiAsyncBatchResponse, WorkersAiBinding, WorkersAiClient, WorkersAiDefinition, WorkersAiEmbeddingInput, WorkersAiEmbeddingResponse, WorkersAiModelsSearchObject, WorkersAiModelsSearchParams, WorkersAiOperationError, WorkersAiOptions, WorkersAiService, embeddingResponse, isWorkersAiBinding, layer, make, makeClient };
+}
+declare const WorkersAiOperationError_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: "WorkersAiOperationError";
+} & Readonly<A>;
+declare class WorkersAiOperationError extends WorkersAiOperationError_base<{
+  readonly binding: string;
+  readonly operation: string;
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+interface WorkersAiDefinition {
+  readonly binding: string;
+}
+type WorkersAiBinding<ModelList extends AiModelListType = AiModels> = CloudflareAi<ModelList>;
+type WorkersAiOptions = AiOptions;
+type WorkersAiModelsSearchParams = AiModelsSearchParams;
+type WorkersAiModelsSearchObject = AiModelsSearchObject;
+type WorkersAiAsyncBatchResponse = AiAsyncBatchResponse;
+type WorkersAiEmbeddingInput = AiTextEmbeddingsInput | Ai_Cf_Qwen_Qwen3_Embedding_0_6B_Input | Parameters<WorkersAiBinding["run"]>[1];
+declare const embeddingDimensionsKey = "shape";
+interface WorkersAiEmbeddingResponse {
+  readonly data: ReadonlyArray<ReadonlyArray<number>>;
+  readonly [embeddingDimensionsKey]: ReadonlyArray<number>;
+}
+interface WorkersAiClient<ModelList extends AiModelListType = AiModels> {
+  readonly aiGatewayLogId: Effect.Effect<string | null, WorkersAiOperationError>;
+  readonly run: {
+    <Name extends keyof ModelList>(model: Name, input: {
+      readonly requests: ReadonlyArray<ModelList[Name]["inputs"]>;
+    }, options: WorkersAiOptions & {
+      readonly queueRequest: true;
+    }): Effect.Effect<WorkersAiAsyncBatchResponse, WorkersAiOperationError>;
+    <Name extends keyof ModelList>(model: Name, input: ModelList[Name]["inputs"], options: WorkersAiOptions & {
+      readonly returnRawResponse: true;
+    }): Effect.Effect<Response, WorkersAiOperationError>;
+    <Name extends keyof ModelList>(model: Name, input: ModelList[Name]["inputs"], options: WorkersAiOptions & {
+      readonly websocket: true;
+    }): Effect.Effect<Response, WorkersAiOperationError>;
+    <Name extends keyof ModelList>(model: Name, input: ModelList[Name]["inputs"] & {
+      readonly stream: true;
+    }, options?: WorkersAiOptions): Effect.Effect<ReadableStream, WorkersAiOperationError>;
+    <Name extends keyof ModelList>(model: Name, input: ModelList[Name]["inputs"], options?: WorkersAiOptions): Effect.Effect<ModelList[Name]["postProcessedOutputs"], WorkersAiOperationError>;
+    <Input extends Parameters<WorkersAiBinding["run"]>[1], Output = Awaited<ReturnType<WorkersAiBinding["run"]>>>(model: string, input: Input, options?: WorkersAiOptions): Effect.Effect<Output, WorkersAiOperationError>;
+  };
+  readonly runEmbedding: <Input extends WorkersAiEmbeddingInput>(model: string, input: Input, options?: WorkersAiOptions) => Effect.Effect<WorkersAiEmbeddingResponse, WorkersAiOperationError>;
+  readonly models: (params?: WorkersAiModelsSearchParams) => Effect.Effect<ReadonlyArray<WorkersAiModelsSearchObject>, WorkersAiOperationError>;
+  readonly gateway: (gatewayId: string) => Effect.Effect<CloudflareAiGateway, WorkersAiOperationError>;
+  readonly rawUnsafe: Effect.Effect<WorkersAiBinding<ModelList>>;
+  readonly definition: WorkersAiDefinition;
+}
+declare const WorkersAiServiceTypeId: unique symbol;
+interface WorkersAiService<Id extends string> {
+  readonly [WorkersAiServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+type LayerOptions = {
+  readonly binding: string;
+};
+interface TagClass<Self, Id extends string, ModelList extends AiModelListType = AiModels> extends Context$1.ServiceClass<Self, Id, WorkersAiClient<ModelList>> {
+  readonly id: Id;
+  readonly layer: (options: LayerOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+}
+type WorkersAiBindingValue = S.Schema.Type<typeof S.Unknown>;
+declare const isWorkersAiBinding: (value: WorkersAiBindingValue) => value is WorkersAiBinding;
+declare const embeddingResponse: (value: {
+  readonly data?: ReadonlyArray<ReadonlyArray<number>>;
+  readonly [embeddingDimensionsKey]?: ReadonlyArray<number>;
+}) => WorkersAiEmbeddingResponse;
+declare const makeClient: <ModelList extends AiModelListType = AiModels>(definition: WorkersAiDefinition) => (ai: WorkersAiBinding<ModelList>) => WorkersAiClient<ModelList>;
+declare const layer: <Self, ModelList extends AiModelListType = AiModels>(tag: Context$1.Service<Self, WorkersAiClient<ModelList>>, definition: WorkersAiDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const make: <Id extends string>(id: Id) => TagClass<WorkersAiService<Id>, Id, AiModels>;
+declare const Tag: <Self>() => <Id extends string, ModelList extends AiModelListType = AiModels>(id: Id) => TagClass<Self, Id, ModelList>;
+//#endregion
+export { LayerOptions, Tag, TagClass, WorkersAiAsyncBatchResponse, WorkersAiBinding, WorkersAiClient, WorkersAiDefinition, WorkersAiEmbeddingInput, WorkersAiEmbeddingResponse, WorkersAiModelsSearchObject, WorkersAiModelsSearchParams, WorkersAiOperationError, WorkersAiOptions, WorkersAiService, WorkersAi_d_exports, embeddingResponse, isWorkersAiBinding, layer, make, makeClient };

package/dist/WorkersAi.mjs

@@ -0,0 +1,84 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { layer as layer$1 } from "./Binding.mjs";
+import { causeMessage } from "./internal/ErrorMessage.mjs";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as S from "effect/Schema";
+import * as Predicate from "effect/Predicate";
+import * as Option from "effect/Option";
+//#region src/WorkersAi.ts
+var WorkersAi_exports = /* @__PURE__ */ __exportAll({
+	Tag: () => Tag,
+	WorkersAiOperationError: () => WorkersAiOperationError,
+	embeddingResponse: () => embeddingResponse,
+	isWorkersAiBinding: () => isWorkersAiBinding,
+	layer: () => layer,
+	make: () => make,
+	makeClient: () => makeClient
+});
+const expectedWorkersAiBinding = "Workers AI binding with run(), gateway(), and models()";
+var WorkersAiOperationError = class extends Data.TaggedError("WorkersAiOperationError") {
+	get message() {
+		return `Workers AI ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
+	}
+};
+const embeddingDimensionsKey = "shape";
+const workersAiError = (binding, operation, cause) => new WorkersAiOperationError({
+	binding,
+	operation,
+	cause
+});
+const tryWorkersAiPromise = (binding, operation, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => workersAiError(binding, operation, cause)
+});
+const tryWorkersAiSync = (binding, operation, evaluate) => Effect.try({
+	try: evaluate,
+	catch: (cause) => workersAiError(binding, operation, cause)
+});
+const WorkersAiBindingSchema = S.declare((value) => Predicate.hasProperty(value, "run") && Predicate.isFunction(value.run) && Predicate.hasProperty(value, "gateway") && Predicate.isFunction(value.gateway) && Predicate.hasProperty(value, "models") && Predicate.isFunction(value.models));
+const decodeWorkersAiBinding = S.decodeUnknownOption(WorkersAiBindingSchema);
+const isWorkersAiBinding = (value) => Option.isSome(decodeWorkersAiBinding(value));
+const embeddingResponse = (value) => ({
+	data: value.data ?? [],
+	[embeddingDimensionsKey]: value[embeddingDimensionsKey] ?? []
+});
+const decodeEmbeddingResponse = S.decodeUnknownEffect(S.Struct({
+	data: S.optional(S.Array(S.Array(S.Number))),
+	[embeddingDimensionsKey]: S.optional(S.Array(S.Number))
+}));
+const makeClient = (definition) => (ai) => {
+	const run = Effect.fn("WorkersAi.run")((model, input, options) => tryWorkersAiPromise(definition.binding, "run", () => {
+		return ai.run(model, input, options);
+	}));
+	return {
+		definition,
+		aiGatewayLogId: tryWorkersAiSync(definition.binding, "aiGatewayLogId", () => ai.aiGatewayLogId),
+		run,
+		runEmbedding: Effect.fn("WorkersAi.runEmbedding")(function* (model, input, options) {
+			const response = yield* run(model, input, options);
+			const decoded = yield* decodeEmbeddingResponse(response).pipe(Effect.mapError((cause) => new WorkersAiOperationError({
+				binding: definition.binding,
+				operation: "runEmbedding",
+				cause
+			})));
+			return embeddingResponse(decoded);
+		}),
+		models: Effect.fn("WorkersAi.models")((params) => tryWorkersAiPromise(definition.binding, "models", () => ai.models(params))),
+		gateway: (gatewayId) => tryWorkersAiSync(definition.binding, "gateway", () => ai.gateway(gatewayId)),
+		rawUnsafe: Effect.succeed(ai)
+	};
+};
+const layer = (tag, definition) => layer$1(tag, definition.binding, (value) => isWorkersAiBinding(value), makeClient(definition), { expected: expectedWorkersAiBinding });
+const make = (id) => Tag()(id);
+const Tag = () => (id) => {
+	const tag = Context.Service()(id);
+	const makeLayer = (definition) => layer(tag, definition);
+	return Object.assign(tag, {
+		id,
+		layer: makeLayer
+	});
+};
+//#endregion
+export { Tag, WorkersAiOperationError, WorkersAi_exports, embeddingResponse, isWorkersAiBinding, layer, make, makeClient };

package/dist/Workflow.d.mts

@@ -0,0 +1,91 @@
+import { WorkerEnv, WorkerEnvironment } from "./Environment.mjs";
+import { ExecutionContext, WorkerContext } from "./Worker.mjs";
+import { Definition as Definition$1, Handler as Handler$1, LayerOptions as LayerOptions$1, Options as Options$1, TagClass as TagClass$1, implement as implement$1 } from "./WorkflowDefinition.mjs";
+import * as Context$1 from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer$1 from "effect/Layer";
+import * as Cause$1 from "effect/Cause";
+import { WorkflowEntrypoint, WorkflowEvent, WorkflowSleepDuration, WorkflowStep, WorkflowStepConfig, WorkflowStepContext, WorkflowStepEvent, WorkflowTimeoutDuration } from "cloudflare:workers";
+import { Scope } from "effect";
+declare namespace Workflow_d_exports {
+  export { Definition, Handler, LayerOptions, Options, Tag, TagClass, WorkflowClass, WorkflowEvent$1 as WorkflowEvent, WorkflowEventService, WorkflowHandler, WorkflowOptions, WorkflowRunContext, WorkflowStep$1 as WorkflowStep, WorkflowStepContext$1 as WorkflowStepContext, WorkflowStepError, WorkflowStepNonRetryableError, WorkflowStepService, implement, make, sleep, sleepUntil, step, waitForEvent };
+}
+interface WorkflowEventService<Payload = unknown> {
+  readonly raw: WorkflowEvent<unknown>;
+  readonly payload: Payload;
+  readonly timestamp: Date;
+  readonly instanceId: string;
+  readonly workflowName: string;
+}
+declare const WorkflowEvent_base: Context$1.ServiceClass<WorkflowEvent$1, "effect-cf/WorkflowEvent", WorkflowEventService<unknown>>;
+declare class WorkflowEvent$1 extends WorkflowEvent_base {}
+declare const WorkflowStepError_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$1.YieldableError & {
+  readonly _tag: "WorkflowStepError";
+} & Readonly<A>;
+declare class WorkflowStepError extends WorkflowStepError_base<{
+  readonly step?: string;
+  readonly operation: string;
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+declare const WorkflowStepNonRetryableError_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$1.YieldableError & {
+  readonly _tag: "WorkflowStepNonRetryableError";
+} & Readonly<A>;
+/**
+ * Typed step failure that Cloudflare must treat as terminal instead of retrying.
+ *
+ * The workflow boundary converts this value into Cloudflare's native
+ * `NonRetryableError` while preserving the original cause and its message.
+ */
+declare class WorkflowStepNonRetryableError extends WorkflowStepNonRetryableError_base<{
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+interface WorkflowStepService {
+  readonly raw: WorkflowStep;
+  do<A, E, R>(name: string, effect: Effect.Effect<A, E, R>, config?: WorkflowStepConfig): Effect.Effect<A, WorkflowStepError, Exclude<R, WorkflowStepContext$1>>;
+  readonly sleep: (name: string, duration: WorkflowSleepDuration) => Effect.Effect<void, WorkflowStepError>;
+  readonly sleepUntil: (name: string, timestamp: Date | number) => Effect.Effect<void, WorkflowStepError>;
+  readonly waitForEvent: <Payload>(name: string, options: {
+    readonly type: string;
+    readonly timeout?: WorkflowTimeoutDuration | number;
+  }) => Effect.Effect<WorkflowStepEvent<Payload>, WorkflowStepError>;
+}
+declare const WorkflowStep_base: Context$1.ServiceClass<WorkflowStep$1, "effect-cf/WorkflowStep", WorkflowStepService>;
+declare class WorkflowStep$1 extends WorkflowStep_base {}
+declare const WorkflowStepContext_base: Context$1.ServiceClass<WorkflowStepContext$1, "effect-cf/WorkflowStepContext", WorkflowStepContext>;
+declare class WorkflowStepContext$1 extends WorkflowStepContext_base {}
+type RuntimeContext<ROut> = ExecutionContext | WorkerContext | WorkerEnvironment | ROut;
+type WorkflowRunContext<ROut> = RuntimeContext<ROut> | WorkflowEvent$1 | WorkflowStep$1 | Scope.Scope;
+type WorkflowHandler<ROut, Payload = unknown, Result = unknown> = (payload: Payload) => Effect.Effect<Result, unknown, WorkflowRunContext<ROut>>;
+interface WorkflowOptions<ROut, Payload = unknown, Result = unknown> {
+  readonly run: WorkflowHandler<ROut, Payload, Result>;
+}
+type WorkflowClass<Payload, Result, _ROut> = new (ctx: globalThis.ExecutionContext, env: WorkerEnv) => WorkflowEntrypoint<WorkerEnv, Payload> & {
+  run(event: Readonly<WorkflowEvent<Payload>>, step: WorkflowStep): Promise<Result>;
+};
+declare const make: <ROut, LayerError, Payload = unknown, Result = unknown>(layer: Layer$1.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: WorkflowOptions<ROut, Payload, Result>) => WorkflowClass<Payload, Result, ROut>;
+declare const step: <A, E, R>(name: string, effect: Effect.Effect<A, E, R>, config?: WorkflowStepConfig) => Effect.Effect<A, WorkflowStepError, WorkflowStep$1 | Exclude<R, WorkflowStepContext$1>>;
+declare const sleep: (name: string, duration: WorkflowSleepDuration) => Effect.Effect<void, WorkflowStepError, WorkflowStep$1>;
+declare const sleepUntil: (name: string, timestamp: Date | number) => Effect.Effect<void, WorkflowStepError, WorkflowStep$1>;
+declare const waitForEvent: <Payload>(name: string, options: {
+  readonly type: string;
+  readonly timeout?: WorkflowTimeoutDuration | number;
+}) => Effect.Effect<WorkflowStepEvent<Payload>, WorkflowStepError, WorkflowStep$1>;
+type Definition<Id extends string = string, Payload extends Definition$1.Any["payload"] = Definition$1.Any["payload"], Result extends Definition$1.Any["result"] = Definition$1.Any["result"]> = Definition$1<Id, Payload, Result>;
+declare namespace Definition {
+  type Any = Definition$1.Any;
+}
+type LayerOptions = LayerOptions$1;
+type TagClass<Self, Id extends string, Payload extends Definition$1.Any["payload"], Result extends Definition$1.Any["result"]> = TagClass$1<Self, Id, Payload, Result>;
+declare const Tag: <Self>() => <Id extends string, Payload extends Definition$1.Any["payload"], Result extends Definition$1.Any["result"]>(id: Id, definition: {
+  readonly payload: Payload;
+  readonly result: Result;
+}) => TagClass<Self, Id, Payload, Result>;
+declare const implement: typeof implement$1;
+type Handler<ROut, Self extends Definition$1.Any> = Handler$1<ROut, Self>;
+type Options<ROut, Self extends Definition$1.Any> = Options$1<ROut, Self>;
+//#endregion
+export { Definition, Handler, LayerOptions, Options, Tag, TagClass, WorkflowClass, WorkflowEvent$1 as WorkflowEvent, WorkflowEventService, WorkflowHandler, WorkflowOptions, WorkflowRunContext, WorkflowStep$1 as WorkflowStep, WorkflowStepContext$1 as WorkflowStepContext, WorkflowStepError, WorkflowStepNonRetryableError, WorkflowStepService, Workflow_d_exports, implement, make, sleep, sleepUntil, step, waitForEvent };

package/dist/Workflow.mjs

@@ -0,0 +1,139 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { causeMessage } from "./internal/ErrorMessage.mjs";
+import { fromExecutionContext } from "./internal/WorkerContext.mjs";
+import { assumeEntrypointClass } from "./internal/Entrypoint.mjs";
+import { makeEntrypointRuntime, runEventPromise } from "./internal/Runtime.mjs";
+import { ExecutionContext, WorkerContext } from "./Worker.mjs";
+import { Tag as Tag$1, implement as implement$1 } from "./WorkflowDefinition.mjs";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Cause from "effect/Cause";
+import * as FiberSet from "effect/FiberSet";
+import { WorkflowEntrypoint } from "cloudflare:workers";
+import { NonRetryableError } from "cloudflare:workflows";
+//#region src/Workflow.ts
+var Workflow_exports = /* @__PURE__ */ __exportAll({
+	Tag: () => Tag,
+	WorkflowEvent: () => WorkflowEvent$1,
+	WorkflowStep: () => WorkflowStep$1,
+	WorkflowStepContext: () => WorkflowStepContext$1,
+	WorkflowStepError: () => WorkflowStepError,
+	WorkflowStepNonRetryableError: () => WorkflowStepNonRetryableError,
+	implement: () => implement,
+	make: () => make,
+	sleep: () => sleep,
+	sleepUntil: () => sleepUntil,
+	step: () => step,
+	waitForEvent: () => waitForEvent
+});
+var WorkflowEvent$1 = class extends Context.Service()("effect-cf/WorkflowEvent") {};
+var WorkflowStepError = class extends Data.TaggedError("WorkflowStepError") {
+	get message() {
+		const step = this.step === void 0 ? "" : ` in step "${this.step}"`;
+		return `Workflow ${this.operation} failed${step}: ${causeMessage(this.cause)}`;
+	}
+};
+/**
+* Typed step failure that Cloudflare must treat as terminal instead of retrying.
+*
+* The workflow boundary converts this value into Cloudflare's native
+* `NonRetryableError` while preserving the original cause and its message.
+*/
+var WorkflowStepNonRetryableError = class extends Data.TaggedError("WorkflowStepNonRetryableError") {
+	get message() {
+		return `Workflow step failed without retry: ${causeMessage(this.cause)}`;
+	}
+};
+var WorkflowStep$1 = class extends Context.Service()("effect-cf/WorkflowStep") {};
+var WorkflowStepContext$1 = class extends Context.Service()("effect-cf/WorkflowStepContext") {};
+const fromWorkflowEvent = (event) => ({
+	raw: event,
+	payload: event.payload,
+	timestamp: event.timestamp,
+	instanceId: event.instanceId,
+	workflowName: event.workflowName
+});
+const toCloudflareNonRetryableError = (error) => {
+	const cloudflareError = new NonRetryableError(error.message);
+	cloudflareError.cause = error.cause;
+	return cloudflareError;
+};
+const exposeCloudflareNonRetryableError = (effect) => Effect.catchCause(effect, (cause) => {
+	const error = Cause.findErrorOption(cause);
+	return Option.isSome(error) && error.value instanceof WorkflowStepNonRetryableError ? Effect.die(toCloudflareNonRetryableError(error.value)) : Effect.failCause(cause);
+});
+const fromWorkflowStep = (step) => ({
+	raw: step,
+	do: (name, effect, config) => Effect.gen(function* () {
+		const context = yield* Effect.context();
+		return yield* Effect.scoped(Effect.gen(function* () {
+			const runPromise = yield* FiberSet.makeRuntimePromise();
+			return yield* Effect.tryPromise({
+				try: () => {
+					const run = (stepContext) => {
+						const stepEffect = Effect.scoped(Effect.provideService(effect, WorkflowStepContext$1, stepContext));
+						return runPromise(exposeCloudflareNonRetryableError(Effect.provideContext(stepEffect, context)));
+					};
+					const rawStep = step;
+					return config === void 0 ? rawStep.do(name, run) : rawStep.do(name, config, run);
+				},
+				catch: (cause) => new WorkflowStepError({
+					step: name,
+					operation: "do",
+					cause
+				})
+			});
+		}));
+	}),
+	sleep: (name, duration) => Effect.tryPromise({
+		try: () => step.sleep(name, duration),
+		catch: (cause) => new WorkflowStepError({
+			step: name,
+			operation: "sleep",
+			cause
+		})
+	}),
+	sleepUntil: (name, timestamp) => Effect.tryPromise({
+		try: () => step.sleepUntil(name, timestamp),
+		catch: (cause) => new WorkflowStepError({
+			step: name,
+			operation: "sleepUntil",
+			cause
+		})
+	}),
+	waitForEvent: (name, options) => Effect.tryPromise({
+		try: () => {
+			return step.waitForEvent(name, options);
+		},
+		catch: (cause) => new WorkflowStepError({
+			step: name,
+			operation: "waitForEvent",
+			cause
+		})
+	})
+});
+const make = (layer, options) => {
+	class EffectWorkflow extends WorkflowEntrypoint {
+		runtime;
+		constructor(ctx, env) {
+			super(ctx, env);
+			this.runtime = makeEntrypointRuntime(layer, env, Layer.mergeAll(Layer.succeed(ExecutionContext, ctx), Layer.succeed(WorkerContext, fromExecutionContext(ctx))));
+		}
+		run(event, step) {
+			const workflowServices = Layer.mergeAll(Layer.succeed(WorkflowEvent$1, fromWorkflowEvent(event)), Layer.succeed(WorkflowStep$1, fromWorkflowStep(step)));
+			return runEventPromise(this.runtime, options.run(event.payload), workflowServices);
+		}
+	}
+	return assumeEntrypointClass(EffectWorkflow);
+};
+const step = (name, effect, config) => Effect.flatMap(WorkflowStep$1, (workflowStep) => workflowStep.do(name, effect, config));
+const sleep = (name, duration) => Effect.flatMap(WorkflowStep$1, (workflowStep) => workflowStep.sleep(name, duration));
+const sleepUntil = (name, timestamp) => Effect.flatMap(WorkflowStep$1, (workflowStep) => workflowStep.sleepUntil(name, timestamp));
+const waitForEvent = (name, options) => Effect.flatMap(WorkflowStep$1, (workflowStep) => workflowStep.waitForEvent(name, options));
+const Tag = Tag$1;
+const implement = implement$1;
+//#endregion
+export { Tag, WorkflowEvent$1 as WorkflowEvent, WorkflowStep$1 as WorkflowStep, WorkflowStepContext$1 as WorkflowStepContext, WorkflowStepError, WorkflowStepNonRetryableError, Workflow_exports, implement, make, sleep, sleepUntil, step, waitForEvent };

package/dist/{WorkflowBinding-DtVykUCz.d.mts → WorkflowBinding.d.mts}

@@ -1,6 +1,10 @@
-import { c as WorkerEnvironment, r as BindingValidationError, t as BindingNotFoundError } from "./Binding-DKcLrQCM.mjs";
-import { S as ServiceFreeSchema } from "./Worker-gV4mDqIs.mjs";
-import { Context, Effect, Option, Schema } from "effect";
+import { WorkerEnvironment } from "./Environment.mjs";
+import { BindingNotFoundError, BindingValidationError } from "./Binding.mjs";
+import { ServiceFreeSchema } from "./RpcDefinition.mjs";
+import * as Effect from "effect/Effect";
+import * as S from "effect/Schema";
+import * as Option from "effect/Option";
+import { Context } from "effect";
 declare namespace WorkflowBinding_d_exports {
   export { WorkflowBindingClient, WorkflowBindingDefinition, WorkflowInstance, WorkflowInstanceCreateBatchOptions, WorkflowInstanceCreateOptions, WorkflowInstanceEvent, WorkflowInstanceLocationHint, WorkflowInstanceRestartOptions, WorkflowInstanceStatus, WorkflowInstanceStatusName, WorkflowInstanceTerminateOptions, WorkflowOperationError, WorkflowResultDecodeError, isWorkflow, layer, makeClient };
 }
@@ -41,10 +45,10 @@ interface WorkflowBindingDefinition<Payload extends ServiceFreeSchema, Result ex
   readonly result: Result;
 }
 interface WorkflowBindingClient<Payload extends ServiceFreeSchema, Result extends ServiceFreeSchema> {
-  readonly create: (payload: Schema.Schema.Type<Payload>, options?: WorkflowInstanceCreateOptions<Schema.Codec.Encoded<Payload>>) => Effect.Effect<WorkflowInstance<Schema.Schema.Type<Result>>, WorkflowOperationError | Schema.SchemaError>;
-  readonly createBatch: (batch: WorkflowInstanceCreateBatchOptions<Schema.Schema.Type<Payload>, Schema.Codec.Encoded<Payload>>) => Effect.Effect<ReadonlyArray<WorkflowInstance<Schema.Schema.Type<Result>>>, WorkflowOperationError | Schema.SchemaError>;
-  readonly get: (instanceId: string) => Effect.Effect<WorkflowInstance<Schema.Schema.Type<Result>>, WorkflowOperationError>;
-  readonly rawUnsafe: Effect.Effect<CloudflareWorkflow<Schema.Codec.Encoded<Payload>>>;
+  readonly create: (payload: S.Schema.Type<Payload>, options?: WorkflowInstanceCreateOptions<S.Codec.Encoded<Payload>>) => Effect.Effect<WorkflowInstance<S.Schema.Type<Result>>, WorkflowOperationError | S.SchemaError>;
+  readonly createBatch: (batch: WorkflowInstanceCreateBatchOptions<S.Schema.Type<Payload>, S.Codec.Encoded<Payload>>) => Effect.Effect<ReadonlyArray<WorkflowInstance<S.Schema.Type<Result>>>, WorkflowOperationError | S.SchemaError>;
+  readonly get: (instanceId: string) => Effect.Effect<WorkflowInstance<S.Schema.Type<Result>>, WorkflowOperationError>;
+  readonly rawUnsafe: Effect.Effect<CloudflareWorkflow<S.Codec.Encoded<Payload>>>;
 }
 declare const WorkflowOperationError_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: "WorkflowOperationError";
@@ -66,9 +70,9 @@ declare class WorkflowResultDecodeError extends WorkflowResultDecodeError_base<{
 }> {
   get message(): string;
 }
-type WorkflowBindingValue = Schema.Schema.Type<typeof Schema.Unknown>;
+type WorkflowBindingValue = S.Schema.Type<typeof S.Unknown>;
 declare const isWorkflow: <Payload>(value: WorkflowBindingValue) => value is CloudflareWorkflow<Payload>;
-declare const makeClient: <Payload extends ServiceFreeSchema, Result extends ServiceFreeSchema>(definition: WorkflowBindingDefinition<Payload, Result>) => ((workflow: CloudflareWorkflow<Schema.Codec.Encoded<Payload>>) => WorkflowBindingClient<Payload, Result>);
+declare const makeClient: <Payload extends ServiceFreeSchema, Result extends ServiceFreeSchema>(definition: WorkflowBindingDefinition<Payload, Result>) => ((workflow: CloudflareWorkflow<S.Codec.Encoded<Payload>>) => WorkflowBindingClient<Payload, Result>);
 declare const layer: <Self, Payload extends ServiceFreeSchema, Result extends ServiceFreeSchema>(tag: Context.Service<Self, WorkflowBindingClient<Payload, Result>>, definition: WorkflowBindingDefinition<Payload, Result>) => import("effect/Layer").Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 //#endregion
-export { WorkflowInstanceCreateOptions as a, WorkflowInstanceCreateBatchOptions as i, WorkflowBinding_d_exports as n, WorkflowInstanceStatusName as o, WorkflowInstance as r, WorkflowOperationError as s, WorkflowBindingClient as t };
+export { WorkflowBindingClient, WorkflowBindingDefinition, WorkflowBinding_d_exports, WorkflowInstance, WorkflowInstanceCreateBatchOptions, WorkflowInstanceCreateOptions, WorkflowInstanceEvent, WorkflowInstanceLocationHint, WorkflowInstanceRestartOptions, WorkflowInstanceStatus, WorkflowInstanceStatusName, WorkflowInstanceTerminateOptions, WorkflowOperationError, WorkflowResultDecodeError, isWorkflow, layer, makeClient };

package/dist/WorkflowBinding.mjs

@@ -0,0 +1,100 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { layer as layer$1 } from "./Binding.mjs";
+import { causeMessage } from "./internal/ErrorMessage.mjs";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as S from "effect/Schema";
+import * as Predicate from "effect/Predicate";
+import * as Option from "effect/Option";
+//#region src/WorkflowBinding.ts
+var WorkflowBinding_exports = /* @__PURE__ */ __exportAll({
+	WorkflowOperationError: () => WorkflowOperationError,
+	WorkflowResultDecodeError: () => WorkflowResultDecodeError,
+	isWorkflow: () => isWorkflow,
+	layer: () => layer,
+	makeClient: () => makeClient
+});
+const expectedWorkflow = "Workflow binding with create(), createBatch(), and get()";
+var WorkflowOperationError = class extends Data.TaggedError("WorkflowOperationError") {
+	get message() {
+		return `Workflow ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
+	}
+};
+var WorkflowResultDecodeError = class extends Data.TaggedError("WorkflowResultDecodeError") {
+	get message() {
+		return `Workflow result decode failed for binding "${this.binding}" instance "${this.instanceId}": ${causeMessage(this.cause)}`;
+	}
+};
+const workflowError = (binding, operation, cause) => new WorkflowOperationError({
+	binding,
+	operation,
+	cause
+});
+const tryWorkflowPromise = (binding, operation, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => workflowError(binding, operation, cause)
+});
+const WorkflowBindingSchema = S.declare((value) => Predicate.hasProperty(value, "create") && Predicate.isFunction(value.create) && Predicate.hasProperty(value, "createBatch") && Predicate.isFunction(value.createBatch) && Predicate.hasProperty(value, "get") && Predicate.isFunction(value.get));
+const decodeWorkflowBinding = S.decodeUnknownOption(WorkflowBindingSchema);
+const isWorkflow = (value) => Option.isSome(decodeWorkflowBinding(value));
+const makeClient = (definition) => {
+	const encodePayload = S.encodeEffect(definition.payload);
+	const decodeResult = S.decodeUnknownEffect(definition.result);
+	const wrapInstance = (raw) => {
+		const operation = (name, evaluate) => tryWorkflowPromise(definition.binding, name, evaluate);
+		return {
+			raw,
+			id: raw.id,
+			pause: operation("pause", () => raw.pause()),
+			resume: operation("resume", () => raw.resume()),
+			terminate: (options) => operation("terminate", () => raw.terminate(options)),
+			restart: (options) => operation("restart", () => raw.restart(options)),
+			delete: operation("delete", () => raw.delete()),
+			status: operation("status", () => raw.status()).pipe(Effect.flatMap((status) => Effect.gen(function* () {
+				const output = status.output === void 0 || status.output === null && status.status !== "complete" ? Option.none() : Option.some(yield* decodeResult(status.output).pipe(Effect.mapError((cause) => new WorkflowResultDecodeError({
+					binding: definition.binding,
+					instanceId: raw.id,
+					cause
+				}))));
+				return {
+					status: status.status,
+					output,
+					error: status.error === null || status.error === void 0 ? Option.none() : Option.some(status.error)
+				};
+			}))),
+			sendEvent: (event) => operation("sendEvent", () => raw.sendEvent(event))
+		};
+	};
+	return (workflow) => ({
+		create: Effect.fn("WorkflowBinding.create", { attributes: {
+			binding: definition.binding,
+			operation: "create"
+		} })(function* (payload, options) {
+			const encoded = yield* encodePayload(payload);
+			const raw = yield* tryWorkflowPromise(definition.binding, "create", () => workflow.create({
+				...options,
+				params: encoded
+			}));
+			return wrapInstance(raw);
+		}),
+		createBatch: Effect.fn("WorkflowBinding.createBatch", { attributes: {
+			binding: definition.binding,
+			operation: "createBatch"
+		} })(function* (batch) {
+			const encodedBatch = [];
+			for (const item of batch) {
+				const { payload, ...options } = item;
+				encodedBatch.push({
+					...options,
+					params: yield* encodePayload(payload)
+				});
+			}
+			return (yield* tryWorkflowPromise(definition.binding, "createBatch", () => workflow.createBatch(encodedBatch))).map(wrapInstance);
+		}),
+		get: (instanceId) => tryWorkflowPromise(definition.binding, "get", () => workflow.get(instanceId)).pipe(Effect.map(wrapInstance)),
+		rawUnsafe: Effect.succeed(workflow)
+	});
+};
+const layer = (tag, definition) => layer$1(tag, definition.binding, (value) => isWorkflow(value), makeClient(definition), { expected: expectedWorkflow });
+//#endregion
+export { WorkflowBinding_exports, WorkflowOperationError, WorkflowResultDecodeError, isWorkflow, layer, makeClient };

package/dist/WorkflowDefinition.d.mts

@@ -0,0 +1,51 @@
+import { WorkerEnvironment } from "./Environment.mjs";
+import { BindingNotFoundError, BindingValidationError } from "./Binding.mjs";
+import { ServiceFreeSchema } from "./RpcDefinition.mjs";
+import { ExecutionContext, WorkerContext } from "./Worker.mjs";
+import { WorkflowBindingClient, WorkflowInstance, WorkflowInstanceCreateBatchOptions, WorkflowInstanceCreateOptions, WorkflowOperationError } from "./WorkflowBinding.mjs";
+import { WorkflowClass, WorkflowRunContext } from "./Workflow.mjs";
+import * as Context$1 from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as S from "effect/Schema";
+import { Layer } from "effect";
+declare namespace WorkflowDefinition_d_exports {
+  export { Definition, Handler, LayerOptions, Options, Tag, TagClass, Workflow, implement, make };
+}
+interface Definition<Id extends string = string, Payload extends ServiceFreeSchema = ServiceFreeSchema, Result extends ServiceFreeSchema = ServiceFreeSchema> {
+  readonly id: Id;
+  readonly payload: Payload;
+  readonly result: Result;
+}
+declare namespace Definition {
+  type Any = Definition<string, ServiceFreeSchema, ServiceFreeSchema>;
+}
+type Handler<ROut, Self extends Definition.Any> = (payload: S.Schema.Type<Self["payload"]>) => Effect.Effect<S.Schema.Type<Self["result"]>, unknown, WorkflowRunContext<ROut>>;
+interface Options<ROut, Self extends Definition.Any> {
+  readonly run: Handler<ROut, Self>;
+}
+type LayerOptions = {
+  readonly binding: string;
+};
+interface TagClass<Self, Id extends string, Payload extends ServiceFreeSchema, Result extends ServiceFreeSchema> extends Context$1.ServiceClass<Self, `effect-cf/Workflow/${Id}`, WorkflowBindingClient<Payload, Result>> {
+  readonly id: Id;
+  readonly payload: Payload;
+  readonly result: Result;
+  readonly make: <ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options<ROut, Definition<Id, Payload, Result>>) => WorkflowClass<S.Codec.Encoded<Payload>, S.Codec.Encoded<Result>, ROut>;
+  readonly layer: (options: LayerOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+  readonly create: (payload: S.Schema.Type<Payload>, options?: WorkflowInstanceCreateOptions<S.Codec.Encoded<Payload>>) => Effect.Effect<WorkflowInstance<S.Schema.Type<Result>>, WorkflowOperationError | S.SchemaError, Self>;
+  readonly createBatch: (batch: WorkflowInstanceCreateBatchOptions<S.Schema.Type<Payload>, S.Codec.Encoded<Payload>>) => Effect.Effect<ReadonlyArray<WorkflowInstance<S.Schema.Type<Result>>>, WorkflowOperationError | S.SchemaError, Self>;
+  readonly get: (instanceId: string) => Effect.Effect<WorkflowInstance<S.Schema.Type<Result>>, WorkflowOperationError, Self>;
+  readonly rawUnsafe: Effect.Effect<globalThis.Workflow<S.Codec.Encoded<Payload>>, never, Self>;
+}
+declare const make: <Id extends string, Payload extends ServiceFreeSchema, Result extends ServiceFreeSchema>(id: Id, definition: {
+  readonly payload: Payload;
+  readonly result: Result;
+}) => TagClass<Definition<Id, Payload, Result>, Id, Payload, Result>;
+declare const Tag: <Self>() => <Id extends string, Payload extends ServiceFreeSchema, Result extends ServiceFreeSchema>(id: Id, definition: {
+  readonly payload: Payload;
+  readonly result: Result;
+}) => TagClass<Self, Id, Payload, Result>;
+declare const Workflow: typeof Tag;
+declare const implement: <ROut, const Self extends Definition.Any>(_definition: Self, handler: Handler<ROut, Self>) => Handler<ROut, Self>;
+//#endregion
+export { Definition, Handler, LayerOptions, Options, Tag, TagClass, Workflow, WorkflowDefinition_d_exports, implement, make };