@skaile/workspaces 0.8.5

package/dist/base-assets/connectors/flow/engine/engine.d.ts

@@ -0,0 +1,107 @@
+import type { FlowDefinition, FlowState, NodeExecutionSnapshot, NodeStatus } from "./types.js";
+/**
+ * Compute the full {@link FlowState} from a flow definition and caller-supplied node ID sets.
+ *
+ * This is the primary engine function. It is stateless and side-effect-free — calling it
+ * twice with the same arguments always returns an equivalent result.
+ *
+ * Edge semantics applied during computation:
+ * - `'flow'`     — hard dependency: target cannot start until source is `complete` or `skipped`.
+ * - `'parallel'` — soft dependency: target may run while source is still running.
+ * - `'optional'` — advisory: target can start regardless of source state.
+ *
+ * A node is `available` when every incoming `'flow'`-type edge has a complete or skipped source.
+ * A node is `not_started` when at least one hard predecessor is still pending.
+ * The flow is `done` when every non-optional node is `complete` or `skipped`.
+ *
+ * Prefer {@link computeFlowStateFromSnapshots} for callers that track full `NodeExecution`
+ * state (interaction statuses such as `awaiting_approval`, `awaiting_input`, `failed`).
+ *
+ * @param flow - The parsed flow definition.
+ * @param completedIds - Set of node IDs that have finished successfully.
+ * @param runningIds - Set of node IDs currently executing. Defaults to an empty set.
+ * @param skippedIds - Set of node IDs that were explicitly skipped. Skipped nodes count
+ *   as satisfied for downstream dependency checks. Defaults to an empty set.
+ * @returns A {@link FlowState} describing the current status of every skill node.
+ * @docLink packages/flow-engine/concepts#compute-flow-state
+ */
+export declare function computeFlowState(flow: FlowDefinition, completedIds: Set<string>, runningIds?: Set<string>, skippedIds?: Set<string>): FlowState;
+/**
+ * Snapshot-based variant of {@link computeFlowState}.
+ *
+ * Accepts a map of `NodeExecutionSnapshot` values carrying the current status and
+ * interaction metadata for every node the caller knows about. Nodes absent from the
+ * map are treated as `not_started`.
+ *
+ * This is the preferred API for the turn-based runner, which has a full `FlowExecution`
+ * and needs to convey richer statuses (`awaiting_approval`, `awaiting_input`, `failed`)
+ * back to the engine so downstream availability is computed correctly.
+ *
+ * Engine semantics:
+ * - A node is `available` when all its incoming `'flow'`-type predecessors are `complete`
+ *   or `skipped`. Any other upstream status — including `awaiting_approval`,
+ *   `awaiting_input`, and `failed` — is treated as blocking.
+ * - A `failed` optional node does **not** block its dependents.
+ * - The flow is `done` when every non-optional node is `complete` or `skipped`. A single
+ *   required node stuck in `failed` keeps `done` false.
+ *
+ * @param flow - The parsed flow definition.
+ * @param snapshots - Map from node ID to its current {@link NodeExecutionSnapshot}.
+ *   Missing entries default to `not_started` with no interaction metadata.
+ * @returns A {@link FlowState} describing the current status of every skill node,
+ *   including interaction fields (`approval`, `input`, `output`, `error`) copied
+ *   from the matching snapshot.
+ * @docLink packages/flow-engine/concepts#compute-flow-state-from-snapshots
+ */
+export declare function computeFlowStateFromSnapshots(flow: FlowDefinition, snapshots: Map<string, NodeExecutionSnapshot>): FlowState;
+/**
+ * Returns `true` when the given status prevents downstream nodes from starting.
+ *
+ * Only `'complete'` and `'skipped'` satisfy a hard (`'flow'`-type) edge dependency.
+ * All other statuses — including `'awaiting_approval'`, `'awaiting_input'`, and
+ * `'failed'` — are considered blocking.
+ *
+ * Use this helper in the FlowAdapter and the turn-based orchestrator instead of
+ * hard-coding the two-value whitelist inline.
+ *
+ * @param status - The {@link NodeStatus} to evaluate.
+ * @returns `true` if the status prevents dependents from becoming `available`.
+ * @docLink packages/flow-engine/concepts#is-blocking
+ */
+export declare function isBlocking(status: NodeStatus): boolean;
+/**
+ * Returns the IDs of nodes that become newly `available` after a specific node completes.
+ *
+ * More efficient than recomputing the full {@link FlowState} when only the downstream
+ * impact of a single completion is needed. Only the direct successors of `justCompleted`
+ * are evaluated — the rest of the graph is untouched.
+ *
+ * @param flow - The parsed flow definition.
+ * @param justCompleted - ID of the node that just finished (will be added to the
+ *   effective completed set before evaluating successors).
+ * @param completedIds - Set of node IDs already known to be complete before this call.
+ * @param skippedIds - Set of node IDs that were explicitly skipped. Defaults to an empty set.
+ * @returns Array of node IDs whose hard dependencies are now fully satisfied and that
+ *   were not already available before `justCompleted` finished.
+ * @docLink packages/flow-engine/concepts#resolve-next-nodes
+ */
+export declare function resolveNextNodes(flow: FlowDefinition, justCompleted: string, completedIds: Set<string>, skippedIds?: Set<string>): string[];
+/**
+ * Returns the IDs of optional nodes that have not yet started and can be safely skipped.
+ *
+ * A node is skippable when it is:
+ * 1. Not yet complete (absent from `completedIds`).
+ * 2. Marked `optional` (`FlowNode.data.optional === true`).
+ * 3. Not connected via a `'flow'`-type edge to any non-optional downstream node
+ *    (i.e. skipping it cannot starve a required node of a hard dependency).
+ *
+ * The runner may call this to present the user with a list of nodes they can bypass
+ * without breaking the flow's required path.
+ *
+ * @param flow - The parsed flow definition.
+ * @param completedIds - Set of node IDs that have already completed (excluded from results).
+ * @returns Array of node IDs that are safe to skip at this point in the execution.
+ * @docLink packages/flow-engine/concepts#compute-skippable
+ */
+export declare function computeSkippable(flow: FlowDefinition, completedIds: Set<string>): string[];
+//# sourceMappingURL=engine.d.ts.map

package/dist/base-assets/connectors/flow/engine/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../../../../base-assets/connectors/flow/engine/engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EAGd,SAAS,EACT,qBAAqB,EAErB,UAAU,EACX,MAAM,YAAY,CAAC;AA+BpB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,cAAc,EACpB,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,EACzB,UAAU,GAAE,GAAG,CAAC,MAAM,CAAa,EACnC,UAAU,GAAE,GAAG,CAAC,MAAM,CAAa,GAClC,SAAS,CA+EX;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,cAAc,EACpB,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,qBAAqB,CAAC,GAC5C,SAAS,CA6DX;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAEtD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,cAAc,EACpB,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,EACzB,UAAU,GAAE,GAAG,CAAC,MAAM,CAAa,GAClC,MAAM,EAAE,CAmBV;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc,EAAE,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,CAgB1F"}

package/dist/base-assets/connectors/flow/engine/flow-kind-provider.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Flow asset kind provider.
+ *
+ * Exported from @skaile/workspaces/base-assets/connectors/flow/engine for explicit registration
+ * by the CLI at bootstrap. Discovery does NOT auto-include this provider
+ * (discovery must stay a leaf — no flow-engine imports).
+ *
+ * Implements IAssetKindProvider with flow-specific:
+ * - Discovery patterns: *.flow.yaml, *.flow.json
+ * - Manifest validation via FlowManifestSchema
+ * - Requires extraction: nodes[].skill references
+ * - File filter: just the manifest file (flows are single-file)
+ */
+import type { IAssetKindProvider } from "@skaile/workspaces/plugins";
+export declare const flowKindProvider: IAssetKindProvider;
+//# sourceMappingURL=flow-kind-provider.d.ts.map

package/dist/base-assets/connectors/flow/engine/flow-kind-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow-kind-provider.d.ts","sourceRoot":"","sources":["../../../../../base-assets/connectors/flow/engine/flow-kind-provider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EACV,kBAAkB,EAGnB,MAAM,4BAA4B,CAAC;AAOpC,eAAO,MAAM,gBAAgB,EAAE,kBA6C9B,CAAC"}

package/dist/base-assets/connectors/flow/engine/flow-manifest.d.ts

@@ -0,0 +1,215 @@
+/**
+ * Flow manifest schema and validation.
+ *
+ * Moved from @skaile/workspaces/types/manifests/flow.ts in Phase 1.7.3.
+ * This is now the canonical location for flow manifest validation.
+ */
+import * as z from "zod";
+export interface ManifestValidationSuccess<T> {
+    ok: true;
+    data: T;
+}
+export interface ManifestValidationFailure {
+    ok: false;
+    errors: Array<{
+        path: string;
+        message: string;
+    }>;
+}
+export type ManifestValidationResult<T> = ManifestValidationSuccess<T> | ManifestValidationFailure;
+export declare const FlowManifestSchema: z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        stage: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        category: z.ZodOptional<z.ZodString>;
+        onboarding: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        stage: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        category: z.ZodOptional<z.ZodString>;
+        onboarding: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        stage: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        category: z.ZodOptional<z.ZodString>;
+        onboarding: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">>>;
+    globals: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    modes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    tier_presets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    artifact_handoff: z.ZodOptional<z.ZodUnknown>;
+    entry: z.ZodOptional<z.ZodString>;
+    nodes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        skill: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodString;
+        skill: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodString;
+        skill: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>, "many">>;
+    edges: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        source: z.ZodString;
+        target: z.ZodString;
+        condition: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodOptional<z.ZodString>;
+        source: z.ZodString;
+        target: z.ZodString;
+        condition: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodOptional<z.ZodString>;
+        source: z.ZodString;
+        target: z.ZodString;
+        condition: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>, "many">>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    id: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        stage: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        category: z.ZodOptional<z.ZodString>;
+        onboarding: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        stage: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        category: z.ZodOptional<z.ZodString>;
+        onboarding: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        stage: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        category: z.ZodOptional<z.ZodString>;
+        onboarding: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">>>;
+    globals: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    modes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    tier_presets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    artifact_handoff: z.ZodOptional<z.ZodUnknown>;
+    entry: z.ZodOptional<z.ZodString>;
+    nodes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        skill: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodString;
+        skill: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodString;
+        skill: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>, "many">>;
+    edges: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        source: z.ZodString;
+        target: z.ZodString;
+        condition: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodOptional<z.ZodString>;
+        source: z.ZodString;
+        target: z.ZodString;
+        condition: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodOptional<z.ZodString>;
+        source: z.ZodString;
+        target: z.ZodString;
+        condition: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>, "many">>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    id: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        stage: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        category: z.ZodOptional<z.ZodString>;
+        onboarding: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        stage: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        category: z.ZodOptional<z.ZodString>;
+        onboarding: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        stage: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        category: z.ZodOptional<z.ZodString>;
+        onboarding: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">>>;
+    globals: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    modes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    tier_presets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    artifact_handoff: z.ZodOptional<z.ZodUnknown>;
+    entry: z.ZodOptional<z.ZodString>;
+    nodes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        skill: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodString;
+        skill: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodString;
+        skill: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>, "many">>;
+    edges: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        source: z.ZodString;
+        target: z.ZodString;
+        condition: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodOptional<z.ZodString>;
+        source: z.ZodString;
+        target: z.ZodString;
+        condition: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodOptional<z.ZodString>;
+        source: z.ZodString;
+        target: z.ZodString;
+        condition: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>, "many">>;
+}, z.ZodTypeAny, "passthrough">>;
+export type FlowManifest = z.infer<typeof FlowManifestSchema>;
+export declare function validateFlow(data: unknown): ManifestValidationResult<FlowManifest>;
+//# sourceMappingURL=flow-manifest.d.ts.map

package/dist/base-assets/connectors/flow/engine/flow-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow-manifest.d.ts","sourceRoot":"","sources":["../../../../../base-assets/connectors/flow/engine/flow-manifest.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAMzB,MAAM,WAAW,yBAAyB,CAAC,CAAC;IAC1C,EAAE,EAAE,IAAI,CAAC;IACT,IAAI,EAAE,CAAC,CAAC;CACT;AAED,MAAM,WAAW,yBAAyB;IACxC,EAAE,EAAE,KAAK,CAAC;IACV,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAClD;AAED,MAAM,MAAM,wBAAwB,CAAC,CAAC,IAAI,yBAAyB,CAAC,CAAC,CAAC,GAAG,yBAAyB,CAAC;AAyBnG,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAwBf,CAAC;AAEjB,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAM9D,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,wBAAwB,CAAC,YAAY,CAAC,CAYlF"}

package/dist/base-assets/connectors/flow/engine/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./engine.js";
+export * from "./loader.js";
+export * from "./types.js";
+export { FlowManifestSchema, validateFlow, } from "./flow-manifest.js";
+export type { FlowManifest, ManifestValidationResult as FlowManifestValidationResult, } from "./flow-manifest.js";
+export { flowKindProvider } from "./flow-kind-provider.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/base-assets/connectors/flow/engine/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../base-assets/connectors/flow/engine/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAG3B,OAAO,EACL,kBAAkB,EAClB,YAAY,GACb,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EACV,YAAY,EACZ,wBAAwB,IAAI,4BAA4B,GACzD,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/base-assets/connectors/flow/engine/loader.d.ts

@@ -0,0 +1,43 @@
+import type { FlowDefinition } from "./types.js";
+/**
+ * Load a single {@link FlowDefinition} from a YAML or JSON file on disk.
+ *
+ * Format detection is based on file extension:
+ * - `.yaml` / `.yml` — parsed with the `yaml` library.
+ * - Everything else  — parsed as JSON.
+ *
+ * @param filePath - Absolute path to the flow file.
+ * @returns The parsed {@link FlowDefinition}.
+ * @throws {Error} If the file does not exist, cannot be read, or fails to parse.
+ * @docLink packages/flow-engine/concepts#flow-loading
+ */
+export declare function loadFlow(filePath: string): FlowDefinition;
+/**
+ * Load all `*.flow.yaml` and legacy `*.flow.json` / `*.json` flow files from a directory.
+ *
+ * Files that fail to parse are skipped with a warning written to `stderr` — they do not
+ * cause the function to throw. Files whose name starts with `_` are skipped entirely
+ * (treated as drafts or disabled flows). Files missing the required `id`, `nodes`, or
+ * `edges` fields are also discarded silently.
+ *
+ * @param dirPath - Absolute path to the directory to scan.
+ * @returns Array of successfully parsed {@link FlowDefinition} objects. Empty if the
+ *   directory does not exist or contains no valid flow files.
+ * @docLink packages/flow-engine/concepts#flow-loading
+ */
+export declare function loadFlowsFromDir(dirPath: string): FlowDefinition[];
+/**
+ * Discover and load all flow definitions from every domain under an `ai-assets` root.
+ *
+ * Walks the top-level subdirectories of `aiResourcesRoot`, looks for a `flows/`
+ * subdirectory inside each domain, and delegates to {@link loadFlowsFromDir} for
+ * each one found. Files prefixed with `_` are skipped (draft/disabled).
+ *
+ * @param aiResourcesRoot - Absolute path to the `ai-assets/` directory (or equivalent
+ *   resource root). Typically the `ai-assets/` folder at the monorepo root.
+ * @returns Flat array of all successfully parsed {@link FlowDefinition} objects across
+ *   all domains. Empty if the root directory does not exist.
+ * @docLink packages/flow-engine/concepts#flow-loading
+ */
+export declare function loadAllFlows(aiResourcesRoot: string): FlowDefinition[];
+//# sourceMappingURL=loader.d.ts.map

package/dist/base-assets/connectors/flow/engine/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../../../../base-assets/connectors/flow/engine/loader.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc,CAOzD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,EAAE,CAsBlE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,eAAe,EAAE,MAAM,GAAG,cAAc,EAAE,CAetE"}