@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/console/assets/synergenius.svg

@@ -0,0 +1,18 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="-18.32 3.48 1062.21 1020.28">
+  <style>
+    g { fill: #0a0a09; }
+    @media (prefers-color-scheme: dark) { g { fill: #f0ede5; } }
+  </style>
+  <g>
+    <path d="M2.10743 843.628C2.10743 775.554 57.2926 720.368 125.367 720.368C193.441 720.368 248.626 775.554 248.626 843.628C248.626 911.702 193.441 966.887 125.367 966.887C57.2926 966.887 2.10743 911.702 2.10743 843.628Z"/>
+    <path d="M678.204 149.032C678.204 149.032 673.449 185.991 664.529 201.238C655.609 216.484 685.707 262.809 704.632 281.442C723.557 300.075 739.684 311.05 757.337 319.097C774.991 327.145 783.729 304.219 850.44 301.618L698.13 438.078C698.13 438.078 703.75 407.301 710.117 387.54C716.484 367.778 687.01 321.111 670.497 304.365C653.984 287.62 638.72 259.55 606.649 252.95C574.578 246.35 552.632 263.195 503.26 234.488C453.889 205.781 678.204 149.032 678.204 149.032Z"/>
+    <path d="M727.218 560.105C727.218 560.105 748.632 591.03 720.592 681.058C692.553 771.085 640.744 768.407 640.744 768.407C640.744 768.407 581.303 757.405 513.805 652.105C446.307 546.806 603.211 526.018 603.211 526.018C603.211 526.018 687.953 511.488 719.375 544.053C750.796 576.618 705.356 416.102 705.356 416.102C705.356 416.102 688.493 476.33 607.644 484.633C526.795 492.937 495.676 467.236 495.676 467.236L383.322 675.786C383.322 675.786 411.448 681.897 440.393 676.471C469.338 671.045 546.959 751.593 546.959 751.593C546.959 751.593 592.227 812.951 588.237 825.929C584.246 838.906 573.852 866.459 579.652 881.642C585.451 896.824 762.91 792.623 762.91 792.623C762.91 792.623 754.172 779.285 744.663 775.655C735.155 772.025 724.457 739.148 751.585 699.439C778.714 659.729 798.427 630.702 830.383 631.16C862.339 631.618 903.829 627.047 929.684 614.108C955.538 601.169 727.218 560.105 727.218 560.105Z"/>
+    <path d="M576.078 885.982C576.078 821.175 628.614 768.638 693.422 768.638C758.229 768.638 810.766 821.175 810.766 885.982C810.766 950.789 758.229 1003.33 693.422 1003.33C628.614 1003.33 576.078 950.789 576.078 885.982Z"/>
+    <path d="M353.35 673.11C353.35 673.11 310.615 658.396 264.425 712.583C243.666 736.937 237.54 748.253 235.339 759.769C233.677 768.46 233.714 766.453 242.555 810.805C255.983 878.162 136.022 758.647 114.808 722.446C110.651 715.351 164.458 725.475 164.458 725.475C164.458 725.475 189.691 724.474 227.104 688.058C264.517 651.642 264.455 613.818 261.072 598.339C257.689 582.86 353.35 673.11 353.35 673.11Z"/>
+    <path d="M230.417 207.977C230.417 207.977 226.834 230.493 217.377 248.484C207.92 266.475 246.002 321.019 259.067 338.109C272.132 355.199 309.927 398.137 332.628 400.183C355.328 402.23 393.582 389.25 435.573 408.585C477.563 427.921 356.371 468.984 356.371 468.984L249.225 513.799C249.225 513.799 256.736 476.984 267.111 459.376C277.486 441.769 273.365 435.194 266.403 423.867C259.442 412.541 195.065 305.024 163.816 296.527C132.566 288.029 83.1783 298.163 52.2048 250.522C21.2314 202.882 230.417 207.977 230.417 207.977Z"/>
+    <path d="M246.615 538.011C246.615 461.312 308.792 399.135 385.49 399.135C462.189 399.135 524.366 461.312 524.366 538.011C524.366 614.709 462.189 676.886 385.49 676.886C308.792 676.886 246.615 614.709 246.615 538.011Z"/>
+    <path d="M695.026 464.996C695.026 374.302 768.548 300.781 859.241 300.781C949.935 300.781 1023.46 374.302 1023.46 464.996C1023.46 555.689 949.935 629.211 859.241 629.211C768.548 629.211 695.026 555.689 695.026 464.996Z"/>
+    <path d="M451.685 138.003C451.685 74.9885 502.768 23.9049 565.783 23.9049C628.798 23.9049 679.881 74.9885 679.881 138.003C679.881 201.018 628.798 252.101 565.783 252.101C502.768 252.101 451.685 201.018 451.685 138.003Z"/>
+    <path d="M33.2846 192.042C33.2846 137.22 77.7266 92.7781 132.549 92.7781C187.371 92.7781 231.813 137.22 231.813 192.042C231.813 246.864 187.371 291.306 132.549 291.306C77.7266 291.306 33.2846 246.864 33.2846 192.042Z"/>
+  </g>
+</svg>

package/dist/console/author.d.ts

@@ -0,0 +1,32 @@
+import type { TMarketplaceManifest, TValidationIssue } from '../marketplace/types.js';
+import { type PackView } from './packs.js';
+export interface PackProject {
+    isPack: boolean;
+    name?: string;
+    version?: string;
+}
+/**
+ * Whether a directory is a pack: it has a manifest, or its package.json
+ * carries the marketplace keyword. The name convention is a last resort,
+ * for a pack begun by hand that has neither yet.
+ */
+export declare function detectPackProject(projectDir: string): PackProject;
+export interface PackCheck {
+    name: string;
+    version: string;
+    parsedFiles: number;
+    parseErrors: string[];
+    valid: boolean;
+    issues: TValidationIssue[];
+    /** The manifest as it would be written, read the way an installed pack is. */
+    manifest: PackView;
+    /** Whether `flowweaver.manifest.json` exists yet. */
+    hasManifest: boolean;
+    /** What writing it would change, in words. Empty when it is up to date. */
+    changes: string[];
+}
+/** What differs between the committed manifest and the generated one, as sentences. */
+export declare function manifestChanges(existing: TMarketplaceManifest | null, next: TMarketplaceManifest): string[];
+/** Generate, validate and compare, as `fw market pack` would, without writing. */
+export declare function checkPackProject(projectDir: string): Promise<PackCheck>;
+//# sourceMappingURL=author.d.ts.map

package/dist/console/cli-catalog.d.ts

@@ -0,0 +1,21 @@
+export interface CliFlag {
+    flag: string;
+    description: string;
+    default: string;
+}
+export interface CliCommand {
+    /** As the heading names it: `compile`, `create workflow`, `market list`. */
+    name: string;
+    /** The words after `fw` that select it, from the usage line. */
+    words: string[];
+    group: string;
+    description: string;
+    usage: string;
+    flags: CliFlag[];
+    examples: string[];
+}
+/** Parse the reference's markdown into commands. Exposed for tests. Use {@link cliCatalog} otherwise. */
+export declare function parseCliReference(markdown: string): CliCommand[];
+/** The commands, parsed once per process. */
+export declare function cliCatalog(): CliCommand[];
+//# sourceMappingURL=cli-catalog.d.ts.map

package/dist/console/cli-run.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Running an `fw` command for the console.
+ *
+ * The console is a local tool driving a local CLI, and the person at it
+ * could open a terminal and type the same thing. What this must not become
+ * is a shell: the command is an argument list handed to this very install
+ * of the CLI, never a string handed to `sh`, so quoting means what the
+ * person meant on Windows and elsewhere alike.
+ */
+import { type ChildProcess } from 'node:child_process';
+/**
+ * Commands that do not belong in a page: they run until stopped, or start
+ * the very thing that is already running.
+ */
+export declare const NOT_FROM_CONSOLE: Set<string>;
+export type Plan = {
+    ok: true;
+    args: string[];
+} | {
+    ok: false;
+    error: string;
+};
+/** Check an argument list before anything is spawned. A leading `fw` is accepted and dropped. */
+export declare function planFwCommand(argv: readonly string[]): Plan;
+/**
+ * How to start this install's CLI: the built entry beside this module in a
+ * package, or the TypeScript entry through `tsx` in a source checkout.
+ */
+export declare function resolveCliEntry(here?: string): {
+    exec: string;
+    prefix: string[];
+};
+/** Start `fw <args>` in the project, output uncoloured. The caller streams stdout/stderr and may kill it. */
+export declare function spawnFw(args: string[], cwd: string): ChildProcess;
+//# sourceMappingURL=cli-run.d.ts.map

package/dist/console/cli-run.js

@@ -0,0 +1,46 @@
+// src/console/cli-run.ts
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+var NOT_FROM_CONSOLE = /* @__PURE__ */ new Set([
+  "console",
+  "mcp-server",
+  "mcp-setup",
+  "dev",
+  "watch",
+  "serve"
+]);
+function planFwCommand(argv) {
+  const args = argv[0] === "fw" || argv[0] === "flow-weaver" ? argv.slice(1) : [...argv];
+  if (!args.length) return { ok: false, error: "nothing to run" };
+  if (args.some((a) => typeof a !== "string")) return { ok: false, error: "arguments must be strings" };
+  const command = args[0];
+  if (NOT_FROM_CONSOLE.has(command)) {
+    return { ok: false, error: `\`fw ${command}\` runs outside the console: it is long-lived. Use a terminal.` };
+  }
+  return { ok: true, args };
+}
+function resolveCliEntry(here = path.dirname(fileURLToPath(import.meta.url))) {
+  const built = path.join(here, "..", "cli", "flow-weaver.mjs");
+  if (fs.existsSync(built)) return { exec: process.execPath, prefix: [built] };
+  const source = path.join(here, "..", "cli", "index.ts");
+  if (fs.existsSync(source)) return { exec: process.execPath, prefix: ["--import", "tsx", source] };
+  throw new Error("cannot find the fw CLI beside the console");
+}
+function spawnFw(args, cwd) {
+  const { exec, prefix } = resolveCliEntry();
+  const { NODE_OPTIONS: _flags, ...env } = process.env;
+  return spawn(exec, [...prefix, ...args], {
+    cwd,
+    env: { ...env, FORCE_COLOR: "0", NO_COLOR: "1" },
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true
+  });
+}
+export {
+  NOT_FROM_CONSOLE,
+  planFwCommand,
+  resolveCliEntry,
+  spawnFw
+};

package/dist/console/debug.d.ts

@@ -0,0 +1,67 @@
+import { type ExecutionTraceEvent } from '../mcp/workflow-executor.js';
+import type { FwMockConfig } from '../built-in-nodes/mock-types.js';
+export type DebugStatus = 'running' | 'paused' | 'completed' | 'failed' | 'aborted' | 'yielded';
+/** A session as the console shows it. */
+export interface DebugView {
+    id: string;
+    file: string;
+    name: string;
+    params: Record<string, unknown>;
+    status: DebugStatus;
+    startedAt: number;
+    updatedAt: number;
+    /** While paused: the node, and whether it is about to run or has just run. */
+    node?: string;
+    phase?: 'before' | 'after';
+    /** How many nodes have completed, out of the execution order. */
+    position: number;
+    order: string[];
+    breakpoints: string[];
+    /** The latest value of every port produced so far, as `node.port`. */
+    values: Record<string, unknown>;
+    result?: unknown;
+    error?: string;
+}
+export interface DebugStartOptions {
+    /** The session's id, when the caller needs it before the first pause. */
+    id?: string;
+    file: string;
+    name: string;
+    params?: Record<string, unknown>;
+    breakpoints?: string[];
+    mocks?: FwMockConfig;
+    /** Every trace event as it happens, as for any other run. */
+    onEvent?: (event: ExecutionTraceEvent) => void;
+    /** Called whenever the session's status changes. */
+    onChange?: (view: DebugView) => void;
+}
+/** `node:port:index` keys to the latest value per `node.port`. */
+export declare function latestValues(variables: Record<string, unknown>): Record<string, unknown>;
+export declare class DebugSessions {
+    private readonly sessions;
+    get(id: string): DebugView | undefined;
+    list(): DebugView[];
+    /**
+     * Start a session. Resolves at the first pause, or when the run ends
+     * without one. The session is listed from the moment this is called, so
+     * a caller that answers with the id before the pause can show it.
+     */
+    start(options: DebugStartOptions): Promise<DebugView>;
+    /** Run the next node and pause again. */
+    step(id: string): Promise<DebugView>;
+    /** Run to the end, or to the next breakpoint. */
+    continue(id: string, toBreakpoint?: boolean): Promise<DebugView>;
+    /** Stop the session, paused or not. */
+    abort(id: string): Promise<DebugView>;
+    /**
+     * Change a value a node produced. Takes effect before the next node runs,
+     * which is how a branch is forced or a bad value patched without a rerun.
+     */
+    setVariable(id: string, node: string, port: string, value: unknown): DebugView;
+    breakpoint(id: string, action: 'add' | 'remove', node: string): DebugView;
+    private need;
+    private act;
+    /** Wait for the next pause or the end, and record which it was. */
+    private settle;
+}
+//# sourceMappingURL=debug.d.ts.map

package/dist/console/diff-view.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Two versions of a workflow as one picture with the changes marked on it.
+ *
+ * The semantic differ says what changed. This turns that into what the
+ * console draws. The two versions are merged into a union -- every step
+ * and control edge from either -- and laid out once, so a removed step
+ * keeps the place it had and an added one sits where it now runs. Rows and
+ * edges are then marked added, removed or changed, and the same facts are
+ * listed for the Changes pane: steps, wiring, contract, and the differ's
+ * verdict in words.
+ */
+import type { TWorkflowAST } from '../ast/types.js';
+import type { TImpactLevel } from '../diff/types.js';
+import { type ProcessModel } from '../diagram/process-view.js';
+export type Change = 'added' | 'removed' | 'changed';
+export interface DiffStep {
+    id: string;
+    label: string;
+    change: Change;
+    detail: string;
+}
+export interface DiffWire {
+    change: 'added' | 'removed';
+    from: string;
+    to: string;
+    fromPort: string;
+    toPort: string;
+    kind: 'ok' | 'fail' | 'data';
+    label: string;
+}
+export interface DiffPort {
+    side: 'in' | 'out';
+    name: string;
+    change: Change;
+    detail: string;
+}
+export interface DiffMarks {
+    added: string[];
+    removed: string[];
+    changed: string[];
+    edgesAdded: Array<[string, string]>;
+    edgesRemoved: Array<[string, string]>;
+}
+/** What a row and its tile need to draw a step that no longer exists in the file. */
+export interface DiffNode {
+    id: string;
+    type: string;
+    label: string;
+    description: string;
+    builtin: boolean;
+    color: string | null;
+    icon: string | null;
+    pull: boolean;
+    gate: 'approval' | 'input' | 'agent' | 'timer' | null;
+    expression: boolean;
+    durablePure: boolean;
+    effect: boolean;
+    async: boolean;
+    inputs: Array<{
+        name: string;
+        tsType: string;
+        optional: boolean;
+        description: string;
+    }>;
+    outputs: Array<{
+        name: string;
+        tsType: string;
+        optional: boolean;
+        description: string;
+    }>;
+    source: string;
+    file: string;
+    line: number | null;
+    outputSchema: null;
+    expr: Array<{
+        port: string;
+        expr: string;
+    }>;
+    pack: null;
+    deploy: null;
+}
+export interface DiffView {
+    identical: boolean;
+    impact: TImpactLevel;
+    reasons: string[];
+    steps: DiffStep[];
+    wiring: DiffWire[];
+    contract: DiffPort[];
+    marks: DiffMarks;
+    /** The union of both versions as a process, or null when the two cannot be laid out together. */
+    model: ProcessModel | null;
+    /** Steps that exist only in the older version, so their rows can still be drawn. */
+    nodes: Record<string, DiffNode>;
+}
+export declare function buildDiffView(before: TWorkflowAST, after: TWorkflowAST): DiffView;
+//# sourceMappingURL=diff-view.d.ts.map

package/dist/console/export.d.ts

@@ -0,0 +1,36 @@
+import type { DeployInstructions, DeploySchema } from '../deployment/targets/base.js';
+export interface TargetView {
+    name: string;
+    description: string;
+    /** The pack that provides it, when it can be told. */
+    pack: string | null;
+    /** The `@deploy` keys the target reads on a workflow. */
+    deploySchema: DeploySchema | null;
+}
+export interface ExportRequest {
+    file: string;
+    name: string;
+    target: string;
+    /** Where the files go. Defaults to `dist/<target>` beside the file. */
+    outputDir?: string;
+    /** Generate without writing. */
+    preview: boolean;
+}
+export interface ExportOutcome {
+    target: string;
+    outputDir: string;
+    written: boolean;
+    files: Array<{
+        path: string;
+        content: string;
+    }>;
+    warnings: string[];
+    instructions: DeployInstructions | null;
+}
+/** Where an export lands unless told otherwise. */
+export declare const defaultOutputDir: (file: string, target: string) => string;
+/** The targets the project's packs provide. */
+export declare function listTargets(projectDir: string): Promise<TargetView[]>;
+/** Run one export. Throws with the target's or the parser's own message. */
+export declare function runExport(projectDir: string, req: ExportRequest): Promise<ExportOutcome>;
+//# sourceMappingURL=export.d.ts.map

package/dist/console/git.d.ts

@@ -0,0 +1,27 @@
+export interface Commit {
+    sha: string;
+    short: string;
+    author: string;
+    at: number;
+    subject: string;
+}
+export interface FileHistory {
+    /** False when the file is not in a git repository, or git is not installed. */
+    repo: boolean;
+    head?: string;
+    /** The file differs from HEAD in the working tree. */
+    dirty: boolean;
+    /** Newest first, following renames. */
+    commits: Commit[];
+}
+/** The repository root a file belongs to, or undefined. */
+export declare function repoRoot(file: string): Promise<string | undefined>;
+export declare function fileHistory(file: string, limit?: number): Promise<FileHistory>;
+/** The file's text at a ref, or undefined when it did not exist there. */
+export declare function fileAt(file: string, ref: string): Promise<string | undefined>;
+/** The short sha HEAD points at, and whether the file has uncommitted changes -- what a run is stamped with. */
+export declare function stamp(file: string): Promise<{
+    commit?: string;
+    dirty?: boolean;
+} | undefined>;
+//# sourceMappingURL=git.d.ts.map

package/dist/console/index.d.ts

@@ -0,0 +1,4 @@
+export { createConsoleServer, stepLabel, type ConsoleServer, type ConsoleServerOptions } from './server.js';
+export { scanWorkflows, type WorkflowSummary } from './scan.js';
+export { workflowParamsSchema, nodeOutputSchema, nodeInputSchema, type FieldSchema } from './schema.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/console/index.html

@@ -0,0 +1,16 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Flow Weaver</title>
+<link rel="icon" type="image/svg+xml" href="/synergenius.svg">
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Material+Symbols+Outlined:opsz,wght,FILL,GRAD@20,500,0,0&display=block">
+<link rel="stylesheet" href="/styles.css">
+</head>
+<body>
+<div id="app"></div>
+<script type="module" src="/app.js"></script>
+</body>
+</html>

package/dist/console/index.js

@@ -0,0 +1,203 @@
+import {
+  nodeInputSchema,
+  nodeOutputSchema,
+  workflowParamsSchema
+} from "../chunks/chunk-OZQAW5ZG.js";
+import {
+  validateWorkflow
+} from "../chunks/chunk-P44RIZ7C.js";
+import {
+  listInstalledPackages
+} from "../chunks/chunk-ZKEGXO73.js";
+import "../chunks/chunk-A5MBOFVY.js";
+import {
+  getAvailableWorkflows
+} from "../chunks/chunk-YSPBPZDV.js";
+import "../chunks/chunk-VQ7H33J4.js";
+import "../chunks/chunk-NQNLUAPO.js";
+import {
+  parseWorkflow
+} from "../chunks/chunk-INDEVYEC.js";
+import "../chunks/chunk-KU3CLJI2.js";
+import "../chunks/chunk-QDE4Z7KW.js";
+import "../chunks/chunk-XAV22WD7.js";
+import "../chunks/chunk-P2CVDGHR.js";
+import "../chunks/chunk-ZMGN6F3S.js";
+import "../chunks/chunk-REEYC73I.js";
+import "../chunks/chunk-4EUSHAY6.js";
+import "../chunks/chunk-4KDUEOFD.js";
+import "../chunks/chunk-DUO6H5PR.js";
+import "../chunks/chunk-VP2P3BPA.js";
+import "../chunks/chunk-B6HQ6YS5.js";
+import "../chunks/chunk-E5WN7IGO.js";
+import "../chunks/chunk-KMWCCOUJ.js";
+import "../chunks/chunk-QYPORSLO.js";
+import "../chunks/chunk-R4QGNK34.js";
+import "../chunks/chunk-SEWDMQ6Q.js";
+
+// src/console/index.ts
+import { createConsoleServer, stepLabel } from "./server.js";
+
+// src/console/scan.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+// src/console/packs.ts
+var posix = (p) => p.replace(/\\/g, "/").replace(/\/+$/, "");
+function packForFile(file, packs) {
+  const f = posix(file);
+  let best = null;
+  for (const p of packs) {
+    const root = posix(p.path);
+    if ((f === root || f.startsWith(`${root}/`)) && (!best || root.length > posix(best.path).length)) best = p;
+  }
+  return best?.name ?? null;
+}
+function packageOfSpecifier(specifier) {
+  const parts = specifier.split("/");
+  if (!parts[0] || parts[0].startsWith(".")) return null;
+  return parts[0].startsWith("@") ? parts[1] ? `${parts[0]}/${parts[1]}` : null : parts[0];
+}
+function packForSpecifier(specifier, packs) {
+  const name = specifier ? packageOfSpecifier(specifier) : null;
+  return name && packs.some((p) => p.name === name) ? name : null;
+}
+var refsCache = /* @__PURE__ */ new Map();
+async function installedRefs(projectDir) {
+  const hit = refsCache.get(projectDir);
+  if (hit && Date.now() - hit.at < 2e3) return hit.refs;
+  const refs = (await listInstalledPackages(projectDir)).map((p) => ({ name: p.name, path: p.path }));
+  refsCache.set(projectDir, { at: Date.now(), refs });
+  return refs;
+}
+
+// src/console/scan.ts
+var SKIP = /* @__PURE__ */ new Set(["node_modules", "dist", ".git", ".fw", "coverage"]);
+var toPosix = (p) => p.split(path.sep).join("/");
+function walk(dir, out) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (SKIP.has(entry.name) || entry.name.startsWith(".")) continue;
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) walk(full, out);
+    else if (entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts") && !entry.name.startsWith(".fw-diff-")) out.push(full);
+  }
+}
+function listOne(file, projectDir, mtimeMs) {
+  let text;
+  try {
+    text = fs.readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+  if (!text.includes("@flowWeaver workflow")) return null;
+  const names = getAvailableWorkflows(text).map((w) => w.functionName).filter(Boolean);
+  return names.length ? { file, rel: toPosix(path.relative(projectDir, file)), names, mtimeMs } : null;
+}
+var checked = /* @__PURE__ */ new Map();
+var listings = /* @__PURE__ */ new Map();
+function listCached(projectDir) {
+  const key = path.resolve(projectDir);
+  const files = [];
+  walk(key, files);
+  const stats = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    try {
+      stats.set(file, fs.statSync(file).mtimeMs);
+    } catch {
+    }
+  }
+  const signature = [...stats].map(([f, m]) => `${f}:${m}`).join("|");
+  const hit = listings.get(key);
+  if (hit && hit.signature === signature) return [...hit.byFile.values()];
+  const byFile = /* @__PURE__ */ new Map();
+  for (const [file, mtimeMs] of stats) {
+    const previous = hit?.byFile.get(file);
+    if (previous && previous.mtimeMs === mtimeMs) {
+      byFile.set(file, previous);
+      continue;
+    }
+    const listed = listOne(file, key, mtimeMs);
+    if (listed) byFile.set(file, listed);
+  }
+  listings.set(key, { byFile, signature });
+  return [...byFile.values()];
+}
+async function check(entry, name, packs) {
+  const base = {
+    file: entry.file,
+    rel: entry.rel,
+    name,
+    steps: 0,
+    gates: 0,
+    errors: 0,
+    warnings: 0,
+    checked: true,
+    codes: [],
+    uses: []
+  };
+  try {
+    const parsed = await parseWorkflow(entry.file, { workflowName: name, projectDir: path.dirname(entry.file) });
+    if (parsed.errors.length || !parsed.ast) return { ...base, errors: Math.max(1, parsed.errors.length) };
+    const ast = parsed.ast;
+    const v = validateWorkflow(ast);
+    const uses = /* @__PURE__ */ new Set();
+    let gates = 0;
+    for (const i of ast.instances) {
+      const nt = ast.nodeTypes.find((n) => n.name === i.nodeType) ?? ast.nodeTypes.find((n) => n.functionName === i.nodeType);
+      if (nt?.durableGate !== void 0) {
+        gates++;
+        uses.add(`gate:${nt.durableGate}`);
+      }
+      if (nt && !nt.functionText) uses.add(`builtin:${nt.functionName}`);
+      const pack = (nt?.sourceLocation?.file ? packForFile(nt.sourceLocation.file, packs) : null) ?? packForSpecifier(nt?.importSource, packs);
+      if (pack) uses.add(`pack:${pack}`);
+      if (nt?.durableEffect) uses.add("effect");
+      if (nt?.durablePure) uses.add("pure");
+      if (nt?.expression) uses.add("expression");
+      if (i.config?.pullExecution !== void 0) uses.add("pull");
+      if (i.config?.portConfigs?.some((c) => c.expression)) uses.add("expr");
+    }
+    if (Object.keys(ast.scopes ?? {}).length) uses.add("scope");
+    const codes = [...new Set([...v.errors, ...v.warnings].map((e) => e.code))];
+    return { ...base, steps: ast.instances.length, gates, errors: v.errors.length, warnings: v.warnings.length, codes, uses: [...uses] };
+  } catch {
+    return { ...base, errors: 1 };
+  }
+}
+var sortSummaries = (rows) => rows.sort((a, b) => a.rel.localeCompare(b.rel) || a.name.localeCompare(b.name));
+async function checkWorkflows(projectDir, onChecked) {
+  const rows = [];
+  const packs = await installedRefs(projectDir);
+  for (const entry of listCached(projectDir)) {
+    for (const name of entry.names) {
+      const key = `${entry.file}|${name}`;
+      const hit = checked.get(key);
+      if (hit && hit.mtimeMs === entry.mtimeMs) {
+        rows.push(hit.summary);
+        continue;
+      }
+      const summary = await check(entry, name, packs);
+      checked.set(key, { mtimeMs: entry.mtimeMs, summary });
+      rows.push(summary);
+      onChecked?.(summary);
+    }
+  }
+  return sortSummaries(rows);
+}
+async function scanWorkflows(projectDir) {
+  return checkWorkflows(projectDir);
+}
+export {
+  createConsoleServer,
+  nodeInputSchema,
+  nodeOutputSchema,
+  scanWorkflows,
+  stepLabel,
+  workflowParamsSchema
+};