@engenty/wizards-runtime 0.0.0-stage → 0.7.6

package/node_modules/@engenty/wizards/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@engenty/wizards",
+  "version": "0.1.0",
+  "license": "FSL-1.1-MIT",
+  "type": "module",
+  "exports": {
+    "./plugin": "./dist/plugin/index.js",
+    "./plugin/studio": "./dist/plugin/studio.js",
+    "./plugin/thread": "./dist/plugin/thread.js"
+  }
+}

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

@@ -0,0 +1,174 @@
+import { z } from "zod";
+/**
+ * The studio's assistant between the browser and the runtime: what a page tells it, the tools
+ * the browser runs, and the events of a turn. The events are our own, shaped like AG-UI's
+ * (docs.ag-ui.com): message and tool-call ids and AG-UI's field names, so a later switch is a
+ * rename on both ends.
+ */
+/** A page's snapshot is cut to this many bytes of JSON. */
+export declare const ASSISTANT_PAGE_BYTES: number;
+/** What the page the person writes from shows; it goes up with every message. */
+export declare const assistantPageSchema: z.ZodObject<{
+    route: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    view: z.ZodOptional<z.ZodString>;
+    open: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodOptional<z.ZodString>;
+        label: z.ZodString;
+    }, z.core.$strip>>;
+    selection: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    summary: z.ZodOptional<z.ZodString>;
+    fields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        value: z.ZodUnknown;
+    }, z.core.$strip>>>;
+    plugin: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AssistantPage = z.infer<typeof assistantPageSchema>;
+/** A tool the browser runs (AG-UI's `Tool`): its arguments as JSON Schema. */
+export declare const browserToolSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export type BrowserTool = z.infer<typeof browserToolSchema>;
+/** The browser waits no longer for a tool than this; the runtime neither. */
+export declare const BROWSER_TOOL_TIMEOUT_MS = 60000;
+/** What the browser sends to start a turn (AG-UI's `RunAgentInput`, cut to what we use). */
+export declare const assistantTurnSchema: z.ZodObject<{
+    message: z.ZodString;
+    projectId: z.ZodOptional<z.ZodString>;
+    page: z.ZodOptional<z.ZodObject<{
+        route: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        view: z.ZodOptional<z.ZodString>;
+        open: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodString;
+            id: z.ZodOptional<z.ZodString>;
+            label: z.ZodString;
+        }, z.core.$strip>>;
+        selection: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        summary: z.ZodOptional<z.ZodString>;
+        fields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            value: z.ZodUnknown;
+        }, z.core.$strip>>>;
+        plugin: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    tools: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>>>;
+    debug: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type AssistantTurn = z.input<typeof assistantTurnSchema>;
+/**
+ * A message the person writes while a turn runs (POST /api/studio/assistant/run/:runId/signal):
+ * the turn takes it before its next step, or after its answer. `ref` is the browser's id for it.
+ */
+export declare const assistantSignalSchema: z.ZodObject<{
+    ref: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strip>;
+export type AssistantSignal = z.infer<typeof assistantSignalSchema>;
+/** One model step of a turn, in developer mode. */
+export interface AssistantStep {
+    /** Counted over the turn, from 1. */
+    step: number;
+    /** The model the class is bound to, e.g. `anthropic/claude-sonnet-4.6` or `claude:sonnet`. */
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+    cachedInputTokens: number;
+    /** From the step's start to its end, tools included. */
+    ms: number;
+    costUsd: number;
+    /** The tools the model called in the step. */
+    tools: string[];
+    /** The model's context window in tokens, where the catalog knows it. */
+    window: number | null;
+}
+/** What a turn sent to the model, in developer mode: its parts and their size. */
+export interface AssistantPrompt {
+    model: string;
+    system: string;
+    /** The turn's own message: earlier chats, the page, the space, what the person wrote. */
+    context: string;
+    /** The open chat's messages sent along. */
+    history: {
+        role: "user" | "assistant";
+        chars: number;
+    }[];
+    /** Each tool's description and schema, in characters. */
+    tools: {
+        name: string;
+        chars: number;
+    }[];
+}
+/** The events of a turn, by SSE event name. */
+export interface AssistantEvents {
+    /**
+     * The turn started; `messageId` is the stored message of the person. Messages written meanwhile
+     * go to `runId` as signals.
+     */
+    run_started: {
+        threadId: string;
+        runId: string;
+        messageId: string;
+    };
+    text: {
+        messageId: string;
+        delta: string;
+    };
+    /** What the assistant does right now, in a few words. */
+    activity: {
+        label: string;
+    };
+    tool_call: {
+        toolCallId: string;
+        toolCallName: string;
+        args: unknown;
+    };
+    tool_result: {
+        toolCallId: string;
+        content: string;
+    };
+    /** A plugin's tool returned what its card in the chat draws. */
+    card: {
+        toolCallId?: string;
+        plugin: string;
+        tool: string;
+        data: unknown;
+    };
+    /** The space or a plugin's data changed: the page reads its data again. */
+    changed: Record<string, never>;
+    /**
+     * The turn took a message written meanwhile (`ref`, stored as `messageId`). What the answer said
+     * before it was stored as `answerId` (null when it had said nothing); the answer goes on after it.
+     */
+    signal: {
+        ref: string;
+        messageId: string;
+        content: string;
+        answerId: string | null;
+    };
+    /** Developer mode: what went to the model. */
+    prompt: AssistantPrompt;
+    /** Developer mode: a model step ended. */
+    step: AssistantStep;
+    done: {
+        messageId: string;
+        reply: string;
+        changed: boolean;
+    };
+    error: {
+        message: string;
+    };
+}
+/** Where the assistant stands on the screen, per person. */
+export declare const ASSISTANT_LAYOUTS: readonly ["bottom", "sidebar", "avatar"];
+export type AssistantLayout = (typeof ASSISTANT_LAYOUTS)[number];

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

@@ -0,0 +1,65 @@
+import { z } from "zod";
+/**
+ * The studio's assistant between the browser and the runtime: what a page tells it, the tools
+ * the browser runs, and the events of a turn. The events are our own, shaped like AG-UI's
+ * (docs.ag-ui.com): message and tool-call ids and AG-UI's field names, so a later switch is a
+ * rename on both ends.
+ */
+/** A page's snapshot is cut to this many bytes of JSON. */
+export const ASSISTANT_PAGE_BYTES = 16 * 1024;
+/** What the page the person writes from shows; it goes up with every message. */
+export const assistantPageSchema = z.object({
+    /** The studio's address: `/shop`, `/space/knowledge`. */
+    route: z.string().max(400),
+    /** What the top bar's trail says the page is. */
+    title: z.string().max(200).optional(),
+    /** The section in view: "Display and checkout". */
+    view: z.string().max(200).optional(),
+    /** An item the page has open. */
+    open: z
+        .object({
+        kind: z.string().max(60),
+        id: z.string().max(120).optional(),
+        label: z.string().max(200),
+    })
+        .optional(),
+    /** Ids of what the person picked. */
+    selection: z.array(z.string().max(120)).max(100).optional(),
+    /** A line on what the page holds: "0 products · no source · prices incl. VAT". */
+    summary: z.string().max(2000).optional(),
+    /** Fields of the page with their values. */
+    fields: z
+        .array(z.object({ id: z.string().max(120), label: z.string().max(200), value: z.unknown() }))
+        .max(60)
+        .optional(),
+    /** The plugin whose page it is. */
+    plugin: z.string().max(60).optional(),
+});
+/** A tool the browser runs (AG-UI's `Tool`): its arguments as JSON Schema. */
+export const browserToolSchema = z.object({
+    name: z.string().regex(/^[a-z][a-z0-9_]{1,62}$/),
+    description: z.string().max(2000),
+    parameters: z.record(z.string(), z.unknown()),
+});
+/** The browser waits no longer for a tool than this; the runtime neither. */
+export const BROWSER_TOOL_TIMEOUT_MS = 60_000;
+/** What the browser sends to start a turn (AG-UI's `RunAgentInput`, cut to what we use). */
+export const assistantTurnSchema = z.object({
+    message: z.string().min(1).max(8000),
+    /** The space the page shows; its tools need it. */
+    projectId: z.string().max(80).optional(),
+    page: assistantPageSchema.optional(),
+    tools: z.array(browserToolSchema).max(40).default([]),
+    /** Developer mode: the turn also sends its prompt and each step (`prompt`, `step`). */
+    debug: z.boolean().optional(),
+});
+/**
+ * A message the person writes while a turn runs (POST /api/studio/assistant/run/:runId/signal):
+ * the turn takes it before its next step, or after its answer. `ref` is the browser's id for it.
+ */
+export const assistantSignalSchema = z.object({
+    ref: z.string().min(1).max(40),
+    message: z.string().min(1).max(8000),
+});
+/** Where the assistant stands on the screen, per person. */
+export const ASSISTANT_LAYOUTS = ["bottom", "sidebar", "avatar"];

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

@@ -0,0 +1,22 @@
+import type { WizardDefinition } from "./definition.js";
+import type { WorkspaceFile } from "./workspace.js";
+/**
+ * What changed in a draft since the version people run: the wizard's own settings, each step
+ * by its title, the steps' order, the workspace's files. "Änderungen live schalten" lists it.
+ */
+export interface VersionChange {
+    kind: "wizard" | "step" | "order" | "file";
+    change: "added" | "removed" | "changed";
+    /** The step's title or the file's path. */
+    name?: string;
+    /** What of a changed step or of the wizard itself: the definition's keys (`instructions`, `fields`). */
+    parts?: string[];
+}
+/** A version as it runs: its definition and its workspace. */
+interface Version {
+    definition: WizardDefinition;
+    files: Pick<WorkspaceFile, "path" | "hash">[];
+}
+/** What `after` changes of `before`: the wizard first, then its steps in their new order, then its files. */
+export declare function versionChanges(before: Version, after: Version): VersionChange[];
+export {};

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

@@ -0,0 +1,61 @@
+const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+/** The keys whose values differ, in the order the newer one has them. */
+function keysChanged(before, after) {
+    const was = before;
+    const now = after;
+    const keys = [...new Set([...Object.keys(now), ...Object.keys(was)])];
+    return keys.filter((k) => !same(was[k], now[k]));
+}
+/** What `after` changes of `before`: the wizard first, then its steps in their new order, then its files. */
+export function versionChanges(before, after) {
+    const changes = [];
+    const { steps: oldSteps, ...oldWizard } = before.definition;
+    const { steps: newSteps, ...newWizard } = after.definition;
+    const parts = keysChanged(oldWizard, newWizard);
+    if (parts.length) {
+        changes.push({ kind: "wizard", change: "changed", parts });
+    }
+    const old = new Map(oldSteps.map((s) => [s.id, s]));
+    const now = new Set(newSteps.map((s) => s.id));
+    for (const step of newSteps) {
+        const was = old.get(step.id);
+        if (!was) {
+            changes.push({ kind: "step", change: "added", name: step.title });
+        }
+        else if (!same(was, step)) {
+            changes.push({
+                kind: "step",
+                change: "changed",
+                name: step.title,
+                parts: keysChanged(was, step).filter((k) => k !== "id"),
+            });
+        }
+    }
+    for (const step of oldSteps) {
+        if (!now.has(step.id)) {
+            changes.push({ kind: "step", change: "removed", name: step.title });
+        }
+    }
+    // The steps both have, in each one's order: a move is one change, however many steps moved.
+    const kept = (steps) => steps.map((s) => s.id).filter((id) => old.has(id) && now.has(id));
+    if (!same(kept(oldSteps), kept(newSteps))) {
+        changes.push({ kind: "order", change: "changed" });
+    }
+    const oldFiles = new Map(before.files.map((f) => [f.path, f.hash]));
+    const newFiles = new Map(after.files.map((f) => [f.path, f.hash]));
+    for (const [path, hash] of newFiles) {
+        const was = oldFiles.get(path);
+        if (was === undefined) {
+            changes.push({ kind: "file", change: "added", name: path });
+        }
+        else if (was !== hash) {
+            changes.push({ kind: "file", change: "changed", name: path });
+        }
+    }
+    for (const path of oldFiles.keys()) {
+        if (!newFiles.has(path)) {
+            changes.push({ kind: "file", change: "removed", name: path });
+        }
+    }
+    return changes;
+}

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

@@ -0,0 +1,77 @@
+/** Imported connectors as the studio shows them: a service of a project, with its actions. */
+export type ActionGroup = "read" | "write" | "destructive";
+export interface ConnectorActionView {
+    id: string;
+    summary: string;
+    group: ActionGroup;
+}
+export interface ConnectorView {
+    id: string;
+    name: string;
+    domain: string;
+    /** Where it comes from: shipped with the product, or imported from a spec or an MCP server. */
+    sourceKind: "builtin" | "openapi" | "mcp";
+    sourceUrl: string;
+    toolPrefix: string;
+    /** Whether a person can connect an account right now. */
+    usable: boolean;
+    /** Built-in OAuth connectors that are not usable: the settings the server still needs. */
+    missingSetup: string | null;
+    /** How a person connects their account. */
+    auth: "none" | "oauth2" | "api_key";
+    /** OAuth without client credentials and without self-registration: connecting cannot work yet. */
+    needsOAuthClient: boolean;
+    /** An MCP server that lists its tools only to a signed-in account: none are known yet. */
+    toolsPending: boolean;
+    actions: ConnectorActionView[];
+    importedAt: string;
+    refreshedAt: string | null;
+}
+export interface RegistryHit {
+    domain: string;
+    name: string;
+    description: string;
+    kinds: string[];
+}
+/** One way a registry service can be imported: an OpenAPI spec or an MCP server. */
+export interface RegistrySource {
+    sourceKind: "openapi" | "mcp";
+    sourceUrl: string;
+    name: string | null;
+    /** Why this source cannot be imported; null = it can. */
+    blocked: string | null;
+    auth: string;
+    suggestedId: string;
+    suggestedToolPrefix: string;
+}
+export interface RegistryService {
+    domain: string;
+    summary: string | null;
+    sources: RegistrySource[];
+    /** How to get a credential, in the provider's words. */
+    credentials: {
+        label: string;
+        setup: string | null;
+        url: string | null;
+    }[];
+}
+export interface SourcePreview {
+    title: string | null;
+    actions: ConnectorActionView[];
+    blockers: string[];
+    /** Actions beyond the per-connector cap. */
+    dropped: number;
+    toolsPending: boolean;
+}
+export interface ImportRequest {
+    domain: string;
+    sourceKind: "openapi" | "mcp";
+    sourceUrl: string;
+    id: string;
+    toolPrefix: string;
+    name?: string;
+    /** Only these actions; default all. */
+    actions?: string[];
+    oauthClientId?: string;
+    oauthClientSecret?: string;
+}

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

@@ -0,0 +1,2 @@
+/** Imported connectors as the studio shows them: a service of a project, with its actions. */
+export {};

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

@@ -0,0 +1,76 @@
+import { z } from "zod";
+/**
+ * Decisions: typed questions over a state, answered by a decision model (System One: TypeSafe's
+ * Jev and models of its kind) or, where there is none, by a language model asked for the same
+ * answers as structured output. Both ways give the same shapes; only a decision model gives
+ * probabilities that mean something.
+ */
+/** Yes or no: P(yes). */
+export interface NoulQuestion {
+    type: "noul";
+    instructions: string;
+    criteria?: {
+        true: string;
+        false: string;
+    };
+}
+/** One of named options, each with what it covers (null: the name says it). */
+export interface ChoiceQuestion {
+    type: "choice";
+    instructions: string;
+    criteria: Record<string, string | null>;
+}
+/** A level on an ordered scale, lowest first. */
+export interface ScoreQuestion {
+    type: "score";
+    instructions: string;
+    criteria: string[];
+}
+export type DecisionQuestion = NoulQuestion | ChoiceQuestion | ScoreQuestion;
+export interface NoulAnswer {
+    type: "noul";
+    /** P(yes), 0–1. A language model's answer is 1 or 0. */
+    noul: number;
+}
+export interface ChoiceAnswer {
+    type: "choice";
+    choice: string;
+    /** Per option; only from a decision model. */
+    probabilities?: Record<string, number>;
+    confidence?: number;
+}
+export interface ScoreAnswer {
+    type: "score";
+    /** Index of the level, lowest = 0. */
+    level: number;
+    /** The level's description, as the question lists it. */
+    label: string;
+    /** Per level index; only from a decision model. */
+    probabilities?: Record<string, number>;
+    confidence?: number;
+}
+export type DecisionAnswer = NoulAnswer | ChoiceAnswer | ScoreAnswer;
+export type DecisionSource = "systemone" | "llm";
+export interface Decision {
+    answers: Record<string, DecisionAnswer>;
+    /** Which way answered; with both, the language model filled what the decision model left open. */
+    source: DecisionSource;
+}
+/**
+ * The answers a System One response gives that fit their questions; a question whose answer is
+ * missing or does not fit is left out, for the language model to answer.
+ */
+export declare function readSystemOne(questions: Record<string, DecisionQuestion>, response: unknown): Record<string, DecisionAnswer>;
+/** The questions as one structured-output object a language model fills. */
+export declare function decisionSchema(questions: Record<string, DecisionQuestion>): z.ZodObject<{
+    [x: string]: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}, z.core.$strip>;
+/** What a language model filled in, as answers; null when it does not fit. */
+export declare function readObject(questions: Record<string, DecisionQuestion>, object: unknown): Record<string, DecisionAnswer> | null;
+/**
+ * How sure the answer is that it picked rightly, as the margin between the winner and the
+ * runner-up; null where there are no probabilities (a language model's answer).
+ */
+export declare function marginOf(answer: DecisionAnswer): number | null;
+/** The probability of what was answered: P(yes) for a yes/no, P(pick) otherwise; 1 without. */
+export declare function pOf(answer: DecisionAnswer): number;

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

@@ -0,0 +1,147 @@
+import { z } from "zod";
+/** Probabilities sum to one within rounding. */
+const SUM_TOLERANCE = 0.02;
+function unit(v) {
+    return typeof v === "number" && Number.isFinite(v) && v >= 0 && v <= 1;
+}
+/**
+ * A distribution over exactly the offered keys that sums to one, with `pick` on top — so a
+ * malformed or cut-off answer never counts. Engenty-pro's validateChoiceAnswer.
+ */
+function validDistribution(probabilities, offered, pick) {
+    if (!probabilities || typeof probabilities !== "object") {
+        return false;
+    }
+    const p = probabilities;
+    const keys = Object.keys(p);
+    if (keys.length !== offered.length || !offered.every((k) => k in p)) {
+        return false;
+    }
+    let sum = 0;
+    let max = 0;
+    for (const k of keys) {
+        if (!unit(p[k])) {
+            return false;
+        }
+        sum += p[k];
+        max = Math.max(max, p[k]);
+    }
+    return Math.abs(sum - 1) < SUM_TOLERANCE && p[pick] >= max - 1e-6;
+}
+/**
+ * The answers a System One response gives that fit their questions; a question whose answer is
+ * missing or does not fit is left out, for the language model to answer.
+ */
+export function readSystemOne(questions, response) {
+    const raw = response?.answers ?? {};
+    const out = {};
+    for (const [name, q] of Object.entries(questions)) {
+        const a = raw[name];
+        if (!a || typeof a !== "object") {
+            continue;
+        }
+        if (q.type === "noul" && a.type === "noul" && unit(a.noul)) {
+            out[name] = { type: "noul", noul: a.noul };
+        }
+        else if (q.type === "choice" && a.type === "choice") {
+            const offered = Object.keys(q.criteria);
+            if (typeof a.choice === "string" &&
+                offered.includes(a.choice) &&
+                validDistribution(a.probabilities, offered, a.choice)) {
+                out[name] = {
+                    type: "choice",
+                    choice: a.choice,
+                    probabilities: a.probabilities,
+                    ...(unit(a.confidence) ? { confidence: a.confidence } : {}),
+                };
+            }
+        }
+        else if (q.type === "score" && a.type === "score") {
+            const offered = q.criteria.map((_, i) => String(i));
+            const probabilities = a.probabilities;
+            const top = probabilities
+                ? Object.entries(probabilities).sort((x, y) => y[1] - x[1])[0]?.[0]
+                : undefined;
+            if (top !== undefined && validDistribution(probabilities, offered, top)) {
+                const level = Number(top);
+                out[name] = {
+                    type: "score",
+                    level,
+                    label: q.criteria[level],
+                    probabilities,
+                    ...(unit(a.confidence) ? { confidence: a.confidence } : {}),
+                };
+            }
+        }
+    }
+    return out;
+}
+/** The questions as one structured-output object a language model fills. */
+export function decisionSchema(questions) {
+    const shape = {};
+    for (const [name, q] of Object.entries(questions)) {
+        if (q.type === "noul") {
+            const hint = q.criteria ? ` (true: ${q.criteria.true}; false: ${q.criteria.false})` : "";
+            shape[name] = z.boolean().describe(`${q.instructions}${hint}`);
+        }
+        else if (q.type === "choice") {
+            const options = Object.keys(q.criteria);
+            const hints = Object.entries(q.criteria)
+                .filter(([, d]) => d)
+                .map(([k, d]) => `${k}: ${d}`)
+                .join("; ");
+            shape[name] = z
+                .enum(options)
+                .describe(hints ? `${q.instructions} (${hints})` : q.instructions);
+        }
+        else {
+            shape[name] = z
+                .enum(q.criteria)
+                .describe(`${q.instructions} (lowest to highest)`);
+        }
+    }
+    return z.object(shape);
+}
+/** What a language model filled in, as answers; null when it does not fit. */
+export function readObject(questions, object) {
+    if (!object || typeof object !== "object") {
+        return null;
+    }
+    const o = object;
+    const out = {};
+    for (const [name, q] of Object.entries(questions)) {
+        const v = o[name];
+        if (q.type === "noul" && typeof v === "boolean") {
+            out[name] = { type: "noul", noul: v ? 1 : 0 };
+        }
+        else if (q.type === "choice" && typeof v === "string" && v in q.criteria) {
+            out[name] = { type: "choice", choice: v };
+        }
+        else if (q.type === "score" && typeof v === "string" && q.criteria.includes(v)) {
+            out[name] = { type: "score", level: q.criteria.indexOf(v), label: v };
+        }
+        else {
+            return null;
+        }
+    }
+    return out;
+}
+/**
+ * How sure the answer is that it picked rightly, as the margin between the winner and the
+ * runner-up; null where there are no probabilities (a language model's answer).
+ */
+export function marginOf(answer) {
+    if (answer.type === "noul") {
+        return null;
+    }
+    const p = Object.values(answer.probabilities ?? {}).sort((a, b) => b - a);
+    return p.length >= 2 ? p[0] - p[1] : null;
+}
+/** The probability of what was answered: P(yes) for a yes/no, P(pick) otherwise; 1 without. */
+export function pOf(answer) {
+    if (answer.type === "noul") {
+        return answer.noul;
+    }
+    const key = answer.type === "choice" ? answer.choice : String(answer.level);
+    return answer.probabilities?.[key] ?? 1;
+}