feat(inspector): derive conservative generation facts
This commit is contained in:
Vito Sansevero
@@ -1,5 +1,33 @@
|
||||
import { test, expect } from '../../tools/vendor/node_modules/@playwright/test/index.mjs';
|
||||
|
||||
test('inspection facts survive actual API to browser transport', async ({ page, request }) => {
|
||||
await expect(await request.post('/__test__/reset', { data: { full_inspector: true } })).toBeOK();
|
||||
await page.goto('/prompt_manager/workspace');
|
||||
const result = await page.evaluate(async () => {
|
||||
if (typeof window.ComfyMetadata?.extractGenerationFacts !== 'function') return { missingFactsExport: true };
|
||||
const { inspectPath, toInspectionRecord } = await import('/prompt_manager/js/workspace/inspection-state.mjs');
|
||||
const { createApiClient } = window.ApiClient;
|
||||
const api = createApiClient();
|
||||
const collection = await api.get('/prompt_manager/images/output?mode=workspace&subfolder=inspector&limit=40');
|
||||
const records = {};
|
||||
for (const name of ['complete', 'ambiguous', 'workflow-only', 'control-heavy']) {
|
||||
const image = collection.images.find(entry => entry.root_index === 0 && entry.path === `inspector/${name}.png`);
|
||||
const envelope = await api.get(inspectPath(image));
|
||||
records[name] = toInspectionRecord(envelope, image, window.ComfyMetadata.extractGenerationFacts);
|
||||
}
|
||||
return records;
|
||||
});
|
||||
expect(result.missingFactsExport).toBeUndefined();
|
||||
const complete = result.complete;
|
||||
expect(Object.values(complete.generation).map(fact => fact.value)).toEqual(['9007199254740993', '28', '6.5', 'dpmpp_2m', 'karras', 'fixture-model.safetensors']);
|
||||
expect(Object.values(complete.generation).every(fact => fact.source === 'api-graph' && fact.evidence === 'configuration')).toBe(true);
|
||||
expect(Object.values(result.ambiguous.generation).every(fact => fact.status === 'ambiguous' && fact.value === null)).toBe(true);
|
||||
expect(result['workflow-only'].generation.seed).toMatchObject({ status: 'known', value: '9007199254740993', source: 'workflow', evidence: 'configuration' });
|
||||
expect(result['workflow-only'].prompts.positive.source).toBe('saved-association');
|
||||
expect(Object.values(result['control-heavy'].generation).every(fact => fact.status === 'unresolved' && fact.value === null && fact.reason === 'projection-limited')).toBe(true);
|
||||
await expect(await request.post('/__test__/reset')).toBeOK();
|
||||
});
|
||||
|
||||
test('inspection wire preserves exact rooted envelope', async ({ request }) => {
|
||||
for (const data of [
|
||||
{ full_inspector: 'true' }, { full_inspector: 1 },
|
||||
|
||||
@@ -113,6 +113,31 @@ test("a 2xx body with success:false throws ApiError", async () => {
|
||||
await assert.rejects(pending, (err) => err instanceof ApiError && err.status === 200 && err.message === "Nope");
|
||||
});
|
||||
|
||||
test("ApiError preserves only a bounded machine code without changing status or message", async () => {
|
||||
assert.equal(new ApiError(409, "unchanged").code, null);
|
||||
for (const [code, expected] of [
|
||||
["source-changed", "source-changed"], ["a".repeat(64), "a".repeat(64)],
|
||||
[undefined, null], [null, null], [4, null], [{ code: "x" }, null],
|
||||
["", null], ["Source-changed", null], ["source_changed", null],
|
||||
["source-changed\n", null], ["a".repeat(65), null],
|
||||
]) {
|
||||
for (const status of [409, 200]) {
|
||||
const api = createApiClient(async () => jsonResponse(status, {
|
||||
success: false, error: "unchanged", code, private: "never expose",
|
||||
}));
|
||||
await assert.rejects(api.get("/x"), error => {
|
||||
assert.ok(error instanceof ApiError);
|
||||
assert.equal(error.status, status);
|
||||
assert.equal(error.message, "unchanged");
|
||||
assert.equal(error.code, expected);
|
||||
assert.equal(error.private, undefined);
|
||||
assert.equal(error.body, undefined);
|
||||
return true;
|
||||
});
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
test("a 2xx body that is not JSON throws ApiError", async () => {
|
||||
const fetch = fakeFetch();
|
||||
const api = createApiClient(fetch);
|
||||
|
||||
@@ -1,7 +1,158 @@
|
||||
// Run with: node --test tests/js/
|
||||
const test = require("node:test");
|
||||
const assert = require("node:assert/strict");
|
||||
const { extractGenerationParams } = require("../../web/js/comfy-metadata.js");
|
||||
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: ["settings", 2], cfg: ["settings", 3], sampler_name: ["settings", 0], scheduler: ["settings", 1], model: ["lora", 0] });
|
||||
graph.primitive = { class_type: "PrimitiveInt", inputs: { value: "0" } };
|
||||
graph.settings = { class_type: "SamplerCombo", inputs: { sampler_name: "euler", scheduler: "normal", steps: "50", cfg: "0" } };
|
||||
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 } };
|
||||
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("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");
|
||||
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");
|
||||
const large = factGraph();
|
||||
for (let index = 0; index < 498; index++) large[`unused${index}`] = { class_type: "PrimitiveInt", inputs: { value: index } };
|
||||
assert.equal(factsFor(large).seed.value, "9007199254740993");
|
||||
large.extra = { class_type: "PrimitiveInt", inputs: { value: 1 } };
|
||||
assert.equal(factsFor(large).seed.status, "unresolved");
|
||||
});
|
||||
|
||||
// Same shape as the workflow attached to #75: PromptManager nodes are saved as
|
||||
// CLIPTextEncode with extra inputs, and the checkpoint loader is pysssss'.
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { inspectPath, promptRoles, createInspectionLoader } from '../../web/js/workspace/prompt-inspector.mjs';
|
||||
import { inspectPath, promptRoles, createInspectionLoader, mountPromptBlocks } from '../../web/js/workspace/prompt-inspector.mjs';
|
||||
|
||||
test('inspection keeps exact physical root and encodes every path component', () => {
|
||||
assert.equal(inspectPath({root_index:2,path:'a b/x#%.png'}), '/prompt_manager/images/inspect/a%20b/x%23%25.png?root=2');
|
||||
@@ -13,6 +13,14 @@ test('only confirmed strings can be sent, including explicit empty negatives', (
|
||||
}
|
||||
assert.deepEqual(promptRoles(null), {});
|
||||
});
|
||||
test('already aborted prompt blocks touch no container DOM or active handlers', () => {
|
||||
const parent = new AbortController(); parent.abort();
|
||||
const container = new Proxy({}, { get() { assert.fail('aborted mount accessed the container'); } });
|
||||
const parentScope = { signal: parent.signal };
|
||||
const view = mountPromptBlocks(container, { parentScope, sender: { open() { assert.fail('aborted action'); } } });
|
||||
view.update({ positive: { status: 'resolved', text: 'late' } });
|
||||
view.setState({ loading: true }); view.dispose();
|
||||
});
|
||||
test('superseded requests and disposed loaders cannot replace current metadata', async () => {
|
||||
const pending = [], changes = [];
|
||||
const loader = createInspectionLoader({get:(url,{signal})=>new Promise(resolve=>pending.push({url,signal,resolve}))}, value=>changes.push(value));
|
||||
|
||||
@@ -0,0 +1,228 @@
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { createRequire } from 'node:module';
|
||||
const require = createRequire(import.meta.url);
|
||||
const { extractGenerationFacts } = require('../../web/js/comfy-metadata.js');
|
||||
const { ApiError } = require('../../web/js/api-client.js');
|
||||
const module = await import('../../web/js/workspace/inspection-state.mjs').catch(error => {
|
||||
if (error.code !== 'ERR_MODULE_NOT_FOUND') throw error;
|
||||
return {};
|
||||
});
|
||||
const scopeA = 'a'.repeat(64), scopeB = 'b'.repeat(64);
|
||||
const refreshMessage = 'The source changed. Refresh the image collection before inspecting this file.';
|
||||
const fields = ['seed', 'steps', 'cfg', 'sampler', 'scheduler', 'model'];
|
||||
function contract(name) { assert.equal(typeof module[name], 'function', `${name} contract is exported`); return module[name]; }
|
||||
function image(root_scope = scopeA) {
|
||||
return { root_index: 0, path: 'folder/a #%.png', filename: 'a #%.png', url: `/prompt_manager/images/serve/folder/a%20%23%25.png?root=0${root_scope === undefined ? '' : `&root_scope=${root_scope}`}`, ...(root_scope === undefined ? {} : { root_scope }) };
|
||||
}
|
||||
function envelope(entry = image()) {
|
||||
return {
|
||||
success: true, inspection_version: 1, root_scope: entry.root_scope ?? scopeA,
|
||||
image: { root_index: entry.root_index, path: entry.path, filename: entry.filename },
|
||||
file: { observation: 'current-file', source_label: 'same label', media_type: 'image', extension: '.png', format: 'PNG', size: 123, width: 720, height: 480, modified_time: 1234 },
|
||||
prompts: { positive: { status: 'resolved', text: 'exact\npositive', source: 'execution' }, negative: { status: 'ambiguous', text: null, source: null } },
|
||||
metadata: {
|
||||
status: 'available', omitted_reason: null, raw: { prompt: '{"rounded":"raw copy"}' }, record_formats: { prompt: 'reserialized-json' },
|
||||
prompt_graph: { status: 'parsed', value: { s: { class_type: 'KSampler', inputs: { seed: '9007199254740993', steps: 28, cfg: '6.5000000000000000001', sampler_name: 'euler', scheduler: 'normal', model: ['model', 0] } }, model: { class_type: 'CheckpointLoaderSimple', inputs: { ckpt_name: 'model.safetensors' } } } },
|
||||
workflow_graph: { status: 'absent', value: null }, parameters: null,
|
||||
},
|
||||
resolution: { state: 'ambiguous', sampler_id: null, reason: 'unknown negative' },
|
||||
library: { status: 'linked', scope: 'saved-library', positive_id: 7, pair_id: 8, title: 'Recipe', category: 'Subject', tags: ['cat'], metadata_scope: 'pair' },
|
||||
};
|
||||
}
|
||||
function pendingApi() {
|
||||
const requests = [];
|
||||
const api = { get: (url, { signal }) => new Promise((resolve, reject) => requests.push({ url, signal, resolve, reject })) };
|
||||
return { api, requests };
|
||||
}
|
||||
|
||||
test('record preserves exact projections and unknown roles without execution fact promotion', () => {
|
||||
const entry = image(), data = envelope(entry);
|
||||
const record = contract('toInspectionRecord')(data, entry, extractGenerationFacts);
|
||||
assert.deepEqual(record.identity, { kind: 'rooted-file', key: '0:folder/a #%.png', root_index: 0, path: entry.path, root_scope: scopeA });
|
||||
assert.equal(record.generation.seed.value, '9007199254740993');
|
||||
assert.equal(record.generation.cfg.value, '6.5000000000000000001');
|
||||
assert.equal(record.generation.seed.evidence, 'configuration');
|
||||
assert.equal(record.prompts.negative.status, 'ambiguous');
|
||||
assert.equal(record.prompts.negative.text, null);
|
||||
assert.equal(record.historyTarget, '#/library/7');
|
||||
assert.deepEqual(record.download, { url: entry.url, filename: entry.filename });
|
||||
assert.equal(record.file.source_label, 'same label');
|
||||
for (const status of ['none', 'ambiguous', 'unavailable', 'limited']) {
|
||||
const result = envelope(entry); result.library.status = status;
|
||||
assert.equal(module.toInspectionRecord(result, entry, extractGenerationFacts).historyTarget, null);
|
||||
}
|
||||
});
|
||||
|
||||
test('record format validation never guesses original text', () => {
|
||||
const toRecord = contract('toInspectionRecord'), entry = image();
|
||||
for (const mutate of [
|
||||
data => delete data.metadata.record_formats,
|
||||
data => { data.metadata.record_formats = { prompt: 'guess' }; },
|
||||
data => { data.metadata.record_formats.extra = 'original-text'; },
|
||||
data => { data.metadata.record_formats.prompt = 'invalid'; },
|
||||
data => { data.metadata.raw.workflow = '{}'; },
|
||||
data => { data.metadata.raw.prompt = {}; },
|
||||
data => { data.metadata.raw.extra = 'secret'; },
|
||||
data => { data.metadata.parameters = 'manufactured'; },
|
||||
data => { data.metadata.prompt_graph = { status: 'absent', value: null }; },
|
||||
data => { data.metadata.record_formats = {}; data.metadata.raw = {}; },
|
||||
data => { data.metadata.status = 'limited'; },
|
||||
]) {
|
||||
const data = envelope(entry); mutate(data);
|
||||
assert.throws(() => toRecord(data, entry, extractGenerationFacts), TypeError);
|
||||
}
|
||||
const data = envelope(entry);
|
||||
data.metadata.record_formats.workflow = 'invalid';
|
||||
data.metadata.workflow_graph = { status: 'malformed', value: null };
|
||||
assert.equal(toRecord(data, entry, extractGenerationFacts).metadata.record_formats.workflow, 'invalid');
|
||||
data.metadata.raw = {}; data.metadata.status = 'limited'; data.metadata.omitted_reason = 'response-size-limit';
|
||||
data.metadata.prompt_graph = { status: 'limited', value: null };
|
||||
const limited = toRecord(data, entry, extractGenerationFacts);
|
||||
assert.deepEqual(limited.metadata.record_formats, { prompt: 'reserialized-json', workflow: 'invalid' });
|
||||
assert.equal(limited.generation.seed.status, 'unresolved');
|
||||
assert.equal(limited.generation.seed.reason, 'projection-limited');
|
||||
let seen;
|
||||
toRecord(envelope(entry), entry, input => { seen = input; return extractGenerationFacts(input); });
|
||||
assert.deepEqual(seen.recordFormats, { prompt: 'reserialized-json' });
|
||||
assert.equal(seen.raw, undefined, 'facts never receive raw graphs for reparsing');
|
||||
});
|
||||
|
||||
test('record rejects root path media and invalid versioned fields with retryable TypeError', () => {
|
||||
const toRecord = contract('toInspectionRecord');
|
||||
for (const mutate of [
|
||||
data => { data.image.root_index = 1; }, data => { data.image.path = 'other.png'; },
|
||||
data => { data.inspection_version = 2; }, data => { data.file.width = 0; },
|
||||
data => { delete data.success; },
|
||||
data => { data.file.size = -1; }, data => { data.library.positive_id = 9007199254740992; },
|
||||
data => { data.metadata.prompt_graph = { status: 'limited', value: {} }; },
|
||||
data => { data.resolution.sampler_id = {}; },
|
||||
]) {
|
||||
const data = envelope(); mutate(data);
|
||||
assert.throws(() => toRecord(data, image(), extractGenerationFacts), error => error instanceof TypeError && !error.refreshRequired);
|
||||
}
|
||||
for (const url of ['https://attacker.invalid/prompt_manager/images/serve/folder/a%20%23%25.png?root=0', 'data:text/plain,unsafe', '/other/a.png', '/prompt_manager/images/serve/other.png?root=0', `/prompt_manager/images/serve/folder/a%20%23%25.png?root=1&root_scope=${scopeA}`, `/prompt_manager/images/serve/folder/a%20%23%25.png?root=0&root_scope=${scopeB}`, `/prompt_manager/images/serve/folder/a%20%23%25.png?root=0&root=1&root_scope=${scopeA}`]) {
|
||||
assert.throws(() => toRecord(envelope(), { ...image(), url }, extractGenerationFacts), TypeError);
|
||||
}
|
||||
});
|
||||
|
||||
test('record preserves proxy originals and rejects opaque or normalized path escapes', () => {
|
||||
const toRecord = contract('toInspectionRecord');
|
||||
const previousLocation = globalThis.location, previousApi = globalThis.ApiClient;
|
||||
globalThis.location = { href: 'https://workspace.example/nested/proxy/prompt_manager/workspace', pathname: '/nested/proxy/prompt_manager/workspace' };
|
||||
globalThis.ApiClient = require('../../web/js/api-client.js');
|
||||
try {
|
||||
assert.equal(toRecord(envelope(), image(), extractGenerationFacts).download.url, `/nested/proxy${image().url}`);
|
||||
const absolute = { ...image(), url: `https://workspace.example:443/nested/proxy${image().url}` };
|
||||
assert.equal(toRecord(envelope(), absolute, extractGenerationFacts).download.url, absolute.url);
|
||||
for (const url of [`https://workspace.example.attacker.invalid/nested/proxy${image().url}`, `/nested/proxy/prompt_manager/images/serve/folder/../a%20%23%25.png?root=0&root_scope=${scopeA}`, `//attacker.invalid${image().url}`]) assert.throws(() => toRecord(envelope(), { ...image(), url }, extractGenerationFacts), TypeError);
|
||||
} finally { globalThis.location = previousLocation; globalThis.ApiClient = previousApi; }
|
||||
});
|
||||
|
||||
test('inspectPath does not coerce or strip malformed scopes', () => {
|
||||
const inspectPath = contract('inspectPath');
|
||||
assert.equal(inspectPath(image()), `/prompt_manager/images/inspect/folder/a%20%23%25.png?root=0&root_scope=${scopeA}`);
|
||||
assert.equal(inspectPath({ root_index: 2, path: 'a b/x#%.png' }), '/prompt_manager/images/inspect/a%20b/x%23%25.png?root=2');
|
||||
for (const root_scope of [null, true, 1, {}, 'a'.repeat(63), 'A'.repeat(64), scopeA + '\n']) {
|
||||
assert.throws(() => inspectPath({ ...image(), root_scope }), TypeError);
|
||||
}
|
||||
for (const entry of [{ root_index: '0', path: 'a.png' }, { root_index: 0, path: '../a.png' }, { root_index: 0, path: 'a//b.png' }, { root_index: 0, path: '/a.png' }, { root_index: 0, path: 'C:file.png' }]) assert.throws(() => inspectPath(entry), TypeError);
|
||||
});
|
||||
|
||||
test('controller shares current request across subscribers', async () => {
|
||||
const { api, requests } = pendingApi(), updates = [[], []];
|
||||
const controller = contract('createInspectionController')({ api, extractFacts: extractGenerationFacts });
|
||||
const off = controller.subscribe(state => updates[0].push(state));
|
||||
controller.subscribe(state => updates[1].push(state));
|
||||
assert.equal(updates[0][0].record, null);
|
||||
const first = controller.select(image()), second = controller.select({ ...image() });
|
||||
assert.equal(requests.length, 1);
|
||||
assert.equal(controller.state.loading, true);
|
||||
requests[0].resolve(envelope()); await Promise.all([first, second]);
|
||||
assert.equal(controller.state.record.generation.seed.value, '9007199254740993');
|
||||
assert.equal(updates[0].at(-1), updates[1].at(-1));
|
||||
await controller.select(image()); assert.equal(requests.length, 1);
|
||||
off(); const count = updates[0].length;
|
||||
const retry = controller.retry(); assert.equal(controller.state.record, null); assert.equal(controller.state.prompts, undefined);
|
||||
assert.equal(requests.length, 2); assert.ok(requests[1].url.endsWith(`root_scope=${scopeA}`));
|
||||
requests[1].resolve(envelope()); await retry;
|
||||
assert.equal(updates[0].length, count);
|
||||
controller.clear(); assert.equal(controller.state.record, null); assert.equal(controller.state.loading, false);
|
||||
const reselect = controller.select(image()); assert.equal(requests.length, 3);
|
||||
requests[2].resolve(envelope()); await reselect; controller.dispose();
|
||||
});
|
||||
|
||||
test('root scope echo and source-changed require refresh', async () => {
|
||||
const SourceChanged = contract('InspectionSourceChangedError'), toRecord = contract('toInspectionRecord');
|
||||
for (const root_scope of [undefined, scopeB]) {
|
||||
const data = envelope();
|
||||
if (root_scope === undefined) delete data.root_scope; else data.root_scope = root_scope;
|
||||
assert.throws(() => toRecord(data, image(), extractGenerationFacts), error => error instanceof SourceChanged && error.refreshRequired && error.message === refreshMessage);
|
||||
const { api, requests } = pendingApi();
|
||||
const controller = contract('createInspectionController')({ api, extractFacts: extractGenerationFacts });
|
||||
const load = controller.select(image()); requests[0].resolve(data); await load;
|
||||
assert.deepEqual([controller.state.error, controller.state.refreshRequired, controller.state.record, controller.state.prompts, controller.state.message], [true, true, null, undefined, refreshMessage]);
|
||||
await controller.retry(); assert.equal(requests.length, 1); controller.dispose();
|
||||
}
|
||||
for (const [status, code, refresh] of [[409, 'source-changed', true], [409, null, false], [409, 'file-changed', false], [500, 'source-changed', false]]) {
|
||||
const { api, requests } = pendingApi();
|
||||
const controller = module.createInspectionController({ api, extractFacts: extractGenerationFacts });
|
||||
const load = controller.select(image()); requests[0].reject(new ApiError(status, refreshMessage, code)); await load;
|
||||
assert.equal(controller.state.refreshRequired, refresh);
|
||||
const retry = controller.retry(); assert.equal(requests.length, refresh ? 1 : 2);
|
||||
if (!refresh) { requests[1].resolve(envelope()); await retry; assert.equal(controller.state.error, false); }
|
||||
controller.dispose();
|
||||
}
|
||||
});
|
||||
|
||||
test('same image key with changed scope supersedes pending actions', async () => {
|
||||
const { api, requests } = pendingApi();
|
||||
const controller = contract('createInspectionController')({ api, extractFacts: extractGenerationFacts });
|
||||
const first = controller.select(image());
|
||||
requests[0].resolve(envelope()); await first;
|
||||
const changed = image(scopeB), next = controller.select(changed);
|
||||
assert.equal(controller.state.record, null); assert.equal(controller.state.prompts, undefined);
|
||||
assert.equal(requests.length, 2);
|
||||
requests[1].resolve(envelope(changed)); await next;
|
||||
assert.equal(controller.state.record.identity.root_scope, scopeB);
|
||||
assert.equal(controller.state.record.file.source_label, 'same label');
|
||||
controller.dispose();
|
||||
});
|
||||
|
||||
test('unscoped role-only callers stay compatible', async () => {
|
||||
const toRecord = contract('toInspectionRecord'), entry = { root_index: 0, path: 'old.png' };
|
||||
const data = { prompts: { positive: { status: 'resolved', text: 'old', source: 'graph-inferred' }, negative: { status: 'unresolved', text: null, source: null } } };
|
||||
const record = toRecord(data, entry, extractGenerationFacts);
|
||||
assert.equal(record.identity.root_scope, null); assert.equal(record.identity.key, '0:old.png');
|
||||
for (const key of ['file', 'metadata', 'library', 'download', 'historyTarget']) assert.equal(record[key], null);
|
||||
for (const field of fields) assert.deepEqual(record.generation[field], { status: 'unresolved', value: null, source: null, evidence: null, reason: null, sampler_id: null });
|
||||
assert.deepEqual(record.prompts, data.prompts);
|
||||
const changes = [];
|
||||
const loader = contract('createInspectionLoader')({ get: async () => data }, value => changes.push(value));
|
||||
await loader.load(entry);
|
||||
assert.deepEqual(changes.at(-1).prompts, data.prompts); assert.equal(changes.at(-1).record.identity.key, '0:old.png');
|
||||
loader.dispose();
|
||||
assert.throws(() => toRecord(data, image(), extractGenerationFacts), error => error.refreshRequired === true);
|
||||
const scoped = toRecord({ ...data, root_scope: scopeA }, image(), extractGenerationFacts);
|
||||
assert.equal(scoped.metadata, null); assert.equal(scoped.download.url, image().url);
|
||||
});
|
||||
|
||||
test('disposed or superseded responses never publish', async () => {
|
||||
const { api, requests } = pendingApi(), updates = [];
|
||||
const controller = contract('createInspectionController')({ api, extractFacts: extractGenerationFacts });
|
||||
controller.subscribe(state => updates.push(state));
|
||||
const first = controller.select(image()), newer = image(scopeB), second = controller.select(newer);
|
||||
assert.equal(requests[0].signal.aborted, true);
|
||||
requests[1].resolve(envelope(newer)); await second;
|
||||
const count = updates.length;
|
||||
requests[0].reject(new ApiError(409, refreshMessage, 'source-changed')); await first;
|
||||
assert.equal(updates.length, count); assert.equal(controller.state.record.identity.root_scope, scopeB);
|
||||
const third = controller.retry(); controller.clear();
|
||||
assert.equal(requests[2].signal.aborted, true);
|
||||
requests[2].resolve(envelope(newer)); await third;
|
||||
assert.equal(controller.state.record, null);
|
||||
const final = controller.select(image()); controller.dispose(); const disposedCount = updates.length;
|
||||
requests[3].resolve(envelope()); await final;
|
||||
await controller.select(newer); await controller.retry(); controller.clear();
|
||||
assert.equal(updates.length, disposedCount); assert.equal(requests.length, 4);
|
||||
});
|
||||
@@ -15,10 +15,11 @@
|
||||
"use strict";
|
||||
|
||||
class ApiError extends Error {
|
||||
constructor(status, message) {
|
||||
constructor(status, message, code = null) {
|
||||
super(message);
|
||||
this.name = "ApiError";
|
||||
this.status = status;
|
||||
this.code = typeof code === "string" && /^[a-z0-9-]{1,64}$/.test(code) ? code : null;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -62,11 +63,11 @@
|
||||
|
||||
const serverMessage = data && typeof data === "object" ? data.error || data.message : undefined;
|
||||
if (!response.ok) {
|
||||
throw new ApiError(response.status, serverMessage || response.statusText || `HTTP ${response.status}`);
|
||||
throw new ApiError(response.status, serverMessage || response.statusText || `HTTP ${response.status}`, data?.code);
|
||||
}
|
||||
if (!parsed) throw new ApiError(response.status, "Invalid JSON response");
|
||||
if (data && typeof data === "object" && data.success === false) {
|
||||
throw new ApiError(response.status, serverMessage || "Request failed");
|
||||
throw new ApiError(response.status, serverMessage || "Request failed", data.code);
|
||||
}
|
||||
return data;
|
||||
}
|
||||
|
||||
+162
-7
@@ -59,7 +59,7 @@
|
||||
* their workflow widget text back. Otherwise the API graph is what actually ran
|
||||
* (expanded dynamic prompts, linked text) and always wins.
|
||||
*/
|
||||
function createContext(graph, workflow) {
|
||||
function createContext(graph, workflow, conservative = false, budget = { remaining: MAX_VISITS }) {
|
||||
const widgets = new Map();
|
||||
for (const n of workflowNodes(workflow)) {
|
||||
const text = widgetsOf(n)[0];
|
||||
@@ -82,7 +82,7 @@
|
||||
ids.forEach((id) => widgetText.set(id, widgets.get(id)));
|
||||
}
|
||||
}
|
||||
return { graph, widgetText };
|
||||
return { graph, widgetText, conservative, budget };
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -92,8 +92,9 @@
|
||||
*/
|
||||
function enter(ctx, link, seen) {
|
||||
if (!isLink(link) || seen.size >= MAX_VISITS) return [];
|
||||
if (ctx.conservative && (!Number.isSafeInteger(link[1]) || link[1] < 0 || seen.size >= 64 || ctx.budget.remaining-- <= 0)) return [];
|
||||
const id = String(link[0]);
|
||||
const node = ctx.graph[id];
|
||||
const node = !ctx.conservative || Object.hasOwn(ctx.graph, id) ? ctx.graph[id] : undefined;
|
||||
const key = `${id}:${link[1]}`;
|
||||
if (!node || !node.inputs || seen.has(key)) return [];
|
||||
seen.add(key);
|
||||
@@ -112,6 +113,10 @@
|
||||
if (name && Object.prototype.hasOwnProperty.call(node.inputs, name)) {
|
||||
return resolveScalar(ctx, node.inputs[name], name, seen);
|
||||
}
|
||||
if (ctx.conservative) {
|
||||
return value[1] === 0 && /^(Primitive(Int|Float|String|Boolean|Node)|PrimitiveStringMultiline)$/.test(node.class_type)
|
||||
&& Object.hasOwn(node.inputs, "value") ? resolveScalar(ctx, node.inputs.value, name, seen) : undefined;
|
||||
}
|
||||
for (const v of Object.values(node.inputs)) {
|
||||
const resolved = resolveScalar(ctx, v, name, seen);
|
||||
if (resolved !== undefined && typeof resolved !== "object") return resolved;
|
||||
@@ -185,6 +190,13 @@
|
||||
function traceModelName(ctx, link, seen = new Set()) {
|
||||
const [, node] = enter(ctx, link, seen);
|
||||
if (!node) return undefined;
|
||||
if (ctx.conservative) {
|
||||
const names = MODEL_NAME_KEYS.filter(key => Object.hasOwn(node.inputs, key));
|
||||
if (names.length) {
|
||||
const values = names.map(key => resolveScalar(ctx, node.inputs[key], key, new Set(seen)));
|
||||
return values.every(value => typeof value === "string" && value.trim() && value === values[0]) ? values[0] : undefined;
|
||||
}
|
||||
}
|
||||
const key = MODEL_NAME_KEYS.find((k) => typeof node.inputs[k] === "string");
|
||||
return key ? node.inputs[key] : traceModelName(ctx, node.inputs.model, seen);
|
||||
}
|
||||
@@ -283,7 +295,7 @@
|
||||
* without a `prompt` chunk are traced the same way. Set/Get pairs, Reroutes and
|
||||
* bypassed nodes are resolved to their real source; muted nodes are dropped.
|
||||
*/
|
||||
function workflowToGraph(workflow) {
|
||||
function workflowToGraph(workflow, conservative = false, budget = { remaining: MAX_VISITS }) {
|
||||
const nodes = workflowNodes(workflow).filter((n) => n && n.id !== undefined && n.id !== null);
|
||||
const byId = new Map(nodes.map((n) => [String(n.id), n]));
|
||||
const links = new Map();
|
||||
@@ -299,7 +311,8 @@
|
||||
const source = (linkId, hops = 0) => {
|
||||
const link = links.get(linkId);
|
||||
const node = link && byId.get(String(link.from));
|
||||
if (!node || node.mode === MODE_MUTED || hops > MAX_VISITS) return undefined;
|
||||
if (!node || node.mode === MODE_MUTED || hops > MAX_VISITS ||
|
||||
(conservative && (hops >= 64 || budget.remaining-- <= 0))) return undefined;
|
||||
const next = (id) => source(id, hops + 1);
|
||||
if (node.type === "Reroute") return next(node.inputs && node.inputs[0] && node.inputs[0].link);
|
||||
if (node.type === "GetNode") return next(setters.get(widgetsOf(node)[0]));
|
||||
@@ -318,7 +331,7 @@
|
||||
const inputs = namedWidgets(n);
|
||||
for (const i of n.inputs || []) {
|
||||
const src = i && i.link !== null && i.link !== undefined ? source(i.link) : undefined;
|
||||
if (src) inputs[i.name] = src;
|
||||
if (src || (conservative && i && i.link !== null && i.link !== undefined)) inputs[i.name] = src;
|
||||
}
|
||||
graph[String(n.id)] = { class_type: n.type, inputs };
|
||||
}
|
||||
@@ -344,7 +357,149 @@
|
||||
return merged;
|
||||
}
|
||||
|
||||
const api = { extractGenerationParams, PLACEHOLDERS };
|
||||
const FACT_FIELDS = ["seed", "steps", "cfg", "sampler", "scheduler", "model"];
|
||||
const GENERATION_SAMPLERS = new Set(["KSampler", "KSamplerAdvanced", "SamplerCustom", "SamplerCustomAdvanced"]);
|
||||
const object = value => value !== null && typeof value === "object" && !Array.isArray(value);
|
||||
|
||||
function fact(status, source = null, samplerId = null, value = null, reason = null) {
|
||||
return { status, value, source, evidence: source === "embedded-parameters" ? source : source ? "configuration" : null, reason, sampler_id: samplerId };
|
||||
}
|
||||
|
||||
function factSet(status, source = null, reason = null) {
|
||||
return Object.fromEntries(FACT_FIELDS.map(name => [name, fact(status, source, null, null, reason)]));
|
||||
}
|
||||
|
||||
function exactFactValue(value, field) {
|
||||
if (typeof value === "number") {
|
||||
// The projection carries decimals as strings; a float here cannot prove exactness.
|
||||
if (!Number.isFinite(value) || !Number.isSafeInteger(value)) return null;
|
||||
value = String(value);
|
||||
}
|
||||
if (typeof value !== "string" || !value.trim()) return null;
|
||||
if (field === "seed" || field === "steps") {
|
||||
return /^\d+$/.test(value) && !/[\r\n]/.test(value) && (field === "seed" || /[1-9]/.test(value)) ? value : null;
|
||||
}
|
||||
if (field === "cfg") return /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(value) && value.trim() === value ? value : null;
|
||||
return value === "Unknown" ? null : value;
|
||||
}
|
||||
|
||||
function scalarFact(ctx, inputs, key, field, source, samplerId, seen = new Set()) {
|
||||
if (!Object.hasOwn(inputs, key)) return fact("not-recorded", source, samplerId);
|
||||
const value = exactFactValue(resolveScalar(ctx, inputs[key], key, seen), field);
|
||||
return fact(value === null ? "unresolved" : "known", source, samplerId, value);
|
||||
}
|
||||
|
||||
function providerFact(ctx, link, keys, field, source, samplerId) {
|
||||
const seen = new Set();
|
||||
const [, node] = enter(ctx, link, seen);
|
||||
if (!node) return fact("unresolved", source, samplerId);
|
||||
const key = keys.find(name => Object.hasOwn(node.inputs, name));
|
||||
return key === undefined ? fact("not-recorded", source, samplerId) : scalarFact(ctx, node.inputs, key, field, source, samplerId, seen);
|
||||
}
|
||||
|
||||
function graphFacts(graph, source, resolution, budget) {
|
||||
if (!object(graph)) return factSet("unresolved", source);
|
||||
const entries = Object.entries(graph);
|
||||
if (entries.length > MAX_VISITS) return factSet("unresolved", source, "projection-limited");
|
||||
if (entries.some(([, node]) => !object(node) || !object(node.inputs) || typeof node.class_type !== "string")) return factSet("unresolved", source);
|
||||
const candidates = entries.filter(([, node]) => GENERATION_SAMPLERS.has(node.class_type));
|
||||
const selected = candidates.find(([id]) => typeof resolution?.sampler_id === "string" && id === resolution.sampler_id);
|
||||
if (!selected && candidates.length !== 1) return factSet(candidates.length > 1 ? "ambiguous" : "unresolved", source);
|
||||
const [samplerId, sampler] = selected || candidates[0];
|
||||
const ctx = createContext(graph, null, true, budget);
|
||||
const inputs = sampler.inputs;
|
||||
const advanced = sampler.class_type === "SamplerCustomAdvanced";
|
||||
const custom = advanced || sampler.class_type === "SamplerCustom";
|
||||
let settings = inputs;
|
||||
const settingsPath = new Set();
|
||||
if (advanced) {
|
||||
const [, guider] = enter(ctx, inputs.guider, settingsPath);
|
||||
settings = guider && ["CFGGuider", "BasicGuider"].includes(guider.class_type) ? guider.inputs : null;
|
||||
}
|
||||
const fromSettings = (key, field) => settings ? scalarFact(ctx, settings, key, field, source, samplerId, new Set(settingsPath)) : fact("unresolved", source, samplerId);
|
||||
const seedKey = Object.hasOwn(inputs, "seed") ? "seed" : "noise_seed";
|
||||
const facts = {
|
||||
seed: advanced ? providerFact(ctx, inputs.noise, ["noise_seed", "seed"], "seed", source, samplerId) : scalarFact(ctx, inputs, seedKey, "seed", source, samplerId),
|
||||
steps: custom ? providerFact(ctx, inputs.sigmas, ["steps"], "steps", source, samplerId) : scalarFact(ctx, inputs, "steps", "steps", source, samplerId),
|
||||
cfg: fromSettings("cfg", "cfg"),
|
||||
sampler: custom ? providerFact(ctx, inputs.sampler, ["sampler_name"], "sampler", source, samplerId) : scalarFact(ctx, inputs, "sampler_name", "sampler", source, samplerId),
|
||||
scheduler: Object.hasOwn(inputs, "scheduler") || !custom ? scalarFact(ctx, inputs, "scheduler", "scheduler", source, samplerId) : providerFact(ctx, inputs.sigmas, ["scheduler"], "scheduler", source, samplerId),
|
||||
model: fact(settings && !Object.hasOwn(settings, "model") ? "not-recorded" : "unresolved", source, samplerId),
|
||||
};
|
||||
if (settings && Object.hasOwn(settings, "model")) {
|
||||
const model = exactFactValue(traceModelName(ctx, settings.model, new Set(settingsPath)), "model");
|
||||
facts.model = fact(model === null ? "unresolved" : "known", source, samplerId, model);
|
||||
}
|
||||
return facts;
|
||||
}
|
||||
|
||||
function validFactWorkflow(workflow) {
|
||||
if (!object(workflow) || !Array.isArray(workflow.nodes) || (workflow.links !== undefined && !Array.isArray(workflow.links))) return false;
|
||||
const ids = new Set(), links = new Set(), setters = new Set();
|
||||
for (const node of workflow.nodes) {
|
||||
if (!object(node) || !["string", "number"].includes(typeof node.id) || typeof node.type !== "string" ||
|
||||
(node.inputs !== undefined && (!Array.isArray(node.inputs) || node.inputs.some(input => !object(input) || typeof input.name !== "string"))) || ids.has(String(node.id))) return false;
|
||||
ids.add(String(node.id));
|
||||
if (node.type === "SetNode") {
|
||||
const name = widgetsOf(node)[0];
|
||||
if (setters.has(name)) return false;
|
||||
setters.add(name);
|
||||
}
|
||||
}
|
||||
for (const link of workflow.links || []) {
|
||||
const id = Array.isArray(link) ? link[0] : link?.id;
|
||||
if (id === undefined || links.has(id)) return false;
|
||||
links.add(id);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
function parameterFacts(parameters) {
|
||||
const source = "embedded-parameters";
|
||||
const matches = [...parameters.matchAll(/^Steps:\s*\d+\s*,[^\n]*$/gm)];
|
||||
if (matches.length !== 1 || parameters.slice(matches[0].index + matches[0][0].length).trim()) return factSet("unresolved", source);
|
||||
const body = parameters.slice(0, matches[0].index).replace(/[\r\n]+$/, "");
|
||||
if (!body.split("\nNegative prompt:")[0].trim() || body.split("\nNegative prompt:").length > 2) return factSet("unresolved", source);
|
||||
const settings = new Map();
|
||||
for (const part of matches[0][0].split(",")) {
|
||||
const match = part.match(/^\s*([^:]+):\s*(.*?)\s*$/);
|
||||
if (!match) return factSet("unresolved", source);
|
||||
const [, key, value] = match;
|
||||
settings.set(key, settings.has(key) ? null : value);
|
||||
}
|
||||
const keys = { seed: "Seed", steps: "Steps", cfg: "CFG scale", sampler: "Sampler", scheduler: "Schedule type", model: "Model" };
|
||||
return Object.fromEntries(FACT_FIELDS.map(field => {
|
||||
const key = keys[field];
|
||||
if (!settings.has(key)) return [field, fact("not-recorded", source)];
|
||||
let value = exactFactValue(settings.get(key), field);
|
||||
if (field === "scheduler" && value !== null && !/^(automatic|normal|karras|exponential|sgm[ _]uniform|simple|ddim[ _]uniform|beta|uniform|linear[ _]quadratic|kl[ _]optimal)$/i.test(value)) value = null;
|
||||
return [field, fact(value === null ? "unresolved" : "known", source, null, value)];
|
||||
}));
|
||||
}
|
||||
|
||||
/** Consume only the exact, bounded inspection projection; never reparse raw copies. */
|
||||
function extractGenerationFacts({ prompt_graph, workflow_graph, parameters, recordFormats = {}, metadataStatus, resolution } = {}) {
|
||||
for (const [record, source] of [[prompt_graph, "api-graph"], [workflow_graph, "workflow"]]) {
|
||||
if (!record || record.status === "absent") continue;
|
||||
if (record.status === "limited") return factSet("unresolved", source, "projection-limited");
|
||||
if (record.status !== "parsed") return factSet("unresolved", source);
|
||||
const budget = { remaining: MAX_VISITS };
|
||||
if (source === "workflow") {
|
||||
if (record.value?.nodes?.length > MAX_VISITS) return factSet("unresolved", source, "projection-limited");
|
||||
if (!validFactWorkflow(record.value)) return factSet("unresolved", source);
|
||||
return graphFacts(workflowToGraph(record.value, true, budget), source, null, budget);
|
||||
}
|
||||
return graphFacts(record.value, source, resolution, budget);
|
||||
}
|
||||
if (metadataStatus === "limited") return factSet("unresolved", null, "projection-limited");
|
||||
if (metadataStatus === "unreadable") return factSet("unresolved", null, "metadata-unreadable");
|
||||
if (parameters !== undefined && parameters !== null || Object.hasOwn(recordFormats, "parameters")) {
|
||||
return recordFormats.parameters === "original-text" && typeof parameters === "string" ? parameterFacts(parameters) : factSet("unresolved");
|
||||
}
|
||||
return factSet(metadataStatus === "available" || metadataStatus === "absent" ? "not-recorded" : "unresolved");
|
||||
}
|
||||
|
||||
const api = { extractGenerationParams, extractGenerationFacts, PLACEHOLDERS };
|
||||
if (typeof module !== "undefined" && module.exports) module.exports = api;
|
||||
else root.ComfyMetadata = api;
|
||||
})(typeof window !== "undefined" ? window : globalThis);
|
||||
|
||||
@@ -0,0 +1,231 @@
|
||||
import { imageKey } from './images-state.mjs';
|
||||
import { promptRoles } from './prompt-blocks.mjs';
|
||||
|
||||
const SOURCE_CHANGED = 'The source changed. Refresh the image collection before inspecting this file.';
|
||||
const RECORD_KEYS = ['prompt', 'workflow', 'parameters', 'comfyassets_prompt_pairs'];
|
||||
const FACT_FIELDS = ['seed', 'steps', 'cfg', 'sampler', 'scheduler', 'model'];
|
||||
const object = value => value !== null && typeof value === 'object' && !Array.isArray(value);
|
||||
const validScope = value => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value) && value.length === 64;
|
||||
|
||||
export class InspectionSourceChangedError extends Error {
|
||||
constructor() {
|
||||
super(SOURCE_CHANGED);
|
||||
this.name = 'InspectionSourceChangedError';
|
||||
this.refreshRequired = true;
|
||||
}
|
||||
}
|
||||
|
||||
function descriptorScope(image) {
|
||||
if (!Object.hasOwn(image, 'root_scope')) return null;
|
||||
if (!validScope(image.root_scope)) throw new TypeError('Invalid inspection source scope');
|
||||
return image.root_scope;
|
||||
}
|
||||
|
||||
function validateIdentity(image) {
|
||||
if (!object(image) || !Number.isSafeInteger(image.root_index) || image.root_index < 0 ||
|
||||
typeof image.path !== 'string' || !image.path || image.path.includes('\\') || /^[a-z]:/i.test(image.path) || /[\x00-\x1f\x7f]/.test(image.path) ||
|
||||
image.path.split('/').some(part => !part || part === '.' || part === '..')) throw new TypeError('Invalid inspection identity');
|
||||
return descriptorScope(image);
|
||||
}
|
||||
|
||||
export function inspectPath(image) {
|
||||
const scope = validateIdentity(image);
|
||||
const query = new URLSearchParams({ root: String(image.root_index) });
|
||||
if (scope !== null) query.set('root_scope', scope);
|
||||
return `/prompt_manager/images/inspect/${image.path.split('/').map(encodeURIComponent).join('/')}?${query}`;
|
||||
}
|
||||
|
||||
function downloadFor(image, required) {
|
||||
try {
|
||||
if (typeof image.url !== 'string' || !image.url) throw new TypeError('Missing original media URL');
|
||||
const location = globalThis.location || globalThis.window?.location;
|
||||
const reference = new URL(location?.href || 'http://localhost/');
|
||||
const resolveUrl = globalThis.window?.ApiClient?.resolveUrl || globalThis.ApiClient?.resolveUrl || (url => url);
|
||||
const value = resolveUrl(image.url);
|
||||
const url = new URL(value, reference);
|
||||
const sameOrigin = 'Origin' in globalThis ?
|
||||
globalThis.Origin.from(url).isSameOrigin(globalThis.Origin.from(reference)) :
|
||||
url.origin !== 'null' && url.origin === reference.origin;
|
||||
const expected = new URL(resolveUrl(`/prompt_manager/images/serve/${image.path.split('/').map(encodeURIComponent).join('/')}`), reference);
|
||||
const scope = descriptorScope(image);
|
||||
if (!sameOrigin || !['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.hash ||
|
||||
url.pathname !== expected.pathname || url.searchParams.getAll('root').length !== 1 || url.searchParams.get('root') !== String(image.root_index) ||
|
||||
url.searchParams.getAll('root_scope').length > 1 || (scope !== null && url.searchParams.get('root_scope') !== scope) ||
|
||||
(url.searchParams.has('root_scope') && !validScope(url.searchParams.get('root_scope')))) throw new TypeError('Invalid original media identity');
|
||||
return { url: value, filename: image.path.split('/').at(-1) };
|
||||
} catch (error) {
|
||||
if (required) throw new TypeError('Invalid original media identity', { cause: error });
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
function promptsFor(value) {
|
||||
if (!object(value)) throw new TypeError('Invalid inspection prompts');
|
||||
const confirmed = promptRoles(value);
|
||||
for (const role of ['positive', 'negative']) {
|
||||
const record = value[role];
|
||||
if (record === undefined) continue;
|
||||
if (!object(record) || typeof record.status !== 'string' ||
|
||||
(record.text !== undefined && record.text !== null && typeof record.text !== 'string') ||
|
||||
(record.status === 'resolved' && !Object.hasOwn(confirmed, role))) throw new TypeError('Invalid inspection role');
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
function fileFor(value) {
|
||||
if (!object(value) || value.observation !== 'current-file' || typeof value.source_label !== 'string' ||
|
||||
!['image', 'video'].includes(value.media_type) || typeof value.extension !== 'string' ||
|
||||
(value.format !== null && typeof value.format !== 'string')) throw new TypeError('Invalid inspection file');
|
||||
const file = { observation: value.observation, source_label: value.source_label, media_type: value.media_type, extension: value.extension, format: value.format };
|
||||
for (const key of ['size', 'width', 'height', 'modified_time']) {
|
||||
const item = value[key] ?? null;
|
||||
if (item !== null && (typeof item !== 'number' || !Number.isFinite(item) ||
|
||||
(['width', 'height'].includes(key) ? !Number.isSafeInteger(item) || item <= 0 : item < 0))) throw new TypeError('Invalid inspection file observation');
|
||||
file[key] = item;
|
||||
}
|
||||
return file;
|
||||
}
|
||||
|
||||
function graphFor(value) {
|
||||
if (!object(value) || !['parsed', 'absent', 'malformed', 'limited'].includes(value.status) ||
|
||||
(value.status === 'parsed' ? !object(value.value) : value.value !== null)) throw new TypeError('Invalid inspection graph');
|
||||
return { status: value.status, value: value.value };
|
||||
}
|
||||
|
||||
function metadataFor(value) {
|
||||
if (!object(value) || !['available', 'absent', 'unreadable', 'limited'].includes(value.status) ||
|
||||
![null, 'response-size-limit'].includes(value.omitted_reason) || !object(value.raw) || !object(value.record_formats) ||
|
||||
(value.parameters !== null && typeof value.parameters !== 'string')) throw new TypeError('Invalid inspection metadata');
|
||||
const raw = {}, formats = {};
|
||||
for (const [key, format] of Object.entries(value.record_formats)) {
|
||||
if (!RECORD_KEYS.includes(key) || !['original-text', 'reserialized-json', 'invalid'].includes(format)) throw new TypeError('Invalid inspection record format');
|
||||
formats[key] = format;
|
||||
}
|
||||
for (const [key, text] of Object.entries(value.raw)) {
|
||||
if (!RECORD_KEYS.includes(key) || typeof text !== 'string' || !Object.hasOwn(formats, key) || formats[key] === 'invalid') throw new TypeError('Invalid inspection raw record');
|
||||
raw[key] = text;
|
||||
}
|
||||
if (value.parameters !== (raw.parameters ?? null)) throw new TypeError('Invalid inspection parameters projection');
|
||||
const prompt = graphFor(value.prompt_graph), workflow = graphFor(value.workflow_graph);
|
||||
for (const [key, graph] of [['prompt', prompt], ['workflow', workflow]]) {
|
||||
const hasRecord = Object.hasOwn(formats, key);
|
||||
if ((formats[key] === 'invalid' && graph.status !== 'malformed') ||
|
||||
hasRecord !== (graph.status !== 'absent')) throw new TypeError('Invalid graph representation provenance');
|
||||
}
|
||||
if ((value.status === 'limited') !== (value.omitted_reason === 'response-size-limit')) throw new TypeError('Invalid metadata omission status');
|
||||
if (['absent', 'unreadable'].includes(value.status) && (Object.keys(raw).length || Object.keys(formats).length || prompt.status !== 'absent' || workflow.status !== 'absent')) throw new TypeError('Invalid unavailable metadata');
|
||||
return { status: value.status, omitted_reason: value.omitted_reason, raw, record_formats: formats, prompt_graph: prompt, workflow_graph: workflow, parameters: value.parameters };
|
||||
}
|
||||
|
||||
function libraryFor(value) {
|
||||
if (!object(value) || !['linked', 'none', 'ambiguous', 'unavailable', 'limited'].includes(value.status) || value.scope !== 'saved-library' ||
|
||||
!Array.isArray(value.tags) || value.tags.some(tag => typeof tag !== 'string') || ![null, 'pair', 'positive'].includes(value.metadata_scope)) throw new TypeError('Invalid inspection library');
|
||||
const library = { status: value.status, scope: value.scope, tags: [...value.tags], metadata_scope: value.metadata_scope };
|
||||
for (const key of ['positive_id', 'pair_id', 'title', 'category']) {
|
||||
const item = value[key] ?? null;
|
||||
if (item !== null && (key.endsWith('_id') ? !Number.isSafeInteger(item) || item <= 0 : typeof item !== 'string')) throw new TypeError('Invalid inspection library field');
|
||||
library[key] = item;
|
||||
}
|
||||
return library;
|
||||
}
|
||||
|
||||
function unavailableFacts() {
|
||||
return Object.fromEntries(FACT_FIELDS.map(key => [key, { status: 'unresolved', value: null, source: null, evidence: null, reason: null, sampler_id: null }]));
|
||||
}
|
||||
|
||||
export function toInspectionRecord(result, image, extractFacts = globalThis.ComfyMetadata?.extractGenerationFacts || globalThis.window?.ComfyMetadata?.extractGenerationFacts) {
|
||||
const scope = validateIdentity(image);
|
||||
if (scope !== null && (!object(result) || result.root_scope !== scope)) throw new InspectionSourceChangedError();
|
||||
if (!object(result) || result.success === false) throw new TypeError('Invalid inspection response');
|
||||
const legacy = result.inspection_version === undefined;
|
||||
if (!legacy && result.inspection_version !== 1) throw new TypeError('Unsupported inspection version');
|
||||
if (!legacy && result.success !== true) throw new TypeError('Invalid inspection success status');
|
||||
if ((!legacy || result.image !== undefined) && (!object(result.image) || result.image.root_index !== image.root_index || result.image.path !== image.path || result.image.filename !== image.path.split('/').at(-1))) throw new TypeError('Mismatched inspection identity');
|
||||
const record = {
|
||||
identity: { kind: 'rooted-file', key: imageKey(image), root_index: image.root_index, path: image.path, root_scope: scope },
|
||||
file: null, prompts: promptsFor(result.prompts), library: null, metadata: null,
|
||||
generation: unavailableFacts(), historyTarget: null, download: downloadFor(image, !legacy || scope !== null),
|
||||
};
|
||||
if (legacy) return record;
|
||||
const resolution = result.resolution;
|
||||
if (!object(resolution) || !['resolved', 'absent', 'ambiguous', 'unresolved'].includes(resolution.state) ||
|
||||
(resolution.sampler_id !== null && (typeof resolution.sampler_id !== 'string' || !resolution.sampler_id)) || typeof resolution.reason !== 'string') throw new TypeError('Invalid inspection resolution');
|
||||
record.file = fileFor(result.file);
|
||||
record.metadata = metadataFor(result.metadata);
|
||||
record.library = libraryFor(result.library);
|
||||
if (typeof extractFacts !== 'function') throw new TypeError('Inspection facts parser unavailable');
|
||||
record.generation = extractFacts({ prompt_graph: record.metadata.prompt_graph, workflow_graph: record.metadata.workflow_graph,
|
||||
parameters: record.metadata.parameters, recordFormats: record.metadata.record_formats, metadataStatus: record.metadata.status, resolution });
|
||||
if (record.library.status === 'linked' && record.library.positive_id !== null) record.historyTarget = `#/library/${record.library.positive_id}`;
|
||||
return record;
|
||||
}
|
||||
|
||||
export function createInspectionLoader(api, onChange, { extractFacts } = {}) {
|
||||
let request = null, disposed = false;
|
||||
return {
|
||||
async load(image) {
|
||||
if (disposed) return;
|
||||
request?.abort();
|
||||
const current = request = new AbortController();
|
||||
onChange({ loading: true });
|
||||
try {
|
||||
const result = await api.get(inspectPath(image), { signal: current.signal });
|
||||
if (disposed || request !== current) return;
|
||||
const record = toInspectionRecord(result, image, extractFacts);
|
||||
onChange({ prompts: record.prompts, record });
|
||||
} catch (error) {
|
||||
if (disposed || request !== current) return;
|
||||
if (error?.status === 409 && error.code === 'source-changed') error = new InspectionSourceChangedError();
|
||||
const refreshRequired = error instanceof InspectionSourceChangedError;
|
||||
onChange({ error: true, refreshRequired, message: refreshRequired ? SOURCE_CHANGED : 'Could not read details from this file.' });
|
||||
}
|
||||
},
|
||||
dispose() { disposed = true; request?.abort(); request = null; },
|
||||
};
|
||||
}
|
||||
|
||||
const emptyState = () => ({ loading: false, error: false, record: null, prompts: undefined, message: '', refreshRequired: false });
|
||||
|
||||
export function createInspectionController({ api, extractFacts }) {
|
||||
let state = Object.freeze(emptyState()), current = null, pending = null, disposed = false;
|
||||
const listeners = new Set();
|
||||
function publish(update) {
|
||||
if (disposed) return;
|
||||
state = Object.freeze({ ...emptyState(), ...update });
|
||||
for (const listener of listeners) listener(state);
|
||||
}
|
||||
const makeLoader = () => createInspectionLoader(api, publish, { extractFacts });
|
||||
let loader = makeLoader();
|
||||
function read(image) {
|
||||
pending = loader.load(image);
|
||||
return pending;
|
||||
}
|
||||
return {
|
||||
get state() { return state; },
|
||||
select(image) {
|
||||
if (disposed) return;
|
||||
const scope = validateIdentity(image), key = imageKey(image);
|
||||
if (current?.key === key && current.scope === scope) return pending;
|
||||
current = { key, scope, image: { ...image } };
|
||||
return read(current.image);
|
||||
},
|
||||
retry() {
|
||||
if (disposed || !current || state.refreshRequired) return;
|
||||
return read(current.image);
|
||||
},
|
||||
clear() {
|
||||
if (disposed) return;
|
||||
loader.dispose(); loader = makeLoader(); current = null; pending = null;
|
||||
publish({});
|
||||
},
|
||||
subscribe(listener) {
|
||||
if (disposed) return () => {};
|
||||
listeners.add(listener); listener(state);
|
||||
return () => listeners.delete(listener);
|
||||
},
|
||||
dispose() {
|
||||
if (disposed) return;
|
||||
disposed = true; loader.dispose(); listeners.clear(); current = null; pending = null; state = Object.freeze(emptyState());
|
||||
},
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,116 @@
|
||||
import { createScope, createButton } from '../shared/toolkit/core.js';
|
||||
import { createSendButton } from './prompt-sender.mjs';
|
||||
import { createWorkspaceIcon } from './icons.mjs';
|
||||
|
||||
export function promptRoles(prompts) {
|
||||
return Object.fromEntries(['positive', 'negative'].filter(role => prompts?.[role]?.status === 'resolved' && typeof prompts[role].text === 'string').map(role => [role, prompts[role].text]));
|
||||
}
|
||||
|
||||
const sources = {
|
||||
library: 'Saved library prompt',
|
||||
execution: 'Recorded at execution',
|
||||
'graph-inferred': 'Inferred from the saved workflow',
|
||||
'embedded-parameters': 'Embedded generation parameters',
|
||||
'saved-association': 'Saved library association',
|
||||
};
|
||||
const statuses = {
|
||||
absent: 'Not recorded in this file.',
|
||||
ambiguous: 'Multiple possible prompts. Source could not be determined.',
|
||||
unresolved: 'Prompt could not be resolved.',
|
||||
};
|
||||
function el(tag, text, className) {
|
||||
const node = document.createElement(tag);
|
||||
if (text !== undefined) node.textContent = text;
|
||||
if (className) node.className = className;
|
||||
return node;
|
||||
}
|
||||
|
||||
function childScope(parentScope) {
|
||||
const scope = createScope();
|
||||
const dispose = () => scope.dispose();
|
||||
parentScope.signal.addEventListener('abort', dispose, {once:true});
|
||||
scope.cleanup(() => parentScope.signal.removeEventListener('abort', dispose));
|
||||
if (parentScope.signal.aborted) scope.dispose();
|
||||
return scope;
|
||||
}
|
||||
|
||||
export function mountPromptBlocks(container, {prompts, sender, parentScope, roles:visibleRoles = ['positive', 'negative'], onRetry}) {
|
||||
if (parentScope.signal.aborted) return {update() {}, setState() {}, dispose() {}};
|
||||
const scope = childScope(parentScope);
|
||||
container.classList.add('prompt-inspector');
|
||||
scope.listen(container, 'click', async event => {
|
||||
const send = event.target.closest('[data-send-role]');
|
||||
if (send) {
|
||||
const role = send.dataset.sendRole;
|
||||
sender.open(role === 'pair' ? roles : {[role]:roles[role]}, send);
|
||||
}
|
||||
const copy = event.target.closest('[data-copy-role]');
|
||||
if (copy) {
|
||||
const role = copy.dataset.copyRole;
|
||||
const status = copy.closest('section').querySelector('.prompt-copy-status');
|
||||
try {
|
||||
await navigator.clipboard.writeText(roles[role]);
|
||||
if (!scope.signal.aborted) status.textContent = 'Copied.';
|
||||
} catch {
|
||||
if (!scope.signal.aborted) status.textContent = 'Copy unavailable. Select the prompt text to copy it.';
|
||||
}
|
||||
}
|
||||
if (event.target.closest('[data-retry-prompts]')) onRetry?.();
|
||||
});
|
||||
let roles = {};
|
||||
function render(state) {
|
||||
if (scope.signal.aborted) return;
|
||||
roles = {};
|
||||
container.replaceChildren();
|
||||
if (state.loading || state.error) {
|
||||
const status = el('p', state.loading ? 'Loading prompts…' : 'Could not read prompts from this file.', 'muted');
|
||||
status.setAttribute('role', state.error ? 'alert' : 'status');
|
||||
container.append(status);
|
||||
if (state.error && onRetry) {
|
||||
const retry = createButton('Retry prompt details');
|
||||
retry.dataset.retryPrompts = '';
|
||||
container.append(retry);
|
||||
}
|
||||
return;
|
||||
}
|
||||
roles = Object.fromEntries(Object.entries(promptRoles(state.prompts)).filter(([role]) => visibleRoles.includes(role)));
|
||||
for (const role of visibleRoles) {
|
||||
const title = `${role[0].toUpperCase() + role.slice(1)} prompt`;
|
||||
const record = state.prompts?.[role];
|
||||
const block = el('section', undefined, `prompt-block prompt-${role}`);
|
||||
block.setAttribute('aria-label', title);
|
||||
const heading = el('div', undefined, 'prompt-block-heading');
|
||||
heading.append(el('h3', title));
|
||||
block.append(heading);
|
||||
if (Object.hasOwn(roles, role)) {
|
||||
block.append(el('p', sources[record.source] || 'Source not recorded', 'prompt-source muted'));
|
||||
if (roles[role] === '') block.append(el('p', `Empty ${role} prompt`, 'prompt-empty'));
|
||||
else {
|
||||
const text = el('pre', roles[role], 'prompt-text');
|
||||
text.tabIndex = 0;
|
||||
block.append(text);
|
||||
}
|
||||
const actions = el('div', undefined, 'prompt-actions');
|
||||
const send = createSendButton(`Send ${role} prompt`);
|
||||
send.dataset.sendRole = role;
|
||||
const copy = createButton('', 'ca-icon-button');
|
||||
copy.setAttribute('aria-label', `Copy ${role} prompt`);
|
||||
copy.title = `Copy ${role} prompt`;
|
||||
copy.append(createWorkspaceIcon('copy'));
|
||||
copy.dataset.copyRole = role;
|
||||
actions.append(copy, send);
|
||||
heading.append(actions);
|
||||
const status = el('p', '', 'prompt-copy-status muted'); status.setAttribute('role', 'status');
|
||||
block.append(status);
|
||||
} else block.append(el('p', typeof record?.message === 'string' ? record.message : statuses[record?.status] || statuses.unresolved, 'muted'));
|
||||
container.append(block);
|
||||
}
|
||||
if (Object.hasOwn(roles, 'positive') && Object.hasOwn(roles, 'negative')) {
|
||||
const pair = createSendButton('Send prompt pair'); pair.dataset.sendRole = 'pair';
|
||||
container.append(pair);
|
||||
}
|
||||
}
|
||||
render({prompts});
|
||||
return {update:prompts => render({prompts}), setState:render, dispose:() => scope.dispose()};
|
||||
}
|
||||
|
||||
@@ -1,52 +1,9 @@
|
||||
import { createScope, createButton } from '../shared/toolkit/core.js';
|
||||
import { createSendButton } from './prompt-sender.mjs';
|
||||
import { createWorkspaceIcon } from './icons.mjs';
|
||||
import { createScope } from '../shared/toolkit/core.js';
|
||||
import { mountPromptBlocks } from './prompt-blocks.mjs';
|
||||
import { createInspectionLoader } from './inspection-state.mjs';
|
||||
|
||||
export function inspectPath(image) {
|
||||
return `/prompt_manager/images/inspect/${image.path.split('/').map(encodeURIComponent).join('/')}?root=${image.root_index}`;
|
||||
}
|
||||
|
||||
export function promptRoles(prompts) {
|
||||
return Object.fromEntries(['positive', 'negative'].filter(role => prompts?.[role]?.status === 'resolved' && typeof prompts[role].text === 'string').map(role => [role, prompts[role].text]));
|
||||
}
|
||||
|
||||
export function createInspectionLoader(api, onChange) {
|
||||
let request, disposed = false;
|
||||
return {
|
||||
async load(image) {
|
||||
if (disposed) return;
|
||||
request?.abort();
|
||||
const current = request = new AbortController();
|
||||
onChange({ loading: true });
|
||||
try {
|
||||
const result = await api.get(inspectPath(image), {signal:current.signal});
|
||||
if (!disposed && request === current) onChange({prompts:result.prompts});
|
||||
} catch {
|
||||
if (!disposed && request === current) onChange({error:true});
|
||||
}
|
||||
},
|
||||
dispose() { disposed = true; request?.abort(); },
|
||||
};
|
||||
}
|
||||
|
||||
const sources = {
|
||||
library: 'Saved library prompt',
|
||||
execution: 'Recorded at execution',
|
||||
'graph-inferred': 'Inferred from the saved workflow',
|
||||
'embedded-parameters': 'Embedded generation parameters',
|
||||
'saved-association': 'Saved library association',
|
||||
};
|
||||
const statuses = {
|
||||
absent: 'Not recorded in this file.',
|
||||
ambiguous: 'Multiple possible prompts. Source could not be determined.',
|
||||
unresolved: 'Prompt could not be resolved.',
|
||||
};
|
||||
function el(tag, text, className) {
|
||||
const node = document.createElement(tag);
|
||||
if (text !== undefined) node.textContent = text;
|
||||
if (className) node.className = className;
|
||||
return node;
|
||||
}
|
||||
export { promptRoles, mountPromptBlocks } from './prompt-blocks.mjs';
|
||||
export { inspectPath, createInspectionLoader } from './inspection-state.mjs';
|
||||
|
||||
function childScope(parentScope) {
|
||||
const scope = createScope();
|
||||
@@ -57,85 +14,6 @@ function childScope(parentScope) {
|
||||
return scope;
|
||||
}
|
||||
|
||||
export function mountPromptBlocks(container, {prompts, sender, parentScope, roles:visibleRoles = ['positive', 'negative'], onRetry}) {
|
||||
const scope = childScope(parentScope);
|
||||
container.classList.add('prompt-inspector');
|
||||
scope.listen(container, 'click', async event => {
|
||||
const send = event.target.closest('[data-send-role]');
|
||||
if (send) {
|
||||
const role = send.dataset.sendRole;
|
||||
sender.open(role === 'pair' ? roles : {[role]:roles[role]}, send);
|
||||
}
|
||||
const copy = event.target.closest('[data-copy-role]');
|
||||
if (copy) {
|
||||
const role = copy.dataset.copyRole;
|
||||
const status = copy.closest('section').querySelector('.prompt-copy-status');
|
||||
try {
|
||||
await navigator.clipboard.writeText(roles[role]);
|
||||
if (!scope.signal.aborted) status.textContent = 'Copied.';
|
||||
} catch {
|
||||
if (!scope.signal.aborted) status.textContent = 'Copy unavailable. Select the prompt text to copy it.';
|
||||
}
|
||||
}
|
||||
if (event.target.closest('[data-retry-prompts]')) onRetry?.();
|
||||
});
|
||||
let roles = {};
|
||||
function render(state) {
|
||||
if (scope.signal.aborted) return;
|
||||
roles = {};
|
||||
container.replaceChildren();
|
||||
if (state.loading || state.error) {
|
||||
const status = el('p', state.loading ? 'Loading prompts…' : 'Could not read prompts from this file.', 'muted');
|
||||
status.setAttribute('role', state.error ? 'alert' : 'status');
|
||||
container.append(status);
|
||||
if (state.error && onRetry) {
|
||||
const retry = createButton('Retry prompt details');
|
||||
retry.dataset.retryPrompts = '';
|
||||
container.append(retry);
|
||||
}
|
||||
return;
|
||||
}
|
||||
roles = Object.fromEntries(Object.entries(promptRoles(state.prompts)).filter(([role]) => visibleRoles.includes(role)));
|
||||
for (const role of visibleRoles) {
|
||||
const title = `${role[0].toUpperCase() + role.slice(1)} prompt`;
|
||||
const record = state.prompts?.[role];
|
||||
const block = el('section', undefined, `prompt-block prompt-${role}`);
|
||||
block.setAttribute('aria-label', title);
|
||||
const heading = el('div', undefined, 'prompt-block-heading');
|
||||
heading.append(el('h3', title));
|
||||
block.append(heading);
|
||||
if (Object.hasOwn(roles, role)) {
|
||||
block.append(el('p', sources[record.source] || 'Source not recorded', 'prompt-source muted'));
|
||||
if (roles[role] === '') block.append(el('p', `Empty ${role} prompt`, 'prompt-empty'));
|
||||
else {
|
||||
const text = el('pre', roles[role], 'prompt-text');
|
||||
text.tabIndex = 0;
|
||||
block.append(text);
|
||||
}
|
||||
const actions = el('div', undefined, 'prompt-actions');
|
||||
const send = createSendButton(`Send ${role} prompt`);
|
||||
send.dataset.sendRole = role;
|
||||
const copy = createButton('', 'ca-icon-button');
|
||||
copy.setAttribute('aria-label', `Copy ${role} prompt`);
|
||||
copy.title = `Copy ${role} prompt`;
|
||||
copy.append(createWorkspaceIcon('copy'));
|
||||
copy.dataset.copyRole = role;
|
||||
actions.append(copy, send);
|
||||
heading.append(actions);
|
||||
const status = el('p', '', 'prompt-copy-status muted'); status.setAttribute('role', 'status');
|
||||
block.append(status);
|
||||
} else block.append(el('p', typeof record?.message === 'string' ? record.message : statuses[record?.status] || statuses.unresolved, 'muted'));
|
||||
container.append(block);
|
||||
}
|
||||
if (Object.hasOwn(roles, 'positive') && Object.hasOwn(roles, 'negative')) {
|
||||
const pair = createSendButton('Send prompt pair'); pair.dataset.sendRole = 'pair';
|
||||
container.append(pair);
|
||||
}
|
||||
}
|
||||
render({prompts});
|
||||
return {update:prompts => render({prompts}), setState:render, dispose:() => scope.dispose()};
|
||||
}
|
||||
|
||||
export function mountPromptInspector(container, {api, image, sender, parentScope}) {
|
||||
const scope = childScope(parentScope);
|
||||
let loader;
|
||||
|
||||
@@ -11,6 +11,7 @@
|
||||
<link rel="stylesheet" href="js/workspace/images.css">
|
||||
<link rel="stylesheet" href="js/workspace/library.css">
|
||||
<script src="lib/viewerjs/viewer.min.js" defer></script>
|
||||
<script src="js/comfy-metadata.js" defer></script>
|
||||
<script type="module" src="js/workspace/index.mjs"></script>
|
||||
</head>
|
||||
<body class="ca-tools">
|
||||
|
||||
Reference in New Issue
Block a user