wizards 0.5.7 → 0.5.9

package/bin/wizards.mjs

@@ -149,8 +149,21 @@ if (command === "version") {
   console.log(versionOf(root));
   process.exit(0);
 }
-const fromNpm =
-  process.platform !== "win32" && !existsSync(join(root, "pnpm-workspace.yaml")) && !isInstall();
+const checkout = existsSync(join(root, "pnpm-workspace.yaml"));
+// Windows has no installer yet, and the setup, the service and the AI clients are written for
+// macOS and Linux: it says so instead of half working. What needs no install still runs.
+if (process.platform === "win32" && !checkout && !RUN_HERE.includes(command)) {
+  console.error(
+    "engenty wizards for Windows is coming soon.\n\n" +
+      "Until then it runs in WSL (Windows Subsystem for Linux). In PowerShell:\n\n" +
+      "  wsl --install\n\n" +
+      "then, in the Ubuntu terminal that opens:\n\n" +
+      "  curl -fsSL https://engenty.ai/install.sh | bash\n\n" +
+      "https://engenty.ai/docs/user/install\n",
+  );
+  process.exit(1);
+}
+const fromNpm = process.platform !== "win32" && !checkout && !isInstall();
 if (fromNpm && (!currentNode || !RUN_HERE.includes(command))) {
   const own = versionOf(root) || "0.0.0";
   const installed = existsSync(wrapper)

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

@@ -3,6 +3,28 @@ import { type SurfaceComponent } from "./surface.js";
 /** The engenty avatars a wizard can wear. Same cast as engenty's ui-core. */
 export declare const ENGENTY_KINDS: readonly ["round", "drop", "dome", "flame", "oval", "bean", "pebble", "sprout", "tower", "wedge"];
 export type EngentyKind = (typeof ENGENTY_KINDS)[number];
+/**
+ * The languages engenty speaks: the studio, the runner, the mails, a wizard's own words. A
+ * language joins once its strings are written; English is the one every string has, and what a
+ * language still lacks is said in English.
+ */
+export declare const LANGS: readonly ["en", "de"];
+export type Lang = (typeof LANGS)[number];
+/** Each language's name, in that language: what a switch or a menu shows. */
+export declare const LANG_NAMES: Record<Lang, string>;
+/** The locale amounts and dates are written in for a language. */
+export declare const LOCALES: Record<Lang, string>;
+/** The locale speech is heard and spoken in for a language (recognition, voices). */
+export declare const SPEECH_LOCALES: Record<Lang, string>;
+export declare function isLang(value: unknown): value is Lang;
+/** The language of a tag such as "de-AT", "fr" or "pt_BR", where engenty speaks it. */
+export declare function langOf(tag: string | null | undefined): Lang | null;
+/**
+ * The person's own language beside English: the first of their languages (the browser's, in
+ * its order) that engenty speaks, else the main language of the country their time zone lies
+ * in; null where neither names one.
+ */
+export declare function localLang(languages: readonly string[], timeZone?: string | null): Lang | null;
 export declare const FIELD_KINDS: readonly ["text", "textarea", "number", "select", "multiselect", "date", "email", "url", "toggle", "color", "image", "file", "items", "connection", "list", "location", "audio", "signature", "slot"];
 export type FieldKind = (typeof FIELD_KINDS)[number];
 /**
@@ -31,7 +53,7 @@ export interface AudioValue {
     seconds?: number;
     transcript?: string;
     /** The language the runner was in when the note was taken: what it is most likely spoken in. */
-    lang?: "de" | "en";
+    lang?: Lang;
 }
 export declare function isLocationValue(v: unknown): v is LocationValue;
 export declare function isAudioValue(v: unknown): v is AudioValue;
@@ -2665,9 +2687,9 @@ export interface SlotTime {
  */
 export declare function slotTime(iso: string): SlotTime | null;
 /** The weekday and date of a slot's day: "Montag, 12. Oktober" / "Monday, 12 October". */
-export declare function slotDayText(iso: string, lang?: "de" | "en"): string;
+export declare function slotDayText(iso: string, lang?: Lang): string;
 /** A chosen slot as a person reads it back: "Di 13.10.2026, 10:30" / "Tue 13/10/2026, 10:30". */
-export declare function slotText(iso: string, lang?: "de" | "en"): string;
+export declare function slotText(iso: string, lang?: Lang): string;
 /**
  * The slot among `options` that is the same moment as `value`, written as offered — so an answer
  * in another offset ("…T07:00:00Z" for "…T09:00:00+02:00") picks the offered time.
@@ -2687,11 +2709,6 @@ export declare function allFields(def: WizardDefinition): Field[];
  * The language a wizard speaks to people: the one it names, else read from its own words
  * (titles, labels, intro) — English where they are not clearly German.
  */
-export declare function wizardLang(def: WizardDefinition): "de" | "en";
-/** The locale amounts and dates are written in for a wizard's language. */
-export declare const LOCALES: {
-    readonly de: "de-DE";
-    readonly en: "en-GB";
-};
+export declare function wizardLang(def: WizardDefinition): Lang;
 /** True when this app's schema reads the definition without losing anything of it. */
 export declare function readable(definition: unknown): boolean;

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

@@ -16,6 +16,130 @@ export const ENGENTY_KINDS = [
     "tower",
     "wedge",
 ];
+// --- languages -------------------------------------------------------------------------------
+/**
+ * The languages engenty speaks: the studio, the runner, the mails, a wizard's own words. A
+ * language joins once its strings are written; English is the one every string has, and what a
+ * language still lacks is said in English.
+ */
+export const LANGS = ["en", "de"];
+/** Each language's name, in that language: what a switch or a menu shows. */
+export const LANG_NAMES = { en: "English", de: "Deutsch" };
+/** The locale amounts and dates are written in for a language. */
+export const LOCALES = { en: "en-GB", de: "de-DE" };
+/** The locale speech is heard and spoken in for a language (recognition, voices). */
+export const SPEECH_LOCALES = { en: "en-US", de: "de-DE" };
+export function isLang(value) {
+    return typeof value === "string" && LANGS.includes(value);
+}
+/** The language of a tag such as "de-AT", "fr" or "pt_BR", where engenty speaks it. */
+export function langOf(tag) {
+    const code = tag?.trim().toLowerCase().split(/[-_]/)[0];
+    return isLang(code) ? code : null;
+}
+/**
+ * The main language of each European country. It holds languages engenty does not speak yet:
+ * `langOf` passes over them until they join `LANGS`.
+ */
+const COUNTRY_LANGUAGE = {
+    AT: "de",
+    BE: "nl",
+    BG: "bg",
+    CH: "de",
+    CY: "el",
+    CZ: "cs",
+    DE: "de",
+    DK: "da",
+    EE: "et",
+    ES: "es",
+    FI: "fi",
+    FR: "fr",
+    GB: "en",
+    GR: "el",
+    HR: "hr",
+    HU: "hu",
+    IE: "en",
+    IS: "is",
+    IT: "it",
+    LI: "de",
+    LT: "lt",
+    LU: "fr",
+    LV: "lv",
+    MC: "fr",
+    MT: "en",
+    NL: "nl",
+    NO: "nb",
+    PL: "pl",
+    PT: "pt",
+    RO: "ro",
+    RS: "sr",
+    SE: "sv",
+    SI: "sl",
+    SK: "sk",
+    SM: "it",
+    UA: "uk",
+    VA: "it",
+};
+/** The country of each European time zone (IANA names, as `Intl` gives them). */
+const ZONE_COUNTRY = {
+    "Europe/Amsterdam": "NL",
+    "Europe/Athens": "GR",
+    "Europe/Belgrade": "RS",
+    "Europe/Berlin": "DE",
+    "Europe/Bratislava": "SK",
+    "Europe/Brussels": "BE",
+    "Europe/Bucharest": "RO",
+    "Europe/Budapest": "HU",
+    "Europe/Busingen": "DE",
+    "Europe/Copenhagen": "DK",
+    "Europe/Dublin": "IE",
+    "Europe/Helsinki": "FI",
+    "Europe/Kiev": "UA",
+    "Europe/Kyiv": "UA",
+    "Europe/Lisbon": "PT",
+    "Europe/Ljubljana": "SI",
+    "Europe/London": "GB",
+    "Europe/Luxembourg": "LU",
+    "Europe/Madrid": "ES",
+    "Europe/Malta": "MT",
+    "Europe/Monaco": "MC",
+    "Europe/Oslo": "NO",
+    "Europe/Paris": "FR",
+    "Europe/Prague": "CZ",
+    "Europe/Riga": "LV",
+    "Europe/Rome": "IT",
+    "Europe/San_Marino": "SM",
+    "Europe/Sofia": "BG",
+    "Europe/Stockholm": "SE",
+    "Europe/Tallinn": "EE",
+    "Europe/Vaduz": "LI",
+    "Europe/Vatican": "VA",
+    "Europe/Vienna": "AT",
+    "Europe/Vilnius": "LT",
+    "Europe/Warsaw": "PL",
+    "Europe/Zagreb": "HR",
+    "Europe/Zurich": "CH",
+    "Atlantic/Canary": "ES",
+    "Atlantic/Madeira": "PT",
+    "Atlantic/Reykjavik": "IS",
+    "Asia/Nicosia": "CY",
+};
+/**
+ * The person's own language beside English: the first of their languages (the browser's, in
+ * its order) that engenty speaks, else the main language of the country their time zone lies
+ * in; null where neither names one.
+ */
+export function localLang(languages, timeZone) {
+    for (const tag of languages) {
+        const found = langOf(tag);
+        if (found && found !== "en") {
+            return found;
+        }
+    }
+    const country = timeZone ? ZONE_COUNTRY[timeZone] : undefined;
+    const found = country ? langOf(COUNTRY_LANGUAGE[country]) : null;
+    return found === "en" ? null : found;
+}
 export const FIELD_KINDS = [
     "text",
     "textarea",
@@ -584,7 +708,7 @@ export const wizardSchema = z.object({
      * The language the wizard speaks to people: its texts, the runner's words, its numbers and
      * dates. Without one it is read from the wizard's own words (`wizardLang`).
      */
-    lang: z.enum(["de", "en"]).optional(),
+    lang: z.enum(LANGS).optional(),
     /** Tabular data the wizard keeps between runs, per person — or for all runs (`shared`). */
     lists: z.array(listSchema).max(12).optional(),
     /** Accounts the person connects; kept between runs, per person. */
@@ -1634,8 +1758,6 @@ export function wizardLang(def) {
     const en = text.match(ENGLISH)?.length ?? 0;
     return de > en ? "de" : "en";
 }
-/** The locale amounts and dates are written in for a wizard's language. */
-export const LOCALES = { de: "de-DE", en: "en-GB" };
 // --- can this app read a definition? ---------------------------------------------------------
 // The schema drops what it does not know. A definition written for a newer app would be read
 // without complaint and run wrongly, so it counts only when nothing of it is lost.

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

@@ -1,5 +1,5 @@
 import { type WizardDefinition } from "./definition.js";
-import type { ItemFormat, MarketplaceLang } from "./marketplace.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;

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

@@ -1,24 +1,25 @@
 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 lang === "de" ? "sonst" : "otherwise";
+        return marketLabel("outline", "otherwise", lang);
     }
-    return conditionsOf(rule.when)
-        .map((c) => conditionText(definition, c, lang))
-        .join(lang === "de" ? " und " : " and ");
+    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;
-    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}`;
+    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;
@@ -40,7 +41,7 @@ function conditionText(definition, c, lang) {
         case "lt":
             return `${name} < ${shown}`;
         case "contains":
-            return de ? `${name} enthält ${shown}` : `${name} contains ${shown}`;
+            return marketLabel("outline", "contains", lang, { name, value: shown });
     }
 }
 export const outlineOf = (definition, lang) => definition.steps.map((s) => ({

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

@@ -1,5 +1,5 @@
 import { scoreCatalogEntry, tokenizeCatalogText, } from "./engenty/search-index/catalog-lexical.js";
-import { CAPABILITIES, INDUSTRIES, ITEM_FORMATS, USE_CASES, } from "./marketplace.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
@@ -36,7 +36,7 @@ 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] : []));
+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);
@@ -46,11 +46,11 @@ export function scoreEntry(entry, query) {
     const record = {
         title: fold(entry.title),
         summary: fold(entry.pitch),
-        category: labels(USE_CASES, entry.useCases),
+        category: labels("useCase", entry.useCases),
         tags: [
-            ...labels(INDUSTRIES, entry.industries),
-            ...labels(ITEM_FORMATS, entry.formats),
-            ...labels(CAPABILITIES, entry.capabilities),
+            ...labels("industry", entry.industries),
+            ...labels("format", entry.formats),
+            ...labels("capability", entry.capabilities),
         ].map(fold),
     };
     let score = scoreCatalogEntry(record, terms.join(" "), WEIGHTS);

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

@@ -1,4 +1,5 @@
-import { type WizardDefinition } from "./definition.js";
+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
@@ -7,215 +8,86 @@ import { type WizardDefinition } from "./definition.js";
 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;
-    };
-    visuals: {
-        de: string;
-        en: string;
-    };
-    inquiries: {
-        de: string;
-        en: string;
-    };
-    advice: {
-        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;
-    };
-    /** A film the installed client makes: only on a computer with Claude Code, on its subscription. */
-    film: {
-        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: 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_PLANS: {
-    free: {
-        de: string;
-        en: string;
-    };
-    pro: {
-        de: string;
-        en: string;
-    };
+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}";
 };
-export type MarketplacePlan = keyof typeof MARKETPLACE_PLANS;
-export declare const ITEM_FORMAT_IDS: ("audio" | "dashboard" | "document" | "image" | "table" | "text" | "video")[];
-export declare const INDUSTRY_IDS: ("agency" | "any" | "events" | "gastronomy" | "health" | "hospitality" | "professional" | "publicSector" | "realEstate" | "retail" | "trades")[];
-export declare const USE_CASE_IDS: ("accounting" | "advice" | "hr" | "inquiries" | "marketing" | "operations" | "research" | "sales" | "service" | "visuals" | "website")[];
-export declare const CAPABILITY_IDS: ("browser" | "code" | "connectors" | "documents" | "film" | "image" | "listening" | "speech" | "text" | "video" | "web")[];
-export declare const MARKETPLACE_PLAN_IDS: ("free" | "pro")[];
+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. */
@@ -357,3 +229,4 @@ export interface MarketplaceEntry extends MarketplaceSummary {
     /** The plugins it needs that this app does not have: a wizard made from it would not run. */
     needs?: string[];
 }
+export {};