@voltro/workflow 0.84.0 → 0.86.0

package/dist/parentClosureRecovery.js

@@ -0,0 +1,54 @@
+import { stageWorkflowParentClosureInTransaction as e } from "./parentClosure.js";
+import { and as t, eq as n, gt as r, isNull as i } from "@voltro/database";
+//#region src/parentClosureRecovery.ts
+var a = "_voltro_workflow_parent_closures", o = /* @__PURE__ */ new WeakMap(), s = async (s, c, l) => {
+	let u = o.get(s), d = await s.store.query({
+		table: a,
+		predicate: t(i("completedAt"), ...u === void 0 ? [] : [r("id", u.afterId)]),
+		order: [{
+			column: "id",
+			direction: "asc"
+		}],
+		take: l,
+		skip: void 0,
+		projection: void 0
+	}), f = 0, p = u?.nextDueAt, m = () => {
+		p = Math.min(p ?? c + 1e3, c + 1e3);
+	};
+	for (let t of d) try {
+		if (typeof t.id != "string" || t.id.length === 0) throw Error("Parent closure has no identity");
+		let r = t.id;
+		await s.transaction(async (t) => {
+			await e(t, r, c);
+			let [i] = await t.query({
+				table: a,
+				predicate: n("id", r),
+				order: [],
+				take: 1,
+				skip: void 0,
+				projection: ["completedAt"]
+			});
+			if (i === void 0) throw Error("Parent closure disappeared");
+			return i.completedAt instanceof Date && Number.isFinite(i.completedAt.getTime());
+		}) || m();
+	} catch {
+		f++, m(), s.log?.warn?.("workflow parent closure could not be reconciled", { closureId: typeof t.id == "string" ? t.id : null });
+	}
+	let h = d.at(-1);
+	return d.length === l && typeof h?.id == "string" ? (o.set(s, {
+		afterId: h.id,
+		nextDueAt: p
+	}), {
+		scanned: d.length,
+		failed: f,
+		nextDueAt: c,
+		examined: !0
+	}) : (o.delete(s), {
+		scanned: d.length,
+		failed: f,
+		nextDueAt: p,
+		examined: d.length > 0
+	});
+};
+//#endregion
+export { s as recoverWorkflowParentClosures };

package/dist/pendingSubmission.js

@@ -0,0 +1,85 @@
+import { withAdmissionTransaction as e } from "./admissionTransaction.js";
+import { persistReservedSubmission as t, readAdmissionSubmission as n, reserveAdmissionSubmissionInTransaction as r } from "./admissionSubmission.js";
+import { bindWorkflowStartReceipts as i } from "./startReceipt.js";
+import { PENDING_TABLE as a, toPendingIntent as o } from "./admissionStore.js";
+import { eq as s } from "@voltro/database";
+//#region src/pendingSubmission.ts
+var c = async (e, r) => {
+	if (new Set(r.intentIds).size !== r.intentIds.length) throw Error("Admitted transfer requires distinct pending identities");
+	let c = await n(e, r.id);
+	if (c !== void 0) {
+		if (c.workflowName !== r.workflowName || c.tenantId !== r.tenantId || c.ledgerId !== r.ledgerId || !c.receiptsBound) throw Error("Admitted transfer contradicts its existing submission");
+		return c;
+	}
+	for (let t of r.intentIds) {
+		let n = await e.query({
+			table: a,
+			predicate: s("id", t),
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: void 0,
+			lock: "update"
+		});
+		if (n[0] === void 0) throw Error("Admitted transfer lost a selected input");
+		let i = o(n[0]);
+		if (i.workflowName !== r.workflowName || i.tenantId !== r.tenantId || i.deadLetteredAt !== void 0) throw Error("Admitted transfer selected a foreign or dead-lettered input");
+	}
+	let l = await t(e, r);
+	await i(e, l.id);
+	for (let t of l.intentIds) if (!await e.delete("_voltro_workflow_pending", t)) throw Error("Admitted input disappeared during submission transfer");
+	return {
+		...l,
+		receiptsBound: !0
+	};
+}, l = async (t, n) => e(t, (e) => u(e, n)), u = async (e, t) => {
+	if (t.id.length === 0 || t.intentIds.length === 0 || new Set(t.intentIds).size !== t.intentIds.length) throw Error("Queue transfer requires a submission identity and distinct pending identities");
+	let c = await n(e, t.id);
+	if (c !== void 0) {
+		if (c.workflowName !== t.workflowName || c.tenantId !== t.tenantId) throw Error("Admission submission identity belongs to a different workflow or tenant");
+		if (!c.receiptsBound) throw Error("Submission exists without completed queue transfer");
+		return {
+			kind: "reserved",
+			submission: c,
+			reused: !0
+		};
+	}
+	let l = [];
+	for (let n of t.intentIds) {
+		let r = await e.query({
+			table: a,
+			predicate: s("id", n),
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: void 0,
+			lock: "update"
+		});
+		if (r[0] === void 0) return { kind: "selection-unavailable" };
+		let i = o(r[0]);
+		if (i.workflowName !== t.workflowName || i.tenantId !== t.tenantId) throw Error("Selected pending start belongs to a different workflow or tenant");
+		if (i.deadLetteredAt !== void 0 || i.dueAt > t.now) return { kind: "selection-unavailable" };
+		l.push(i);
+	}
+	let u = t.prepare(l);
+	if (u.control.workflowName !== t.workflowName) throw Error("Prepared submission belongs to a different workflow");
+	let d = await r(e, {
+		...u,
+		id: t.id,
+		tenantId: t.tenantId,
+		intentIds: t.intentIds,
+		now: t.now
+	});
+	if (d.kind !== "reserved") return d;
+	await i(e, t.id);
+	for (let t of l) if (!await e.delete("_voltro_workflow_pending", t.id)) throw Error("Pending start disappeared during queue transfer");
+	return {
+		...d,
+		submission: {
+			...d.submission,
+			receiptsBound: !0
+		}
+	};
+};
+//#endregion
+export { c as takeAdmittedSubmissionInTransaction, l as takePendingAdmissionSubmission, u as takePendingAdmissionSubmissionInTransaction };

package/dist/prepareSubmissionDispatch.js

@@ -0,0 +1,17 @@
+import { prepareAdmissionSubmissionExecutionInTransaction as e, readAdmissionSubmission as t } from "./admissionSubmission.js";
+//#region src/prepareSubmissionDispatch.ts
+var n = async (n, r, i) => {
+	let a = await n.transaction((e) => t(e, r.id));
+	if (a === void 0 || a.workflowName !== r.workflowName || a.tenantId !== r.tenantId || a.ledgerId !== r.ledgerId) throw Error("Submission dispatch lost its resident owner");
+	if (!a.receiptsBound || a.failureId !== null) throw Error("Cannot dispatch an incomplete or rejected submission");
+	if (a.preparedExecutionId !== null) {
+		if (a.executionId !== null && a.executionId !== a.preparedExecutionId) throw Error("Submission acceptance contradicts its prepared identity");
+		return a.preparedExecutionId;
+	}
+	if (a.dispatchAttempts !== 0 || a.executionId !== null) throw Error("Submission has an unbound prior dispatch; reconciliation required");
+	let o = await n.resolveExecutionId(r.workflowName, i), s = await n.transaction((t) => e(t, r.id, o));
+	if (s.preparedExecutionId === null) throw Error("Submission preparation returned no execution identity");
+	return s.preparedExecutionId;
+};
+//#endregion
+export { n as prepareSubmissionDispatch };

package/dist/preparedExecution.js

@@ -0,0 +1,14 @@
+import { Effect as e } from "effect";
+//#region src/preparedExecution.ts
+var t = Symbol.for("@voltro/workflow/PreparedExecution"), n = (e, n) => {
+	Object.defineProperty(e, t, {
+		value: n,
+		enumerable: !0
+	});
+}, r = (e) => (typeof e == "object" || typeof e == "function") && e !== null && typeof e[t] == "function", i = (n, r, i, a) => e.suspend(() => {
+	if (i.length === 0) return e.die(/* @__PURE__ */ Error("Prepared workflow execution requires a non-empty identity"));
+	let o = n[t];
+	return typeof o == "function" ? o(r, i, a?.discard ?? !0) : e.die(/* @__PURE__ */ Error("Workflow definition has no prepared-execution capability"));
+});
+//#endregion
+export { n as attachPreparedWorkflowExecution, i as executePreparedWorkflow, r as hasPreparedWorkflowExecution };

package/dist/primitives.d.ts

@@ -1,13 +1,14 @@
-import { DurableClock as durableClock } from '@effect/workflow';
-import { DurableQueue as durableQueueModule } from '@effect/workflow';
-import { DurableRateLimiter as durableRateLimiterModule } from '@effect/workflow';
+import { Context } from 'effect';
+import { DurableClock as durableClock } from 'effect/workflow';
+import { DurableQueue as durableQueueModule } from 'effect/workflow';
 import { Duration } from 'effect';
 import { Effect } from 'effect';
-import { FiberRef } from 'effect';
+import { RateLimiter } from 'effect/persistence';
 import { Schema } from 'effect';
-import { Activity as stepModule } from '@effect/workflow';
+import { Activity as stepModule } from 'effect/workflow';
 import { WorkflowAccessOptions } from '@voltro/protocol';
-import { Workflow as workflowModule } from '@effect/workflow';
+import { WorkflowEngine } from 'effect/workflow';
+import { Workflow as workflowModule } from 'effect/workflow';
 
 /**
  * Assert every workflow sharing a `concurrency.pool` declares the SAME limit.
@@ -34,7 +35,7 @@ export declare const assertConsistentPools: (controls: ReadonlyArray<ResolvedFlo
  * whose row already exists). A first entry has no prior shape, so the whole
  * mechanism costs one `FiberRef` read per step and nothing else.
  */
-export declare const CurrentWorkflowReplayShape: FiberRef.FiberRef<ReplayShapeTracker | undefined>;
+export declare const CurrentWorkflowReplayShape: Context.Reference<ReplayShapeTracker | undefined>;
 
 /** The DECODED payload type. Mirrors `Workflow.make`'s own `idempotencyKey`
  *  parameter, so the two never disagree about what a payload is. */
@@ -65,18 +66,16 @@ export declare const deferringControlsOf: (control: ResolvedFlowControl | undefi
 export { durableClock }
 
 /** Define a durable queue for concurrency-controlled side work. */
-export declare const durableQueue: typeof durableQueueModule.make & (<Options extends Parameters<typeof durableQueueModule.make>[0] & {
+export declare const durableQueue: <Payload extends Schema.Top | Schema.Struct.Fields, Success extends Schema.Top = typeof Schema.Void, Error extends Schema.Top = typeof Schema.Never>(options: Parameters<typeof durableQueueModule.make<Payload, Success, Error>>[0] & {
     readonly encrypted?: boolean;
-}>(options: Options) => ReturnType<typeof durableQueueModule.make>);
+}) => ReturnType<typeof durableQueueModule.make<Payload, Success, Error>>;
 
 export { durableQueueModule }
 
-export { durableRateLimiterModule }
-
 /** A duration in any shape Effect accepts: `'15 minutes'`, `900_000`,
  *  `Duration.minutes(15)`. Same input type `sleep({ duration })` takes, so
  *  there is one duration vocabulary in the whole workflow surface. */
-export declare type FlowDuration = Duration.DurationInput;
+export declare type FlowDuration = Duration.Input;
 
 /** The resolved flow-control declaration attached to a workflow definition, or
  *  `undefined` when it declares none — in which case every start takes exactly
@@ -102,6 +101,10 @@ export declare const hasCancelOn: (control: ResolvedFlowControl | undefined) =>
  *  two writes per start for a decision that is always "admit". */
 export declare const hasFlowControl: (control: ResolvedFlowControl | undefined) => boolean;
 
+/** A value that can carry definition metadata: a workflow definition is a
+ *  callable in v4 (`Workflow.make` returns a function), a queue is an object. */
+export declare const isCarrier: (value: unknown) => value is object;
+
 export declare const isWorkflowWorkerLayer: (value: unknown) => value is WorkflowWorkerLayerBrand;
 
 /**
@@ -135,7 +138,7 @@ export declare type NondeterminismKind = 'unreached-step' | 'extra-step-occurren
 declare type NormaliseWorkflowMessages<M extends WorkflowMessageSchemas | undefined> = {
     readonly signals: M extends {
         readonly signals: infer Signals;
-    } ? NonNullable<Signals> & Readonly<Record<string, Schema.Schema.Any>> : {};
+    } ? NonNullable<Signals> & Readonly<Record<string, Schema.Top>> : {};
     readonly updates: M extends {
         readonly updates: infer Updates;
     } ? NonNullable<Updates> & Readonly<Record<string, WorkflowMessagePairSchemas>> : {};
@@ -176,7 +179,7 @@ declare type NormaliseWorkflowMessages<M extends WorkflowMessageSchemas | undefi
  * however many times it replays and whatever the deployed code says — which is
  * the property that makes the branch deterministic across a redeploy.
  *
- * Under `@effect/workflow` the naive implementation does the opposite: an
+ * Under `effect/workflow` the naive implementation does the opposite: an
  * activity that is ABSENT from an old run's journal EXECUTES on replay (the
  * journal is keyed name/attempt), so a marker journaled by an activity would
  * answer `true` for exactly the old runs it must answer `false` for. Reading
@@ -214,8 +217,26 @@ export declare const processQueue: typeof durableQueueModule.process;
  *  inferred type) is what emits in the `.d.ts`, so it stays portable. */
 export declare const queueWorker: typeof durableQueueModule.worker;
 
-/** Durable rate limiter activity. Delays through the workflow clock. */
-export declare const rateLimit: typeof durableRateLimiterModule.rateLimit;
+/**
+ * Durable rate limit. Consumes from the shared limiter; when the window is
+ * exhausted the wait is a durable clock sleep under `name`, so a deploy or a
+ * worker crash does not lose the delay and a replay does not consume twice.
+ */
+export declare const rateLimit: (options: RateLimitOptions) => Effect.Effect<void, RateLimiter.RateLimiterError, RateLimiter.RateLimiter | WorkflowEngine.WorkflowEngine | WorkflowEngine.WorkflowInstance>;
+
+/** What `rateLimit` admits: one unit of work under `limit` per `window` for
+ *  `key`, counted by the `RateLimiter` service the boot provides. */
+export declare interface RateLimitOptions {
+    /** Names this ADMISSION within the run: the decision is journaled under it, so a
+     *  replay reads it back instead of consuming again. Two calls with the same name
+     *  in one run share one decision — give each call its own (`send/${i}` in a loop). */
+    readonly name: string;
+    readonly window: Duration.Input;
+    readonly limit: number;
+    readonly key: string;
+    readonly algorithm?: 'fixed-window' | 'token-bucket' | undefined;
+    readonly tokens?: number | undefined;
+}
 
 /** The slice of a `_voltro_workflow_run_steps` row this needs. */
 export declare interface RecordedStepShape {
@@ -256,7 +277,7 @@ export declare const reportNondeterminism: (findings: ReadonlyArray<Nondetermini
  *  event at all". */
 export declare interface ResolvedCancelOn {
     readonly event: string;
-    readonly schema: Schema.Schema.Any;
+    readonly schema: Schema.Top;
     readonly match: (event: unknown, payload: unknown) => boolean;
     readonly withinMs?: number;
     readonly reason: string;
@@ -370,7 +391,7 @@ export declare const sleepUntil: (options: {
     readonly until: Date | number;
 }) => Effect.Effect<void, never, never>;
 
-export declare const step: <R, Success extends Schema.Schema.Any = typeof Schema.Void, Error extends Schema.Schema.All = typeof Schema.Never>(options: StepOptions<R, Success, Error>) => ReturnType<typeof stepModule.make<R, Success, Error>>;
+export declare const step: <R, Success extends Schema.Top = typeof Schema.Void, Error extends Schema.Top = typeof Schema.Never>(options: StepOptions<R, Success, Error>) => ReturnType<typeof stepModule.make<R, Success, Error>>;
 
 /**
  * Derive a deterministic idempotency key for the current workflow run,
@@ -389,7 +410,7 @@ export { stepModule }
 /**
  * Define a checkpointed step (activity) inside a workflow body.
  *
- * Wraps `@effect/workflow`'s `Activity.make` to record every
+ * Wraps `effect/workflow`'s `Activity.make` to record every
  * invocation in `_voltro_workflow_run_steps`. The wrapping is
  * transparent — accepts everything `Activity.make` accepts, plus an
  * optional `input` field whose value is persisted to the step row
@@ -408,7 +429,7 @@ export { stepModule }
  * Without the recorder service in scope (unit tests, etc.) the input
  * is dropped and the wrap is a no-op.
  */
-declare type StepOptions<R, Success extends Schema.Schema.Any, Error extends Schema.Schema.All> = {
+declare type StepOptions<R, Success extends Schema.Top, Error extends Schema.Top> = {
     readonly name: string;
     readonly success?: Success | undefined;
     readonly error?: Error | undefined;
@@ -518,7 +539,9 @@ export declare const withCompensation: typeof workflowModule.withCompensation;
 
 export declare const workflow: WorkflowFn;
 
-declare type WorkflowBaseOptions = Parameters<WorkflowMake>[0];
+declare type WorkflowBaseOptions = Parameters<WorkflowMake>[1] & {
+    readonly name: Parameters<WorkflowMake>[0];
+};
 
 /**
  * Collect many starts into ONE run over an array of items.
@@ -577,7 +600,7 @@ export declare interface WorkflowBatch<Item> {
  * }],
  * ```
  */
-export declare interface WorkflowCancelOn<EventSchema extends Schema.Schema.Any, Payload> {
+export declare interface WorkflowCancelOn<EventSchema extends Schema.Top, Payload> {
     /** The event NAME, exactly as `ctx.events.publish` writes it. */
     readonly event: string;
     /** Decoded before `match` sees it, so the predicate reads the domain type
@@ -611,7 +634,7 @@ export declare interface WorkflowCancelOn<EventSchema extends Schema.Schema.Any,
  *  the per-entry-inferred {@link WorkflowCancelOnList}; this is what survives
  *  erasure, and it is deliberately not the public spelling. */
 export declare interface WorkflowCancelOnDeclared {
-    readonly cancelOn?: ReadonlyArray<WorkflowCancelOn<Schema.Schema.Any, never>>;
+    readonly cancelOn?: ReadonlyArray<WorkflowCancelOn<Schema.Top, never>>;
 }
 
 /** The `cancelOn` array as declared, with each entry's event type inferred
@@ -619,7 +642,7 @@ export declare interface WorkflowCancelOnDeclared {
  *  per-entry inference work — a plain `ReadonlyArray<WorkflowCancelOn<…>>`
  *  collapses every entry's event to the constraint (`any`), which is how the
  *  predicate silently stops being checked. */
-export declare type WorkflowCancelOnList<Cancels extends ReadonlyArray<Schema.Schema.Any>, Payload> = {
+export declare type WorkflowCancelOnList<Cancels extends ReadonlyArray<Schema.Top>, Payload> = {
     readonly [I in keyof Cancels]: WorkflowCancelOn<Cancels[I], Payload>;
 };
 
@@ -820,7 +843,7 @@ export declare const WorkflowFlowControlProperty = "__voltroWorkflowFlowControl"
  * meaning anything if this ever regresses to `any` — which is precisely what
  * all three failed attempts did.
  */
-declare type WorkflowFn = <const Name extends string, Payload extends WorkflowPayloadInput, Success extends Schema.Schema.Any = typeof Schema.Void, Error extends Schema.Schema.All = typeof Schema.Never, const Messages extends WorkflowMessageSchemas | undefined = undefined, Cancels extends ReadonlyArray<Schema.Schema.Any> = readonly []>(options: {
+declare type WorkflowFn = <const Name extends string, Payload extends WorkflowPayloadInput, Success extends Schema.Top = typeof Schema.Void, Error extends Schema.Top = typeof Schema.Never, const Messages extends WorkflowMessageSchemas | undefined = undefined, Cancels extends ReadonlyArray<Schema.Top> = readonly []>(options: {
     readonly name: Name;
     readonly payload: Payload;
     readonly idempotencyKey: (payload: DecodedPayload<Payload>) => string;
@@ -838,13 +861,15 @@ declare type WorkflowFn = <const Name extends string, Payload extends WorkflowPa
     readonly schedule?: WorkflowScheduleDeclaration<DecodedPayload<Payload>>;
 } & Omit<WorkflowBaseOptions, 'name' | 'payload' | 'idempotencyKey' | 'success' | 'error'> & WorkflowVersionOptions & {
     readonly messages?: Messages;
-} & WorkflowFlowControl<DecodedPayload<Payload>> & WorkflowAccessOptions<DecodedPayload<Payload>>) => workflowModule.Workflow<Name, PayloadSchemaOf<Payload>, Success, Error> & WorkflowMessagesCarrier<NormaliseWorkflowMessages<Messages>>;
+} & WorkflowFlowControl<DecodedPayload<Payload>> & WorkflowAccessOptions<DecodedPayload<Payload>>) => workflowModule.Workflow<Name, PayloadSchemaOf<Payload>, Success, Error> & {
+    readonly name: Name;
+} & WorkflowMessagesCarrier<NormaliseWorkflowMessages<Messages>>;
 
 declare type WorkflowMake = typeof workflowModule.make;
 
 export declare interface WorkflowMessagePairSchemas {
-    readonly payload: Schema.Schema.Any;
-    readonly success: Schema.Schema.Any;
+    readonly payload: Schema.Top;
+    readonly success: Schema.Top;
 }
 
 export declare interface WorkflowMessagesCarrier<M extends WorkflowMessagesMetadata = WorkflowMessagesMetadata> {
@@ -862,12 +887,12 @@ export declare interface WorkflowMessagesCarrier<M extends WorkflowMessagesMetad
  * and updates (synchronous, with a result) are the channels that exist.
  */
 export declare interface WorkflowMessageSchemas {
-    readonly signals?: Readonly<Record<string, Schema.Schema.Any>>;
+    readonly signals?: Readonly<Record<string, Schema.Top>>;
     readonly updates?: Readonly<Record<string, WorkflowMessagePairSchemas>>;
 }
 
 export declare interface WorkflowMessagesMetadata {
-    readonly signals: Readonly<Record<string, Schema.Schema.Any>>;
+    readonly signals: Readonly<Record<string, Schema.Top>>;
     readonly updates: Readonly<Record<string, WorkflowMessagePairSchemas>>;
 }
 
@@ -1049,7 +1074,7 @@ export declare interface WorkflowVersionOptions {
      * suspended-on-failure run shows up under `--status suspended`, NOT in the
      * dead-letter view — it is recoverable, not dead.
      *
-     * Maps to `@effect/workflow`'s `SuspendOnFailure` annotation.
+     * Maps to `effect/workflow`'s `SuspendOnFailure` annotation.
      */
     readonly suspendOnFailure?: boolean;
 }

package/dist/primitives.js

@@ -1,2 +1,225 @@
-import { A as e, C as t, D as n, E as r, G as i, J as a, K as o, O as s, S as c, T as l, U as u, W as d, _ as f, a as p, b as m, c as h, d as g, f as _, g as v, h as y, i as b, j as x, k as S, l as C, m as w, n as T, o as E, p as D, q as O, r as k, s as A, t as j, u as M, v as N, w as P, x as F, y as I } from "./primitives-Btjhjm8P.js";
-export { P as CurrentWorkflowReplayShape, s as DEFAULT_WORKFLOW_SCHEDULE_MAX_RUNTIME_MS, u as DEFERRING_CONTROLS, j as WorkflowFlowControlProperty, T as WorkflowMessagesProperty, S as WorkflowScheduleProperty, k as WorkflowVersionTypeId, b as WorkflowWorkerLayerTypeId, d as assertConsistentPools, i as deferringControlsOf, p as durableClock, E as durableQueue, A as durableQueueModule, h as durableRateLimiterModule, C as getWorkflowFlowControl, e as getWorkflowSchedule, M as getWorkflowVersionMetadata, o as hasCancelOn, O as hasFlowControl, g as isWorkflowWorkerLayer, l as makeReplayShapeTracker, r as nondeterminismEventPayload, _ as patch, D as processQueue, w as queueWorker, y as rateLimit, n as reportNondeterminism, v as sleep, f as sleepUntil, N as step, I as stepIdempotencyKey, m as stepModule, a as validateFlowControl, x as validateWorkflowSchedule, F as withCompensation, c as workflow, t as workflowModule };
+import { failureMessage as e } from "./failureMessage.js";
+import { attachPreparedWorkflowExecution as t } from "./preparedExecution.js";
+import { CurrentWorkflowEncrypted as n, isQueueEncrypted as r, markQueueEncrypted as i, markWorkflowEncrypted as a, openDefect as o, sealDefect as s, sealedPayloadFields as c, sealedSchema as l } from "./journalEncryption.js";
+import { DEFERRING_CONTROLS as u, assertConsistentPools as d, deferringControlsOf as f, hasCancelOn as p, hasFlowControl as m, validateFlowControl as h } from "./flowControl.js";
+import { CurrentWorkflowPatches as g, CurrentWorkflowRunId as _, CurrentWorkflowStep as v, CurrentWorkflowWakeTenant as ee, WorkflowRunRecorder as y, WorkflowStepInterceptorTag as b } from "./recorder.js";
+import { DEFAULT_WORKFLOW_SCHEDULE_MAX_RUNTIME_MS as x, WorkflowScheduleProperty as S, getWorkflowSchedule as C, validateWorkflowSchedule as w } from "./scheduleDeclaration.js";
+import { CurrentWorkflowReplayShape as T, makeReplayShapeTracker as E, nondeterminismEventPayload as D, reportNondeterminism as O } from "./nondeterminism.js";
+import { applyRetryPolicy as k } from "./retryPolicy.js";
+import { Activity as A, Activity as j, DurableClock as M, DurableClock as N, DurableQueue as P, DurableQueue as te, Workflow as F, Workflow as ne, WorkflowEngine as I } from "effect/workflow";
+import { RateLimiter as L } from "effect/persistence";
+import { Cause as R, Duration as z, Effect as B, Effectable as V, Schema as H } from "effect";
+import { attachWorkflowAccess as U, resolveWorkflowAccess as W } from "@voltro/protocol";
+//#region src/primitives.ts
+var G = Symbol.for("voltro.workflow.workerLayer"), K = Symbol.for("voltro.workflow.version"), q = "__voltroWorkflowMessages", J = "__voltroWorkflowFlowControl", Y = (e) => typeof e == "object" && !!e && e[G] === !0, X = (e) => (typeof e == "object" || typeof e == "function") && e !== null, re = (e) => X(e) && e[K] !== void 0 ? e[K] : {
+	version: "1",
+	compatibleWith: ["1"],
+	patches: []
+}, Z = (e) => {
+	let t = e, r = `workflow '${e.name}' defect`;
+	return Object.assign(Object.create(Object.getPrototypeOf(e)), e, {
+		toLayer: (e) => t.toLayer((t, i) => B.provideService(e(t, i), n, !0).pipe(B.catchDefect((e) => B.die(s(e, r))))),
+		execute: (...e) => t.execute(...e).pipe(B.catchDefect((e) => B.die(o(e, r)))),
+		annotate: (...e) => Z(t.annotate(...e)),
+		annotateContext: (...e) => Z(t.annotateContext(...e))
+	});
+}, ie = ((e) => {
+	let n = e.encrypted === !0, r = F.make(e.name, n ? {
+		...e,
+		payload: c(e.name, e.payload),
+		...e.success === void 0 ? {} : { success: l(e.success, `workflow '${e.name}' result`) },
+		...e.error === void 0 ? {} : { error: l(e.error, `workflow '${e.name}' failure`) }
+	} : e);
+	n && a(e.name);
+	let i = e.suspendOnFailure === !0 ? r.annotate(F.SuspendOnFailure, !0) : r, o = n ? Z(i) : i;
+	Object.defineProperty(o, "name", {
+		value: e.name,
+		enumerable: !0
+	}), t(o, (t, n, r) => B.gen(function* () {
+		let i = o.payloadSchema.make(t), a = yield* I.WorkflowEngine;
+		return yield* B.annotateCurrentSpan({ executionId: n }), yield* a.execute(o, {
+			executionId: n,
+			payload: i,
+			discard: r,
+			suspendedRetrySchedule: e.suspendedRetrySchedule
+		});
+	}).pipe(B.withSpan(`${e.name}.execute`)));
+	let s = String(e.version ?? "1"), u = {
+		version: s,
+		compatibleWith: (e.compatibleWith ?? [s]).map(String),
+		patches: [...e.patches ?? []]
+	}, d = {
+		signals: { ...e.messages?.signals ?? {} },
+		updates: { ...e.messages?.updates ?? {} }
+	};
+	Object.defineProperty(o, K, {
+		value: u,
+		enumerable: !1
+	}), Object.defineProperty(o, q, {
+		value: d,
+		enumerable: !1
+	}), U(o, W(e.name, e));
+	let f = h({
+		workflowName: e.name,
+		payloadSchema: H.isSchema(e.payload) ? e.payload : H.Struct(e.payload),
+		control: e
+	});
+	f !== void 0 && Object.defineProperty(o, J, {
+		value: f,
+		enumerable: !1
+	});
+	let p = w(e.name, e.schedule);
+	return p !== void 0 && Object.defineProperty(o, S, {
+		value: p,
+		enumerable: !1
+	}), o;
+}), ae = (e) => {
+	if (!X(e)) return;
+	let t = e[J];
+	return t === void 0 ? void 0 : t;
+}, oe = (e) => {
+	if (e.encrypted !== !0) return P.make(e);
+	i(e.name);
+	let t = H.isSchema(e.payload) ? e.payload : H.Struct(e.payload);
+	return P.make({
+		...e,
+		payload: l(t, `queue '${e.name}' payload`),
+		success: l(e.success ?? H.Void, `queue '${e.name}' result`),
+		error: l(e.error ?? H.Never, `queue '${e.name}' failure`)
+	});
+}, se = ((e, ...t) => B.flatMap(n, (n) => n && !r(e.name) ? B.die(/* @__PURE__ */ Error(`an encrypted workflow enqueued into durable queue '${e.name}', which is not encrypted: the queue's journal would hold the value in plaintext. Declare \`durableQueue({ …, encrypted: true })\`.`)) : P.process(e, ...t))), Q = ((...e) => {
+	let t = P.worker(...e);
+	return Object.defineProperty(t, G, {
+		value: !0,
+		enumerable: !1
+	}), t;
+}), ce = (e) => B.gen(function* () {
+	let t = yield* A.make({
+		name: `${e.name}/rateLimit`,
+		success: H.Number,
+		error: L.RateLimiterError,
+		execute: B.gen(function* () {
+			let t = yield* (yield* L.RateLimiter).consume({
+				...e,
+				onExceeded: "delay"
+			});
+			return z.toMillis(t.delay);
+		})
+	});
+	t > 0 && (yield* M.sleep({
+		name: `${e.name}/rateLimit`,
+		duration: z.millis(t)
+	}));
+}), $ = (e) => B.gen(function* () {
+	let t = yield* _, n = yield* B.serviceOption(y), r = z.toMillis(z.fromInputUnsafe(e.duration));
+	if (t !== void 0 && n._tag === "Some") {
+		let i = n.value, a = new Date(Date.now() + r).toISOString(), o = yield* ee;
+		yield* B.promise(() => i.recordEvent({
+			runId: t,
+			eventType: "timer-set",
+			payload: {
+				name: e.name,
+				durationMs: r,
+				scheduledWakeAt: a,
+				...o === void 0 ? {} : { tenantId: o }
+			}
+		}).catch(() => {}));
+		let s = Date.now();
+		yield* M.sleep(e), yield* B.promise(() => i.recordEvent({
+			runId: t,
+			eventType: "timer-fired",
+			payload: {
+				name: e.name,
+				actualDurationMs: Date.now() - s,
+				...o === void 0 ? {} : { tenantId: o }
+			}
+		}).catch(() => {}));
+	} else yield* M.sleep(e);
+}), le = (e) => B.gen(function* () {
+	let t = (yield* A.make({
+		name: `sleepUntil:${e.name}`,
+		success: H.Number,
+		execute: B.sync(() => e.until instanceof Date ? e.until.getTime() : e.until)
+	})) - Date.now();
+	t <= 0 || (yield* $({
+		name: e.name,
+		duration: `${t} millis`
+	}));
+}), ue = (t, r, i, a) => B.gen(function* () {
+	let o = yield* _, s = yield* A.CurrentAttempt, c = yield* B.serviceOption(y), l = yield* B.serviceOption(b), u = l._tag === "Some" ? l.value.interceptor(r, {
+		runId: o ?? "unrecorded",
+		stepName: t,
+		attempt: s
+	}) : r, d, f, p = !1;
+	if (o !== void 0 && c._tag === "Some") {
+		f = c.value;
+		let e = a === void 0 ? void 0 : (({ retryable: e, ...t }) => t)(a);
+		p = yield* n;
+		try {
+			d = yield* B.promise(() => f.startStep({
+				runId: o,
+				stepName: t,
+				attempt: s,
+				stepInput: i,
+				sealed: p,
+				...e === void 0 ? {} : { retryPolicy: e }
+			}));
+		} catch {
+			d = void 0;
+		}
+	}
+	let m = Date.now();
+	return yield* B.provideService(k(u, a), v, t).pipe(B.tap((e) => d && f ? B.promise(async () => {
+		try {
+			await f.endStepSuccess({
+				stepRecordId: d,
+				sealed: p,
+				output: e,
+				durationMs: Date.now() - m
+			});
+		} catch {}
+	}) : B.void), B.tapCause((t) => d && f && !R.hasInterruptsOnly(t) ? B.promise(async () => {
+		try {
+			let n = R.findErrorOption(t), r = t.reasons.filter(R.isFailReason).map((e) => e.error), i = t.reasons.filter(R.isDieReason).map((e) => e.defect), a = n._tag === "Some" ? n.value : i[0] ?? R.squash(t), o = e(a), s = a && typeof a == "object" && "_tag" in a ? String(a._tag) : null;
+			await f.endStepFailure({
+				stepRecordId: d,
+				sealed: p,
+				errorTag: s,
+				errorMessage: o,
+				errorCause: {
+					pretty: R.pretty(t),
+					failures: r,
+					defects: i
+				},
+				durationMs: Date.now() - m
+			});
+		} catch {}
+	}) : B.void));
+}), de = (e) => B.gen(function* () {
+	let t = yield* T;
+	if (t === void 0) return;
+	let n = t.reach(e);
+	n !== void 0 && (yield* O([n]));
+}), fe = (e, t, r) => {
+	let i = e;
+	return {
+		...e,
+		...V.Prototype({
+			label: "Activity",
+			evaluate: () => B.andThen(de(t), r === void 0 ? i : B.flatMap(n, (e) => e ? r().pipe(B.catchDefect((e) => B.die(o(e, `step '${t}' defect`)))) : i))
+		})
+	};
+}, pe = (e) => {
+	let { input: t, retry: n, ...r } = e, i = ue(r.name, r.execute, t, n), a = A.make({
+		...r,
+		execute: i
+	}), o, c = `step '${r.name}' defect`;
+	return fe(a, r.name, () => o ??= A.make({
+		...r,
+		success: l(r.success ?? H.Void, `step '${r.name}' result`),
+		error: l(r.error ?? H.Never, `step '${r.name}' failure`),
+		execute: i.pipe(B.catchDefect((e) => B.die(s(e, c))))
+	}));
+}, me = (e) => B.map(g, (t) => t.includes(e)), he = F.withCompensation, ge = A.idempotencyKey;
+//#endregion
+export { T as CurrentWorkflowReplayShape, x as DEFAULT_WORKFLOW_SCHEDULE_MAX_RUNTIME_MS, u as DEFERRING_CONTROLS, J as WorkflowFlowControlProperty, q as WorkflowMessagesProperty, S as WorkflowScheduleProperty, K as WorkflowVersionTypeId, G as WorkflowWorkerLayerTypeId, d as assertConsistentPools, f as deferringControlsOf, N as durableClock, oe as durableQueue, te as durableQueueModule, ae as getWorkflowFlowControl, C as getWorkflowSchedule, re as getWorkflowVersionMetadata, p as hasCancelOn, m as hasFlowControl, X as isCarrier, Y as isWorkflowWorkerLayer, E as makeReplayShapeTracker, D as nondeterminismEventPayload, me as patch, se as processQueue, Q as queueWorker, ce as rateLimit, O as reportNondeterminism, $ as sleep, le as sleepUntil, pe as step, ge as stepIdempotencyKey, j as stepModule, h as validateFlowControl, w as validateWorkflowSchedule, he as withCompensation, ie as workflow, ne as workflowModule };