wizards 0.1.9

package/node_modules/@engenty-wizards/shared/dist/engenty/data-tables/columns.js

@@ -0,0 +1,216 @@
+/**
+ * Space-table column definitions.
+ *
+ * A table is a small database, not a CSV dump: every column has a type and a
+ * display format. Agents create the definition; row writes are validated
+ * against it.
+ */
+import { z } from "zod";
+const COLUMN_ID = /^[a-z][a-z0-9_]*$/;
+const columnBaseSchema = z.object({
+    description: z.string().max(1024).optional(),
+    /**
+     * Where the cell is edited. Omit to use the type default:
+     * single-line text and booleans are in-field; everything else is a popout.
+     */
+    edit: z.enum(["inline", "popout"]).optional(),
+    id: z
+        .string()
+        .min(1)
+        .max(64)
+        .regex(COLUMN_ID, "column id must be a lowercase slug (a-z, 0-9, _)"),
+    name: z.string().min(1).max(128),
+    required: z.boolean().optional(),
+});
+export const numberStyleSchema = z.enum([
+    "integer",
+    "decimal",
+    "percent",
+    "currency",
+]);
+export const numberFormatSchema = z
+    .object({
+    currency: z
+        .string()
+        .regex(/^[A-Z]{3}$/, "currency must be an ISO 4217 code")
+        .optional(),
+    fractionDigits: z.number().int().min(0).max(8).optional(),
+    grouping: z.boolean().optional(),
+    style: numberStyleSchema,
+})
+    .superRefine((val, ctx) => {
+    if (val.style === "currency" && !val.currency) {
+        ctx.addIssue({
+            code: "custom",
+            message: "currency style needs an ISO 4217 code",
+            path: ["currency"],
+        });
+    }
+    if (val.style !== "currency" && val.currency) {
+        ctx.addIssue({
+            code: "custom",
+            message: "currency is only valid on currency columns",
+            path: ["currency"],
+        });
+    }
+});
+export const dateKindSchema = z.enum(["date", "datetime", "time"]);
+export const dateStyleSchema = z.enum(["short", "medium", "long", "iso"]);
+/** `hours` is clock time with no minutes — `14` or `14:30` both store as `14:00`. */
+export const timePrecisionSchema = z.enum(["hours", "minutes", "seconds"]);
+export const dateFormatSchema = z.object({
+    dateStyle: dateStyleSchema.optional(),
+    kind: dateKindSchema,
+    timePrecision: timePrecisionSchema.optional(),
+});
+export const durationUnitSchema = z.enum([
+    "milliseconds",
+    "seconds",
+    "minutes",
+    "hours",
+    "days",
+]);
+export const durationDisplaySchema = z.enum([
+    "hms",
+    "hours",
+    "minutes",
+    "decimal-hours",
+    "iso",
+]);
+export const durationFormatSchema = z.object({
+    display: durationDisplaySchema,
+    /** Unit a writer typically types; stored value is always milliseconds. */
+    inputUnit: durationUnitSchema,
+});
+export const selectOptionSchema = z.object({
+    id: z.string().min(1).max(64),
+    label: z.string().min(1).max(128),
+});
+export const selectFormatSchema = z.object({
+    /** Values outside `options` are kept as-is instead of rejected. */
+    allowCustom: z.boolean(),
+    multiple: z.boolean().optional(),
+    options: z.array(selectOptionSchema).max(200),
+});
+export const textStyleSchema = z.enum(["single", "multiline", "markdown"]);
+export const textFormatSchema = z.object({
+    /** `single` is one line; `multiline` is plain wrapping text; `markdown` is inline marks. */
+    style: textStyleSchema.default("single"),
+});
+export const tableColumnSchema = z.discriminatedUnion("type", [
+    columnBaseSchema.extend({
+        format: textFormatSchema.optional(),
+        type: z.literal("text"),
+    }),
+    columnBaseSchema.extend({
+        format: numberFormatSchema,
+        type: z.literal("number"),
+    }),
+    columnBaseSchema.extend({
+        format: dateFormatSchema,
+        type: z.literal("date"),
+    }),
+    columnBaseSchema.extend({
+        format: durationFormatSchema,
+        type: z.literal("duration"),
+    }),
+    columnBaseSchema.extend({
+        format: selectFormatSchema,
+        type: z.literal("select"),
+    }),
+    columnBaseSchema.extend({ type: z.literal("boolean") }),
+]);
+export function textColumnStyle(column) {
+    return column.type === "text" ? (column.format?.style ?? "single") : "single";
+}
+/** Where this cell is edited. Explicit `edit` wins; otherwise type defaults. */
+export function columnEdit(column) {
+    if (column.edit) {
+        return column.edit;
+    }
+    if (column.type === "boolean") {
+        return "inline";
+    }
+    if (column.type === "text" && textColumnStyle(column) === "single") {
+        return "inline";
+    }
+    return "popout";
+}
+export const tableColumnsSchema = z
+    .array(tableColumnSchema)
+    .min(1)
+    .max(64)
+    .superRefine((columns, ctx) => {
+    const seen = new Set();
+    for (let i = 0; i < columns.length; i++) {
+        const id = columns[i]?.id;
+        if (!id) {
+            continue;
+        }
+        if (seen.has(id)) {
+            ctx.addIssue({
+                code: "custom",
+                message: `duplicate column id "${id}"`,
+                path: [i, "id"],
+            });
+        }
+        seen.add(id);
+    }
+});
+/**
+ * The shape a MODEL is shown for `columns`, as opposed to the one we validate.
+ *
+ * `tableColumnsSchema` is a six-branch discriminated union that repeats the
+ * whole column base per branch. As a tool's JSON Schema that came to 14.7 KB —
+ * on its own 5% of a copilot prompt, resent on every model call of every run,
+ * whether or not a table is in play. The union earns that as a *contract*; it
+ * does not earn it as a *hint*.
+ *
+ * So the wire shape is one flat object with every format key optional, and the
+ * tool re-parses the result with `tableColumnsSchema` before doing anything.
+ * Validation is unchanged and the error the model gets back is the strict
+ * schema's own; only the advertisement shrinks. Per-type rules live in the
+ * tool description, which the model reads anyway.
+ */
+export const tableColumnWireSchema = z.object({
+    description: z.string().optional(),
+    edit: z.enum(["inline", "popout"]).optional(),
+    format: z
+        .object({
+        allowCustom: z.boolean().optional(),
+        currency: z.string().optional(),
+        dateStyle: z.enum(["short", "medium", "long", "iso"]).optional(),
+        display: durationDisplaySchema.optional(),
+        fractionDigits: z.number().int().optional(),
+        grouping: z.boolean().optional(),
+        inputUnit: durationUnitSchema.optional(),
+        kind: dateKindSchema.optional(),
+        multiple: z.boolean().optional(),
+        options: z.array(selectOptionSchema).optional(),
+        // `style` spans text and number columns; which values are legal follows
+        // from `type`, and the strict schema is what decides.
+        style: z
+            .enum([
+            "single",
+            "multiline",
+            "markdown",
+            "integer",
+            "decimal",
+            "percent",
+            "currency",
+        ])
+            .optional(),
+        timePrecision: timePrecisionSchema.optional(),
+    })
+        .optional(),
+    id: z.string(),
+    name: z.string(),
+    required: z.boolean().optional(),
+    type: z.enum(["text", "number", "date", "duration", "select", "boolean"]),
+});
+export const tableColumnsWireSchema = z.array(tableColumnWireSchema);
+export const DATA_TABLE_ARTIFACT_TYPE = "database";
+export const DATA_TABLE_MIME_TYPE = "application/vnd.engenty.database+json";
+export const dataTableHandleSchema = z.object({
+    table_id: z.string().uuid(),
+});

package/node_modules/@engenty-wizards/shared/dist/engenty/data-tables/index.d.ts

@@ -0,0 +1,3 @@
+export { type ColumnEdit, columnEdit, DATA_TABLE_ARTIFACT_TYPE, DATA_TABLE_MIME_TYPE, type DataTableHandle, type DateFormat, type DateKind, type DateStyle, type DurationDisplay, type DurationFormat, type DurationUnit, dataTableHandleSchema, dateFormatSchema, durationFormatSchema, type NumberFormat, type NumberStyle, numberFormatSchema, type SelectFormat, type SelectOption, selectFormatSchema, type TableColumn, type TableColumnWire, type TextFormat, type TextStyle, type TimePrecision, tableColumnSchema, tableColumnsSchema, tableColumnsWireSchema, tableColumnWireSchema, textColumnStyle, textFormatSchema, textStyleSchema, } from "./columns.js";
+export { formatDateCell, formatDurationCell, formatNumberCell, formatTableCell, } from "./columns-format.js";
+export { coerceColumnValue, coerceRowValues, mergeRowValues, parseTableColumns, TableColumnValueError, } from "./columns-value.js";

package/node_modules/@engenty-wizards/shared/dist/engenty/data-tables/index.js

@@ -0,0 +1,3 @@
+export { columnEdit, DATA_TABLE_ARTIFACT_TYPE, DATA_TABLE_MIME_TYPE, dataTableHandleSchema, dateFormatSchema, durationFormatSchema, numberFormatSchema, selectFormatSchema, tableColumnSchema, tableColumnsSchema, tableColumnsWireSchema, tableColumnWireSchema, textColumnStyle, textFormatSchema, textStyleSchema, } from "./columns.js";
+export { formatDateCell, formatDurationCell, formatNumberCell, formatTableCell, } from "./columns-format.js";
+export { coerceColumnValue, coerceRowValues, mergeRowValues, parseTableColumns, TableColumnValueError, } from "./columns-value.js";

package/node_modules/@engenty-wizards/shared/dist/engenty/search-index/catalog-lexical.d.ts

@@ -0,0 +1,14 @@
+export type CatalogSearchEntry = Record<string, unknown>;
+export type CatalogFieldWeights = ReadonlyArray<readonly [string, number]>;
+export declare const CATALOG_FIELD_WEIGHTS: CatalogFieldWeights;
+export declare function tokenizeCatalogText(value: string): string[];
+export declare function stringifyCatalogSearchValue(value: unknown): string;
+/**
+ * Weighted "key: value" text for an entry — the canonical input for
+ * embedding an entry when a consumer layers semantic search on top.
+ */
+export declare function buildCatalogSearchText(entry: CatalogSearchEntry, weights?: CatalogFieldWeights): string;
+/** BM25-like weighted-field lexical score; 0 when the query has no overlap. */
+export declare function scoreCatalogEntry(entry: CatalogSearchEntry, query?: string, weights?: CatalogFieldWeights): number;
+/** Sort entries by precomputed lexical score, dropping zero-score entries. */
+export declare function rankLexically<T extends CatalogSearchEntry>(entries: T[], lexicalScores: number[]): T[];

package/node_modules/@engenty-wizards/shared/dist/engenty/search-index/catalog-lexical.js

@@ -0,0 +1,166 @@
+// Shared lexical scoring for API-catalog-shaped entries.
+//
+// Extracted from apps/core's api-catalog search so both apps/core (the
+// `core_api_catalog_search` gateway method, lexical-only) and apps/ai
+// (the agent-facing catalog provider, which layers semantic reranking on
+// top) score entries the same way. Entries are plain records; callers
+// pick which fields matter via a weight list.
+// Default weights match the historical apps/core catalog ranking (entries
+// produced by buildApiCatalog: HTTP routes + tool operations).
+export const CATALOG_FIELD_WEIGHTS = [
+    ["id", 8],
+    ["toolId", 10],
+    ["moduleId", 7],
+    ["pluginId", 6],
+    ["title", 6],
+    ["description", 4],
+    ["tags", 3],
+    ["path", 3],
+    ["inputSchema", 2],
+    ["outputSchema", 2],
+    ["request", 1],
+    ["response", 1],
+];
+function normalizeText(value) {
+    return value
+        .normalize("NFKD")
+        .replace(/[̀-ͯ]/g, "")
+        .replace(/([a-z])([A-Z])/g, "$1 $2")
+        .toLowerCase();
+}
+export function tokenizeCatalogText(value) {
+    return normalizeText(value)
+        .split(/[^a-z0-9]+/)
+        .map((token) => token.trim())
+        .filter((token) => token.length > 1);
+}
+export function stringifyCatalogSearchValue(value) {
+    if (value == null) {
+        return "";
+    }
+    if (Array.isArray(value)) {
+        return value.map(stringifyCatalogSearchValue).filter(Boolean).join(" ");
+    }
+    if (typeof value === "object") {
+        return Object.values(value)
+            .map(stringifyCatalogSearchValue)
+            .filter(Boolean)
+            .join(" ");
+    }
+    return String(value);
+}
+function buildSearchDocument(entry, weights) {
+    const fields = weights
+        .map(([key, weight]) => ({
+        text: stringifyCatalogSearchValue(entry[key]),
+        weight,
+    }))
+        .filter((field) => field.text.length > 0);
+    const tokens = fields.flatMap((field) => tokenizeCatalogText(field.text));
+    return { fields, tokens };
+}
+/**
+ * Weighted "key: value" text for an entry — the canonical input for
+ * embedding an entry when a consumer layers semantic search on top.
+ */
+export function buildCatalogSearchText(entry, weights = CATALOG_FIELD_WEIGHTS) {
+    return weights
+        .map(([key]) => {
+        const value = stringifyCatalogSearchValue(entry[key]);
+        return value ? `${key}: ${value}` : "";
+    })
+        .filter(Boolean)
+        .join("\n");
+}
+function inflectionStems(token) {
+    const stems = [token];
+    if (token.length < 5) {
+        return stems;
+    }
+    if (token.endsWith("ing")) {
+        const base = token.slice(0, -3);
+        if (base.length >= 3) {
+            stems.push(base, `${base}e`);
+        }
+    }
+    else if (token.endsWith("ies") && token.length >= 6) {
+        stems.push(`${token.slice(0, -3)}y`);
+    }
+    else if (token.endsWith("es")) {
+        stems.push(token.slice(0, -2), token.slice(0, -1));
+    }
+    else if (token.endsWith("ed")) {
+        const base = token.slice(0, -2);
+        stems.push(base, `${base}e`);
+    }
+    else if (token.endsWith("s") && !token.endsWith("ss")) {
+        stems.push(token.slice(0, -1));
+    }
+    return [...new Set(stems)];
+}
+function tokenMatchStrength(queryToken, candidate) {
+    if (queryToken === candidate) {
+        return 1;
+    }
+    let best = 0;
+    for (const queryStem of inflectionStems(queryToken)) {
+        for (const candidateStem of inflectionStems(candidate)) {
+            if (queryStem === candidateStem) {
+                best = Math.max(best, queryStem === queryToken && candidateStem === candidate ? 1 : 0.75);
+                continue;
+            }
+            if (queryStem.length >= 2 && candidateStem.startsWith(queryStem)) {
+                best = Math.max(best, 0.55 * (queryStem.length / candidateStem.length));
+            }
+            if (candidateStem.length >= 4 && queryStem.startsWith(candidateStem)) {
+                best = Math.max(best, 0.4 * (candidateStem.length / queryStem.length));
+            }
+        }
+    }
+    return best;
+}
+function weightedTokenFrequency(tokens, queryToken) {
+    return tokens.reduce((sum, token) => sum + tokenMatchStrength(queryToken, token), 0);
+}
+/** BM25-like weighted-field lexical score; 0 when the query has no overlap. */
+export function scoreCatalogEntry(entry, query, weights = CATALOG_FIELD_WEIGHTS) {
+    if (!query?.trim()) {
+        return 0;
+    }
+    const queryTokens = tokenizeCatalogText(query);
+    if (queryTokens.length === 0) {
+        return 0;
+    }
+    const document = buildSearchDocument(entry, weights);
+    if (document.tokens.length === 0) {
+        return 0;
+    }
+    return queryTokens.reduce((score, token) => {
+        const termFrequency = weightedTokenFrequency(document.tokens, token);
+        if (termFrequency === 0) {
+            return score;
+        }
+        const fieldScore = document.fields.reduce((sum, field) => {
+            const fieldTokens = tokenizeCatalogText(field.text);
+            const fieldFrequency = weightedTokenFrequency(fieldTokens, token);
+            if (fieldFrequency === 0) {
+                return sum;
+            }
+            const bm25Like = (fieldFrequency * 2.2) /
+                (fieldFrequency + 1.2 + fieldTokens.length / 16);
+            return sum + field.weight * bm25Like;
+        }, 0);
+        return score + fieldScore;
+    }, 0);
+}
+/** Sort entries by precomputed lexical score, dropping zero-score entries. */
+export function rankLexically(entries, lexicalScores) {
+    return entries
+        .map((entry, index) => ({
+        entry,
+        score: lexicalScores[index] ?? 0,
+    }))
+        .filter((item) => item.score > 0)
+        .sort((a, b) => b.score - a.score)
+        .map((item) => item.entry);
+}

package/node_modules/@engenty-wizards/shared/dist/engenty/search-index/catalog-rank.d.ts

@@ -0,0 +1,33 @@
+import { type CatalogFieldWeights, type CatalogSearchEntry } from "./catalog-lexical.js";
+export type CatalogRankStrategy = "hybrid" | "lexical" | "semantic";
+/** Name/description records (space modules, skills, connections, agents). */
+export declare const RECORD_CATALOG_FIELD_WEIGHTS: CatalogFieldWeights;
+/**
+ * Rank name/description records by lexical BM25 (prefix + inflection).
+ * Empty query keeps input order; zero-score rows drop out.
+ */
+export declare function rankRecordsLexically<T>(items: readonly T[], query: string, toRecord: (item: T) => CatalogSearchEntry, weights?: CatalogFieldWeights): T[];
+export declare function cosineSimilarity(a: number[], b: number[]): number;
+export declare function blendCatalogScores(params: {
+    lexical: number;
+    maxLexical: number;
+    semantic: number;
+    strategy: CatalogRankStrategy;
+}): number;
+export interface ScoredCatalogItem<T> {
+    entry: T;
+    lexical: number;
+    score: number;
+    semantic: number;
+}
+/**
+ * Sort catalog rows by blended score. Lexical hits always survive; semantic
+ * hits need to clear `minSemantic` (default 0 means any cosine > 0).
+ */
+export declare function rankScoredCatalog<T>(items: ReadonlyArray<{
+    entry: T;
+    lexical: number;
+    semantic: number;
+}>, strategy: CatalogRankStrategy, options?: {
+    minSemantic?: number;
+}): ScoredCatalogItem<T>[];

package/node_modules/@engenty-wizards/shared/dist/engenty/search-index/catalog-rank.js

@@ -0,0 +1,99 @@
+// Shared hybrid ranking for catalog-shaped records.
+//
+// Lexical BM25 lives in catalog-lexical.ts. This module blends those scores
+// with cosine similarity when a consumer (apps/ai today) supplies embeddings.
+// UI pickers can call rankScoredCatalog with semantic=0 for lexical-only.
+import { scoreCatalogEntry, } from "./catalog-lexical.js";
+/** Name/description records (space modules, skills, connections, agents). */
+export const RECORD_CATALOG_FIELD_WEIGHTS = [
+    ["name", 10],
+    ["id", 8],
+    ["title", 6],
+    ["summary", 6],
+    ["description", 6],
+    ["category", 5],
+    ["modules", 4],
+    ["connectorId", 4],
+    ["role", 3],
+    ["tags", 3],
+    ["source", 2],
+];
+/**
+ * Rank name/description records by lexical BM25 (prefix + inflection).
+ * Empty query keeps input order; zero-score rows drop out.
+ */
+export function rankRecordsLexically(items, query, toRecord, weights = RECORD_CATALOG_FIELD_WEIGHTS) {
+    const trimmed = query.trim();
+    if (!trimmed) {
+        return [...items];
+    }
+    return items
+        .map((item) => ({
+        item,
+        score: scoreCatalogEntry(toRecord(item), trimmed, weights),
+    }))
+        .filter((row) => row.score > 0)
+        .sort((left, right) => right.score - left.score)
+        .map((row) => row.item);
+}
+export function cosineSimilarity(a, b) {
+    const length = Math.min(a.length, b.length);
+    if (length === 0) {
+        return 0;
+    }
+    let dot = 0;
+    let left = 0;
+    let right = 0;
+    for (let index = 0; index < length; index += 1) {
+        const aValue = a[index] ?? 0;
+        const bValue = b[index] ?? 0;
+        dot += aValue * bValue;
+        left += aValue * aValue;
+        right += bValue * bValue;
+    }
+    const denominator = Math.sqrt(left) * Math.sqrt(right);
+    if (denominator === 0) {
+        return 0;
+    }
+    return dot / denominator;
+}
+export function blendCatalogScores(params) {
+    if (params.strategy === "lexical") {
+        return params.lexical;
+    }
+    if (params.strategy === "semantic") {
+        return params.semantic;
+    }
+    const normalizedLexical = params.maxLexical > 0 ? params.lexical / params.maxLexical : 0;
+    return params.semantic * 0.65 + normalizedLexical * 0.35;
+}
+/**
+ * Sort catalog rows by blended score. Lexical hits always survive; semantic
+ * hits need to clear `minSemantic` (default 0 means any cosine > 0).
+ */
+export function rankScoredCatalog(items, strategy, options = {}) {
+    const minSemantic = options.minSemantic ?? 0;
+    const maxLexical = Math.max(...items.map((item) => item.lexical), 0);
+    return items
+        .map((item) => ({
+        entry: item.entry,
+        lexical: item.lexical,
+        score: blendCatalogScores({
+            lexical: item.lexical,
+            maxLexical,
+            semantic: item.semantic,
+            strategy,
+        }),
+        semantic: item.semantic,
+    }))
+        .filter((item) => {
+        if (strategy === "lexical") {
+            return item.lexical > 0;
+        }
+        if (strategy === "semantic") {
+            return item.semantic > minSemantic;
+        }
+        return item.lexical > 0 || item.semantic > minSemantic;
+    })
+        .sort((a, b) => b.score - a.score);
+}

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

@@ -0,0 +1,35 @@
+import { type WizardDefinition } from "./definition.js";
+import type { ItemFormat, MarketplaceLang } from "./marketplace.js";
+/** A step as the flow shows it: what happens there, not how — and where the flow branches. */
+export interface OutlineStep {
+    id: string;
+    type: string;
+    title: string;
+    /** What a generate step makes. */
+    asset?: string;
+    /** A widget step that cuts a film. */
+    video?: boolean;
+    /** Where the flow goes on instead of the next step, and when. `to` is a step's id or `end`. */
+    branches?: {
+        to: string;
+        when: string;
+    }[];
+}
+/** What a person takes along at the end: each thing by its name, with the files it comes as. */
+export interface EntryResult {
+    title: string;
+    kind: ItemFormat;
+    formats: string[];
+}
+/** What an entry's wizard is made of, as a reader sees it. */
+export interface WizardOutline {
+    description: string;
+    outline: OutlineStep[];
+    results: EntryResult[];
+    /** The workspace files it starts with. */
+    files: string[];
+}
+export declare const outlineOf: (definition: WizardDefinition, lang: MarketplaceLang) => OutlineStep[];
+export declare function resultsOf(definition: WizardDefinition): EntryResult[];
+/** An entry's wizard as a reader sees it, in a language. */
+export declare function wizardOutline(definition: WizardDefinition, files: string[], lang: MarketplaceLang): WizardOutline;

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

@@ -0,0 +1,86 @@
+import { allFields, 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;
+    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.
+    const bare = name.replace(/^(mit|with)\s+/i, "");
+    const without = de ? `ohne ${bare}` : `without ${bare}`;
+    const withIt = de ? `mit ${bare}` : `with ${bare}`;
+    // A toggle reads better as with / without than as "= true".
+    if (typeof value === "boolean" && (op === "equals" || op === "notEquals")) {
+        return (op === "equals") === value ? withIt : without;
+    }
+    const shown = Array.isArray(value) ? value.join(" / ") : String(value ?? "");
+    switch (op) {
+        case "equals":
+            return `${name}: ${shown}`;
+        case "notEquals":
+            return `${name} ≠ ${shown}`;
+        case "in":
+            return `${name}: ${shown}`;
+        case "notEmpty":
+            return withIt;
+        case "empty":
+            return without;
+    }
+}
+export const outlineOf = (definition, lang) => definition.steps.map((s) => ({
+    id: s.id,
+    type: s.type,
+    title: s.title,
+    ...(s.type === "generate" ? { asset: s.asset } : {}),
+    ...(s.type === "widget" && s.video ? { video: true } : {}),
+    ...(s.next?.length
+        ? {
+            branches: s.next.map((rule) => ({
+                to: rule.goto,
+                when: condition(definition, rule, lang),
+            })),
+        }
+        : {}),
+}));
+/** What a step hands over, as the marketplace sorts results. */
+function resultKind(definition, from) {
+    if (listRef(from)) {
+        return "table";
+    }
+    const step = definition.steps.find((s) => s.id === from);
+    if (step?.type === "generate") {
+        return step.asset === "voice" ? "audio" : step.asset;
+    }
+    if (step?.type === "widget") {
+        return step.video ? "video" : "dashboard";
+    }
+    return step?.type === "agent" && step.output.format === "json" ? "table" : "text";
+}
+export function resultsOf(definition) {
+    const out = [];
+    for (const step of definition.steps) {
+        if (step.type !== "result") {
+            continue;
+        }
+        for (const d of step.deliverables) {
+            const list = listRef(d.from);
+            const title = d.label ??
+                (list
+                    ? definition.lists?.find((l) => l.id === list)?.title
+                    : definition.steps.find((s) => s.id === d.from)?.title) ??
+                d.from;
+            if (!out.some((r) => r.title === title)) {
+                out.push({ title, kind: resultKind(definition, d.from), formats: d.formats });
+            }
+        }
+    }
+    return out;
+}
+/** An entry's wizard as a reader sees it, in a language. */
+export function wizardOutline(definition, files, lang) {
+    return {
+        description: definition.description,
+        outline: outlineOf(definition, lang),
+        results: resultsOf(definition),
+        files,
+    };
+}

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

@@ -0,0 +1,20 @@
+import { type MarketplaceFilters, type MarketplacePage, type MarketplaceSummary } from "./marketplace.js";
+/** What a query is looked up by: its words, without the ones that say nothing. */
+export declare function searchTerms(query: string): string[];
+/** From this many words on a query is a sentence: it shares some word with nearly every entry. */
+export declare const SENTENCE_WORDS = 3;
+export declare const isSentence: (query: string) => boolean;
+/** How well an entry answers the query by its words; 0 when it does not at all. */
+export declare function scoreEntry(entry: MarketplaceSummary, query: string): number;
+/** The entries a query finds by its words, best first. An empty query keeps the list as it is. */
+export declare function rankEntries<T extends MarketplaceSummary>(entries: readonly T[], query: string): T[];
+/** Whether an entry passes the filters. An entry made for any industry passes every industry. */
+export declare function matchesFilters(e: MarketplaceSummary, f: MarketplaceFilters): boolean;
+/**
+ * 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 declare function searchEntries<T extends MarketplaceSummary>(entries: readonly T[], query: string, filters?: MarketplaceFilters, page?: {
+    limit?: number;
+    offset?: number;
+}): MarketplacePage<T>;