@cronus-ui/stack 0.6.0

package/dist/cli.d.ts

@@ -0,0 +1,18 @@
+import type { Catalog, Selection, StackConfig } from "./types.js";
+export type StackFlagValue = string | string[] | boolean | undefined;
+export type StackFlagValues = Record<string, StackFlagValue>;
+export interface ParseStackFlagsOptions {
+    catalog?: Catalog;
+    baseSelection?: Selection;
+}
+/**
+ * Parse CLI-style flag values into a partial Stack Builder selection.
+ *
+ * Values intentionally use the same short tokens emitted by `generateCommand`
+ * (`--web next`, `--db-setup neon`, `--mcp cronus-ui,github`, ...). The resolver
+ * still performs the final cascade, so invalid combinations auto-correct through
+ * the same rules the UI uses.
+ */
+export declare function parseStackFlags(values: StackFlagValues, options?: ParseStackFlagsOptions): Selection;
+export declare function resolveStackFlags(values: StackFlagValues, options?: ParseStackFlagsOptions): StackConfig;
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -0,0 +1,78 @@
+import { catalog as defaultCatalog } from "./catalog.js";
+import { defaultSelection, resolve } from "./engine.js";
+import { CLI_FLAGS, flagValue } from "./kickoff.js";
+function categoryById(catalog, categoryId) {
+    const category = catalog.find((candidate) => candidate.id === categoryId);
+    if (!category)
+        throw new Error(`Unknown stack category "${categoryId}".`);
+    return category;
+}
+function firstString(value) {
+    if (Array.isArray(value))
+        return value.find((entry) => typeof entry === "string");
+    return typeof value === "string" ? value : undefined;
+}
+function tokens(raw) {
+    return raw
+        .split(",")
+        .map((token) => token.trim())
+        .filter(Boolean);
+}
+function isNone(raw) {
+    return raw.trim().toLowerCase() === "none";
+}
+function optionIdForFlag(category, value, flag) {
+    const normalized = value.trim().toLowerCase();
+    const match = category.options.find((option) => option.id === normalized || flagValue(option.id) === normalized);
+    if (!match) {
+        const allowed = category.options.map((option) => flagValue(option.id)).join(", ");
+        throw new Error(`Unknown --${flag} "${value}". Use one of: ${allowed}.`);
+    }
+    return match.id;
+}
+/**
+ * Parse CLI-style flag values into a partial Stack Builder selection.
+ *
+ * Values intentionally use the same short tokens emitted by `generateCommand`
+ * (`--web next`, `--db-setup neon`, `--mcp cronus-ui,github`, ...). The resolver
+ * still performs the final cascade, so invalid combinations auto-correct through
+ * the same rules the UI uses.
+ */
+export function parseStackFlags(values, options = {}) {
+    const catalog = options.catalog ?? defaultCatalog;
+    const selection = { ...(options.baseSelection ?? {}) };
+    for (const { catId, flag, kind } of CLI_FLAGS) {
+        const raw = firstString(values[flag]);
+        if (!raw)
+            continue;
+        const category = categoryById(catalog, catId);
+        if (kind === "single") {
+            selection[catId] = optionIdForFlag(category, raw, flag);
+        }
+        else {
+            if (isNone(raw)) {
+                selection[catId] = [];
+                continue;
+            }
+            const ids = tokens(raw).map((value) => optionIdForFlag(category, value, flag));
+            selection[catId] = [...new Set(ids)];
+        }
+    }
+    if (values.vibe === true)
+        selection.vibe = true;
+    if (values.git === true)
+        selection.git = true;
+    if (values["no-git"] === true)
+        selection.git = false;
+    if (values.install === true)
+        selection.install = true;
+    if (values["no-install"] === true)
+        selection.install = false;
+    return selection;
+}
+export function resolveStackFlags(values, options = {}) {
+    const catalog = options.catalog ?? defaultCatalog;
+    const base = options.baseSelection ?? defaultSelection(catalog);
+    return resolve(catalog, { ...base, ...parseStackFlags(values, { catalog }) }).selection;
+}
+//# sourceMappingURL=cli.js.map

package/dist/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const STACK_CREATE_ALIAS = "cronus-stack";
+export declare const STACK_CREATE_PACKAGE = "create-cronus-stack";
+export declare const STACK_CREATE_COMMAND = "bun create cronus-stack@latest";
+export declare const STACK_BUILDER_GENERATOR = "cronus-stack-builder";
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.js

@@ -0,0 +1,5 @@
+export const STACK_CREATE_ALIAS = "cronus-stack";
+export const STACK_CREATE_PACKAGE = "create-cronus-stack";
+export const STACK_CREATE_COMMAND = `bun create ${STACK_CREATE_ALIAS}@latest`;
+export const STACK_BUILDER_GENERATOR = "cronus-stack-builder";
+//# sourceMappingURL=constants.js.map

package/dist/engine.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The Cronus Stack Builder resolver — PURE and DETERMINISTIC.
+ *
+ * Given a {@link Catalog} and a raw {@link Selection}, `resolve()` returns a
+ * fully resolved {@link Resolution}:
+ *  1. expands `implies` (auto-selects implied options);
+ *  2. marks every option `available` + a human `reason` when a `requires` is
+ *     unsatisfied or it `conflicts` with something selected;
+ *  3. CASCADES — if a category's current value became unavailable, it falls
+ *     back to that category's default valid option, iterating to a fixpoint.
+ *
+ * No I/O, no Date.now (except the seedable randomizer), no module state — the
+ * same inputs always produce the same output, so it's trivially unit-testable
+ * and safe to run on every keystroke in the UI.
+ */
+import type { Catalog, Resolution, Selection } from "./types.js";
+/**
+ * Resolve a raw selection into a fully consistent {@link Resolution}.
+ * Deterministic: same (catalog, selection, pinnedCatId) → same output.
+ *
+ * `pinnedCatId` (optional) marks the category the user just changed so its
+ * value wins every conflict during the cascade; omit it for a plain resolve
+ * where catalog order decides which side of a conflict gives way.
+ */
+export declare function resolve(catalog: Catalog, selection: Selection, pinnedCatId?: string): Resolution;
+/**
+ * Set a "single" category's value (or toggle a boolean), then re-resolve so
+ * cascades/implies run. Returns the corrected, resolved selection.
+ */
+export declare function select(catalog: Catalog, selection: Selection, categoryId: string, optionId: string | boolean): Selection;
+/**
+ * Toggle one option in a "multi" category on/off, then re-resolve.
+ */
+export declare function toggleMulti(catalog: Catalog, selection: Selection, categoryId: string, optionId: string): Selection;
+/**
+ * The canonical default selection: every single category at its first option,
+ * toggles per {@link TOGGLE_DEFAULTS_ON}, multis per {@link MULTI_DEFAULTS},
+ * with `ui` nudged to Cronus UI (the product default) when a React web frontend
+ * is present. Always valid.
+ */
+export declare function defaultSelection(catalog?: Catalog): Selection;
+/**
+ * Produce a VALID random selection. Picks an available option for each single
+ * category and a random subset for each multi, re-resolving after every pick so
+ * later choices respect earlier ones. `seed` makes it deterministic for tests.
+ */
+export declare function randomize(catalog: Catalog, seed?: number): Selection;
+//# sourceMappingURL=engine.d.ts.map

package/dist/engine.js

@@ -0,0 +1,528 @@
+/**
+ * The Cronus Stack Builder resolver — PURE and DETERMINISTIC.
+ *
+ * Given a {@link Catalog} and a raw {@link Selection}, `resolve()` returns a
+ * fully resolved {@link Resolution}:
+ *  1. expands `implies` (auto-selects implied options);
+ *  2. marks every option `available` + a human `reason` when a `requires` is
+ *     unsatisfied or it `conflicts` with something selected;
+ *  3. CASCADES — if a category's current value became unavailable, it falls
+ *     back to that category's default valid option, iterating to a fixpoint.
+ *
+ * No I/O, no Date.now (except the seedable randomizer), no module state — the
+ * same inputs always produce the same output, so it's trivially unit-testable
+ * and safe to run on every keystroke in the UI.
+ */
+import { catalog as defaultCatalog, MULTI_DEFAULTS, SYNTHETIC_REQUIREMENTS, TOGGLE_DEFAULTS_ON, } from "./catalog.js";
+/** Max cascade iterations before we bail (defensive — fixpoint is reached fast). */
+const CASCADE_CAP = 20;
+function indexCatalog(catalog) {
+    const catById = new Map();
+    const catOfOption = new Map();
+    const optById = new Map();
+    const conflictedBy = new Map();
+    for (const cat of catalog) {
+        catById.set(cat.id, cat);
+        for (const opt of cat.options) {
+            catOfOption.set(opt.id, cat);
+            optById.set(opt.id, opt);
+        }
+    }
+    // Second pass: now every option is known, build the symmetric reverse edges.
+    for (const cat of catalog) {
+        for (const opt of cat.options) {
+            for (const conf of opt.conflicts ?? []) {
+                let set = conflictedBy.get(conf);
+                if (!set) {
+                    set = new Set();
+                    conflictedBy.set(conf, set);
+                }
+                set.add(opt.id);
+            }
+        }
+    }
+    return { catById, catOfOption, optById, conflictedBy };
+}
+// --------------------------------------------------------------------------
+// Selection accessors (typed by category kind)
+// --------------------------------------------------------------------------
+function singleValue(selection, catId) {
+    const v = selection[catId];
+    return typeof v === "string" ? v : undefined;
+}
+function multiValue(selection, catId) {
+    const v = selection[catId];
+    return Array.isArray(v) ? v : [];
+}
+/** The default option id for a "single" category (its first option). */
+function defaultSingle(cat) {
+    return cat.options[0]?.id;
+}
+// --------------------------------------------------------------------------
+// Selected-id set (drives requires/conflicts evaluation)
+// --------------------------------------------------------------------------
+/**
+ * Build the set of currently-selected option ids across all categories, plus
+ * the SYNTHETIC group ids ("web-react", "db-sql", ...) that are satisfied.
+ */
+function buildSelectedSet(catalog, selection) {
+    const selected = new Set();
+    for (const cat of catalog) {
+        if (cat.kind === "single") {
+            const v = singleValue(selection, cat.id);
+            if (v)
+                selected.add(v);
+        }
+        else if (cat.kind === "multi") {
+            for (const id of multiValue(selection, cat.id))
+                selected.add(id);
+        }
+        // toggles never contribute option ids to constraints.
+    }
+    // Expand synthetic group satisfaction.
+    for (const [synthetic, members] of Object.entries(SYNTHETIC_REQUIREMENTS)) {
+        if (members.some((m) => selected.has(m)))
+            selected.add(synthetic);
+    }
+    return selected;
+}
+// --------------------------------------------------------------------------
+// Availability of a single option given the selected set
+// --------------------------------------------------------------------------
+/** A friendlier label for a (possibly synthetic) requirement id. */
+function requirementLabel(reqId, index) {
+    switch (reqId) {
+        case "web-react":
+            return "a React web frontend";
+        case "db-sql":
+            return "a SQL database";
+        case "db-sql-server":
+            return "PostgreSQL or MySQL";
+        default:
+            return index.optById.get(reqId)?.name ?? reqId;
+    }
+}
+/**
+ * Curated, human reasons for the most common unavailability cases. Falls back
+ * to a generic message built from the requirement/conflict label.
+ */
+function reasonFor(opt, unmetRequire, conflictId, index) {
+    // Hand-tuned short reasons for the headline constraints.
+    switch (opt.id) {
+        case "orm-drizzle":
+        case "orm-prisma":
+            if (conflictId === "db-mongodb")
+                return `${opt.name} is SQL-only — not for MongoDB`;
+            if (unmetRequire === "db-sql")
+                return "Requires a SQL database";
+            break;
+        case "orm-mongoose":
+            return "Mongoose only works with MongoDB";
+        case "ui-cronus":
+        case "ui-shadcn":
+        case "ui-heroui":
+        case "ui-aceternity":
+            return "Needs a React web frontend";
+        case "backend-elysia":
+            return "Elysia requires the Bun runtime";
+        case "backend-express":
+            if (conflictId === "runtime-cloudflare")
+                return "Express can't run on Cloudflare Workers";
+            return "Express requires the Node.js runtime";
+        case "backend-fullstack-next":
+            if (conflictId)
+                return "Fullstack Next replaces a dedicated backend";
+            return "Requires the Next.js web frontend";
+        case "backend-fullstack-tanstack":
+            if (conflictId)
+                return "Fullstack TanStack replaces a dedicated backend";
+            return "Requires the TanStack Start web frontend";
+        case "deploy-cloudflare":
+            return "Requires the Cloudflare Workers runtime";
+        default:
+            break;
+    }
+    // Convex conflicts surface from the OTHER side (db/orm options conflicting).
+    if (conflictId === "backend-convex")
+        return "Convex is an all-in-one backend";
+    // Fullstack meta-frameworks reverse-conflict with dedicated backends.
+    if (conflictId === "backend-fullstack-next" || conflictId === "backend-fullstack-tanstack") {
+        return "A fullstack backend is selected";
+    }
+    if (conflictId)
+        return `Conflicts with ${requirementLabel(conflictId, index)}`;
+    if (unmetRequire)
+        return `Requires ${requirementLabel(unmetRequire, index)}`;
+    return "Unavailable in this stack";
+}
+/**
+ * Evaluate availability of one option against the currently-selected set.
+ * Returns `{ available, reason }`.
+ */
+function evaluateOption(opt, selected, index) {
+    // conflicts (checked first — usually the most specific reason): if any id
+    // this option declares a conflict with is selected, it's unavailable.
+    for (const conf of opt.conflicts ?? []) {
+        if (selected.has(conf)) {
+            return { available: false, reason: reasonFor(opt, null, conf, index) };
+        }
+    }
+    // Symmetric reverse conflicts: something selected declared a conflict with us.
+    const reverse = index.conflictedBy.get(opt.id);
+    if (reverse) {
+        for (const other of reverse) {
+            if (selected.has(other)) {
+                return { available: false, reason: reasonFor(opt, null, other, index) };
+            }
+        }
+    }
+    // requires: every listed id (or synthetic group) must be satisfied.
+    for (const req of opt.requires ?? []) {
+        if (!selected.has(req)) {
+            return { available: false, reason: reasonFor(opt, req, null, index) };
+        }
+    }
+    return { available: true };
+}
+// --------------------------------------------------------------------------
+// implies expansion
+// --------------------------------------------------------------------------
+/**
+ * Apply `implies` once: for every selected option, auto-select its implied
+ * options (single categories get their value set, multi categories get the id
+ * appended). Returns a NEW selection; idempotent at fixpoint.
+ */
+function applyImplies(catalog, selection, index) {
+    const next = { ...selection };
+    const selected = buildSelectedSet(catalog, next);
+    for (const id of selected) {
+        const opt = index.optById.get(id);
+        if (!opt?.implies)
+            continue;
+        for (const impliedId of opt.implies) {
+            const owner = index.catOfOption.get(impliedId);
+            if (!owner)
+                continue;
+            if (owner.kind === "single") {
+                next[owner.id] = impliedId;
+            }
+            else if (owner.kind === "multi") {
+                const arr = multiValue(next, owner.id);
+                if (!arr.includes(impliedId))
+                    next[owner.id] = [...arr, impliedId];
+            }
+        }
+    }
+    return next;
+}
+// --------------------------------------------------------------------------
+// Normalization — make sure every category has a well-typed value
+// --------------------------------------------------------------------------
+function normalize(catalog, selection) {
+    const next = { ...selection };
+    for (const cat of catalog) {
+        const raw = next[cat.id];
+        if (cat.kind === "single") {
+            if (typeof raw !== "string" || !cat.options.some((o) => o.id === raw)) {
+                const def = defaultSingle(cat);
+                if (def !== undefined)
+                    next[cat.id] = def;
+                else
+                    delete next[cat.id];
+            }
+        }
+        else if (cat.kind === "multi") {
+            const valid = new Set(cat.options.map((o) => o.id));
+            const arr = Array.isArray(raw)
+                ? raw.filter((x) => typeof x === "string" && valid.has(x))
+                : (MULTI_DEFAULTS[cat.id] ?? []);
+            next[cat.id] = arr;
+        }
+        else {
+            // toggle
+            if (typeof raw !== "boolean")
+                next[cat.id] = TOGGLE_DEFAULTS_ON.has(cat.id);
+        }
+    }
+    return next;
+}
+// --------------------------------------------------------------------------
+// Conflict priority — decides which side of a symmetric conflict gives way
+// --------------------------------------------------------------------------
+/**
+ * Category priority: lower number = higher priority (gets to keep its value).
+ * The just-`select()`ed category is pinned to the very top (-1) so the user's
+ * explicit choice always wins; everything else uses catalog order, so a
+ * higher-up category (e.g. Backend=Convex) forces lower ones (Database/ORM) to
+ * give way rather than the reverse.
+ */
+function buildPriority(catalog, pinnedCatId) {
+    const prio = new Map();
+    for (let i = 0; i < catalog.length; i++) {
+        const cat = catalog[i];
+        if (cat)
+            prio.set(cat.id, cat.id === pinnedCatId ? -1 : i);
+    }
+    return prio;
+}
+/**
+ * Whether a SELECTED single option must give way in this cascade pass. It gives
+ * way if (a) a hard `requires` is unsatisfied, or (b) it conflicts with another
+ * selected option owned by a strictly HIGHER-priority category. A conflict with
+ * a lower-priority category does NOT force it out — that other category yields.
+ */
+function mustGiveWay(opt, ownerCatId, selected, index, prio) {
+    const probe = removeSelf(selected, opt.id);
+    // (a) requires — always binding.
+    for (const req of opt.requires ?? []) {
+        if (!probe.has(req))
+            return true;
+    }
+    // (b) conflicts — binding only against higher-priority selected options.
+    const myPrio = prio.get(ownerCatId) ?? Number.MAX_SAFE_INTEGER;
+    const partners = new Set(opt.conflicts ?? []);
+    for (const p of index.conflictedBy.get(opt.id) ?? [])
+        partners.add(p);
+    for (const partner of partners) {
+        if (!probe.has(partner))
+            continue;
+        const partnerCat = index.catOfOption.get(partner);
+        const partnerPrio = partnerCat
+            ? (prio.get(partnerCat.id) ?? Number.MAX_SAFE_INTEGER)
+            : Number.MAX_SAFE_INTEGER;
+        // Strictly higher priority (smaller number) wins; on a tie, keep ours.
+        if (partnerPrio < myPrio)
+            return true;
+    }
+    return false;
+}
+// --------------------------------------------------------------------------
+// One cascade pass — drop unavailable values, fall back to defaults
+// --------------------------------------------------------------------------
+/** Returns the corrected selection and whether anything changed. */
+function cascadePass(catalog, selection, index, prio) {
+    const next = { ...selection };
+    let changed = false;
+    const selected = buildSelectedSet(catalog, next);
+    for (const cat of catalog) {
+        if (cat.kind === "single") {
+            const current = singleValue(next, cat.id);
+            const opt = current ? index.optById.get(current) : undefined;
+            if (!opt)
+                continue;
+            if (mustGiveWay(opt, cat.id, selected, index, prio)) {
+                // Fall back to the first AVAILABLE option (default-first ordering).
+                const fallback = cat.options.find((o) => evaluateOption(o, removeSelf(selected, current ?? ""), index).available);
+                const target = fallback?.id ?? defaultSingle(cat);
+                if (target && target !== current) {
+                    next[cat.id] = target;
+                    changed = true;
+                }
+            }
+        }
+        else if (cat.kind === "multi") {
+            const arr = multiValue(next, cat.id);
+            const kept = arr.filter((id) => {
+                const o = index.optById.get(id);
+                if (!o)
+                    return false;
+                // Multi options are independent — drop any that aren't available, but a
+                // multi never out-prioritizes a single, so plain availability is right.
+                return !mustGiveWay(o, cat.id, selected, index, prio);
+            });
+            if (kept.length !== arr.length) {
+                next[cat.id] = kept;
+                changed = true;
+            }
+        }
+    }
+    return { next, changed };
+}
+/** A copy of `selected` without `self` so an option doesn't conflict with itself. */
+function removeSelf(selected, self) {
+    if (!selected.has(self))
+        return selected;
+    const copy = new Set(selected);
+    copy.delete(self);
+    // Re-derive synthetics after removal so e.g. dropping the only React web
+    // frontend also clears "web-react".
+    return copy;
+}
+// --------------------------------------------------------------------------
+// Public API
+// --------------------------------------------------------------------------
+/**
+ * Resolve a raw selection into a fully consistent {@link Resolution}.
+ * Deterministic: same (catalog, selection, pinnedCatId) → same output.
+ *
+ * `pinnedCatId` (optional) marks the category the user just changed so its
+ * value wins every conflict during the cascade; omit it for a plain resolve
+ * where catalog order decides which side of a conflict gives way.
+ */
+export function resolve(catalog, selection, pinnedCatId) {
+    const index = indexCatalog(catalog);
+    const prio = buildPriority(catalog, pinnedCatId);
+    // 1. Normalize + apply implies + cascade to a fixpoint.
+    let current = normalize(catalog, selection);
+    for (let i = 0; i < CASCADE_CAP; i++) {
+        const implied = normalize(catalog, applyImplies(catalog, current, index));
+        const { next, changed } = cascadePass(catalog, implied, index, prio);
+        if (!changed && shallowEqual(catalog, next, current)) {
+            current = next;
+            break;
+        }
+        current = next;
+    }
+    // 2. Build per-category resolved state against the final selected set.
+    const finalSelected = buildSelectedSet(catalog, current);
+    const categories = {};
+    const issues = [];
+    for (const cat of catalog) {
+        const value = current[cat.id];
+        const options = cat.options.map((opt) => {
+            const isSelected = cat.kind === "single"
+                ? value === opt.id
+                : cat.kind === "multi"
+                    ? Array.isArray(value) && value.includes(opt.id)
+                    : false;
+            // For availability, an already-selected option shouldn't conflict with itself.
+            const probe = isSelected ? removeSelf(finalSelected, opt.id) : finalSelected;
+            const { available, reason } = evaluateOption(opt, probe, index);
+            return { option: opt, available, reason, selected: isSelected };
+        });
+        categories[cat.id] = { category: cat, options, value };
+        // Validity: a selected single/multi option that is NOT available is an error.
+        for (const ro of options) {
+            if (ro.selected && !ro.available) {
+                issues.push({
+                    categoryId: cat.id,
+                    level: "error",
+                    message: `${cat.title}: ${ro.option.name} — ${ro.reason ?? "unavailable"}`,
+                });
+            }
+        }
+        // Advisory recommends.
+        if (cat.kind === "single" || cat.kind === "multi") {
+            for (const ro of options) {
+                if (!ro.selected || !ro.option.recommends)
+                    continue;
+                for (const rec of ro.option.recommends) {
+                    if (!finalSelected.has(rec)) {
+                        const recOpt = index.optById.get(rec);
+                        issues.push({
+                            categoryId: cat.id,
+                            level: "info",
+                            message: `${ro.option.name} works best with ${recOpt?.name ?? rec}`,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    const valid = issues.every((i) => i.level !== "error");
+    return { selection: current, categories, valid, issues };
+}
+/** Shallow per-category equality for fixpoint detection. */
+function shallowEqual(catalog, a, b) {
+    for (const cat of catalog) {
+        const av = a[cat.id];
+        const bv = b[cat.id];
+        if (Array.isArray(av) && Array.isArray(bv)) {
+            if (av.length !== bv.length || av.some((x, i) => x !== bv[i]))
+                return false;
+        }
+        else if (av !== bv) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Set a "single" category's value (or toggle a boolean), then re-resolve so
+ * cascades/implies run. Returns the corrected, resolved selection.
+ */
+export function select(catalog, selection, categoryId, optionId) {
+    const next = { ...selection, [categoryId]: optionId };
+    // Pin the changed category so the user's explicit pick wins every conflict.
+    return resolve(catalog, next, categoryId).selection;
+}
+/**
+ * Toggle one option in a "multi" category on/off, then re-resolve.
+ */
+export function toggleMulti(catalog, selection, categoryId, optionId) {
+    const arr = multiValue(selection, categoryId);
+    const nextArr = arr.includes(optionId) ? arr.filter((x) => x !== optionId) : [...arr, optionId];
+    const next = { ...selection, [categoryId]: nextArr };
+    return resolve(catalog, next, categoryId).selection;
+}
+/**
+ * The canonical default selection: every single category at its first option,
+ * toggles per {@link TOGGLE_DEFAULTS_ON}, multis per {@link MULTI_DEFAULTS},
+ * with `ui` nudged to Cronus UI (the product default) when a React web frontend
+ * is present. Always valid.
+ */
+export function defaultSelection(catalog = defaultCatalog) {
+    const seed = {};
+    for (const cat of catalog) {
+        if (cat.kind === "single") {
+            const def = defaultSingle(cat);
+            if (def !== undefined)
+                seed[cat.id] = def;
+        }
+        else if (cat.kind === "multi") {
+            seed[cat.id] = MULTI_DEFAULTS[cat.id] ?? [];
+        }
+        else {
+            seed[cat.id] = TOGGLE_DEFAULTS_ON.has(cat.id);
+        }
+    }
+    // Product defaults: Next.js + Cronus UI.
+    seed.web = "web-next";
+    seed.ui = "ui-cronus";
+    return resolve(catalog, seed).selection;
+}
+// --------------------------------------------------------------------------
+// Deterministic randomizer
+// --------------------------------------------------------------------------
+/** A tiny seedable PRNG (mulberry32) so `randomize(seed)` is reproducible. */
+function mulberry32(seed) {
+    let a = seed >>> 0;
+    return () => {
+        a |= 0;
+        a = (a + 0x6d2b79f5) | 0;
+        let t = Math.imul(a ^ (a >>> 15), 1 | a);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+/**
+ * Produce a VALID random selection. Picks an available option for each single
+ * category and a random subset for each multi, re-resolving after every pick so
+ * later choices respect earlier ones. `seed` makes it deterministic for tests.
+ */
+export function randomize(catalog, seed = 1) {
+    const rand = mulberry32(seed);
+    const index = indexCatalog(catalog);
+    let selection = defaultSelection(catalog);
+    for (const cat of catalog) {
+        if (cat.kind === "single") {
+            const selected = removeSelf(buildSelectedSet(catalog, selection), singleValue(selection, cat.id) ?? "");
+            const avail = cat.options.filter((o) => evaluateOption(o, selected, index).available);
+            if (avail.length > 0) {
+                const pick = avail[Math.floor(rand() * avail.length)];
+                if (pick)
+                    selection = select(catalog, selection, cat.id, pick.id);
+            }
+        }
+        else if (cat.kind === "multi") {
+            const chosen = cat.options.filter(() => rand() > 0.5).map((o) => o.id);
+            selection = resolve(catalog, { ...selection, [cat.id]: chosen }).selection;
+        }
+        else {
+            selection = { ...selection, [cat.id]: rand() > 0.5 };
+        }
+    }
+    // Final resolve to guarantee validity.
+    return resolve(catalog, selection).selection;
+}
+//# sourceMappingURL=engine.js.map