@engenty/wizards-runtime 0.0.0-stage → 0.7.5

package/node_modules/@engenty-wizards/shared/dist/json-schema.js

@@ -0,0 +1,66 @@
+import { z } from "zod";
+import { DEFINITION_VERSION, wizardSchema } from "./definition.js";
+import { manifestSchema, PACKAGE_SCHEMA_URL, WIZARD_SCHEMA_URL } from "./wizard-package.js";
+const DIALECT = "https://json-schema.org/draft/2020-12/schema";
+/** `$comment` is the one place a validator ignores; an unknown `$license` keyword would trip Ajv's strict mode. */
+const LICENSE_COMMENT = "MIT License. Copyright (c) 2026 Matthias Platzer.";
+const SCHEMA_PROPERTY = {
+    type: "string",
+    description: "The JSON Schema an editor checks this file against; the app does not read it.",
+};
+/**
+ * Objects take no other keys. The app drops an unknown key without a word, so a typo would
+ * vanish on the first save; an editor says so instead. Loose objects (a surface component's
+ * props) stay open.
+ */
+function closeObjects(ctx) {
+    const def = ctx.zodSchema._zod.def;
+    if (def.type === "object" && def.catchall === undefined) {
+        ctx.jsonSchema.additionalProperties = false;
+    }
+}
+function generate(schema) {
+    const { $schema: _, ...rest } = z.toJSONSchema(schema, {
+        io: "input",
+        target: "draft-2020-12",
+        override: closeObjects,
+    });
+    if (JSON.stringify(rest).includes('"$ref"')) {
+        // The package schema embeds this one under $defs; a reference of its own would point wrong.
+        throw new Error("The wizard schema has a $ref; embed it differently.");
+    }
+    return rest;
+}
+function withSchemaProperty(schema) {
+    const properties = schema.properties;
+    return { ...schema, properties: { $schema: SCHEMA_PROPERTY, ...properties } };
+}
+/** A wizard's definition: what `get_wizard` returns and `replace_wizard` takes. */
+export function wizardJsonSchema() {
+    return {
+        $schema: DIALECT,
+        $id: WIZARD_SCHEMA_URL,
+        $comment: LICENSE_COMMENT,
+        title: "engenty.wizards wizard definition",
+        description: `A wizard's definition, version ${DEFINITION_VERSION}. Checked by \`wizards validate\`, which also checks what this schema cannot say: ids, references between steps and templates.`,
+        ...withSchemaProperty(generate(wizardSchema)),
+    };
+}
+/** `wizard.json` in a `.wizard` package: the definition with what it needs from its project. */
+export function packageJsonSchema() {
+    const manifest = generate(manifestSchema);
+    const properties = manifest.properties;
+    return {
+        $schema: DIALECT,
+        $id: PACKAGE_SCHEMA_URL,
+        $comment: LICENSE_COMMENT,
+        title: "engenty.wizards package manifest (wizard.json)",
+        description: "wizard.json in a .wizard package — a zip with this file and the wizard's workspace under files/.",
+        ...manifest,
+        properties: {
+            ...properties,
+            definition: { $ref: "#/$defs/definition" },
+        },
+        $defs: { definition: withSchemaProperty(generate(wizardSchema)) },
+    };
+}

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

@@ -0,0 +1,199 @@
+import { z } from "zod";
+/**
+ * Knowledge: what a space holds for its wizards' steps to look up. Pages (Markdown, with sub-pages),
+ * tables (typed columns; FAQ is a format of one) and files that could not be read into either.
+ * Categories run across all of them: typed properties a step filters on before it searches.
+ */
+export declare const CATEGORY_TYPES: readonly ["choice", "date", "number", "text", "boolean"];
+export type CategoryType = (typeof CATEGORY_TYPES)[number];
+/** A value of a choice, how many items have it, and whether it has a summary. */
+export interface CategoryValueInfo {
+    id: string;
+    value: string;
+    count: number;
+    summary: boolean;
+}
+export interface SpaceCategory {
+    id: string;
+    name: string;
+    type: CategoryType;
+    /** A number's unit: `h`, `€`, `kg`. */
+    unit: string | null;
+    /** A choice: several values per item. */
+    multiple: boolean;
+    /** A choice whose values are ranked: their order is the rank. */
+    ordered: boolean;
+    /** Where its values come from, in a few words. */
+    hint: string | null;
+    /** The plugin that brought it. */
+    origin: string | null;
+    /** Proposed, not taken yet: never filled until a person takes it. */
+    proposed: boolean;
+    /** A column of a table whose cells are its values. */
+    tableId: string | null;
+    columnId: string | null;
+    /** How many items have it. */
+    count: number;
+    /** A choice's values, in their order. */
+    values: CategoryValueInfo[];
+    /** A date's or a number's lowest and highest value (a date as `YYYY-MM-DD`). */
+    range: {
+        min: string | number;
+        max: string | number;
+    } | null;
+    /** Pairs of values that look like one written two ways ("Graz-Süd", "Graz Süd"), by id. */
+    alike: [string, string][];
+}
+/** A value as an item has it: a choice's value, a date as `YYYY-MM-DD`, a number, a text, yes/no. */
+export type CategoryCell = string | number | boolean;
+/** What an item has of one category. */
+export interface ItemCategory {
+    categoryId: string;
+    /** A choice with several values has several. */
+    values: CategoryCell[];
+    by: "person" | "origin" | "model";
+}
+/** What a writer sets: by the category's name; a list for a choice with several values. */
+export type CategoryInput = Record<string, CategoryCell | CategoryCell[] | null>;
+export type KnowledgeKind = "page" | "table" | "file";
+/** An item of Knowledge, as lists show it. Sub-pages stand under their page, not in the list. */
+export interface KnowledgeItem {
+    /** `p:<id>`, `t:<id>`, `f:<id>`. */
+    key: string;
+    kind: KnowledgeKind;
+    id: string;
+    title: string;
+    /** How a step names it: `pages/handbuch/montage`, `tables/kettenprogramm`, `files/plan.dwg`. */
+    path: string;
+    /** A page's sub-pages. */
+    children: number;
+    /** A table's rows. */
+    rows: number | null;
+    format: "faq" | null;
+    /** What wrote it: a plugin's id and what it calls the source; null when a person did. */
+    origin: string | null;
+    originLabel: string | null;
+    /** A person changed what its origin wrote: the origin no longer writes it. */
+    kept: boolean;
+    /** Why a person should look at it; null when nothing is in doubt. */
+    review: string | null;
+    /** The file it was read from. */
+    fileId: string | null;
+    /** A file still being read, or that could not be read. */
+    status: "pending" | "ready" | "failed";
+    categories: ItemCategory[];
+    updatedAt: string;
+}
+export interface Knowledge {
+    items: KnowledgeItem[];
+    categories: SpaceCategory[];
+    /** The index finds by meaning too, not by keywords alone. */
+    embeddings: boolean;
+    /** A classifier checks what a search found. */
+    checked: boolean;
+}
+/** A value of a choice, opened: its summary and its table of contents, the items that have it. */
+export interface KnowledgeValue {
+    id: string;
+    value: string;
+    category: {
+        id: string;
+        name: string;
+    };
+    summary: string | null;
+    summaryAt: string | null;
+    /** Pages (sub-pages too), tables and files that have the value. */
+    items: KnowledgeItem[];
+    /** Rows of tables that have it, by table. */
+    rows: {
+        tableId: string;
+        title: string;
+        count: number;
+    }[];
+}
+/** A page with what Knowledge knows about it, as the studio opens it. */
+export interface KnowledgePage {
+    id: string;
+    path: string;
+    /** Its ancestors, outermost first. */
+    parents: {
+        id: string;
+        title: string;
+    }[];
+    children: {
+        id: string;
+        title: string;
+        path: string;
+    }[];
+    categories: ItemCategory[];
+    origin: string | null;
+    originLabel: string | null;
+    kept: boolean;
+    review: string | null;
+    file: {
+        id: string;
+        name: string;
+        mime: string;
+    } | null;
+}
+/**
+ * A filter on one category: a value (a choice is it, a text equals it, yes/no), one of several,
+ * or a range — numbers by `gte`/`lte`, dates by `after`/`before` (`YYYY-MM-DD`, both ends
+ * included), a text by `contains`, an ordered choice by `atLeast`.
+ */
+export declare const whereValueSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>, z.ZodObject<{
+    gte: z.ZodOptional<z.ZodNumber>;
+    lte: z.ZodOptional<z.ZodNumber>;
+    after: z.ZodOptional<z.ZodString>;
+    before: z.ZodOptional<z.ZodString>;
+    contains: z.ZodOptional<z.ZodString>;
+    atLeast: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>]>;
+export type WhereValue = z.infer<typeof whereValueSchema>;
+/** Filters by the category's name; an item matches all of them. */
+export declare const whereSchema: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>, z.ZodObject<{
+    gte: z.ZodOptional<z.ZodNumber>;
+    lte: z.ZodOptional<z.ZodNumber>;
+    after: z.ZodOptional<z.ZodString>;
+    before: z.ZodOptional<z.ZodString>;
+    contains: z.ZodOptional<z.ZodString>;
+    atLeast: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>]>>;
+export type Where = z.infer<typeof whereSchema>;
+export interface KnowledgeHit {
+    /** `p:<id>`, `t:<id>` (a row of it), `f:<id>`, `v:<id>` (a value's summary), `d:<id>` (a
+     * document read before Knowledge had pages), `x:<plugin>:<key>` (a plugin's text). */
+    key: string;
+    kind: KnowledgeKind | "summary" | "document" | "plugin";
+    /** What the studio opens for it: `p:`, `t:` (a row's table), `f:`, `v:`; null for a plugin's text. */
+    open: string | null;
+    path: string;
+    title: string;
+    /** The categories as `name: value`. */
+    categories: string[];
+    /** The best section's headings, outermost first, joined by " › ". */
+    heading: string | null;
+    /** The page of the original it stands on. */
+    sheet: number | null;
+    /** A row of a table: its id. */
+    rowId: string | null;
+    text: string;
+    /** P(relevant) the classifier gave; null when nothing checked it. */
+    relevance: number | null;
+    /** Where the studio shows a plugin's text. */
+    link: string | null;
+    plugin: string | null;
+}
+export interface KnowledgeSearch {
+    hits: KnowledgeHit[];
+    /** How many units the keywords and the vectors found together, before the classifier. */
+    candidates: number;
+    /** A classifier judged the candidates; false: they keep the order the index gave them. */
+    checked: boolean;
+    /** Items the filter left, when there was one. */
+    filtered: number | null;
+}
+/** A day as `YYYY-MM-DD` from what a person or a source wrote: ISO, `14.03.2026`, a timestamp. */
+export declare function dayOf(value: unknown): string | null;
+/** A slug for a path: lower case, `-` between words, umlauts spelled out. */
+export declare function slugOf(title: string): string;

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

@@ -0,0 +1,68 @@
+import { z } from "zod";
+/**
+ * Knowledge: what a space holds for its wizards' steps to look up. Pages (Markdown, with sub-pages),
+ * tables (typed columns; FAQ is a format of one) and files that could not be read into either.
+ * Categories run across all of them: typed properties a step filters on before it searches.
+ */
+export const CATEGORY_TYPES = ["choice", "date", "number", "text", "boolean"];
+// --- filters --------------------------------------------------------------------
+/**
+ * A filter on one category: a value (a choice is it, a text equals it, yes/no), one of several,
+ * or a range — numbers by `gte`/`lte`, dates by `after`/`before` (`YYYY-MM-DD`, both ends
+ * included), a text by `contains`, an ordered choice by `atLeast`.
+ */
+export const whereValueSchema = z.union([
+    z.string().max(200),
+    z.number(),
+    z.boolean(),
+    z.array(z.union([z.string().max(200), z.number()])).max(50),
+    z
+        .object({
+        gte: z.number().optional(),
+        lte: z.number().optional(),
+        after: z.string().max(40).optional(),
+        before: z.string().max(40).optional(),
+        contains: z.string().max(200).optional(),
+        atLeast: z.string().max(200).optional(),
+    })
+        .strict(),
+]);
+/** Filters by the category's name; an item matches all of them. */
+export const whereSchema = z.record(z.string().max(120), whereValueSchema);
+/** A day as `YYYY-MM-DD` from what a person or a source wrote: ISO, `14.03.2026`, a timestamp. */
+export function dayOf(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        const d = new Date(value);
+        return Number.isNaN(d.getTime()) ? null : d.toISOString().slice(0, 10);
+    }
+    if (typeof value !== "string") {
+        return null;
+    }
+    const s = value.trim();
+    const iso = /^(\d{4})-(\d{2})-(\d{2})/.exec(s);
+    if (iso) {
+        return `${iso[1]}-${iso[2]}-${iso[3]}`;
+    }
+    const de = /^(\d{1,2})\.(\d{1,2})\.(\d{2,4})/.exec(s);
+    if (de) {
+        const year = de[3].length === 2 ? `20${de[3]}` : de[3];
+        return `${year}-${de[2].padStart(2, "0")}-${de[1].padStart(2, "0")}`;
+    }
+    return null;
+}
+/** A slug for a path: lower case, `-` between words, umlauts spelled out. */
+export function slugOf(title) {
+    return (title
+        .toLowerCase()
+        .replace(/ä/g, "ae")
+        .replace(/ö/g, "oe")
+        .replace(/ü/g, "ue")
+        .replace(/ß/g, "ss")
+        .replace(/§/g, "p")
+        .normalize("NFKD")
+        .replace(/[̀-ͯ]/g, "")
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 60)
+        .replace(/-+$/, "") || "page");
+}

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

@@ -0,0 +1,35 @@
+import { type WizardDefinition } from "./definition.js";
+import { type ItemFormat, type 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,107 @@
+import { allFields, conditionsOf, listRef, } from "./definition.js";
+import { marketLabel } from "./marketplace.js";
+/** When a branch is taken, in words: the field's label stands for its id. */
+function condition(definition, rule, lang) {
+    if (rule.ask) {
+        return rule.ask;
+    }
+    if (rule.when === undefined) {
+        return marketLabel("outline", "otherwise", lang);
+    }
+    const parts = conditionsOf(rule.when).map((c) => conditionText(definition, c, lang));
+    return parts.length
+        ? parts.reduce((first, second) => marketLabel("outline", "and", lang, { first, second }))
+        : "";
+}
+function conditionText(definition, c, lang) {
+    const { field, op, value } = c;
+    const name = allFields(definition).find((f) => f.id === field)?.label ?? field.split(".").pop() ?? field;
+    // A toggle is often labelled "Mit …" already.
+    const bare = name.replace(/^(mit|with)\s+/i, "");
+    const without = marketLabel("outline", "without", lang, { name: bare });
+    const withIt = marketLabel("outline", "with", lang, { name: 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;
+        case "gt":
+            return `${name} > ${shown}`;
+        case "lt":
+            return `${name} < ${shown}`;
+        case "contains":
+            return marketLabel("outline", "contains", lang, { name, value: shown });
+    }
+}
+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";
+    }
+    if (step?.type === "film") {
+        return "video";
+    }
+    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>;

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

@@ -0,0 +1,136 @@
+import { scoreCatalogEntry, tokenizeCatalogText, } from "./engenty/search-index/catalog-lexical.js";
+import { marketLabels, } 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 = (group, ids) => ids.flatMap((id) => marketLabels(group, id));
+/** 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("useCase", entry.useCases),
+        tags: [
+            ...labels("industry", entry.industries),
+            ...labels("format", entry.formats),
+            ...labels("capability", 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)) &&
+        (!f.plan || (e.plan ?? "free") === f.plan));
+}
+const FACETS = {
+    useCase: (e) => e.useCases,
+    industry: (e) => e.industries,
+    format: (e) => e.formats,
+    capability: (e) => e.capabilities,
+    plan: (e) => [e.plan ?? "free"],
+};
+/**
+ * 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: {},
+        plan: {},
+    };
+    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),
+    };
+}