@engenty/wizards-runtime 0.0.0-stage → 0.7.5

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

@@ -0,0 +1,227 @@
+import { type Lang, type WizardDefinition } from "./definition.js";
+import { type Gap, type Texts } from "./texts.js";
+/**
+ * The marketplace: wizards anyone can start from. What an entry is sorted by — formats, industry,
+ * use case — and what follows from its definition: the AI capabilities it needs, how much a
+ * person has to fill in, and how expensive a run is.
+ */
+export declare const MARKETPLACE_LANGS: readonly ["de", "en"];
+export type MarketplaceLang = (typeof MARKETPLACE_LANGS)[number];
+/** What comes out of a run. */
+export declare const ITEM_FORMAT_IDS: readonly ["text", "document", "table", "image", "video", "audio", "dashboard"];
+export type ItemFormat = (typeof ITEM_FORMAT_IDS)[number];
+export declare const INDUSTRY_IDS: readonly ["any", "trades", "gastronomy", "hospitality", "realEstate", "retail", "health", "professional", "agency", "events", "publicSector"];
+export type Industry = (typeof INDUSTRY_IDS)[number];
+export declare const USE_CASE_IDS: readonly ["marketing", "sales", "accounting", "service", "research", "hr", "operations", "website", "visuals", "inquiries", "advice"];
+export type UseCase = (typeof USE_CASE_IDS)[number];
+/**
+ * What the models and tools behind a wizard must be able to do. `film`: a film the installed
+ * client makes, only on a computer with Claude Code, on its subscription.
+ */
+export declare const CAPABILITY_IDS: readonly ["text", "web", "browser", "documents", "image", "video", "speech", "listening", "code", "connectors", "film"];
+export type Capability = (typeof CAPABILITY_IDS)[number];
+export declare const COST_TIER_IDS: readonly ["low", "medium", "high"];
+export type CostTier = (typeof COST_TIER_IDS)[number];
+/**
+ * The plan a wizard needs. Free runs on what every runtime has; Pro needs plugins, which come
+ * with the Pro and Team plans of engenty.ai.
+ */
+export declare const MARKETPLACE_PLAN_IDS: readonly ["free", "pro"];
+export type MarketplacePlan = (typeof MARKETPLACE_PLAN_IDS)[number];
+/** What a marketplace label belongs to: a facet, a cost tier, a plan. */
+export type MarketGroup = "format" | "industry" | "useCase" | "capability" | "cost" | "plan" | "outline";
+declare const MARKET_EN: {
+    readonly "format.text": "Text";
+    readonly "format.document": "Document (PDF, Word)";
+    readonly "format.table": "Table";
+    readonly "format.image": "Image";
+    readonly "format.video": "Video";
+    readonly "format.audio": "Audio";
+    readonly "format.dashboard": "Dashboard";
+    readonly "industry.any": "Any industry";
+    readonly "industry.trades": "Trades";
+    readonly "industry.gastronomy": "Food service";
+    readonly "industry.hospitality": "Hotels & tourism";
+    readonly "industry.realEstate": "Real estate";
+    readonly "industry.retail": "Retail";
+    readonly "industry.health": "Health";
+    readonly "industry.professional": "Professional services";
+    readonly "industry.agency": "Agency & marketing";
+    readonly "industry.events": "Events";
+    readonly "industry.publicSector": "Associations & public sector";
+    readonly "useCase.marketing": "Marketing & social media";
+    readonly "useCase.sales": "Offers & sales";
+    readonly "useCase.accounting": "Accounting & receipts";
+    readonly "useCase.service": "Customer service";
+    readonly "useCase.research": "Research & analysis";
+    readonly "useCase.hr": "HR & applications";
+    readonly "useCase.operations": "Planning & operations";
+    readonly "useCase.website": "Website helpers";
+    readonly "useCase.visuals": "Images & video";
+    readonly "useCase.inquiries": "Inquiries & bookings";
+    readonly "useCase.advice": "Advice & pricing";
+    readonly "capability.text": "Writes text";
+    readonly "capability.web": "Web search";
+    readonly "capability.browser": "Drives a browser";
+    readonly "capability.documents": "Reads documents & photos";
+    readonly "capability.image": "Makes images";
+    readonly "capability.video": "Makes video";
+    readonly "capability.speech": "Speech output";
+    readonly "capability.listening": "Understands voice notes";
+    readonly "capability.code": "Runs code";
+    readonly "capability.connectors": "Connected accounts & systems";
+    readonly "capability.film": "Films with Claude Code (on your subscription)";
+    readonly "cost.low": "low cost";
+    readonly "cost.medium": "medium cost";
+    readonly "cost.high": "high cost";
+    readonly "plan.free": "Free";
+    readonly "plan.pro": "Pro";
+    readonly "outline.otherwise": "otherwise";
+    readonly "outline.and": "{first} and {second}";
+    readonly "outline.with": "with {name}";
+    readonly "outline.without": "without {name}";
+    readonly "outline.contains": "{name} contains {value}";
+};
+type MarketKey = keyof typeof MARKET_EN;
+export declare const MARKET_TEXTS: Texts<MarketKey>;
+/** The label of a facet value, a cost tier or a plan in a language; its id where it has none. */
+export declare function marketLabel(group: MarketGroup, id: string, lang: Lang, params?: Record<string, Gap | undefined>): string;
+/** A label in every language, for search: a person may type either. */
+export declare const marketLabels: (group: MarketGroup, id: string) => string[];
+/** 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. */
+export declare function capabilitiesOf(def: WizardDefinition): Capability[];
+/** The plugins a definition's steps use, by id: a runtime without one of them cannot run it. */
+export declare function pluginsOf(def: WizardDefinition): string[];
+/** The plan a wizard needs: Pro as soon as it uses a plugin. */
+export declare const planOf: (plugins: readonly string[]) => MarketplacePlan;
+/** What a person does in a run, and about how long the whole run takes. */
+export interface Effort {
+    /** Fields to fill in, the required ones of them. */
+    fields: number;
+    required: number;
+    /** Stops where the person looks at a result before it goes on. */
+    reviews: number;
+    /** Minutes from start to result: filling in, plus the time the steps work. */
+    minutes: number;
+}
+export declare function effortOf(def: WizardDefinition): Effort;
+/** How expensive a run is, where no price in credits is known: by what it makes and uses. */
+export declare function costTierOf(capabilities: Capability[]): CostTier;
+/** One entry as the marketplace lists it, in a language. */
+export interface MarketplaceSummary {
+    id: string;
+    /** Goes up whenever the entry changes. */
+    revision: number;
+    /** Of everything the entry is made of, every language and file: changes with any of it. */
+    hash: string;
+    /** When the entry last changed, ISO 8601. */
+    updatedAt: string;
+    /** One of the entries an app keeps for offline use without being asked. */
+    starter: boolean;
+    /** The language of `title` and `pitch`; the entry's own where it is not translated. */
+    language: MarketplaceLang;
+    title: string;
+    pitch: string;
+    /** What people ask for when they mean this entry: searched, never shown. */
+    terms: string[];
+    avatar: string;
+    formats: ItemFormat[];
+    industries: Industry[];
+    useCases: UseCase[];
+    capabilities: Capability[];
+    effort: Effort;
+    costTier: CostTier;
+    steps: number;
+    /** The definition version the entry's wizard is written in (`DEFINITION_VERSION`). */
+    version: number;
+    /**
+     * The plugins its wizard uses, by id (`pluginsOf`). A marketplace older than this field leaves
+     * it out: read it as none.
+     */
+    plugins?: string[];
+    /** The plan it needs (`planOf`); left out by an older marketplace: free. */
+    plan?: MarketplacePlan;
+    /**
+     * The plugin's own starter this entry shows in the catalog, `<plugin id>.<starter id>`: a
+     * runtime with that plugin lists the plugin's starter instead.
+     */
+    pluginStarter?: string;
+}
+/** What a search narrows by, besides its words. */
+export interface MarketplaceFilters {
+    useCase?: UseCase;
+    industry?: Industry;
+    format?: ItemFormat;
+    capability?: Capability;
+    plan?: MarketplacePlan;
+}
+/** Per option of a filter: the entries it would leave, with the other filters as they are. */
+export interface MarketplaceFacets {
+    useCase: Partial<Record<UseCase, number>>;
+    industry: Partial<Record<Industry, number>>;
+    format: Partial<Record<ItemFormat, number>>;
+    /** Optional: a marketplace older than this filter leaves it out. */
+    capability?: Partial<Record<Capability, number>>;
+    /** Optional: a marketplace older than this filter leaves it out. */
+    plan?: Partial<Record<MarketplacePlan, number>>;
+}
+/** A page of a search: the entries, best first, how many there are, and the filters' counts. */
+export interface MarketplacePage<T extends MarketplaceSummary = MarketplaceSummary> {
+    entries: T[];
+    total: number;
+    /** Every published entry, before words and filters. */
+    all: number;
+    facets: MarketplaceFacets;
+}
+/** One entry with its wizard in a language: what an app starts a wizard from. */
+export interface MarketplaceItem extends MarketplaceSummary {
+    /** The wizard as written; an app reads it with its own schema. */
+    definition: unknown;
+    /** The workspace it starts with: path → base64. */
+    files: Record<string, string>;
+}
+/** Everything of an entry, every language: what an app keeps for offline use. */
+export interface MarketplaceExport extends MarketplaceSummary {
+    texts: {
+        language: MarketplaceLang;
+        title: string;
+        pitch: string;
+        definition: unknown;
+        /** Written by a model, not by a person. */
+        machine: boolean;
+    }[];
+    /** path → base64 */
+    files: Record<string, string>;
+}
+/** What an app compares with what it keeps: an entry changed where its hash differs. */
+export interface MarketplaceSyncItem {
+    id: string;
+    hash: string;
+    updatedAt: string;
+}
+/** One entry as the app shows it: the summary, read against this app. */
+export interface MarketplaceEntry extends MarketplaceSummary {
+    /** A run's price in credits and what it rarely exceeds; null where it is not worked out. */
+    credits: {
+        credits: number;
+        high: number;
+    } | null;
+    /** False: this app is older than the entry and would read its wizard wrongly. */
+    usable: boolean;
+    /** The person keeps it for offline use. */
+    starred: boolean;
+    /** What it needs that this runtime has no model for: a wizard made from it would not start. */
+    missing: Capability[];
+    /** What only some of its paths need and this runtime has no model for: it runs the other ways. */
+    optional: Capability[];
+    /** It comes with a plugin of this app, not from the marketplace: the plugin's id and name. */
+    plugin?: {
+        id: string;
+        name: string;
+    };
+    /** The plugins it needs that this app does not have: a wizard made from it would not run. */
+    needs?: string[];
+}
+export {};

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

@@ -0,0 +1,354 @@
+import { LANGS, pluginToolOf, } from "./definition.js";
+import { textOf } from "./texts.js";
+/**
+ * The marketplace: wizards anyone can start from. What an entry is sorted by — formats, industry,
+ * use case — and what follows from its definition: the AI capabilities it needs, how much a
+ * person has to fill in, and how expensive a run is.
+ */
+export const MARKETPLACE_LANGS = ["de", "en"];
+/** What comes out of a run. */
+export const ITEM_FORMAT_IDS = [
+    "text",
+    "document",
+    "table",
+    "image",
+    "video",
+    "audio",
+    "dashboard",
+];
+export const INDUSTRY_IDS = [
+    "any",
+    "trades",
+    "gastronomy",
+    "hospitality",
+    "realEstate",
+    "retail",
+    "health",
+    "professional",
+    "agency",
+    "events",
+    "publicSector",
+];
+export const USE_CASE_IDS = [
+    "marketing",
+    "sales",
+    "accounting",
+    "service",
+    "research",
+    "hr",
+    "operations",
+    "website",
+    "visuals",
+    "inquiries",
+    "advice",
+];
+/**
+ * What the models and tools behind a wizard must be able to do. `film`: a film the installed
+ * client makes, only on a computer with Claude Code, on its subscription.
+ */
+export const CAPABILITY_IDS = [
+    "text",
+    "web",
+    "browser",
+    "documents",
+    "image",
+    "video",
+    "speech",
+    "listening",
+    "code",
+    "connectors",
+    "film",
+];
+export const COST_TIER_IDS = ["low", "medium", "high"];
+/**
+ * The plan a wizard needs. Free runs on what every runtime has; Pro needs plugins, which come
+ * with the Pro and Team plans of engenty.ai.
+ */
+export const MARKETPLACE_PLAN_IDS = ["free", "pro"];
+const MARKET_EN = {
+    "format.text": "Text",
+    "format.document": "Document (PDF, Word)",
+    "format.table": "Table",
+    "format.image": "Image",
+    "format.video": "Video",
+    "format.audio": "Audio",
+    "format.dashboard": "Dashboard",
+    "industry.any": "Any industry",
+    "industry.trades": "Trades",
+    "industry.gastronomy": "Food service",
+    "industry.hospitality": "Hotels & tourism",
+    "industry.realEstate": "Real estate",
+    "industry.retail": "Retail",
+    "industry.health": "Health",
+    "industry.professional": "Professional services",
+    "industry.agency": "Agency & marketing",
+    "industry.events": "Events",
+    "industry.publicSector": "Associations & public sector",
+    "useCase.marketing": "Marketing & social media",
+    "useCase.sales": "Offers & sales",
+    "useCase.accounting": "Accounting & receipts",
+    "useCase.service": "Customer service",
+    "useCase.research": "Research & analysis",
+    "useCase.hr": "HR & applications",
+    "useCase.operations": "Planning & operations",
+    "useCase.website": "Website helpers",
+    "useCase.visuals": "Images & video",
+    "useCase.inquiries": "Inquiries & bookings",
+    "useCase.advice": "Advice & pricing",
+    "capability.text": "Writes text",
+    "capability.web": "Web search",
+    "capability.browser": "Drives a browser",
+    "capability.documents": "Reads documents & photos",
+    "capability.image": "Makes images",
+    "capability.video": "Makes video",
+    "capability.speech": "Speech output",
+    "capability.listening": "Understands voice notes",
+    "capability.code": "Runs code",
+    "capability.connectors": "Connected accounts & systems",
+    "capability.film": "Films with Claude Code (on your subscription)",
+    "cost.low": "low cost",
+    "cost.medium": "medium cost",
+    "cost.high": "high cost",
+    "plan.free": "Free",
+    "plan.pro": "Pro",
+    "outline.otherwise": "otherwise",
+    "outline.and": "{first} and {second}",
+    "outline.with": "with {name}",
+    "outline.without": "without {name}",
+    "outline.contains": "{name} contains {value}",
+};
+const MARKET_DE = {
+    "format.text": "Text",
+    "format.document": "Dokument (PDF, Word)",
+    "format.table": "Tabelle",
+    "format.image": "Bild",
+    "format.video": "Video",
+    "format.audio": "Audio",
+    "format.dashboard": "Dashboard",
+    "industry.any": "Jede Branche",
+    "industry.trades": "Handwerk",
+    "industry.gastronomy": "Gastronomie",
+    "industry.hospitality": "Hotel & Tourismus",
+    "industry.realEstate": "Immobilien",
+    "industry.retail": "Handel",
+    "industry.health": "Gesundheit",
+    "industry.professional": "Kanzlei & Beratung",
+    "industry.agency": "Agentur & Marketing",
+    "industry.events": "Veranstaltungen",
+    "industry.publicSector": "Vereine & Öffentliches",
+    "useCase.marketing": "Marketing & Social Media",
+    "useCase.sales": "Angebote & Verkauf",
+    "useCase.accounting": "Buchhaltung & Belege",
+    "useCase.service": "Kundenservice",
+    "useCase.research": "Recherche & Analyse",
+    "useCase.hr": "Personal & Bewerbungen",
+    "useCase.operations": "Planung & Abläufe",
+    "useCase.website": "Helfer für die Website",
+    "useCase.visuals": "Bilder & Video",
+    "useCase.inquiries": "Anfragen & Termine",
+    "useCase.advice": "Beratung & Preise",
+    "capability.text": "Text schreiben",
+    "capability.web": "Websuche",
+    "capability.browser": "Browser bedienen",
+    "capability.documents": "Dokumente & Fotos lesen",
+    "capability.image": "Bilder erzeugen",
+    "capability.video": "Videos erzeugen",
+    "capability.speech": "Sprachausgabe",
+    "capability.listening": "Sprachnotizen verstehen",
+    "capability.code": "Code ausführen",
+    "capability.connectors": "Verbundene Konten & Systeme",
+    "capability.film": "Filme mit Claude Code (auf deinem Abo)",
+    "cost.low": "günstig",
+    "cost.medium": "mittel",
+    "cost.high": "teuer",
+    "plan.free": "Kostenlos",
+    "plan.pro": "Pro",
+    "outline.otherwise": "sonst",
+    "outline.and": "{first} und {second}",
+    "outline.with": "mit {name}",
+    "outline.without": "ohne {name}",
+    "outline.contains": "{name} enthält {value}",
+};
+export const MARKET_TEXTS = { en: MARKET_EN, de: MARKET_DE };
+/** The label of a facet value, a cost tier or a plan in a language; its id where it has none. */
+export function marketLabel(group, id, lang, params) {
+    const key = `${group}.${id}`;
+    return key in MARKET_EN ? textOf(MARKET_TEXTS, key, lang, params) : id;
+}
+/** A label in every language, for search: a person may type either. */
+export const marketLabels = (group, id) => LANGS.map((lang) => marketLabel(group, id, lang));
+const FORMAT_OF = {
+    pdf: "document",
+    docx: "document",
+    xlsx: "table",
+    csv: "table",
+    png: "image",
+    mp4: "video",
+    mp3: "audio",
+    md: "text",
+    txt: "text",
+};
+/** The formats a run hands over, read from what the result step offers. */
+export function formatsOf(def) {
+    const found = new Set();
+    for (const step of def.steps) {
+        if (step.type === "generate" && step.asset === "dashboard") {
+            found.add("dashboard");
+        }
+        if (step.type === "result") {
+            for (const d of step.deliverables) {
+                const from = def.steps.find((s) => s.id === d.from);
+                for (const f of d.formats) {
+                    const format = FORMAT_OF[f];
+                    // A dashboard's PNG or PDF is still the dashboard.
+                    if (format && !(from?.type === "generate" && from.asset === "dashboard")) {
+                        found.add(format);
+                    }
+                }
+            }
+        }
+    }
+    if (!found.size) {
+        found.add("text");
+    }
+    return ITEM_FORMAT_IDS.filter((f) => found.has(f));
+}
+/** The capabilities a definition needs, read from its steps. */
+export function capabilitiesOf(def) {
+    const found = new Set();
+    for (const step of def.steps) {
+        if (step.type === "page") {
+            for (const field of step.fields) {
+                if (field.kind === "image" || field.kind === "file") {
+                    found.add("documents");
+                }
+                if (field.kind === "audio") {
+                    found.add("listening");
+                }
+            }
+        }
+        else if (step.type === "agent") {
+            // A call runs no model: it needs nothing but its plugin.
+            if (step.call) {
+                continue;
+            }
+            found.add("text");
+            for (const tool of step.tools) {
+                if (tool === "web_search" || tool === "web_fetch") {
+                    found.add("web");
+                }
+                else if (tool === "browser") {
+                    found.add("browser");
+                }
+                else if (tool === "sandbox") {
+                    found.add("code");
+                }
+                else if (tool === "image") {
+                    found.add("image");
+                }
+                else if (tool === "http") {
+                    found.add("connectors");
+                }
+            }
+            if (step.mcp?.length || step.connections?.length) {
+                found.add("connectors");
+            }
+        }
+        else if (step.type === "generate") {
+            if (step.asset === "image") {
+                found.add("image");
+            }
+            else if (step.asset === "video") {
+                found.add("video");
+            }
+            else if (step.asset === "voice") {
+                found.add("speech");
+            }
+            else {
+                found.add("text");
+            }
+        }
+        else if (step.type === "film") {
+            found.add("film");
+        }
+    }
+    if (def.connections?.length) {
+        found.add("connectors");
+    }
+    return CAPABILITY_IDS.filter((c) => found.has(c));
+}
+/** The plugins a definition's steps use, by id: a runtime without one of them cannot run it. */
+export function pluginsOf(def) {
+    const found = new Set();
+    for (const step of def.steps) {
+        if (step.type === "agent") {
+            for (const tool of step.call ? [...step.tools, step.call.tool] : step.tools) {
+                const of = pluginToolOf(tool);
+                if (of) {
+                    found.add(of.plugin);
+                }
+            }
+        }
+    }
+    return [...found].sort();
+}
+/** The plan a wizard needs: Pro as soon as it uses a plugin. */
+export const planOf = (plugins) => plugins.length ? "pro" : "free";
+const WORK_SECONDS = { agent: 25, tools: 70, browser: 150, image: 30, video: 120, voice: 20 };
+export function effortOf(def) {
+    let fields = 0;
+    let required = 0;
+    let reviews = 0;
+    let seconds = 0;
+    for (const step of def.steps) {
+        if (step.type === "page") {
+            fields += step.fields.length;
+            required += step.fields.filter((f) => f.required).length;
+            seconds += step.fields.length * 15;
+        }
+        else if (step.type === "review") {
+            reviews += 1;
+            seconds += 30;
+        }
+        else if (step.type === "agent" && step.call) {
+            seconds += 1;
+        }
+        else if (step.type === "agent") {
+            seconds += step.tools.includes("browser")
+                ? WORK_SECONDS.browser
+                : step.tools.length || step.mcp?.length || step.connections?.length
+                    ? WORK_SECONDS.tools
+                    : WORK_SECONDS.agent;
+        }
+        else if (step.type === "generate") {
+            // "each" makes one result per entry; three stands in for a number nobody knows yet.
+            const times = step.each ? 3 : 1;
+            seconds +=
+                times *
+                    (step.asset === "image"
+                        ? WORK_SECONDS.image
+                        : step.asset === "video"
+                            ? WORK_SECONDS.video
+                            : step.asset === "voice"
+                                ? WORK_SECONDS.voice
+                                : WORK_SECONDS.agent);
+        }
+        else if (step.type === "widget" && step.video) {
+            seconds += 60;
+        }
+        else if (step.type === "film") {
+            // A client writing a film from a style kit: ten minutes to half an hour (2026-10 tests).
+            seconds += 25 * 60;
+        }
+    }
+    return { fields, required, reviews, minutes: Math.max(1, Math.round(seconds / 60)) };
+}
+/** How expensive a run is, where no price in credits is known: by what it makes and uses. */
+export function costTierOf(capabilities) {
+    if (capabilities.includes("video")) {
+        return "high";
+    }
+    return capabilities.some((c) => c === "image" || c === "browser" || c === "speech")
+        ? "medium"
+        : "low";
+}

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

@@ -0,0 +1,7 @@
+import type { WizardDefinition } from "./definition.js";
+/**
+ * Three-way merge, step by step, of a draft edited in the studio (`local`) with one written
+ * elsewhere meanwhile (`remote`), both starting from `base`. What the studio changed, added or
+ * removed wins; everything else is taken from `remote`.
+ */
+export declare function mergeDrafts(base: WizardDefinition, local: WizardDefinition, remote: WizardDefinition): WizardDefinition;

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

@@ -0,0 +1,40 @@
+const META = ["title", "description", "avatar", "intro", "lists", "connections"];
+const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+/**
+ * Three-way merge, step by step, of a draft edited in the studio (`local`) with one written
+ * elsewhere meanwhile (`remote`), both starting from `base`. What the studio changed, added or
+ * removed wins; everything else is taken from `remote`.
+ */
+export function mergeDrafts(base, local, remote) {
+    const merged = { ...remote };
+    for (const key of META) {
+        if (!same(local[key], base[key])) {
+            Object.assign(merged, { [key]: local[key] });
+        }
+    }
+    const baseSteps = new Map(base.steps.map((s) => [s.id, s]));
+    const localIds = new Set(local.steps.map((s) => s.id));
+    // Removed in the studio: gone, unless the other side changed it meanwhile.
+    const steps = remote.steps.filter((s) => {
+        const before = baseSteps.get(s.id);
+        return localIds.has(s.id) || !before || !same(before, s);
+    });
+    local.steps.forEach((step, i) => {
+        const before = baseSteps.get(step.id);
+        if (before && same(before, step)) {
+            return;
+        }
+        const at = steps.findIndex((s) => s.id === step.id);
+        if (at !== -1) {
+            steps[at] = step;
+            return;
+        }
+        // New in the studio: after the step it follows there.
+        const prev = local.steps
+            .slice(0, i)
+            .reverse()
+            .find((p) => steps.some((s) => s.id === p.id));
+        steps.splice(prev ? steps.findIndex((s) => s.id === prev.id) + 1 : 0, 0, step);
+    });
+    return { ...merged, steps };
+}

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

@@ -0,0 +1,24 @@
+/**
+ * Numbers as people write and read them: what a phone's number pad, a table cell or a document
+ * gives, and an amount or a file's size as a page shows it. The server, the studio and the runner read and
+ * show them the same way.
+ */
+/**
+ * A number as a person types it: digits with at most one decimal mark, a point or a comma
+ * alike, as a phone's number pad gives it in either language (`1.5`, `1,5`, `89,90`). There are
+ * no thousands separators: `1.234` and `1,234` are 1.234, and anything with two marks
+ * (`1.234,50`, `1.234.567`) is no number, since only the writer's language could say which mark
+ * is which. Text that is not typed (a document, a website) is read by a model into numbers
+ * before it gets here. With `units`, what stands around the number is dropped (`38 h`,
+ * `19 %`); without, anything but the number makes it none. Null where there is no number.
+ */
+export declare function readNumber(value: unknown, opts?: {
+    units?: boolean;
+}): number | null;
+/**
+ * A file's size for a list, in decimal units as the operating systems show them: `1 KB` for
+ * anything below a kilobyte but nothing (`0 KB`), `340 KB`, `2.4 MB`, `1.2 GB`.
+ */
+export declare function formatBytes(bytes: number): string;
+/** An amount in a currency, as the language writes it (`1.234,50 €`); an unknown currency code as `1234.50 XYZ`. */
+export declare function formatMoney(amount: number, currency: string, locale: string): string;