octaflow 0.21.0 → 0.23.0

package/dist/ai/index.d.ts

@@ -1,7 +1,7 @@
 import { E as RetryPolicy, g as TypedWorkflow, h as TypedStepContext, m as TypedStep, nt as Result, tt as FlowErrorShape } from "../index-BURAYZui.js";
 import { n as Logger } from "../logger-BCus3AOa.js";
 import { i as BuildStepContextArgs, o as WorkflowHooks } from "../hooks-BdxIcc92.js";
-import { a as AiProviderMeta, c as DEFAULT_AI_PROVIDER, d as EMBEDDING_PROVIDER_IDS, f as EmbeddingProviderId, i as AiProviderId, l as DEFAULT_EMBEDDING_PROVIDER, m as embeddingDimensionsFor, n as AI_PROVIDER_IDS, o as AiProviderModelOption, p as EmbeddingProviderMeta, r as AiProcessingRegion, s as AiVendorResidency, t as AI_PROVIDERS, u as EMBEDDING_PROVIDERS } from "../provider-registry-bXGOmyeh.js";
+import { C as isSubprocessorResidency, S as embeddingDimensionsFor, _ as EmbeddingProviderMeta, a as AiProcessingRegion, b as OpenAiCompatibleProviderId, c as AiProviderModelOption, d as AiVendorResidency, f as DEFAULT_AI_PROVIDER, g as EmbeddingProviderId, h as EMBEDDING_PROVIDER_IDS, i as AiEndpointResidency, l as AiResidencyError, m as EMBEDDING_PROVIDERS, n as AI_PROVIDER_IDS, o as AiProviderId, p as DEFAULT_EMBEDDING_PROVIDER, r as AiEndpointRegion, s as AiProviderMeta, t as AI_PROVIDERS, u as AiResidencyResult, v as OPENAI_COMPATIBLE_PROVIDER, w as resolveEndpointResidency, x as OpenAiCompatibleProviderMeta, y as OPENAI_COMPATIBLE_PROVIDER_ID } from "../provider-registry-BDKSe_iO.js";
 import { z } from "zod";
 import { EmbeddingModelV4, LanguageModelV4, SharedV4ProviderMetadata } from "@ai-sdk/provider";
 //#region src/ai/instrumented-model.d.ts
@@ -82,6 +82,13 @@ export interface TokenUsage {
  * pinned ids (`mistral-medium-2508`) fall to the fallback.
  */
 export declare const DEFAULT_MODEL_PRICING: Record<string, ModelPricing>;
+/**
+ * A zero row for a model that costs nothing per token, such as one on a server
+ * you run. Add it per model id: `{ ...DEFAULT_MODEL_PRICING, 'qwen3-32b': ZERO_MODEL_PRICING }`.
+ * An id missing from the table prices at the priciest row, which is safe for a
+ * vendor and makes quota refuse a free model long before it should.
+ */
+export declare const ZERO_MODEL_PRICING: ModelPricing;
 export interface CostEstimatorOptions {
   /** Pricing table keyed by model id. Defaults to `DEFAULT_MODEL_PRICING`. */
   pricing?: Record<string, ModelPricing>;
@@ -543,4 +550,4 @@ export declare function thinkingSettingsFor(providerId: string, modelId: string,
   budgetTokens: number;
 }): ThinkingSettings;
 //#endregion
-export { AI_PROVIDERS, AI_PROVIDER_IDS, AiProcessingRegion, AiProviderId, AiProviderMeta, AiProviderModelOption, AiVendorResidency, DEFAULT_AI_PROVIDER, DEFAULT_EMBEDDING_PROVIDER, EMBEDDING_PROVIDERS, EMBEDDING_PROVIDER_IDS, EmbeddingProviderId, EmbeddingProviderMeta, embeddingDimensionsFor };
+export { AI_PROVIDERS, AI_PROVIDER_IDS, AiEndpointRegion, AiEndpointResidency, AiProcessingRegion, AiProviderId, AiProviderMeta, AiProviderModelOption, AiResidencyError, AiResidencyResult, AiVendorResidency, DEFAULT_AI_PROVIDER, DEFAULT_EMBEDDING_PROVIDER, EMBEDDING_PROVIDERS, EMBEDDING_PROVIDER_IDS, EmbeddingProviderId, EmbeddingProviderMeta, OPENAI_COMPATIBLE_PROVIDER, OPENAI_COMPATIBLE_PROVIDER_ID, OpenAiCompatibleProviderId, OpenAiCompatibleProviderMeta, embeddingDimensionsFor, isSubprocessorResidency, resolveEndpointResidency };

package/dist/ai/index.js

@@ -1,6 +1,6 @@
 import { S as ok, b as noopLogger, f as defineStep, l as buildWorkflow, x as err } from "../core-DNWPwFaE.js";
 import { a as readRefusalDetails, i as isAiRefusalError, n as REFUSAL_FINISH_REASON, r as createRefusalAwareModel, t as AiRefusalError } from "../refusal-BsL2HPDb.js";
-import { a as EMBEDDING_PROVIDERS, i as DEFAULT_EMBEDDING_PROVIDER, n as AI_PROVIDER_IDS, o as EMBEDDING_PROVIDER_IDS, r as DEFAULT_AI_PROVIDER, s as embeddingDimensionsFor, t as AI_PROVIDERS } from "../provider-registry-DcRDsjtT.js";
+import { a as EMBEDDING_PROVIDERS, c as OPENAI_COMPATIBLE_PROVIDER_ID, d as resolveEndpointResidency, i as DEFAULT_EMBEDDING_PROVIDER, l as embeddingDimensionsFor, n as AI_PROVIDER_IDS, o as EMBEDDING_PROVIDER_IDS, r as DEFAULT_AI_PROVIDER, s as OPENAI_COMPATIBLE_PROVIDER, t as AI_PROVIDERS, u as isSubprocessorResidency } from "../provider-registry-DHL-Ed-L.js";
 import { wrapEmbeddingModel, wrapLanguageModel } from "ai";
 //#region src/ai/instrumented-model.ts
 function createUsageAccumulator() {
@@ -266,6 +266,18 @@ const DEFAULT_MODEL_PRICING = {
 		cacheWritePerMillion: 0
 	}
 };
+/**
+* A zero row for a model that costs nothing per token, such as one on a server
+* you run. Add it per model id: `{ ...DEFAULT_MODEL_PRICING, 'qwen3-32b': ZERO_MODEL_PRICING }`.
+* An id missing from the table prices at the priciest row, which is safe for a
+* vendor and makes quota refuse a free model long before it should.
+*/
+const ZERO_MODEL_PRICING = Object.freeze({
+	inputPerMillion: 0,
+	outputPerMillion: 0,
+	cacheReadPerMillion: 0,
+	cacheWritePerMillion: 0
+});
 function priciest(pricing) {
 	let best;
 	for (const p of Object.values(pricing)) if (!best || p.outputPerMillion > best.outputPerMillion) best = p;
@@ -650,4 +662,4 @@ function thinkingSettingsFor(providerId, modelId, opts) {
 	return { temperature: opts.temperature };
 }
 //#endregion
-export { AI_PROVIDERS, AI_PROVIDER_IDS, AiRefusalError, DEFAULT_AI_PROVIDER, DEFAULT_AI_QUOTA, DEFAULT_EMBEDDING_PROVIDER, DEFAULT_MODEL_PRICING, EMBEDDING_PROVIDERS, EMBEDDING_PROVIDER_IDS, REFUSAL_FINISH_REASON, anthropicThinkingSettings, buildAiWorkflow, createAiQuotaService, createAiUsageAggregationService, createAiWorkflowHooks, createCostEstimator, createEmbeddingUsageAccumulator, createInstrumentedEmbeddingModel, createInstrumentedModel, createRefusalAwareModel, createUsageAccumulator, defineAiStep, embeddingDimensionsFor, estimateCostMicros, isAiRefusalError, readRefusalDetails, supportsAdaptiveThinking, supportsToolSearch, thinkingSettingsFor };
+export { AI_PROVIDERS, AI_PROVIDER_IDS, AiRefusalError, DEFAULT_AI_PROVIDER, DEFAULT_AI_QUOTA, DEFAULT_EMBEDDING_PROVIDER, DEFAULT_MODEL_PRICING, EMBEDDING_PROVIDERS, EMBEDDING_PROVIDER_IDS, OPENAI_COMPATIBLE_PROVIDER, OPENAI_COMPATIBLE_PROVIDER_ID, REFUSAL_FINISH_REASON, ZERO_MODEL_PRICING, anthropicThinkingSettings, buildAiWorkflow, createAiQuotaService, createAiUsageAggregationService, createAiWorkflowHooks, createCostEstimator, createEmbeddingUsageAccumulator, createInstrumentedEmbeddingModel, createInstrumentedModel, createRefusalAwareModel, createUsageAccumulator, defineAiStep, embeddingDimensionsFor, estimateCostMicros, isAiRefusalError, isSubprocessorResidency, readRefusalDetails, resolveEndpointResidency, supportsAdaptiveThinking, supportsToolSearch, thinkingSettingsFor };

package/dist/ai/providers/index.d.ts

@@ -1,4 +1,4 @@
-import { f as EmbeddingProviderId, i as AiProviderId } from "../../provider-registry-bXGOmyeh.js";
+import { b as OpenAiCompatibleProviderId, g as EmbeddingProviderId, i as AiEndpointResidency, o as AiProviderId } from "../../provider-registry-BDKSe_iO.js";
 import { EmbeddingModelV4, LanguageModelV4 } from "@ai-sdk/provider";
 //#region src/ai/providers/index.d.ts
 export type LanguageModelFactory = (modelId: string) => LanguageModelV4;
@@ -66,4 +66,81 @@ export interface LazyEmbeddingModelMeta {
  * next call rather than cached.
  */
 export declare function createLazyEmbeddingModel(meta: LazyEmbeddingModelMeta, load: () => Promise<EmbeddingModelV4>): EmbeddingModelV4;
+export type AiProviderConfigErrorKey = 'ai_residency_undeclared' | 'ai_residency_invalid' | 'ai_base_url_invalid' | 'ai_model_required' | 'ai_embedding_dimensions_invalid';
+/**
+ * A provider configuration that cannot work. Thrown before any SDK is loaded
+ * or any request is made: it is a deployment mistake, found at wiring time.
+ */
+export declare class AiProviderConfigError extends Error {
+  readonly key: AiProviderConfigErrorKey;
+  constructor(key: AiProviderConfigErrorKey, message: string);
+}
+export interface OpenAiCompatibleEndpointConfig {
+  /** The API root including its version segment, e.g. `http://vllm.ai.svc:8000/v1`. Required: there is no default host. */
+  baseUrl: string;
+  /** Sent as `Authorization: Bearer …` when set. Most self-hosted servers need none. */
+  apiKey?: string;
+  /** Where the endpoint processes payloads. Required, validated by `resolveEndpointResidency`. */
+  residency: AiEndpointResidency;
+  /** Reported as the model's `provider`. Defaults to `openai-compatible`. */
+  name?: string;
+  headers?: Record<string, string>;
+  /** A fetch implementation, for middleware or tests. Defaults to the global `fetch`. */
+  fetch?: typeof globalThis.fetch;
+}
+export interface OpenAiCompatibleModelProviderConfig extends OpenAiCompatibleEndpointConfig {
+  /** The model a call without an id uses. Required: a server you run has no registry default. */
+  defaultModel: string;
+  /** Cheap model for classifier-style passes. Defaults to `defaultModel`. */
+  classifierModel?: string;
+  /** Set when the server enforces a JSON schema on output (vLLM does); otherwise `generateObject` uses JSON mode. */
+  structuredOutputs?: boolean;
+  /**
+   * Ask for token usage on streamed responses. Defaults to `true`, because the
+   * instrumented model meters what the stream reports and a stream without it
+   * reports zero tokens. Turn it off only for a server that rejects the option.
+   */
+  includeUsage?: boolean;
+}
+export interface OpenAiCompatibleModelProvider {
+  providerId: OpenAiCompatibleProviderId;
+  /** The declared residency, validated — what a badge or an audit record shows. */
+  residency: AiEndpointResidency;
+  classifierModelId: string;
+  /** A Chat Completions model, wrapped for refusal detection like the vendor ones. */
+  languageModel(modelId?: string): LanguageModelV4;
+}
+export interface OpenAiCompatibleEmbeddingProviderConfig extends OpenAiCompatibleEndpointConfig {
+  model: string;
+  /**
+   * The model's vector width, which must match your `vector(N)` column.
+   * Required: a guessed width, such as the registry's 1536 fallback, silently
+   * breaks a 1024-wide model like `bge-m3` at the first insert.
+   */
+  dimensions: number;
+}
+export interface OpenAiCompatibleEmbeddingProvider {
+  providerId: OpenAiCompatibleProviderId;
+  residency: AiEndpointResidency;
+  modelId: string;
+  dimensions: number;
+  embeddingModel(): EmbeddingModelV4;
+}
+/**
+ * A model server you run, or any host with the OpenAI-compatible API, as
+ * refusal-aware models. Language models go through **Chat Completions**, which
+ * is what vLLM, Ollama and llama.cpp speak — not the Responses API that
+ * `@ai-sdk/openai` defaults to.
+ *
+ * ```ts
+ * const models = await createOpenAiCompatibleModelProvider({
+ *   baseUrl: 'http://vllm.ai.svc:8000/v1',
+ *   residency: { region: 'self-hosted' },
+ *   defaultModel: 'qwen3-32b',
+ * });
+ * ```
+ */
+export declare function createOpenAiCompatibleModelProvider(config: OpenAiCompatibleModelProviderConfig): Promise<OpenAiCompatibleModelProvider>;
+/** An embedding model on an OpenAI-compatible endpoint, with its declared width. */
+export declare function createOpenAiCompatibleEmbeddingProvider(config: OpenAiCompatibleEmbeddingProviderConfig): Promise<OpenAiCompatibleEmbeddingProvider>;
 //#endregion

package/dist/ai/providers/index.js

@@ -1,5 +1,5 @@
 import { r as createRefusalAwareModel } from "../../refusal-BsL2HPDb.js";
-import { a as EMBEDDING_PROVIDERS, t as AI_PROVIDERS } from "../../provider-registry-DcRDsjtT.js";
+import { a as EMBEDDING_PROVIDERS, c as OPENAI_COMPATIBLE_PROVIDER_ID, d as resolveEndpointResidency, t as AI_PROVIDERS } from "../../provider-registry-DHL-Ed-L.js";
 //#region src/ai/providers/index.ts
 const LLM_LOADERS = {
 	anthropic: async (apiKey, baseURL) => {
@@ -103,5 +103,87 @@ function createLazyEmbeddingModel(meta, load) {
 		doEmbed: (options) => model().then((m) => m.doEmbed(options))
 	};
 }
+/**
+* A provider configuration that cannot work. Thrown before any SDK is loaded
+* or any request is made: it is a deployment mistake, found at wiring time.
+*/
+var AiProviderConfigError = class extends Error {
+	key;
+	constructor(key, message) {
+		super(message);
+		this.name = "AiProviderConfigError";
+		this.key = key;
+	}
+};
+function checkEndpoint(config) {
+	const residency = resolveEndpointResidency(config.residency);
+	if (!residency.ok) throw new AiProviderConfigError(residency.error.key, residency.error.message);
+	let url;
+	try {
+		url = new URL(config.baseUrl);
+	} catch {
+		url = void 0;
+	}
+	if (url === void 0 || url.protocol !== "http:" && url.protocol !== "https:") throw new AiProviderConfigError("ai_base_url_invalid", `baseUrl must be an absolute http(s) URL, got ${JSON.stringify(config.baseUrl)}`);
+	return residency.value;
+}
+function requireModel(modelId, field) {
+	if (typeof modelId !== "string" || modelId.trim() === "") throw new AiProviderConfigError("ai_model_required", `${field} is required for an OpenAI-compatible endpoint`);
+	return modelId;
+}
+async function loadOpenAiCompatible(config, options = {}) {
+	const { createOpenAICompatible } = await import("@ai-sdk/openai-compatible");
+	return createOpenAICompatible({
+		name: config.name ?? "openai-compatible",
+		baseURL: config.baseUrl.replace(/\/+$/, ""),
+		apiKey: config.apiKey,
+		headers: config.headers,
+		fetch: config.fetch,
+		includeUsage: options.includeUsage ?? true,
+		supportsStructuredOutputs: options.structuredOutputs
+	});
+}
+/**
+* A model server you run, or any host with the OpenAI-compatible API, as
+* refusal-aware models. Language models go through **Chat Completions**, which
+* is what vLLM, Ollama and llama.cpp speak — not the Responses API that
+* `@ai-sdk/openai` defaults to.
+*
+* ```ts
+* const models = await createOpenAiCompatibleModelProvider({
+*   baseUrl: 'http://vllm.ai.svc:8000/v1',
+*   residency: { region: 'self-hosted' },
+*   defaultModel: 'qwen3-32b',
+* });
+* ```
+*/
+async function createOpenAiCompatibleModelProvider(config) {
+	const residency = checkEndpoint(config);
+	const defaultModel = requireModel(config.defaultModel, "defaultModel");
+	const provider = await loadOpenAiCompatible(config, {
+		structuredOutputs: config.structuredOutputs,
+		includeUsage: config.includeUsage
+	});
+	return {
+		providerId: OPENAI_COMPATIBLE_PROVIDER_ID,
+		residency,
+		classifierModelId: config.classifierModel ?? defaultModel,
+		languageModel: (modelId) => createRefusalAwareModel(provider.chatModel(modelId ?? defaultModel))
+	};
+}
+/** An embedding model on an OpenAI-compatible endpoint, with its declared width. */
+async function createOpenAiCompatibleEmbeddingProvider(config) {
+	const residency = checkEndpoint(config);
+	const modelId = requireModel(config.model, "model");
+	if (!Number.isInteger(config.dimensions) || config.dimensions <= 0) throw new AiProviderConfigError("ai_embedding_dimensions_invalid", `dimensions must be a positive integer matching your vector column, got ${JSON.stringify(config.dimensions)}`);
+	const provider = await loadOpenAiCompatible(config);
+	return {
+		providerId: OPENAI_COMPATIBLE_PROVIDER_ID,
+		residency,
+		modelId,
+		dimensions: config.dimensions,
+		embeddingModel: () => provider.embeddingModel(modelId)
+	};
+}
 //#endregion
-export { createEmbeddingModelFactory, createEmbeddingModelProvider, createLanguageModelFactory, createLanguageModelProvider, createLazyEmbeddingModel };
+export { AiProviderConfigError, createEmbeddingModelFactory, createEmbeddingModelProvider, createLanguageModelFactory, createLanguageModelProvider, createLazyEmbeddingModel, createOpenAiCompatibleEmbeddingProvider, createOpenAiCompatibleModelProvider };

package/dist/ai/registry.d.ts

@@ -1,2 +1,2 @@
-import { a as AiProviderMeta, c as DEFAULT_AI_PROVIDER, d as EMBEDDING_PROVIDER_IDS, f as EmbeddingProviderId, i as AiProviderId, l as DEFAULT_EMBEDDING_PROVIDER, m as embeddingDimensionsFor, n as AI_PROVIDER_IDS, o as AiProviderModelOption, p as EmbeddingProviderMeta, r as AiProcessingRegion, s as AiVendorResidency, t as AI_PROVIDERS, u as EMBEDDING_PROVIDERS } from "../provider-registry-bXGOmyeh.js";
-export { AI_PROVIDERS, AI_PROVIDER_IDS, AiProcessingRegion, AiProviderId, AiProviderMeta, AiProviderModelOption, AiVendorResidency, DEFAULT_AI_PROVIDER, DEFAULT_EMBEDDING_PROVIDER, EMBEDDING_PROVIDERS, EMBEDDING_PROVIDER_IDS, EmbeddingProviderId, EmbeddingProviderMeta, embeddingDimensionsFor };
+import { C as isSubprocessorResidency, S as embeddingDimensionsFor, _ as EmbeddingProviderMeta, a as AiProcessingRegion, b as OpenAiCompatibleProviderId, c as AiProviderModelOption, d as AiVendorResidency, f as DEFAULT_AI_PROVIDER, g as EmbeddingProviderId, h as EMBEDDING_PROVIDER_IDS, i as AiEndpointResidency, l as AiResidencyError, m as EMBEDDING_PROVIDERS, n as AI_PROVIDER_IDS, o as AiProviderId, p as DEFAULT_EMBEDDING_PROVIDER, r as AiEndpointRegion, s as AiProviderMeta, t as AI_PROVIDERS, u as AiResidencyResult, v as OPENAI_COMPATIBLE_PROVIDER, w as resolveEndpointResidency, x as OpenAiCompatibleProviderMeta, y as OPENAI_COMPATIBLE_PROVIDER_ID } from "../provider-registry-BDKSe_iO.js";
+export { AI_PROVIDERS, AI_PROVIDER_IDS, AiEndpointRegion, AiEndpointResidency, AiProcessingRegion, AiProviderId, AiProviderMeta, AiProviderModelOption, AiResidencyError, AiResidencyResult, AiVendorResidency, DEFAULT_AI_PROVIDER, DEFAULT_EMBEDDING_PROVIDER, EMBEDDING_PROVIDERS, EMBEDDING_PROVIDER_IDS, EmbeddingProviderId, EmbeddingProviderMeta, OPENAI_COMPATIBLE_PROVIDER, OPENAI_COMPATIBLE_PROVIDER_ID, OpenAiCompatibleProviderId, OpenAiCompatibleProviderMeta, embeddingDimensionsFor, isSubprocessorResidency, resolveEndpointResidency };

package/dist/ai/registry.js

@@ -1,2 +1,2 @@
-import { a as EMBEDDING_PROVIDERS, i as DEFAULT_EMBEDDING_PROVIDER, n as AI_PROVIDER_IDS, o as EMBEDDING_PROVIDER_IDS, r as DEFAULT_AI_PROVIDER, s as embeddingDimensionsFor, t as AI_PROVIDERS } from "../provider-registry-DcRDsjtT.js";
-export { AI_PROVIDERS, AI_PROVIDER_IDS, DEFAULT_AI_PROVIDER, DEFAULT_EMBEDDING_PROVIDER, EMBEDDING_PROVIDERS, EMBEDDING_PROVIDER_IDS, embeddingDimensionsFor };
+import { a as EMBEDDING_PROVIDERS, c as OPENAI_COMPATIBLE_PROVIDER_ID, d as resolveEndpointResidency, i as DEFAULT_EMBEDDING_PROVIDER, l as embeddingDimensionsFor, n as AI_PROVIDER_IDS, o as EMBEDDING_PROVIDER_IDS, r as DEFAULT_AI_PROVIDER, s as OPENAI_COMPATIBLE_PROVIDER, t as AI_PROVIDERS, u as isSubprocessorResidency } from "../provider-registry-DHL-Ed-L.js";
+export { AI_PROVIDERS, AI_PROVIDER_IDS, DEFAULT_AI_PROVIDER, DEFAULT_EMBEDDING_PROVIDER, EMBEDDING_PROVIDERS, EMBEDDING_PROVIDER_IDS, OPENAI_COMPATIBLE_PROVIDER, OPENAI_COMPATIBLE_PROVIDER_ID, embeddingDimensionsFor, isSubprocessorResidency, resolveEndpointResidency };

package/dist/pg-boss/index.d.ts

@@ -1,2 +1,226 @@
-import { C as WireStartPayload, S as WIRE_STEP_PAYLOAD_SCHEMA, T as resolveStartIdempotencyKey, _ as ensureStepQueue, a as createPgBossScheduler, b as StepQueueConfig, c as DlqProcessor, d as PgBossStepWorkerDeps, f as PgBossStepWorkerOptions, g as createPgBossStepWorker, h as createPgBossDlqWorker, i as StartJobProcessor, l as PgBossDispatcherDeps, m as createPgBossDispatcher, n as PgBossStartWorkerDeps, o as createPgBossStartWorker, p as StepJobProcessor, r as ScheduleStartInput, s as ensureStartQueue, t as PgBossSchedulerDeps, u as PgBossDlqWorkerDeps, v as DEFAULT_STEP_QUEUE_CONFIG, w as WireStepPayload, x as WIRE_START_PAYLOAD_SCHEMA, y as StartJobContext } from "../scheduler-YCFUqjXf.js";
-export { DEFAULT_STEP_QUEUE_CONFIG, DlqProcessor, PgBossDispatcherDeps, PgBossDlqWorkerDeps, PgBossSchedulerDeps, PgBossStartWorkerDeps, PgBossStepWorkerDeps, PgBossStepWorkerOptions, ScheduleStartInput, StartJobContext, StartJobProcessor, StepJobProcessor, StepQueueConfig, WIRE_START_PAYLOAD_SCHEMA, WIRE_STEP_PAYLOAD_SCHEMA, WireStartPayload, WireStepPayload, createPgBossDispatcher, createPgBossDlqWorker, createPgBossScheduler, createPgBossStartWorker, createPgBossStepWorker, ensureStartQueue, ensureStepQueue, resolveStartIdempotencyKey };
+import "../index-BURAYZui.js";
+import { n as Logger } from "../logger-BCus3AOa.js";
+import { r as Dispatcher } from "../dispatcher-g7Ct0J6w.js";
+import { z } from "zod";
+import { PgBoss } from "pg-boss";
+//#region src/pg-boss/payload.d.ts
+/**
+ * The wire payload for a step job. It is the flow-core `DispatchStepPayload`
+ * plus the `partitionKey` — the worker needs the partition to reconstruct a
+ * partition-scoped engine before handing the job to `engine.handleStepJob`.
+ */
+export declare const WIRE_STEP_PAYLOAD_SCHEMA: z.ZodObject<{
+  partitionKey: z.ZodString;
+  workflowId: z.ZodNumber;
+  stepId: z.ZodNumber;
+  stepKey: z.ZodString;
+  stepType: z.ZodString;
+  kind: z.ZodDefault<z.ZodEnum<{
+    execute: "execute";
+    timeout: "timeout";
+  }>>;
+}, z.core.$strip>;
+export type WireStepPayload = z.infer<typeof WIRE_STEP_PAYLOAD_SCHEMA>;
+export interface StepQueueConfig {
+  /** Retries before a job is dead-lettered. Default 2. */
+  retryLimit?: number;
+  /** Seconds between retries. Default 30. */
+  retryDelay?: number;
+  /** Seconds before an in-flight job is considered expired. Default 600. */
+  expireInSeconds?: number;
+}
+export declare const DEFAULT_STEP_QUEUE_CONFIG: Required<StepQueueConfig>;
+/**
+ * The wire payload for a scheduled (or ad-hoc) workflow **start**. Carries the
+ * partition plus what `engine.startWorkflow` needs; the host resolves `workflowType`
+ * to a definition.
+ *
+ * Two mutually exclusive ways to ask for start idempotency, because a cron schedule
+ * stores its payload **once** and pg-boss redelivers that same payload on every tick:
+ *
+ * - `idempotencyKeyPrefix` — the usual choice. The start worker appends the job id,
+ *   so each tick gets a distinct key while a redelivery of the *same* tick reuses it.
+ * - `idempotencyKey` — used verbatim. On a schedule this means "start exactly one
+ *   workflow, ever"; every later tick returns the first one.
+ */
+export declare const WIRE_START_PAYLOAD_SCHEMA: z.ZodObject<{
+  partitionKey: z.ZodString;
+  workflowType: z.ZodString;
+  input: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  entityRef: z.ZodOptional<z.ZodString>;
+  idempotencyKey: z.ZodOptional<z.ZodString>;
+  idempotencyKeyPrefix: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type WireStartPayload = z.infer<typeof WIRE_START_PAYLOAD_SCHEMA>;
+/**
+ * What a {@link WireStartPayload} becomes at delivery time: the same fields, plus the
+ * pg-boss job id and the **resolved** `idempotencyKey` to hand `engine.startWorkflow`.
+ *
+ * `idempotencyKey` is verbatim when the payload set one, `${idempotencyKeyPrefix}:${jobId}`
+ * when it set a prefix, and `undefined` when it set neither.
+ */
+export interface StartJobContext extends WireStartPayload {
+  /** pg-boss job id — unique per cron tick, stable across that job's retries. */
+  jobId: string;
+}
+/** Resolve the per-delivery idempotency key. Explicit key wins over a prefix. */
+export declare function resolveStartIdempotencyKey(payload: WireStartPayload, jobId: string): string | undefined;
+//#endregion
+//#region src/pg-boss/queue.d.ts
+/**
+ * Create the step queue and its dead-letter queue if they do not exist. Call
+ * once at startup; the dispatcher also runs it from `prepare` and lazily on a
+ * plain first enqueue.
+ *
+ * Only what is missing is created: pg-boss's `createQueue` evicts the queue's
+ * entry from its per-instance cache, and a `send` that misses that cache reads
+ * the queue on pg-boss's *own* connection — inside a store transaction on a
+ * single-connection database that is a deadlock. An existing queue is left
+ * alone, cache entry and all.
+ */
+export declare function ensureStepQueue(boss: PgBoss, queueName: string, config?: StepQueueConfig): Promise<void>;
+export interface PgBossDispatcherDeps {
+  boss: PgBoss;
+  queueName: string;
+  /** Partition this dispatcher is bound to — stamped into every enqueued job. */
+  partitionKey: string;
+  config?: StepQueueConfig;
+}
+/** A flow-core `Dispatcher` backed by pg-boss. */
+export declare function createPgBossDispatcher(deps: PgBossDispatcherDeps): Dispatcher;
+export interface PgBossStepWorkerOptions {
+  /** Steps fetched per poll. Default 1. */
+  batchSize?: number;
+  /** Base poll interval in seconds (pg-boss minimum 0.5). Default: pg-boss's own. */
+  pollingIntervalSeconds?: number;
+  /**
+   * Poll interval used while pg-boss's LISTEN/NOTIFY is active for the queue, where
+   * polling is only a backstop. Ignored when notify is off or unavailable.
+   */
+  notifyPollingIntervalSeconds?: number;
+  /**
+   * Keep fetching with no delay while every fetch returns a full `batchSize` batch;
+   * the first short fetch ends the burst. Ignored when `batchSize` is 1.
+   *
+   * **Worth enabling for throughput.** Without it a worker spends most of its time
+   * waiting out the poll interval: it drains a batch in milliseconds, then sleeps.
+   * See the performance table in the README.
+   */
+  burstWhenBatchFull?: boolean;
+  /** Burst while the queue's cached ready count exceeds this. Reacts on pg-boss's stats cadence. */
+  burstWhenReadyExceeds?: number;
+  /**
+   * How many steps from one fetched batch run at a time. Default 1 (serial).
+   *
+   * Raising this only helps once the worker is not poll-bound — pair it with
+   * `burstWhenBatchFull`. Each in-flight step needs a store connection, so keep
+   * `concurrency × workers` within your Postgres pool and `max_connections`.
+   */
+  concurrency?: number;
+}
+export interface PgBossStepWorkerDeps {
+  boss: PgBoss;
+  queueName: string;
+  config?: StepQueueConfig;
+  logger?: Logger;
+  workerOptions?: PgBossStepWorkerOptions;
+}
+/** Handles a single step job. Reconstruct the partition-scoped engine and call
+ * `engine.executeStep(workflowId, stepId)`. Throw to trigger a pg-boss retry. */
+export type StepJobProcessor = (payload: WireStepPayload) => Promise<void>;
+/** A pg-boss worker that drives `executeStep` for step jobs. */
+export declare function createPgBossStepWorker(deps: PgBossStepWorkerDeps): {
+  start: (process: StepJobProcessor) => Promise<void>;
+  stop: () => Promise<void>;
+};
+export interface PgBossDlqWorkerDeps {
+  boss: PgBoss;
+  queueName: string;
+  logger?: Logger;
+  pollingIntervalSeconds?: number;
+}
+/** Invoked for a step job that exhausted all retries. Typically calls
+ * `engine.handleStepExhausted(workflowId, stepId, reason)`. */
+export type DlqProcessor = (payload: WireStepPayload) => Promise<void>;
+/** A pg-boss worker on the step queue's dead-letter queue. */
+export declare function createPgBossDlqWorker(deps: PgBossDlqWorkerDeps): {
+  start: (onDlq: DlqProcessor) => Promise<void>;
+  stop: () => Promise<void>;
+};
+//#endregion
+//#region src/pg-boss/scheduler.d.ts
+/** Create the start queue (idempotent). */
+export declare function ensureStartQueue(boss: PgBoss, queueName: string): Promise<void>;
+export interface PgBossSchedulerDeps {
+  boss: PgBoss;
+  /** Queue scheduled start jobs are sent to (and the start worker reads). */
+  queueName: string;
+  /** Partition stamped into every scheduled start payload. */
+  partitionKey: string;
+  logger?: Logger;
+}
+export interface ScheduleStartInput {
+  /** Unique key for this schedule within the queue (allows many crons per queue). */
+  key: string;
+  /** Cron expression (5- or 6-field). */
+  cron: string;
+  /** Workflow type to start (the host resolves it to a definition). */
+  workflowType: string;
+  input?: Record<string, unknown>;
+  entityRef?: string;
+  /**
+   * Per-tick start idempotency. The start worker resolves this to
+   * `${idempotencyKeyPrefix}:${jobId}`, so each cron tick gets a distinct key while a
+   * redelivery of the same tick reuses it — the usual thing you want on a schedule.
+   */
+  idempotencyKeyPrefix?: string;
+  /**
+   * Verbatim start idempotency key.
+   *
+   * A schedule stores its payload **once**, so this same key rides every tick — and
+   * start keys never expire. On a cron schedule that means **exactly one workflow,
+   * ever**; every later tick returns the first one. That is occasionally what you
+   * want ("run this once and never again"); if it isn't, use `idempotencyKeyPrefix`.
+   */
+  idempotencyKey?: string;
+  /** Optional IANA time zone (default UTC). */
+  tz?: string;
+}
+/** Registers cron schedules that enqueue workflow-start jobs. */
+export declare function createPgBossScheduler(deps: PgBossSchedulerDeps): {
+  /** Create or replace a cron schedule that starts a workflow. */
+  schedule(input: ScheduleStartInput): Promise<void>;
+  /** Remove a schedule by key. */
+  unschedule(key: string): Promise<void>;
+  /** List the schedules registered on this queue. */
+  list(): Promise<import("pg-boss").Schedule[]>;
+};
+/**
+ * Invoked for each start job — typically resolves the type and calls `engine.startWorkflow`.
+ *
+ * The context's `idempotencyKey` is already resolved for **this delivery** (see
+ * {@link resolveStartIdempotencyKey}), so forwarding it is the right default:
+ *
+ * ```ts
+ * await starter.start(async (job) => {
+ *   const wf = workflowsByType[job.workflowType];
+ *   await engine.startWorkflow(wf.definition, job.input, { idempotencyKey: job.idempotencyKey });
+ * });
+ * ```
+ */
+export type StartJobProcessor = (payload: StartJobContext) => Promise<void>;
+export interface PgBossStartWorkerDeps {
+  boss: PgBoss;
+  queueName: string;
+  logger?: Logger;
+  workerOptions?: {
+    batchSize?: number;
+    pollingIntervalSeconds?: number;
+  };
+}
+/** A pg-boss worker on the start queue that drives a host start callback. */
+export declare function createPgBossStartWorker(deps: PgBossStartWorkerDeps): {
+  start: (process: StartJobProcessor) => Promise<void>;
+  stop: () => Promise<void>;
+};
+//#endregion