@tscomfy/codegen 0.0.0-stage → 0.1.0

package/dist/rules.js

@@ -0,0 +1,82 @@
+// Input rules the generated types are written with (docs/plan.md §6.2, §7.2), shared by the type
+// emitter, which writes them, and the transpiler, which must decide by the same rules whether
+// the types can express a node.
+import { sendsInputValue } from "@tscomfy/core";
+/**
+ * Whether a property named `name` must be required: TypeScript checks an optional property
+ * against the `Object` member of that name, which every object literal has.
+ */
+export function isObjectMember(name) {
+    return OBJECT_MEMBERS.has(name);
+}
+/** Members of TypeScript's `Object` interface, which every object type has. */
+const OBJECT_MEMBERS = new Set([
+    "constructor",
+    "toString",
+    "toLocaleString",
+    "valueOf",
+    "hasOwnProperty",
+    "isPrototypeOf",
+    "propertyIsEnumerable",
+]);
+/**
+ * The field a DynamicGroup row's type requires beyond the required ones (§7.2): a row is counted
+ * only when one of its keys is sent, so when no field is required or has a default, the first
+ * one must be given, or `{}` would send no row at all.
+ */
+export function forcedRowField(fields) {
+    const sendable = fields.filter(sendsInputValue);
+    return sendable.some((field) => isRequired(field) || hasDefault(field)) ? undefined : sendable[0];
+}
+/**
+ * Whether an input must be given: the backend requires it and no default fills it in.
+ * Autogrow and DynamicGroup are required by their minimum alone: the backend enforces it even
+ * when the input itself is optional. An input named after a member of `Object` is always
+ * required: TypeScript checks an optional property against the member every object literal
+ * has (`constructor: Function`), so leaving it out would fail to compile.
+ */
+export function isRequired(input) {
+    if (isObjectMember(input.name))
+        return true;
+    switch (input.kind) {
+        case "autogrow":
+            return input.template.required && input.min > 0 && input.slots.length > 0;
+        case "dynamicGroup":
+            return input.min > 0;
+        case "combo":
+            // A forceInput combo has no widget, so nothing fills its default in.
+            return input.required && (input.default === undefined || input.forceInput === true);
+        case "int":
+        case "float":
+        case "string":
+        case "boolean":
+        case "value":
+            return input.required && input.default === undefined;
+        case "socket":
+        case "dynamicCombo":
+        case "matchType":
+        case "unknown":
+            return input.required;
+    }
+}
+/** Whether the exporter sends a value for the input when none is given. */
+export function hasDefault(input) {
+    switch (input.kind) {
+        case "combo":
+            return input.default !== undefined && input.forceInput !== true;
+        case "int":
+        case "float":
+        case "string":
+        case "boolean":
+        case "value":
+            return input.default !== undefined;
+        case "socket":
+        case "autogrow":
+        case "dynamicCombo":
+        case "dynamicGroup":
+        case "matchType":
+        case "unknown":
+            return false;
+    }
+}
+//# sourceMappingURL=rules.js.map

package/dist/rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.js","sourceRoot":"","sources":["../src/rules.ts"],"names":[],"mappings":"AAAA,iGAAiG;AACjG,8FAA8F;AAC9F,gCAAgC;AAEhC,OAAO,EAAiB,eAAe,EAAE,MAAM,eAAe,CAAC;AAE/D;;;GAGG;AACH,MAAM,UAAU,cAAc,CAAC,IAAY;IACzC,OAAO,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AAClC,CAAC;AAED,+EAA+E;AAC/E,MAAM,cAAc,GAAwB,IAAI,GAAG,CAAC;IAClD,aAAa;IACb,UAAU;IACV,gBAAgB;IAChB,SAAS;IACT,gBAAgB;IAChB,eAAe;IACf,sBAAsB;CACvB,CAAC,CAAC;AAEH;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,MAA2B;IACxD,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;IAChD,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;AACpG,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,UAAU,CAAC,KAAe;IACxC,IAAI,cAAc,CAAC,KAAK,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IAC5C,QAAQ,KAAK,CAAC,IAAI,EAAE,CAAC;QACnB,KAAK,UAAU;YACb,OAAO,KAAK,CAAC,QAAQ,CAAC,QAAQ,IAAI,KAAK,CAAC,GAAG,GAAG,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;QAC5E,KAAK,cAAc;YACjB,OAAO,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC;QACvB,KAAK,OAAO;YACV,qEAAqE;YACrE,OAAO,KAAK,CAAC,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,KAAK,SAAS,IAAI,KAAK,CAAC,UAAU,KAAK,IAAI,CAAC,CAAC;QACtF,KAAK,KAAK,CAAC;QACX,KAAK,OAAO,CAAC;QACb,KAAK,QAAQ,CAAC;QACd,KAAK,SAAS,CAAC;QACf,KAAK,OAAO;YACV,OAAO,KAAK,CAAC,QAAQ,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS,CAAC;QACvD,KAAK,QAAQ,CAAC;QACd,KAAK,cAAc,CAAC;QACpB,KAAK,WAAW,CAAC;QACjB,KAAK,SAAS;YACZ,OAAO,KAAK,CAAC,QAAQ,CAAC;IAC1B,CAAC;AACH,CAAC;AAED,2EAA2E;AAC3E,MAAM,UAAU,UAAU,CAAC,KAAe;IACxC,QAAQ,KAAK,CAAC,IAAI,EAAE,CAAC;QACnB,KAAK,OAAO;YACV,OAAO,KAAK,CAAC,OAAO,KAAK,SAAS,IAAI,KAAK,CAAC,UAAU,KAAK,IAAI,CAAC;QAClE,KAAK,KAAK,CAAC;QACX,KAAK,OAAO,CAAC;QACb,KAAK,QAAQ,CAAC;QACd,KAAK,SAAS,CAAC;QACf,KAAK,OAAO;YACV,OAAO,KAAK,CAAC,OAAO,KAAK,SAAS,CAAC;QACrC,KAAK,QAAQ,CAAC;QACd,KAAK,UAAU,CAAC;QAChB,KAAK,cAAc,CAAC;QACpB,KAAK,cAAc,CAAC;QACpB,KAAK,WAAW,CAAC;QACjB,KAAK,SAAS;YACZ,OAAO,KAAK,CAAC;IACjB,CAAC;AACH,CAAC"}

package/dist/transpile.d.ts

@@ -0,0 +1,40 @@
+import { type Diagnostic, type Workflow } from "@tscomfy/core";
+/** Options for {@link transpile}. */
+export interface TranspileOptions {
+    /** The exported constant holding the workflow, e.g. `txt2img`. */
+    readonly name: string;
+    /** Where the generated schema is imported from, e.g. `./comfy/local/index.js`. */
+    readonly schemaModule: string;
+    /** The schema module's export, e.g. `local`. */
+    readonly schemaName: string;
+    /** Inline a node used once into its use, unless that node inlines another. Default `true`. */
+    readonly inline?: boolean;
+    /** Extra header lines, e.g. the command that transpiled the file. */
+    readonly header?: readonly string[];
+}
+/** What {@link transpile} returns. */
+export interface TranspileResult {
+    /** The module source, formatted as oxfmt formats it. */
+    readonly code: string;
+    readonly diagnostics: readonly Diagnostic[];
+}
+/**
+ * Builder code for `workflow`: an ES module exporting the workflow, built with
+ * the generated types over `options.schemaName`. Nodes keep their ids and titles and come in
+ * dependency order; inputs equal to their default are left out, since the exporter fills them
+ * in. Running it and exporting gives the same prompt as `toApi(workflow)`, except that ids that
+ * aren't integers (`40:31`) come in dependency order, where the workflow lists one before a node
+ * it depends on. Pure and deterministic.
+ *
+ * Reports `W_TRANSPILED_AS_RAW` for a node the types can't express, which is written as
+ * `raw(…)`, and `E_DEPENDENCY_CYCLE` and `E_DANGLING_LINK` for what no program can build: those
+ * nodes, or links, are left out.
+ */
+export declare function transpile(workflow: Workflow, options: TranspileOptions): TranspileResult;
+/**
+ * Why {@link transpile} refuses these names, or `undefined` when it takes them: each must pass
+ * `exportNameProblem`, they must differ, and the declaration
+ * `export const <name>: Workflow<NodesOf<typeof <schemaName>>> =` must fit on one line.
+ */
+export declare function transpileNameProblem(options: Pick<TranspileOptions, "name" | "schemaName">): string | undefined;
+//# sourceMappingURL=transpile.d.ts.map

package/dist/transpile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transpile.d.ts","sourceRoot":"","sources":["../src/transpile.ts"],"names":[],"mappings":"AAQA,OAAO,EAEL,KAAK,UAAU,EAUf,KAAK,QAAQ,EACd,MAAM,eAAe,CAAC;AA2BvB,qCAAqC;AACrC,MAAM,WAAW,gBAAgB;IAC/B,kEAAkE;IAClE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,kFAAkF;IAClF,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,gDAAgD;IAChD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,8FAA8F;IAC9F,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,qEAAqE;IACrE,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACrC;AAED,sCAAsC;AACtC,MAAM,WAAW,eAAe;IAC9B,wDAAwD;IACxD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,SAAS,UAAU,EAAE,CAAC;CAC7C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,gBAAgB,GAAG,eAAe,CAIxF;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,IAAI,CAAC,gBAAgB,EAAE,MAAM,GAAG,YAAY,CAAC,GACrD,MAAM,GAAG,SAAS,CAiBpB"}

package/dist/transpile.js

@@ -0,0 +1,531 @@
+// Workflow → TypeScript (docs/plan.md §10): the builder code that rebuilds a workflow over the
+// generated types. Nodes the types can express become `n.Class(…)` calls; the rest become
+// `raw(…)` with their wire keys, so the program always rebuilds the same prompt.
+//
+// Whether the types can express a node is decided by the same rules `emit-types.ts` writes the
+// types with (`typing.ts`, §6.2, §6.3), so the output compiles: a test type-checks it for every
+// mock and for the corpus. The layout is oxfmt's (`expressions.ts`).
+import { createDiagnostic, exportApi, isOutputRef, stringify, } from "@tscomfy/core";
+import { hardline, indent, join, print, PRINT_WIDTH, textWidth } from "./doc.js";
+import { exportNameProblem, isExportName, TRANSPILED_MODULE_NAMES } from "./export-name.js";
+import { arrayDoc, breaksArray, callDoc, declarationDoc, declarationLayout, declarationLeft, isNumberList, jsonDoc, numbersDoc, objectDoc, objectKey, propertyDoc, scalarDoc, STATEMENT_INDENT, statementDoc, } from "./expressions.js";
+import { CODEGEN_VERSION } from "./generate.js";
+import { headerLines, NameRegistry, quote } from "./names.js";
+import { hasDefault, isRequired } from "./rules.js";
+import { Typing } from "./typing.js";
+import { isList, isPlainObject, references } from "./values.js";
+/**
+ * Builder code for `workflow`: an ES module exporting the workflow, built with
+ * the generated types over `options.schemaName`. Nodes keep their ids and titles and come in
+ * dependency order; inputs equal to their default are left out, since the exporter fills them
+ * in. Running it and exporting gives the same prompt as `toApi(workflow)`, except that ids that
+ * aren't integers (`40:31`) come in dependency order, where the workflow lists one before a node
+ * it depends on. Pure and deterministic.
+ *
+ * Reports `W_TRANSPILED_AS_RAW` for a node the types can't express, which is written as
+ * `raw(…)`, and `E_DEPENDENCY_CYCLE` and `E_DANGLING_LINK` for what no program can build: those
+ * nodes, or links, are left out.
+ */
+export function transpile(workflow, options) {
+    const problem = transpileNameProblem(options);
+    if (problem !== undefined)
+        throw new TypeError(`transpile: ${problem}`);
+    return new Transpiler(workflow, options).run();
+}
+/**
+ * Why {@link transpile} refuses these names, or `undefined` when it takes them: each must pass
+ * `exportNameProblem`, they must differ, and the declaration
+ * `export const <name>: Workflow<NodesOf<typeof <schemaName>>> =` must fit on one line.
+ */
+export function transpileNameProblem(options) {
+    for (const [label, value] of [
+        ["name", options.name],
+        ["schema name", options.schemaName],
+    ]) {
+        const problem = exportNameProblem(value);
+        if (problem !== undefined)
+            return `the ${label} ${JSON.stringify(value)} won't do: ${problem}`;
+    }
+    if (options.name === options.schemaName) {
+        return `the name and the schema name are both ${JSON.stringify(options.name)}`;
+    }
+    const left = declarationLeft(options);
+    // Export names are ASCII, so their length is their width.
+    if (textWidth(left) > PRINT_WIDTH) {
+        return `the declaration \`${left}\` is wider than ${String(PRINT_WIDTH)} columns`;
+    }
+    return undefined;
+}
+class Transpiler {
+    #workflow;
+    #options;
+    #diagnostics = [];
+    #plans = new Map();
+    #references = new Map();
+    #inlined = new Set();
+    #usedSlots = new Map();
+    #names;
+    #usesN = false;
+    #usesRaw = false;
+    #layout = "hug";
+    constructor(workflow, options) {
+        this.#workflow = workflow;
+        this.#options = options;
+        this.#names = new NameRegistry([...TRANSPILED_MODULE_NAMES, options.name, options.schemaName]);
+    }
+    run() {
+        const nodes = [...this.#workflow.graph.nodes.values()];
+        // Before modes: a bypassed or muted raw node is written with its own inputs.
+        const exported = exportApi(this.#workflow, { validate: false, meta: false, modes: false });
+        // What the exporter can't send, the program can't build either.
+        this.#diagnostics.push(...exported.diagnostics);
+        const order = this.#order(nodes);
+        // A link to an output a node doesn't have can only be written as raw(…).output(slot).
+        const missing = new Map();
+        for (const node of nodes) {
+            for (const ref of references(node.inputs)) {
+                const source = this.#workflow.graph.nodes.get(ref.node);
+                const outputs = source === undefined ? undefined : this.#workflow.schema.nodes[source.classType]?.outputs;
+                if (outputs !== undefined && outputs[ref.slot] === undefined) {
+                    missing.set(ref.node, ref.slot);
+                }
+            }
+        }
+        // In dependency order, so a node's sources are decided first: a raw source is `Out<"*">`.
+        const typing = new Typing(this.#workflow, (id) => this.#plans.get(id)?.mode);
+        for (const node of order) {
+            const definition = Object.hasOwn(this.#workflow.schema.nodes, node.classType)
+                ? this.#workflow.schema.nodes[node.classType]
+                : undefined;
+            const slot = missing.get(node.id);
+            const reason = node.raw || definition === undefined
+                ? undefined
+                : slot === undefined
+                    ? typing.problem(node, definition)
+                    : `output ${String(slot)} is linked, but it has no such output`;
+            if (reason !== undefined) {
+                this.#diagnostics.push(createDiagnostic("W_TRANSPILED_AS_RAW", [node.id], `Node ${node.id} (${node.classType}) is written as raw(…): ${reason}.`));
+            }
+            this.#plans.set(node.id, {
+                node,
+                definition,
+                mode: node.raw || definition === undefined || reason !== undefined ? "raw" : "typed",
+                wire: exported.prompt[node.id]?.inputs ?? {},
+            });
+        }
+        const plans = order.flatMap((node) => this.#plans.get(node.id) ?? []);
+        this.#usesN = plans.some((plan) => plan.mode === "typed");
+        this.#usesRaw = plans.some((plan) => plan.mode === "raw");
+        // Known before any statement: how deep the statements sit decides their layout.
+        this.#layout = declarationLayout(this.#options, this.#build(), plans.length === 0);
+        const uses = this.#uses(plans);
+        const statements = [];
+        for (const plan of plans) {
+            const statement = this.#statement(plan, uses);
+            if (statement !== undefined)
+                statements.push(statement);
+        }
+        return { code: this.#module(statements), diagnostics: this.#diagnostics };
+    }
+    /**
+     * Dependency order, ties broken by graph order. No program can build a cycle, or a node that
+     * depends on one: they are reported and left out.
+     */
+    #order(nodes) {
+        const index = new Map(nodes.map((node, position) => [node.id, position]));
+        const dependents = new Map();
+        const waiting = new Map();
+        for (const node of nodes) {
+            const sources = new Set(references(node.inputs).flatMap((ref) => (index.has(ref.node) ? [ref.node] : [])));
+            waiting.set(node.id, sources.size);
+            for (const source of sources) {
+                const list = dependents.get(source);
+                if (list === undefined)
+                    dependents.set(source, [node.id]);
+                else
+                    list.push(node.id);
+            }
+        }
+        const ready = new MinHeap();
+        for (const node of nodes)
+            if (waiting.get(node.id) === 0)
+                ready.push(index.get(node.id) ?? 0);
+        const order = [];
+        for (let at = ready.pop(); at !== undefined; at = ready.pop()) {
+            const node = nodes[at];
+            if (node === undefined)
+                continue;
+            order.push(node);
+            for (const dependent of dependents.get(node.id) ?? []) {
+                const left = (waiting.get(dependent) ?? 0) - 1;
+                waiting.set(dependent, left);
+                if (left === 0)
+                    ready.push(index.get(dependent) ?? 0);
+            }
+        }
+        const left = nodes.filter((node) => (waiting.get(node.id) ?? 0) > 0);
+        const cyclic = inCycles(left);
+        for (const node of left) {
+            this.#diagnostics.push(createDiagnostic("E_DEPENDENCY_CYCLE", [node.id], cyclic.has(node.id)
+                ? `Node ${node.id} (${node.classType}) depends on itself through its links; leaving it out.`
+                : `Node ${node.id} (${node.classType}) depends on nodes in a cycle; leaving it out.`));
+        }
+        return order;
+    }
+    /** How often each output (`id`, `slot`) is used by what will be printed. */
+    #uses(plans) {
+        const uses = new Map();
+        for (const plan of plans) {
+            // A raw node prints its exported inputs, which may drop what the exporter can't send.
+            const refs = plan.mode === "raw"
+                ? Object.values(plan.wire).flatMap((value) => isLink(value) ? [{ node: value[0], slot: value[1] }] : [])
+                : references(plan.node.inputs);
+            for (const ref of refs) {
+                const key = slotKey(ref.node, ref.slot);
+                uses.set(key, (uses.get(key) ?? 0) + 1);
+                const slots = this.#usedSlots.get(ref.node);
+                if (slots === undefined)
+                    this.#usedSlots.set(ref.node, new Set([ref.slot]));
+                else
+                    slots.add(ref.slot);
+            }
+        }
+        return uses;
+    }
+    /** The statement for one node, or `undefined` when it is inlined into its only use. */
+    #statement(plan, uses) {
+        const { node, definition } = plan;
+        const options = this.#nodeOptions(node);
+        if (plan.mode === "raw" || definition === undefined) {
+            const call = callDoc("raw", [quote(node.classType), this.#wireObject(plan), options]);
+            const slots = this.#usedSlots.get(node.id);
+            if (slots === undefined)
+                return [call, ";"];
+            const name = this.#claim(camel(node.classType, "node"));
+            for (const slot of slots) {
+                this.#references.set(slotKey(node.id, slot), [name, ".output(", String(slot), ")"]);
+            }
+            return statementDoc(`const ${name}`, call);
+        }
+        const callee = /^[A-Za-z_$][\w$]*$/.test(node.classType)
+            ? `n.${node.classType}`
+            : `n[${quote(node.classType)}]`;
+        const call = callDoc(callee, [this.#inputsObject(definition.inputs, node.inputs).doc, options]);
+        const { outputs } = definition;
+        const used = outputs.filter((output) => (uses.get(slotKey(node.id, output.index)) ?? 0) > 0);
+        if (used.length === 0)
+            return [call, ";"];
+        if (outputs.length === 1) {
+            const key = slotKey(node.id, 0);
+            // Used once, by a node written later, and inlining nothing itself: written in place. Not
+            // with an id that isn't an array index: such keys keep the order nodes are created in.
+            if (this.#options.inline !== false &&
+                isArrayIndex(node.id) &&
+                uses.get(key) === 1 &&
+                references(node.inputs).every((ref) => !this.#inlined.has(ref.node))) {
+                this.#inlined.add(node.id);
+                this.#references.set(key, call);
+                return undefined;
+            }
+            const name = this.#claim(camel(outputs[0]?.name ?? node.classType, "output"));
+            this.#references.set(key, name);
+            return statementDoc(`const ${name}`, call);
+        }
+        // Several outputs: destructure the ones used, by their names, while the pattern fits on its
+        // line (Prettier would break a longer one); otherwise index one variable.
+        const last = Math.max(...used.map((output) => output.index));
+        const bindings = outputs
+            .slice(0, last + 1)
+            .map((output) => (used.includes(output) ? this.#claim(camel(output.name, "output")) : ""));
+        const pattern = `const [${bindings.join(", ")}] =`;
+        if (STATEMENT_INDENT[this.#layout] + textWidth(pattern) <= PRINT_WIDTH) {
+            for (const [index, binding] of bindings.entries()) {
+                if (binding !== "")
+                    this.#references.set(slotKey(node.id, index), binding);
+            }
+            return statementDoc(`const [${bindings.join(", ")}]`, call);
+        }
+        const name = this.#claim(camel(node.classType, "node"));
+        for (const output of used) {
+            this.#references.set(slotKey(node.id, output.index), [name, "[", String(output.index), "]"]);
+        }
+        return statementDoc(`const ${name}`, call);
+    }
+    #claim(base) {
+        // A word no export may be gets a suffix, except the module's own names, which the registry
+        // holds: those get a number, like any other taken name.
+        const usable = isExportName(base) || TRANSPILED_MODULE_NAMES.includes(base);
+        return this.#names.claim(usable ? base : `${base}Node`);
+    }
+    /** `{ id: "5" }`, and the title and mode if there are. */
+    #nodeOptions(node) {
+        return objectDoc([
+            propertyDoc("id", quote(node.id)),
+            ...(node.title === undefined ? [] : [propertyDoc("title", quote(node.title))]),
+            ...(node.mode === undefined ? [] : [propertyDoc("mode", quote(node.mode))]),
+        ]);
+    }
+    /**
+     * Inputs as an object literal, in the order given (the exporter orders them by the schema).
+     * Values equal to their default are left out at every level, as the exporter fills them in.
+     * Also returns how many properties were written.
+     */
+    #inputsObject(definitions, inputs) {
+        const known = new Map(definitions.map((input) => [input.name, input]));
+        const properties = [];
+        for (const [name, value] of Object.entries(inputs)) {
+            const definition = known.get(name);
+            // The exporter fills defaults in; but what the types require must be written.
+            if (definition !== undefined && !isRequired(definition) && equalsDefault(definition, value)) {
+                continue;
+            }
+            const key = objectKey(name);
+            const doc = this.#value(value, definition);
+            // `{ model }` rather than `{ model: model }`.
+            properties.push(doc === key ? key : propertyDoc(key, doc));
+        }
+        return { doc: objectDoc(properties), count: properties.length };
+    }
+    /** A structured value as an expression. */
+    #value(value, definition) {
+        if (isOutputRef(value))
+            return this.#reference(value.node, value.slot);
+        if (isList(value)) {
+            if (definition?.kind === "dynamicGroup") {
+                const rows = value.map((row) => isPlainObject(row)
+                    ? this.#inputsObject(definition.fields, row)
+                    : { doc: this.#value(row, undefined), count: 0 });
+                // Rows as printed, defaults left out, decide whether the list must break.
+                const breaks = rows.length > 1 && rows.every((row) => row.count > 1);
+                return arrayDoc(rows.map((row) => row.doc), breaks);
+            }
+            const element = definition?.kind === "autogrow" ? definition.template : undefined;
+            if (isNumberList(value))
+                return numbersDoc(value);
+            return arrayDoc(value.map((item) => this.#value(item, element)), breaksArray(value));
+        }
+        if (isPlainObject(value)) {
+            if (definition?.kind === "dynamicCombo" && typeof value["option"] === "string") {
+                const key = value["option"];
+                const chosen = definition.options.find((option) => option.key === key);
+                const children = value["inputs"];
+                const inputs = isPlainObject(children)
+                    ? this.#inputsObject(chosen?.inputs ?? [], children)
+                    : undefined;
+                // With every option input at its default, the key alone says the same.
+                if (inputs === undefined || inputs.count === 0)
+                    return quote(key);
+                return objectDoc([propertyDoc("option", quote(key)), propertyDoc("inputs", inputs.doc)]);
+            }
+            const element = definition?.kind === "autogrow" ? definition.template : undefined;
+            return objectDoc(Object.entries(value).map(([key, item]) => propertyDoc(objectKey(key), this.#value(item, element))));
+        }
+        return scalarDoc(value);
+    }
+    /** A raw node's inputs: wire keys, links as references, lists unwrapped (raw wraps them). */
+    #wireObject(plan) {
+        return objectDoc(Object.entries(plan.wire).flatMap(([key, value]) => {
+            if (isLink(value)) {
+                const [node, slot] = value;
+                if (!this.#workflow.graph.nodes.has(node)) {
+                    this.#dangling(plan.node.id, key, node);
+                    return [];
+                }
+                return [propertyDoc(objectKey(key), this.#reference(node, slot))];
+            }
+            const unwrapped = isWrappedList(value) ? value["__value__"] : value;
+            return [propertyDoc(objectKey(key), jsonDoc(unwrapped ?? null))];
+        }));
+    }
+    #reference(node, slot) {
+        const reference = this.#references.get(slotKey(node, slot));
+        // Sources are written before their uses, and left-out nodes have no uses written.
+        if (reference === undefined)
+            throw new Error(`transpile: no reference for ${node}:${String(slot)}`);
+        return reference;
+    }
+    #dangling(id, key, node) {
+        this.#diagnostics.push(createDiagnostic("E_DANGLING_LINK", [id, "inputs", key], `Input ${key} of node ${id} links to node ${node}, which the workflow doesn't have; leaving it out.`));
+    }
+    /** The build function's head: `({ n, raw }) =>` with what the statements use. */
+    #build() {
+        const context = [...(this.#usesN ? ["n"] : []), ...(this.#usesRaw ? ["raw"] : [])];
+        return `(${context.length === 0 ? "" : `{ ${context.join(", ")} }`}) =>`;
+    }
+    #module(statements) {
+        const header = [
+            `Transpiled by @tscomfy/codegen ${CODEGEN_VERSION}.`,
+            ...(this.#options.header ?? []),
+        ];
+        const { schemaName } = this.#options;
+        const block = statements.length === 0
+            ? "{}"
+            : ["{", indent([hardline, join(hardline, statements)]), hardline, "}"];
+        return [
+            ...headerLines(header),
+            "",
+            'import { type NodesOf, type Workflow, workflow } from "@tscomfy/core";',
+            `import { ${schemaName} } from ${quote(this.#options.schemaModule)};`,
+            "",
+            print(declarationDoc(this.#options, this.#build(), block, this.#layout), PRINT_WIDTH),
+            "",
+        ].join("\n");
+    }
+}
+/** The nodes of `nodes` that lie on a cycle among them (Tarjan's algorithm, iteratively). */
+function inCycles(nodes) {
+    const ids = new Set(nodes.map((node) => node.id));
+    const edges = new Map(nodes.map((node) => [
+        node.id,
+        [...new Set(references(node.inputs).map((ref) => ref.node))].filter((id) => ids.has(id)),
+    ]));
+    const order = new Map();
+    const low = new Map();
+    const stack = [];
+    const onStack = new Set();
+    const cyclic = new Set();
+    let counter = 0;
+    for (const start of ids) {
+        if (order.has(start))
+            continue;
+        const frames = [{ id: start, next: 0 }];
+        order.set(start, counter);
+        low.set(start, counter++);
+        stack.push(start);
+        onStack.add(start);
+        while (frames.length > 0) {
+            const frame = frames.at(-1);
+            if (frame === undefined)
+                break;
+            const targets = edges.get(frame.id) ?? [];
+            const target = targets[frame.next++];
+            if (target !== undefined) {
+                if (!order.has(target)) {
+                    order.set(target, counter);
+                    low.set(target, counter++);
+                    stack.push(target);
+                    onStack.add(target);
+                    frames.push({ id: target, next: 0 });
+                }
+                else if (onStack.has(target)) {
+                    low.set(frame.id, Math.min(low.get(frame.id) ?? 0, order.get(target) ?? 0));
+                }
+                continue;
+            }
+            frames.pop();
+            const parent = frames.at(-1);
+            if (parent !== undefined) {
+                low.set(parent.id, Math.min(low.get(parent.id) ?? 0, low.get(frame.id) ?? 0));
+            }
+            if (low.get(frame.id) !== order.get(frame.id))
+                continue;
+            const component = [];
+            for (let id = stack.pop(); id !== undefined; id = stack.pop()) {
+                onStack.delete(id);
+                component.push(id);
+                if (id === frame.id)
+                    break;
+            }
+            const self = (edges.get(frame.id) ?? []).includes(frame.id);
+            if (component.length > 1 || self)
+                for (const id of component)
+                    cyclic.add(id);
+        }
+    }
+    return cyclic;
+}
+/** Whether a key is an array index, which objects order numerically rather than by creation. */
+function isArrayIndex(key) {
+    return /^(?:0|[1-9][0-9]{0,9})$/.test(key) && Number(key) < 2 ** 32 - 1;
+}
+/** A binary min-heap of graph positions, for the dependency order's ready list. */
+class MinHeap {
+    #items = [];
+    push(value) {
+        const items = this.#items;
+        items.push(value);
+        for (let at = items.length - 1; at > 0;) {
+            const parent = (at - 1) >> 1;
+            const [up, down] = [items[at] ?? 0, items[parent] ?? 0];
+            if (down <= up)
+                break;
+            items[at] = down;
+            items[parent] = up;
+            at = parent;
+        }
+    }
+    pop() {
+        const items = this.#items;
+        const top = items[0];
+        const last = items.pop();
+        if (top === undefined || last === undefined || items.length === 0)
+            return top;
+        items[0] = last;
+        for (let at = 0;;) {
+            const [left, right] = [2 * at + 1, 2 * at + 2];
+            let smallest = at;
+            if (left < items.length && (items[left] ?? 0) < (items[smallest] ?? 0))
+                smallest = left;
+            if (right < items.length && (items[right] ?? 0) < (items[smallest] ?? 0))
+                smallest = right;
+            if (smallest === at)
+                break;
+            const [a, b] = [items[at] ?? 0, items[smallest] ?? 0];
+            items[at] = b;
+            items[smallest] = a;
+            at = smallest;
+        }
+        return top;
+    }
+}
+/** Whether a value equals what the exporter would send for the input when left out. */
+function equalsDefault(input, value) {
+    if (!hasDefault(input) || isOutputRef(value))
+        return false;
+    const fallback = "default" in input ? input.default : undefined;
+    return fallback !== undefined && stringify(fallback) === stringify(toJson(value));
+}
+/** A structured value without references, as JSON; references compare as `null`. */
+function toJson(value) {
+    if (isOutputRef(value))
+        return null;
+    if (isList(value))
+        return value.map(toJson);
+    if (isPlainObject(value)) {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, toJson(item)]));
+    }
+    return value;
+}
+function slotKey(node, slot) {
+    return `${node}\u0000${String(slot)}`;
+}
+function isLink(value) {
+    return (isList(value) &&
+        value.length === 2 &&
+        typeof value[0] === "string" &&
+        typeof value[1] === "number");
+}
+function isWrappedList(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !isList(value) &&
+        Object.keys(value).length === 1 &&
+        isList(value["__value__"]));
+}
+/**
+ * A camelCase variable name from a ComfyUI name, split at case changes: `LATENT` → `latent`,
+ * `VAEDecode` → `vaeDecode`, `CLIP_VISION` → `clipVision`. Never empty, never a leading digit.
+ */
+function camel(name, fallback) {
+    const words = name.match(/[A-Z]+(?![a-z])|[A-Z]?[a-z]+|[0-9]+/g) ?? [];
+    const joined = words
+        .map((word, index) => {
+        const lower = word.toLowerCase();
+        return index === 0 ? lower : lower.charAt(0).toUpperCase() + lower.slice(1);
+    })
+        .join("");
+    if (joined === "")
+        return fallback;
+    return /^[0-9]/.test(joined) ? `${fallback}${joined}` : joined;
+}
+//# sourceMappingURL=transpile.js.map