@ggui-ai/ui-gen 0.27.0 → 0.29.0

package/dist/chunk-WEOXFEVE.js

@@ -0,0 +1,739 @@
+import { emitValidatorTraceEvent, truncateSourceForTrace, newValidatorTraceId } from './chunk-WYHP46LT.js';
+import { pickWorkflow } from './chunk-S2GVXKKY.js';
+import { traceAxisChecksSkipped, runGatedAxisChecks } from './chunk-U7GALWLG.js';
+import { buildSystemPrompt, generateBoilerplate } from './chunk-FB7OEEAH.js';
+import { hasProfile } from './chunk-NF6JUZWF.js';
+import { DEFAULT_DESIGN_MODE } from './chunk-3T2HMTON.js';
+import { compose } from './chunk-YIQ42IUX.js';
+import { hashClassification, computeHarnessId, computeHarnessName } from './chunk-DUU3ZJDQ.js';
+import { defaultApplyPatch } from './chunk-TVHGKFJS.js';
+import { DEFAULT_HARNESS_POLICY, isDefaultHarnessPolicy } from './chunk-JMD4RGSV.js';
+import { createHash } from 'crypto';
+
+// src/run-workflow.ts
+var noopDefaultRunner = async (task) => task.id;
+async function runWorkflow(input) {
+  const { harness, prompt, contract, taskRunners, defaultRunner, initialResults } = input;
+  const workflow = harness.process.workflow;
+  const startTotal = Date.now();
+  const priorResults = { ...initialResults ?? {} };
+  const phaseResults = [];
+  const runners = taskRunners ?? {};
+  const fallback = defaultRunner ?? noopDefaultRunner;
+  for (const phase of workflow.phases) {
+    const phaseStart = Date.now();
+    const ctx = {
+      harness,
+      priorResults: { ...priorResults },
+      classification: harness.classification,
+      prompt,
+      contract
+    };
+    const taskPromises = phase.tasks.map(async (task) => {
+      const taskStart = Date.now();
+      const runner = runners[task.id] ?? fallback;
+      const output = await runner(task, ctx);
+      return {
+        taskId: task.id,
+        outputName: task.outputName,
+        output,
+        durationMs: Date.now() - taskStart
+      };
+    });
+    const taskResults = await Promise.all(taskPromises);
+    for (const tr of taskResults) {
+      priorResults[tr.outputName] = tr.output;
+    }
+    phaseResults.push({
+      phaseId: phase.id,
+      taskResults,
+      durationMs: Date.now() - phaseStart
+    });
+  }
+  return {
+    workflowId: workflow.id,
+    phases: phaseResults,
+    results: { ...priorResults },
+    durationMs: Date.now() - startTotal
+  };
+}
+
+// src/run-check.ts
+async function runCheck(input) {
+  const { harness, sourceCode, compiledCode, contract, prompt } = input;
+  const check = harness.check;
+  const startedAt = Date.now();
+  if (compiledCode === null) {
+    traceAxisChecksSkipped(
+      { sourceCode, contract, originalPrompt: prompt, classification: harness.classification, designMode: harness.designMode },
+      "compiledCode null \u2014 no check ran"
+    );
+    const result2 = {
+      issues: [],
+      axisIssueCount: 0,
+      tierIssueCount: 0,
+      llmIssueCount: 0,
+      runtimeRenderIssueCount: 0,
+      firedCheckIds: []
+    };
+    const endedAt2 = Date.now();
+    emitValidatorTraceEvent({
+      id: newValidatorTraceId(),
+      at: startedAt,
+      endedAt: endedAt2,
+      durationMs: endedAt2 - startedAt,
+      harnessId: harness.id,
+      classification: harness.classification,
+      workflowId: harness.process.workflow.id,
+      hadCompiledCode: false,
+      skippedRuntimeRender: input.skipRuntimeRender ?? false,
+      summary: {
+        totalIssues: 0,
+        axisIssues: 0,
+        tierIssues: 0,
+        llmIssues: 0,
+        runtimeRenderIssues: 0,
+        firedCheckIds: []
+      },
+      issues: [],
+      sourceCode: truncateSourceForTrace(sourceCode),
+      prompt
+    });
+    return result2;
+  }
+  const issues = [];
+  const firedIds = [];
+  const axisInput = {
+    sourceCode,
+    compiledCode,
+    contract,
+    originalPrompt: prompt,
+    classification: harness.classification,
+    designMode: harness.designMode,
+    // ggui#1117: the canvas the harness was built for, when it has one — never a default.
+    ...harness.canvas !== void 0 ? { canvas: harness.canvas } : {},
+    // ggui#1285: the props the probe and judge rendered with — the fixture-echo check reads them.
+    ...input.fixtureProps !== void 0 ? { fixtureProps: input.fixtureProps } : {}
+  };
+  const axisRun = runGatedAxisChecks(check.axisChecks, axisInput);
+  issues.push(...axisRun.issues);
+  firedIds.push(...axisRun.firedIds);
+  const axisIssueCount = axisRun.issues.length;
+  let tierIssueCount = 0;
+  for (const tierCheck of check.tierChecks) {
+    firedIds.push(tierCheck.id);
+    const tierIssues = await tierCheck.run({ sourceCode, compiledCode });
+    issues.push(...tierIssues);
+    tierIssueCount += tierIssues.length;
+  }
+  let runtimeRenderIssueCount = 0;
+  if (check.runtimeRender && !input.skipRuntimeRender) {
+    const cheapTier0Failures = issues.filter(
+      (i) => i.result === "fail" && (i.tier === 0 || i.tier === void 0)
+    ).length;
+    if (cheapTier0Failures === 0) {
+      const outcome = await check.runtimeRender.run({
+        sourceCode,
+        compiledCode,
+        contract,
+        fixtureProps: input.fixtureProps
+      });
+      if (outcome.status === "ran") {
+        firedIds.push(check.runtimeRender.id);
+        issues.push(...outcome.issues);
+        runtimeRenderIssueCount = outcome.issues.length;
+      }
+    }
+  }
+  let llmIssueCount = 0;
+  if (check.llmEvaluator && contract) {
+    firedIds.push(check.llmEvaluator.id);
+    const llmIssues = await check.llmEvaluator.run({
+      sourceCode,
+      compiledCode,
+      contract,
+      prompt
+    });
+    issues.push(...llmIssues);
+    llmIssueCount = llmIssues.length;
+  }
+  const result = {
+    issues,
+    axisIssueCount,
+    tierIssueCount,
+    llmIssueCount,
+    runtimeRenderIssueCount,
+    firedCheckIds: firedIds
+  };
+  const endedAt = Date.now();
+  emitValidatorTraceEvent({
+    id: newValidatorTraceId(),
+    at: startedAt,
+    endedAt,
+    durationMs: endedAt - startedAt,
+    harnessId: harness.id,
+    classification: harness.classification,
+    workflowId: harness.process.workflow.id,
+    hadCompiledCode: true,
+    skippedRuntimeRender: input.skipRuntimeRender ?? false,
+    summary: {
+      totalIssues: issues.length,
+      axisIssues: axisIssueCount,
+      tierIssues: tierIssueCount,
+      llmIssues: llmIssueCount,
+      runtimeRenderIssues: runtimeRenderIssueCount,
+      firedCheckIds: firedIds
+    },
+    issues,
+    sourceCode: truncateSourceForTrace(sourceCode),
+    prompt
+  });
+  return result;
+}
+
+// src/run-harness.ts
+var defaultPasses = (r) => r.issues.every((i) => i.result !== "fail");
+async function runHarness(input) {
+  const {
+    harness: initialHarness,
+    prompt,
+    contract,
+    taskRunners,
+    compile,
+    passes = defaultPasses,
+    maxIterations: explicitMax,
+    skipCheck = false
+  } = input;
+  const maxIterations = explicitMax ?? initialHarness.process.retry.maxIterations;
+  const start = Date.now();
+  const iterations = [];
+  let harness = initialHarness;
+  let lastSource = null;
+  let lastCompiled = null;
+  let lastCheck = null;
+  for (let i = 1; i <= maxIterations; i++) {
+    const workflowResult = await runWorkflow({
+      harness,
+      prompt,
+      contract,
+      taskRunners
+    });
+    const source = workflowResult.results.source ?? null;
+    let compiled = null;
+    if (source && compile) {
+      compiled = await compile(source);
+    } else if (source && !compile) {
+      compiled = source;
+    }
+    const compileFailed = source !== null && compile !== void 0 && compiled === null;
+    const checkStart = Date.now();
+    const checkResult = source && !compileFailed && !skipCheck ? await runCheck({ harness, sourceCode: source, compiledCode: compiled, contract, prompt }) : { issues: [], axisIssueCount: 0, tierIssueCount: 0, llmIssueCount: 0, runtimeRenderIssueCount: 0, firedCheckIds: [] };
+    const checkDurationMs = Date.now() - checkStart;
+    iterations.push({
+      iteration: i,
+      harnessId: harness.id,
+      workflowId: harness.process.workflow.id,
+      source,
+      compiled,
+      workflowDurationMs: workflowResult.durationMs,
+      checkDurationMs,
+      issueCount: checkResult.issues.length,
+      firedCheckIds: checkResult.firedCheckIds
+    });
+    lastSource = source;
+    lastCompiled = compiled;
+    lastCheck = checkResult;
+    if (!source) {
+      return buildResult({
+        ok: false,
+        reason: "no-source",
+        finalHarness: harness,
+        finalSource: null,
+        finalCompiled: null,
+        finalCheck: checkResult,
+        iterations,
+        start
+      });
+    }
+    if (compileFailed) {
+      return buildResult({
+        ok: false,
+        reason: "compile-failed",
+        finalHarness: harness,
+        finalSource: source,
+        finalCompiled: null,
+        finalCheck: checkResult,
+        iterations,
+        start
+      });
+    }
+    if (passes(checkResult)) {
+      return buildResult({
+        ok: true,
+        reason: "passed",
+        finalHarness: harness,
+        finalSource: source,
+        finalCompiled: compiled,
+        finalCheck: checkResult,
+        iterations,
+        start
+      });
+    }
+    if (i < maxIterations) {
+      harness = harness.derive({});
+    }
+  }
+  return buildResult({
+    ok: false,
+    reason: "max-iterations",
+    finalHarness: harness,
+    finalSource: lastSource,
+    finalCompiled: lastCompiled,
+    finalCheck: lastCheck,
+    iterations,
+    start
+  });
+}
+function buildResult(args) {
+  return {
+    ok: args.ok,
+    reason: args.reason,
+    finalHarness: args.finalHarness,
+    finalSource: args.finalSource,
+    finalCompiled: args.finalCompiled,
+    finalCheck: args.finalCheck,
+    iterations: args.iterations,
+    durationMs: Date.now() - args.start
+  };
+}
+
+// src/tools.ts
+var APPLY_CHANGES_TOOL = {
+  name: "apply_changes",
+  description: "Surgical edit: replace line ranges in ui.tsx with new code. Use line numbers from the Current File (shown as N\u2502). Preferred for targeted changes \u2014 fixing one hook, renaming a prop, swapping a component, closing a missing tag. The patch is ALWAYS applied to the workspace even if the resulting file has syntax errors \u2014 the error location is returned as guidance so you can iterate. If the file is in a tangled state and patches aren't converging cleanly, use `write` to rewrite from scratch.",
+  parameters: {
+    type: "object",
+    properties: {
+      changes: {
+        type: "array",
+        description: "Array of changes. Each replaces lines startLine through endLine (inclusive) with the new code lines. Applied bottom-to-top to preserve line numbers.",
+        items: {
+          type: "object",
+          properties: {
+            startLine: {
+              type: "number",
+              description: "First line to replace (from the N\u2502 numbers in Current File)"
+            },
+            endLine: { type: "number", description: "Last line to replace (inclusive)" },
+            code: {
+              type: "array",
+              items: { type: "string" },
+              description: "New code lines. One source line per array element. Avoid embedding newlines inside an element. For long JSX blocks, split at statement boundaries across multiple changes."
+            },
+            description: { type: "string", description: "What this change does (< 10 words)" }
+          },
+          required: ["startLine", "endLine", "code", "description"]
+        }
+      },
+      commit_message: { type: "string", description: "Short summary of all changes" },
+      allowBroken: {
+        type: "boolean",
+        description: "Opt-in: commit the patch even if the resulting file fails syntax preflight. Use when you want to iterate across multiple turns and accept a broken intermediate state (e.g., split a big JSX refactor into 2 patches). Default false (strict preflight)."
+      }
+    },
+    required: ["changes", "commit_message"]
+  }
+};
+var APPLY_CHANGES_TOOL_SCOPED = {
+  name: "apply_changes",
+  description: "Replace ONE small line range in ui.tsx. Narrow schema for transport-error recovery: emit a single change covering at most 20 lines.",
+  parameters: {
+    type: "object",
+    properties: {
+      changes: {
+        type: "array",
+        minItems: 1,
+        maxItems: 1,
+        description: "Single change. endLine - startLine \u2264 20.",
+        items: {
+          type: "object",
+          properties: {
+            startLine: { type: "number", description: "First line to replace" },
+            endLine: {
+              type: "number",
+              description: "Last line (inclusive). Keep endLine - startLine \u2264 20."
+            },
+            code: {
+              type: "array",
+              items: { type: "string" },
+              description: "New code lines (one source line per element, no embedded newlines). \u2264 20 elements."
+            },
+            description: { type: "string", description: "What this change does (< 10 words)" }
+          },
+          required: ["startLine", "endLine", "code", "description"]
+        }
+      },
+      commit_message: { type: "string", description: "Short summary" }
+    },
+    required: ["changes", "commit_message"]
+  }
+};
+var APPLY_CHANGES_HASHLINE_TOOL = {
+  name: "apply_changes",
+  description: "Surgical edit with line-hash verification. Replace line ranges in ui.tsx. Line refs use the format `N:hh` from the Current File block (e.g., `47:a3`) \u2014 the 2-char hash anchors your view so the edit is rejected if the file drifted under you. Always use the exact hashes shown in the latest Current File view. The patch is applied even if the resulting file has syntax errors (the error location is returned as guidance); but edits with mismatched hashes are rejected BEFORE apply.",
+  parameters: {
+    type: "object",
+    properties: {
+      changes: {
+        type: "array",
+        description: "Array of changes. Each replaces `startLine` through `endLine` (inclusive) with the new code lines. Line refs use the `N:hh` format.",
+        items: {
+          type: "object",
+          properties: {
+            startLine: {
+              type: "string",
+              pattern: "^\\d+:[0-9a-f]{2}$",
+              description: "First line to replace, as `N:hh` (e.g., `47:a3`). The hash MUST match the line's hash in the latest Current File view. Format is line-number, colon, 2 lowercase hex chars \u2014 enforced by JSON schema pattern."
+            },
+            endLine: {
+              type: "string",
+              pattern: "^\\d+:[0-9a-f]{2}$",
+              description: "Last line to replace, as `N:hh` (e.g., `83:b1`). Hash MUST match. Format: line-number, colon, 2 lowercase hex chars."
+            },
+            code: {
+              type: "array",
+              items: { type: "string" },
+              description: "New code lines. One source line per array element. No embedded newlines."
+            },
+            description: { type: "string", description: "What this change does (< 10 words)" }
+          },
+          required: ["startLine", "endLine", "code", "description"]
+        }
+      },
+      commit_message: { type: "string", description: "Short summary of all changes" }
+    },
+    required: ["changes", "commit_message"]
+  }
+};
+var APPLY_CHANGES_TOOL_FLAT = {
+  name: "apply_changes",
+  description: "Surgical edit: replace line ranges in ui.tsx with new code. Use line numbers from the Current File (shown as N\u2502). Preferred for targeted changes. The `code` field is a single string with newlines (`\\n`) between lines. The patch is ALWAYS applied even if the resulting file has syntax errors \u2014 the error is returned as guidance. For a full rewrite, use `rewrite`.",
+  parameters: {
+    type: "object",
+    properties: {
+      changes: {
+        type: "array",
+        description: "Array of changes. Each replaces lines startLine through endLine (inclusive). Applied bottom-to-top.",
+        items: {
+          type: "object",
+          properties: {
+            startLine: {
+              type: "number",
+              description: "First line to replace (from the N\u2502 numbers in Current File)"
+            },
+            endLine: { type: "number", description: "Last line to replace (inclusive)" },
+            code: {
+              type: "string",
+              description: "New code as a single string. Separate lines with `\\n`. Preserve leading indentation inside the string."
+            },
+            description: { type: "string", description: "What this change does (< 10 words)" }
+          },
+          required: ["startLine", "endLine", "code", "description"]
+        }
+      },
+      commit_message: { type: "string", description: "Short summary of all changes" },
+      allowBroken: {
+        type: "boolean",
+        description: "Opt-in: commit the patch even if the resulting file fails syntax preflight."
+      }
+    },
+    required: ["changes", "commit_message"]
+  }
+};
+var APPLY_CHANGES_HASHLINE_TOOL_FLAT = {
+  name: "apply_changes",
+  description: "Surgical edit with line-hash verification. Replace line ranges in ui.tsx using `N:hh` references from the Current File (e.g. `47:a3`). The `code` field is a single string with newlines between lines. Edits with mismatched hashes are rejected before apply.",
+  parameters: {
+    type: "object",
+    properties: {
+      changes: {
+        type: "array",
+        description: "Array of changes. Line refs use `N:hh` format.",
+        items: {
+          type: "object",
+          properties: {
+            startLine: {
+              type: "string",
+              pattern: "^\\d+:[0-9a-f]{2}$",
+              description: "First line to replace, as `N:hh` (e.g., `47:a3`). Hash MUST match the latest Current File view. Format: line-number, colon, 2 lowercase hex chars."
+            },
+            endLine: {
+              type: "string",
+              pattern: "^\\d+:[0-9a-f]{2}$",
+              description: "Last line to replace, as `N:hh` (e.g., `83:b1`). Hash MUST match."
+            },
+            code: {
+              type: "string",
+              description: "New code as a single string. Separate lines with `\\n`. Preserve leading indentation."
+            },
+            description: { type: "string", description: "What this change does (< 10 words)" }
+          },
+          required: ["startLine", "endLine", "code", "description"]
+        }
+      },
+      commit_message: { type: "string", description: "Short summary of all changes" }
+    },
+    required: ["changes", "commit_message"]
+  }
+};
+var ICON_LIST_NO_MATCH_GUIDANCE = "This list is complete and constant \u2014 calling again returns exactly it. If the name you wanted is not here, pick the nearest listed name (or a neutral one such as `circle`) and continue with apply_changes; never call this tool twice.";
+var GET_ICONS_TOOL = {
+  name: "get_available_icons",
+  description: 'List every Lucide icon name the <Icon name="..."> component renders (kebab-case). A name outside this list renders nothing \u2014 check before choosing. ' + ICON_LIST_NO_MATCH_GUIDANCE,
+  parameters: { type: "object", properties: {} }
+};
+var GET_COMPONENTS_INFO_TOOL = {
+  name: "get_components_info",
+  description: "Fetch full prop API + example + variant mappings for one or more design-system components. Use when the compact index doesn't give you enough detail to write correct JSX (e.g., you need to know the exact prop values for `variant` or the shape of an options array). Batch names in one call \u2014 cheaper than multiple fetches.",
+  parameters: {
+    type: "object",
+    properties: {
+      names: {
+        type: "array",
+        items: { type: "string" },
+        description: "Component names to fetch (e.g., ['Card', 'Stack', 'Input']). Names must match the index entries exactly."
+      }
+    },
+    required: ["names"]
+  }
+};
+var WRITE_PLAN_TOOL = {
+  name: "write_plan",
+  description: "Commit to a concrete plan before writing code. Produce a short structured outline: which components you'll use, rough JSX structure, and wiring (state/actions/streams). After this call, on the next turn you'll be able to write code with `apply_changes`. Keep it brief \u2014 this is a commitment, not a design doc.",
+  parameters: {
+    type: "object",
+    properties: {
+      components: {
+        type: "array",
+        items: { type: "string" },
+        description: "Primitive/component names you'll use in the final JSX (e.g., ['Card', 'Stack', 'Input', 'Button'])."
+      },
+      structure: {
+        type: "string",
+        description: "Brief JSX structure outline \u2014 a few lines of pseudocode showing nesting. Example: 'Card > Stack > [Heading, Input x3, Button].'"
+      },
+      wiring: {
+        type: "string",
+        description: "Brief note on state/actions/streams you'll wire. Example: 'useState for form payload; invokeAction(submit) on Button click.'"
+      }
+    },
+    required: ["components", "structure", "wiring"]
+  }
+};
+var REWRITE_TOOL = {
+  name: "rewrite",
+  description: "Escape hatch: rewrite the entire ui.tsx file in one call. Use only when surgical `apply_changes` patches have accumulated into a tangled broken state and you need to reset the file to a clean implementation. Single-string payload; auto-compiles + validates. Prefer `apply_changes` for normal edits.",
+  parameters: {
+    type: "object",
+    properties: {
+      code: {
+        type: "string",
+        description: "Complete TSX component source \u2014 the whole file."
+      },
+      commit_message: {
+        type: "string",
+        description: "Short description (< 10 words)"
+      }
+    },
+    required: ["code", "commit_message"]
+  }
+};
+
+// src/harness-tool-names.ts
+var HARNESS_CODING_TOOLS = [APPLY_CHANGES_TOOL];
+var HARNESS_SCOPED_TOOLS = [APPLY_CHANGES_TOOL_SCOPED];
+function harnessToolEntry(def) {
+  return `${def.name}@${createHash("sha256").update(JSON.stringify(def), "utf8").digest("hex").slice(0, 8)}`;
+}
+function harnessToolNames(designMode) {
+  return [...new Set([...HARNESS_CODING_TOOLS, ...HARNESS_SCOPED_TOOLS].map(harnessToolEntry))].sort();
+}
+
+// src/create-harness.ts
+var HARNESS_VERSION = "harness@1";
+var HOW_VERSION = "how@1";
+var WHAT_VERSION = "what@1";
+var CHECK_VERSION = "check@1";
+var PROCESS_VERSION = "process@1";
+var defaultPatchFn = defaultApplyPatch;
+function applyLegOverride(base, ovr, ctx) {
+  if (!ovr) return base;
+  if (typeof ovr === "function") return ovr(base, ctx);
+  return { ...base, ...ovr };
+}
+function countCacheTiers(fragments) {
+  const counts = { stable: 0, axisDelta: 0, volatile: 0 };
+  for (const f of fragments) counts[f.cacheTier]++;
+  return counts;
+}
+function createHarness(input) {
+  const { classification, contract, prompt, shellType, screen, overrides } = input;
+  const ctx = { classification, contract, prompt };
+  const designMode = input.designMode ?? DEFAULT_DESIGN_MODE;
+  const composed = compose(classification);
+  const systemPromptBuilder = input.systemPromptBuilder ?? buildSystemPrompt;
+  const systemPrompt = systemPromptBuilder({
+    userRequest: prompt,
+    shellType,
+    screen,
+    axisDelta: composed.promptText,
+    designMode,
+    ...input.canvas !== void 0 ? { canvas: input.canvas } : {},
+    ...input.profile !== void 0 ? { profile: input.profile } : {}
+  });
+  const howFragments = composed.fragments.filter(
+    (f) => f.promptText && f.promptText.trim().length > 0
+  );
+  const baseHow = {
+    systemPrompt,
+    implPrompt: "",
+    fragments: howFragments,
+    version: HOW_VERSION
+  };
+  const how = applyLegOverride(baseHow, overrides?.how, ctx);
+  const boilerplate = generateBoilerplate(
+    prompt,
+    contract,
+    shellType,
+    screen,
+    composed.boilerplateSections,
+    input.appGadgets,
+    designMode
+  );
+  const whatFragments = composed.fragments.filter(
+    (f) => f.boilerplateMarker && f.boilerplateMarker.trim().length > 0
+  );
+  const baseWhat = {
+    boilerplate,
+    fragments: whatFragments,
+    codingTools: [...HARNESS_CODING_TOOLS],
+    scopedTools: [...HARNESS_SCOPED_TOOLS],
+    applyPatch: defaultPatchFn,
+    // Registered gadget catalog — drives the system prompt's gadget
+    // table + the boilerplate's direct-import emission. Omitted when no
+    // gadgets registered.
+    ...input.appGadgets !== void 0 ? { appGadgets: input.appGadgets } : {},
+    // Third-party wrapper `.d.ts` map — autoCommit's typecheck overlays
+    // the real wrapper declarations so a generated direct gadget import
+    // gets strict hook types.
+    ...input.gadgetTypes !== void 0 ? { gadgetTypes: input.gadgetTypes } : {},
+    version: WHAT_VERSION
+  };
+  const what = applyLegOverride(baseWhat, overrides?.what, ctx);
+  const axisChecks = input.axisChecks ?? [];
+  const baseCheck = {
+    axisChecks,
+    tierChecks: [],
+    runtimeRender: input.runtimeRender,
+    llmEvaluator: void 0,
+    version: CHECK_VERSION
+  };
+  const check = applyLegOverride(baseCheck, overrides?.check, ctx);
+  const policy = input.policy ?? DEFAULT_HARNESS_POLICY;
+  const workflow = pickWorkflow(classification);
+  const baseProcess = {
+    mode: policy.processMode ?? "single_pass",
+    workflow,
+    planner: void 0,
+    retry: { maxIterations: 30 },
+    version: PROCESS_VERSION
+  };
+  const processLeg = applyLegOverride(baseProcess, overrides?.process, ctx);
+  const classificationHash = hashClassification(classification);
+  const fragmentIds = composed.fragments.map((f) => `${f.axis}=${f.value}`);
+  const cacheTierBreakdown = countCacheTiers(composed.fragments);
+  const overrideLabels = [];
+  if (overrides?.how) overrideLabels.push("how");
+  if (overrides?.what) overrideLabels.push("what");
+  if (overrides?.check) overrideLabels.push("check");
+  if (overrides?.process) overrideLabels.push("process");
+  if (overrides?.label) overrideLabels.push(`label:${overrides.label}`);
+  if (!isDefaultHarnessPolicy(policy)) overrideLabels.push("policy");
+  if (designMode !== DEFAULT_DESIGN_MODE) overrideLabels.push(`designMode:${designMode}`);
+  if (hasProfile(input.profile)) overrideLabels.push("profile");
+  const id = computeHarnessId({
+    classificationHash,
+    howVersion: how.version,
+    whatVersion: what.version,
+    checkVersion: check.version,
+    processVersion: processLeg.version,
+    workflowId: workflow.id,
+    fragmentIds,
+    overrides: overrideLabels
+  });
+  const name = computeHarnessName({
+    classification,
+    workflowName: workflow.name,
+    version: HARNESS_VERSION
+  });
+  const meta = {
+    classificationHash,
+    fragmentIds,
+    cacheTierBreakdown,
+    overrides: overrideLabels,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    harnessVersion: HARNESS_VERSION
+  };
+  const harness = {
+    id,
+    name,
+    classification,
+    designMode,
+    ...input.canvas !== void 0 ? { canvas: input.canvas } : {},
+    ...input.profile !== void 0 ? { profile: input.profile } : {},
+    how,
+    what,
+    check,
+    process: processLeg,
+    policy,
+    meta,
+    derive(revision) {
+      return deriveHarness(this, revision, input);
+    }
+  };
+  return harness;
+}
+function deriveHarness(base, revision, originalInput) {
+  let mergedOverrides = {
+    ...originalInput.overrides,
+    ...revision.overrides ?? {}
+  };
+  if (revision.workflow) {
+    const currentProcessOverride = mergedOverrides.process;
+    const processBuilder = (baseProcess, ctx) => {
+      const withOverride = typeof currentProcessOverride === "function" ? currentProcessOverride(baseProcess, ctx) : { ...baseProcess, ...currentProcessOverride ?? {} };
+      return { ...withOverride, workflow: revision.workflow };
+    };
+    mergedOverrides = { ...mergedOverrides, process: processBuilder };
+  }
+  if (revision.useFallbackTools) {
+    const currentWhatOverride = mergedOverrides.what;
+    const whatBuilder = (baseWhat, ctx) => {
+      const withOverride = typeof currentWhatOverride === "function" ? currentWhatOverride(baseWhat, ctx) : { ...baseWhat, ...currentWhatOverride ?? {} };
+      if (withOverride.scopedTools && withOverride.scopedTools.length > 0) {
+        return { ...withOverride, codingTools: withOverride.scopedTools };
+      }
+      return withOverride;
+    };
+    mergedOverrides = { ...mergedOverrides, what: whatBuilder };
+  }
+  return createHarness({
+    ...originalInput,
+    classification: revision.classification ?? base.classification,
+    overrides: mergedOverrides
+  });
+}
+
+export { APPLY_CHANGES_HASHLINE_TOOL, APPLY_CHANGES_HASHLINE_TOOL_FLAT, APPLY_CHANGES_TOOL, APPLY_CHANGES_TOOL_FLAT, APPLY_CHANGES_TOOL_SCOPED, GET_COMPONENTS_INFO_TOOL, GET_ICONS_TOOL, HARNESS_CODING_TOOLS, HARNESS_SCOPED_TOOLS, ICON_LIST_NO_MATCH_GUIDANCE, REWRITE_TOOL, WRITE_PLAN_TOOL, createHarness, harnessToolEntry, harnessToolNames, runCheck, runHarness, runWorkflow };
+//# sourceMappingURL=chunk-WEOXFEVE.js.map
+//# sourceMappingURL=chunk-WEOXFEVE.js.map