Vito
6d2213ead5
* feat(inspect): add a declarative inspection node semantics table
* fix(inspect): bound and isolate the semantics table
Bound the semantics loader: at most 1 MiB is read, containers may nest
at most eight levels, and a RecursionError from the JSON parser becomes
a SemanticsError instead of escaping.
The table is no longer loaded at import. get_semantics() reads it on
first use and caches only a valid result, and the resolver imports it
lazily, only for a profile with semantics on. The default ingestion
profile never imports the module, so a missing or corrupt table cannot
break scan, monitor or admin import. Inspection of a prompt graph with
an unusable table is unresolved with the reason "Inspection node
semantics are unavailable" and an error log, rather than a crash.
INSPECTION_PROFILE now has semantics on; no strategy consumes the table
yet, so resolution is unchanged.
* feat(inspect): resolve guider-based samplers
Under INSPECTION_PROFILE the resolver discovers samplers from the
semantics table and follows SamplerCustomAdvanced through its guider
link (Reroutes allowed) to a listed guider:
- CFGGuider: positive and negative, so the pair resolves.
- BasicGuider: positive only. The state is "absent" with the reason
"Guider has no negative input", the existing missing-negative path.
- Any other guider, including DualCFGGuider (D17), is unsupported-node
and names that guider.
Guider hops draw visits, scan and depth from the existing budgets. A
SamplerCustomAdvanced upstream in latent ancestry is an earlier stage,
so the result stays multistage-ambiguous. Positive and negative
provenance record guider_id. FaceDetailer (detailer-stage) is not a
candidate yet: deciding it needs output ancestry. DEFAULT_PROFILE never
loads the table and is unchanged.
Vector changes (inspection profile only, default vectors unchanged):
- f07b: no-sampler -> resolved (CFGGuider).
- f17: no-sampler -> unsupported-node (FluxGuidance, Task 2.3).
- f01b: no-sampler -> unsupported-node (EmptyFlux2LatentImage latent,
Task 2.5).
- f01: no-sampler -> ambiguous (24 SamplerCustomAdvanced branches).
The no-sampler tests (resolver and inspect route) now use a sampler
class the inspector does not know, because f17 has a supported one.
* feat(inspect): trace conditioning through supported pass-through and selector nodes
* feat(inspect): treat detailers as sampler stages
* fix(inspect): choose selectors that share one condition together
* fix(inspect): bound detailer stage chains by the depth limit
* feat(inspect): support common text encoders and string sources
* fix(inspect): keep pair execution evidence behind unreadable string sources
* feat(inspect): accept any non-sampler latent origin
* fix(inspect): queue each node once in breadth-first ancestry walks
The latent and detailer image walks queued every link before checking
whether its node was already seen, and popped from the list head. A dense
shared fan-in grew the queue far past the visit budget before any visit
was charged. Both walks now use a deque and enqueue each node at most
once, charging every examined edge as scanned work; outcomes are
unchanged.
* fix(inspect): treat unlisted pipe and embed samplers as possible stages
The latent and detailer ancestry walks only flagged unlisted nodes with a
linked latent_image, guider, positive or negative input, so easy-use pipe
samplers, Impact pipe detailers and embed-driven video samplers were walked
through and the final sampler's prompt resolved silently. A separate
stage-shaped input set (adding pipes, embeds and custom-sampler parts)
now makes such nodes unsupported-node, named.
* fix(inspect): walk each sampler's latent ancestry once per resolution
Every selector branch run and candidate re-walked the same latent
ancestry, so conditioning-carrying origins such as WanImageToVideo turned
a three-selector graph from ambiguous into work-limit. The walk outcome is
now cached per sampler; branch runs of one candidate pay for it once and
other candidates are charged its visit cost, as the text memo does. Walks
that ran out of work are not cached. Every link input is still walked.
* fix(inspect): treat unlisted model-driven samplers as possible stages
Unlisted samplers that link a model with conditioning or a latent under
other input names (XlabsSampler, generic video samplers) were still walked
through, so the final sampler's prompt resolved silently. An unlisted node
with a linked model plus conditioning, neg_conditioning, samples or latent
is now unsupported-node, named; model patches such as LoraLoader and
ModelSampling nodes are not.
* feat(inspect): compute facts from the resolved sampler
* fix(inspect): merge facts across sampler branches when ambiguous
* fix(inspect): merge facts over unresolved stages and share stage inputs via the table
* feat(inspect): explain why a prompt could not be resolved
* feat(inspect): port legacy parser rules the new resolver missed (PromptManager)
R1: before 3.2.3 a save patch overwrote every PromptManager node's saved
text with the last-run node's prompt. The legacy viewer recognizes the
signature (comfy-metadata.js createContext: two or more PromptManager
workflow nodes with one API text and different widget values). Inspection
now refuses those nodes as malformed instead of resolving to another
node's prompt; the inspector hands the parsed workflow to the resolver for
this check only. Lands before the new pass-throughs (R6) that would
otherwise make these graphs resolve to the wrong text.
R7: this repository's node classes up to 07a5af3 (PromptManagerV2,
Positive, Negative, Detailer, V2Text, PositiveText, NegativeText) resolve
with their own outputs and their exact strip and ", " join.
The default (ingestion) profile ignores both.
* feat(inspect): port legacy parser rules the new resolver missed (A1111)
R3: an accumulating batch saver repeats the A1111 parameters record once
per batch item, identical except "Batch index: N". The bounded PNG reader
now keeps the last copy (Pillow's rule, which #165 relied on) instead of
calling the file unreadable. Any other difference, including a missing or
second batch index, is still a conflict, and decoding the copies draws from
the duplicate role budget.
R4: parameters text that starts with "Negative prompt:" has an empty
positive (#165), instead of showing the delimiter line as the positive.
R5: the settings footer may be followed by sd-dynamic-prompts' one-line
"Template:" and "Negative Template:" records, and may be "Steps: N" alone
when there is no full footer.
R10: commas inside A1111's quoted settings values no longer split them, so
an "ADetailer prompt" with a comma keeps the other facts known.
The facts' A1111 reader mirrors R4, R5 and R10; the default (ingestion)
profile keeps the historical split. Also from the Task 2.7 review: a guard
test fails on any uncoded unresolved reason without a user line (M1), and
the encoder bounds role lines to the client's 512 code units (M4).
* feat(inspect): port legacy parser rules the new resolver missed (installed nodes)
R6 and R9 for nodes whose sources are installed beside ComfyUI, each
entry's input names and output slots read from the node's code (the task
report lists file and line):
- detailer stages UltimateSDUpscale (image), UltimateSDUpscaleNoUpscale
(upscaled_image) and DetailerForEach (image), judged with their upstream
samplers like FaceDetailer;
- pass-throughs ControlNetInpaintingAliMamaApply and LTXVConditioning
(positive 0, negative 1) and FluxKontextMultiReferenceLatentMethod;
- encoder Text to Conditioning, strings TextInput and DisplayText;
- facts model pass-throughs Lora Loader (LoraManager), Power Lora Loader
(rgthree), ModelPatchTorchSettings, CFGNorm, PerturbedAttentionGuidance.
Impact Pack encodes a detailer's non-empty wildcard instead of its positive
input, so FaceDetailer and DetailerForEach now list it as a prompt
override: a literal wildcard is decided at run time and a linked one names
its source, instead of resolving to the positive input. The overwritten
PromptManager refusal (R1) still holds behind the new pass-throughs. The
default profile does not read the table.
* feat(inspect): port legacy parser rules the new resolver missed (upstream nodes)
R6 and R9 for nodes not installed beside ComfyUI here. Their input names
and output slots come from each pack's source at the commit the saved
workflows record in the node's cnr_id and ver properties (the task report
lists repository, commit, file and line):
- samplers ClownsharKSampler_Beta (RES4LYF), KSampler (Efficient) and
ttN KSampler_v2 (latent input "latent");
- pass-throughs SeedVarianceEnhancer and ApplyInstantIDAdvanced (positive
1, negative 2; output 0 is the model);
- selector Switch conditioning [Crystools];
- encoder smZ CLIPTextEncode: its text when with_SDXL is false; when true
the connected CLIP decides at run time which inputs are read, so the
prompt is known only when text, text_g and text_l agree;
- strings ttN text, CR Text, CR Prompt Text and TextBoxMira;
- facts model pass-through CR Apply LoRA Stack.
Inputs that replace what a sampler reads are not followed: RES4LYF options
(may carry a guider, and with sigmas replace the settings), an Efficiency
script and a ttN XY plot leave the prompt unsupported and the facts
unresolved. The overwritten PromptManager refusal (R1) still holds behind
SeedVarianceEnhancer. The default profile does not read the table.
* test(inspect): cover batch copies past the role budget and orphan widgets
* fix(inspect): match the batch index only in the settings footer
Review I-1: duplicate A1111 parameters copies were compared after blanking
"Batch index: N" anywhere in the record, so copies whose prompts differ
only by that phrase were accepted. The field is now blanked only inside
the record's one "Steps: N, ..." footer line, which must hold it exactly
once; any other difference stays a conflict.
Review M-4: the inspector parses the workflow record only when the API
graph can show the overwritten-PromptManager signature (a PromptManager
class, or a node with PromptManager's search_text input).
* fix(inspect): refuse overwritten PromptManager text inside subgraphs
Controller ruling on review M-1: PromptManager nodes inside subgraphs run
as "<instance>:<inner>" API IDs, nested instances chaining their IDs. The
overwritten-text check now walks subgraph instances (bounded in depth and
nodes) and reads a text widget stored by name, so these nodes are refused
like top-level ones, anchored or not. A definition without an instance
runs nothing and is ignored.
Review M-5: the historical adapters skip an explicit null prepend or append,
as the 07a5af3 code's "if prepend_text:" did.
* test(inspect): import unittest one way in the inspection suites
Code scanning flagged the mixed 'import unittest' and 'from unittest import
mock' forms. Use 'import unittest' plus 'import unittest.mock' everywhere.
* fix(history): name the recorded run's current-file prompts apart from its frozen fields
Now that the inspector resolves more saved files, the Recorded run dialog can
hold two regions named "Positive prompt" (and two of each Copy/Send action):
the frozen run field and the inline current file's prompt. Assistive
technology could not tell them apart, and the real-host chronology test read
two <pre> elements.
Prompt blocks take an optional context label. The inline current file inside
a recorded run names its regions "Current file positive prompt" and its
actions "Copy/Send current file positive prompt"; the visible headings stay
as in the concept. The real-host test now also scopes its frozen-field reads
to the "Frozen run prompt texts" section, and a disposable-server workflow
pins the distinct names with a resolved current file.
* fix(inspect): drop preview-only stages from unanchored candidates
A stage whose outputs reach only non-file outputs (PreviewImage and the other
non_file_outputs) cannot have written a saved file, yet it stayed an
unanchored candidate, so a preview-only FaceDetailer made the saved branch
ambiguous (f01b).
The inspection profile now drops such stages before detailer absorption,
using two linear backward passes over the graph (charged like the consumer
map; a failed pass keeps every stage). A stage without consumers, or one that
also reaches any other terminal, is kept, and nothing is dropped when every
stage is preview-only. Raw plus detailed double saves both write files and
stay ambiguous. A file in the host temp folder may itself be a preview, so it
is inspected with PREVIEW_INSPECTION_PROFILE, which keeps those stages.
Workspace facts follow the same choice: an absent or unresolved result that
names a sampler merges facts across that sampler's stages only, so the
dropped detailer's settings no longer blur the saved file's facts.
f01b now resolves (absent negative, guider has none); its vector is updated
and the expected failure removed. The default profile is unchanged:
differential against 39dcc40 identical over 160,256 cases. Over 60,054
inspection cases no previously resolved or absent result changed.
* fix(history): name the current file's prompt pair button apart from the frozen run's
The recorded run dialog nests the current-file inspector, whose footer repeated the "Send prompt pair" name. Name it from the prompt context, scope the real-host test to the frozen region, and add a dialog-wide duplicate-name check.
1029 lines
67 KiB
JavaScript
1029 lines
67 KiB
JavaScript
// Run with: node --test tests/js/
|
|
const test = require("node:test");
|
|
const assert = require("node:assert/strict");
|
|
const { extractGenerationParams, extractGenerationFacts } = require("../../web/js/comfy-metadata.js");
|
|
|
|
const parsedFactGraph = value => ({ status: "parsed", value });
|
|
const absentFactGraph = () => ({ status: "absent", value: null });
|
|
const factFields = ["seed", "steps", "cfg", "sampler", "scheduler", "model"];
|
|
function factsFor(graph, extra = {}) {
|
|
assert.equal(typeof extractGenerationFacts, "function", "the conservative facts contract is exported");
|
|
return extractGenerationFacts({ prompt_graph: parsedFactGraph(graph), workflow_graph: absentFactGraph(), metadataStatus: "available", ...extra });
|
|
}
|
|
function factGraph(inputs = {}) {
|
|
return {
|
|
s: { class_type: "KSampler", inputs: { seed: "9007199254740993", steps: 28, cfg: "6.5000000000000000001", sampler_name: "dpmpp_2m", scheduler: "karras", model: ["model", 0], ...inputs } },
|
|
model: { class_type: "CheckpointLoaderSimple", inputs: { ckpt_name: "model.safetensors" } },
|
|
};
|
|
}
|
|
|
|
test("facts keep unsafe seed and decimal strings exact", () => {
|
|
const facts = factsFor(factGraph());
|
|
assert.deepEqual(Object.keys(facts), factFields);
|
|
assert.deepEqual(factFields.map(field => facts[field].value), ["9007199254740993", "28", "6.5000000000000000001", "dpmpp_2m", "karras", "model.safetensors"]);
|
|
for (const fact of Object.values(facts)) assert.deepEqual(fact, {
|
|
status: "known", value: fact.value, source: "api-graph", evidence: "configuration", reason: null, sampler_id: "s",
|
|
});
|
|
const zero = factsFor(factGraph({ seed: 0, cfg: "0", steps: "1" }));
|
|
assert.equal(zero.seed.value, "0"); assert.equal(zero.cfg.value, "0");
|
|
for (const inputs of [{ seed: 9007199254740992 }, { seed: "1.5" }, { steps: "0" }, { cfg: "NaN" }, { cfg: {} }, { cfg: true }]) {
|
|
const key = Object.keys(inputs)[0];
|
|
assert.equal(factsFor(factGraph(inputs))[key].status, "unresolved");
|
|
}
|
|
});
|
|
|
|
test("facts do not choose equal sampler branches or unrelated model", () => {
|
|
const graph = factGraph(); graph.other = structuredClone(graph.s);
|
|
const ambiguous = factsFor(graph);
|
|
assert.ok(Object.values(ambiguous).every(fact => fact.status === "ambiguous" && fact.value === null));
|
|
const selected = factsFor(graph, { resolution: { state: "resolved", sampler_id: "other" } });
|
|
assert.equal(selected.seed.sampler_id, "other");
|
|
const unrelated = factsFor(factGraph({ model: ["missing", 0] }));
|
|
assert.equal(unrelated.model.status, "unresolved");
|
|
assert.equal(unrelated.model.value, null);
|
|
assert.equal(factsFor({ only: graph.model }).seed.status, "unresolved");
|
|
});
|
|
|
|
test("facts respect named scalar outputs and custom scheduler paths", () => {
|
|
const graph = factGraph({ seed: ["primitive", 0], steps: ["steps", 0], cfg: ["cfg", 0], sampler_name: ["sampler", 0], scheduler: ["scheduler", 0], model: ["lora", 0] });
|
|
graph.primitive = { class_type: "PrimitiveInt", inputs: { value: "0" } };
|
|
graph.steps = { class_type: "PrimitiveInt", inputs: { value: "50" } };
|
|
graph.cfg = { class_type: "PrimitiveFloat", inputs: { value: "0" } };
|
|
graph.sampler = { class_type: "PrimitiveString", inputs: { value: "euler" } };
|
|
graph.scheduler = { class_type: "PrimitiveStringMultiline", inputs: { value: "normal" } };
|
|
graph.lora = { class_type: "LoraLoader", inputs: { lora_name: "style", model: ["model", 0] } };
|
|
assert.deepEqual(factFields.map(field => factsFor(graph)[field].value), ["0", "50", "0", "euler", "normal", "model.safetensors"]);
|
|
graph.settings = { class_type: "UnknownSettings", inputs: { first: 20, second: 30 } };
|
|
graph.s.inputs.steps = ["settings", 0];
|
|
assert.equal(factsFor(graph).steps.status, "unresolved");
|
|
const custom = {
|
|
s: { class_type: "SamplerCustomAdvanced", inputs: { guider: ["g", 0], noise: ["n", 0], sampler: ["k", 0], sigmas: ["sigmas", 0] } },
|
|
g: { class_type: "CFGGuider", inputs: { model: ["m", 0], cfg: "4.0000000000000001" } },
|
|
n: { class_type: "RandomNoise", inputs: { noise_seed: "9007199254740993" } },
|
|
k: { class_type: "KSamplerSelect", inputs: { sampler_name: "euler" } },
|
|
sigmas: { class_type: "BasicScheduler", inputs: { steps: 22, scheduler: "karras" } },
|
|
m: { class_type: "UNETLoader", inputs: { unet_name: "flux.safetensors" } },
|
|
};
|
|
assert.deepEqual(factFields.map(field => factsFor(custom)[field].value), ["9007199254740993", "22", "4.0000000000000001", "euler", "karras", "flux.safetensors"]);
|
|
custom.s = { class_type: "SamplerCustom", inputs: { model: ["m", 0], cfg: 0, noise_seed: 0, sampler: ["k", 0], sigmas: ["sigmas", 0] } };
|
|
assert.deepEqual([factsFor(custom).seed.value, factsFor(custom).steps.value, factsFor(custom).cfg.value], ["0", "22", "0"]);
|
|
custom.sigmas.inputs = { steps: 22 };
|
|
assert.equal(factsFor(custom).scheduler.status, "not-recorded");
|
|
assert.equal(factsFor(custom).sampler.value, "euler");
|
|
});
|
|
|
|
test("facts require supported scalar producer types and output slots", () => {
|
|
const cases = [
|
|
["PrimitiveInt", "seed", "42", true], ["PrimitiveFloat", "cfg", "6.5000000000000000001", true],
|
|
["PrimitiveString", "sampler_name", "euler", true], ["PrimitiveStringMultiline", "scheduler", "normal", true],
|
|
["PrimitiveString", "seed", "42", false], ["PrimitiveStringMultiline", "steps", "42", false],
|
|
["PrimitiveInt", "sampler_name", "euler", false], ["PrimitiveFloat", "scheduler", "normal", false],
|
|
["PrimitiveBoolean", "seed", "42", false], ["PrimitiveNode", "seed", "42", false],
|
|
["UnknownSettings", "seed", "42", false], ["SamplerCombo", "steps", "42", false],
|
|
];
|
|
for (const [class_type, input, value, supported] of cases) {
|
|
for (const slot of [0, 1, 999, -1, 0.5]) {
|
|
const graph = factGraph({ [input]: ["settings", slot] });
|
|
graph.settings = { class_type, inputs: { value, [input]: value } };
|
|
const fact = factsFor(graph)[input === "sampler_name" ? "sampler" : input];
|
|
assert.equal(fact.status, supported && slot === 0 ? "known" : "unresolved", `${class_type} output${slot} as ${input}`);
|
|
assert.equal(fact.value, supported && slot === 0 ? value : null);
|
|
}
|
|
}
|
|
const graph = factGraph({ seed: ["primitive", 0] });
|
|
graph.primitive = { class_type: "PrimitiveInt", inputs: { seed: "987" } };
|
|
assert.equal(factsFor(graph).seed.status, "unresolved", "a matching input is not the output's value");
|
|
graph.primitive.inputs = { value: "42", seed: "987" };
|
|
assert.equal(factsFor(graph).seed.value, "42");
|
|
for (const [input, class_type, inputs] of [
|
|
["seed", "RandomNoise", { noise_seed: "42", seed: "42" }],
|
|
["sampler_name", "KSamplerSelect", { sampler_name: "euler" }],
|
|
["steps", "BasicScheduler", { steps: "42" }],
|
|
["cfg", "CFGGuider", { cfg: "7" }],
|
|
]) {
|
|
const graph = factGraph({ [input]: ["provider", 0] }); graph.provider = { class_type, inputs };
|
|
assert.equal(factsFor(graph)[input === "sampler_name" ? "sampler" : input].status, "unresolved", `${class_type} is not a generic scalar output`);
|
|
}
|
|
});
|
|
|
|
function customFactGraph() {
|
|
return {
|
|
s: { class_type: "SamplerCustomAdvanced", inputs: { guider: ["g", 0], noise: ["n", 0], sampler: ["k", 0], sigmas: ["sigmas", 0] } },
|
|
g: { class_type: "CFGGuider", inputs: { model: ["m", 0], cfg: ["cfg", 0] } },
|
|
n: { class_type: "RandomNoise", inputs: { noise_seed: ["seed", 0] } },
|
|
k: { class_type: "KSamplerSelect", inputs: { sampler_name: ["sampler", 0] } },
|
|
sigmas: { class_type: "BasicScheduler", inputs: { steps: ["steps", 0], scheduler: ["scheduler", 0] } },
|
|
seed: { class_type: "PrimitiveInt", inputs: { value: "9007199254740993" } },
|
|
cfg: { class_type: "PrimitiveFloat", inputs: { value: "4.0000000000000001" } },
|
|
steps: { class_type: "PrimitiveInt", inputs: { value: 22 } },
|
|
sampler: { class_type: "PrimitiveString", inputs: { value: "euler" } },
|
|
scheduler: { class_type: "PrimitiveString", inputs: { value: "karras" } },
|
|
m: { class_type: "UNETLoader", inputs: { unet_name: "flux.safetensors" } },
|
|
};
|
|
}
|
|
|
|
test("facts require supported custom providers and guider outputs", () => {
|
|
assert.deepEqual(factFields.map(field => factsFor(customFactGraph())[field].value), ["9007199254740993", "22", "4.0000000000000001", "euler", "karras", "flux.safetensors"]);
|
|
for (const [input, nodeId, fields] of [["noise", "n", ["seed"]], ["sampler", "k", ["sampler"]], ["sigmas", "sigmas", ["steps", "scheduler"]], ["guider", "g", ["cfg", "model"]]]) {
|
|
for (const slot of [1, 999, -1, 0.5]) {
|
|
const graph = customFactGraph(); graph.s.inputs[input] = [nodeId, slot];
|
|
for (const field of fields) assert.equal(factsFor(graph)[field].status, "unresolved", `${input} output${slot} ${field}`);
|
|
}
|
|
for (const class_type of ["UnknownProvider", "PrimitiveInt", "PrimitiveString", "BasicGuider"]) {
|
|
if (input === "guider" && class_type === "BasicGuider") continue;
|
|
const graph = customFactGraph(); graph[nodeId].class_type = class_type;
|
|
for (const field of fields) assert.equal(factsFor(graph)[field].status, "unresolved", `${class_type} cannot provide ${input}`);
|
|
}
|
|
}
|
|
const basic = customFactGraph(); basic.g = { class_type: "BasicGuider", inputs: { model: ["m", 0] } };
|
|
assert.equal(factsFor(basic).model.value, "flux.safetensors");
|
|
assert.equal(factsFor(basic).cfg.status, "not-recorded");
|
|
});
|
|
|
|
test("facts require model output ancestry with supported loaders and passthroughs", () => {
|
|
for (const [class_type, key] of [["CheckpointLoader", "ckpt_name"], ["CheckpointLoaderSimple", "ckpt_name"], ["unCLIPCheckpointLoader", "ckpt_name"], ["UNETLoader", "unet_name"]]) {
|
|
for (const slot of [0, 1, 2, 999, -1, 0.5]) {
|
|
const graph = factGraph({ model: ["loader", slot] });
|
|
graph.loader = { class_type, inputs: { [key]: "selected.safetensors" } };
|
|
assert.equal(factsFor(graph).model.value, slot === 0 ? "selected.safetensors" : null, `${class_type} output${slot}`);
|
|
assert.equal(factsFor(graph).model.status, slot === 0 ? "known" : "unresolved");
|
|
}
|
|
}
|
|
for (const class_type of ["LoraLoader", "LoraLoaderModelOnly", "UnknownModelPassThrough"]) {
|
|
for (const slot of [0, 1, 2, 999]) {
|
|
const graph = factGraph({ model: ["lora", slot] }); graph.lora = { class_type, inputs: { model: ["model", 0] } };
|
|
assert.equal(factsFor(graph).model.status, class_type !== "UnknownModelPassThrough" && slot === 0 ? "known" : "unresolved", `${class_type} output${slot}`);
|
|
}
|
|
}
|
|
for (const [class_type, inputs] of [["UnknownLoader", { ckpt_name: "fake" }], ["PrimitiveString", { model_name: "fake", value: "fake" }], ["__proto__", { "[object Object]": "fake" }]]) {
|
|
const graph = factGraph({ model: ["unknown", 0] }); graph.unknown = { class_type, inputs };
|
|
assert.equal(factsFor(graph).model.status, "unresolved");
|
|
}
|
|
for (const [input, field] of [["sampler_name", "sampler"], ["scheduler", "scheduler"]]) assert.equal(factsFor(factGraph({ [input]: 42 }))[field].status, "unresolved");
|
|
const numericModel = factGraph(); numericModel.model.inputs.ckpt_name = 42;
|
|
assert.equal(factsFor(numericModel).model.status, "unresolved", "model names require string evidence");
|
|
});
|
|
|
|
// D19: a FaceDetailer re-samples the KSampler's decoded image with its own settings.
|
|
function detailerFactGraph(detailer = {}) {
|
|
const graph = factGraph({ seed: "42", steps: 25, cfg: "6.5", sampler_name: "euler", scheduler: "normal" });
|
|
graph.decode = { class_type: "VAEDecode", inputs: { samples: ["s", 0], vae: ["model", 2] } };
|
|
graph.d = { class_type: "FaceDetailer", inputs: { image: ["decode", 0], model: ["model", 0], seed: "7", steps: 12, cfg: "6.5", sampler_name: "euler", scheduler: "normal", denoise: "0.4", ...detailer } };
|
|
return graph;
|
|
}
|
|
const statusValues = facts => Object.fromEntries(factFields.map(field => [field, [facts[field].status, facts[field].value]]));
|
|
|
|
test("facts use resolution.sampler_id for detailer-stage nodes", () => {
|
|
// Resolved (the stages' prompts agree): the final stage the server named supplies every fact.
|
|
const resolved = factsFor(detailerFactGraph(), { resolution: { state: "resolved", sampler_id: "d" } });
|
|
assert.deepEqual(statusValues(resolved), {
|
|
seed: ["known", "7"], steps: ["known", "12"], cfg: ["known", "6.5"],
|
|
sampler: ["known", "euler"], scheduler: ["known", "normal"], model: ["known", "model.safetensors"],
|
|
});
|
|
assert.ok(factFields.every(field => resolved[field].sampler_id === "d" && resolved[field].evidence === "configuration"));
|
|
// The upstream KSampler is also accepted when it is the one resolved.
|
|
assert.equal(factsFor(detailerFactGraph(), { resolution: { state: "resolved", sampler_id: "s" } }).seed.value, "42");
|
|
// Ambiguous stages: merged per field, never the detailer's or the upstream value alone.
|
|
const ambiguous = factsFor(detailerFactGraph(), { resolution: { state: "ambiguous", sampler_id: "d", reason_code: "multistage-differs" } });
|
|
assert.deepEqual(statusValues(ambiguous), {
|
|
seed: ["ambiguous", null], steps: ["ambiguous", null], cfg: ["known", "6.5"],
|
|
sampler: ["known", "euler"], scheduler: ["known", "normal"], model: ["known", "model.safetensors"],
|
|
});
|
|
assert.ok(factFields.every(field => ambiguous[field].sampler_id === null), "a merged fact names no single sampler");
|
|
// A field one stage cannot read and the others agree on stays unresolved; not-recorded is not agreement.
|
|
const unreadable = factsFor(detailerFactGraph({ cfg: ["missing", 0] }), { resolution: { state: "ambiguous", sampler_id: "d" } });
|
|
assert.deepEqual([unreadable.cfg.status, unreadable.cfg.value], ["unresolved", null]);
|
|
const unrecorded = detailerFactGraph(); delete unrecorded.d.inputs.scheduler;
|
|
assert.equal(factsFor(unrecorded, { resolution: { state: "ambiguous", sampler_id: "d" } }).scheduler.status, "unresolved");
|
|
// Two detailer stages over one KSampler: three stages merge.
|
|
const chained = detailerFactGraph({ seed: "42" });
|
|
chained.d2 = { class_type: "FaceDetailer", inputs: { image: ["d", 0], model: ["model", 0], seed: "42", steps: 25, cfg: "3", sampler_name: "euler", scheduler: "normal" } };
|
|
assert.deepEqual(statusValues(factsFor(chained, { resolution: { state: "ambiguous", sampler_id: "d2" } })), {
|
|
seed: ["known", "42"], steps: ["ambiguous", null], cfg: ["ambiguous", null],
|
|
sampler: ["known", "euler"], scheduler: ["known", "normal"], model: ["known", "model.safetensors"],
|
|
});
|
|
// Without a resolution, two samplers stay ambiguous (today's rules, now over the samplers table).
|
|
assert.ok(Object.values(factsFor(detailerFactGraph())).every(fact => fact.status === "ambiguous"));
|
|
// A sampler_id the graph or the samplers table does not hold never falls back to a guess.
|
|
for (const sampler_id of ["missing", "decode", "model", "__proto__"]) {
|
|
for (const state of ["resolved", "ambiguous"]) {
|
|
const facts = factsFor(detailerFactGraph(), { resolution: { state, sampler_id } });
|
|
assert.ok(Object.values(facts).every(fact => fact.status === "unresolved" && fact.value === null), `${state} ${sampler_id}`);
|
|
}
|
|
}
|
|
// Stage ancestry that cannot be walked is unresolved, not a partial merge.
|
|
const cyclic = detailerFactGraph(); cyclic.decode.inputs.samples = ["d", 0];
|
|
const unlinked = detailerFactGraph({ image: "not a link" });
|
|
for (const graph of [cyclic, unlinked]) {
|
|
assert.ok(Object.values(factsFor(graph, { resolution: { state: "ambiguous", sampler_id: "d" } })).every(fact => fact.status === "unresolved"));
|
|
}
|
|
const wide = detailerFactGraph();
|
|
let previous = ["s", 0];
|
|
for (let index = 0; index < 600; index++) { wide[`hop${index}`] = { class_type: "ImageScale", inputs: { image: previous } }; previous = [`hop${index}`, 0]; }
|
|
wide.decode.inputs.samples = ["s", 0]; wide.d.inputs.image = previous;
|
|
assert.ok(Object.values(factsFor(wide, { resolution: { state: "ambiguous", sampler_id: "d" } })).every(fact => fact.status === "unresolved"), "the stage walk is bounded by MAX_VISITS");
|
|
});
|
|
|
|
test("ambiguous results without a sampler_id merge facts across every listed stage", () => {
|
|
const ambiguous = { resolution: { state: "ambiguous", sampler_id: null, reason: "Multiple sampler branches" } };
|
|
// f01b's shape: an upstream sampler and a detailer whose settings partly differ.
|
|
assert.deepEqual(statusValues(factsFor(detailerFactGraph(), ambiguous)), {
|
|
seed: ["ambiguous", null], steps: ["ambiguous", null], cfg: ["known", "6.5"],
|
|
sampler: ["known", "euler"], scheduler: ["known", "normal"], model: ["known", "model.safetensors"],
|
|
});
|
|
assert.ok(Object.values(factsFor(detailerFactGraph(), ambiguous)).every(fact => fact.sampler_id === null));
|
|
// Equal independent branches agree on every field once the server says ambiguous;
|
|
// without a resolution they stay ambiguous (today's rules, reversed in PR3).
|
|
const equal = factGraph(); equal.other = structuredClone(equal.s);
|
|
assert.ok(Object.values(factsFor(equal, ambiguous)).every(fact => fact.status === "known"));
|
|
assert.ok(Object.values(factsFor(equal)).every(fact => fact.status === "ambiguous"));
|
|
// A walk that fails keeps every field unresolved; so does a graph with no listed sampler.
|
|
const cyclic = detailerFactGraph(); cyclic.decode.inputs.samples = ["d", 0];
|
|
const broken = detailerFactGraph(); broken.d.inputs.image = ["gone", 0];
|
|
for (const graph of [cyclic, broken, { model: factGraph().model }]) {
|
|
assert.ok(Object.values(factsFor(graph, ambiguous)).every(fact => fact.status === "unresolved" && fact.value === null));
|
|
}
|
|
const many = factGraph();
|
|
for (let index = 0; index < 40; index++) many[`s${index}`] = structuredClone(many.s);
|
|
assert.ok(Object.values(factsFor(many, ambiguous)).every(fact => fact.status === "unresolved"), "more stages than the candidate cap");
|
|
});
|
|
|
|
test("stage walks fail on unlisted sampler-shaped nodes like the resolver", () => {
|
|
const shaped = [
|
|
{ positive: ["model", 0] }, { latent_image: ["model", 0] }, { guider: ["model", 0] }, { negative: ["model", 0] },
|
|
{ pipe: ["model", 0] }, { basic_pipe: ["model", 0] }, { detailer_pipe: ["model", 0] }, { sampler: ["model", 0] },
|
|
{ sigmas: ["model", 0] }, { noise: ["model", 0] }, { text_embeds: ["model", 0] }, { hyvid_embeds: ["model", 0] },
|
|
{ model: ["model", 0], conditioning: ["model", 0] }, { model: ["model", 0], neg_conditioning: ["model", 0] },
|
|
{ model: ["model", 0], samples: ["model", 0] }, { model: ["model", 0], latent: ["model", 0] },
|
|
];
|
|
for (const inputs of shaped) {
|
|
const graph = detailerFactGraph();
|
|
graph.efficient = { class_type: "MysterySampler", inputs: { ...inputs, image: ["decode", 0] } };
|
|
graph.d.inputs.image = ["efficient", 0];
|
|
for (const sampler_id of ["d", null]) {
|
|
const facts = factsFor(graph, { resolution: { state: "ambiguous", sampler_id } });
|
|
assert.ok(Object.values(facts).every(fact => fact.status === "unresolved"), `${JSON.stringify(inputs)} ${sampler_id}`);
|
|
}
|
|
}
|
|
// Model patches (model alone, or with clip) and listed table classes are walked through.
|
|
for (const [class_type, inputs] of [["ModelPatch", { model: ["model", 0] }], ["LoraPatch", { model: ["model", 0], clip: ["model", 1] }], ["ImageScale", { samples: ["model", 0] }], ["CFGGuider", { model: ["model", 0], positive: ["model", 0] }]]) {
|
|
const graph = detailerFactGraph();
|
|
graph.hop = { class_type, inputs: { ...inputs, image: ["decode", 0] } };
|
|
graph.d.inputs.image = ["hop", 0];
|
|
assert.equal(factsFor(graph, { resolution: { state: "ambiguous", sampler_id: "d" } }).seed.status, "ambiguous", class_type);
|
|
}
|
|
});
|
|
|
|
test("unresolved and absent results over several stages merge facts per field", () => {
|
|
// Review I-1: the run's settings are facts even when its prompt is not, e.g. an
|
|
// upstream prompt behind an unsupported node (LoRAfromText) leaves the server unresolved.
|
|
const merged = {
|
|
seed: ["ambiguous", null], steps: ["ambiguous", null], cfg: ["known", "6.5"],
|
|
sampler: ["known", "euler"], scheduler: ["known", "normal"], model: ["known", "model.safetensors"],
|
|
};
|
|
for (const resolution of [
|
|
{ state: "unresolved", sampler_id: "d", reason_code: "unsupported-node" },
|
|
{ state: "unresolved", sampler_id: null, reason_code: "malformed" },
|
|
{ state: "absent", sampler_id: "d" },
|
|
]) {
|
|
const facts = factsFor(detailerFactGraph(), { resolution });
|
|
assert.deepEqual(statusValues(facts), merged, JSON.stringify(resolution));
|
|
assert.ok(factFields.every(field => facts[field].sampler_id === null));
|
|
}
|
|
// A stage missing a field leaves it unresolved; a failed walk leaves everything unresolved.
|
|
const unrecorded = detailerFactGraph(); delete unrecorded.d.inputs.scheduler;
|
|
assert.equal(factsFor(unrecorded, { resolution: { state: "unresolved", sampler_id: "d" } }).scheduler.status, "unresolved");
|
|
const cyclic = detailerFactGraph(); cyclic.decode.inputs.samples = ["d", 0];
|
|
assert.ok(Object.values(factsFor(cyclic, { resolution: { state: "unresolved", sampler_id: "d" } })).every(fact => fact.status === "unresolved"));
|
|
// One listed sampler keeps today's rule: its own facts, attributed to it.
|
|
const single = factsFor(factGraph(), { resolution: { state: "unresolved", sampler_id: "s" } });
|
|
assert.ok(factFields.every(field => single[field].status === "known" && single[field].sampler_id === "s"));
|
|
});
|
|
|
|
test("a named sampler limits absent and unresolved facts to its own stages", () => {
|
|
// Codex P2: the server dropped a preview-only detailer and named the saved sampler, so
|
|
// the detailer's settings never leak into the saved file's facts.
|
|
const graph = detailerFactGraph();
|
|
graph.save = { class_type: "SaveImage", inputs: { images: ["decode", 0] } };
|
|
graph.preview = { class_type: "PreviewImage", inputs: { images: ["d", 0] } };
|
|
const own = {
|
|
seed: ["known", "42"], steps: ["known", "25"], cfg: ["known", "6.5"],
|
|
sampler: ["known", "euler"], scheduler: ["known", "normal"], model: ["known", "model.safetensors"],
|
|
};
|
|
for (const state of ["absent", "unresolved"]) assert.deepEqual(statusValues(factsFor(graph, { resolution: { state, sampler_id: "s" } })), own, state);
|
|
// Without a named sampler every listed sampler still merges.
|
|
assert.equal(factsFor(graph, { resolution: { state: "absent", sampler_id: null } }).seed.status, "ambiguous");
|
|
});
|
|
|
|
test("stage walks follow only the resolver's links", () => {
|
|
// Review M-2: `["eff", -1]` is not a link to the server, so it is not walked.
|
|
for (const slot of [-1, 0.5, "0"]) {
|
|
const graph = detailerFactGraph();
|
|
graph.eff = { class_type: "MysterySampler", inputs: { positive: ["model", 0], model: ["model", 0] } };
|
|
graph.decode.inputs.extra = ["eff", slot];
|
|
assert.equal(factsFor(graph, { resolution: { state: "ambiguous", sampler_id: "d" } }).seed.status, "ambiguous", String(slot));
|
|
const shaped = detailerFactGraph();
|
|
shaped.eff = { class_type: "Unlisted", inputs: { positive: ["model", slot], image: ["decode", 0] } };
|
|
shaped.d.inputs.image = ["eff", 0];
|
|
assert.equal(factsFor(shaped, { resolution: { state: "ambiguous", sampler_id: "d" } }).seed.status, "ambiguous", `shaped ${slot}`);
|
|
}
|
|
const linked = detailerFactGraph();
|
|
linked.eff = { class_type: "MysterySampler", inputs: { positive: ["model", 0], model: ["model", 0] } };
|
|
linked.decode.inputs.extra = ["eff", 0];
|
|
assert.equal(factsFor(linked, { resolution: { state: "ambiguous", sampler_id: "d" } }).seed.status, "unresolved");
|
|
});
|
|
|
|
test("Flux2Scheduler provides steps and scheduler is its node type", () => {
|
|
const graph = customFactGraph();
|
|
graph.sigmas = { class_type: "Flux2Scheduler", inputs: { steps: 4, width: 1024, height: 1024 } };
|
|
const facts = factsFor(graph);
|
|
assert.deepEqual([facts.steps.status, facts.steps.value], ["known", "4"]);
|
|
assert.deepEqual([facts.scheduler.status, facts.scheduler.value, facts.scheduler.evidence], ["known", "Flux2Scheduler", "configuration"]);
|
|
for (const slot of [1, -1]) {
|
|
const linked = customFactGraph(); linked.sigmas = graph.sigmas; linked.s.inputs.sigmas = ["sigmas", slot];
|
|
assert.equal(factsFor(linked).scheduler.status, "unresolved", `output${slot}`);
|
|
}
|
|
// Its own inputs cannot replace the node type, and steps keep exact-integer rules.
|
|
const named = customFactGraph(); named.sigmas = { class_type: "Flux2Scheduler", inputs: { steps: 0, scheduler: "karras" } };
|
|
assert.equal(factsFor(named).scheduler.value, "Flux2Scheduler");
|
|
assert.equal(factsFor(named).steps.status, "unresolved");
|
|
});
|
|
|
|
test("ModelSampling passthroughs reach UNETLoader", () => {
|
|
const graph = customFactGraph();
|
|
graph.g.inputs.model = ["flux", 0];
|
|
graph.flux = { class_type: "ModelSamplingFlux", inputs: { model: ["aura", 0], max_shift: "1.15", base_shift: "0.5" } };
|
|
graph.aura = { class_type: "ModelSamplingAuraFlow", inputs: { model: ["sd3", 0], shift: "1.73" } };
|
|
graph.sd3 = { class_type: "ModelSamplingSD3", inputs: { model: ["lora", 0], shift: "3" } };
|
|
graph.lora = { class_type: "LoraLoaderModelOnly", inputs: { model: ["m", 0], lora_name: "style", strength_model: "1" } };
|
|
assert.deepEqual([factsFor(graph).model.status, factsFor(graph).model.value], ["known", "flux.safetensors"]);
|
|
for (const node of ["flux", "aura", "sd3"]) {
|
|
const wrongSlot = structuredClone(graph);
|
|
const parent = { flux: "g", aura: "flux", sd3: "aura" }[node];
|
|
wrongSlot[parent].inputs.model = [node, 1];
|
|
assert.equal(factsFor(wrongSlot).model.status, "unresolved", `${node} output1`);
|
|
const unlisted = structuredClone(graph); unlisted[node].class_type = "ModelSamplingUnknown";
|
|
assert.equal(factsFor(unlisted).model.status, "unresolved", `${node} unlisted`);
|
|
}
|
|
});
|
|
|
|
test("vectors.json pins full facts for every inspection fixture", () => {
|
|
const fs = require("node:fs");
|
|
const path = require("node:path");
|
|
const vectors = JSON.parse(fs.readFileSync(path.join(__dirname, "..", "fixtures", "inspection_parity", "vectors.json"), "utf8"));
|
|
const inspection = vectors.filter(vector => vector.profile === "inspection");
|
|
assert.ok(inspection.length > 0);
|
|
const statuses = new Set(["known", "ambiguous", "unresolved", "not-recorded"]);
|
|
for (const vector of inspection) {
|
|
const facts = vector.expect.facts;
|
|
assert.deepEqual(Object.keys(facts), factFields, vector.name);
|
|
for (const field of factFields) {
|
|
assert.ok(statuses.has(facts[field].status), `${vector.name} ${field}`);
|
|
assert.equal(facts[field].value === null, facts[field].status !== "known", `${vector.name} ${field} value`);
|
|
}
|
|
}
|
|
// f19: KSampler seed 42 / steps 25 / cfg 6.5 then FaceDetailer seed 7 / steps 12 / cfg 4.5, different prompts.
|
|
const f19 = inspection.find(vector => vector.fixture === "f19");
|
|
assert.equal(f19.expect.state, "ambiguous");
|
|
assert.deepEqual(Object.fromEntries(factFields.map(field => [field, f19.expect.facts[field].status])), {
|
|
seed: "ambiguous", steps: "ambiguous", cfg: "ambiguous", sampler: "known", scheduler: "known", model: "known",
|
|
});
|
|
});
|
|
|
|
test("wide workflow lookups retain selected core sampler facts", () => {
|
|
const nodes = [{ id: "text", type: "PrimitiveString", widgets_values_named: { value: "unrelated text" } }], links = [];
|
|
let linkId = 1;
|
|
for (let index = 0; index < 20; index++) {
|
|
nodes.push({ id: `r${index}`, type: "Reroute", inputs: [{ name: "value", link: linkId }] });
|
|
links.push([linkId++, index ? `r${index - 1}` : "text", 0, `r${index}`, 0, "STRING"]);
|
|
}
|
|
for (let index = 0; index < 40; index++) {
|
|
nodes.push({ id: `encoder${index}`, type: "CLIPTextEncode", inputs: [{ name: "text", link: linkId }] });
|
|
links.push([linkId++, "r19", 0, `encoder${index}`, 0, "STRING"]);
|
|
}
|
|
nodes.push({ id: "model", type: "CheckpointLoaderSimple", widgets_values_named: { ckpt_name: "selected.safetensors" } },
|
|
{ id: "steps", type: "PrimitiveInt", widgets_values_named: { value: 28 } },
|
|
{ id: "s", type: "KSampler", widgets_values: ["9007199254740993", "fixed", 28, "6.5000000000000000001", "euler", "normal"], inputs: [{ name: "model", link: linkId }, { name: "steps", link: linkId + 1 }] });
|
|
links.push([linkId, "model", 0, "s", 0, "MODEL"], [linkId + 1, "steps", 0, "s", 1, "INT"]);
|
|
const facts = factsFor(null, { prompt_graph: absentFactGraph(), workflow_graph: parsedFactGraph({ nodes, links }) });
|
|
assert.deepEqual(factFields.map(field => facts[field].value), ["9007199254740993", "28", "6.5000000000000000001", "euler", "normal", "selected.safetensors"]);
|
|
});
|
|
|
|
test("workflow facts require supported passthrough output slots and bypass ancestry", () => {
|
|
function workflow(type, slot, mode) {
|
|
const pass = { id: "pass", type, ...(mode === undefined ? {} : { mode }), widgets_values: ["selected"], inputs: [{ name: type === "Reroute" ? "value" : "model", type: "MODEL", link: 1 }] };
|
|
const nodes = [{ id: "m", type: "CheckpointLoaderSimple", widgets_values_named: { ckpt_name: "selected.safetensors" } }, pass,
|
|
{ id: "s", type: "KSampler", widgets_values: [0, "fixed", 28, "0", "euler", "normal"], inputs: [{ name: "model", link: 2 }] }];
|
|
if (type === "GetNode") {
|
|
nodes.push({ id: "set", type: "SetNode", widgets_values: ["selected"], inputs: [{ name: "model", link: 1 }] });
|
|
pass.inputs = [];
|
|
}
|
|
return { nodes, links: [[1, "m", 0, "pass", 0, "MODEL"], [2, "pass", slot, "s", 0, "MODEL"]] };
|
|
}
|
|
const model = value => factsFor(null, { prompt_graph: absentFactGraph(), workflow_graph: parsedFactGraph(value) }).model;
|
|
for (const [type, mode] of [["Reroute", undefined], ["GetNode", undefined], ["SetNode", undefined], ["LoraLoader", 4], ["LoraLoaderModelOnly", 4]]) {
|
|
for (const slot of [0, 1, 999, -1, 0.5]) {
|
|
assert.equal(model(workflow(type, slot, mode)).status, slot === 0 ? "known" : "unresolved", `${type} output${slot}`);
|
|
}
|
|
}
|
|
assert.equal(model(workflow("UnknownBypass", 0, 4)).status, "unresolved");
|
|
const duplicate = workflow("LoraLoader", 0, 4);
|
|
duplicate.nodes[1].inputs.push({ name: "model", type: "MODEL", link: 1 });
|
|
assert.equal(model(duplicate).status, "unresolved", "bypass model input is uniquely named");
|
|
const wrongOrigin = workflow("Reroute", 0); wrongOrigin.links[0][2] = 1;
|
|
assert.equal(model(wrongOrigin).status, "unresolved", "passthrough cannot turn CLIP into MODEL");
|
|
const cycle = workflow("Reroute", 0); cycle.links[0][1] = "pass";
|
|
assert.equal(model(cycle).status, "unresolved");
|
|
const unnamed = workflow("GetNode", 0);
|
|
delete unnamed.nodes.find(node => node.id === "pass").widgets_values;
|
|
delete unnamed.nodes.find(node => node.id === "set").widgets_values;
|
|
assert.equal(model(unnamed).status, "unresolved", "missing Get/Set names are not a source association");
|
|
const scalar = factGraph({ seed: ["bypass", 0] });
|
|
scalar.bypass = { class_type: "LoraLoader", inputs: { model: ["primitive", 0] } };
|
|
scalar.primitive = { class_type: "PrimitiveInt", inputs: { value: 42 } };
|
|
const scalarWorkflow = factWorkflowFromGraph(scalar); scalarWorkflow.nodes.find(node => node.id === "bypass").mode = 4;
|
|
assert.equal(factsFor(null, { prompt_graph: absentFactGraph(), workflow_graph: parsedFactGraph(scalarWorkflow) }).seed.status, "unresolved", "bypassed MODEL output cannot become a scalar");
|
|
for (const [input, field] of [["noise", "seed"], ["sampler", "sampler"], ["sigmas", "steps"], ["guider", "model"]]) {
|
|
const graph = customFactGraph(), target = graph.s.inputs[input];
|
|
graph.s.inputs[input] = ["bypass", 0]; graph.bypass = { class_type: "LoraLoaderModelOnly", inputs: { model: target } };
|
|
const workflow = factWorkflowFromGraph(graph); workflow.nodes.find(node => node.id === "bypass").mode = 4;
|
|
assert.equal(factsFor(null, { prompt_graph: absentFactGraph(), workflow_graph: parsedFactGraph(workflow) })[field].status, "unresolved", `MODEL output cannot become ${input}`);
|
|
}
|
|
});
|
|
|
|
function factWorkflowFromGraph(graph) {
|
|
const nodes = [], links = [];
|
|
for (const [id, node] of Object.entries(graph)) {
|
|
const inputs = [], widgets_values_named = {};
|
|
for (const [name, value] of Object.entries(node.inputs)) {
|
|
if (Array.isArray(value)) {
|
|
const link = links.length + 1;
|
|
links.push([link, value[0], value[1], id, inputs.length, "*"]);
|
|
inputs.push({ name, link });
|
|
} else widgets_values_named[name] = value;
|
|
}
|
|
nodes.push({ id, type: node.class_type, inputs, widgets_values_named });
|
|
}
|
|
return { nodes, links };
|
|
}
|
|
|
|
test("workflow facts count combined original ancestry once across passthroughs and providers", () => {
|
|
const inspect = graph => factsFor(null, { prompt_graph: absentFactGraph(), workflow_graph: parsedFactGraph(factWorkflowFromGraph(graph)) });
|
|
function chain(graph, reroutes, primitives, model = false) {
|
|
let link = model ? ["model", 0] : null;
|
|
for (let index = 0; index < primitives; index++) {
|
|
graph[`p${index}`] = { class_type: model ? "LoraLoader" : "PrimitiveInt", inputs: model ? { model: link } : { value: link || "42" } };
|
|
link = [`p${index}`, 0];
|
|
}
|
|
for (let index = 0; index < reroutes; index++) {
|
|
graph[`r${index}`] = { class_type: "Reroute", inputs: { value: link } };
|
|
link = [`r${index}`, 0];
|
|
}
|
|
return link;
|
|
}
|
|
for (const [reroutes, known] of [[32, true], [33, false]]) {
|
|
const scalar = factGraph(); scalar.s.inputs.seed = chain(scalar, reroutes, 32);
|
|
assert.equal(inspect(scalar).seed.status, known ? "known" : "unresolved", `${reroutes}+32 scalar links`);
|
|
const model = factGraph(); model.s.inputs.model = chain(model, reroutes, 31, true);
|
|
assert.equal(inspect(model).model.status, known ? "known" : "unresolved", `${reroutes}+31 LoRA+loader links`);
|
|
const noise = customFactGraph();
|
|
noise.n.inputs.noise_seed = chain(noise, reroutes - 1, 31);
|
|
noise.noiseAlias = { class_type: "Reroute", inputs: { value: ["n", 0] } };
|
|
noise.s.inputs.noise = ["noiseAlias", 0];
|
|
assert.equal(inspect(noise).seed.status, known ? "known" : "unresolved", `noise alias+provider+${reroutes - 1}+31 links`);
|
|
const guider = customFactGraph();
|
|
guider.model = { class_type: "CheckpointLoaderSimple", inputs: { ckpt_name: "model.safetensors" } };
|
|
guider.g.inputs.model = chain(guider, reroutes - 1, 30, true);
|
|
guider.guiderAlias = { class_type: "Reroute", inputs: { value: ["g", 0] } };
|
|
guider.s.inputs.guider = ["guiderAlias", 0];
|
|
assert.equal(inspect(guider).model.status, known ? "known" : "unresolved", `guider alias+provider+${reroutes - 1}+30 LoRA+loader links`);
|
|
}
|
|
const cycle = factGraph();
|
|
cycle.s.inputs.seed = ["r", 0]; cycle.r = { class_type: "Reroute", inputs: { value: ["p", 0] } }; cycle.p = { class_type: "PrimitiveInt", inputs: { value: ["r", 0] } };
|
|
assert.equal(inspect(cycle).seed.status, "unresolved");
|
|
cycle.s.inputs.model = ["r", 0]; cycle.p = { class_type: "LoraLoader", inputs: { model: ["r", 0] } };
|
|
assert.equal(inspect(cycle).model.status, "unresolved");
|
|
for (const [reroutes, known] of [[32, true], [33, false]]) {
|
|
const graph = factGraph(), value = chain(graph, reroutes, 31);
|
|
const workflow = factWorkflowFromGraph(graph);
|
|
const sourceLink = workflow.links.length + 1;
|
|
workflow.nodes.push({ id: "set", type: "SetNode", widgets_values: ["seed"], inputs: [{ name: "value", link: sourceLink }] }, { id: "get", type: "GetNode", widgets_values: ["seed"], inputs: [] });
|
|
workflow.links.push([sourceLink, value[0], 0, "set", 0, "INT"], [sourceLink + 1, "get", 0, "s", 0, "INT"]);
|
|
workflow.nodes.find(node => node.id === "s").inputs.push({ name: "seed", link: sourceLink + 1 });
|
|
const fact = factsFor(null, { prompt_graph: absentFactGraph(), workflow_graph: parsedFactGraph(workflow) }).seed;
|
|
assert.equal(fact.status, known ? "known" : "unresolved", `Get+${reroutes}+31 links, no extra setter expansion`);
|
|
}
|
|
});
|
|
|
|
test("workflow sampler selection retains prototype-named node identities", () => {
|
|
const workflow = { nodes: [
|
|
{ id: "__proto__", type: "KSampler", widgets_values: [1, "fixed", 20, "7", "euler", "normal"] },
|
|
{ id: "other", type: "KSampler", widgets_values: [2, "fixed", 20, "7", "euler", "normal"] },
|
|
], links: [] };
|
|
assert.ok(Object.values(factsFor(null, { prompt_graph: absentFactGraph(), workflow_graph: parsedFactGraph(workflow) })).every(fact => fact.status === "ambiguous"));
|
|
});
|
|
|
|
test("workflow-only facts are configuration without creating sendable roles", () => {
|
|
const workflow = { nodes: [
|
|
{ id: 1, type: "UNETLoader", widgets_values: ["flux.safetensors", "default"] },
|
|
{ id: 2, type: "SetNode", widgets_values: ["model"], inputs: [{ name: "MODEL", link: 1 }] },
|
|
{ id: 3, type: "GetNode", widgets_values: ["model"] },
|
|
{ id: 4, type: "KSamplerAdvanced", widgets_values: ["enable", "9007199254740993", "fixed", 28, "6.5000000000000000001", "euler", "normal", 0, 28, "disable"], inputs: [{ name: "model", link: 2 }] },
|
|
], links: [[1, 1, 0, 2, 0, "MODEL"], [2, 3, 0, 4, 0, "MODEL"]] };
|
|
const facts = factsFor(null, { prompt_graph: absentFactGraph(), workflow_graph: parsedFactGraph(workflow) });
|
|
assert.deepEqual(factFields.map(field => facts[field].value), ["9007199254740993", "28", "6.5000000000000000001", "euler", "normal", "flux.safetensors"]);
|
|
assert.ok(Object.values(facts).every(fact => fact.source === "workflow" && fact.evidence === "configuration"));
|
|
assert.equal(facts.positive, undefined);
|
|
workflow.nodes.push({ ...workflow.nodes[3] });
|
|
assert.ok(Object.values(factsFor(null, { prompt_graph: absentFactGraph(), workflow_graph: parsedFactGraph(workflow) })).every(fact => fact.status === "unresolved"));
|
|
});
|
|
|
|
test("limited projection stays unresolved", () => {
|
|
for (const extra of [
|
|
{ prompt_graph: { status: "limited", value: null } },
|
|
{ prompt_graph: absentFactGraph(), workflow_graph: { status: "limited", value: null } },
|
|
{ prompt_graph: absentFactGraph(), metadataStatus: "limited", parameters: null },
|
|
]) {
|
|
const facts = factsFor(null, extra);
|
|
assert.ok(Object.values(facts).every(fact => fact.status === "unresolved" && fact.value === null && fact.reason === "projection-limited"));
|
|
}
|
|
const unreadable = factsFor(null, { prompt_graph: absentFactGraph(), metadataStatus: "unreadable" });
|
|
assert.equal(unreadable.seed.reason, "metadata-unreadable");
|
|
const absent = factsFor(null, { prompt_graph: absentFactGraph(), metadataStatus: "absent" });
|
|
assert.equal(absent.seed.status, "not-recorded");
|
|
});
|
|
|
|
test("facts preserve exact video-projected decimals without reading reserialized raw", () => {
|
|
const graph = factGraph();
|
|
const facts = factsFor(graph, { recordFormats: { prompt: "reserialized-json" }, raw: { prompt: '{"s":{"inputs":{"seed":9007199254740992,"cfg":6.5}}}' } });
|
|
assert.equal(facts.seed.value, "9007199254740993");
|
|
assert.equal(facts.cfg.value, "6.5000000000000000001");
|
|
assert.equal(factsFor(factGraph({ cfg: "1E+1000000000" })).cfg.value, "1E+1000000000");
|
|
});
|
|
|
|
test("nontext parameters remain unresolved", () => {
|
|
const parameters = "A portrait\nNegative prompt: blur\nSteps: 28, Sampler: Euler, Schedule type: Karras, CFG scale: 6.5000000000000000001, Seed: 9007199254740993, Model: model";
|
|
const base = { prompt_graph: absentFactGraph(), parameters };
|
|
for (const format of [undefined, "reserialized-json", "invalid"]) {
|
|
const facts = factsFor(null, { ...base, recordFormats: format ? { parameters: format } : {} });
|
|
assert.ok(Object.values(facts).every(fact => fact.status === "unresolved" && fact.value === null));
|
|
}
|
|
const facts = factsFor(null, { ...base, recordFormats: { parameters: "original-text" } });
|
|
assert.deepEqual(factFields.map(field => facts[field].value), ["9007199254740993", "28", "6.5000000000000000001", "Euler", "Karras", "model"]);
|
|
assert.ok(Object.values(facts).every(fact => fact.source === "embedded-parameters" && fact.evidence === "embedded-parameters"));
|
|
for (const invalid of [parameters + "\nSteps: 5, Seed: 2", parameters + ", Seed: 1", parameters + "\ntrailing", parameters.replace("Seed: 9007199254740993", "Seed: -1"), parameters.replace("Karras", "invented"), parameters.replace("Negative prompt: blur", "Negative prompt: blur\nNegative prompt: again")]) {
|
|
assert.ok(Object.values(factsFor(null, { ...base, parameters: invalid, recordFormats: { parameters: "original-text" } })).some(fact => fact.status === "unresolved"));
|
|
}
|
|
});
|
|
|
|
test("malformed or unsupported API evidence blocks plausible workflow and parameter fallback", () => {
|
|
const workflow = { nodes: [{ id: 1, type: "KSampler", widgets_values: [42, "fixed", 20, 7, "euler", "normal"] }], links: [] };
|
|
const extra = { workflow_graph: parsedFactGraph(workflow), parameters: "portrait\nSteps: 20, Sampler: Euler, CFG scale: 7, Seed: 42", recordFormats: { parameters: "original-text" } };
|
|
for (const prompt_graph of [{ status: "malformed", value: null }, parsedFactGraph({ s: { class_type: "UnknownSampler", inputs: { seed: 99 } } }), parsedFactGraph({ s: { class_type: "KSampler", inputs: [] } })]) {
|
|
const facts = factsFor(null, { ...extra, prompt_graph });
|
|
assert.ok(Object.values(facts).every(fact => fact.status === "unresolved" && fact.value === null));
|
|
assert.ok(Object.values(facts).every(fact => fact.source !== "workflow" && fact.source !== "embedded-parameters"));
|
|
}
|
|
});
|
|
|
|
test("conservative facts bound cycles fan-out visits and link depth", () => {
|
|
const graph = factGraph({ seed: ["loop", 0], model: ["loop", 0] });
|
|
graph.loop = { class_type: "Unknown", inputs: { seed: ["loop", 0], model: ["loop", 0], a: ["loop", 0], b: ["loop", 0] } };
|
|
assert.equal(factsFor(graph).seed.status, "unresolved");
|
|
assert.equal(factsFor(graph).model.status, "unresolved");
|
|
graph.loop = { class_type: "PrimitiveInt", inputs: { value: ["loop", 0] } };
|
|
assert.equal(factsFor(graph).seed.status, "unresolved", "registered scalar cycle is bounded");
|
|
graph.loop = { class_type: "LoraLoader", inputs: { model: ["loop", 0] } };
|
|
assert.equal(factsFor(graph).model.status, "unresolved", "registered model cycle is bounded");
|
|
const chain = depth => {
|
|
const value = factGraph({ seed: ["p0", 0] });
|
|
for (let index = 0; index < depth; index++) value[`p${index}`] = { class_type: "PrimitiveInt", inputs: { value: index === depth - 1 ? "42" : [`p${index + 1}`, 0] } };
|
|
return value;
|
|
};
|
|
assert.equal(factsFor(chain(64)).seed.value, "42");
|
|
assert.equal(factsFor(chain(65)).seed.status, "unresolved");
|
|
const custom = chain(64);
|
|
custom.s = { class_type: "SamplerCustomAdvanced", inputs: { noise: ["noise", 0] } };
|
|
custom.noise = { class_type: "RandomNoise", inputs: { noise_seed: ["p0", 0] } };
|
|
assert.equal(factsFor(custom).seed.status, "unresolved", "the provider itself consumes one of the 64 allowed links");
|
|
});
|
|
|
|
// Spec section 10: graph size is not a facts bound. Only the per-lookup visit
|
|
// set (MAX_VISITS) and the projection's 20,000-node ceiling (`limited`) bound work.
|
|
test("facts resolve on a parsed 600-node graph with one KSampler", () => {
|
|
const large = factGraph();
|
|
for (let index = 0; index < 598; index++) large[`unused${index}`] = { class_type: "PrimitiveInt", inputs: { value: index } };
|
|
assert.equal(Object.keys(large).length, 600);
|
|
const facts = factsFor(large);
|
|
for (const [field, value] of [["seed", "9007199254740993"], ["steps", "28"], ["cfg", "6.5000000000000000001"]]) {
|
|
assert.equal(facts[field].status, "known", field);
|
|
assert.equal(facts[field].value, value);
|
|
assert.equal(facts[field].reason, null);
|
|
}
|
|
});
|
|
|
|
test("workflow facts are not gated by UI node count", () => {
|
|
const nodes = [
|
|
{ id: 1, type: "CheckpointLoaderSimple", widgets_values: ["wide.safetensors"] },
|
|
{ id: 2, type: "KSampler", widgets_values: [42, "fixed", 20, "7", "euler", "normal"], inputs: [{ name: "model", link: 1 }] },
|
|
];
|
|
for (let index = 0; index < 598; index++) nodes.push({ id: `note${index}`, type: "Note", widgets_values: [`note ${index}`] });
|
|
const workflow = { nodes, links: [[1, 1, 0, 2, 0, "MODEL"]] };
|
|
const facts = factsFor(null, { prompt_graph: absentFactGraph(), workflow_graph: parsedFactGraph(workflow) });
|
|
assert.deepEqual(factFields.map(field => facts[field].status), Array(6).fill("known"));
|
|
assert.deepEqual(factFields.map(field => facts[field].value), ["42", "20", "7", "euler", "normal", "wide.safetensors"]);
|
|
assert.ok(Object.values(facts).every(fact => fact.source === "workflow" && fact.reason === null));
|
|
});
|
|
|
|
// Same shape as the workflow attached to #75: PromptManager nodes are saved as
|
|
// CLIPTextEncode with extra inputs, and the checkpoint loader is pysssss'.
|
|
const issue75Prompt = {
|
|
1: {
|
|
class_type: "KSampler",
|
|
inputs: {
|
|
seed: 480655185510613, steps: 25, cfg: 5.5,
|
|
sampler_name: "euler_ancestral", scheduler: "normal", denoise: 0.8,
|
|
model: ["20", 0], positive: ["39", 0], negative: ["40", 0], latent_image: ["36", 0],
|
|
},
|
|
},
|
|
8: { class_type: "CLIPSetLastLayer", inputs: { stop_at_clip_layer: -2, clip: ["20", 1] } },
|
|
20: {
|
|
class_type: "CheckpointLoader|pysssss",
|
|
inputs: { ckpt_name: "Anime\\Model-XL.safetensors", prompt: "[none]", example: "[none]" },
|
|
},
|
|
39: {
|
|
class_type: "CLIPTextEncode",
|
|
inputs: {
|
|
text: "1girl, cat_ears, smile", category: "", tags: "", search_text: "",
|
|
prepend_text: "masterpiece, best quality, ", append_text: "", clip: ["8", 0],
|
|
},
|
|
},
|
|
40: {
|
|
class_type: "CLIPTextEncode",
|
|
inputs: {
|
|
text: "3d, crowd", category: "", tags: "", search_text: "",
|
|
prepend_text: "bad quality, worst quality, ", append_text: "", clip: ["8", 0],
|
|
},
|
|
},
|
|
};
|
|
|
|
test("#75: traces PromptManager prompts and pysssss checkpoint from the sampler", () => {
|
|
const r = extractGenerationParams({ prompt: issue75Prompt });
|
|
assert.equal(r.positivePrompt, "masterpiece, best quality, 1girl, cat_ears, smile");
|
|
assert.equal(r.negativePrompt, "bad quality, worst quality, 3d, crowd");
|
|
assert.equal(r.checkpoint, "Anime\\Model-XL.safetensors");
|
|
assert.deepEqual(
|
|
[r.seed, r.steps, r.cfgScale, r.sampler],
|
|
[480655185510613, 25, 5.5, "euler_ancestral"],
|
|
);
|
|
});
|
|
|
|
test("#75: workflow blob does not override values from the prompt graph", () => {
|
|
const workflow = { nodes: [{ type: "KSampler", widgets_values: [1, "randomize", 99, 7, "ddim"] }] };
|
|
const r = extractGenerationParams({ prompt: issue75Prompt, workflow });
|
|
assert.equal(r.steps, 25);
|
|
assert.equal(r.cfgScale, 5.5);
|
|
});
|
|
|
|
test("#75: recovers per-node text when SaveImage patch overwrote every PromptManager node", () => {
|
|
// Pre-fix images: both nodes carry the final positive text in the prompt graph,
|
|
// but the workflow graph still has each node's real widget values.
|
|
const positiveFinal = "masterpiece, best quality, 1girl, smile";
|
|
const prompt = {
|
|
1: { class_type: "KSampler", inputs: { seed: 1, steps: 20, cfg: 7, sampler_name: "euler", positive: ["39", 0], negative: ["40", 0], model: ["20", 0] } },
|
|
20: { class_type: "CheckpointLoaderSimple", inputs: { ckpt_name: "m.safetensors" } },
|
|
39: { class_type: "PromptManager", inputs: { text: positiveFinal, prepend_text: "masterpiece, best quality,", append_text: "" } },
|
|
40: { class_type: "PromptManager", inputs: { text: positiveFinal, prepend_text: "bad quality,", append_text: "" } },
|
|
};
|
|
const workflow = {
|
|
nodes: [
|
|
{ id: 39, type: "PromptManager", widgets_values: ["1girl, smile", "", "", "", "masterpiece, best quality,", ""] },
|
|
{ id: 40, type: "PromptManager", widgets_values: ["3d, crowd", "", "", "", "bad quality,", ""] },
|
|
],
|
|
};
|
|
const r = extractGenerationParams({ prompt, workflow });
|
|
assert.equal(r.positivePrompt, "masterpiece, best quality, 1girl, smile");
|
|
assert.equal(r.negativePrompt, "bad quality, 3d, crowd");
|
|
});
|
|
|
|
test("current metadata: API text wins over a stale or unexpanded workflow widget", () => {
|
|
// Dynamic prompt expanded at queue time: API holds what ran, workflow holds the template
|
|
const prompt = {
|
|
1: { class_type: "KSampler", inputs: { positive: ["39", 0], negative: ["40", 0], model: ["20", 0] } },
|
|
20: { class_type: "CheckpointLoaderSimple", inputs: { ckpt_name: "m.safetensors" } },
|
|
39: { class_type: "PromptManager", inputs: { text: "a red cat", prepend_text: "", append_text: "" } },
|
|
40: { class_type: "PromptManager", inputs: { text: "blurry", prepend_text: "", append_text: "" } },
|
|
};
|
|
const workflow = {
|
|
nodes: [
|
|
{ id: 39, type: "PromptManager", widgets_values: ["a {red|blue} cat", "", "", "", "", ""] },
|
|
{ id: 40, type: "PromptManager", widgets_values: ["blurry", "", "", "", "", ""] },
|
|
],
|
|
};
|
|
const r = extractGenerationParams({ prompt, workflow });
|
|
assert.equal(r.positivePrompt, "a red cat");
|
|
assert.equal(r.negativePrompt, "blurry");
|
|
});
|
|
|
|
test("current metadata: linked text is followed, not replaced by the widget's stale value", () => {
|
|
const prompt = {
|
|
1: { class_type: "KSampler", inputs: { positive: ["39", 0], negative: ["40", 0], model: ["20", 0] } },
|
|
20: { class_type: "CheckpointLoaderSimple", inputs: { ckpt_name: "m.safetensors" } },
|
|
39: { class_type: "PromptManager", inputs: { text: ["50", 0], prepend_text: "", append_text: "" } },
|
|
40: { class_type: "PromptManager", inputs: { text: ["50", 0], prepend_text: "bad,", append_text: "" } },
|
|
50: { class_type: "PrimitiveString", inputs: { value: "shared text" } },
|
|
};
|
|
const workflow = {
|
|
nodes: [
|
|
{ id: 39, type: "PromptManager", widgets_values: ["old value A", "", "", "", "", ""] },
|
|
{ id: 40, type: "PromptManager", widgets_values: ["old value B", "", "", "", "bad,", ""] },
|
|
],
|
|
};
|
|
const r = extractGenerationParams({ prompt, workflow });
|
|
assert.equal(r.positivePrompt, "shared text");
|
|
});
|
|
|
|
test("prepend/append are not doubled when text is already the combined prompt", () => {
|
|
const prompt = {
|
|
1: { class_type: "KSampler", inputs: { positive: ["2", 0], negative: ["3", 0], model: ["4", 0] } },
|
|
2: { class_type: "PromptManager", inputs: { text: "best quality, a cat, 8k", prepend_text: "best quality,", append_text: "8k" } },
|
|
3: { class_type: "CLIPTextEncode", inputs: { text: "blurry" } },
|
|
};
|
|
assert.equal(extractGenerationParams({ prompt }).positivePrompt, "best quality, a cat, 8k");
|
|
});
|
|
|
|
test("linked prepend/append inputs are resolved (no longer baked into text since 3.2.3)", () => {
|
|
const prompt = {
|
|
1: { class_type: "KSampler", inputs: { positive: ["2", 0], negative: ["3", 0], model: ["4", 0] } },
|
|
2: { class_type: "PromptManager", inputs: { text: "a fox", prepend_text: ["5", 0], append_text: ["6", 0] } },
|
|
3: { class_type: "CLIPTextEncode", inputs: { text: "blurry" } },
|
|
5: { class_type: "PrimitiveString", inputs: { value: "masterpiece," } },
|
|
6: { class_type: "PrimitiveString", inputs: { value: "8k" } },
|
|
};
|
|
assert.equal(extractGenerationParams({ prompt }).positivePrompt, "masterpiece, a fox 8k");
|
|
});
|
|
|
|
test("negative prompt is identified by link, not by keywords", () => {
|
|
const prompt = {
|
|
3: { class_type: "KSampler", inputs: { seed: 1, steps: 20, cfg: 7, sampler_name: "euler", positive: ["6", 0], negative: ["7", 0], model: ["4", 0] } },
|
|
4: { class_type: "CheckpointLoaderSimple", inputs: { ckpt_name: "sd15.safetensors" } },
|
|
6: { class_type: "CLIPTextEncode", inputs: { text: "embedding:goodstyle, a lighthouse" } },
|
|
7: { class_type: "CLIPTextEncode", inputs: { text: "blurry" } },
|
|
};
|
|
const r = extractGenerationParams({ prompt });
|
|
assert.equal(r.positivePrompt, "embedding:goodstyle, a lighthouse");
|
|
assert.equal(r.negativePrompt, "blurry");
|
|
});
|
|
|
|
test("follows LoRA chains, ControlNet pass-through, concatenated text and primitive inputs", () => {
|
|
const prompt = {
|
|
1: { class_type: "KSamplerAdvanced", inputs: { noise_seed: 42, steps: ["9", 0], cfg: 6, sampler_name: "dpmpp_2m", positive: ["5", 0], negative: ["5", 1], model: ["3", 0] } },
|
|
2: { class_type: "CheckpointLoaderSimple", inputs: { ckpt_name: "base.safetensors" } },
|
|
3: { class_type: "LoraLoader", inputs: { lora_name: "style.safetensors", model: ["2", 0], clip: ["2", 1] } },
|
|
5: { class_type: "ControlNetApplyAdvanced", inputs: { positive: ["6", 0], negative: ["7", 0], strength: 1 } },
|
|
6: { class_type: "CLIPTextEncode", inputs: { text: ["8", 0] } },
|
|
7: { class_type: "CLIPTextEncode", inputs: { text: "lowres" } },
|
|
8: { class_type: "Text Concatenate", inputs: { delimiter: ", ", text_a: "a castle", text_b: "at dusk" } },
|
|
9: { class_type: "PrimitiveInt", inputs: { value: 30 } },
|
|
};
|
|
const r = extractGenerationParams({ prompt });
|
|
assert.equal(r.positivePrompt, "a castle, at dusk");
|
|
assert.equal(r.negativePrompt, "lowres");
|
|
assert.equal(r.checkpoint, "base.safetensors");
|
|
assert.equal(r.seed, 42);
|
|
assert.equal(r.steps, 30);
|
|
});
|
|
|
|
test("custom sampler graphs (Flux: SamplerCustomAdvanced + CFGGuider) resolve every field", () => {
|
|
const prompt = {
|
|
85: { class_type: "UNETLoader", inputs: { unet_name: "flux2-klein.safetensors" } },
|
|
135: { class_type: "Lora Loader (LoraManager)", inputs: { model: ["85", 0], clip: ["90", 0] } },
|
|
149: { class_type: "PromptManager", inputs: { text: "a red fox", prepend_text: ["133", 0], append_text: "" } },
|
|
152: { class_type: "SeedHistory", inputs: { seed: 1725922648 } },
|
|
// ControlNet-style node with positive/negative but no model: must not be taken as the sampler
|
|
200: { class_type: "ControlNetApplyAdvanced", inputs: { positive: ["149", 0], negative: ["274", 0], strength: 1 } },
|
|
265: { class_type: "SamplerCustomAdvanced", inputs: { noise: ["267", 0], guider: ["268", 0], sampler: ["269", 0], sigmas: ["266", 0] } },
|
|
266: { class_type: "Flux2Scheduler", inputs: { steps: 50, width: ["153", 1] } },
|
|
267: { class_type: "RandomNoise", inputs: { noise_seed: ["152", 0] } },
|
|
268: { class_type: "CFGGuider", inputs: { cfg: 5.0, model: ["135", 0], positive: ["149", 0], negative: ["274", 0] } },
|
|
269: { class_type: "KSamplerSelect", inputs: { sampler_name: "uni_pc" } },
|
|
274: { class_type: "CLIPTextEncode", inputs: { text: "watermark" } },
|
|
};
|
|
const r = extractGenerationParams({ prompt });
|
|
assert.deepEqual(
|
|
[r.positivePrompt, r.negativePrompt, r.checkpoint, r.cfgScale, r.seed, r.steps, r.sampler],
|
|
["a red fox", "watermark", "flux2-klein.safetensors", 5.0, 1725922648, 50, "uni_pc"],
|
|
);
|
|
});
|
|
|
|
test("multi-output settings nodes (SamplerCombo) map each field to its own value", () => {
|
|
const prompt = {
|
|
5: {
|
|
class_type: "KSampler",
|
|
inputs: {
|
|
seed: ["162", 0], steps: ["165", 2], cfg: ["165", 3], sampler_name: ["165", 0],
|
|
positive: ["6", 0], negative: ["7", 0], model: ["4", 0],
|
|
},
|
|
},
|
|
4: { class_type: "CheckpointLoaderSimple", inputs: { ckpt_name: "m.safetensors" } },
|
|
6: { class_type: "CLIPTextEncode", inputs: { text: "a cat" } },
|
|
7: { class_type: "CLIPTextEncode", inputs: { text: "blurry" } },
|
|
162: { class_type: "SeedHistory", inputs: { seed: 1495646836, seed_history_ui: "" } },
|
|
165: { class_type: "SamplerCombo", inputs: { sampler_name: "euler_ancestral", scheduler: "normal", steps: 50, cfg: 7 } },
|
|
};
|
|
const r = extractGenerationParams({ prompt });
|
|
assert.deepEqual([r.seed, r.steps, r.cfgScale, r.sampler], [1495646836, 50, 7, "euler_ancestral"]);
|
|
});
|
|
|
|
test("workflow-only images account for the hidden control_after_generate widget", () => {
|
|
const workflow = {
|
|
nodes: [
|
|
{ id: 1, type: "CheckpointLoader|pysssss", widgets_values: ["model.safetensors", "[none]"] },
|
|
{ id: 2, type: "KSampler", widgets_values: [123, "randomize", 25, 5.5, "euler", "normal", 1] },
|
|
],
|
|
};
|
|
const r = extractGenerationParams({ workflow });
|
|
assert.deepEqual(
|
|
[r.checkpoint, r.seed, r.steps, r.cfgScale, r.sampler],
|
|
["model.safetensors", 123, 25, 5.5, "euler"],
|
|
);
|
|
});
|
|
|
|
test("cyclic, fan-out graphs from crafted PNGs resolve quickly", () => {
|
|
// Every node links to itself and its neighbour through several inputs and has
|
|
// no scalars: without a visited set this explores ~inputs^MAX_DEPTH paths.
|
|
const loop = (id, next) => ({
|
|
class_type: "Evil",
|
|
inputs: {
|
|
text_a: [id, 0], text_b: [next, 0], text_c: [id, 0], text_d: [next, 0],
|
|
value_a: [id, 0], value_b: [next, 0], model: [next, 0],
|
|
},
|
|
});
|
|
const prompt = {
|
|
1: { class_type: "KSampler", inputs: { seed: ["2", 0], steps: ["3", 0], positive: ["2", 0], negative: ["3", 0], model: ["2", 0] } },
|
|
2: loop("2", "3"),
|
|
3: loop("3", "2"),
|
|
};
|
|
const started = Date.now();
|
|
const r = extractGenerationParams({ prompt });
|
|
assert.ok(Date.now() - started < 500, `took ${Date.now() - started}ms`);
|
|
assert.equal(r.positivePrompt, "No prompt found");
|
|
assert.equal(r.seed, "Unknown");
|
|
});
|
|
|
|
test("chained encoders whose prepend and append both link onward stay linear", () => {
|
|
const prompt = { 1: { class_type: "KSampler", inputs: { positive: ["n0", 0], negative: ["n0", 0], model: ["n0", 0] } } };
|
|
for (let i = 0; i < 60; i++) {
|
|
prompt[`n${i}`] = {
|
|
class_type: "PromptManager",
|
|
inputs: { text: `t${i}`, prepend_text: [`n${i + 1}`, 0], append_text: [`n${i + 1}`, 0] },
|
|
};
|
|
}
|
|
const started = Date.now();
|
|
extractGenerationParams({ prompt });
|
|
assert.ok(Date.now() - started < 500, `took ${Date.now() - started}ms`);
|
|
});
|
|
|
|
// UI-format link: [id, from_node, from_slot, to_node, to_slot, type]
|
|
test("workflow-only: traces prompts, model and KSamplerAdvanced settings through Set/Get and Reroute", () => {
|
|
const workflow = {
|
|
nodes: [
|
|
{ id: 1, type: "UNETLoader", widgets_values: ["flux.safetensors", "default"], outputs: [{ links: [1] }] },
|
|
{ id: 2, type: "SetNode", widgets_values: ["model"], inputs: [{ name: "MODEL", link: 1 }] },
|
|
{ id: 3, type: "GetNode", widgets_values: ["model"], outputs: [{ links: [2] }] },
|
|
{ id: 4, type: "PromptManager", widgets_values: ["a castle", "", "", "", "masterpiece,", ""], inputs: [], outputs: [{ links: [3] }] },
|
|
{ id: 5, type: "Reroute", inputs: [{ name: "", link: 3 }], outputs: [{ links: [4] }] },
|
|
{ id: 6, type: "CLIPTextEncode", widgets_values: ["lowres"], outputs: [{ links: [5] }] },
|
|
{
|
|
id: 7, type: "KSamplerAdvanced",
|
|
inputs: [{ name: "model", link: 2 }, { name: "positive", link: 4 }, { name: "negative", link: 5 }],
|
|
widgets_values: ["enable", 77, "randomize", 30, 6.5, "dpmpp_2m", "karras", 0, 10000, "disable"],
|
|
},
|
|
],
|
|
links: [
|
|
[1, 1, 0, 2, 0, "MODEL"], [2, 3, 0, 7, 0, "MODEL"], [3, 4, 0, 5, 0, "CONDITIONING"],
|
|
[4, 5, 0, 7, 1, "CONDITIONING"], [5, 6, 0, 7, 2, "CONDITIONING"],
|
|
],
|
|
};
|
|
const r = extractGenerationParams({ workflow });
|
|
assert.deepEqual(
|
|
[r.positivePrompt, r.negativePrompt, r.checkpoint, r.seed, r.steps, r.cfgScale, r.sampler],
|
|
["masterpiece, a castle", "lowres", "flux.safetensors", 77, 30, 6.5, "dpmpp_2m"],
|
|
);
|
|
});
|
|
|
|
test("workflow-only: widgets_values_named and widget-backed inputs take precedence over positions", () => {
|
|
const workflow = {
|
|
nodes: [
|
|
{ id: 1, type: "CheckpointLoaderSimple", widgets_values: ["m.safetensors"], outputs: [{ links: [1] }] },
|
|
{ id: 2, type: "CLIPTextEncode", widgets_values_named: { text: "named text" }, widgets_values: ["ignored"], outputs: [{ links: [2] }] },
|
|
{ id: 3, type: "CLIPTextEncode", widgets_values: ["neg"], outputs: [{ links: [3] }] },
|
|
{
|
|
id: 4, type: "KSampler",
|
|
inputs: [
|
|
{ name: "model", link: 1 }, { name: "positive", link: 2 }, { name: "negative", link: 3 },
|
|
{ name: "seed", widget: { name: "seed" }, link: null },
|
|
{ name: "steps", widget: { name: "steps" }, link: null },
|
|
{ name: "cfg", widget: { name: "cfg" }, link: null },
|
|
{ name: "sampler_name", widget: { name: "sampler_name" }, link: null },
|
|
],
|
|
widgets_values: [5, "fixed", 12, 4, "euler", "normal", 1],
|
|
},
|
|
],
|
|
links: [[1, 1, 0, 4, 0, "MODEL"], [2, 2, 0, 4, 1, "CONDITIONING"], [3, 3, 0, 4, 2, "CONDITIONING"]],
|
|
};
|
|
const r = extractGenerationParams({ workflow });
|
|
assert.deepEqual([r.positivePrompt, r.seed, r.steps, r.cfgScale, r.sampler], ["named text", 5, 12, 4, "euler"]);
|
|
});
|
|
|
|
test("workflow-only: bypassed nodes pass through, muted nodes are ignored", () => {
|
|
const workflow = {
|
|
nodes: [
|
|
{ id: 1, type: "CheckpointLoaderSimple", widgets_values: ["m.safetensors"], outputs: [{ links: [1] }] },
|
|
{ id: 2, type: "LoraLoader", mode: 4, inputs: [{ name: "model", type: "MODEL", link: 1 }], outputs: [{ type: "MODEL", links: [2] }] },
|
|
{ id: 3, type: "CLIPTextEncode", widgets_values: ["pos"], outputs: [{ links: [3] }] },
|
|
{ id: 4, type: "CLIPTextEncode", widgets_values: ["neg"], outputs: [{ links: [4] }] },
|
|
{ id: 5, type: "KSampler", mode: 2, inputs: [{ name: "model", link: 2 }, { name: "positive", link: 3 }, { name: "negative", link: 4 }], widgets_values: [9, "fixed", 99, 9, "ddim"] },
|
|
{ id: 6, type: "KSampler", inputs: [{ name: "model", link: 2 }, { name: "positive", link: 3 }, { name: "negative", link: 4 }], widgets_values: [1, "fixed", 20, 7, "euler"] },
|
|
],
|
|
links: [[1, 1, 0, 2, 0, "MODEL"], [2, 2, 0, 6, 0, "MODEL"], [3, 3, 0, 6, 1, "CONDITIONING"], [4, 4, 0, 6, 2, "CONDITIONING"]],
|
|
};
|
|
const r = extractGenerationParams({ workflow });
|
|
assert.deepEqual([r.checkpoint, r.positivePrompt, r.steps], ["m.safetensors", "pos", 20]);
|
|
});
|
|
|
|
test("missing or empty metadata yields placeholders", () => {
|
|
const r = extractGenerationParams({});
|
|
assert.equal(r.positivePrompt, "No prompt found");
|
|
assert.equal(r.negativePrompt, "No negative prompt found");
|
|
assert.equal(r.checkpoint, "Unknown");
|
|
assert.equal(extractGenerationParams(null).seed, "Unknown");
|
|
});
|
|
|
|
|
|
test("Focused API metadata composes linked positive text and preserves negative role", () => {
|
|
const prompt = {
|
|
1: { class_type: "KSampler", inputs: { positive: ["2", 0], negative: ["3", 0], model: ["4", 0] } },
|
|
2: { class_type: "PromptManagerFocused", inputs: { text: "a fox", prepend_text: ["5", 0], append_text: "8k" } },
|
|
3: { class_type: "PromptManagerFocused", inputs: { text: "blurry", prepend_text: "avoid" } },
|
|
4: { class_type: "CheckpointLoaderSimple", inputs: { ckpt_name: "model.safetensors" } },
|
|
5: { class_type: "PrimitiveString", inputs: { value: "lora trigger" } },
|
|
};
|
|
const result = extractGenerationParams({ prompt });
|
|
assert.equal(result.positivePrompt, "lora trigger a fox 8k");
|
|
assert.equal(result.negativePrompt, "avoid blurry");
|
|
});
|
|
|
|
test("Focused workflow-only metadata recovers serialized fields and connected composition", () => {
|
|
const workflow = {
|
|
nodes: [
|
|
{ id: 1, type: "KSampler", inputs: [{ name: "positive", link: 1 }, { name: "negative", link: 2 }, { name: "model", link: 3 }] },
|
|
{ id: 2, type: "PromptManagerFocused", widgets_values: ["a fox", "animals", "fox", "ignored search", "stale widget", "8k"], inputs: [{ name: "prepend_text", link: 4 }] },
|
|
{ id: 3, type: "PromptManagerFocused", widgets_values: ["blurry", "negative", "bad", "ignored search", "avoid", "watermark"] },
|
|
{ id: 4, type: "UNETLoader", widgets_values: ["model.safetensors", "default"] },
|
|
{ id: 5, type: "CLIPTextEncode", widgets_values: ["lora trigger"] },
|
|
],
|
|
links: [
|
|
[1, 2, 0, 1, 0, "CONDITIONING"], [2, 3, 0, 1, 1, "CONDITIONING"],
|
|
[3, 4, 0, 1, 2, "MODEL"], [4, 5, 0, 2, 0, "STRING"],
|
|
],
|
|
};
|
|
const result = extractGenerationParams({ workflow });
|
|
assert.equal(result.positivePrompt, "lora trigger a fox 8k");
|
|
assert.equal(result.negativePrompt, "avoid blurry watermark");
|
|
assert.equal(result.checkpoint, "model.safetensors");
|
|
});
|
|
|
|
test("Split API metadata composes linked positive text and preserves negative role", () => {
|
|
const prompt = {
|
|
1: { class_type: "KSampler", inputs: { positive: ["2", 0], negative: ["3", 0], model: ["4", 0] } },
|
|
2: { class_type: "PromptManagerSplit", inputs: { text: "a fox", prepend_text: ["5", 0], append_text: "8k" } },
|
|
3: { class_type: "PromptManagerSplit", inputs: { text: "blurry", prepend_text: "avoid" } },
|
|
4: { class_type: "CheckpointLoaderSimple", inputs: { ckpt_name: "model.safetensors" } },
|
|
5: { class_type: "PrimitiveString", inputs: { value: "lora trigger" } },
|
|
};
|
|
const result = extractGenerationParams({ prompt });
|
|
assert.equal(result.positivePrompt, "lora trigger a fox 8k");
|
|
assert.equal(result.negativePrompt, "avoid blurry");
|
|
});
|
|
|
|
test("Split workflow-only metadata recovers serialized fields and connected composition", () => {
|
|
const workflow = {
|
|
nodes: [
|
|
{ id: 1, type: "KSampler", inputs: [{ name: "positive", link: 1 }, { name: "negative", link: 2 }, { name: "model", link: 3 }] },
|
|
{ id: 2, type: "PromptManagerSplit", widgets_values: ["a fox", "animals", "fox", "ignored search", "stale widget", "8k"], inputs: [{ name: "prepend_text", link: 4 }] },
|
|
{ id: 3, type: "PromptManagerSplit", widgets_values: ["blurry", "negative", "bad", "ignored search", "avoid", "watermark"] },
|
|
{ id: 4, type: "UNETLoader", widgets_values: ["model.safetensors", "default"] },
|
|
{ id: 5, type: "CLIPTextEncode", widgets_values: ["lora trigger"] },
|
|
],
|
|
links: [
|
|
[1, 2, 0, 1, 0, "CONDITIONING"], [2, 3, 0, 1, 1, "CONDITIONING"],
|
|
[3, 4, 0, 1, 2, "MODEL"], [4, 5, 0, 2, 0, "STRING"],
|
|
],
|
|
};
|
|
const result = extractGenerationParams({ workflow });
|
|
assert.equal(result.positivePrompt, "lora trigger a fox 8k");
|
|
assert.equal(result.negativePrompt, "avoid blurry watermark");
|
|
assert.equal(result.checkpoint, "model.safetensors");
|
|
});
|