wizards 0.1.9

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

@@ -0,0 +1,133 @@
+import { scoreCatalogEntry, tokenizeCatalogText, } from "./engenty/search-index/catalog-lexical.js";
+import { CAPABILITIES, INDUSTRIES, ITEM_FORMATS, USE_CASES, } from "./marketplace.js";
+/**
+ * Searching the marketplace by words: BM25 with prefixes and inflections, the scoring engenty's
+ * catalogs use. The marketplace answers every search with it; an app that cannot reach the
+ * marketplace searches what it keeps the same way.
+ */
+const WEIGHTS = [
+    ["title", 10],
+    ["summary", 6],
+    ["category", 5],
+    ["tags", 3],
+];
+/** One search term of an entry, scored on its own. */
+const TERM_WEIGHT = [["term", 7]];
+/**
+ * Words a sentence is full of and no entry is found by — in the form the search reads words in,
+ * so "für" is left out as "fur".
+ */
+const STOP = new Set(tokenizeCatalogText(`aber als also am an auch auf aus bei bin bitte brauche brauchen braucht das dass dem den der
+    des die dies diese dieser doch du ein eine einem einen einer eines er es etwas fuer für gerne
+    habe haben hat ich ihr im in ist kann können koennen mache machen mag mein meine meinem meinen
+    meiner mich mir mit möchte moechte nach nicht noch nur oder sich sie sind soll suche suchen
+    sucht um und uns unser unsere vom von vor was wie will wir wird wo wollen zu zum zur
+    a about an and are as at be can do for from have how i in is it like looking me my need of on
+    or our that the this to want we what which who with would you your`));
+const fold = (text) => text.replace(/ß/g, "ss");
+/** What a query is looked up by: its words, without the ones that say nothing. */
+export function searchTerms(query) {
+    const words = tokenizeCatalogText(fold(query));
+    const kept = words.filter((w) => !STOP.has(w));
+    return kept.length ? kept : words;
+}
+/** From this many words on a query is a sentence: it shares some word with nearly every entry. */
+export const SENTENCE_WORDS = 3;
+/** Of a sentence's finds by words, those with at least this share of the best score are kept. */
+const SENTENCE_SHARE = 0.4;
+export const isSentence = (query) => query.trim().split(/\s+/).filter(Boolean).length >= SENTENCE_WORDS;
+const labels = (all, ids) => ids.flatMap((id) => (all[id] ? [all[id].de, all[id].en] : []));
+/** How well an entry answers the query by its words; 0 when it does not at all. */
+export function scoreEntry(entry, query) {
+    const terms = searchTerms(query);
+    if (!terms.length) {
+        return 0;
+    }
+    const record = {
+        title: fold(entry.title),
+        summary: fold(entry.pitch),
+        category: labels(USE_CASES, entry.useCases),
+        tags: [
+            ...labels(INDUSTRIES, entry.industries),
+            ...labels(ITEM_FORMATS, entry.formats),
+            ...labels(CAPABILITIES, entry.capabilities),
+        ].map(fold),
+    };
+    let score = scoreCatalogEntry(record, terms.join(" "), WEIGHTS);
+    // An entry's own search terms: each word of the query counts once, by the term it fits best.
+    // Scored as one long text they would count for less the more of them an entry has.
+    const own = entry.terms.map((term) => ({ term: fold(term) }));
+    for (const word of terms) {
+        score += Math.max(0, ...own.map((t) => scoreCatalogEntry(t, word, TERM_WEIGHT)));
+    }
+    // German writes words together: "anzeige" is found inside "Videoanzeige" as well.
+    const text = tokenizeCatalogText(`${record.title} ${record.summary}`).join(" ");
+    const inside = terms.filter((term) => term.length >= 4 && text.includes(term)).length;
+    return score + inside * 2;
+}
+/** The entries a query finds by its words, best first. An empty query keeps the list as it is. */
+export function rankEntries(entries, query) {
+    if (!query.trim()) {
+        return [...entries];
+    }
+    const rows = entries
+        .map((entry) => ({ entry, score: scoreEntry(entry, query) }))
+        .filter((row) => row.score > 0)
+        .sort((a, b) => b.score - a.score);
+    // A sentence shares some word with nearly every entry: only what comes close to the best counts.
+    const least = isSentence(query) ? (rows[0]?.score ?? 0) * SENTENCE_SHARE : 0;
+    return rows.filter((row) => row.score >= least).map((row) => row.entry);
+}
+/** Whether an entry passes the filters. An entry made for any industry passes every industry. */
+export function matchesFilters(e, f) {
+    return ((!f.useCase || e.useCases.includes(f.useCase)) &&
+        (!f.industry ||
+            e.industries.includes(f.industry) ||
+            (f.industry !== "any" && e.industries.includes("any"))) &&
+        (!f.format || e.formats.includes(f.format)) &&
+        (!f.capability || e.capabilities.includes(f.capability)));
+}
+const FACETS = {
+    useCase: (e) => e.useCases,
+    industry: (e) => e.industries,
+    format: (e) => e.formats,
+    capability: (e) => e.capabilities,
+};
+/**
+ * Per option of each filter, the found entries it would leave with the other filters as they
+ * are. An option no entry has at all is left out.
+ */
+function facetsOf(all, found, filters) {
+    const facets = {
+        useCase: {},
+        industry: {},
+        format: {},
+        capability: {},
+    };
+    for (const key of Object.keys(FACETS)) {
+        const options = new Set(all.flatMap(FACETS[key]));
+        const counts = facets[key];
+        for (const option of options) {
+            counts[option] = found.filter((e) => matchesFilters(e, {
+                ...filters,
+                [key]: option,
+            })).length;
+        }
+    }
+    return facets;
+}
+/**
+ * A search as the marketplace answers it: the entries the words find, best first (an empty
+ * query keeps the order given), narrowed by the filters, one page of them, and the counts.
+ */
+export function searchEntries(entries, query, filters = {}, page = {}) {
+    const found = rankEntries(entries, query);
+    const shown = found.filter((e) => matchesFilters(e, filters));
+    const offset = Math.max(0, page.offset ?? 0);
+    return {
+        entries: shown.slice(offset, offset + Math.max(1, page.limit ?? 60)),
+        total: shown.length,
+        all: entries.length,
+        facets: facetsOf(entries, found, filters),
+    };
+}

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

@@ -0,0 +1,298 @@
+import type { WizardDefinition } from "./definition.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_FORMATS: {
+    text: {
+        de: string;
+        en: string;
+    };
+    document: {
+        de: string;
+        en: string;
+    };
+    table: {
+        de: string;
+        en: string;
+    };
+    image: {
+        de: string;
+        en: string;
+    };
+    video: {
+        de: string;
+        en: string;
+    };
+    audio: {
+        de: string;
+        en: string;
+    };
+    dashboard: {
+        de: string;
+        en: string;
+    };
+};
+export type ItemFormat = keyof typeof ITEM_FORMATS;
+export declare const INDUSTRIES: {
+    any: {
+        de: string;
+        en: string;
+    };
+    trades: {
+        de: string;
+        en: string;
+    };
+    gastronomy: {
+        de: string;
+        en: string;
+    };
+    hospitality: {
+        de: string;
+        en: string;
+    };
+    realEstate: {
+        de: string;
+        en: string;
+    };
+    retail: {
+        de: string;
+        en: string;
+    };
+    health: {
+        de: string;
+        en: string;
+    };
+    professional: {
+        de: string;
+        en: string;
+    };
+    agency: {
+        de: string;
+        en: string;
+    };
+    events: {
+        de: string;
+        en: string;
+    };
+    publicSector: {
+        de: string;
+        en: string;
+    };
+};
+export type Industry = keyof typeof INDUSTRIES;
+export declare const USE_CASES: {
+    marketing: {
+        de: string;
+        en: string;
+    };
+    sales: {
+        de: string;
+        en: string;
+    };
+    accounting: {
+        de: string;
+        en: string;
+    };
+    service: {
+        de: string;
+        en: string;
+    };
+    research: {
+        de: string;
+        en: string;
+    };
+    hr: {
+        de: string;
+        en: string;
+    };
+    operations: {
+        de: string;
+        en: string;
+    };
+    website: {
+        de: string;
+        en: string;
+    };
+};
+export type UseCase = keyof typeof USE_CASES;
+/** What the models and tools behind a wizard must be able to do. */
+export declare const CAPABILITIES: {
+    text: {
+        de: string;
+        en: string;
+    };
+    web: {
+        de: string;
+        en: string;
+    };
+    browser: {
+        de: string;
+        en: string;
+    };
+    documents: {
+        de: string;
+        en: string;
+    };
+    image: {
+        de: string;
+        en: string;
+    };
+    video: {
+        de: string;
+        en: string;
+    };
+    speech: {
+        de: string;
+        en: string;
+    };
+    listening: {
+        de: string;
+        en: string;
+    };
+    code: {
+        de: string;
+        en: string;
+    };
+    connectors: {
+        de: string;
+        en: string;
+    };
+};
+export type Capability = keyof typeof CAPABILITIES;
+export declare const COST_TIERS: {
+    low: {
+        de: string;
+        en: string;
+    };
+    medium: {
+        de: string;
+        en: string;
+    };
+    high: {
+        de: string;
+        en: string;
+    };
+};
+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")[];
+export declare const CAPABILITY_IDS: ("text" | "code" | "image" | "browser" | "video" | "speech" | "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. */
+export declare function capabilitiesOf(def: WizardDefinition): Capability[];
+/** 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;
+/**
+ * The link that opens an entry in a local install at its default address — in the browser, or
+ * in the studio installed as a Chrome app.
+ */
+export declare const entryLocalLink: (id: string) => string;
+/** 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;
+}
+/** What a search narrows by, besides its words. */
+export interface MarketplaceFilters {
+    useCase?: UseCase;
+    industry?: Industry;
+    format?: ItemFormat;
+    capability?: Capability;
+}
+/** 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>>;
+}
+/** 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[];
+}

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

@@ -0,0 +1,211 @@
+/**
+ * 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_FORMATS = {
+    text: { de: "Text", en: "Text" },
+    document: { de: "Dokument (PDF, Word)", en: "Document (PDF, Word)" },
+    table: { de: "Tabelle", en: "Table" },
+    image: { de: "Bild", en: "Image" },
+    video: { de: "Video", en: "Video" },
+    audio: { de: "Audio", en: "Audio" },
+    dashboard: { de: "Dashboard", en: "Dashboard" },
+};
+export const INDUSTRIES = {
+    any: { de: "Jede Branche", en: "Any industry" },
+    trades: { de: "Handwerk", en: "Trades" },
+    gastronomy: { de: "Gastronomie", en: "Food service" },
+    hospitality: { de: "Hotel & Tourismus", en: "Hotels & tourism" },
+    realEstate: { de: "Immobilien", en: "Real estate" },
+    retail: { de: "Handel", en: "Retail" },
+    health: { de: "Gesundheit", en: "Health" },
+    professional: { de: "Kanzlei & Beratung", en: "Professional services" },
+    agency: { de: "Agentur & Marketing", en: "Agency & marketing" },
+    events: { de: "Veranstaltungen", en: "Events" },
+    publicSector: { de: "Vereine & Öffentliches", en: "Associations & public sector" },
+};
+export const USE_CASES = {
+    marketing: { de: "Marketing & Social Media", en: "Marketing & social media" },
+    sales: { de: "Angebote & Verkauf", en: "Offers & sales" },
+    accounting: { de: "Buchhaltung & Belege", en: "Accounting & receipts" },
+    service: { de: "Kundenservice", en: "Customer service" },
+    research: { de: "Recherche & Analyse", en: "Research & analysis" },
+    hr: { de: "Personal & Bewerbungen", en: "HR & applications" },
+    operations: { de: "Planung & Abläufe", en: "Planning & operations" },
+    website: { de: "Helfer für die Website", en: "Website helpers" },
+};
+/** What the models and tools behind a wizard must be able to do. */
+export const CAPABILITIES = {
+    text: { de: "Text schreiben", en: "Writes text" },
+    web: { de: "Websuche", en: "Web search" },
+    browser: { de: "Browser bedienen", en: "Drives a browser" },
+    documents: { de: "Dokumente & Fotos lesen", en: "Reads documents & photos" },
+    image: { de: "Bilder erzeugen", en: "Makes images" },
+    video: { de: "Videos erzeugen", en: "Makes video" },
+    speech: { de: "Sprachausgabe", en: "Speech output" },
+    listening: { de: "Sprachnotizen verstehen", en: "Understands voice notes" },
+    code: { de: "Code ausführen", en: "Runs code" },
+    connectors: { de: "Verbundene Konten & Systeme", en: "Connected accounts & systems" },
+};
+export const COST_TIERS = {
+    low: { de: "günstig", en: "low cost" },
+    medium: { de: "mittel", en: "medium cost" },
+    high: { de: "teuer", en: "high cost" },
+};
+const keys = (o) => Object.keys(o);
+export const ITEM_FORMAT_IDS = keys(ITEM_FORMATS);
+export const INDUSTRY_IDS = keys(INDUSTRIES);
+export const USE_CASE_IDS = keys(USE_CASES);
+export const CAPABILITY_IDS = keys(CAPABILITIES);
+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") {
+            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");
+            }
+        }
+    }
+    if (def.connections?.length) {
+        found.add("connectors");
+    }
+    return CAPABILITY_IDS.filter((c) => found.has(c));
+}
+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") {
+            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;
+        }
+    }
+    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";
+}
+/**
+ * The link that opens an entry in a local install at its default address — in the browser, or
+ * in the studio installed as a Chrome app.
+ */
+export const entryLocalLink = (id) => `http://localhost:24368/studio/new?starter=${encodeURIComponent(id)}`;

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 };
+}