modwright 0.1.0

package/dist/core/scaffold/sequence.js

@@ -0,0 +1,396 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { parse as parseYaml } from "yaml";
+import { z } from "zod";
+import { findScaffold, scaffoldsRoot } from "./load.js";
+const assetSchema = z
+    .object({
+    name: z.string().min(1),
+    prompt: z.string().min(1),
+    inputs: z.array(z.string().min(1)).default([]),
+})
+    .strict();
+const stepSchema = z
+    .object({
+    id: z.string().regex(/^[a-z][a-z0-9-]*$/, "step ids are lowercase slugs"),
+    scaffold: z.string().min(1),
+    title: z.string().min(1),
+    skipIf: z.enum(["project-exists"]).optional(),
+    inputs: z.record(z.string()).default({}),
+    assets: z.array(assetSchema).default([]),
+})
+    .strict();
+export const sequenceSchema = z
+    .object({
+    id: z.string().regex(/^[a-z0-9]+\.[a-z][a-z0-9-]*$/, "sequence ids are <game>.<slug>"),
+    game: z.enum(["baldursgate3", "cyberpunk2077", "stardewvalley"]),
+    title: z.string().min(1),
+    summary: z.string().min(1),
+    modType: z.string().min(1),
+    inputs: z.array(z.object({ name: z.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/), prompt: z.string().min(1) }).strict()).default([]),
+    steps: z.array(stepSchema).min(1),
+    evidence: z.array(z.string()).default([]),
+})
+    .strict();
+const TOKEN_RE = /\$\{(sequence|steps|project)\.([a-zA-Z0-9_-]+(?:\.[a-zA-Z0-9_-]+)*)\}/g;
+function formatPath(segments) {
+    if (segments.length === 0)
+        return "(root)";
+    let out = "";
+    for (const segment of segments)
+        out += typeof segment === "number" ? `[${segment}]` : out ? `.${segment}` : segment;
+    return out;
+}
+export function checkSequence(def, catalog) {
+    const problems = [];
+    const sequenceInputs = new Set(def.inputs.map((i) => i.name));
+    if (sequenceInputs.size !== def.inputs.length)
+        problems.push("sequence inputs must have unique names");
+    const seen = new Set();
+    const earlier = new Map();
+    for (const step of def.steps) {
+        const where = `step "${step.id}"`;
+        if (seen.has(step.id))
+            problems.push(`${where}: duplicate step id`);
+        seen.add(step.id);
+        const found = findScaffold(catalog, step.scaffold);
+        if (!found) {
+            problems.push(`${where}: unknown scaffold "${step.scaffold}"`);
+            continue;
+        }
+        if (found.definition.game !== def.game)
+            problems.push(`${where}: "${step.scaffold}" is a ${found.definition.game} scaffold in a ${def.game} sequence`);
+        const inputNames = new Set(found.definition.inputs.map((i) => i.name));
+        for (const name of Object.keys(step.inputs)) {
+            if (!inputNames.has(name))
+                problems.push(`${where}: "${step.scaffold}" has no input "${name}"`);
+        }
+        const assetNames = new Set();
+        for (const asset of step.assets) {
+            if (assetNames.has(asset.name))
+                problems.push(`${where}: duplicate asset "${asset.name}"`);
+            assetNames.add(asset.name);
+            for (const name of asset.inputs) {
+                if (!inputNames.has(name))
+                    problems.push(`${where}: asset "${asset.name}" fills input "${name}", which "${step.scaffold}" does not have`);
+                if (name in step.inputs)
+                    problems.push(`${where}: asset "${asset.name}" fills input "${name}", which the step also fixes`);
+            }
+        }
+        for (const [name, value] of Object.entries(step.inputs)) {
+            for (const match of value.matchAll(TOKEN_RE)) {
+                const [, ns, key] = match;
+                if (ns === "sequence" && !sequenceInputs.has(key))
+                    problems.push(`${where}: input "${name}" names \${sequence.${key}}, which the sequence does not declare`);
+                if (ns === "project" && !["name", "game", "version"].includes(key))
+                    problems.push(`${where}: input "${name}" names \${project.${key}}; only name, game and version exist`);
+                if (ns === "steps") {
+                    const [stepId, kind, ...rest] = key.split(".");
+                    const ref = stepId ? earlier.get(stepId) : undefined;
+                    if (!ref) {
+                        problems.push(`${where}: input "${name}" names \${steps.${key}}, which is not an earlier step`);
+                    }
+                    else if (kind === "ids") {
+                        if (!ref.definition.ids.some((i) => i.name === rest.join(".")))
+                            problems.push(`${where}: input "${name}" names \${steps.${key}}, but "${ref.definition.id}" allocates no id "${rest.join(".")}"`);
+                    }
+                    else if (kind === "inputs") {
+                        if (!ref.definition.inputs.some((i) => i.name === rest.join(".")))
+                            problems.push(`${where}: input "${name}" names \${steps.${key}}, but "${ref.definition.id}" has no input "${rest.join(".")}"`);
+                    }
+                    else {
+                        problems.push(`${where}: input "${name}" names \${steps.${key}}; only ids.<name> and inputs.<name> exist`);
+                    }
+                }
+            }
+        }
+        earlier.set(step.id, found);
+    }
+    return problems;
+}
+export function parseSequenceDefinition(raw, sourcePath) {
+    const result = sequenceSchema.safeParse(raw);
+    if (result.success)
+        return result.data;
+    const lines = result.error.issues.map((issue) => `${formatPath(issue.path)}: ${issue.message}`);
+    throw new Error(`Invalid sequence definition at ${sourcePath}:\n${lines.join("\n")}`);
+}
+export async function loadSequenceFile(filePath, catalog) {
+    const text = await fs.readFile(filePath, "utf8");
+    let raw;
+    try {
+        raw = parseYaml(text);
+    }
+    catch (err) {
+        throw new Error(`${filePath}: YAML parse error: ${err.message}`);
+    }
+    const def = parseSequenceDefinition(raw, filePath);
+    const problems = checkSequence(def, catalog);
+    if (problems.length > 0)
+        throw new Error(`${filePath}: sequence "${def.id}" does not fit the scaffold catalogue:\n${problems.join("\n")}`);
+    return def;
+}
+export async function listSequenceFiles(root = scaffoldsRoot()) {
+    const out = [];
+    let games;
+    try {
+        games = (await fs.readdir(root, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name);
+    }
+    catch {
+        return [];
+    }
+    for (const game of games) {
+        const dir = path.join(root, game, "sequences");
+        let files;
+        try {
+            files = (await fs.readdir(dir)).filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
+        }
+        catch {
+            continue;
+        }
+        for (const file of files.sort())
+            out.push({ file: path.join(dir, file), game });
+    }
+    return out;
+}
+export async function loadAllSequences(catalog, root = scaffoldsRoot()) {
+    const loaded = [];
+    const problems = [];
+    for (const entry of await listSequenceFiles(root)) {
+        try {
+            loaded.push({ file: entry.file, definition: await loadSequenceFile(entry.file, catalog) });
+        }
+        catch (err) {
+            problems.push(err.message);
+        }
+    }
+    return { loaded, problems };
+}
+export function findSequence(loaded, id) {
+    return loaded.find((s) => s.definition.id === id);
+}
+export function summarizeSequences(loaded) {
+    return loaded.map(({ definition }) => ({
+        id: definition.id,
+        game: definition.game,
+        title: definition.title,
+        summary: definition.summary,
+        modType: definition.modType,
+        steps: definition.steps.map((s) => ({ id: s.id, scaffold: s.scaffold, title: s.title, assets: s.assets.length })),
+    }));
+}
+async function readScaffoldManifests(projectRoot) {
+    const dir = path.join(projectRoot, ".modwright", "scaffolds");
+    let names;
+    try {
+        names = (await fs.readdir(dir)).filter((n) => n.endsWith(".json")).sort();
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const name of names) {
+        try {
+            const raw = JSON.parse(await fs.readFile(path.join(dir, name), "utf8"));
+            if (typeof raw.scaffold !== "string")
+                continue;
+            out.push({
+                scaffold: raw.scaffold,
+                inputs: raw.inputs && typeof raw.inputs === "object" ? raw.inputs : {},
+                generatedIds: Array.isArray(raw.generatedIds) ? raw.generatedIds : [],
+                file: path.join(dir, name),
+            });
+        }
+        catch {
+        }
+    }
+    return out;
+}
+function requiredInput(spec) {
+    if (spec.type === "string" || spec.type === "list")
+        return spec.default === undefined;
+    if (spec.type === "number")
+        return spec.default === undefined;
+    return true;
+}
+function resolveValue(value, scope) {
+    let waitingOn;
+    let unresolved;
+    const out = value.replace(TOKEN_RE, (whole, ns, key) => {
+        if (ns === "sequence") {
+            const v = scope.sequence[key];
+            if (v === undefined)
+                unresolved ??= whole;
+            return v ?? whole;
+        }
+        if (ns === "project") {
+            const v = scope.project[key];
+            if (v === undefined)
+                unresolved ??= whole;
+            return v ?? whole;
+        }
+        const [stepId, kind, ...rest] = key.split(".");
+        const manifest = stepId ? scope.steps.get(stepId) : undefined;
+        if (!manifest) {
+            waitingOn ??= stepId;
+            return whole;
+        }
+        const name = rest.join(".");
+        const v = kind === "ids" ? manifest.generatedIds.find((g) => g.name === name)?.value : manifest.inputs[name];
+        if (v === undefined)
+            unresolved ??= whole;
+        return v ?? whole;
+    });
+    if (waitingOn)
+        return { waitingOn };
+    if (unresolved)
+        return { unresolved };
+    return { value: out };
+}
+function manifestMatches(manifest, step, fixed) {
+    if (manifest.scaffold !== step.scaffold)
+        return false;
+    for (const [name, value] of Object.entries(fixed)) {
+        if (manifest.inputs[name] !== value)
+            return false;
+    }
+    return true;
+}
+export async function planSequence(options) {
+    const { definition, catalog, project } = options;
+    const given = options.inputs ?? {};
+    const answers = options.assets ?? {};
+    const manifests = project ? await readScaffoldManifests(project.root) : [];
+    const sequenceScope = {};
+    const missingSequence = [];
+    for (const input of definition.inputs) {
+        const v = given[input.name];
+        if (v !== undefined && v !== "")
+            sequenceScope[input.name] = v;
+        else
+            missingSequence.push({ kind: "input", name: input.name, prompt: input.prompt, answerAs: input.name });
+    }
+    const projectScope = project
+        ? { name: project.project.name, game: project.project.game, ...(project.project.version ? { version: project.project.version } : {}) }
+        : {};
+    const doneSteps = new Map();
+    const steps = [];
+    let blockedEarlier;
+    for (const step of definition.steps) {
+        const found = findScaffold(catalog, step.scaffold);
+        const specs = found.definition.inputs;
+        const plan = { id: step.id, scaffold: step.scaffold, title: step.title, status: "waiting", inputs: {}, missing: [] };
+        steps.push(plan);
+        if (step.skipIf === "project-exists" && project) {
+            plan.status = "skipped";
+            plan.reason = `a project already exists (${project.project.name}); this step creates one.`;
+            continue;
+        }
+        if (!project && step.skipIf !== "project-exists") {
+            plan.status = "waiting";
+            plan.reason = "no modwright.json yet; the project step comes first.";
+            continue;
+        }
+        const fixed = {};
+        let waitingOn;
+        const unresolved = new Map();
+        for (const [name, raw] of Object.entries(step.inputs)) {
+            const r = resolveValue(raw, { sequence: sequenceScope, project: projectScope, steps: doneSteps });
+            if (r.waitingOn)
+                waitingOn ??= r.waitingOn;
+            else if (r.unresolved)
+                unresolved.set(name, r.unresolved);
+            else
+                fixed[name] = r.value;
+        }
+        const proof = manifests.find((m) => manifestMatches(m, step, fixed));
+        if (proof) {
+            plan.status = "done";
+            plan.manifest = proof.file;
+            plan.inputs = proof.inputs;
+            doneSteps.set(step.id, proof);
+            continue;
+        }
+        if (blockedEarlier) {
+            plan.status = "waiting";
+            plan.reason = `step "${blockedEarlier}" comes first.`;
+            continue;
+        }
+        if (waitingOn) {
+            plan.status = "waiting";
+            plan.reason = `carries a value from step "${waitingOn}", which has not been applied yet.`;
+            blockedEarlier = step.id;
+            continue;
+        }
+        const filledByAssets = {};
+        for (const asset of step.assets) {
+            const key = `${step.id}.${asset.name}`;
+            const answer = answers[key];
+            if (answer === undefined || answer === "") {
+                plan.missing.push({ kind: "asset", name: asset.name, prompt: asset.prompt, fills: asset.inputs, answerAs: key });
+                continue;
+            }
+            for (const name of asset.inputs)
+                filledByAssets[name] = answer;
+        }
+        const inputs = {};
+        const fixedNames = new Set(Object.keys(step.inputs));
+        const oneOfGroups = found.definition.oneOf;
+        const valueByName = (name) => given[`${step.id}.${name}`] ?? fixed[name] ?? filledByAssets[name];
+        for (const spec of specs) {
+            const override = given[`${step.id}.${spec.name}`];
+            const value = override ?? fixed[spec.name] ?? filledByAssets[spec.name];
+            if (value !== undefined) {
+                inputs[spec.name] = value;
+                continue;
+            }
+            const group = oneOfGroups.find((g) => g.includes(spec.name));
+            if (group && group.some((n) => n !== spec.name && valueByName(n) !== undefined))
+                continue;
+            const token = unresolved.get(spec.name);
+            if (fixedNames.has(spec.name) && token?.startsWith("${sequence."))
+                continue;
+            if (requiredInput(spec) || token) {
+                plan.missing.push({ kind: "input", name: spec.name, prompt: spec.prompt, answerAs: `${step.id}.${spec.name}` });
+            }
+        }
+        for (const token of unresolved.values()) {
+            const name = /^\$\{sequence\.([^}]+)\}$/.exec(token)?.[1];
+            if (name && !plan.missing.some((m) => m.answerAs === name)) {
+                const seqInput = definition.inputs.find((i) => i.name === name);
+                plan.missing.push({ kind: "input", name, prompt: seqInput?.prompt ?? token, answerAs: name });
+            }
+        }
+        plan.inputs = inputs;
+        if (plan.missing.length > 0) {
+            plan.status = "blocked";
+            blockedEarlier = step.id;
+        }
+        else {
+            plan.status = "ready";
+            plan.run = { action: "run", scaffoldId: step.scaffold, inputs, mode: "dry-run" };
+            blockedEarlier = step.id;
+        }
+    }
+    const next = steps.find((s) => s.status === "ready" || s.status === "blocked");
+    const complete = steps.every((s) => s.status === "done" || s.status === "skipped");
+    const doneCount = steps.filter((s) => s.status === "done" || s.status === "skipped").length;
+    const summary = complete
+        ? `every step is done (${doneCount}/${steps.length}); what remains is each step's own manual checklist and the in-game check.`
+        : next
+            ? next.status === "ready"
+                ? `${doneCount}/${steps.length} done; step "${next.id}" (${next.scaffold}) is ready: run it dry-run, then apply.`
+                : `${doneCount}/${steps.length} done; step "${next.id}" (${next.scaffold}) needs ${next.missing.length} answer(s) first.`
+            : `${doneCount}/${steps.length} done; the remaining steps wait on a project.`;
+    return {
+        sequence: definition.id,
+        game: definition.game,
+        title: definition.title,
+        project: project ? { name: project.project.name, game: project.project.game, root: project.root } : undefined,
+        missing: missingSequence,
+        steps,
+        next: next ? { stepId: next.id, status: next.status, missing: next.missing, run: next.run } : undefined,
+        complete,
+        summary,
+    };
+}

package/dist/core/scaffold/types.js

@@ -0,0 +1,309 @@
+import { z } from "zod";
+import { probeExpectSchema } from "../bridge/types.js";
+export const inputSpecSchema = z.discriminatedUnion("type", [
+    z
+        .object({
+        type: z.literal("string"),
+        name: z.string(),
+        prompt: z.string(),
+        pattern: z.string().optional(),
+        default: z.string().optional(),
+        reindent: z.number().int().min(0).optional(),
+    })
+        .strict(),
+    z
+        .object({
+        type: z.literal("enum"),
+        name: z.string(),
+        prompt: z.string(),
+        values: z.array(z.string()).min(1),
+    })
+        .strict(),
+    z
+        .object({
+        type: z.literal("number"),
+        name: z.string(),
+        prompt: z.string(),
+        default: z.number().optional(),
+        min: z.number().optional(),
+        max: z.number().optional(),
+    })
+        .strict(),
+    z
+        .object({
+        type: z.literal("list"),
+        name: z.string(),
+        prompt: z.string(),
+        itemPattern: z.string().optional(),
+        minItems: z.number().int().nonnegative().default(1),
+        default: z.string().optional(),
+    })
+        .strict(),
+    z
+        .object({
+        type: z.literal("path"),
+        name: z.string(),
+        prompt: z.string(),
+        mustExist: z.boolean().default(false),
+    })
+        .strict(),
+    z
+        .object({
+        type: z.literal("index-ref"),
+        name: z.string(),
+        prompt: z.string(),
+        lookup: z.object({ kind: z.string(), params: z.record(z.string()) }).strict(),
+        requires: z
+            .array(z
+            .object({
+            path: z.string(),
+            matches: z.string().optional(),
+            reason: z.string(),
+            through: z
+                .object({
+                kind: z.string(),
+                param: z.string(),
+                path: z.string(),
+                params: z.record(z.string()).optional(),
+                expose: z.string().optional(),
+            })
+                .strict()
+                .optional(),
+            expose: z.string().optional(),
+        })
+            .strict())
+            .default([]),
+    })
+        .strict(),
+    z
+        .object({
+        type: z.literal("template-record"),
+        name: z.string(),
+        prompt: z.string(),
+        expectKind: z
+            .object({ by: z.string(), map: z.record(z.string()), reason: z.string() })
+            .strict()
+            .optional(),
+    })
+        .strict(),
+]);
+export const ID_FORMS = ["uuid", "bg3-handle", "bg3-handle-bare", "dashed-uuid", "tweak-record", "slug", "map-key", "fnv1a64", "fixed-point"];
+export const DERIVED_ID_FORMS = new Set(["fnv1a64", "fixed-point"]);
+export const NUMERIC_ID_FORMS = new Set(["fixed-point"]);
+export const idSpecSchema = z
+    .object({
+    name: z.string(),
+    slot: z.string(),
+    form: z.enum(ID_FORMS),
+    fractionBits: z.number().int().min(0).max(40).optional(),
+    collision: z
+        .object({
+        project: z.boolean().default(true),
+        loadOrder: z.boolean().default(false),
+        index: z.object({ kind: z.string(), param: z.string() }).strict().optional(),
+    })
+        .strict()
+        .default({}),
+})
+    .strict();
+const requiredValueSchema = z.unknown().refine((v) => v !== undefined, { message: "value is required" });
+const emitWhenSchema = z.union([
+    z.object({ templateDefined: z.string() }).strict(),
+    z.object({ templateUndefined: z.string() }).strict(),
+    z.object({ inputDefined: z.string() }).strict(),
+    z.object({ inputUndefined: z.string() }).strict(),
+]);
+export const emitSchema = z.discriminatedUnion("op", [
+    z.object({ op: z.literal("ensure-dir"), path: z.string(), when: emitWhenSchema.optional() }).strict(),
+    z
+        .object({
+        op: z.literal("write-text"),
+        path: z.string(),
+        body: z.string(),
+        bom: z.boolean().default(false),
+        ifExists: z.enum(["fail", "skip", "overwrite"]).default("fail"),
+        when: emitWhenSchema.optional(),
+    })
+        .strict(),
+    z
+        .object({
+        op: z.literal("write-json"),
+        path: z.string(),
+        value: requiredValueSchema,
+        renumberHandles: z.boolean().default(true),
+        ifExists: z.enum(["fail", "skip", "overwrite"]).default("fail"),
+        when: emitWhenSchema.optional(),
+    })
+        .strict(),
+    z
+        .object({
+        op: z.literal("write-json-from-template"),
+        path: z.string(),
+        template: z.string(),
+        rewrite: z.array(z
+            .object({
+            path: z.string(),
+            value: requiredValueSchema,
+            match: z.record(z.string()).optional(),
+            minMatches: z.number().int().min(0).optional(),
+        })
+            .strict()),
+        require: z
+            .array(z.object({ match: z.record(z.string()), minMatches: z.number().int().min(1).optional(), reason: z.string() }).strict())
+            .default([]),
+        strip: z.array(z.string()).default([]),
+        renumberHandles: z.boolean().default(true),
+        when: emitWhenSchema.optional(),
+    })
+        .strict(),
+    z
+        .object({
+        op: z.literal("insert-block"),
+        path: z.string(),
+        body: z.string(),
+        anchor: z.enum(["append", "before-first-entry", "before-last-line"]).default("append"),
+        anchorPattern: z.string().optional(),
+        indent: z.number().int().min(0).optional(),
+        createIfMissing: z.string().optional(),
+        when: emitWhenSchema.optional(),
+    })
+        .strict(),
+    z
+        .object({
+        op: z.literal("insert-loca-row"),
+        path: z.string(),
+        handle: z.string(),
+        text: z.string(),
+        version: z.number().int().default(1),
+        when: emitWhenSchema.optional(),
+    })
+        .strict(),
+    z
+        .object({
+        op: z.literal("insert-xl-entry"),
+        path: z.string(),
+        pointer: z.string(),
+        value: z.unknown(),
+        unique: z.boolean().default(false),
+        when: emitWhenSchema.optional(),
+    })
+        .strict(),
+    z.object({ op: z.literal("insert-csv-row"), path: z.string(), row: z.record(z.string()), when: emitWhenSchema.optional() }).strict(),
+    z
+        .object({
+        op: z.literal("patch-project"),
+        when: emitWhenSchema.optional(),
+        add: z
+            .object({
+            sources: z.array(z.unknown()).default([]),
+            steps: z.array(z.unknown()).default([]),
+            deployTargets: z.array(z.unknown()).default([]),
+            dependencies: z.array(z.unknown()).default([]),
+            outDir: z.string().optional(),
+            toolchain: z.record(z.string()).optional(),
+        })
+            .strict(),
+    })
+        .strict(),
+]);
+export const testRowProbeSchema = z
+    .object({
+    kind: z.string().min(1),
+    params: z.record(z.unknown()),
+    expect: probeExpectSchema.optional(),
+})
+    .strict();
+export const scaffoldSchema = z
+    .object({
+    id: z.string(),
+    game: z.enum(["baldursgate3", "cyberpunk2077", "stardewvalley"]),
+    title: z.string(),
+    summary: z.string(),
+    modTypes: z.array(z.string()).min(1),
+    needs: z
+        .object({
+        index: z.boolean().default(false),
+        install: z.boolean().default(false),
+        toolchain: z.array(z.string()).default([]),
+    })
+        .strict()
+        .default({}),
+    inputs: z.array(inputSpecSchema),
+    oneOf: z.array(z.array(z.string()).min(2)).default([]),
+    ids: z.array(idSpecSchema).default([]),
+    emits: z.array(emitSchema).min(1),
+    templates: z
+        .array(z
+        .object({
+        ref: z.string(),
+        from: z.string(),
+        conversion: z.string().optional(),
+        provenanceFrom: z.string().optional(),
+    })
+        .strict())
+        .default([]),
+    satisfies: z.array(z.string()).min(1),
+    manual: z.array(z.object({ title: z.string(), steps: z.array(z.string()), expected: z.string() }).strict()).default([]),
+    claim: z.object({ idSuffix: z.string(), claim: z.string() }).strict(),
+    testRows: z
+        .array(z
+        .object({
+        gate: z.string(),
+        title: z.string(),
+        expected: z.string(),
+        manual: z.boolean().default(true),
+        probeKinds: z.array(z.string()).default([]),
+        probes: z.array(testRowProbeSchema).min(1).optional(),
+    })
+        .strict()
+        .transform((row) => row.probes && row.probes.length > 0 && row.probeKinds.length === 0
+        ? { ...row, probeKinds: row.probes.map((p) => p.kind) }
+        : row))
+        .default([]),
+    evidence: z.array(z.string()).min(1),
+})
+    .strict()
+    .superRefine((def, ctx) => {
+    def.ids.forEach((id, i) => {
+        if (id.fractionBits !== undefined && id.form !== "fixed-point") {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["ids", i, "fractionBits"], message: `only the fixed-point form takes fractionBits (this id is "${id.form}")` });
+        }
+    });
+    const byName = new Map(def.inputs.map((i) => [i.name, i]));
+    const groupOf = new Map();
+    def.oneOf.forEach((group, gi) => {
+        group.forEach((name, ni) => {
+            const spec = byName.get(name);
+            if (!spec) {
+                ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["oneOf", gi, ni], message: `names input "${name}", which is not declared in inputs[]` });
+                return;
+            }
+            if ((spec.type === "string" || spec.type === "number" || spec.type === "list") && spec.default !== undefined) {
+                ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["oneOf", gi, ni], message: `input "${name}" has a default, so it can never be absent — a oneOf member must be genuinely optional` });
+            }
+            const prev = groupOf.get(name);
+            if (prev !== undefined) {
+                ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["oneOf", gi, ni], message: `input "${name}" appears in more than one oneOf group (already in group ${prev})` });
+            }
+            else {
+                groupOf.set(name, gi);
+            }
+        });
+    });
+});
+function formatPath(segments) {
+    if (segments.length === 0)
+        return "(root)";
+    let out = "";
+    for (const segment of segments) {
+        out += typeof segment === "number" ? `[${segment}]` : out ? `.${segment}` : segment;
+    }
+    return out;
+}
+export function parseScaffoldDefinition(raw, sourcePath) {
+    const result = scaffoldSchema.safeParse(raw);
+    if (result.success)
+        return result.data;
+    const lines = result.error.issues.map((issue) => `${formatPath(issue.path)}: ${issue.message}`);
+    throw new Error(`Invalid scaffold definition at ${sourcePath}:\n${lines.join("\n")}`);
+}