@skaile/workspaces 2.1.0 → 2.3.0

package/dist/factory-assets/connectors/flow/contract/hash.d.ts

@@ -0,0 +1,6 @@
+import type { ParsedFlowDefinition } from "./normalize.js";
+/** Gives equivalent definitions identical bytes while preserving content-significant array order. */
+export declare function canonicalizeFlowDefinition(definition: ParsedFlowDefinition): string;
+/** Creates a browser-safe content identity for caching, pinning, and change detection. */
+export declare function hashFlowDefinition(definition: ParsedFlowDefinition): Promise<string>;
+//# sourceMappingURL=hash.d.ts.map

package/dist/factory-assets/connectors/flow/contract/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../../../../factory-assets/connectors/flow/contract/hash.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAwE3D,qGAAqG;AACrG,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,oBAAoB,GAAG,MAAM,CAEnF;AAED,0FAA0F;AAC1F,wBAAsB,kBAAkB,CAAC,UAAU,EAAE,oBAAoB,GAAG,OAAO,CAAC,MAAM,CAAC,CAI1F"}

package/dist/factory-assets/connectors/flow/contract/index.d.ts

@@ -0,0 +1,6 @@
+export { FlowDefinitionSchema, type FlowAssetRef, type FlowDefinition, type FlowEdge, type FlowInputContract, type FlowNode, type FlowNodeBindings, type FlowNodeContract, type FlowNodeControl, type FlowNodeKind, type FlowNodePrecondition, type FlowNodeRun, type FlowOutputContract, type FlowRoute, } from "./schema.js";
+export { normalizeV1, parseFlowDefinition, type FlowDefinitionIssue, type FlowDefinitionParseResult, type LegacyCompatibilityEdge, type ParsedFlowDefinition, } from "./normalize.js";
+export { evaluate, evaluateFlowExpression, FLOW_EXPRESSION_LIMITS, FlowExpressionError, type FlowExpressionContext, } from "./expression.js";
+export { canonicalizeFlowDefinition, hashFlowDefinition } from "./hash.js";
+export { FLOW_DEFINITION_JSON_SCHEMA_ID, generateFlowDefinitionJsonSchema, } from "./json-schema.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/factory-assets/connectors/flow/contract/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../factory-assets/connectors/flow/contract/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,QAAQ,EACb,KAAK,iBAAiB,EACtB,KAAK,QAAQ,EACb,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,oBAAoB,EACzB,KAAK,WAAW,EAChB,KAAK,kBAAkB,EACvB,KAAK,SAAS,GACf,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,WAAW,EACX,mBAAmB,EACnB,KAAK,mBAAmB,EACxB,KAAK,yBAAyB,EAC9B,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,GAC1B,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,QAAQ,EACR,sBAAsB,EACtB,sBAAsB,EACtB,mBAAmB,EACnB,KAAK,qBAAqB,GAC3B,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,0BAA0B,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAC3E,OAAO,EACL,8BAA8B,EAC9B,gCAAgC,GACjC,MAAM,kBAAkB,CAAC"}

package/dist/factory-assets/connectors/flow/contract/json-schema.d.ts

@@ -0,0 +1,6 @@
+import * as z from "zod";
+/** Canonical URI editors can use to identify the published Flow v2 vocabulary. */
+export declare const FLOW_DEFINITION_JSON_SCHEMA_ID = "https://skaile.ai/schemas/flow/v2.json";
+/** Keeps editor tooling downstream of Zod so the checked-in artifact cannot become an authority. */
+export declare function generateFlowDefinitionJsonSchema(): z.core.JSONSchema.JSONSchema;
+//# sourceMappingURL=json-schema.d.ts.map

package/dist/factory-assets/connectors/flow/contract/json-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema.d.ts","sourceRoot":"","sources":["../../../../../factory-assets/connectors/flow/contract/json-schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAGzB,kFAAkF;AAClF,eAAO,MAAM,8BAA8B,2CAA2C,CAAC;AAEvF,oGAAoG;AACpG,wBAAgB,gCAAgC,IAAI,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,UAAU,CAS/E"}

package/dist/factory-assets/connectors/flow/contract/normalize.d.ts

@@ -0,0 +1,38 @@
+import { type FlowDefinition } from "./schema.js";
+/** Stable authored-path failure returned without exposing Zod as part of the public boundary. */
+export interface FlowDefinitionIssue {
+    /** Dot-separated authored-data path; the empty string identifies the root. */
+    path: string;
+    /** Human-readable reason the value failed contract validation. */
+    message: string;
+}
+/** Inert legacy edge retained for round-tripping outside the closed authored-v2 vocabulary. */
+export type LegacyCompatibilityEdge = {
+    id: string;
+    source: string;
+    target: string;
+    type: string;
+} & Record<string, unknown>;
+/** Normalized content whose nodes are strict v2 while inert legacy edges remain lossless. */
+export type ParsedFlowDefinition = Omit<FlowDefinition, "edges"> & {
+    edges: Array<FlowDefinition["edges"][number] | LegacyCompatibilityEdge>;
+};
+/** Normalized authoring or compatibility content, or complete authored-path failures. */
+export type FlowDefinitionParseResult = {
+    ok: true;
+    data: ParsedFlowDefinition;
+} | {
+    ok: false;
+    errors: FlowDefinitionIssue[];
+};
+/**
+ * Converts a recognized v1 definition to strict v2 without mutating the authored input.
+ * Non-executable legacy nodes become inert placeholders so dependency and terminal semantics survive.
+ */
+export declare function normalizeV1(data: unknown): FlowDefinitionParseResult;
+/**
+ * Parses strict v2 or normalizes v1, reusing an unchanged successful result across boundaries.
+ * Only an absent own schema version permits compatibility normalization.
+ */
+export declare function parseFlowDefinition(data: unknown): FlowDefinitionParseResult;
+//# sourceMappingURL=normalize.d.ts.map

package/dist/factory-assets/connectors/flow/contract/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../../../factory-assets/connectors/flow/contract/normalize.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,cAAc,EACpB,MAAM,aAAa,CAAC;AAyGrB,iGAAiG;AACjG,MAAM,WAAW,mBAAmB;IAClC,8EAA8E;IAC9E,IAAI,EAAE,MAAM,CAAC;IACb,kEAAkE;IAClE,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,+FAA+F;AAC/F,MAAM,MAAM,uBAAuB,GAAG;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE5B,6FAA6F;AAC7F,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC,cAAc,EAAE,OAAO,CAAC,GAAG;IACjE,KAAK,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,GAAG,uBAAuB,CAAC,CAAC;CACzE,CAAC;AAEF,yFAAyF;AACzF,MAAM,MAAM,yBAAyB,GACjC;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,oBAAoB,CAAA;CAAE,GACxC;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,mBAAmB,EAAE,CAAA;CAAE,CAAC;AAsFjD;;;GAGG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,GAAG,yBAAyB,CAuHpE;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,yBAAyB,CAY5E"}

package/dist/factory-assets/connectors/flow/contract/schema.d.ts

@@ -0,0 +1,364 @@
+import * as z from "zod";
+/** Validates normalized field shapes without applying authored-v2 graph semantics. */
+export declare function parseFlowDefinitionStructure(data: unknown): z.ZodSafeParseResult<{
+    schemaVersion: 2;
+    id: string;
+    version: string;
+    name: string;
+    nodes: {
+        id: string;
+        label: string;
+        description: string;
+        run: {
+            kind: "agent";
+            instruction: string;
+            assets?: string[] | undefined;
+        } | {
+            kind: "subprompt";
+            instruction: string;
+            assets?: string[] | undefined;
+            model?: string | undefined;
+        } | {
+            command: string;
+            kind: "function";
+            assets?: string[] | undefined;
+            runtime?: "shell" | "node" | "python" | undefined;
+            cwd?: string | undefined;
+            successExit?: number[] | undefined;
+            capture?: {
+                stdout?: string | undefined;
+                stderr?: string | undefined;
+            } | undefined;
+        } | {
+            command: string;
+            kind: "check";
+            onFail: "escalate" | "fail";
+            assets?: string[] | undefined;
+            runtime?: "shell" | "node" | "python" | undefined;
+            cwd?: string | undefined;
+            successExit?: number[] | undefined;
+            capture?: {
+                stdout?: string | undefined;
+                stderr?: string | undefined;
+            } | undefined;
+        } | {
+            kind: "gate";
+            prompt: string;
+            schema: {
+                kind: "text";
+                multiline?: boolean | undefined;
+            } | {
+                kind: "choice";
+                options: {
+                    id: string;
+                    label: string;
+                    description?: string | undefined;
+                }[];
+                multiple?: boolean | undefined;
+            } | {
+                kind: "form";
+                fields: {
+                    id: string;
+                    label: string;
+                    type: "number" | "boolean" | "text" | "file" | "choice" | "textarea" | "date";
+                    required?: boolean | undefined;
+                    options?: {
+                        id: string;
+                        label: string;
+                        description?: string | undefined;
+                    }[] | undefined;
+                    accept?: string[] | undefined;
+                }[];
+            } | {
+                kind: "file";
+                accept?: string[] | undefined;
+                maxSize?: number | undefined;
+                multiple?: boolean | undefined;
+            };
+            assets?: string[] | undefined;
+        } | {
+            kind: "router";
+            routes: {
+                when: string;
+                target: string | null;
+            }[];
+            assets?: string[] | undefined;
+        };
+        phase?: string | undefined;
+        contract?: {
+            requires?: {
+                expr: string;
+                message?: string | undefined;
+            }[] | undefined;
+            input?: Record<string, z.core.util.JSONType> | undefined;
+            output?: {
+                fields?: Record<string, z.core.util.JSONType> | undefined;
+                artifacts?: {
+                    kind: string;
+                    lifetime: "session" | "persistent";
+                }[] | undefined;
+            } | undefined;
+        } | undefined;
+        gate?: {
+            approval: "none" | "optional" | "mandatory";
+        } | undefined;
+        control?: {
+            optional?: boolean | undefined;
+            retries?: number | undefined;
+            timeoutSec?: number | undefined;
+            parallelGroup?: string | undefined;
+        } | undefined;
+    }[];
+    edges: {
+        id: string;
+        source: string;
+        target: string;
+        type: "flow" | "optional" | "parallel";
+    }[];
+    $schema?: string | undefined;
+    description?: string | undefined;
+    input?: {
+        schema: Record<string, z.core.util.JSONType>;
+        example?: z.core.util.JSONType | undefined;
+    } | undefined;
+    output?: {
+        schema: Record<string, z.core.util.JSONType>;
+    } | undefined;
+    defaults?: {
+        approval?: "manual" | "auto" | "checkpoint" | undefined;
+        researchDepth?: string | undefined;
+        autoReview?: boolean | undefined;
+        subagentMode?: boolean | undefined;
+        verbosity?: string | undefined;
+        cliMode?: boolean | undefined;
+        run_input?: z.core.util.JSONType | undefined;
+        parameters?: Record<string, z.core.util.JSONType> | undefined;
+    } | undefined;
+    entry?: string | undefined;
+    meta?: {
+        icon?: string | undefined;
+        category?: string | undefined;
+        tags?: string[] | undefined;
+        stage?: string | undefined;
+        onboarding?: {
+            input_style: "repo" | "freeform" | "structured";
+            placeholder?: string | undefined;
+            fields?: string[] | undefined;
+        } | undefined;
+    } | undefined;
+}>;
+/** Authoritative strict runtime schema for authored, acyclic Flow v2 definitions. */
+export declare const FlowDefinitionSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    schemaVersion: z.ZodLiteral<2>;
+    id: z.ZodString;
+    version: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    input: z.ZodOptional<z.ZodObject<{
+        schema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        example: z.ZodOptional<z.ZodJSONSchema>;
+    }, z.core.$strict>>;
+    output: z.ZodOptional<z.ZodObject<{
+        schema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    }, z.core.$strict>>;
+    defaults: z.ZodOptional<z.ZodObject<{
+        approval: z.ZodOptional<z.ZodEnum<{
+            manual: "manual";
+            auto: "auto";
+            checkpoint: "checkpoint";
+        }>>;
+        researchDepth: z.ZodOptional<z.ZodString>;
+        autoReview: z.ZodOptional<z.ZodBoolean>;
+        subagentMode: z.ZodOptional<z.ZodBoolean>;
+        verbosity: z.ZodOptional<z.ZodString>;
+        cliMode: z.ZodOptional<z.ZodBoolean>;
+        run_input: z.ZodOptional<z.ZodJSONSchema>;
+        parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    }, z.core.$strict>>;
+    entry: z.ZodOptional<z.ZodString>;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodString;
+        phase: z.ZodOptional<z.ZodString>;
+        run: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            assets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            kind: z.ZodLiteral<"agent">;
+            instruction: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            assets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            kind: z.ZodLiteral<"subprompt">;
+            instruction: z.ZodString;
+            model: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            assets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            runtime: z.ZodOptional<z.ZodEnum<{
+                shell: "shell";
+                node: "node";
+                python: "python";
+            }>>;
+            command: z.ZodString;
+            cwd: z.ZodOptional<z.ZodString>;
+            successExit: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+            capture: z.ZodOptional<z.ZodObject<{
+                stdout: z.ZodOptional<z.ZodString>;
+                stderr: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            kind: z.ZodLiteral<"function">;
+        }, z.core.$strict>, z.ZodObject<{
+            assets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            runtime: z.ZodOptional<z.ZodEnum<{
+                shell: "shell";
+                node: "node";
+                python: "python";
+            }>>;
+            command: z.ZodString;
+            cwd: z.ZodOptional<z.ZodString>;
+            successExit: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+            capture: z.ZodOptional<z.ZodObject<{
+                stdout: z.ZodOptional<z.ZodString>;
+                stderr: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            kind: z.ZodLiteral<"check">;
+            onFail: z.ZodDefault<z.ZodEnum<{
+                escalate: "escalate";
+                fail: "fail";
+            }>>;
+        }, z.core.$strict>, z.ZodObject<{
+            assets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            kind: z.ZodLiteral<"gate">;
+            prompt: z.ZodString;
+            schema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"text">;
+                multiline: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"choice">;
+                options: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+                multiple: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"form">;
+                fields: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    type: z.ZodEnum<{
+                        number: "number";
+                        boolean: "boolean";
+                        text: "text";
+                        file: "file";
+                        choice: "choice";
+                        textarea: "textarea";
+                        date: "date";
+                    }>;
+                    required: z.ZodOptional<z.ZodBoolean>;
+                    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        label: z.ZodString;
+                        description: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>>;
+                    accept: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"file">;
+                accept: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                maxSize: z.ZodOptional<z.ZodNumber>;
+                multiple: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>, z.ZodObject<{
+            assets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            kind: z.ZodLiteral<"router">;
+            routes: z.ZodArray<z.ZodObject<{
+                when: z.ZodString;
+                target: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>], "kind">;
+        contract: z.ZodOptional<z.ZodObject<{
+            requires: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                expr: z.ZodString;
+                message: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+            output: z.ZodOptional<z.ZodObject<{
+                fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+                artifacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    kind: z.ZodString;
+                    lifetime: z.ZodEnum<{
+                        session: "session";
+                        persistent: "persistent";
+                    }>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        gate: z.ZodOptional<z.ZodObject<{
+            approval: z.ZodEnum<{
+                none: "none";
+                optional: "optional";
+                mandatory: "mandatory";
+            }>;
+        }, z.core.$strict>>;
+        control: z.ZodOptional<z.ZodObject<{
+            optional: z.ZodOptional<z.ZodBoolean>;
+            retries: z.ZodOptional<z.ZodNumber>;
+            timeoutSec: z.ZodOptional<z.ZodNumber>;
+            parallelGroup: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    edges: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        source: z.ZodString;
+        target: z.ZodString;
+        type: z.ZodEnum<{
+            flow: "flow";
+            optional: "optional";
+            parallel: "parallel";
+        }>;
+    }, z.core.$strict>>;
+    meta: z.ZodOptional<z.ZodObject<{
+        icon: z.ZodOptional<z.ZodString>;
+        category: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        stage: z.ZodOptional<z.ZodString>;
+        onboarding: z.ZodOptional<z.ZodObject<{
+            input_style: z.ZodEnum<{
+                repo: "repo";
+                freeform: "freeform";
+                structured: "structured";
+            }>;
+            placeholder: z.ZodOptional<z.ZodString>;
+            fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** Validated authoring content that is strict, acyclic, and always schema version 2. */
+export type FlowDefinition = z.infer<typeof FlowDefinitionSchema>;
+/** Graph vertex whose execution identity comes only from its `run.kind`. */
+export type FlowNode = FlowDefinition["nodes"][number];
+/** Directed dependency link whose authored array position remains content-significant. */
+export type FlowEdge = FlowDefinition["edges"][number];
+/** Closed execution-owner declaration with no dispatch or conversation-mode switches. */
+export type FlowNodeRun = FlowNode["run"];
+/** Closed vocabulary of the six supported execution-owner identities. */
+export type FlowNodeKind = FlowNodeRun["kind"];
+/** Validation boundary applied to values entering a Flow run. */
+export type FlowInputContract = NonNullable<FlowDefinition["input"]>;
+/** Validation boundary applied to values leaving a Flow run. */
+export type FlowOutputContract = NonNullable<FlowDefinition["output"]>;
+/** Node admission and data contract; output typing is paid only when downstream consumers need it. */
+export type FlowNodeContract = NonNullable<FlowNode["contract"]>;
+/** Availability and failure policy that never changes execution ownership. */
+export type FlowNodeControl = NonNullable<FlowNode["control"]>;
+/** Named values resolved at the consumer boundary before admission. */
+export type FlowNodeBindings = NonNullable<FlowNode["contract"]>["input"];
+/** Bounded deterministic admission condition; arbitrary calls and property access are invalid. */
+export type FlowNodePrecondition = NonNullable<FlowNode["contract"]>["requires"] extends Array<infer T> | undefined ? T : never;
+/** Ordered router branch; the first matching condition owns the routing decision. */
+export type FlowRoute = Extract<FlowNodeRun, {
+    kind: "router";
+}>["routes"][number];
+/** Asset requirement independent of node identity and available on every run kind. */
+export type FlowAssetRef = NonNullable<FlowNodeRun["assets"]>[number];
+//# sourceMappingURL=schema.d.ts.map

package/dist/factory-assets/connectors/flow/contract/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../../factory-assets/connectors/flow/contract/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAyMzB,sFAAsF;AACtF,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAEzD;AA6CD,qFAAqF;AACrF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgL/B,CAAC;AAEH,wFAAwF;AACxF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,4EAA4E;AAC5E,MAAM,MAAM,QAAQ,GAAG,cAAc,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;AAEvD,0FAA0F;AAC1F,MAAM,MAAM,QAAQ,GAAG,cAAc,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;AAEvD,yFAAyF;AACzF,MAAM,MAAM,WAAW,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;AAE1C,yEAAyE;AACzE,MAAM,MAAM,YAAY,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC;AAE/C,iEAAiE;AACjE,MAAM,MAAM,iBAAiB,GAAG,WAAW,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC;AAErE,gEAAgE;AAChE,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,CAAC;AAEvE,sGAAsG;AACtG,MAAM,MAAM,gBAAgB,GAAG,WAAW,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC;AAEjE,8EAA8E;AAC9E,MAAM,MAAM,eAAe,GAAG,WAAW,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC;AAE/D,uEAAuE;AACvE,MAAM,MAAM,gBAAgB,GAAG,WAAW,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;AAE1E,kGAAkG;AAClG,MAAM,MAAM,oBAAoB,GAAG,WAAW,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,SAC5E,KAAK,CAAC,MAAM,CAAC,CAAC,GACd,SAAS,GACT,CAAC,GACD,KAAK,CAAC;AAEV,qFAAqF;AACrF,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC,WAAW,EAAE;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC;AAEnF,sFAAsF;AACtF,MAAM,MAAM,YAAY,GAAG,WAAW,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC"}

package/dist/factory-assets/connectors/flow/contract.d.ts

@@ -0,0 +1,2 @@
+// Auto-generated by _scripts/emit-dts-sidecars.ts — do not edit by hand.
+export * from "./contract/index.js";

package/dist/factory-assets/connectors/flow/contract.js

@@ -0,0 +1,5 @@
+export { FLOW_DEFINITION_JSON_SCHEMA_ID, canonicalizeFlowDefinition, generateFlowDefinitionJsonSchema, hashFlowDefinition } from '../../../chunk-SIF5F5SN.js';
+export { FLOW_EXPRESSION_LIMITS, FlowDefinitionSchema, FlowExpressionError, evaluate, evaluateFlowExpression, normalizeV1, parseFlowDefinition } from '../../../chunk-ZE2KEPE2.js';
+import '../../../chunk-NSBPE2FW.js';
+//# sourceMappingURL=contract.js.map
+//# sourceMappingURL=contract.js.map

package/dist/factory-assets/connectors/flow/contract.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"contract.js"}

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

@@ -22,7 +22,7 @@ import type { FlowDefinition, FlowState, NodeExecutionSnapshot, NodeStatus } fro
  * @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.
+ * @returns A {@link FlowState} describing every active agent 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;
@@ -48,7 +48,7 @@ export declare function computeFlowState(flow: FlowDefinition, completedIds: Set
  * @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,
+ * @returns A {@link FlowState} describing every active agent node,
  *   including interaction fields (`approval`, `input`, `output`, `error`) copied
  *   from the matching snapshot.
  * @docLink packages/flow-engine/concepts#compute-flow-state-from-snapshots
@@ -82,10 +82,10 @@ export declare function isBlocking(status: NodeStatus): boolean;
  * @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. Unlike {@link skillNodes}-based
+ *   were not already available before `justCompleted` finished. Unlike agent-node-filtered
  *   helpers, this walks raw edge targets and does not filter by node type — if a `group`,
  *   `sub-flow`, or `router` node is a direct successor, its ID can appear here. Callers that
- *   dispatch these IDs as runnable skill nodes are responsible for filtering non-`'skill'` IDs.
+ *   dispatch these IDs are responsible for filtering non-agent nodes.
  * @docLink packages/flow-engine/concepts#resolve-next-nodes
  */
 export declare function resolveNextNodes(flow: FlowDefinition, justCompleted: string, completedIds: Set<string>, skippedIds?: Set<string>): string[];

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

@@ -1 +1 @@
-{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../../../../factory-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;;;;;;;;;;;;;;;;;;GAkBG;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"}
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../../../../factory-assets/connectors/flow/engine/engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EAGd,SAAS,EACT,qBAAqB,EAErB,UAAU,EACX,MAAM,YAAY,CAAC;AAgCpB;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;;;;;;;;;;;;;;;GAkBG;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/factory-assets/connectors/flow/engine/flow-kind-provider.d.ts

@@ -8,7 +8,7 @@
  * Implements IAssetKindProvider with flow-specific:
  * - Discovery patterns: *.flow.yaml, *.flow.json
  * - Manifest validation via FlowManifestSchema
- * - Requires extraction: nodes[].data.skill / nodes[].data.flow references
+ * - Requires extraction: nodes[].run.assets plus legacy skill/sub-flow references
  * - File filter: just the manifest file (flows are single-file)
  */
 import type { IAssetKindProvider } from "@skaile/workspaces/plugins";

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../../../../factory-assets/connectors/flow/engine/loader.ts"],"names":[],"mappings":"AAIA,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,CActE"}
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../../../../factory-assets/connectors/flow/engine/loader.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc,CAYzD;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,CActE"}

package/dist/factory-assets/connectors/flow/engine/node-shape.d.ts

@@ -0,0 +1,20 @@
+import type { FlowDefinition, FlowNode } from "./types.js";
+/** Returns whether a node is executable by the currently active agent-turn runtime. */
+export declare function isAgentNode(node: FlowNode): boolean;
+/** Returns the node's optional policy across strict v2 and legacy definitions. */
+export declare function nodeIsOptional(node: FlowNode): boolean;
+/** Returns the node's mandatory approval policy across strict v2 and legacy definitions. */
+export declare function nodeRequiresApproval(node: FlowNode): boolean;
+/** Returns the first declared skill requirement without making it the node identity. */
+export declare function nodeSkillId(node: FlowNode): string;
+/** Returns the user-facing node label across strict v2 and legacy definitions. */
+export declare function nodeLabel(node: FlowNode): string;
+/** Returns strict v2 run assets or the equivalent legacy declarations. */
+export declare function nodeAssets(node: FlowNode): string[];
+/** Returns the binding values already supplied at the node boundary. */
+export declare function nodeBindings(node: FlowNode): Record<string, unknown>;
+/** Returns the first-class instruction for a strict v2 agent node. */
+export declare function nodeInstruction(node: FlowNode): string | undefined;
+/** Returns run-scoped defaults across strict v2 and legacy definitions. */
+export declare function flowDefaults(flow: FlowDefinition): Record<string, unknown>;
+//# sourceMappingURL=node-shape.d.ts.map

package/dist/factory-assets/connectors/flow/engine/node-shape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-shape.d.ts","sourceRoot":"","sources":["../../../../../factory-assets/connectors/flow/engine/node-shape.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3D,uFAAuF;AACvF,wBAAgB,WAAW,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAEnD;AAED,kFAAkF;AAClF,wBAAgB,cAAc,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAEtD;AAED,4FAA4F;AAC5F,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAE5D;AAED,wFAAwF;AACxF,wBAAgB,WAAW,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAIlD;AAED,kFAAkF;AAClF,wBAAgB,SAAS,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAEhD;AAED,0EAA0E;AAC1E,wBAAgB,UAAU,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,EAAE,CAOnD;AAED,wEAAwE;AACxE,wBAAgB,YAAY,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAGpE;AAED,sEAAsE;AACtE,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,SAAS,CAElE;AAED,2EAA2E;AAC3E,wBAAgB,YAAY,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAE1E"}