wizards 0.2.25 → 0.2.26

package/node_modules/@engenty-wizards/shared/dist/marketplace-entry.js

@@ -1,7 +1,18 @@
-import { allFields, listRef } from "./definition.js";
+import { allFields, conditionsOf, listRef, } from "./definition.js";
 /** When a branch is taken, in words: the field's label stands for its id. */
 function condition(definition, rule, lang) {
-    const { field, op, value } = rule.when;
+    if (rule.ask) {
+        return rule.ask;
+    }
+    if (rule.when === undefined) {
+        return lang === "de" ? "sonst" : "otherwise";
+    }
+    return conditionsOf(rule.when)
+        .map((c) => conditionText(definition, c, lang))
+        .join(lang === "de" ? " und " : " and ");
+}
+function conditionText(definition, c, lang) {
+    const { field, op, value } = c;
     const name = allFields(definition).find((f) => f.id === field)?.label ?? field.split(".").pop() ?? field;
     const de = lang === "de";
     // A toggle is often labelled "Mit …" already.
@@ -24,6 +35,12 @@ function condition(definition, rule, lang) {
             return withIt;
         case "empty":
             return without;
+        case "gt":
+            return `${name} > ${shown}`;
+        case "lt":
+            return `${name} < ${shown}`;
+        case "contains":
+            return de ? `${name} enthält ${shown}` : `${name} contains ${shown}`;
     }
 }
 export const outlineOf = (definition, lang) => definition.steps.map((s) => ({

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

@@ -199,7 +199,7 @@ export type CostTier = keyof typeof COST_TIERS;
 export declare const ITEM_FORMAT_IDS: ("text" | "image" | "audio" | "video" | "document" | "dashboard" | "table")[];
 export declare const INDUSTRY_IDS: ("any" | "trades" | "gastronomy" | "hospitality" | "realEstate" | "retail" | "health" | "professional" | "agency" | "events" | "publicSector")[];
 export declare const USE_CASE_IDS: ("marketing" | "sales" | "accounting" | "service" | "research" | "hr" | "operations" | "website" | "visuals" | "inquiries" | "advice")[];
-export declare const CAPABILITY_IDS: ("text" | "code" | "image" | "browser" | "video" | "speech" | "film" | "web" | "documents" | "listening" | "connectors")[];
+export declare const CAPABILITY_IDS: ("code" | "text" | "image" | "browser" | "video" | "speech" | "film" | "web" | "documents" | "listening" | "connectors")[];
 /** The formats a run hands over, read from what the result step offers. */
 export declare function formatsOf(def: WizardDefinition): ItemFormat[];
 /** The capabilities a definition needs, read from its steps. */

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

@@ -1,5 +1,6 @@
 import type { Format, ModelClass, Step, WizardDefinition } from "./definition.js";
 import type { ConnectionView, ListDef, ListRow } from "./store.js";
+import type { Surface } from "./surface.js";
 export type RunStatus = "waiting_input" | "running" | "done" | "failed" | "cancelled";
 export interface AssetRef {
     id: string;
@@ -16,6 +17,10 @@ export interface AssetRef {
 export interface StepOutput {
     text?: string;
     json?: unknown;
+    /** A decision step: how probable each answer is (1 or 0 where a language model answered). */
+    decided?: Record<string, number>;
+    /** A view from the surface catalog and the data it is bound to. */
+    surface?: Surface;
     assets?: AssetRef[];
     /** Widgets: what loading it with this run's data showed. */
     widget?: {
@@ -34,12 +39,39 @@ export interface RunState {
     notes: Record<string, string>;
     /** Steps that make several results: the entries (from 0) to make again; the others stay. */
     redo?: Record<string, number[]>;
+    /** The step whose `ask` branches are being decided; the run waits on that decision. */
+    deciding?: string;
+    /** What decided `ask` branches answered, by step. */
+    decisions?: Record<string, BranchDecision>;
+    /** Pages whose fields a decision chose: the field ids kept, by page. */
+    pages?: Record<string, {
+        shown: string[];
+    }>;
+    /** How often each branch was taken, by "<step>→<goto>": loops stop at the rule's max. */
+    loops?: Record<string, number>;
     /** File fields with `listen`: what is said in the recording, piece by piece with its times. */
     heard?: Record<string, {
         start: number;
         end: number;
         text: string;
     }[]>;
+    /**
+     * A test run's own copy of the wizard's memory: the pages it wrote, by title. The wizard's
+     * pages stay as they are; the copy goes with the run.
+     */
+    memory?: Record<string, string>;
+}
+/** What a decision over a step's `ask` branches found. */
+export interface BranchDecision {
+    /** The index of the rule in the step's `next`, or null: none of them, go on. */
+    rule: number | null;
+    source: "systemone" | "llm";
+    probabilities?: Record<string, number>;
+    at: string;
+}
+/** A branch decision as the studio sees it: with the step's branches it was made over. */
+export interface ShownDecision extends BranchDecision {
+    over: NonNullable<Step["next"]>;
 }
 interface AskBase {
     id: string;
@@ -123,6 +155,18 @@ export interface ShownList {
  * line into the run's log, a runner shows it in the language the person reads.
  */
 export declare const RUN_NOTES: {
+    readonly entry: {
+        readonly de: "Eintrag {n} von {total}";
+        readonly en: "Entry {n} of {total}";
+    };
+    readonly deciding: {
+        readonly de: "Entscheidet, wie es weitergeht …";
+        readonly en: "Deciding how to go on …";
+    };
+    readonly choosingFields: {
+        readonly de: "Wählt die passenden Fragen …";
+        readonly en: "Choosing the right questions …";
+    };
     readonly batchDone: {
         readonly de: "{done} von {total} fertig";
         readonly en: "{done} of {total} done";
@@ -310,6 +354,17 @@ export interface RunView {
     values: Record<string, unknown>;
     /** What fields of the current page start with, from earlier steps (`prefill`). */
     prefill: Record<string, unknown>;
+    /** What the `when` of the current page's fields read from before the page, by reference. */
+    known?: Record<string, unknown>;
+    /** Choices of the current page's fields that come from earlier data (`optionsFrom`). */
+    options?: Record<string, string[]>;
+    /** The decided fields (`ask`, `group`) of the current page that a decision kept. */
+    decidedFields?: string[];
+    /**
+     * What decided branches answered so far, by step, with the branches decided over (test runs:
+     * the studio shows them while the draft's branches are still those).
+     */
+    decisions?: Record<string, ShownDecision>;
     /** Choices of the current page that lead to a step without a model here, by field id. */
     closed: Record<string, ClosedChoice>;
     outputs: Record<string, StepOutput>;

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

@@ -3,6 +3,9 @@
  * line into the run's log, a runner shows it in the language the person reads.
  */
 export const RUN_NOTES = {
+    entry: { de: "Eintrag {n} von {total}", en: "Entry {n} of {total}" },
+    deciding: { de: "Entscheidet, wie es weitergeht …", en: "Deciding how to go on …" },
+    choosingFields: { de: "Wählt die passenden Fragen …", en: "Choosing the right questions …" },
     batchDone: { de: "{done} von {total} fertig", en: "{done} of {total} done" },
     editing: { de: "Bearbeitet {n} von {total}", en: "Editing {n} of {total}" },
     filming: { de: "Dreht {n} von {total}", en: "Filming {n} of {total}" },

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

@@ -0,0 +1,89 @@
+import { z } from "zod";
+/**
+ * Surfaces: views composed from a small catalog of native components, bound to a run's data and
+ * rendered by the runner itself — themed, on phones, no iframe and nothing to pay per run. A
+ * surface is data, not code: only catalog components render, so it needs no sandbox. Between the
+ * plain table a review shows and a widget, which is free HTML. As engenty-pro's A2UI catalog
+ * (`engenty:core/v1`), kept to what a wizard's result needs.
+ *
+ * A surface is a flat list of components with ids; the one with id "root" is drawn, containers
+ * name their children by id. A prop may be a literal or `{ "path": "/json/pointer" }` into the
+ * surface's data. A `List` or `Table` repeats over an array: inside a repeated row, a path
+ * without a leading slash reads the row ("name"), one with a slash the whole data.
+ */
+export declare const SURFACE_COMPONENTS: readonly ["Column", "Text", "List", "Row", "DetailGrid", "Badge", "Grid", "Metric", "Table", "Image", "BarChart", "LineChart", "DonutChart", "Actions", "Button"];
+export type SurfaceComponentName = (typeof SURFACE_COMPONENTS)[number];
+export declare const SURFACE_ACTIONS: readonly ["regenerate", "open"];
+/** One component: its id, its kind, its children (ids, or a template repeated over an array). */
+export declare const surfaceComponentSchema: z.ZodObject<{
+    id: z.ZodString;
+    component: z.ZodEnum<{
+        Column: "Column";
+        Text: "Text";
+        List: "List";
+        Row: "Row";
+        DetailGrid: "DetailGrid";
+        Badge: "Badge";
+        Grid: "Grid";
+        Metric: "Metric";
+        Table: "Table";
+        Image: "Image";
+        BarChart: "BarChart";
+        LineChart: "LineChart";
+        DonutChart: "DonutChart";
+        Actions: "Actions";
+        Button: "Button";
+    }>;
+    children: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+        path: z.ZodString;
+        componentId: z.ZodString;
+    }, z.core.$strip>]>>;
+}, z.core.$loose>;
+export type SurfaceComponent = z.infer<typeof surfaceComponentSchema>;
+export declare const surfaceComponentsSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    component: z.ZodEnum<{
+        Column: "Column";
+        Text: "Text";
+        List: "List";
+        Row: "Row";
+        DetailGrid: "DetailGrid";
+        Badge: "Badge";
+        Grid: "Grid";
+        Metric: "Metric";
+        Table: "Table";
+        Image: "Image";
+        BarChart: "BarChart";
+        LineChart: "LineChart";
+        DonutChart: "DonutChart";
+        Actions: "Actions";
+        Button: "Button";
+    }>;
+    children: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+        path: z.ZodString;
+        componentId: z.ZodString;
+    }, z.core.$strip>]>>;
+}, z.core.$loose>>;
+/** What a run shows: the components and the data they are bound to. */
+export interface Surface {
+    components: SurfaceComponent[];
+    data: Record<string, unknown>;
+}
+export interface SurfaceIssue {
+    message: string;
+}
+/**
+ * What can be wrong with a surface: an unknown or missing component, no root, a child that is
+ * not there, an id twice, a loop, a prop missing, and — given the data keys a run will provide —
+ * an absolute path into data nothing provides.
+ */
+export declare function validateSurface(raw: unknown, dataKeys?: string[]): SurfaceIssue[];
+/** A JSON pointer into data: "/suppliers/0/name". */
+export declare function pointer(data: unknown, path: string): unknown;
+/**
+ * A prop's value: a literal as it is, a path read from the data — or, without a leading slash,
+ * from the row a List or Table repeats over.
+ */
+export declare function bound(value: unknown, data: unknown, row?: unknown): unknown;
+/** What a model needs to compose a surface: the catalog, briefly. */
+export declare const SURFACE_GUIDE = "A surface is a flat JSON array of components; the one with id \"root\" is drawn. Containers list their children by id.\nComponents and props (a prop may be a literal or {\"path\": \"/key/...\"} into the data):\n- Column { children: [ids] } \u2014 vertical stack (use for root)\n- Text { text, variant?: \"h3\"|\"h4\"|\"body\"|\"muted\" }\n- List { children: {\"path\": \"/rows\", \"componentId\": \"<a Row id>\"} } \u2014 one Row per array entry; inside, paths without \"/\" read the entry (\"name\")\n- Row { title, subtitle?, meta?, badge?, image? }\n- DetailGrid { rows: [{ label, value }] } \u2014 label/value facts\n- Badge { label, tone?: \"default\"|\"success\"|\"warning\" }\n- Grid { children: [ids], columns?: 2|3|4 } \u2014 tiles side by side\n- Metric { label, value, caption? } \u2014 a key figure\n- Table { rows: {\"path\": \"/rows\"}, columns?: [{ key, label }] }\n- Image { src: an asset id or {\"path\": ...}, alt? }\n- BarChart / LineChart { title?, points: [{ label, value }] or {\"path\": ...}, labelKey?, valueKey? }\n- DonutChart { title?, slices: [{ label, value }] or {\"path\": ...}, labelKey?, valueKey? }\n  (labelKey / valueKey: the columns of bound rows that hold the label and the number, e.g. \"name\", \"price\")\n- Actions { children: [Button ids] } / Button { label, action: \"regenerate\"|\"open\" }\nKeep it small: what the person needs to see first, then the details. Never invent numbers: bind them by path.";

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

@@ -0,0 +1,198 @@
+import { z } from "zod";
+/**
+ * Surfaces: views composed from a small catalog of native components, bound to a run's data and
+ * rendered by the runner itself — themed, on phones, no iframe and nothing to pay per run. A
+ * surface is data, not code: only catalog components render, so it needs no sandbox. Between the
+ * plain table a review shows and a widget, which is free HTML. As engenty-pro's A2UI catalog
+ * (`engenty:core/v1`), kept to what a wizard's result needs.
+ *
+ * A surface is a flat list of components with ids; the one with id "root" is drawn, containers
+ * name their children by id. A prop may be a literal or `{ "path": "/json/pointer" }` into the
+ * surface's data. A `List` or `Table` repeats over an array: inside a repeated row, a path
+ * without a leading slash reads the row ("name"), one with a slash the whole data.
+ */
+export const SURFACE_COMPONENTS = [
+    "Column",
+    "Text",
+    "List",
+    "Row",
+    "DetailGrid",
+    "Badge",
+    "Grid",
+    "Metric",
+    "Table",
+    "Image",
+    "BarChart",
+    "LineChart",
+    "DonutChart",
+    "Actions",
+    "Button",
+];
+/** Components that hold others by id. */
+const CONTAINERS = new Set(["Column", "List", "Grid", "Actions"]);
+/** The props each component needs. */
+const REQUIRED = {
+    Text: ["text"],
+    Row: ["title"],
+    DetailGrid: ["rows"],
+    Badge: ["label"],
+    Metric: ["label", "value"],
+    Table: ["rows"],
+    Image: ["src"],
+    BarChart: ["points"],
+    LineChart: ["points"],
+    DonutChart: ["slices"],
+    Button: ["label", "action"],
+};
+export const SURFACE_ACTIONS = ["regenerate", "open"];
+const id = z.string().regex(/^[a-zA-Z][a-zA-Z0-9_-]{0,40}$/, "ids are letters, digits, _ and -");
+/** One component: its id, its kind, its children (ids, or a template repeated over an array). */
+export const surfaceComponentSchema = z.looseObject({
+    id,
+    component: z.enum(SURFACE_COMPONENTS),
+    children: z
+        .union([z.array(z.string()), z.object({ path: z.string(), componentId: z.string() })])
+        .optional(),
+});
+export const surfaceComponentsSchema = z.array(surfaceComponentSchema).min(1).max(200);
+const isPath = (v) => Boolean(v && typeof v === "object" && !Array.isArray(v) && typeof v.path === "string");
+/** Every `{ path }` in a component's props, with whether it reads a repeated row. */
+function pathsOf(c) {
+    const out = [];
+    const walk = (v) => {
+        if (isPath(v)) {
+            out.push(v.path);
+        }
+        else if (Array.isArray(v)) {
+            v.forEach(walk);
+        }
+        else if (v && typeof v === "object") {
+            Object.values(v).forEach(walk);
+        }
+    };
+    for (const [key, value] of Object.entries(c)) {
+        if (key !== "id" && key !== "component") {
+            walk(key === "children" && !Array.isArray(value) && isPath(value) ? { path: value.path } : value);
+        }
+    }
+    return out;
+}
+/**
+ * What can be wrong with a surface: an unknown or missing component, no root, a child that is
+ * not there, an id twice, a loop, a prop missing, and — given the data keys a run will provide —
+ * an absolute path into data nothing provides.
+ */
+export function validateSurface(raw, dataKeys) {
+    const parsed = surfaceComponentsSchema.safeParse(raw);
+    if (!parsed.success) {
+        return parsed.error.issues.map((i) => ({ message: `${i.path.join(".")}: ${i.message}` }));
+    }
+    const components = parsed.data;
+    const issues = [];
+    const byId = new Map();
+    for (const c of components) {
+        if (byId.has(c.id)) {
+            issues.push({ message: `Duplicate component id "${c.id}".` });
+        }
+        byId.set(c.id, c);
+    }
+    if (!byId.has("root")) {
+        issues.push({ message: 'A surface has a component with id "root".' });
+    }
+    for (const c of components) {
+        for (const prop of REQUIRED[c.component] ?? []) {
+            if (c[prop] === undefined) {
+                issues.push({ message: `${c.component} "${c.id}" needs "${prop}".` });
+            }
+        }
+        const action = c.action;
+        if (action !== undefined && !SURFACE_ACTIONS.includes(action)) {
+            issues.push({
+                message: `"${c.id}": action is one of ${SURFACE_ACTIONS.join(", ")}.`,
+            });
+        }
+        const children = c.children;
+        if (children && !CONTAINERS.has(c.component) && c.component !== "Table") {
+            issues.push({ message: `${c.component} "${c.id}" holds no children.` });
+        }
+        const ids = Array.isArray(children) ? children : children ? [children.componentId] : [];
+        for (const child of ids) {
+            if (!byId.has(child)) {
+                issues.push({ message: `"${c.id}" names a child "${child}" that is not there.` });
+            }
+        }
+        if (dataKeys) {
+            for (const path of pathsOf(c)) {
+                const key = path.startsWith("/") ? path.split("/")[1] : null;
+                if (key !== null && !dataKeys.includes(key)) {
+                    issues.push({ message: `"${c.id}" reads "${path}", which no data provides.` });
+                }
+            }
+        }
+    }
+    // A child that holds its parent would draw forever.
+    const seen = new Set();
+    const loops = (cid, stack) => {
+        if (stack.has(cid)) {
+            return true;
+        }
+        if (seen.has(cid)) {
+            return false;
+        }
+        seen.add(cid);
+        const c = byId.get(cid);
+        const kids = Array.isArray(c?.children)
+            ? c.children
+            : c?.children
+                ? [c.children.componentId]
+                : [];
+        const next = new Set(stack).add(cid);
+        return kids.some((k) => loops(k, next));
+    };
+    if (byId.has("root") && loops("root", new Set())) {
+        issues.push({ message: "Components hold each other in a loop." });
+    }
+    return issues;
+}
+/** A JSON pointer into data: "/suppliers/0/name". */
+export function pointer(data, path) {
+    let at = data;
+    for (const part of path.split("/").slice(1)) {
+        if (at === null || typeof at !== "object") {
+            return undefined;
+        }
+        at = at[part.replace(/~1/g, "/").replace(/~0/g, "~")];
+    }
+    return at;
+}
+/**
+ * A prop's value: a literal as it is, a path read from the data — or, without a leading slash,
+ * from the row a List or Table repeats over.
+ */
+export function bound(value, data, row) {
+    if (!isPath(value)) {
+        return value;
+    }
+    if (value.path.startsWith("/")) {
+        return pointer(data, value.path);
+    }
+    return row === undefined ? undefined : pointer(row, `/${value.path.replace(/\./g, "/")}`);
+}
+/** What a model needs to compose a surface: the catalog, briefly. */
+export const SURFACE_GUIDE = `A surface is a flat JSON array of components; the one with id "root" is drawn. Containers list their children by id.
+Components and props (a prop may be a literal or {"path": "/key/..."} into the data):
+- Column { children: [ids] } — vertical stack (use for root)
+- Text { text, variant?: "h3"|"h4"|"body"|"muted" }
+- List { children: {"path": "/rows", "componentId": "<a Row id>"} } — one Row per array entry; inside, paths without "/" read the entry ("name")
+- Row { title, subtitle?, meta?, badge?, image? }
+- DetailGrid { rows: [{ label, value }] } — label/value facts
+- Badge { label, tone?: "default"|"success"|"warning" }
+- Grid { children: [ids], columns?: 2|3|4 } — tiles side by side
+- Metric { label, value, caption? } — a key figure
+- Table { rows: {"path": "/rows"}, columns?: [{ key, label }] }
+- Image { src: an asset id or {"path": ...}, alt? }
+- BarChart / LineChart { title?, points: [{ label, value }] or {"path": ...}, labelKey?, valueKey? }
+- DonutChart { title?, slices: [{ label, value }] or {"path": ...}, labelKey?, valueKey? }
+  (labelKey / valueKey: the columns of bound rows that hold the label and the number, e.g. "name", "price")
+- Actions { children: [Button ids] } / Button { label, action: "regenerate"|"open" }
+Keep it small: what the person needs to see first, then the details. Never invent numbers: bind them by path.`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wizards",
-  "version": "0.2.25",
+  "version": "0.2.26",
   "description": "Make a wish. Get your wizard. It guides you step by step. Let AI do the work. Runs on your machine, on the AI subscription you already have.",
   "license": "FSL-1.1-MIT",
   "homepage": "https://engenty.ai",