@pgflow/edge-worker 0.0.8 → 0.0.10-prealpha.1

package/dist/core/WorkerState.js

@@ -0,0 +1,70 @@
+export var States;
+(function (States) {
+    /** The worker has been created but has not yet started. */
+    States["Created"] = "created";
+    /** The worker is starting but has not yet started processing messages. */
+    States["Starting"] = "starting";
+    /** The worker is processing messages. */
+    States["Running"] = "running";
+    /** The worker stopped processing messages but is still releasing resources. */
+    States["Stopping"] = "stopping";
+    /** The worker has stopped processing messages and released resources
+     * and can be discarded. */
+    States["Stopped"] = "stopped";
+})(States || (States = {}));
+export const Transitions = {
+    [States.Created]: [States.Starting],
+    [States.Starting]: [States.Running],
+    [States.Running]: [States.Stopping],
+    [States.Stopping]: [States.Stopped],
+    [States.Stopped]: [], // Terminal state - no valid transitions from here
+};
+export class TransitionError extends Error {
+    constructor(options) {
+        super(`Cannot transition from ${options.from} to ${options.to}`);
+    }
+}
+/**
+ * Represents the state of a worker and exposes method for doing allowed transitions
+ */
+export class WorkerState {
+    logger;
+    state = States.Created;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    get current() {
+        return this.state;
+    }
+    get isCreated() {
+        return this.state === States.Created;
+    }
+    get isStarting() {
+        return this.state === States.Starting;
+    }
+    get isRunning() {
+        return this.state === States.Running;
+    }
+    get isStopping() {
+        return this.state === States.Stopping;
+    }
+    get isStopped() {
+        return this.state === States.Stopped;
+    }
+    transitionTo(state) {
+        this.logger.debug(`[WorkerState] Starting transition to '${state}' (current state: ${this.state})`);
+        if (this.state === state) {
+            return;
+        }
+        if (Transitions[this.state].includes(state)) {
+            this.state = state;
+            this.logger.debug(`[WorkerState] Transitioned to '${state}'`);
+        }
+        else {
+            throw new TransitionError({
+                from: this.state,
+                to: state,
+            });
+        }
+    }
+}

package/dist/core/types.d.ts

@@ -0,0 +1,39 @@
+export type { Json } from '@pgflow/core';
+export interface IPoller<IMessage> {
+    poll(): Promise<IMessage[]>;
+}
+export interface IExecutor {
+    get msgId(): number;
+    execute(): Promise<unknown>;
+}
+export interface IMessage {
+    msg_id: number;
+}
+export interface ILifecycle {
+    acknowledgeStart(workerBootstrap: WorkerBootstrap): Promise<void>;
+    acknowledgeStop(): void;
+    sendHeartbeat(): Promise<void>;
+    get edgeFunctionName(): string | undefined;
+    get queueName(): string;
+    get isRunning(): boolean;
+    get isStopping(): boolean;
+    get isStopped(): boolean;
+    transitionToStopping(): void;
+}
+export interface IBatchProcessor {
+    processBatch(): Promise<void>;
+    awaitCompletion(): Promise<void>;
+}
+export type WorkerRow = {
+    last_heartbeat_at: string;
+    queue_name: string;
+    started_at: string;
+    stopped_at: string | null;
+    worker_id: string;
+    function_name: string;
+};
+export interface WorkerBootstrap {
+    edgeFunctionName: string;
+    workerId: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,MAAM,WAAW,OAAO,CAAC,QAAQ;IAC/B,IAAI,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;CAC7B;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,KAAK,IAAI,MAAM,CAAC;IACpB,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;CAC7B;AAED,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,UAAU;IACzB,gBAAgB,CAAC,eAAe,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClE,eAAe,IAAI,IAAI,CAAC;IACxB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAE/B,IAAI,gBAAgB,IAAI,MAAM,GAAG,SAAS,CAAC;IAC3C,IAAI,SAAS,IAAI,MAAM,CAAC;IACxB,IAAI,SAAS,IAAI,OAAO,CAAC;IACzB,IAAI,UAAU,IAAI,OAAO,CAAC;IAC1B,IAAI,SAAS,IAAI,OAAO,CAAC;IAEzB,oBAAoB,IAAI,IAAI,CAAC;CAC9B;AAED,MAAM,WAAW,eAAe;IAC9B,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9B,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAClC;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,WAAW,eAAe;IAC9B,gBAAgB,EAAE,MAAM,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;CAClB"}

package/dist/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/flow/FlowWorkerLifecycle.d.ts

@@ -0,0 +1,26 @@
+import type { Queries } from '../core/Queries.js';
+import type { ILifecycle, WorkerBootstrap } from '../core/types.js';
+import type { Logger } from '../platform/types.js';
+import type { AnyFlow } from '@pgflow/dsl';
+/**
+ * A specialized WorkerLifecycle for Flow-based workers that is aware of the Flow's step types
+ */
+export declare class FlowWorkerLifecycle<TFlow extends AnyFlow> implements ILifecycle {
+    private workerState;
+    private heartbeat?;
+    private logger;
+    private queries;
+    private workerRow?;
+    private flow;
+    constructor(queries: Queries, flow: TFlow, logger: Logger);
+    acknowledgeStart(workerBootstrap: WorkerBootstrap): Promise<void>;
+    acknowledgeStop(): void;
+    get edgeFunctionName(): string | undefined;
+    get queueName(): string;
+    sendHeartbeat(): Promise<void>;
+    get isRunning(): boolean;
+    get isStopping(): boolean;
+    get isStopped(): boolean;
+    transitionToStopping(): void;
+}
+//# sourceMappingURL=FlowWorkerLifecycle.d.ts.map

package/dist/flow/FlowWorkerLifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowWorkerLifecycle.d.ts","sourceRoot":"","sources":["../../src/flow/FlowWorkerLifecycle.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAa,MAAM,kBAAkB,CAAC;AAC/E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C;;GAEG;AACH,qBAAa,mBAAmB,CAAC,KAAK,SAAS,OAAO,CAAE,YAAW,UAAU;IAC3E,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,SAAS,CAAC,CAAY;IAC9B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,SAAS,CAAC,CAAY;IAC9B,OAAO,CAAC,IAAI,CAAQ;gBAER,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM;IAOnD,gBAAgB,CAAC,eAAe,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAkBvE,eAAe;IAiBf,IAAI,gBAAgB,uBAEnB;IAED,IAAI,SAAS,WAEZ;IAEK,aAAa;IAInB,IAAI,SAAS,YAEZ;IAED,IAAI,UAAU,YAEb;IAED,IAAI,SAAS,YAEZ;IAED,oBAAoB;CAGrB"}

package/dist/flow/FlowWorkerLifecycle.js

@@ -0,0 +1,64 @@
+import { Heartbeat } from '../core/Heartbeat.js';
+import { States, WorkerState } from '../core/WorkerState.js';
+/**
+ * A specialized WorkerLifecycle for Flow-based workers that is aware of the Flow's step types
+ */
+export class FlowWorkerLifecycle {
+    workerState;
+    heartbeat;
+    logger;
+    queries;
+    workerRow;
+    flow;
+    constructor(queries, flow, logger) {
+        this.queries = queries;
+        this.flow = flow;
+        this.logger = logger;
+        this.workerState = new WorkerState(logger);
+    }
+    async acknowledgeStart(workerBootstrap) {
+        this.workerState.transitionTo(States.Starting);
+        this.workerRow = await this.queries.onWorkerStarted({
+            queueName: this.queueName,
+            ...workerBootstrap,
+        });
+        this.heartbeat = new Heartbeat(5000, this.queries, this.workerRow, this.logger);
+        this.workerState.transitionTo(States.Running);
+    }
+    acknowledgeStop() {
+        this.workerState.transitionTo(States.Stopping);
+        if (!this.workerRow) {
+            throw new Error('Cannot stop worker: workerRow not set');
+        }
+        try {
+            this.logger.debug('Acknowledging worker stop...');
+            this.workerState.transitionTo(States.Stopped);
+            this.logger.debug('Worker stop acknowledged');
+        }
+        catch (error) {
+            this.logger.debug(`Error acknowledging worker stop: ${error}`);
+            throw error;
+        }
+    }
+    get edgeFunctionName() {
+        return this.workerRow?.function_name;
+    }
+    get queueName() {
+        return this.flow.slug;
+    }
+    async sendHeartbeat() {
+        await this.heartbeat?.send();
+    }
+    get isRunning() {
+        return this.workerState.isRunning;
+    }
+    get isStopping() {
+        return this.workerState.isStopping;
+    }
+    get isStopped() {
+        return this.workerState.isStopped;
+    }
+    transitionToStopping() {
+        this.workerState.transitionTo(States.Stopping);
+    }
+}

package/dist/flow/StepTaskExecutor.d.ts

@@ -0,0 +1,28 @@
+import type { AnyFlow } from '@pgflow/dsl';
+import type { StepTaskRecord, IPgflowClient } from './types.js';
+import type { IExecutor } from '../core/types.js';
+import type { Logger } from '../platform/types.js';
+/**
+ * An executor that processes step tasks using an IPgflowClient
+ * with strong typing for the flow's step handlers
+ */
+export declare class StepTaskExecutor<TFlow extends AnyFlow> implements IExecutor {
+    private readonly flow;
+    private readonly task;
+    private readonly adapter;
+    private readonly signal;
+    private logger;
+    constructor(flow: TFlow, task: StepTaskRecord<TFlow>, adapter: IPgflowClient<TFlow>, signal: AbortSignal, logger: Logger);
+    get msgId(): number;
+    execute(): Promise<void>;
+    /**
+     * Handles the error that occurred during execution.
+     *
+     * If the error is an AbortError, it means that the worker was aborted and stopping,
+     * the task will be picked up by another worker later.
+     *
+     * Otherwise, it marks the task as failed.
+     */
+    private handleExecutionError;
+}
+//# sourceMappingURL=StepTaskExecutor.d.ts.map

package/dist/flow/StepTaskExecutor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StepTaskExecutor.d.ts","sourceRoot":"","sources":["../../src/flow/StepTaskExecutor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AASnD;;;GAGG;AACH,qBAAa,gBAAgB,CAAC,KAAK,SAAS,OAAO,CAAE,YAAW,SAAS;IAIrE,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM;IANzB,OAAO,CAAC,MAAM,CAAS;gBAGJ,IAAI,EAAE,KAAK,EACX,IAAI,EAAE,cAAc,CAAC,KAAK,CAAC,EAC3B,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,EAC7B,MAAM,EAAE,WAAW,EACpC,MAAM,EAAE,MAAM;IAKhB,IAAI,KAAK,WAER;IAEK,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAoC9B;;;;;;;OAOG;YACW,oBAAoB;CAYnC"}

package/dist/flow/StepTaskExecutor.js

@@ -0,0 +1,71 @@
+class AbortError extends Error {
+    constructor() {
+        super('Operation aborted');
+        this.name = 'AbortError';
+    }
+}
+/**
+ * An executor that processes step tasks using an IPgflowClient
+ * with strong typing for the flow's step handlers
+ */
+export class StepTaskExecutor {
+    flow;
+    task;
+    adapter;
+    signal;
+    logger;
+    constructor(flow, task, adapter, signal, logger) {
+        this.flow = flow;
+        this.task = task;
+        this.adapter = adapter;
+        this.signal = signal;
+        this.logger = logger;
+    }
+    get msgId() {
+        return this.task.msg_id;
+    }
+    async execute() {
+        try {
+            if (this.signal.aborted) {
+                throw new AbortError();
+            }
+            // Check if already aborted before starting
+            this.signal.throwIfAborted();
+            const stepSlug = this.task.step_slug;
+            this.logger.debug(`Executing step task ${this.task.msg_id} for step ${stepSlug}`);
+            // Get the step handler from the flow with proper typing
+            const stepDef = this.flow.getStepDefinition(stepSlug);
+            if (!stepDef) {
+                throw new Error(`No step definition found for slug=${stepSlug}`);
+            }
+            // !!! HANDLER EXECUTION !!!
+            const result = await stepDef.handler(this.task.input);
+            // !!! HANDLER EXECUTION !!!
+            this.logger.debug(`step task ${this.task.msg_id} completed successfully, marking as complete`);
+            await this.adapter.completeTask(this.task, result);
+            this.logger.debug(`step task ${this.task.msg_id} marked as complete`);
+        }
+        catch (error) {
+            await this.handleExecutionError(error);
+        }
+    }
+    /**
+     * Handles the error that occurred during execution.
+     *
+     * If the error is an AbortError, it means that the worker was aborted and stopping,
+     * the task will be picked up by another worker later.
+     *
+     * Otherwise, it marks the task as failed.
+     */
+    async handleExecutionError(error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+            this.logger.debug(`Aborted execution for step task ${this.task.msg_id}`);
+            // Do not mark as failed - the worker was aborted and stopping,
+            // the task will be picked up by another worker later
+        }
+        else {
+            this.logger.error(`step task ${this.task.msg_id} failed with error: ${error}`);
+            await this.adapter.failTask(this.task, error);
+        }
+    }
+}

package/dist/flow/StepTaskPoller.d.ts

@@ -0,0 +1,21 @@
+import type { StepTaskRecord, IPgflowClient } from './types.js';
+import type { IPoller } from '../core/types.js';
+import type { Logger } from '../platform/types.js';
+import type { AnyFlow } from '@pgflow/dsl';
+export interface StepTaskPollerConfig {
+    batchSize: number;
+    queueName: string;
+}
+/**
+ * A poller that retrieves flow tasks using an IPgflowClient
+ */
+export declare class StepTaskPoller<TFlow extends AnyFlow> implements IPoller<StepTaskRecord<TFlow>> {
+    private readonly adapter;
+    private readonly signal;
+    private readonly config;
+    private logger;
+    constructor(adapter: IPgflowClient<TFlow>, signal: AbortSignal, config: StepTaskPollerConfig, logger: Logger);
+    poll(): Promise<StepTaskRecord<TFlow>[]>;
+    private isAborted;
+}
+//# sourceMappingURL=StepTaskPoller.d.ts.map

package/dist/flow/StepTaskPoller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StepTaskPoller.d.ts","sourceRoot":"","sources":["../../src/flow/StepTaskPoller.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,qBAAa,cAAc,CAAC,KAAK,SAAS,OAAO,CAC/C,YAAW,OAAO,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;IAKvC,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IALzB,OAAO,CAAC,MAAM,CAAS;gBAGJ,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,EAC7B,MAAM,EAAE,WAAW,EACnB,MAAM,EAAE,oBAAoB,EAC7C,MAAM,EAAE,MAAM;IAKV,IAAI,IAAI,OAAO,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,CAAC;IAuB9C,OAAO,CAAC,SAAS;CAGlB"}

package/dist/flow/StepTaskPoller.js

@@ -0,0 +1,34 @@
+/**
+ * A poller that retrieves flow tasks using an IPgflowClient
+ */
+export class StepTaskPoller {
+    adapter;
+    signal;
+    config;
+    logger;
+    constructor(adapter, signal, config, logger) {
+        this.adapter = adapter;
+        this.signal = signal;
+        this.config = config;
+        this.logger = logger;
+    }
+    async poll() {
+        if (this.isAborted()) {
+            this.logger.debug('Polling aborted, returning empty array');
+            return [];
+        }
+        this.logger.debug(`Polling for flow tasks with batch size ${this.config.batchSize}`);
+        try {
+            const tasks = await this.adapter.pollForTasks(this.config.queueName, this.config.batchSize);
+            this.logger.debug(`Retrieved ${tasks.length} flow tasks`);
+            return tasks;
+        }
+        catch (err) {
+            this.logger.error(`Error polling for flow tasks: ${err}`);
+            return [];
+        }
+    }
+    isAborted() {
+        return this.signal.aborted;
+    }
+}

package/dist/flow/createFlowWorker.d.ts

@@ -0,0 +1,24 @@
+import type { AnyFlow } from '@pgflow/dsl';
+import type { EdgeWorkerConfig } from '../EdgeWorker.js';
+import type { Logger } from '../platform/types.js';
+import { Worker } from '../core/Worker.js';
+import postgres from 'postgres';
+/**
+ * Configuration for the flow worker
+ */
+export type FlowWorkerConfig = EdgeWorkerConfig & {
+    maxConcurrent?: number;
+    connectionString?: string;
+    sql?: postgres.Sql;
+    maxPgConnections?: number;
+    batchSize?: number;
+};
+/**
+ * Creates a new Worker instance for processing flow tasks.
+ *
+ * @param flow - The Flow DSL definition
+ * @param config - Configuration options for the worker
+ * @returns A configured Worker instance ready to be started
+ */
+export declare function createFlowWorker<TFlow extends AnyFlow>(flow: TFlow, config: FlowWorkerConfig, createLogger: (module: string) => Logger): Worker;
+//# sourceMappingURL=createFlowWorker.d.ts.map

package/dist/flow/createFlowWorker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createFlowWorker.d.ts","sourceRoot":"","sources":["../../src/flow/createFlowWorker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAQzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,OAAO,QAAQ,MAAM,UAAU,CAAC;AAIhC;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,gBAAgB,GAAG;IAChD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,GAAG,CAAC,EAAE,QAAQ,CAAC,GAAG,CAAC;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,SAAS,OAAO,EACpD,IAAI,EAAE,KAAK,EACX,MAAM,EAAE,gBAAgB,EACxB,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,GACvC,MAAM,CAsFR"}

package/dist/flow/createFlowWorker.js

@@ -0,0 +1,56 @@
+import { ExecutionController } from '../core/ExecutionController.js';
+import { StepTaskPoller } from './StepTaskPoller.js';
+import { StepTaskExecutor } from './StepTaskExecutor.js';
+import { PgflowSqlClient } from '@pgflow/core';
+import { Queries } from '../core/Queries.js';
+import { Worker } from '../core/Worker.js';
+import postgres from 'postgres';
+import { FlowWorkerLifecycle } from './FlowWorkerLifecycle.js';
+import { BatchProcessor } from '../core/BatchProcessor.js';
+/**
+ * Creates a new Worker instance for processing flow tasks.
+ *
+ * @param flow - The Flow DSL definition
+ * @param config - Configuration options for the worker
+ * @returns A configured Worker instance ready to be started
+ */
+export function createFlowWorker(flow, config, createLogger) {
+    const logger = createLogger('createFlowWorker');
+    // Create abort controller for graceful shutdown
+    const abortController = new AbortController();
+    const abortSignal = abortController.signal;
+    if (!config.sql && !config.connectionString) {
+        throw new Error("Either 'sql' or 'connectionString' must be provided in FlowWorkerConfig.");
+    }
+    const sql = config.sql ||
+        postgres(config.connectionString, {
+            max: config.maxPgConnections,
+            prepare: false,
+        });
+    // Create the pgflow adapter
+    const pgflowAdapter = new PgflowSqlClient(sql);
+    // Use flow slug as queue name, or fallback to 'tasks'
+    const queueName = flow.slug || 'tasks';
+    logger.debug(`Using queue name: ${queueName}`);
+    // Create specialized FlowWorkerLifecycle with the proxied queue and flow
+    const queries = new Queries(sql);
+    const lifecycle = new FlowWorkerLifecycle(queries, flow, createLogger('FlowWorkerLifecycle'));
+    // Create StepTaskPoller
+    const pollerConfig = {
+        batchSize: config.batchSize || 10,
+        queueName: flow.slug,
+    };
+    const poller = new StepTaskPoller(pgflowAdapter, abortSignal, pollerConfig, createLogger('StepTaskPoller'));
+    // Create executor factory with proper typing
+    const executorFactory = (record, signal) => {
+        return new StepTaskExecutor(flow, record, pgflowAdapter, signal, createLogger('StepTaskExecutor'));
+    };
+    // Create ExecutionController
+    const executionController = new ExecutionController(executorFactory, abortSignal, {
+        maxConcurrent: config.maxConcurrent || 10,
+    }, createLogger('ExecutionController'));
+    // Create BatchProcessor
+    const batchProcessor = new BatchProcessor(executionController, poller, abortSignal, createLogger('BatchProcessor'));
+    // Return Worker
+    return new Worker(batchProcessor, lifecycle, sql, createLogger('Worker'));
+}

package/dist/flow/types.d.ts

@@ -0,0 +1,2 @@
+export * from '@pgflow/core';
+//# sourceMappingURL=types.d.ts.map

package/dist/flow/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/flow/types.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC"}

package/dist/flow/types.js

@@ -0,0 +1 @@
+export * from '@pgflow/core';

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { createQueueWorker } from './queue/createQueueWorker.js';
+export { EdgeWorker } from './EdgeWorker.js';
+export { createFlowWorker } from './flow/createFlowWorker.js';
+export { FlowWorkerLifecycle } from './flow/FlowWorkerLifecycle.js';
+export * from './platform/index.js';
+export type { StepTaskRecord } from './flow/types.js';
+export type { FlowWorkerConfig } from './flow/createFlowWorker.js';
+export type { StepTaskPollerConfig } from './flow/StepTaskPoller.js';
+export type { Json, IExecutor, IPoller, IMessage, ILifecycle, IBatchProcessor, } from './core/types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAG7C,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAGpE,cAAc,qBAAqB,CAAC;AAGpC,YAAY,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,YAAY,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACnE,YAAY,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAGrE,YAAY,EACV,IAAI,EACJ,SAAS,EACT,OAAO,EACP,QAAQ,EACR,UAAU,EACV,eAAe,GAChB,MAAM,iBAAiB,CAAC"}