@happyvertical/smrt-planner 0.0.0-stage → 0.0.1

package/dist/recipes/scope.js

@@ -0,0 +1,31 @@
+/**
+ * The scope of a page: `view` is the entry key in the path (none for the
+ * plain entry); `added` are the nav entries of the added recipes.
+ */
+export function pageScope(modelId, view, added) {
+    const here = added.filter((e) => e.model.id === modelId && e.filter);
+    if (view) {
+        const filter = here.find((e) => e.key === view)?.filter;
+        return filter ? { field: filter.field, equals: filter.value } : undefined;
+    }
+    const first = here[0]?.filter;
+    if (!first)
+        return undefined;
+    const claimed = here
+        .map((e) => e.filter)
+        .filter((f) => f?.field === first.field)
+        .map((f) => String(f?.value));
+    return { field: first.field, notIn: [...new Set(claimed)] };
+}
+export function inScope(scope, row) {
+    if (!scope)
+        return true;
+    const value = String(row[scope.field] ?? '');
+    if (scope.equals !== undefined)
+        return value === scope.equals;
+    return !scope.notIn?.includes(value);
+}
+/** Values a row created from the page carries, so it stays in view. */
+export function scopePreset(scope) {
+    return scope?.equals !== undefined ? { [scope.field]: scope.equals } : {};
+}

package/dist/recipes/sections.d.ts

@@ -0,0 +1,49 @@
+import type { Recipe, RecipeNavSection } from './types.ts';
+/**
+ * A navigation section: one recipe, or the recipes of one `group` (Products
+ * from Simple and Clothing). A section owns one Options page and one Help
+ * page, at `/recipes/<id>/` and `/recipes/<id>/help/`. For a recipe with no
+ * group the id is the recipe id, so those URLs are the recipe's own.
+ */
+export interface RecipeSection {
+    /** The group id, or the recipe id for a recipe with no group. */
+    id: string;
+    label: string;
+    /** In declaration order. */
+    recipes: Recipe[];
+}
+/** The id of the section a recipe belongs to. */
+export declare function sectionId(recipe: Recipe): string;
+/** Sections in the order their first recipe is declared. */
+export declare function buildSections(recipes: readonly Recipe[]): RecipeSection[];
+/**
+ * The NAV section a recipe's entries sit under by default: the section it
+ * suggests, else its group, else the recipe. Not to be confused with
+ * {@link RecipeSection} (Options and Help pages), which follows `group`.
+ */
+export declare function navSectionOf(recipe: Recipe): RecipeNavSection;
+/** Nav sections of the given recipes, in the order their first recipe comes. */
+export declare function buildNavSections(recipes: readonly Recipe[]): (RecipeNavSection & {
+    recipes: Recipe[];
+})[];
+/**
+ * Old nav section key (the `group` id or recipe id that used to name a nav
+ * section) to its key now. Only keys that changed appear.
+ */
+export declare function legacyNavSectionKeys(recipes: readonly Recipe[]): Record<string, string>;
+/**
+ * The stable layout id of a navigation item: `item:<package>:<Model>`, or
+ * `item:<package>:<Model>:<key>` when a model appears twice in the nav and the
+ * extra entry declares a fixed `key`. It never names the section, the label or
+ * the href, so renaming an entry, moving a recipe's suggested section or
+ * changing the selection query leaves saved layouts and cookbooks valid.
+ */
+export declare function navItemId(packageId: string, modelName: string, key?: string): string;
+/**
+ * The line under an entry on its section card: the recipe's own text first,
+ * then the catalog model's description, then a plain fallback.
+ */
+export declare function entryDescription(own: string | undefined, model: {
+    description?: string;
+    name: string;
+}): string;

package/dist/recipes/sections.js

@@ -0,0 +1,84 @@
+/** The id of the section a recipe belongs to. */
+export function sectionId(recipe) {
+    return recipe.group?.id ?? recipe.id;
+}
+/** Sections in the order their first recipe is declared. */
+export function buildSections(recipes) {
+    const sections = new Map();
+    for (const recipe of recipes) {
+        const id = sectionId(recipe);
+        const existing = sections.get(id);
+        if (existing)
+            existing.recipes.push(recipe);
+        else
+            sections.set(id, {
+                id,
+                label: recipe.group?.label ?? recipe.label,
+                recipes: [recipe],
+            });
+    }
+    return [...sections.values()];
+}
+/**
+ * The NAV section a recipe's entries sit under by default: the section it
+ * suggests, else its group, else the recipe. Not to be confused with
+ * {@link RecipeSection} (Options and Help pages), which follows `group`.
+ */
+export function navSectionOf(recipe) {
+    return (recipe.section ?? {
+        id: sectionId(recipe),
+        label: recipe.group?.label ?? recipe.label,
+    });
+}
+/** Nav sections of the given recipes, in the order their first recipe comes. */
+export function buildNavSections(recipes) {
+    const out = new Map();
+    for (const recipe of recipes) {
+        const nav = navSectionOf(recipe);
+        const existing = out.get(nav.id);
+        if (existing)
+            existing.recipes.push(recipe);
+        else
+            out.set(nav.id, { ...nav, recipes: [recipe] });
+    }
+    return [...out.values()];
+}
+/**
+ * Old nav section key (the `group` id or recipe id that used to name a nav
+ * section) to its key now. Only keys that changed appear.
+ */
+export function legacyNavSectionKeys(recipes) {
+    // A key that is still a nav section today (`billing`: the invoicing group id
+    // AND its section) is not legacy, whatever another recipe's old key meant.
+    const current = new Set(recipes.map((recipe) => navSectionOf(recipe).id));
+    const map = {};
+    for (const recipe of recipes) {
+        const old = sectionId(recipe);
+        const now = navSectionOf(recipe).id;
+        if (old !== now && !current.has(old))
+            map[old] = now;
+    }
+    return map;
+}
+/**
+ * The stable layout id of a navigation item: `item:<package>:<Model>`, or
+ * `item:<package>:<Model>:<key>` when a model appears twice in the nav and the
+ * extra entry declares a fixed `key`. It never names the section, the label or
+ * the href, so renaming an entry, moving a recipe's suggested section or
+ * changing the selection query leaves saved layouts and cookbooks valid.
+ */
+export function navItemId(packageId, modelName, key) {
+    return `item:${packageId}:${modelName}${key ? `:${key}` : ''}`;
+}
+/**
+ * The line under an entry on its section card: the recipe's own text first,
+ * then the catalog model's description, then a plain fallback.
+ */
+export function entryDescription(own, model) {
+    return (own?.trim() ||
+        model.description?.trim() ||
+        `Your ${humanizeName(model.name)} records, all in one place.`);
+}
+function humanizeName(name) {
+    return name.replace(/([a-z0-9])([A-Z])/g, '$1 $2').toLowerCase();
+}

package/dist/recipes/state.svelte.d.ts

@@ -0,0 +1,67 @@
+import type { CatalogModel } from '../catalog/types.ts';
+import type { Cookbook } from '../cookbook/types.ts';
+import { type PlanData } from './plan-data.ts';
+import { type FieldPolicyRow, type ResolvedField, type ViewField } from './policy.ts';
+import type { ExposureSurface, RecipeModelHints } from './types.ts';
+/** A model as the generated views see it once recipe options are applied. */
+export interface AppliedModel {
+    /** The model with narrowed surfaces emptied. */
+    model: CatalogModel;
+    /** Every field's merged policy, in order. */
+    resolved: ResolvedField[];
+    /** What lists and forms show. */
+    fields: ViewField[];
+    /** Defaults for fields that are not shown, so records still carry them. */
+    background: Record<string, unknown>;
+}
+/**
+ * The visitor's added recipes and their saved options. Like the package
+ * selection, it is the one store the planner page, navigation and a future
+ * chat assistant drive. The cookbook (`cookbook/`) is its persisted form:
+ * `snapshot()` and `load()` are the only way in or out. Policy rows live in
+ * memory here; smrt-planner#4 makes them real rows.
+ */
+declare class RecipeState {
+    ids: string[];
+    rows: FieldPolicyRow[];
+    narrowed: Record<string, ExposureSurface[]>;
+    /** Added feature models (qualified names): models no recipe covers. */
+    features: string[];
+    /**
+     * Recipe and feature ids a loaded cookbook named that this version does not
+     * know. Kept so the next save and export carry them; never applied.
+     */
+    unavailableRecipes: string[];
+    unavailableFeatures: string[];
+    /** The rules live in `plan-data.ts`; this holds their data in runes. */
+    get data(): PlanData;
+    private set;
+    /** Forget the ids this version does not know (the visitor's explicit say). */
+    removeUnavailable(): void;
+    hasFeature(id: string): boolean;
+    addFeature(id: string): void;
+    removeFeature(id: string): void;
+    has(id: string): boolean;
+    /** Added recipes that need `id`; non-empty means it cannot be removed. */
+    requiredBy(id: string): string[];
+    /** Add recipes, pulling in everything they `require`. */
+    add(...ids: string[]): void;
+    /** Remove recipes; ones other added recipes need are kept. */
+    remove(...ids: string[]): void;
+    toggle(id: string): void;
+    clear(): void;
+    /** The hints of the first added recipe that includes this model. */
+    hintsFor(modelId: string): RecipeModelHints | undefined;
+    /** Apply the added recipes' hints and the saved rows to a catalog model. */
+    apply(model: CatalogModel): AppliedModel;
+    /** Replace the saved options for one model. */
+    save(modelId: string, rows: readonly FieldPolicyRow[], narrowed: readonly ExposureSurface[]): void;
+    /** Forget the saved options for one model. */
+    reset(modelId: string): void;
+    /** The recipes and options as cookbook fields, in a stable order. */
+    snapshot(): Pick<Cookbook, 'recipes' | 'features' | 'policies' | 'exposure'>;
+    /** Replace everything from a validated cookbook. */
+    load(cookbook: Pick<Cookbook, 'recipes' | 'features' | 'policies' | 'exposure'>): void;
+}
+export declare const recipeState: RecipeState;
+export {};

package/dist/recipes/state.svelte.js

@@ -0,0 +1,112 @@
+import { emptyPlanData, hintsForModel, planFields, planFromCookbook, recipesRequiringId, withFeatureAdded, withFeatureRemoved, withModelOptions, withRecipesAdded, withRecipesRemoved, } from "./plan-data.js";
+import { backgroundDefaults, narrowModel, resolveExposure, resolveFields, viewFields, } from "./policy.js";
+/**
+ * The visitor's added recipes and their saved options. Like the package
+ * selection, it is the one store the planner page, navigation and a future
+ * chat assistant drive. The cookbook (`cookbook/`) is its persisted form:
+ * `snapshot()` and `load()` are the only way in or out. Policy rows live in
+ * memory here; smrt-planner#4 makes them real rows.
+ */
+class RecipeState {
+    ids = $state([]);
+    rows = $state([]);
+    narrowed = $state({});
+    /** Added feature models (qualified names): models no recipe covers. */
+    features = $state([]);
+    /**
+     * Recipe and feature ids a loaded cookbook named that this version does not
+     * know. Kept so the next save and export carry them; never applied.
+     */
+    unavailableRecipes = $state([]);
+    unavailableFeatures = $state([]);
+    /** The rules live in `plan-data.ts`; this holds their data in runes. */
+    get data() {
+        return {
+            ids: this.ids,
+            rows: this.rows,
+            narrowed: this.narrowed,
+            features: this.features,
+            unavailableRecipes: this.unavailableRecipes,
+            unavailableFeatures: this.unavailableFeatures,
+        };
+    }
+    set(next) {
+        this.ids = next.ids;
+        this.rows = next.rows;
+        this.narrowed = next.narrowed;
+        this.features = next.features;
+        this.unavailableRecipes = next.unavailableRecipes;
+        this.unavailableFeatures = next.unavailableFeatures;
+    }
+    /** Forget the ids this version does not know (the visitor's explicit say). */
+    removeUnavailable() {
+        this.unavailableRecipes = [];
+        this.unavailableFeatures = [];
+    }
+    hasFeature(id) {
+        return this.features.includes(id);
+    }
+    addFeature(id) {
+        this.set(withFeatureAdded(this.data, id));
+    }
+    removeFeature(id) {
+        this.set(withFeatureRemoved(this.data, id));
+    }
+    has(id) {
+        return this.ids.includes(id);
+    }
+    /** Added recipes that need `id`; non-empty means it cannot be removed. */
+    requiredBy(id) {
+        return recipesRequiringId(this.data, id);
+    }
+    /** Add recipes, pulling in everything they `require`. */
+    add(...ids) {
+        this.set(withRecipesAdded(this.data, ids));
+    }
+    /** Remove recipes; ones other added recipes need are kept. */
+    remove(...ids) {
+        this.set(withRecipesRemoved(this.data, ids));
+    }
+    toggle(id) {
+        if (this.has(id))
+            this.remove(id);
+        else
+            this.add(id);
+    }
+    clear() {
+        this.set(emptyPlanData());
+    }
+    /** The hints of the first added recipe that includes this model. */
+    hintsFor(modelId) {
+        return hintsForModel(this, modelId);
+    }
+    /** Apply the added recipes' hints and the saved rows to a catalog model. */
+    apply(model) {
+        const hints = this.hintsFor(model.id);
+        const resolved = resolveFields(model, hints, this.rows);
+        const exposure = resolveExposure(model, hints, this.narrowed[model.id] ?? []);
+        return {
+            model: narrowModel(model, exposure),
+            resolved,
+            fields: viewFields(resolved),
+            background: backgroundDefaults(resolved),
+        };
+    }
+    /** Replace the saved options for one model. */
+    save(modelId, rows, narrowed) {
+        this.set(withModelOptions(this.data, modelId, rows, narrowed));
+    }
+    /** Forget the saved options for one model. */
+    reset(modelId) {
+        this.save(modelId, [], []);
+    }
+    /** The recipes and options as cookbook fields, in a stable order. */
+    snapshot() {
+        return planFields(this.data);
+    }
+    /** Replace everything from a validated cookbook. */
+    load(cookbook) {
+        this.set(planFromCookbook(cookbook));
+    }
+}
+export const recipeState = new RecipeState();

package/dist/recipes/types.d.ts

@@ -0,0 +1,322 @@
+/**
+ * The shape of a recipe as `SmrtRecipe` (happyvertical/smrt#3590) emits it into
+ * `smrt-knowledge.json` under the top-level `recipes` key, and the only place
+ * the planner depends on that shape. Until the generator reads recipes from the
+ * published packages. The catalog carries them; `overlay.json` adds the
+ * planner-local `forms` and `extends`.
+ */
+import type { RecipeHelp } from './help.ts';
+/**
+ * Curation hints for one field. The vocabulary is the smrt-fields policy
+ * vocabulary (default, visibility, label, help, order, locked), so applying a
+ * recipe's options produces smrt-fields policy rows. Hints are never a second
+ * schema: they can only name fields the model already declares.
+ */
+export interface RecipeFieldHint {
+    /** A different starting value. Present (even `null`) means "override". */
+    default?: unknown;
+    /** `hidden` removes the parameter from the options form and the views. */
+    visibility?: 'basic' | 'advanced' | 'hidden';
+    label?: string;
+    help?: string;
+    order?: number;
+    /** The planner may not change this field's policy. */
+    locked?: boolean;
+    /** The form refuses to save without a value, whatever the catalog says. */
+    required?: boolean;
+}
+/** The `@smrt()` surfaces a recipe may narrow. It can never switch one on. */
+export type ExposureSurface = 'api' | 'mcp' | 'cli';
+export interface RecipeModelHints {
+    /** Keyed by field name. */
+    fields?: Record<string, RecipeFieldHint>;
+    /** `false` narrows that surface off; `true` is not allowed. */
+    exposure?: Partial<Record<ExposureSurface, false>>;
+}
+export interface RecipeNavEntry {
+    label: string;
+    /**
+     * A shell icon name (`users`, `calendar`...) drawn on the entry's row.
+     * Optional in smrt; the planner draws a generic record icon without one.
+     */
+    icon?: string;
+    /**
+     * One friendly line for a business owner, shown on the section card.
+     * Optional in smrt; the planner falls back to the model's description.
+     */
+    description?: string;
+    /** Qualified model name, `@scope/pkg:Class`. */
+    model: string;
+    /**
+     * Fixed key making this entry's layout id `item:<pkg>:<Model>:<key>`. Only
+     * for a model that appears twice in the nav; never derived from the label.
+     */
+    key?: string;
+    /**
+     * What New creates, when the label is not a countable noun ("Stock levels"
+     * -> "stock entry"). Without it, the label's singular is used.
+     */
+    noun?: string;
+    /**
+     * LOCAL. Narrows the entry to rows whose `field` equals `value` (an
+     * Ingredients entry over Products: `productType` = `material`). Needs a
+     * `key`, which puts the view at `/m/<pkg>/<Model>/<key>/`. New rows from
+     * the view carry the value; the model's plain entry stops listing them
+     * while the filtered entry's recipe is added.
+     */
+    filter?: {
+        field: string;
+        value: string;
+    };
+}
+/**
+ * LOCAL (not in `SmrtRecipe` yet): recipes with the same `group.id` share one
+ * Planner card. The card's switch is on while any of its recipes is, and each
+ * recipe is a sub-switch on the card, in declaration order (the first is what
+ * turning the card on adds). `label` and `summary` are the card's.
+ */
+export interface RecipeGroup {
+    id: string;
+    label: string;
+    summary?: string;
+}
+/**
+ * LOCAL, to upstream to `SmrtRecipe` (PR notes): the navigation section a
+ * recipe SUGGESTS its `nav` entries sit under, e.g. `{ id: 'sales', label:
+ * 'Sales' }`. Distinct from {@link RecipeGroup}, which is the Planner card and
+ * the Options/Help pages. The app owns the sections; the user may rename,
+ * add or reorder them in the Layout tab, so `id` must be stable (it keys a
+ * saved layout). Recipes naming the same `id` share one section. Absent: the
+ * recipe's `group`, else the recipe itself.
+ */
+export interface RecipeNavSection {
+    id: string;
+    label: string;
+    /**
+     * LOCAL: the section's icon, a shell icon name (`shoppingBag`, `receipt`...).
+     * The sidebar shows only sections, so every suggested section has one; the
+     * user can change it in edit mode.
+     */
+    icon?: string;
+    /** LOCAL: one line for the section's page, under its title. */
+    description?: string;
+}
+/** A value in a form record: a literal, a `{ref}` to another record's id, or a template. */
+export type RecipeFormValue = string | number | boolean | null | {
+    ref: string;
+    field?: string;
+};
+/**
+ * LOCAL. One row a form saves. Records are applied in order, so a record can
+ * `{ref}` an earlier one. A record with no `match` is created (or, when the
+ * form is editing, is the row being edited, for the first record). With a
+ * `match` it is found by those values or created from them, so shared rows
+ * such as the default location are never duplicated. A `{ref, field}` is that
+ * record's value of `field` rather than its id. A `match` that points at a
+ * record LATER in the list (a Profile found by its Customer's `profileId`)
+ * locates the row when editing and is ignored when creating. `values` apply when the
+ * row is created; fields mapped with `to` apply on every save. A string value
+ * may use `{alias.field}` and `{alias.field|slug}` over values the form holds.
+ */
+export interface RecipeFormRecord {
+    as: string;
+    /** Qualified model name. */
+    model: string;
+    match?: Record<string, RecipeFormValue>;
+    values?: Record<string, RecipeFormValue>;
+}
+/** An input mapped onto `alias.field` of one of the form's records. */
+export interface RecipeFormField {
+    id: string;
+    label: string;
+    /** `alias.field`, e.g. `product.price`. */
+    to: string;
+    required?: boolean;
+    help?: string;
+    /** Starting value for a new row. */
+    default?: unknown;
+}
+interface RecipeFormBase {
+    /** Unique across recipes; `extends` points at it. */
+    id: string;
+    /** What New offers and the edit form is titled, e.g. "Simple product". */
+    label: string;
+    /** The Kind column's text for a row this form edits, e.g. "Simple". */
+    kindLabel: string;
+    /** Qualified model the form creates and edits; its list is the one shown. */
+    model: string;
+}
+/** Inputs mapped to fields of related objects, saved together. */
+export interface FieldMapForm extends RecipeFormBase {
+    kind: 'field-map';
+    records: RecipeFormRecord[];
+    fields: RecipeFormField[];
+}
+/** One axis of a variant grid. */
+export interface VariantAxis {
+    /** Written to `ProductVariant.axisName` and the keys of `Sku.attributes`. */
+    name: string;
+    /** Label of the chip input, e.g. "Sizes". */
+    label: string;
+    /** Values offered to start with. */
+    values: string[];
+}
+/**
+ * A product with axes: name and price, a chip input per axis, then a grid with
+ * one cell per combination. Saves the product, a `variants` row per axis and a
+ * `skus` row per cell with its `attributes` pinned.
+ */
+export interface VariantGridForm extends RecipeFormBase {
+    kind: 'variant-grid';
+    /** The product row, as a record the `fields` map onto. */
+    product: RecipeFormRecord;
+    fields: RecipeFormField[];
+    axes: VariantAxis[];
+    /** Qualified model of the axis rows. */
+    variants: string;
+    /** Qualified model of the cell rows. */
+    skus: string;
+}
+export type RecipeForm = FieldMapForm | VariantGridForm;
+/**
+ * LOCAL. Adds to another recipe's form from a recipe that is switched on
+ * alongside it. On a field-map form the `records` and `fields` join the form.
+ * On a variant grid they are evaluated once per cell: `product` and `sku` are
+ * the cell's rows, and each `fields` entry is one more input in every cell.
+ */
+export interface RecipeFormExtension {
+    /** Id of the form being extended. */
+    form: string;
+    records?: RecipeFormRecord[];
+    fields?: RecipeFormField[];
+}
+/**
+ * Shell slots a `shell-widget` surface may name (smrt-svelte's `ShellSlot`;
+ * kept open here so a slot a newer smrt adds still renders).
+ */
+export type RecipeShellSlot = 'header.start' | 'header.center' | 'header.end' | 'footer.start' | 'footer.center' | 'footer.end' | 'leftSidebar.header' | 'leftSidebar.footer' | 'rightSidebar.header' | 'rightSidebar.footer' | (string & {});
+/** `'<module specifier>#<ExportName>'`; the planner never imports it. */
+export type RecipeExportRef = `${string}#${string}`;
+/**
+ * A widget a recipe contributes to customizable overviews (smrt#3727). The
+ * planner reads only these keys; the rest of the declaration is carried
+ * as authored for the host that registers it.
+ */
+export interface RecipeWidgetSurface {
+    kind: 'widget';
+    type: string;
+    export: RecipeExportRef;
+    label: string;
+    description?: string;
+    icon?: string;
+    [key: string]: unknown;
+}
+/** A non-model piece of UI a recipe adds (smrt#3708). */
+export type RecipeSurface = {
+    kind: 'shell-widget';
+    slot: RecipeShellSlot;
+    export: RecipeExportRef;
+    label: string;
+    icon?: string;
+} | {
+    kind: 'route';
+    path: string;
+    export: RecipeExportRef;
+    label: string;
+} | {
+    kind: 'settings-panel';
+    export: RecipeExportRef;
+    label: string;
+} | {
+    kind: 'playground';
+    export: RecipeExportRef;
+    label?: string;
+} | RecipeWidgetSurface;
+/** A provider a recipe needs or can use (email, oauth, storage, llm...). */
+export interface RecipeProvider {
+    id: string;
+    /** Open slug: `email`, `oauth`, `storage`, `llm`... */
+    kind: string;
+    /** Supported implementations (`imap`, `smtp`; `openai`, `webllm`). */
+    options: string[];
+    required: boolean;
+    /** Names (never values) of the secrets the provider needs. */
+    secrets?: string[];
+    /** The `options` that run in a browser with none of the `secrets`. */
+    browserOptions?: string[];
+}
+/** Where a recipe's runtime pieces can run. Absent means `both`. */
+export type RecipeRuntime = 'browser' | 'server' | 'both';
+/** A demo fixture: an export reference, or small inline JSON. */
+export type RecipeDemoSeed = {
+    export: RecipeExportRef;
+} | {
+    data: unknown;
+};
+/**
+ * How far a feature runs in a browser-only demo (smrt#3709), derived at smrt
+ * build time and never authored: `live` (real browser data layer), `mock` (a
+ * provider is faked), `sample` (fixtures only), `server` (needs a server).
+ */
+export type RecipeDemoMode = 'live' | 'mock' | 'sample' | 'server';
+export interface RecipeDemo {
+    mode: RecipeDemoMode;
+    /** Plain sentences saying why, in the order the rules fired. */
+    reasons: string[];
+    /** Ids of the providers a demo fakes. */
+    mocked?: string[];
+}
+/** Whether a package's root entry builds for a browser (smrt#3709). */
+export interface PackageBrowserCapability {
+    status: 'browser-safe' | 'server-only';
+    /** Tracking issues (`#3624`); absent when browser-safe. */
+    issues?: string[];
+    /** What blocks the package itself; absent when only inherited. */
+    reason?: string;
+    /** Packages it inherits `server-only` from. */
+    via?: string[];
+}
+export interface Recipe {
+    /** Unique, e.g. `commerce.sales`. */
+    id: string;
+    label: string;
+    summary: string;
+    synonyms: string[];
+    /** Qualified model names, all owned by the recipe's package. */
+    models: string[];
+    nav: RecipeNavEntry[];
+    /** Ids of other recipes (possibly in other packages). */
+    requires: string[];
+    /**
+     * LOCAL. Alternatives: at least one must be on. Adding the recipe with none
+     * on adds the first; the last one on cannot be removed while this is.
+     */
+    requiresAny?: string[][];
+    /** LOCAL. Card this is a sub-switch of; see {@link RecipeGroup}. */
+    group?: RecipeGroup;
+    /** LOCAL. Suggested navigation section; see {@link RecipeNavSection}. */
+    section?: RecipeNavSection;
+    /** LOCAL. Forms that replace the generic one-model form for `nav` models. */
+    forms?: RecipeForm[];
+    /** LOCAL. Additions to other recipes' forms; see {@link RecipeFormExtension}. */
+    extends?: RecipeFormExtension[];
+    /** Curation hints keyed by qualified model name. */
+    options?: Record<string, RecipeModelHints>;
+    /** User-facing help (happyvertical/smrt#3591); see `help.ts`. */
+    help?: RecipeHelp;
+    /** Non-model surfaces the recipe adds: a shell widget, a route, a panel. */
+    surfaces?: RecipeSurface[];
+    /** Providers (and secret NAMES) the recipe needs or can use. */
+    providers?: RecipeProvider[];
+    runtime?: RecipeRuntime;
+    demoSeed?: RecipeDemoSeed;
+    /** Browser-demo classification of this recipe on its own (smrt#3709). */
+    demo?: RecipeDemo;
+    /**
+     * LOCAL, written by the catalog generator: `demo` once what the recipe
+     * requires is counted (smrt-core's `effectiveRecipeDemo`). Present only when
+     * it differs from `demo`; read both through `features/demo.ts`.
+     */
+    effectiveDemo?: RecipeDemo;
+}
+export {};

package/dist/recipes/types.js

@@ -0,0 +1,8 @@
+/**
+ * The shape of a recipe as `SmrtRecipe` (happyvertical/smrt#3590) emits it into
+ * `smrt-knowledge.json` under the top-level `recipes` key, and the only place
+ * the planner depends on that shape. Until the generator reads recipes from the
+ * published packages. The catalog carries them; `overlay.json` adds the
+ * planner-local `forms` and `extends`.
+ */
+export {};