octaflow 0.17.2 → 0.17.3

package/README.md

@@ -1,6 +1,6 @@
 # octaflow
 
-[![CI](https://github.com/octabits-io/octaflow/actions/workflows/ci.yml/badge.svg)](https://github.com/octabits-io/octaflow/actions/workflows/ci.yml)
+[![CI](https://github.com/octabits-io/octabits/actions/workflows/ci.yml/badge.svg)](https://github.com/octabits-io/octabits/actions/workflows/ci.yml)
 [![npm](https://img.shields.io/npm/v/octaflow.svg)](https://www.npmjs.com/package/octaflow)
 [![docs](https://img.shields.io/badge/docs-octaflow.octabits.io-16794a.svg)](https://octaflow.octabits.io/)
 [![license](https://img.shields.io/npm/l/octaflow.svg)](./LICENSE)
@@ -299,6 +299,8 @@ enforces, and the correctness requirements a custom `WorkflowStore` has to meet.
 
 ## Status
 
-Pre-1.0 — developed in [octabits-io/octaflow](https://github.com/octabits-io/octaflow) (extracted from the
-[octabits platform monorepo](https://github.com/octabits-io/platform), where its earlier history lives).
-The API is stable but may still see breaking changes in 0.x minors.
+Pre-1.0 — developed in the [octabits platform monorepo](https://github.com/octabits-io/octabits)
+under [`packages/octaflow`](https://github.com/octabits-io/octabits/tree/main/packages/octaflow)
+(a standalone repository from 2026-07-14 to 2026-09-06; that history is merged in).
+Independently versioned and published as the unscoped `octaflow`. The API is stable but may
+still see breaking changes in 0.x minors.

package/dist/ai/index.d.ts

@@ -4,14 +4,14 @@ import { i as BuildStepContextArgs, o as WorkflowHooks } from "../hooks-BdxIcc92
 import { z } from "zod";
 import { EmbeddingModelV4, LanguageModelV4 } from "@ai-sdk/provider";
 //#region src/ai/instrumented-model.d.ts
-interface AccumulatedUsage {
+export interface AccumulatedUsage {
   inputTokens: number;
   outputTokens: number;
   cacheReadTokens: number;
   cacheWriteTokens: number;
   modelId: string;
 }
-interface UsageAccumulator {
+export interface UsageAccumulator {
   /** Record usage from a single LLM call (additive — supports multiple calls per step). */
   record(usage: AccumulatedUsage): void;
   /** Total accumulated usage across all calls. */
@@ -19,20 +19,20 @@ interface UsageAccumulator {
   /** Whether any usage was recorded. */
   hasUsage(): boolean;
 }
-declare function createUsageAccumulator(): UsageAccumulator;
+export declare function createUsageAccumulator(): UsageAccumulator;
 /**
  * Wrap a language model with usage-tracking middleware. The accumulator collects
  * token usage from every doGenerate/doStream call routed through the wrapped model.
  */
-declare function createInstrumentedModel(model: LanguageModelV4, accumulator: UsageAccumulator): LanguageModelV4;
+export declare function createInstrumentedModel(model: LanguageModelV4, accumulator: UsageAccumulator): LanguageModelV4;
 //#endregion
 //#region src/ai/instrumented-embedding-model.d.ts
-interface EmbeddingAccumulatedUsage {
+export interface EmbeddingAccumulatedUsage {
   inputTokens: number;
   callCount: number;
   modelId: string;
 }
-interface EmbeddingUsageAccumulator {
+export interface EmbeddingUsageAccumulator {
   /** Record usage from a single doEmbed call (additive — supports multiple calls per batch). */
   record(tokens: number, modelId: string): void;
   /** Total accumulated usage across all calls. */
@@ -42,14 +42,14 @@ interface EmbeddingUsageAccumulator {
   /** Clear all accumulated state — used when a long-lived accumulator is reused across flushes. */
   reset(): void;
 }
-declare function createEmbeddingUsageAccumulator(): EmbeddingUsageAccumulator;
+export declare function createEmbeddingUsageAccumulator(): EmbeddingUsageAccumulator;
 /**
  * Wrap an embedding model with usage-tracking middleware. The accumulator collects
  * token usage from every doEmbed call routed through the wrapped model — both
  * `embed()` (single value) and `embedMany()` (batched values) invoke doEmbed one or
  * more times, and each invocation is recorded.
  */
-declare function createInstrumentedEmbeddingModel(model: EmbeddingModelV4, accumulator: EmbeddingUsageAccumulator): EmbeddingModelV4;
+export declare function createInstrumentedEmbeddingModel(model: EmbeddingModelV4, accumulator: EmbeddingUsageAccumulator): EmbeddingModelV4;
 //#endregion
 //#region src/ai/cost.d.ts
 /**
@@ -59,31 +59,31 @@ declare function createInstrumentedEmbeddingModel(model: EmbeddingModelV4, accum
  * The pricing table is injectable: pass your own to `createCostEstimator` for a
  * different provider/model set. A default Anthropic/OpenAI-embedding table ships.
  */
-interface ModelPricing {
+export interface ModelPricing {
   inputPerMillion: number;
   outputPerMillion: number;
   cacheReadPerMillion: number;
   cacheWritePerMillion: number;
 }
-interface TokenUsage {
+export interface TokenUsage {
   inputTokens: number;
   outputTokens: number;
   cacheReadTokens: number;
   cacheWriteTokens: number;
 }
 /** Default pricing (USD per million tokens), as of 2026-04. */
-declare const DEFAULT_MODEL_PRICING: Record<string, ModelPricing>;
-interface CostEstimatorOptions {
+export declare const DEFAULT_MODEL_PRICING: Record<string, ModelPricing>;
+export interface CostEstimatorOptions {
   /** Pricing table keyed by model id. Defaults to `DEFAULT_MODEL_PRICING`. */
   pricing?: Record<string, ModelPricing>;
   /** Pricing used for unknown model ids. Defaults to the priciest entry in the table (safe overcounting). */
   fallback?: ModelPricing;
 }
-type CostEstimator = (usage: TokenUsage, modelId: string) => number;
+export type CostEstimator = (usage: TokenUsage, modelId: string) => number;
 /** Build a cost estimator returning microdollars. */
-declare function createCostEstimator(options?: CostEstimatorOptions): CostEstimator;
+export declare function createCostEstimator(options?: CostEstimatorOptions): CostEstimator;
 /** Convenience estimator using the default pricing table. */
-declare const estimateCostMicros: CostEstimator;
+export declare const estimateCostMicros: CostEstimator;
 //#endregion
 //#region src/ai/context.d.ts
 /**
@@ -91,7 +91,7 @@ declare const estimateCostMicros: CostEstimator;
  * `buildStepContext` hook in `createAiWorkflowHooks` and consumed by AI step
  * handlers (which read `ctx.context.model` / `ctx.context.host`).
  */
-interface AiContext<THost = unknown> {
+export interface AiContext<THost = unknown> {
   /** Instrumented language model — token usage is captured automatically. */
   model: LanguageModelV4;
   /** Host-provided per-step context (DI scope, domain services, …). */
@@ -105,7 +105,7 @@ interface AiContext<THost = unknown> {
 //#endregion
 //#region src/ai/define-ai-step.d.ts
 /** An AI workflow step — a flow-core `TypedStep` whose context is an `AiContext`. */
-type AiTypedStep<TInput extends Record<string, unknown> = Record<string, unknown>, TOutput extends Record<string, unknown> = Record<string, unknown>, THost = unknown, TDeps extends Record<string, TypedStep<any, any, any, AiContext<THost>>> = {}> = TypedStep<TInput, TOutput, TDeps, AiContext<THost>>;
+export type AiTypedStep<TInput extends Record<string, unknown> = Record<string, unknown>, TOutput extends Record<string, unknown> = Record<string, unknown>, THost = unknown, TDeps extends Record<string, TypedStep<any, any, any, AiContext<THost>>> = {}> = TypedStep<TInput, TOutput, TDeps, AiContext<THost>>;
 interface DefineAiStepConfig<TInput extends Record<string, unknown>, TOutput extends Record<string, unknown>, THost, TDeps extends Record<string, TypedStep<any, any, any, AiContext<THost>>>> {
   type: string;
   workflowInputSchema: z.ZodType<TInput>;
@@ -124,16 +124,16 @@ interface DefineAiStepConfig<TInput extends Record<string, unknown>, TOutput ext
  * except the handler context is fixed to `AiContext<THost>`, so handlers get a
  * ready-to-use `ctx.context.model` (instrumented) and `ctx.context.host`.
  */
-declare function defineAiStep<TInput extends Record<string, unknown>, TOutput extends Record<string, unknown>, THost = unknown, TDeps extends Record<string, TypedStep<any, any, any, AiContext<THost>>> = {}>(config: DefineAiStepConfig<TInput, TOutput, THost, TDeps>): AiTypedStep<TInput, TOutput, THost, TDeps>;
+export declare function defineAiStep<TInput extends Record<string, unknown>, TOutput extends Record<string, unknown>, THost = unknown, TDeps extends Record<string, TypedStep<any, any, any, AiContext<THost>>> = {}>(config: DefineAiStepConfig<TInput, TOutput, THost, TDeps>): AiTypedStep<TInput, TOutput, THost, TDeps>;
 /** Build a typed AI workflow from `defineAiStep` definitions. */
-declare function buildAiWorkflow<TInput extends Record<string, unknown>, THost = unknown, TSteps extends Record<string, TypedStep<any, any, any, AiContext<THost>>> = {}>(config: {
+export declare function buildAiWorkflow<TInput extends Record<string, unknown>, THost = unknown, TSteps extends Record<string, TypedStep<any, any, any, AiContext<THost>>> = {}>(config: {
   type: string;
   inputSchema: z.ZodType<TInput>;
   steps: TSteps;
 }): TypedWorkflow<TInput, AiContext<THost>>;
 //#endregion
 //#region src/ai/hooks.d.ts
-interface AiModelResolver<THost = unknown> {
+export interface AiModelResolver<THost = unknown> {
   /** Resolve the base (uninstrumented) model for a step. */
   resolveModel(args: BuildStepContextArgs): Promise<LanguageModelV4> | LanguageModelV4;
   /** Optional host context (DI scope, services) exposed to handlers as `ctx.context.host`. */
@@ -145,7 +145,7 @@ interface AiModelResolver<THost = unknown> {
    */
   resolveKeySource?(): Promise<string> | string;
 }
-interface AiUsageRecorder {
+export interface AiUsageRecorder {
   /** Persist per-step token usage + cost (e.g. onto the step row). */
   recordStepUsage(args: {
     workflowId: number;
@@ -170,11 +170,11 @@ interface AiUsageRecorder {
     date: string;
   }): Promise<void>;
 }
-interface AiQuotaPolicy {
+export interface AiQuotaPolicy {
   /** Return an error (e.g. `ai_quota_exceeded`) to reject a workflow start. */
   checkQuota(): Promise<Result<void, FlowErrorShape>>;
 }
-interface CreateAiWorkflowHooksDeps<THost = unknown> {
+export interface CreateAiWorkflowHooksDeps<THost = unknown> {
   modelResolver: AiModelResolver<THost>;
   usageRecorder: AiUsageRecorder;
   /** Optional quota guard. BYOK exemption etc. is the policy's concern. */
@@ -189,7 +189,7 @@ interface CreateAiWorkflowHooksDeps<THost = unknown> {
  * usage rollups) into a set of flow-core lifecycle hooks. Pass the result as the
  * engine's `hooks`. flow-core stays AI-free; everything AI lives here.
  */
-declare function createAiWorkflowHooks<THost = unknown>(deps: CreateAiWorkflowHooksDeps<THost>): WorkflowHooks<AiContext<THost>>;
+export declare function createAiWorkflowHooks<THost = unknown>(deps: CreateAiWorkflowHooksDeps<THost>): WorkflowHooks<AiContext<THost>>;
 //#endregion
 //#region src/ai/quota.d.ts
 /**
@@ -198,7 +198,7 @@ declare function createAiWorkflowHooks<THost = unknown>(deps: CreateAiWorkflowHo
  * return `null` for the whole config to exempt a scope entirely (e.g. a
  * bring-your-own-key caller that shouldn't be metered against platform quota).
  */
-interface AiQuotaConfig {
+export interface AiQuotaConfig {
   /** Max simultaneously-running workflows. `null` = unlimited. */
   maxConcurrentWorkflows: number | null;
   /** Max workflows started per calendar day (UTC). `null` = unlimited. */
@@ -211,14 +211,14 @@ interface AiQuotaConfig {
  * flow does **not** apply these automatically — resolution policy lives in the
  * injected {@link AiQuotaConfigResolver}.
  */
-declare const DEFAULT_AI_QUOTA: AiQuotaConfig;
+export declare const DEFAULT_AI_QUOTA: AiQuotaConfig;
 /**
  * Resolves the quota limits for a scope. Returning `null` exempts the scope
  * from all quota enforcement (the check short-circuits to success).
  */
-type AiQuotaConfigResolver = (partitionKey: string) => AiQuotaConfig | null | Promise<AiQuotaConfig | null>;
+export type AiQuotaConfigResolver = (partitionKey: string) => AiQuotaConfig | null | Promise<AiQuotaConfig | null>;
 /** A `[startDate, endDate]` inclusive query over the daily-usage rollup (dates are `YYYY-MM-DD`). */
-interface AiUsageCountQuery {
+export interface AiUsageCountQuery {
   partitionKey: string;
   /** Inclusive lower bound, `YYYY-MM-DD`. */
   startDate: string;
@@ -232,16 +232,16 @@ interface AiUsageCountQuery {
  * (e.g. excluding synthetic embedding rows from the count) lives in the
  * consumer's SQL, keeping this layer policy-agnostic.
  */
-interface AiQuotaStore {
+export interface AiQuotaStore {
   /** Number of workflows currently `running` for the scope. */
   countRunningWorkflows(partitionKey: string): Promise<number>;
   /** Sum of `workflowCount` in the daily rollup over the inclusive date range. */
   sumWorkflowCount(query: AiUsageCountQuery): Promise<number>;
 }
 /** Reason a start was rejected — which window tripped. */
-type AiQuotaExceededReason = 'concurrent_limit' | 'daily_limit' | 'monthly_limit';
+export type AiQuotaExceededReason = 'concurrent_limit' | 'daily_limit' | 'monthly_limit';
 /** Expected error value when a start is rejected by quota. Extends flow's structural error. */
-interface AiQuotaExceededError {
+export interface AiQuotaExceededError {
   key: 'ai_quota_exceeded';
   reason: AiQuotaExceededReason;
   message: string;
@@ -250,7 +250,7 @@ interface AiQuotaExceededError {
   /** The observed count at rejection (includes in-flight runs for the day/month windows). */
   current: number;
 }
-interface CreateAiQuotaServiceDeps {
+export interface CreateAiQuotaServiceDeps {
   /** Count reads over the in-flight workflow table + daily rollup. */
   store: AiQuotaStore;
   /** Per-scope limit resolver. Return `null` to exempt the scope. */
@@ -258,7 +258,7 @@ interface CreateAiQuotaServiceDeps {
   /** Clock injection for window computation (tests). Defaults to `() => new Date()`. */
   now?: () => Date;
 }
-interface AiQuotaService {
+export interface AiQuotaService {
   /**
    * Check all quota windows for the scope. Resolves `ok` when the start is
    * allowed, or an {@link AiQuotaExceededError} naming the window that tripped.
@@ -271,11 +271,11 @@ interface AiQuotaService {
  * Build a store-agnostic AI quota service. Enforcement order is concurrent →
  * day → month; the first tripped window short-circuits with its error.
  */
-declare function createAiQuotaService(deps: CreateAiQuotaServiceDeps): AiQuotaService;
+export declare function createAiQuotaService(deps: CreateAiQuotaServiceDeps): AiQuotaService;
 //#endregion
 //#region src/ai/usage-aggregation.d.ts
 /** An additive write into the daily-usage rollup for one run (workflow completion or embedding batch). */
-interface DailyUsageDelta {
+export interface DailyUsageDelta {
   partitionKey: string;
   /** Calendar day of the run, `YYYY-MM-DD`. */
   date: string;
@@ -290,13 +290,13 @@ interface DailyUsageDelta {
   estimatedCostMicros: number;
 }
 /** Inclusive `[startDate, endDate]` range query for the aggregate reads (`YYYY-MM-DD`). */
-interface AiUsageRangeQuery {
+export interface AiUsageRangeQuery {
   partitionKey: string;
   startDate: string;
   endDate: string;
 }
 /** One row of the per-day aggregate (GROUP BY date). */
-interface UsageSummaryRow {
+export interface UsageSummaryRow {
   date: string;
   workflowCount: number;
   inputTokens: number;
@@ -306,7 +306,7 @@ interface UsageSummaryRow {
   estimatedCostMicros: number;
 }
 /** One row of the per-type aggregate (GROUP BY workflowType, keySource). */
-interface UsageByTypeRow {
+export interface UsageByTypeRow {
   workflowType: string;
   keySource: string;
   workflowCount: number;
@@ -320,7 +320,7 @@ interface UsageByTypeRow {
  * and aggregation engines. The `addDailyUsage` UPSERT and the two aggregate
  * reads are the consumer's SQL; flow owns everything above the seam.
  */
-interface AiUsageStore extends AiQuotaStore {
+export interface AiUsageStore extends AiQuotaStore {
   /** UPSERT-add a run's usage into the daily rollup (unique on partition+date+type+keySource). */
   addDailyUsage(delta: DailyUsageDelta): Promise<void>;
   /** Per-day totals over the range, ascending by date. */
@@ -329,7 +329,7 @@ interface AiUsageStore extends AiQuotaStore {
   aggregateByWorkflowType(query: AiUsageRangeQuery): Promise<UsageByTypeRow[]>;
 }
 /** A completed LLM workflow's usage to roll up. */
-interface WorkflowUsageInput {
+export interface WorkflowUsageInput {
   partitionKey: string;
   /** Calendar day of completion, `YYYY-MM-DD`. */
   date: string;
@@ -343,7 +343,7 @@ interface WorkflowUsageInput {
  * tokens (no output, no cache); `workflowCount` increments once per flushed
  * batch, not per inner embed call.
  */
-interface EmbeddingUsageInput {
+export interface EmbeddingUsageInput {
   partitionKey: string;
   /** Calendar day of the flush, `YYYY-MM-DD`. */
   date: string;
@@ -354,7 +354,7 @@ interface EmbeddingUsageInput {
   estimatedCostMicros: number;
 }
 /** Current-window usage snapshot for a scope. */
-interface CurrentQuotaUsage {
+export interface CurrentQuotaUsage {
   today: {
     workflowCount: number;
   };
@@ -366,18 +366,18 @@ interface CurrentQuotaUsage {
   };
 }
 /** Expected error value from aggregation reads/writes. Extends flow's structural error. */
-interface AiUsageError {
+export interface AiUsageError {
   key: 'ai_usage_error';
   message: string;
 }
-interface CreateAiUsageAggregationServiceDeps {
+export interface CreateAiUsageAggregationServiceDeps {
   store: AiUsageStore;
   /** Clock injection for the current-window computation (tests). Defaults to `() => new Date()`. */
   now?: () => Date;
   /** Optional logger for write failures. Defaults to a no-op. */
   logger?: Logger;
 }
-interface AiUsageAggregationService {
+export interface AiUsageAggregationService {
   /** Roll a completed LLM workflow's totals into the daily aggregate (UPSERT +1). */
   recordWorkflowCompletion(data: WorkflowUsageInput): Promise<Result<void, AiUsageError>>;
   /** Roll a flushed embedding batch into the daily aggregate (output/cache tokens = 0). */
@@ -392,6 +392,5 @@ interface AiUsageAggregationService {
   }): Promise<Result<CurrentQuotaUsage, AiUsageError>>;
 }
 /** Build a store-agnostic AI usage-aggregation service. */
-declare function createAiUsageAggregationService(deps: CreateAiUsageAggregationServiceDeps): AiUsageAggregationService;
-//#endregion
-export { AccumulatedUsage, AiContext, AiModelResolver, AiQuotaConfig, AiQuotaConfigResolver, AiQuotaExceededError, AiQuotaExceededReason, AiQuotaPolicy, AiQuotaService, AiQuotaStore, AiTypedStep, AiUsageAggregationService, AiUsageCountQuery, AiUsageError, AiUsageRangeQuery, AiUsageRecorder, AiUsageStore, CostEstimator, CostEstimatorOptions, CreateAiQuotaServiceDeps, CreateAiUsageAggregationServiceDeps, CreateAiWorkflowHooksDeps, CurrentQuotaUsage, DEFAULT_AI_QUOTA, DEFAULT_MODEL_PRICING, DailyUsageDelta, EmbeddingAccumulatedUsage, EmbeddingUsageAccumulator, EmbeddingUsageInput, ModelPricing, TokenUsage, UsageAccumulator, UsageByTypeRow, UsageSummaryRow, WorkflowUsageInput, buildAiWorkflow, createAiQuotaService, createAiUsageAggregationService, createAiWorkflowHooks, createCostEstimator, createEmbeddingUsageAccumulator, createInstrumentedEmbeddingModel, createInstrumentedModel, createUsageAccumulator, defineAiStep, estimateCostMicros };
+export declare function createAiUsageAggregationService(deps: CreateAiUsageAggregationServiceDeps): AiUsageAggregationService;
+//#endregion

package/dist/dispatcher-pgboss/index.d.ts

@@ -9,7 +9,7 @@ import { PgBoss } from "pg-boss";
  * plus the `partitionKey` — the worker needs the partition to reconstruct a
  * partition-scoped engine before handing the job to `engine.handleStepJob`.
  */
-declare const WIRE_STEP_PAYLOAD_SCHEMA: z.ZodObject<{
+export declare const WIRE_STEP_PAYLOAD_SCHEMA: z.ZodObject<{
   partitionKey: z.ZodString;
   workflowId: z.ZodNumber;
   stepId: z.ZodNumber;
@@ -20,8 +20,8 @@ declare const WIRE_STEP_PAYLOAD_SCHEMA: z.ZodObject<{
     timeout: "timeout";
   }>>;
 }, z.core.$strip>;
-type WireStepPayload = z.infer<typeof WIRE_STEP_PAYLOAD_SCHEMA>;
-interface StepQueueConfig {
+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. */
@@ -29,7 +29,7 @@ interface StepQueueConfig {
   /** Seconds before an in-flight job is considered expired. Default 600. */
   expireInSeconds?: number;
 }
-declare const DEFAULT_STEP_QUEUE_CONFIG: Required<StepQueueConfig>;
+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`
@@ -43,7 +43,7 @@ declare const DEFAULT_STEP_QUEUE_CONFIG: Required<StepQueueConfig>;
  * - `idempotencyKey` — used verbatim. On a schedule this means "start exactly one
  *   workflow, ever"; every later tick returns the first one.
  */
-declare const WIRE_START_PAYLOAD_SCHEMA: z.ZodObject<{
+export declare const WIRE_START_PAYLOAD_SCHEMA: z.ZodObject<{
   partitionKey: z.ZodString;
   workflowType: z.ZodString;
   input: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -51,7 +51,7 @@ declare const WIRE_START_PAYLOAD_SCHEMA: z.ZodObject<{
   idempotencyKey: z.ZodOptional<z.ZodString>;
   idempotencyKeyPrefix: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-type WireStartPayload = z.infer<typeof WIRE_START_PAYLOAD_SCHEMA>;
+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`.
@@ -59,12 +59,12 @@ type WireStartPayload = z.infer<typeof WIRE_START_PAYLOAD_SCHEMA>;
  * `idempotencyKey` is verbatim when the payload set one, `${idempotencyKeyPrefix}:${jobId}`
  * when it set a prefix, and `undefined` when it set neither.
  */
-interface StartJobContext extends WireStartPayload {
+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. */
-declare function resolveStartIdempotencyKey(payload: WireStartPayload, jobId: string): string | undefined;
+export declare function resolveStartIdempotencyKey(payload: WireStartPayload, jobId: string): string | undefined;
 //#endregion
 //#region src/dispatcher-pgboss/queue.d.ts
 /**
@@ -78,8 +78,8 @@ declare function resolveStartIdempotencyKey(payload: WireStartPayload, jobId: st
  * single-connection database that is a deadlock. An existing queue is left
  * alone, cache entry and all.
  */
-declare function ensureStepQueue(boss: PgBoss, queueName: string, config?: StepQueueConfig): Promise<void>;
-interface PgBossDispatcherDeps {
+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. */
@@ -87,8 +87,8 @@ interface PgBossDispatcherDeps {
   config?: StepQueueConfig;
 }
 /** A flow-core `Dispatcher` backed by pg-boss. */
-declare function createPgBossDispatcher(deps: PgBossDispatcherDeps): Dispatcher;
-interface PgBossStepWorkerOptions {
+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. */
@@ -118,7 +118,7 @@ interface PgBossStepWorkerOptions {
    */
   concurrency?: number;
 }
-interface PgBossStepWorkerDeps {
+export interface PgBossStepWorkerDeps {
   boss: PgBoss;
   queueName: string;
   config?: StepQueueConfig;
@@ -127,13 +127,13 @@ interface PgBossStepWorkerDeps {
 }
 /** Handles a single step job. Reconstruct the partition-scoped engine and call
  * `engine.executeStep(workflowId, stepId)`. Throw to trigger a pg-boss retry. */
-type StepJobProcessor = (payload: WireStepPayload) => Promise<void>;
+export type StepJobProcessor = (payload: WireStepPayload) => Promise<void>;
 /** A pg-boss worker that drives `executeStep` for step jobs. */
-declare function createPgBossStepWorker(deps: PgBossStepWorkerDeps): {
+export declare function createPgBossStepWorker(deps: PgBossStepWorkerDeps): {
   start: (process: StepJobProcessor) => Promise<void>;
   stop: () => Promise<void>;
 };
-interface PgBossDlqWorkerDeps {
+export interface PgBossDlqWorkerDeps {
   boss: PgBoss;
   queueName: string;
   logger?: Logger;
@@ -141,17 +141,17 @@ interface PgBossDlqWorkerDeps {
 }
 /** Invoked for a step job that exhausted all retries. Typically calls
  * `engine.handleStepExhausted(workflowId, stepId, reason)`. */
-type DlqProcessor = (payload: WireStepPayload) => Promise<void>;
+export type DlqProcessor = (payload: WireStepPayload) => Promise<void>;
 /** A pg-boss worker on the step queue's dead-letter queue. */
-declare function createPgBossDlqWorker(deps: PgBossDlqWorkerDeps): {
+export declare function createPgBossDlqWorker(deps: PgBossDlqWorkerDeps): {
   start: (onDlq: DlqProcessor) => Promise<void>;
   stop: () => Promise<void>;
 };
 //#endregion
 //#region src/dispatcher-pgboss/scheduler.d.ts
 /** Create the start queue (idempotent). */
-declare function ensureStartQueue(boss: PgBoss, queueName: string): Promise<void>;
-interface PgBossSchedulerDeps {
+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;
@@ -159,7 +159,7 @@ interface PgBossSchedulerDeps {
   partitionKey: string;
   logger?: Logger;
 }
-interface ScheduleStartInput {
+export interface ScheduleStartInput {
   /** Unique key for this schedule within the queue (allows many crons per queue). */
   key: string;
   /** Cron expression (5- or 6-field). */
@@ -187,7 +187,7 @@ interface ScheduleStartInput {
   tz?: string;
 }
 /** Registers cron schedules that enqueue workflow-start jobs. */
-declare function createPgBossScheduler(deps: PgBossSchedulerDeps): {
+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. */
@@ -208,8 +208,8 @@ declare function createPgBossScheduler(deps: PgBossSchedulerDeps): {
  * });
  * ```
  */
-type StartJobProcessor = (payload: StartJobContext) => Promise<void>;
-interface PgBossStartWorkerDeps {
+export type StartJobProcessor = (payload: StartJobContext) => Promise<void>;
+export interface PgBossStartWorkerDeps {
   boss: PgBoss;
   queueName: string;
   logger?: Logger;
@@ -219,9 +219,8 @@ interface PgBossStartWorkerDeps {
   };
 }
 /** A pg-boss worker on the start queue that drives a host start callback. */
-declare function createPgBossStartWorker(deps: PgBossStartWorkerDeps): {
+export declare function createPgBossStartWorker(deps: PgBossStartWorkerDeps): {
   start: (process: StartJobProcessor) => Promise<void>;
   stop: () => Promise<void>;
 };
-//#endregion
-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 };
+//#endregion

package/dist/index.d.ts

@@ -9,7 +9,7 @@ import { a as WorkflowCompletedArgs, i as BuildStepContextArgs, n as BeforeStart
  * Populate it at application startup (e.g. by registering every workflow's steps).
  * Each registration carries the handler plus its optional retry/timeout policy.
  */
-declare function createStepHandlerRegistry<TContext = unknown>(): StepHandlerRegistry<TContext>;
+export declare function createStepHandlerRegistry<TContext = unknown>(): StepHandlerRegistry<TContext>;
 //#endregion
 //#region src/core/retry.d.ts
 /**
@@ -21,11 +21,11 @@ declare function createStepHandlerRegistry<TContext = unknown>(): StepHandlerReg
  * throw markRetryable(await client.readError(), true);
  * ```
  */
-declare function markRetryable<E>(error: E, retryable?: boolean): E;
+export declare function markRetryable<E>(error: E, retryable?: boolean): E;
 /** An error the engine will always retry (within the step's attempt budget). */
-declare function retryableError(message: string, options?: ErrorOptions): Error;
+export declare function retryableError(message: string, options?: ErrorOptions): Error;
 /** An error the engine will never retry, whatever its message says. */
-declare function nonRetryableError(message: string, options?: ErrorOptions): Error;
+export declare function nonRetryableError(message: string, options?: ErrorOptions): Error;
 /**
  * The explicit decision carried by an error, or `undefined` if it carries none.
  * Callers deciding retryability themselves should consult this first.
@@ -35,7 +35,7 @@ declare function nonRetryableError(message: string, options?: ErrorOptions): Err
  * still reports `true`. The outermost decision wins; the walk is depth-capped and
  * cycle-safe.
  */
-declare function explicitRetryability(error: unknown): boolean | undefined;
+export declare function explicitRetryability(error: unknown): boolean | undefined;
 /**
  * Default classifier for a thrown error, used when nothing more specific applies.
  * Checked in order:
@@ -51,10 +51,10 @@ declare function explicitRetryability(error: unknown): boolean | undefined;
  * {@link nonRetryableError}, `defineStep`'s `isRetryable`, or the engine's
  * `defaultRetryable` when the answer matters.
  */
-declare function isRetryableError(error: unknown): boolean;
+export declare function isRetryableError(error: unknown): boolean;
 //#endregion
 //#region src/core/engine.d.ts
-interface WorkflowEngineConfig {
+export interface WorkflowEngineConfig {
   /** The dispatcher's per-step expiry, in seconds. Used by the stuck-step sweeper. Default 600. */
   stepExpirySeconds?: number;
   /** Extra grace added to the stuck threshold beyond `stepExpirySeconds`. Default 300. */
@@ -82,7 +82,7 @@ interface WorkflowEngineConfig {
    */
   defaultRetryable?: boolean;
 }
-interface WorkflowEngineDeps<TContext = unknown> {
+export interface WorkflowEngineDeps<TContext = unknown> {
   store: WorkflowStore;
   dispatcher: Dispatcher;
   registry: StepHandlerRegistry<TContext>;
@@ -104,7 +104,7 @@ interface WorkflowEngineDeps<TContext = unknown> {
   now?: () => Date;
 }
 /** What one sweep of `recoverStuckWorkflows` did. */
-interface RecoverySweepResult {
+export interface RecoverySweepResult {
   /** Stuck steps put back on the queue for another attempt. */
   retriedSteps: number;
   /** Stuck steps failed outright — attempt budget spent, or `onStuckStep: 'fail'`. */
@@ -115,12 +115,12 @@ interface RecoverySweepResult {
   expiredWorkflows: number;
 }
 /** What `retryWorkflow` put back in flight. */
-interface RetryWorkflowResult {
+export interface RetryWorkflowResult {
   workflowId: WorkflowId;
   /** Keys of the steps reset to `pending` — the work that will run again. */
   resetSteps: string[];
 }
-declare function createWorkflowEngine<TContext = unknown>(deps: WorkflowEngineDeps<TContext>): {
+export declare function createWorkflowEngine<TContext = unknown>(deps: WorkflowEngineDeps<TContext>): {
   validateDefinition: (definition: WorkflowDefinition) => Result<void, FlowError>;
   startWorkflow: (definition: WorkflowDefinition, input: Record<string, unknown>, options?: StartOptions) => Promise<Result<WorkflowCreatedResult, FlowError>>;
   start: <TInput extends Record<string, unknown>>(workflow: {
@@ -145,7 +145,7 @@ declare function createWorkflowEngine<TContext = unknown>(deps: WorkflowEngineDe
     limit?: number;
   }) => Promise<Result<WorkflowWithSteps[], FlowError>>;
 };
-type WorkflowEngine<TContext = unknown> = ReturnType<typeof createWorkflowEngine<TContext>>;
+export type WorkflowEngine<TContext = unknown> = ReturnType<typeof createWorkflowEngine<TContext>>;
 //#endregion
 //#region src/core/in-memory-store.d.ts
 /**
@@ -154,7 +154,7 @@ type WorkflowEngine<TContext = unknown> = ReturnType<typeof createWorkflowEngine
  * mirror real adapters (the partition value is recorded but isolation is trivial
  * since each instance owns its own maps).
  */
-declare function createInMemoryWorkflowStore(partitionKey?: string): WorkflowStore & {
+export declare function createInMemoryWorkflowStore(partitionKey?: string): WorkflowStore & {
   /** Test helper: read everything currently stored. */
   _dump(): {
     workflows: WorkflowRecord[];
@@ -162,4 +162,4 @@ declare function createInMemoryWorkflowStore(partitionKey?: string): WorkflowSto
   };
 };
 //#endregion
-export { AddChildStep, AfterStepArgs, BeforeStartArgs, BeforeStartResult, BuildStepContextArgs, CompleteStepParams, ConcurrencyRule, CreateWorkflowParams, CreateWorkflowStep, CreatedWorkflow, DispatchKind, DispatchStepPayload, Dispatcher, EnqueueOptions, FailStepParams, FinishWorkflowParams, FlowError, FlowErrorShape, FlowEvent, FlowEventType, FlowObserver, FlowSpan, FlowTracer, InMemoryStepGateConfig, InvalidWorkflowDefinitionError, JoinRule, ListWorkflowsFilters, LogAttributes, Logger, PUBLIC_WORKFLOW_SCHEMA, PUBLIC_WORKFLOW_STEP_SCHEMA, PlannedSkip, PublicWorkflow, PublicWorkflowStep, RateRule, ReadinessPlan, RecordedSpan, RecordingObserver, RecordingTracer, RecoverySweepResult, ReopenWorkflowParams, Result, RetryPolicy, RetryWorkflowResult, STEP_DISPLAY_STATUS, STEP_DISPLAY_STATUS_SCHEMA, StartOptions, StepCompensateHandler, StepCompensationContext, StepConditionHandler, StepDefinition, StepDeps, StepDisplayStatus, StepError, StepExecutionContext, StepGate, StepGateDecision, StepGateRequest, StepHandler, StepHandlerNotFoundError, StepHandlerRegistry, StepId, StepOutput, StepRecord, StepRegistration, StepStatus, TransactionalScope, TypedStep, TypedStepContext, TypedWorkflow, WORKFLOW_STATUS_SCHEMA, WaitTimeoutPolicy, WorkflowCompletedArgs, WorkflowCreatedResult, WorkflowDefinition, WorkflowEngine, WorkflowEngineConfig, WorkflowEngineDeps, WorkflowHooks, WorkflowId, WorkflowNotFoundError, WorkflowNotRetryableError, WorkflowOutput, WorkflowRecord, WorkflowStatus, WorkflowStore, WorkflowWithSteps, buildWorkflow, computeReadiness, createInMemoryStepGate, createInMemoryWorkflowStore, createRecordingObserver, createRecordingTracer, createStepHandlerRegistry, createWorkflowEngine, defineMapStep, defineSleepStep, defineStep, defineSubWorkflowStep, defineWaitStep, err, explicitRetryability, isRetryableError, isTerminalStepStatus, markRetryable, nonRetryableError, noopLogger, noopObserver, noopTracer, ok, retryableError, toDisplayStepStatus, toPublicStep, toPublicWorkflow };
+export { AddChildStep, AfterStepArgs, BeforeStartArgs, BeforeStartResult, BuildStepContextArgs, CompleteStepParams, ConcurrencyRule, CreateWorkflowParams, CreateWorkflowStep, CreatedWorkflow, DispatchKind, DispatchStepPayload, Dispatcher, EnqueueOptions, FailStepParams, FinishWorkflowParams, FlowError, FlowErrorShape, FlowEvent, FlowEventType, FlowObserver, FlowSpan, FlowTracer, InMemoryStepGateConfig, InvalidWorkflowDefinitionError, JoinRule, ListWorkflowsFilters, LogAttributes, Logger, PUBLIC_WORKFLOW_SCHEMA, PUBLIC_WORKFLOW_STEP_SCHEMA, PlannedSkip, PublicWorkflow, PublicWorkflowStep, RateRule, ReadinessPlan, RecordedSpan, RecordingObserver, RecordingTracer, ReopenWorkflowParams, Result, RetryPolicy, STEP_DISPLAY_STATUS, STEP_DISPLAY_STATUS_SCHEMA, StartOptions, StepCompensateHandler, StepCompensationContext, StepConditionHandler, StepDefinition, StepDeps, StepDisplayStatus, StepError, StepExecutionContext, StepGate, StepGateDecision, StepGateRequest, StepHandler, StepHandlerNotFoundError, StepHandlerRegistry, StepId, StepOutput, StepRecord, StepRegistration, StepStatus, TransactionalScope, TypedStep, TypedStepContext, TypedWorkflow, WORKFLOW_STATUS_SCHEMA, WaitTimeoutPolicy, WorkflowCompletedArgs, WorkflowCreatedResult, WorkflowDefinition, WorkflowHooks, WorkflowId, WorkflowNotFoundError, WorkflowNotRetryableError, WorkflowOutput, WorkflowRecord, WorkflowStatus, WorkflowStore, WorkflowWithSteps, buildWorkflow, computeReadiness, createInMemoryStepGate, createRecordingObserver, createRecordingTracer, defineMapStep, defineSleepStep, defineStep, defineSubWorkflowStep, defineWaitStep, err, isTerminalStepStatus, noopLogger, noopObserver, noopTracer, ok, toDisplayStepStatus, toPublicStep, toPublicWorkflow };

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

@@ -9,15 +9,15 @@ import { Pool } from "pg";
  * `partition_key` is the generic multi-tenancy column (the engine/store are bound
  * to one partition). Add Row Level Security on top if you need hard isolation.
  */
-declare function flowStoreDdl(schema?: string): string;
+export declare function flowStoreDdl(schema?: string): string;
 /** Default-schema DDL string. */
-declare const FLOW_STORE_DDL: string;
+export declare const FLOW_STORE_DDL: string;
 /** `CREATE SCHEMA IF NOT EXISTS` line for non-default schemas; empty for 'public'. */
-declare function createSchemaDdl(schema: string): string;
+export declare function createSchemaDdl(schema: string): string;
 //#endregion
 //#region src/store-pg/executor.d.ts
 /** Minimal query result shape the adapters consume (a structural subset of `pg`'s `QueryResult`). */
-interface SqlResult<R> {
+export interface SqlResult<R> {
   rows: R[];
   rowCount: number | null;
 }
@@ -31,7 +31,7 @@ interface SqlResult<R> {
  * DB transaction; the passed executor is that same-connection handle. Adapters
  * never nest transactions.
  */
-interface SqlExecutor {
+export interface SqlExecutor {
   query<R = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<SqlResult<R>>;
   transaction<T>(fn: (tx: SqlExecutor) => Promise<T>): Promise<T>;
 }
@@ -41,24 +41,24 @@ interface SqlExecutor {
  * `BEGIN`/`COMMIT` (rolling back and always releasing on error). This is the
  * batteries-included executor used by the `createPg*` adapters.
  */
-declare function poolExecutor(pool: Pool): SqlExecutor;
+export declare function poolExecutor(pool: Pool): SqlExecutor;
 /**
  * Normalize a `Pool | SqlExecutor` argument to a {@link SqlExecutor}. Lets the
  * read helpers accept either the batteries-included pool or a host's RLS-scoped
  * executor without a breaking signature change. `SqlExecutor` is discriminated by
  * its `transaction` method (a `pg` `Pool` has none).
  */
-declare function toExecutor(db: Pool | SqlExecutor): SqlExecutor;
+export declare function toExecutor(db: Pool | SqlExecutor): SqlExecutor;
 //#endregion
 //#region src/store-pg/store.d.ts
-interface PgWorkflowStoreDeps {
+export interface PgWorkflowStoreDeps {
   pool: Pool;
   /** Partition this store instance is bound to (e.g. a tenant id). */
   partitionKey: string;
   /** Schema the flow tables live in. Default 'public'. */
   schema?: string;
 }
-interface WorkflowStoreDeps {
+export interface WorkflowStoreDeps {
   /** How the store talks to Postgres (pool-backed, RLS-scoped, …). */
   exec: SqlExecutor;
   /** Partition this store instance is bound to (e.g. a tenant id). */
@@ -76,7 +76,7 @@ interface WorkflowStoreDeps {
  * plain pool; a host that wants Row Level Security injects an executor whose
  * `transaction` sets the tenant GUC, so the store's own transactions run scoped.
  */
-declare function createWorkflowStore(deps: WorkflowStoreDeps): WorkflowStore;
+export declare function createWorkflowStore(deps: WorkflowStoreDeps): WorkflowStore;
 /**
  * A `WorkflowStore` backed by a `pg` {@link Pool} — the batteries-included
  * adapter that owns its own connections/transactions (via {@link poolExecutor})
@@ -84,20 +84,20 @@ declare function createWorkflowStore(deps: WorkflowStoreDeps): WorkflowStore;
  * that need Row Level Security or their own migrations should instead build an
  * executor and call {@link createWorkflowStore}.
  */
-declare function createPgWorkflowStore(deps: PgWorkflowStoreDeps): WorkflowStore;
+export declare function createPgWorkflowStore(deps: PgWorkflowStoreDeps): WorkflowStore;
 /** Convenience: apply the flow-store schema to a database. */
-declare function applySchema(pool: Pool, ddl: string): Promise<void>;
+export declare function applySchema(pool: Pool, ddl: string): Promise<void>;
 //#endregion
 //#region src/store-pg/gate.d.ts
 /** DDL for the gate's two tables. Apply once at deploy time (or via `applySchema`). */
-declare function flowGateDdl(opts?: {
+export declare function flowGateDdl(opts?: {
   schema?: string;
   rateBucketTable?: string;
   leaseTable?: string;
 }): string;
 /** Default-schema gate DDL string. */
-declare const FLOW_GATE_DDL: string;
-interface PgStepGateConfig {
+export declare const FLOW_GATE_DDL: string;
+export interface PgStepGateConfig {
   pool: Pool;
   /** Partition this gate is bound to (matches the engine/store partition). */
   partitionKey: string;
@@ -117,7 +117,7 @@ interface PgStepGateConfig {
     lease?: string;
   };
 }
-interface StepGateConfig extends Omit<PgStepGateConfig, 'pool'> {
+export interface StepGateConfig extends Omit<PgStepGateConfig, 'pool'> {
   /** How the gate talks to Postgres (pool-backed, RLS-scoped, …). */
   exec: SqlExecutor;
 }
@@ -128,30 +128,30 @@ interface StepGateConfig extends Omit<PgStepGateConfig, 'pool'> {
  * Global concurrency caps + rate limits shared across all workers; drop-in for
  * the in-memory gate via `WorkflowEngineDeps.gate`.
  */
-declare function createStepGate(config: StepGateConfig): StepGate;
+export declare function createStepGate(config: StepGateConfig): StepGate;
 /**
  * A Postgres-backed {@link StepGate} over a `pg` {@link Pool} — the
  * batteries-included adapter (via {@link poolExecutor}). Hosts that need Row
  * Level Security should build an executor and call {@link createStepGate}.
  */
-declare function createPgStepGate(config: PgStepGateConfig): StepGate;
+export declare function createPgStepGate(config: PgStepGateConfig): StepGate;
 //#endregion
 //#region src/store-pg/event-sink.d.ts
 /**
  * DDL for the append-only run-history table. Apply once at deploy time (alongside
  * `flowStoreDdl`), or call `applySchema(pool, flowEventDdl())`.
  */
-declare function flowEventDdl(schema?: string): string;
+export declare function flowEventDdl(schema?: string): string;
 /** Default-schema event-table DDL string. */
-declare const FLOW_EVENT_DDL: string;
-interface PgEventSinkDeps {
+export declare const FLOW_EVENT_DDL: string;
+export interface PgEventSinkDeps {
   pool: Pool;
   /** Partition this sink is bound to (e.g. a tenant id). */
   partitionKey: string;
   /** Schema the flow tables live in. Default 'public'. */
   schema?: string;
 }
-interface EventSinkDeps {
+export interface EventSinkDeps {
   /** How the sink talks to Postgres (pool-backed, RLS-scoped, …). */
   exec: SqlExecutor;
   /** Partition this sink is bound to (e.g. a tenant id). */
@@ -164,7 +164,7 @@ interface EventSinkDeps {
  * fire-and-forget (it never throws and never blocks the engine); call `flush()` to await the
  * in-flight inserts — useful in tests and before shutdown.
  */
-interface PgEventSink extends FlowObserver {
+export interface PgEventSink extends FlowObserver {
   flush(): Promise<void>;
 }
 /**
@@ -174,22 +174,21 @@ interface PgEventSink extends FlowObserver {
  * `record` is fire-and-forget (never throws, never blocks the engine); `flush()`
  * awaits the in-flight inserts.
  */
-declare function createEventSink(deps: EventSinkDeps): PgEventSink;
+export declare function createEventSink(deps: EventSinkDeps): PgEventSink;
 /**
  * A `FlowObserver` backed by a `pg` {@link Pool} — the batteries-included sink
  * (via {@link poolExecutor}). Hosts that need Row Level Security should build an
  * executor and call {@link createEventSink} instead.
  */
-declare function createPgEventSink(deps: PgEventSinkDeps): PgEventSink;
+export declare function createPgEventSink(deps: PgEventSinkDeps): PgEventSink;
 /**
  * Read a workflow's run history, ordered oldest-first. Accepts either a
  * `pg` {@link Pool} (batteries-included) or a host's {@link SqlExecutor} (e.g.
  * RLS-scoped) — both route through the same seam.
  */
-declare function readFlowEvents(db: Pool | SqlExecutor, params: {
+export declare function readFlowEvents(db: Pool | SqlExecutor, params: {
   workflowId: WorkflowId;
   partitionKey: string;
   schema?: string;
 }): Promise<FlowEvent[]>;
-//#endregion
-export { EventSinkDeps, FLOW_EVENT_DDL, FLOW_GATE_DDL, FLOW_STORE_DDL, PgEventSink, PgEventSinkDeps, PgStepGateConfig, PgWorkflowStoreDeps, SqlExecutor, SqlResult, StepGateConfig, WorkflowStoreDeps, applySchema, createEventSink, createPgEventSink, createPgStepGate, createPgWorkflowStore, createSchemaDdl, createStepGate, createWorkflowStore, flowEventDdl, flowGateDdl, flowStoreDdl, poolExecutor, readFlowEvents, toExecutor };
+//#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "octaflow",
-  "version": "0.17.2",
+  "version": "0.17.3",
   "description": "Durable DAG workflow engine: Zod-typed steps over Postgres + pg-boss, with an optional AI add-on (token/cost/quota). Layered single package.",
   "license": "MIT",
   "type": "module",
@@ -29,9 +29,6 @@
   "engines": {
     "node": ">=22"
   },
-  "simple-git-hooks": {
-    "commit-msg": "pnpm commitlint --edit $1"
-  },
   "files": [
     "dist",
     "README.md",
@@ -42,11 +39,12 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/octabits-io/octaflow.git"
+    "url": "https://github.com/octabits-io/octabits.git",
+    "directory": "packages/octaflow"
   },
   "homepage": "https://octaflow.octabits.io/",
   "bugs": {
-    "url": "https://github.com/octabits-io/octaflow/issues"
+    "url": "https://github.com/octabits-io/octabits/issues"
   },
   "keywords": [
     "workflow",
@@ -82,22 +80,17 @@
     }
   },
   "devDependencies": {
-    "@ai-sdk/provider": "^4.0.9",
-    "@changesets/changelog-github": "^1.0.0",
-    "@changesets/cli": "^3.0.1",
-    "@commitlint/cli": "^21.2.2",
-    "@commitlint/config-conventional": "^21.2.2",
+    "@ai-sdk/provider": "^4.0.10",
     "@testcontainers/postgresql": "^12.1.0",
-    "@types/node": "^26.4.0",
+    "@types/node": "^26.4.1",
     "@types/pg": "^8.23.1",
-    "ai": "^7.0.87",
+    "ai": "^7.0.93",
     "pg": "^8.23.0",
-    "pg-boss": "^12.29.0",
-    "simple-git-hooks": "^2.14.0",
+    "pg-boss": "^12.30.0",
     "testcontainers": "^12.1.0",
-    "tsdown": "^0.22.14",
+    "tsdown": "^0.23.0",
     "typescript": "^7.0.2",
-    "vitest": "^4.1.11",
+    "vitest": "^5.0.0",
     "zod": "^4.5.4"
   },
   "scripts": {
@@ -107,10 +100,6 @@
     "test:unit": "vitest run --project unit",
     "test:integration": "vitest run --project integration",
     "lint": "node scripts/check-boundaries.mjs",
-    "typecheck": "tsc --noEmit",
-    "changeset": "changeset",
-    "changeset:version": "GITHUB_TOKEN=$(passage show github/token) changeset version",
-    "changeset:publish": "pnpm build && echo \"//registry.npmjs.org/:_authToken=$(passage show npm/token/octabits)\" > .npmrc && { changeset publish; s=$?; rm -f .npmrc; exit $s; }",
-    "release": "bash scripts/release.sh"
+    "typecheck": "tsc --noEmit"
   }
 }