@db3.ai/app 0.1.0-beta.1

package/dist/flows/blocks/FlowInput.d.ts

@@ -0,0 +1,10 @@
+import type { FlowValues } from '../contracts/index.js';
+/** Stable framework type for the visible public-input boundary node. */
+export declare const FLOW_INPUT_BLOCK_TYPE = "flow.input";
+/**
+ * Framework-owned input boundary whose effective ports come from its flow.
+ *
+ * The fallback `value` port keeps an unspecialized designer node connectable.
+ * The compiler replaces it with the source definition's complete input contract.
+ */
+export declare const FlowInput: import("../index.js").FlowBlockDefinition<FlowValues, FlowValues, FlowValues>;

package/dist/flows/blocks/FlowInput.js

@@ -0,0 +1,29 @@
+import { defineBlock } from '../defineBlock.js';
+/** Stable framework type for the visible public-input boundary node. */
+export const FLOW_INPUT_BLOCK_TYPE = 'flow.input';
+/**
+ * Framework-owned input boundary whose effective ports come from its flow.
+ *
+ * The fallback `value` port keeps an unspecialized designer node connectable.
+ * The compiler replaces it with the source definition's complete input contract.
+ */
+export const FlowInput = defineBlock({
+    type: FLOW_INPUT_BLOCK_TYPE,
+    name: 'Flow Input',
+    description: 'Exposes the public flow inputs to blocks inside this definition.',
+    inputs: {
+        value: { type: 'json', required: true },
+    },
+    outputs: {
+        value: { type: 'json', required: true },
+    },
+    /**
+     * Passes validated public flow input through its visible output handles.
+     *
+     * @param input - Public flow input validated against the resolved contract.
+     * @returns Unchanged input values.
+     */
+    run(input) {
+        return input;
+    },
+});

package/dist/flows/blocks/FlowOutput.d.ts

@@ -0,0 +1,10 @@
+import type { FlowValues } from '../contracts/index.js';
+/** Stable framework type for the visible public-output boundary node. */
+export declare const FLOW_OUTPUT_BLOCK_TYPE = "flow.output";
+/**
+ * Framework-owned output boundary whose effective ports come from its flow.
+ *
+ * Reaching this node terminates the current sequential run and exposes its
+ * values through the public contract of the containing flow.
+ */
+export declare const FlowOutput: import("../index.js").FlowBlockDefinition<FlowValues, FlowValues, FlowValues>;

package/dist/flows/blocks/FlowOutput.js

@@ -0,0 +1,29 @@
+import { defineBlock } from '../defineBlock.js';
+/** Stable framework type for the visible public-output boundary node. */
+export const FLOW_OUTPUT_BLOCK_TYPE = 'flow.output';
+/**
+ * Framework-owned output boundary whose effective ports come from its flow.
+ *
+ * Reaching this node terminates the current sequential run and exposes its
+ * values through the public contract of the containing flow.
+ */
+export const FlowOutput = defineBlock({
+    type: FLOW_OUTPUT_BLOCK_TYPE,
+    name: 'Flow Output',
+    description: 'Terminates the graph and exposes named values to parent flows and callers.',
+    inputs: {
+        value: { type: 'json', required: true },
+    },
+    outputs: {
+        value: { type: 'json', required: true },
+    },
+    /**
+     * Passes terminal values through to the public flow result.
+     *
+     * @param input - Values delivered to the output boundary.
+     * @returns Unchanged public output values.
+     */
+    run(input) {
+        return input;
+    },
+});

package/dist/flows/blocks/Subflow.d.ts

@@ -0,0 +1,10 @@
+import type { FlowValues } from '../contracts/index.js';
+/** Stable framework type for a definition-backed nested flow block. */
+export declare const SUBFLOW_BLOCK_TYPE = "flow.subflow";
+/**
+ * Generic nested-flow placeholder resolved from its referenced definition.
+ *
+ * The fallback port allows a newly dropped placeholder to be connected before
+ * its child definition is created. Once linked, the child contract replaces it.
+ */
+export declare const Subflow: import("../index.js").FlowBlockDefinition<FlowValues, FlowValues, FlowValues>;

package/dist/flows/blocks/Subflow.js

@@ -0,0 +1,21 @@
+import { defineBlock } from '../defineBlock.js';
+/** Stable framework type for a definition-backed nested flow block. */
+export const SUBFLOW_BLOCK_TYPE = 'flow.subflow';
+/**
+ * Generic nested-flow placeholder resolved from its referenced definition.
+ *
+ * The fallback port allows a newly dropped placeholder to be connected before
+ * its child definition is created. Once linked, the child contract replaces it.
+ */
+export const Subflow = defineBlock({
+    type: SUBFLOW_BLOCK_TYPE,
+    kind: 'flow',
+    name: 'Subflow',
+    description: 'Groups a nested flow behind the inputs and outputs declared by its definition.',
+    inputs: {
+        value: { type: 'json', required: true },
+    },
+    outputs: {
+        value: { type: 'json', required: true },
+    },
+});

package/dist/flows/blocks/index.d.ts

@@ -0,0 +1,6 @@
+export * from './FlowInput.js';
+export * from './FlowOutput.js';
+export * from './Subflow.js';
+import type { FlowBlockDefinition } from '../contracts/index.js';
+/** Framework-owned structural blocks registered for every flow service. */
+export declare const FLOW_SYSTEM_BLOCKS: FlowBlockDefinition[];

package/dist/flows/blocks/index.js

@@ -0,0 +1,8 @@
+export * from './FlowInput.js';
+export * from './FlowOutput.js';
+export * from './Subflow.js';
+import { FlowInput } from './FlowInput.js';
+import { FlowOutput } from './FlowOutput.js';
+import { Subflow } from './Subflow.js';
+/** Framework-owned structural blocks registered for every flow service. */
+export const FLOW_SYSTEM_BLOCKS = [FlowInput, FlowOutput, Subflow];

package/dist/flows/constants.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Durable lifecycle states for a complete flow invocation.
+ */
+export declare const FLOW_RUN_STATUS: {
+    readonly queued: "queued";
+    readonly running: "running";
+    readonly completed: "completed";
+    readonly failed: "failed";
+};
+/**
+ * Durable lifecycle states for one block occurrence in a run.
+ */
+export declare const FLOW_STEP_STATUS: {
+    readonly pending: "pending";
+    readonly queued: "queued";
+    readonly running: "running";
+    readonly waiting: "waiting";
+    readonly completed: "completed";
+    readonly failed: "failed";
+};
+/**
+ * Ordered event types emitted while flow runs progress.
+ */
+export declare const FLOW_RUN_EVENT_TYPE: {
+    readonly runCreated: "run.created";
+    readonly runStarted: "run.started";
+    readonly runCompleted: "run.completed";
+    readonly runFailed: "run.failed";
+    readonly runReplayed: "run.replayed";
+    readonly stepQueued: "step.queued";
+    readonly stepStarted: "step.started";
+    readonly stepWaiting: "step.waiting";
+    readonly stepLog: "step.log";
+    readonly stepCompleted: "step.completed";
+    readonly stepRetrying: "step.retrying";
+    readonly stepFailed: "step.failed";
+    readonly nestedStarted: "nested.started";
+    readonly nestedCompleted: "nested.completed";
+    readonly nestedFailed: "nested.failed";
+};
+/**
+ * Supported replay sources for a new run.
+ */
+export declare const FLOW_REPLAY_DEFINITION: {
+    readonly original: "original";
+    readonly latest: "latest";
+};
+/** Durable flow-run status value. */
+export type FlowRunStatus = typeof FLOW_RUN_STATUS[keyof typeof FLOW_RUN_STATUS];
+/** Durable flow-step status value. */
+export type FlowStepStatus = typeof FLOW_STEP_STATUS[keyof typeof FLOW_STEP_STATUS];
+/** Ordered flow-run event type. */
+export type FlowRunEventType = typeof FLOW_RUN_EVENT_TYPE[keyof typeof FLOW_RUN_EVENT_TYPE];
+/** Definition source used to create a replayed run. */
+export type FlowReplayDefinition = typeof FLOW_REPLAY_DEFINITION[keyof typeof FLOW_REPLAY_DEFINITION];

package/dist/flows/constants.js

@@ -0,0 +1,47 @@
+/**
+ * Durable lifecycle states for a complete flow invocation.
+ */
+export const FLOW_RUN_STATUS = {
+    queued: 'queued',
+    running: 'running',
+    completed: 'completed',
+    failed: 'failed',
+};
+/**
+ * Durable lifecycle states for one block occurrence in a run.
+ */
+export const FLOW_STEP_STATUS = {
+    pending: 'pending',
+    queued: 'queued',
+    running: 'running',
+    waiting: 'waiting',
+    completed: 'completed',
+    failed: 'failed',
+};
+/**
+ * Ordered event types emitted while flow runs progress.
+ */
+export const FLOW_RUN_EVENT_TYPE = {
+    runCreated: 'run.created',
+    runStarted: 'run.started',
+    runCompleted: 'run.completed',
+    runFailed: 'run.failed',
+    runReplayed: 'run.replayed',
+    stepQueued: 'step.queued',
+    stepStarted: 'step.started',
+    stepWaiting: 'step.waiting',
+    stepLog: 'step.log',
+    stepCompleted: 'step.completed',
+    stepRetrying: 'step.retrying',
+    stepFailed: 'step.failed',
+    nestedStarted: 'nested.started',
+    nestedCompleted: 'nested.completed',
+    nestedFailed: 'nested.failed',
+};
+/**
+ * Supported replay sources for a new run.
+ */
+export const FLOW_REPLAY_DEFINITION = {
+    original: 'original',
+    latest: 'latest',
+};

package/dist/flows/contracts/FlowBlock.d.ts

@@ -0,0 +1,64 @@
+import type { FlowBlockInstance } from './FlowDefinition.js';
+import type { FlowValue, FlowValueDefinitions, FlowValues } from './FlowValue.js';
+/**
+ * Severity attached to one durable block log entry.
+ */
+export type FlowLogLevel = 'debug' | 'info' | 'warning' | 'error';
+/** Execution strategy owned by a registered block type. */
+export type FlowBlockKind = 'function' | 'flow';
+/**
+ * Runtime information and services exposed to an executing block function.
+ */
+export interface FlowBlockContext<TConfig extends FlowValues = FlowValues> {
+    /** Flow definition currently being executed. */
+    flowId: string;
+    /** Durable run ULID. */
+    runId: string;
+    /** Durable step-run ULID. */
+    stepRunId: string;
+    /** Configured block occurrence being executed. */
+    block: FlowBlockInstance;
+    /** Validated block configuration with defaults applied. */
+    config: TConfig;
+    /**
+     * Records an ordered durable log entry for this block.
+     *
+     * @param level - Log severity.
+     * @param message - Human-readable log message.
+     * @param data - Optional structured diagnostic data.
+     */
+    log(level: FlowLogLevel, message: string, data?: FlowValue): Promise<void>;
+}
+/**
+ * Executable block type registered with a Flows service.
+ */
+export interface FlowBlockDefinition<TInput extends FlowValues = FlowValues, TOutput extends FlowValues = FlowValues, TConfig extends FlowValues = FlowValues> {
+    /** Stable namespaced type used by serialized flow definitions. */
+    type: string;
+    /** Whether this block executes a function or delegates to a nested flow. */
+    kind?: FlowBlockKind;
+    /** Human-readable block type name. */
+    name: string;
+    /** Optional explanation shown in block palettes and inspectors. */
+    description?: string;
+    /** Whether this block safely preserves a value when automatically inserted on a compatible connection. */
+    insertable?: boolean;
+    /** Named values accepted by the block function. */
+    inputs: FlowValueDefinitions;
+    /** Named values returned by the block function. */
+    outputs: FlowValueDefinitions;
+    /** Serializable configuration fields shown in the block inspector. */
+    config?: FlowValueDefinitions;
+    /**
+     * Executes the block with validated input and runtime context.
+     *
+     * @param input - Values assembled from the flow input or incoming connections.
+     * @param context - Durable run context, configuration, and logging API.
+     * @returns Values emitted through the block output ports.
+     */
+    run?(input: TInput, context: FlowBlockContext<TConfig>): TOutput | Promise<TOutput>;
+}
+/**
+ * Designer-safe metadata for one registered executable block type.
+ */
+export type FlowBlockMetadata = Omit<FlowBlockDefinition, 'run'>;

package/dist/flows/contracts/FlowBlock.js

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

package/dist/flows/contracts/FlowCompiler.d.ts

@@ -0,0 +1,30 @@
+import type { FlowBlockDefinition } from './FlowBlock.js';
+import type { FlowBlockInstance, FlowConnection, FlowExecutionDefinition } from './FlowDefinition.js';
+/**
+ * Executable block occurrence with its resolved type and graph connections.
+ */
+export interface CompiledFlowBlock {
+    /** Zero-based execution position in the sequential graph. */
+    sequence: number;
+    /** Configured block occurrence from the source definition. */
+    instance: FlowBlockInstance;
+    /** Registered executable block type. */
+    block: FlowBlockDefinition;
+    /** Connections supplying this block's input values. */
+    incoming: FlowConnection[];
+    /** Connections carrying this block's output values forward. */
+    outgoing: FlowConnection[];
+}
+/**
+ * Validated sequential execution plan derived from a flow definition snapshot.
+ */
+export interface CompiledFlowDefinition {
+    /** Definition snapshot used to produce this plan. */
+    definition: FlowExecutionDefinition;
+    /** Blocks in deterministic execution order. */
+    blocks: CompiledFlowBlock[];
+    /** Root block receiving the public flow input. */
+    root: CompiledFlowBlock;
+    /** Terminal block producing the public flow output. */
+    terminal: CompiledFlowBlock;
+}

package/dist/flows/contracts/FlowCompiler.js

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

package/dist/flows/contracts/FlowDefinition.d.ts

@@ -0,0 +1,118 @@
+import type { FlowValueDefinitions, FlowValues } from './FlowValue.js';
+/**
+ * Position persisted for a block in compatible graph designers.
+ */
+export interface FlowBlockPosition {
+    /** Horizontal canvas coordinate. */
+    x: number;
+    /** Vertical canvas coordinate. */
+    y: number;
+}
+/**
+ * One configured occurrence of a registered block type inside a flow.
+ */
+export interface FlowBlockInstance {
+    /** Stable ULID for this block occurrence. */
+    id: string;
+    /** Registered executable block type. */
+    type: string;
+    /** Optional instance label overriding the block type name in the designer. */
+    name?: string;
+    /** JSON-safe configuration supplied to the block when it runs. */
+    config?: FlowValues;
+    /** Designer position stored with the source-of-truth definition. */
+    position: FlowBlockPosition;
+    /** Optional nested flow id when this instance executes another flow. */
+    flowId?: string;
+}
+/**
+ * Serializable input/output contract captured for one resolved block occurrence.
+ *
+ * Generic subflow and flow-boundary blocks derive their ports from a referenced
+ * definition rather than from a statically registered block file. Runs retain
+ * this resolved contract so queued steps and replay do not depend on later edits.
+ */
+export interface FlowResolvedBlockContract {
+    /** Named values accepted by the resolved block occurrence. */
+    inputs: FlowValueDefinitions;
+    /** Named values emitted by the resolved block occurrence. */
+    outputs: FlowValueDefinitions;
+}
+/**
+ * One directed value connection between named block ports.
+ */
+export interface FlowConnection {
+    /** Stable ULID for this graph connection. */
+    id: string;
+    /** Source block occurrence ULID. */
+    sourceBlockId: string;
+    /** Named output port on the source block. */
+    sourcePort: string;
+    /** Target block occurrence ULID. */
+    targetBlockId: string;
+    /** Named input port on the target block. */
+    targetPort: string;
+}
+/**
+ * Serializable source-of-truth graph executed by the flow runtime.
+ */
+export interface FlowDefinition {
+    /** Definition schema version used for future compatible migrations. */
+    schemaVersion: 1;
+    /** Stable ULID used to invoke and reference this flow. */
+    id: string;
+    /** Human-readable flow name. */
+    name: string;
+    /** Optional longer explanation for developers and AI tooling. */
+    description?: string;
+    /** Public input contract accepted when the flow is invoked. */
+    inputs: FlowValueDefinitions;
+    /** Public output contract returned by the terminal block. */
+    outputs: FlowValueDefinitions;
+    /** Configured block occurrences in the graph. */
+    blocks: FlowBlockInstance[];
+    /** Directed connections between block ports. */
+    connections: FlowConnection[];
+}
+/**
+ * Immutable execution snapshot produced from one source flow definition.
+ *
+ * Resolution data is stored only on durable runs. Definition providers continue
+ * to read and write the smaller `FlowDefinition` source shape.
+ */
+export interface FlowExecutionDefinition extends FlowDefinition {
+    /** Effective dynamic contracts keyed by block occurrence ULID. */
+    resolvedBlocks: Record<string, FlowResolvedBlockContract>;
+    /** Immediate child snapshots keyed by flow-backed block occurrence ULID. */
+    nestedDefinitions: Record<string, StoredNestedFlowDefinition>;
+}
+/**
+ * Stored child definition captured as part of a parent execution snapshot.
+ */
+export interface StoredNestedFlowDefinition {
+    /** Fully resolved child definition used when the nested block is reached. */
+    definition: FlowExecutionDefinition;
+    /** Definition-provider revision captured with the child source. */
+    revision: string;
+    /** Optional provider-relative source path. */
+    path?: string;
+}
+/**
+ * Lightweight definition metadata used by flow lists and selectors.
+ */
+export interface FlowDefinitionSummary {
+    /** Stable flow ULID. */
+    id: string;
+    /** Human-readable flow name. */
+    name: string;
+    /** Optional developer-facing description. */
+    description?: string;
+    /** Public input contract exposed when this flow is used as a subflow block. */
+    inputs: FlowValueDefinitions;
+    /** Public output contract exposed when this flow is used as a subflow block. */
+    outputs: FlowValueDefinitions;
+    /** Current content revision returned by the definition provider. */
+    revision: string;
+    /** Provider-relative source path, when one exists. */
+    path?: string;
+}

package/dist/flows/contracts/FlowDefinition.js

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

package/dist/flows/contracts/FlowDefinitionStore.d.ts

@@ -0,0 +1,47 @@
+import type { FlowDefinition, FlowDefinitionSummary } from './FlowDefinition.js';
+/**
+ * Definition plus provider metadata required for conflict-safe editing.
+ */
+export interface StoredFlowDefinition {
+    /** Parsed and validated source-of-truth definition. */
+    definition: FlowDefinition;
+    /** Content revision used for optimistic concurrency. */
+    revision: string;
+    /** Provider-relative source path, when one exists. */
+    path?: string;
+}
+/**
+ * Options used when saving one flow definition.
+ */
+export interface FlowDefinitionWriteOptions {
+    /** Previously-read revision that must still match before replacement. */
+    expectedRevision?: string;
+    /** Optional provider-relative path used when creating a new definition. */
+    path?: string;
+}
+/**
+ * Storage boundary shared by local file definitions and future hosted drivers.
+ */
+export interface FlowDefinitionStore {
+    /**
+     * Lists available definitions without requiring callers to know provider paths.
+     *
+     * @returns Available flow summaries.
+     */
+    list(): Promise<FlowDefinitionSummary[]>;
+    /**
+     * Loads one definition by stable flow ULID.
+     *
+     * @param id - Flow ULID.
+     * @returns Stored definition or null when absent.
+     */
+    read(id: string): Promise<StoredFlowDefinition | null>;
+    /**
+     * Creates or replaces one definition.
+     *
+     * @param definition - Valid flow definition to persist.
+     * @param options - Revision and optional creation path.
+     * @returns Newly stored definition metadata.
+     */
+    write(definition: FlowDefinition, options?: FlowDefinitionWriteOptions): Promise<StoredFlowDefinition>;
+}

package/dist/flows/contracts/FlowDefinitionStore.js

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

package/dist/flows/contracts/FlowRun.d.ts

@@ -0,0 +1,40 @@
+import type { FlowReplayDefinition } from '../constants.js';
+import type { FlowValue, FlowValues } from './FlowValue.js';
+/**
+ * Structured error snapshot stored on failed runs and block steps.
+ */
+export interface FlowErrorSnapshot {
+    /** Error class or provider name. */
+    name: string;
+    /** Human-readable failure message. */
+    message: string;
+    /** Optional stack trace captured in development/runtime logs. */
+    stack?: string;
+}
+/**
+ * Options controlling creation of a new flow run.
+ */
+export interface FlowRunOptions {
+    /** Optional run ULID that this invocation replays. */
+    replayOfRunId?: string;
+}
+/**
+ * Options controlling which definition snapshot a replay executes.
+ */
+export interface FlowReplayOptions {
+    /** Whether to execute the original snapshot or the latest stored definition. */
+    definition?: FlowReplayDefinition;
+    /** Optional replacement public input for the replay. */
+    input?: FlowValues;
+}
+/**
+ * Durable log entry requested by an executing block.
+ */
+export interface FlowBlockLogInput {
+    /** Log severity. */
+    level: 'debug' | 'info' | 'warning' | 'error';
+    /** Human-readable log message. */
+    message: string;
+    /** Optional structured diagnostic value. */
+    data?: FlowValue;
+}

package/dist/flows/contracts/FlowRun.js

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

package/dist/flows/contracts/FlowValue.d.ts

@@ -0,0 +1,49 @@
+/**
+ * JSON-safe value that can cross a flow block boundary or be persisted in a run.
+ */
+export type FlowValue = string | number | boolean | null | FlowValue[] | {
+    [key: string]: FlowValue;
+};
+/**
+ * Named JSON-safe values received or returned by a flow block.
+ */
+export type FlowValues = Record<string, FlowValue>;
+/**
+ * Value kinds understood by the initial flow validator and designer inspector.
+ */
+export type FlowValueType = 'string' | 'number' | 'boolean' | 'object' | 'array' | 'json';
+/**
+ * Optional presentation hints for definition-driven input and configuration forms.
+ *
+ * Runtime validation does not depend on these values. Hosts may map `component`
+ * names such as `DomTextInput` or `DomJsonInput` to their own component registry.
+ */
+export interface FlowValueEditorDefinition {
+    /** Host component name preferred for this value. */
+    component?: string;
+    /** Human-readable field label overriding the serialized value name. */
+    label?: string;
+    /** Optional empty-value guidance rendered by compatible editors. */
+    placeholder?: string;
+    /** Preferred textarea row count for multiline or JSON values. */
+    rows?: number;
+}
+/**
+ * Serializable schema for one block port or configuration value.
+ */
+export interface FlowValueDefinition {
+    /** Value kind used for validation and editor controls. */
+    type: FlowValueType;
+    /** Whether the value must be present and non-null. */
+    required?: boolean;
+    /** Human-readable explanation shown by development tools. */
+    description?: string;
+    /** Default value applied when block configuration omits the field. */
+    default?: FlowValue;
+    /** Optional host-agnostic form renderer hints. */
+    editor?: FlowValueEditorDefinition;
+}
+/**
+ * Named schemas for block ports or configuration values.
+ */
+export type FlowValueDefinitions = Record<string, FlowValueDefinition>;

package/dist/flows/contracts/FlowValue.js

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

package/dist/flows/contracts/FlowsService.d.ts

@@ -0,0 +1,37 @@
+import type { Queue } from '../../queue/index.js';
+import type { AppDatabaseProvider } from '../../server/index.js';
+import type { FlowBlockDefinition } from './FlowBlock.js';
+import type { FlowDefinitionStore } from './FlowDefinitionStore.js';
+/**
+ * Dependencies and limits used by one application-scoped Flows service.
+ */
+export interface FlowsOptions {
+    /** Existing application queue used to execute durable block jobs. */
+    queue: Queue;
+    /** Definition provider used to load and save source-of-truth graphs. */
+    definitions: FlowDefinitionStore;
+    /** Executable block types available to this application. */
+    blocks: FlowBlockDefinition[];
+    /** Queue/channel used for flow step jobs. Defaults to `flows`. */
+    queueName?: string;
+    /** Maximum queue attempts for each block step. Defaults to 3. */
+    maxTries?: number;
+    /** Maximum serialized input or output size retained per boundary. */
+    maxPayloadBytes?: number;
+}
+/**
+ * Minimal application shape required by queue-rehydrated flow step jobs.
+ */
+export interface FlowStepJobApp extends AppDatabaseProvider {
+    /** Application-scoped flow service. */
+    flows: {
+        /**
+         * Executes one durable step claimed by the queue.
+         *
+         * @param runId - Flow run ULID.
+         * @param blockId - Block occurrence ULID.
+         * @param job - Claimed queue job metadata.
+         */
+        processStep(runId: string, blockId: string, job: import('../../queue/index.js').QueueJob): Promise<void>;
+    };
+}

package/dist/flows/contracts/FlowsService.js

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

package/dist/flows/contracts/index.d.ts

@@ -0,0 +1,7 @@
+export * from './FlowBlock.js';
+export * from './FlowCompiler.js';
+export * from './FlowDefinition.js';
+export * from './FlowDefinitionStore.js';
+export * from './FlowRun.js';
+export * from './FlowValue.js';
+export * from './FlowsService.js';