effect-cf 0.35.0 → 0.37.0

package/dist/WorkerContext-Yobnfw-K.mjs

@@ -0,0 +1,60 @@
+import { Cause, Effect, Exit, FiberSet } from "effect";
+//#region src/internal/NativeCallback.ts
+/**
+* Runs an Effect callback owned by a native Promise operation.
+*
+* The callback keeps the caller's context, while a private scope owns its
+* fiber. Closing that scope interrupts and joins the callback before awaiting
+* the native operation's settlement.
+*/
+const runNativeCallback = Effect.fnUntraced(function* (operation) {
+	const callerContext = yield* Effect.context();
+	return yield* Effect.scoped(Effect.gen(function* () {
+		let nativePromise;
+		yield* Effect.addFinalizer(() => {
+			const promise = nativePromise;
+			return promise === void 0 ? Effect.void : Effect.promise(() => promise.then(() => void 0, () => void 0));
+		});
+		const runPromise = yield* FiberSet.makeRuntimePromise();
+		return yield* Effect.callback((resume) => {
+			try {
+				nativePromise = operation((effect) => runPromise(Effect.provideContext(Effect.exit(effect), callerContext)));
+			} catch (cause) {
+				resume(Effect.fail(cause));
+				return;
+			}
+			nativePromise.then((value) => resume(Effect.succeed(value)), (cause) => resume(Effect.fail(cause)));
+		});
+	}));
+});
+//#endregion
+//#region src/internal/WorkerContext.ts
+const causeError = (cause) => {
+	const squashed = Cause.squash(cause);
+	return squashed instanceof Error ? squashed : new Error(Cause.pretty(cause), { cause: squashed });
+};
+const failureHandler = (label, cause, options) => Effect.suspend(() => options?.onFailure?.(cause) ?? Effect.logError(`${label} failed`, Cause.pretty(cause))).pipe(Effect.catchCause((handlerCause) => Effect.logError(`${label} failure handler failed`, Cause.pretty(cause), Cause.pretty(handlerCause))));
+const makeWaitUntilScheduler = (label, register, runPromiseExit = (effect) => Effect.runPromiseExit(effect)) => {
+	return (effect, options, mode) => Effect.context().pipe(Effect.flatMap((context) => Effect.sync(() => {
+		const runHandler = (cause) => runPromiseExit(Effect.provideContext(Effect.scoped(failureHandler(label, cause, options)), context)).then((exit) => {
+			if (Exit.isFailure(exit)) console.error(`${label} failure handler failed`, Cause.pretty(exit.cause));
+		});
+		register(runPromiseExit(Effect.provideContext(Effect.scoped(effect), context)).then(async (exit) => {
+			if (Exit.isSuccess(exit)) return;
+			await runHandler(exit.cause);
+			if (mode === "propagate") throw causeError(exit.cause);
+		}));
+	})));
+};
+const fromExecutionContext = (ctx, runPromiseExit = (effect) => Effect.runPromiseExit(effect)) => {
+	const schedule = makeWaitUntilScheduler("WorkerContext.waitUntil", (promise) => ctx.waitUntil(promise), runPromiseExit);
+	return {
+		raw: ctx,
+		waitUntil: (effect, options) => schedule(effect, options, options?.mode ?? "observe"),
+		waitUntilPropagating: (effect, options) => schedule(effect, options, "propagate"),
+		passThroughOnException: Effect.sync(() => ctx.passThroughOnException()),
+		abort: (reason) => Effect.sync(() => ctx.abort(reason))
+	};
+};
+//#endregion
+export { makeWaitUntilScheduler as n, runNativeCallback as r, fromExecutionContext as t };

package/dist/{WorkflowBinding-Cn3AuUyP.d.mts → WorkflowBinding-CvJT9hB5.d.mts}

@@ -1,5 +1,5 @@
 import { c as WorkerEnvironment, r as BindingValidationError, t as BindingNotFoundError } from "./Binding-DKcLrQCM.mjs";
-import { w as ServiceFreeSchema } from "./DurableObjectState-DpYdNZgT.mjs";
+import { S as ServiceFreeSchema } from "./Worker-Dl6_Pijl.mjs";
 import { Context, Effect, Option, Schema } from "effect";
 declare namespace WorkflowBinding_d_exports {
   export { WorkflowBindingClient, WorkflowBindingDefinition, WorkflowInstance, WorkflowInstanceCreateBatchOptions, WorkflowInstanceCreateOptions, WorkflowInstanceEvent, WorkflowInstanceLocationHint, WorkflowInstanceRestartOptions, WorkflowInstanceStatus, WorkflowInstanceStatusName, WorkflowInstanceTerminateOptions, WorkflowOperationError, WorkflowResultDecodeError, isWorkflow, layer, makeClient };

package/dist/index.d.mts

@@ -1,9 +1,10 @@
 import { a as Environment_d_exports, c as WorkerEnvironment, i as Binding_d_exports, n as BindingService, o as WorkerConfig, r as BindingValidationError, s as WorkerEnv, t as BindingNotFoundError } from "./Binding-DKcLrQCM.mjs";
 import { l as Artifacts_d_exports } from "./Artifacts-B3r3RuTB.mjs";
-import { A as DurableWebSocket, C as RpcDefinition_d_exports, D as AcceptUpgradeOptions, E as Rpc_d_exports, M as DurableObjectStorage_d_exports, N as StorageOperationError, O as AcceptedUpgrade, S as ReservedMethodName$2, T as Provider, _ as Queue_d_exports, a as NativeRequest, b as Definition$4, c as WorkerDefinition_d_exports, d as AsyncMethodCloudflareReturn, f as AsyncMethodKey, g as RpcTracing_d_exports, h as RpcInvocationInfo, i as ExecutionContext, j as DurableWebSocketAttachmentError, k as DurableObjectWebSocket_d_exports, l as ServiceBinding_d_exports, m as ReceiverOptions, o as WorkerContext, p as AsyncMethodSuccess, r as DurableObjectState_d_exports, s as Worker_d_exports, t as DurableObjectState, u as AsyncMethodArgs, v as QueueDefinition_d_exports, w as ServiceFreeSchema$1, x as Method$2, y as QueueBinding_d_exports } from "./DurableObjectState-DpYdNZgT.mjs";
+import { a as AcceptedUpgrade, c as DurableWebSocketAttachmentError, i as AcceptUpgradeOptions, l as DurableObjectStorage_d_exports, o as DurableObjectWebSocket_d_exports, r as DurableObjectState_d_exports, s as DurableWebSocket, t as DurableObjectState, u as StorageOperationError } from "./DurableObjectState-CpgAmFqo.mjs";
+import { C as Provider, S as ServiceFreeSchema$1, _ as QueueBinding_d_exports, a as Worker_d_exports, b as ReservedMethodName$2, c as AsyncMethodArgs, d as AsyncMethodSuccess, f as ReceiverOptions, g as QueueDefinition_d_exports, h as Queue_d_exports, l as AsyncMethodCloudflareReturn, m as RpcTracing_d_exports, n as NativeRequest, o as WorkerDefinition_d_exports, p as RpcInvocationInfo, r as WorkerContext, s as ServiceBinding_d_exports, t as ExecutionContext, u as AsyncMethodKey, v as Definition$4, w as Rpc_d_exports, x as RpcDefinition_d_exports, y as Method$2 } from "./Worker-Dl6_Pijl.mjs";
 import { t as Hyperdrive_d_exports } from "./Hyperdrive-HrwFlZ6x.mjs";
 import { t as ContainerNamespace_d_exports } from "./ContainerNamespace-DbLaeFhN.mjs";
-import { a as WorkflowInstanceCreateOptions, i as WorkflowInstanceCreateBatchOptions, n as WorkflowBinding_d_exports, r as WorkflowInstance, s as WorkflowOperationError, t as WorkflowBindingClient } from "./WorkflowBinding-Cn3AuUyP.mjs";
+import { a as WorkflowInstanceCreateOptions, i as WorkflowInstanceCreateBatchOptions, n as WorkflowBinding_d_exports, r as WorkflowInstance, s as WorkflowOperationError, t as WorkflowBindingClient } from "./WorkflowBinding-CvJT9hB5.mjs";
 import { Cause, Config, Context, Data, DateTime, Duration, Effect, Layer, Option, Predicate, Redacted, Schema, Scope } from "effect";
 import { Headers as Headers$1, HttpClient, HttpClientResponse } from "effect/unstable/http";
 import { OtlpExporter, OtlpResource } from "effect/unstable/observability";
@@ -852,7 +853,7 @@ type DurableObjectClass<Rpc extends DurableObjectRpc<ROut>, ROut> = new (state:
  */
 declare const make$6: <ROut, LayerError, REvent = never, EventLayerError = never, const Rpc extends DurableObjectRpc<ROut | REvent> = Record<never, never>>(layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>, options?: DurableObjectOptions<ROut, REvent, EventLayerError, Rpc>) => DurableObjectClass<Rpc, ROut | REvent>;
 declare namespace DurableObjectAlarm_d_exports {
-  export { AlarmDefinitionConfig, AlarmDefinitionEntry, AlarmDefinitionPayload, AlarmDefinitions, AlarmFailurePolicy, AlarmPayload, AlarmPayloadSchema, AlarmRef, AlarmRetryPolicy, AlarmScheduler, DefinedAlarmEvent, DefinedAlarmHandlers, DurableObjectAlarm, DurableObjectAlarmError, DurableObjectAlarmEvent, InvalidAlarmPayloadError, InvalidAlarmRefError, InvalidProcessDueAlarmsOptionsError, InvalidRepeatEveryError, ProcessDueAlarmsFailure, ProcessDueAlarmsFailureAction, ProcessDueAlarmsHandler, ProcessDueAlarmsMode, ProcessDueAlarmsOptions, ProcessDueAlarmsResult, ScheduleAlarmInput, StoredAlarmDecodeError, define, processDue };
+  export { AlarmDefinitionConfig, AlarmDefinitionEntry, AlarmDefinitionPayload, AlarmDefinitions, AlarmFailurePolicy, AlarmPayload, AlarmPayloadSchema, AlarmRef, AlarmRetryPolicy, AlarmScheduler, AlarmTransaction, DefinedAlarmEvent, DefinedAlarmHandlers, DurableObjectAlarm, DurableObjectAlarmError, DurableObjectAlarmEvent, InvalidAlarmPayloadError, InvalidAlarmRefError, InvalidProcessDueAlarmsOptionsError, InvalidRepeatEveryError, ProcessDueAlarmsFailure, ProcessDueAlarmsFailureAction, ProcessDueAlarmsHandler, ProcessDueAlarmsMode, ProcessDueAlarmsOptions, ProcessDueAlarmsResult, ScheduleAlarmInput, StoredAlarmDecodeError, define, processDue };
 }
 type AlarmPayload = Schema.Json;
 declare const InvalidAlarmRefError_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 & {
@@ -945,8 +946,26 @@ interface ProcessDueAlarmsOptions<OnFailureR = never, OnFailureE = never> {
   readonly retryFailedAfter?: Duration.Input;
 }
 type ProcessDueAlarmsHandler<R = never, E = never> = (event: DurableObjectAlarmEvent) => Effect.Effect<void, E, R>;
+/**
+ * Alarm mutations owned by one transaction callback. Run them in the callback's
+ * fiber; forked work and use after the callback ends fail with StorageOperationError.
+ */
+type AlarmTransaction = Pick<AlarmScheduler, "scheduleAlarm" | "cancelAlarm">;
 /** Own `storage.setAlarm()` exclusively: a Durable Object has one platform alarm timestamp. */
 type AlarmScheduler = {
+  /**
+   * Commits local application storage and logical alarms in one native SQLite
+   * Durable Object transaction, reconciling the native alarm before commit.
+   * Use the supplied mutations, not standalone alarm methods or nested transactions.
+   * SqlClient queries must use this same Durable Object's storage.
+   *
+   * Failure, defects and interruption before commit roll back. A lost reply or
+   * interruption after commit does not undo committed state. Keep RPC and other
+   * external effects outside; atomically pre-arm a later wake before fallible work.
+   * Cloudflare's native retries are bounded; composition does not remove the
+   * pre-arm requirement or promise infinite retry liveness.
+   */
+  readonly transaction: <A, E, R>(closure: (alarms: AlarmTransaction) => Effect.Effect<A, E, R>) => Effect.Effect<A, E | StorageOperationError, R>;
   readonly cancelAlarm: (input: AlarmRef) => Effect.Effect<void, InvalidAlarmRefError | StorageOperationError>;
   /** Acknowledge after handling. Conditional writes preserve handler replacements; alarms are at-least-once. */
   readonly processDueAlarms: <R = never, E = never, OnFailureR = never, OnFailureE = never>(handle: ProcessDueAlarmsHandler<R, E>, options?: ProcessDueAlarmsOptions<OnFailureR, OnFailureE>) => Effect.Effect<ProcessDueAlarmsResult, E | OnFailureE | DurableObjectAlarmError, R | OnFailureR>;