@engenty/wizards-runtime 0.0.0-stage → 0.7.5

package/node_modules/@engenty-wizards/shared/dist/feature-flags.js

@@ -0,0 +1,70 @@
+/**
+ * The feature flags of the core: the parts that ship in the code but are not on for everyone
+ * yet (`release`), and the parts a plan includes (`plan`). This file is the list – add a flag
+ * here, branch on it with `useFeature("name")` in the studio or `feature("name")` in the
+ * runtime, and delete it with its branches once its default became `true`.
+ *
+ * How a flag gets its value (defaults here → `FEATURES` env → the Manage-App → the `.features`
+ * file) lives in features.ts. A plugin's flags are declared in its manifest under `features`
+ * and are known as `<plugin id>.<name>`; they do not belong here. No public page lists these.
+ */
+/**
+ * One entry per flag. `kind: "release"`: on or off for everyone by default, turned on for a
+ * team or a machine before the default flips. `kind: "plan"`: on until a plan says `false`.
+ */
+export const FEATURES = {
+    account: {
+        kind: "release",
+        default: true,
+        label: "Account in a local install",
+        hint: "Linking, Settings → Account, the offer to sign in.",
+    },
+    unsetConnectors: {
+        kind: "release",
+        default: false,
+        label: "Connectors without an OAuth client",
+        hint: "Built-in connectors are shown although their client is not set up.",
+    },
+    site: {
+        kind: "release",
+        default: false,
+        label: "Link to the website in the setup",
+        hint: "The local install's setup links the product's site.",
+    },
+    teamPlans: {
+        kind: "release",
+        default: false,
+        label: "Team plans",
+        hint: "The team page in the cloud studio, and plans that carry this switch on the account pages.",
+    },
+    brandSections: {
+        kind: "release",
+        default: false,
+        label: "Sections in Info & brand",
+        hint: "Sections of logos and of colours, gradients and patterns among them.",
+    },
+    brandRules: {
+        kind: "release",
+        default: false,
+        label: "Rules in Info & brand",
+        hint: "Rules for how the logos, the colours and the type may be used.",
+    },
+    typography: {
+        kind: "release",
+        default: false,
+        label: "Typography in Info & brand",
+        hint: "The brand's fonts, their licences and a type scale.",
+    },
+    goose: {
+        kind: "release",
+        default: false,
+        label: "Goose",
+        hint: "The studio's assistant: its chat at the foot of the page and in the sidebar.",
+    },
+    ownKeys: {
+        kind: "plan",
+        default: true,
+        label: "Own API keys",
+        hint: "The team puts its providers' keys into the cloud studio instead of running on credits.",
+    },
+};

package/node_modules/@engenty-wizards/shared/dist/features.d.ts

@@ -0,0 +1,41 @@
+import { FEATURES, type FeatureDeclaration } from "./feature-flags.js";
+/**
+ * Feature switches: how a flag of feature-flags.ts (or a plugin's manifest) gets its value.
+ * The runtime resolves them from the defaults, what the Manage-App says for the team or the
+ * linked account, and this install's `.features` file; the studio and plugins read the result.
+ */
+export { FEATURES, type FeatureDeclaration };
+export type FeatureName = keyof typeof FEATURES;
+export type FeatureKind = (typeof FEATURES)[FeatureName]["kind"];
+/** A switch by name; a plugin's own switches carry its id: `contacts.leadScoring`. */
+export type Features = Record<string, boolean>;
+/** `teamPlans`, `contacts.leadScoring`. */
+export declare const FEATURE_NAME: RegExp;
+/** What a manifest declares for one switch; what is left out is a release switch, off, named by its key. */
+export interface FeatureDeclarationInput {
+    kind?: "release" | "plan";
+    default?: boolean;
+    label?: string;
+    hint?: string;
+}
+/** A plugin's declarations under its id: `contacts` + `leadScoring` → `contacts.leadScoring`. */
+export declare function declaredByPlugin(pluginId: string, features: Record<string, FeatureDeclarationInput | boolean> | undefined): Record<string, FeatureDeclaration>;
+/**
+ * Whether a switch is on in resolved values: a switch they do not carry counts as declared – a
+ * core flag with its default (`ownKeys` on, `teamPlans` off), anything else off. Every read of a
+ * flag goes through this (`useFeature` in the studio), so a missing value means one thing.
+ */
+export declare function featureOn(features: Features | null | undefined, name: string): boolean;
+/** The defaults of these declarations; without any, the core's. */
+export declare function defaultFeatures(declared?: Record<string, FeatureDeclaration>): Features;
+/**
+ * Switches in the shape of a `.env` file: one `name=on` or `name=off` per line (`true`/`false`
+ * and `1`/`0` count too), `#` starts a comment, anything else is skipped. The `FEATURES`
+ * environment variable holds the same, comma-separated. Unknown names are kept: a plugin's
+ * switches are not known here.
+ */
+export declare function parseFeatures(text: string): Features;
+/** The text of a `.features` file for these switches, one `name=on|off` per line. */
+export declare function formatFeatures(features: Features): string;
+/** Layers laid over each other, the last one winning; null layers are skipped. */
+export declare function resolveFeatures(...layers: (Features | null | undefined)[]): Features;

package/node_modules/@engenty-wizards/shared/dist/features.js

@@ -0,0 +1,89 @@
+import { FEATURES } from "./feature-flags.js";
+/**
+ * Feature switches: how a flag of feature-flags.ts (or a plugin's manifest) gets its value.
+ * The runtime resolves them from the defaults, what the Manage-App says for the team or the
+ * linked account, and this install's `.features` file; the studio and plugins read the result.
+ */
+export { FEATURES };
+/** `teamPlans`, `contacts.leadScoring`. */
+export const FEATURE_NAME = /^[a-z][a-zA-Z0-9]*(\.[a-z][a-zA-Z0-9]*)?$/;
+/** A plugin's declarations under its id: `contacts` + `leadScoring` → `contacts.leadScoring`. */
+export function declaredByPlugin(pluginId, features) {
+    const out = {};
+    for (const [key, raw] of Object.entries(features ?? {})) {
+        const name = `${pluginId}.${key}`;
+        if (!FEATURE_NAME.test(name)) {
+            continue;
+        }
+        const d = typeof raw === "boolean" ? { default: raw } : raw;
+        out[name] = {
+            kind: d.kind ?? "release",
+            default: d.default ?? false,
+            label: d.label ?? key,
+            ...(d.hint ? { hint: d.hint } : {}),
+        };
+    }
+    return out;
+}
+/**
+ * Whether a switch is on in resolved values: a switch they do not carry counts as declared – a
+ * core flag with its default (`ownKeys` on, `teamPlans` off), anything else off. Every read of a
+ * flag goes through this (`useFeature` in the studio), so a missing value means one thing.
+ */
+export function featureOn(features, name) {
+    const value = features?.[name];
+    if (typeof value === "boolean") {
+        return value;
+    }
+    return Object.hasOwn(FEATURES, name) ? FEATURES[name].default : false;
+}
+/** The defaults of these declarations; without any, the core's. */
+export function defaultFeatures(declared = FEATURES) {
+    const out = {};
+    for (const [name, d] of Object.entries(declared)) {
+        out[name] = d.default;
+    }
+    return out;
+}
+/**
+ * Switches in the shape of a `.env` file: one `name=on` or `name=off` per line (`true`/`false`
+ * and `1`/`0` count too), `#` starts a comment, anything else is skipped. The `FEATURES`
+ * environment variable holds the same, comma-separated. Unknown names are kept: a plugin's
+ * switches are not known here.
+ */
+export function parseFeatures(text) {
+    const out = {};
+    for (const raw of text.split(/[\n,]/)) {
+        const line = raw.replace(/#.*$/, "").trim();
+        if (!line) {
+            continue;
+        }
+        const m = /^([A-Za-z0-9.]+)\s*=\s*(\S+)$/.exec(line);
+        if (!m?.[1] || !m[2] || !FEATURE_NAME.test(m[1])) {
+            continue;
+        }
+        const value = m[2].toLowerCase();
+        if (["on", "true", "1"].includes(value)) {
+            out[m[1]] = true;
+        }
+        else if (["off", "false", "0"].includes(value)) {
+            out[m[1]] = false;
+        }
+    }
+    return out;
+}
+/** The text of a `.features` file for these switches, one `name=on|off` per line. */
+export function formatFeatures(features) {
+    const lines = Object.entries(features).map(([name, on]) => `${name}=${on ? "on" : "off"}`);
+    return lines.length ? `${lines.join("\n")}\n` : "";
+}
+/** Layers laid over each other, the last one winning; null layers are skipped. */
+export function resolveFeatures(...layers) {
+    const out = {};
+    for (const layer of layers) {
+        if (layer) {
+            Object.assign(out, layer);
+        }
+    }
+    return out;
+}

package/node_modules/@engenty-wizards/shared/dist/fit.d.ts

@@ -0,0 +1,71 @@
+import { type AssetKind, type FieldKind, type Format, type ModelClass, type PageStep, type Step, type ToolId, type WizardDefinition } from "./definition.js";
+import type { Capability } from "./marketplace.js";
+import type { ClosedChoice } from "./run.js";
+/**
+ * What a wizard needs beyond a text model, and whether it runs where there is nothing else: a
+ * WordPress site with the AI Client, no tools, no plugins, no media models (docs/plans/
+ * wordpress-plugin.md, "The check"). One function, computed in the studio, on upload into the
+ * plugin and by the gallery, so every place gives the same answer.
+ */
+/** Something a step wants beyond a text model, as a stable id every app can word. */
+export type Need = `tool:${ToolId}` | "mcp" | "connections" | `plugin:${string}` | `asset:${AssetKind}` | "film"
+/** A widget runs in the runtime's widget host; the standalone runner has none yet. */
+ | "widget" | "widget:video" | `field:${Extract<FieldKind, "audio" | "connection" | "slot" | "location" | "image" | "file">}`
+/** A file the person gives that a later thinking step reads: reading documents is the runtime's. */
+ | "field:file-read" | `format:${Format}` | "lists" | "memory" | "each";
+export interface StepNeed {
+    stepId: string;
+    need: Need;
+    /** The step cannot run without it; a soft need is left out and the step runs with less. */
+    hard: boolean;
+}
+/** What one step wants beyond a text model. */
+export declare function needs(step: Step, def: WizardDefinition): StepNeed[];
+export interface Fit {
+    /** `full`: runs as is. `less`: the choices leading to a hard need are closed, soft needs are left out. `no`: a hard need on a step every run passes through. */
+    fit: "full" | "less" | "no";
+    notes: StepNeed[];
+}
+/** Whether a wizard runs on its own, with what left out. */
+export declare function standaloneFit(def: WizardDefinition): Fit;
+/** The gallery's capability a need stands for; none for what the gallery has no word for. */
+export declare function capabilityOf(need: Need): Capability | null;
+/**
+ * The fit in the fields a marketplace entry already has, so the gallery's chips and entry
+ * dialog draw it: `missing` is what the wizard cannot do without here (rose, "nicht
+ * eingerichtet"), `optional` what it runs without (amber, "geht auch ohne"), `needs` the
+ * plugins behind an account, `without` the result formats that fall away.
+ */
+export interface StandaloneFit extends Fit {
+    missing: Capability[];
+    optional: Capability[];
+    needs: string[];
+    without: Format[];
+}
+export declare function standaloneEntry(def: WizardDefinition): StandaloneFit;
+/** The steps every run passes through: without one of them the end is not reachable. */
+export declare function unavoidableSteps(def: WizardDefinition): Set<string>;
+/**
+ * The steps every path from `from` to the end passes through. A rule on an answer in `known`
+ * goes one way; a rule on anything else may go either way.
+ */
+export declare function unavoidableFrom(def: WizardDefinition, from: string, known: Record<string, unknown>): Set<string>;
+/** Where step `i` goes when none of its rules holds, as an index; the length = the end. */
+export declare function otherwiseIndex(def: WizardDefinition, i: number, index: Map<string, number>): number;
+/** The choices a page offers: each select's options, a toggle's on and off. */
+export interface PageChoice {
+    field: string;
+    values: (string | boolean)[];
+}
+export declare function choicesOf(step: PageStep): PageChoice[];
+/**
+ * The answers on a page that lead to a step this runtime cannot run: with them the run would
+ * stop there, after what came before was paid for. `lacking` says per step what it lacks (model
+ * classes on a runtime, needs on a standalone site). The answers given already count; the page's
+ * other fields may still go either way. A choice whose every value leads there is left open: the
+ * run cannot go around it, and the start already warned. `closedFields` are closed as a whole
+ * (no values): a voice note nothing here can listen to.
+ */
+export declare function closedChoicesFor(def: WizardDefinition, step: PageStep, values: Record<string, unknown>, lacking: (step: Step) => ModelClass[], closedFields?: (field: PageStep["fields"][number]) => ModelClass[] | null): Record<string, ClosedChoice>;
+/** The answer a closed choice gets instead: its first value that stays open. */
+export declare function openValue(step: PageStep, field: string, closed: ClosedChoice): string | boolean | undefined;

package/node_modules/@engenty-wizards/shared/dist/fit.js

@@ -0,0 +1,382 @@
+// SPDX-License-Identifier: FSL-1.1-MIT OR MIT
+import { conditionsOf, dataRef, isOtherwise, listRef, pluginToolOf, ruleMatches, templateRefs, } from "./definition.js";
+/** What the standalone runner can hand over of a thinking step's text itself. */
+const BASE_FORMATS = new Set(["html", "md", "txt", "csv", "json"]);
+/** Tools the standalone runner has no way to run; `pages` only reads the space's pages, which it lacks. */
+const HARD_TOOLS = new Set(["web_search", "browser", "sandbox", "image"]);
+/**
+ * Tools the standalone runner runs itself: a WordPress site reads a public page and calls a
+ * public API through its own abilities (the plugin's `Engenty_Abilities`). No need at all.
+ */
+const RUNNER_TOOLS = new Set(["web_fetch", "http"]);
+const MEMORY_RE = /\{\{\s*memory\b/;
+/** The templates a step renders: what may name lists or the memory. */
+function templatesOf(step) {
+    switch (step.type) {
+        case "agent":
+            return [step.instructions, step.call ? JSON.stringify(step.call.input) : ""];
+        case "generate":
+            return [step.prompt, step.options?.style ?? ""];
+        case "film":
+            return [step.brief];
+        case "widget":
+        case "surface":
+            return Object.values(step.data).map((ref) => `{{${dataRef(ref)}}}`);
+        default:
+            return [];
+    }
+}
+/** Whether a thinking step that reads files may run after `index`. */
+function readsFilesLater(def, index) {
+    return def.steps
+        .slice(index + 1)
+        .some((s) => (s.type === "agent" && !s.call) || s.type === "generate" || s.type === "film");
+}
+/** What one step wants beyond a text model. */
+export function needs(step, def) {
+    const out = [];
+    const add = (need, hard) => {
+        const found = out.find((n) => n.need === need);
+        if (found) {
+            found.hard ||= hard;
+        }
+        else {
+            out.push({ stepId: step.id, need, hard });
+        }
+    };
+    const index = def.steps.indexOf(step);
+    for (const template of templatesOf(step)) {
+        if (MEMORY_RE.test(template)) {
+            add("memory", true);
+        }
+        if (templateRefs(template).some((ref) => ref.startsWith("lists."))) {
+            add("lists", true);
+        }
+    }
+    switch (step.type) {
+        case "page":
+            for (const field of step.fields) {
+                switch (field.kind) {
+                    case "audio":
+                        add("field:audio", Boolean(field.required));
+                        break;
+                    case "connection":
+                        add("field:connection", true);
+                        break;
+                    case "slot":
+                        add("field:slot", true);
+                        break;
+                    case "list":
+                        add("lists", true);
+                        break;
+                    case "location":
+                        add("field:location", false);
+                        break;
+                    case "image":
+                        add("field:image", false);
+                        break;
+                    case "file":
+                        if (readsFilesLater(def, index)) {
+                            add("field:file-read", true);
+                        }
+                        else {
+                            add("field:file", false);
+                        }
+                        break;
+                    default:
+                        break;
+                }
+                if (field.optionsFrom &&
+                    listRef(dataRef(field.optionsFrom).split(".").slice(0, 2).join("."))) {
+                    add("lists", true);
+                }
+            }
+            break;
+        case "agent": {
+            const tools = step.call ? [...step.tools, step.call.tool] : step.tools;
+            for (const tool of tools) {
+                const plugin = pluginToolOf(tool);
+                if (plugin) {
+                    add(`plugin:${plugin.plugin}`, true);
+                }
+                else if (RUNNER_TOOLS.has(tool)) {
+                    // The site runs it.
+                }
+                else if (HARD_TOOLS.has(tool)) {
+                    add(`tool:${tool}`, true);
+                }
+                else {
+                    add(`tool:${tool}`, false);
+                }
+            }
+            if (step.mcp?.length) {
+                add("mcp", true);
+            }
+            if (step.connections?.length) {
+                add("connections", true);
+            }
+            if (step.each) {
+                if (listRef(dataRef(step.each))) {
+                    add("lists", true);
+                }
+                else {
+                    add("each", false);
+                }
+            }
+            break;
+        }
+        case "generate":
+            // A document or a dashboard is HTML a text model writes in one call: the standalone runner
+            // makes it too, and the browser prints it. Media need a model of their own.
+            if (step.asset !== "document" && step.asset !== "dashboard") {
+                add(`asset:${step.asset}`, true);
+            }
+            break;
+        case "film":
+            add("film", true);
+            break;
+        case "widget":
+            add(step.video ? "widget:video" : "widget", true);
+            break;
+        case "surface":
+            if (Object.values(step.data).some((ref) => listRef(dataRef(ref)))) {
+                add("lists", true);
+            }
+            break;
+        case "review":
+            if (step.show.some((ref) => listRef(ref))) {
+                add("lists", true);
+            }
+            break;
+        case "result":
+            for (const d of step.deliverables) {
+                if (listRef(d.from)) {
+                    add("lists", true);
+                    continue;
+                }
+                const from = def.steps.find((s) => s.id === d.from);
+                // What a media step, a widget or a film makes is the step's own need.
+                const written = from?.type === "agent" ||
+                    (from?.type === "generate" && (from.asset === "document" || from.asset === "dashboard"));
+                if (!written) {
+                    continue;
+                }
+                const stays = d.formats.some((f) => BASE_FORMATS.has(f));
+                for (const f of d.formats) {
+                    if (BASE_FORMATS.has(f)) {
+                        continue;
+                    }
+                    // A PDF of a written text the runner makes in the browser (packages/runner/src/pdf.ts);
+                    // of a document the browser prints the HTML. The others fall away where another stays.
+                    if (f === "pdf" && from?.type === "agent") {
+                        continue;
+                    }
+                    add(`format:${f}`, f !== "pdf" && !stays);
+                }
+            }
+            break;
+    }
+    return out;
+}
+/** Whether a wizard runs on its own, with what left out. */
+export function standaloneFit(def) {
+    const notes = def.steps.flatMap((s) => needs(s, def));
+    if (def.lists?.length && !notes.some((n) => n.need === "lists")) {
+        notes.push({ stepId: def.steps[0]?.id ?? "", need: "lists", hard: true });
+    }
+    if (def.connections?.length && !notes.some((n) => n.need === "connections")) {
+        notes.push({ stepId: def.steps[0]?.id ?? "", need: "connections", hard: true });
+    }
+    const unavoidable = unavoidableSteps(def);
+    const blocked = notes.some((n) => n.hard && unavoidable.has(n.stepId));
+    return { fit: blocked ? "no" : notes.length ? "less" : "full", notes };
+}
+/** The gallery's capability a need stands for; none for what the gallery has no word for. */
+export function capabilityOf(need) {
+    switch (need) {
+        case "tool:web_search":
+        case "tool:web_fetch":
+            return "web";
+        case "tool:browser":
+            return "browser";
+        case "tool:sandbox":
+            return "code";
+        case "tool:image":
+        case "asset:image":
+            return "image";
+        case "asset:video":
+        case "film":
+        case "widget:video":
+            return "video";
+        case "asset:voice":
+            return "speech";
+        case "field:audio":
+            return "listening";
+        case "tool:http":
+        case "mcp":
+        case "connections":
+        case "field:connection":
+            return "connectors";
+        case "field:image":
+        case "field:file":
+        case "field:file-read":
+            return "documents";
+        default:
+            return null;
+    }
+}
+export function standaloneEntry(def) {
+    const fit = standaloneFit(def);
+    const unavoidable = unavoidableSteps(def);
+    const missing = new Set();
+    const optional = new Set();
+    const needs = new Set();
+    const without = new Set();
+    for (const note of fit.notes) {
+        if (note.need.startsWith("plugin:")) {
+            needs.add(note.need.slice("plugin:".length));
+            continue;
+        }
+        if (note.need.startsWith("format:")) {
+            without.add(note.need.slice("format:".length));
+            continue;
+        }
+        const capability = capabilityOf(note.need);
+        if (!capability) {
+            continue;
+        }
+        if (note.hard && unavoidable.has(note.stepId)) {
+            missing.add(capability);
+        }
+        else {
+            optional.add(capability);
+        }
+    }
+    for (const c of missing) {
+        optional.delete(c);
+    }
+    return {
+        ...fit,
+        missing: [...missing],
+        optional: [...optional],
+        needs: [...needs].sort(),
+        without: [...without],
+    };
+}
+// --- the steps every run passes through ------------------------------------------------------
+/** The steps every run passes through: without one of them the end is not reachable. */
+export function unavoidableSteps(def) {
+    return def.steps.length ? unavoidableFrom(def, def.steps[0].id, {}) : new Set();
+}
+/**
+ * The steps every path from `from` to the end passes through. A rule on an answer in `known`
+ * goes one way; a rule on anything else may go either way.
+ */
+export function unavoidableFrom(def, from, known) {
+    const index = new Map(def.steps.map((s, i) => [s.id, i]));
+    const start = index.get(from) ?? 0;
+    const successors = (i) => {
+        const out = [];
+        for (const rule of def.steps[i].next ?? []) {
+            if (isOtherwise(rule)) {
+                continue;
+            }
+            const target = rule.goto === "end" ? def.steps.length : (index.get(rule.goto) ?? -1);
+            if (rule.ask || !conditionsOf(rule.when).every((c) => c.field in known)) {
+                if (target >= 0) {
+                    out.push(target);
+                }
+                continue;
+            }
+            if (ruleMatches(rule, known)) {
+                // The first rule that matches decides; nothing after it is tried.
+                return target >= 0 ? [...out, target] : out;
+            }
+        }
+        // No rule matching goes on to the "otherwise" step, else the next (or ends after the last).
+        out.push(otherwiseIndex(def, i, index));
+        return out;
+    };
+    const reachesEnd = (without) => {
+        if (without === start) {
+            return false;
+        }
+        const seen = new Set([start]);
+        const queue = [start];
+        while (queue.length) {
+            const i = queue.shift();
+            if (i >= def.steps.length) {
+                return true;
+            }
+            for (const j of successors(i)) {
+                if (j !== without && !seen.has(j)) {
+                    seen.add(j);
+                    queue.push(j);
+                }
+            }
+        }
+        return false;
+    };
+    return new Set(def.steps.filter((_, i) => !reachesEnd(i)).map((s) => s.id));
+}
+/** Where step `i` goes when none of its rules holds, as an index; the length = the end. */
+export function otherwiseIndex(def, i, index) {
+    const goto = def.steps[i].next?.find(isOtherwise)?.goto;
+    if (goto === undefined) {
+        return i + 1;
+    }
+    return goto === "end" ? def.steps.length : (index.get(goto) ?? i + 1);
+}
+export function choicesOf(step) {
+    return step.fields.flatMap((f) => {
+        if (f.kind === "select" && f.options?.length) {
+            return [{ field: f.id, values: f.options }];
+        }
+        if (f.kind === "toggle") {
+            return [{ field: f.id, values: [true, false] }];
+        }
+        return [];
+    });
+}
+/**
+ * The answers on a page that lead to a step this runtime cannot run: with them the run would
+ * stop there, after what came before was paid for. `lacking` says per step what it lacks (model
+ * classes on a runtime, needs on a standalone site). The answers given already count; the page's
+ * other fields may still go either way. A choice whose every value leads there is left open: the
+ * run cannot go around it, and the start already warned. `closedFields` are closed as a whole
+ * (no values): a voice note nothing here can listen to.
+ */
+export function closedChoicesFor(def, step, values, lacking, closedFields = () => null) {
+    const byId = new Map(def.steps.map((s) => [s.id, s]));
+    const known = Object.fromEntries(Object.entries(values).filter(([id]) => !step.fields.some((f) => f.id === id)));
+    const out = {};
+    for (const field of step.fields) {
+        const whole = closedFields(field);
+        if (whole) {
+            out[field.id] = { values: [], classes: whole };
+        }
+    }
+    for (const choice of choicesOf(step)) {
+        const closed = { values: [], classes: [] };
+        for (const value of choice.values) {
+            const ahead = unavoidableFrom(def, step.id, { ...known, [choice.field]: value });
+            const missing = [...ahead].flatMap((id) => {
+                const s = byId.get(id);
+                return s ? lacking(s) : [];
+            });
+            if (missing.length) {
+                closed.values.push(value);
+                closed.classes = [...new Set([...closed.classes, ...missing])];
+            }
+        }
+        if (closed.values.length && closed.values.length < choice.values.length) {
+            out[choice.field] = closed;
+        }
+    }
+    return out;
+}
+/** The answer a closed choice gets instead: its first value that stays open. */
+export function openValue(step, field, closed) {
+    const choice = choicesOf(step).find((c) => c.field === field);
+    return choice?.values.find((v) => !closed.values.some((c) => String(c) === String(v)));
+}

package/node_modules/@engenty-wizards/shared/dist/json-schema.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The definition and the package's `wizard.json` as JSON Schema, for editors and for checks
+ * outside this app. Written from the Zod schemas the app parses with (`pnpm schema`), so the two
+ * cannot drift; a test compares the published files with a fresh run.
+ *
+ * What JSON Schema cannot say stays with the app: the schema's refinements and `validateWizard`
+ * (ids, references between steps, templates). `wizards validate` checks both.
+ */
+type JsonSchema = Record<string, unknown>;
+/** A wizard's definition: what `get_wizard` returns and `replace_wizard` takes. */
+export declare function wizardJsonSchema(): JsonSchema;
+/** `wizard.json` in a `.wizard` package: the definition with what it needs from its project. */
+export declare function packageJsonSchema(): JsonSchema;
+export {};