@wocart/theme 0.0.0-stage → 1.1.0

package/dist/instances.js

@@ -0,0 +1,307 @@
+/**
+ * Instance-level behavior: the defaults chain, composition gating, and
+ * insertion-time materialization. Pure functions — no I/O, no mutation of
+ * inputs. The renderer consumes `resolveInstance`; a future editor consumes
+ * `createInstance`.
+ *
+ * Chain: instance value (in the requested language, then the fallback chain)
+ * → `content[contentKey]` → `field.default` → omit (the component's own
+ * default applies last).
+ */
+import { localize } from "./locales.js";
+import { COLOR_PATTERN, MENU_HANDLE_PATTERN, isLocaleMap, isSafeLinkTarget } from "./schemas.js";
+/** Field kinds whose values may differ per language. Numbers, toggles and choices are shared. */
+const TRANSLATABLE_KINDS = new Set(["text", "textarea", "url"]);
+const isTranslatable = (field) => TRANSLATABLE_KINDS.has(field.kind);
+/**
+ * Gate one instance for rendering: field values through the chain, children
+ * and named slots gated against the declared slots, every degradation
+ * reported. The instance (and page data) is never modified.
+ */
+export function resolveInstance(definition, instance, scope = {}) {
+    const content = scope.content ?? {};
+    const locales = scope.locales ?? [];
+    const issues = [];
+    const fields = definition.fields ?? [];
+    const declaredFields = new Map(fields.map((field) => [field.key, field]));
+    const rawProps = instance.props ?? {};
+    for (const key of Object.keys(rawProps)) {
+        if (!declaredFields.has(key)) {
+            issues.push({
+                path: `props.${key}`,
+                code: "unknown-prop",
+                message: `"${key}" is not a declared field of "${definition.type}"`,
+            });
+        }
+    }
+    const props = {};
+    for (const field of fields) {
+        const resolved = resolveField(field, ownValue(rawProps, field.key), content, locales, issues, "props");
+        if (resolved !== undefined) {
+            props[field.key] = resolved;
+        }
+    }
+    const slotDefinitions = new Map((definition.slots ?? []).map((slot) => [slot.name, slot]));
+    const fromChildren = instance.children ?? [];
+    const fromDefaultSlot = instance.slots?.default ?? [];
+    let children = [];
+    if (fromChildren.length + fromDefaultSlot.length > 0) {
+        const defaultSlot = slotDefinitions.get("default");
+        if (defaultSlot === undefined) {
+            issues.push({
+                path: "children",
+                code: "undeclared-children",
+                message: `"${definition.type}" declares no "default" slot; ${fromChildren.length + fromDefaultSlot.length} child instance(s) dropped`,
+            });
+        }
+        else {
+            const accepted = [
+                ...filterAllowed(defaultSlot, fromChildren, "children", issues),
+                ...filterAllowed(defaultSlot, fromDefaultSlot, "slots.default", issues),
+            ];
+            children = applyMultiple(defaultSlot, accepted, "children", issues);
+        }
+    }
+    const slots = {};
+    for (const [name, list] of Object.entries(instance.slots ?? {})) {
+        if (name === "default") {
+            continue; // handled with children above
+        }
+        const slotDefinition = slotDefinitions.get(name);
+        if (slotDefinition === undefined) {
+            issues.push({
+                path: `slots.${name}`,
+                code: "unknown-slot",
+                message: `"${name}" is not a declared slot of "${definition.type}"; content dropped`,
+            });
+            continue;
+        }
+        const accepted = filterAllowed(slotDefinition, list, `slots.${name}`, issues);
+        slots[name] = applyMultiple(slotDefinition, accepted, `slots.${name}`, issues);
+    }
+    return { props, children, slots, issues };
+}
+/** An own property only: `constructor` or `toString` must never read the prototype. */
+export function ownValue(record, key) {
+    return Object.hasOwn(record, key) ? record[key] : undefined;
+}
+/**
+ * The value an instance stores for this field, in the preferred language. A
+ * per-language map without an entry for any preferred language is not an
+ * error — the chain moves on to the pack and the default.
+ */
+function storedValueFor(field, raw, locales) {
+    if (!isTranslatable(field) || typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        return { kind: "value", value: raw };
+    }
+    if (!isLocaleMap(raw)) {
+        return {
+            kind: "invalid",
+            message: "must be a string or a map from language tags to strings",
+        };
+    }
+    const picked = localize(raw, locales);
+    return picked === undefined ? { kind: "untranslated" } : { kind: "value", value: picked };
+}
+/**
+ * One field through the chain. `undefined` = omit the value. Issues are
+ * reported under `${prefix}.${field.key}` — a component's `props`, or a theme's
+ * `settings`.
+ */
+export function resolveField(field, raw, content, locales, issues, prefix) {
+    if (raw !== undefined) {
+        const stored = storedValueFor(field, raw, locales);
+        const checked = stored.kind === "value"
+            ? checkFieldValue(field, stored.value)
+            : stored.kind === "invalid"
+                ? { ok: false, message: stored.message }
+                : undefined;
+        if (checked?.ok) {
+            return checked.value;
+        }
+        if (checked !== undefined) {
+            issues.push({
+                path: `${prefix}.${field.key}`,
+                code: "invalid-prop",
+                message: `"${field.key}" ${checked.message}; treated as absent`,
+            });
+        }
+    }
+    if (field.kind === "text" || field.kind === "textarea") {
+        const contentKey = field.contentKey;
+        if (contentKey !== undefined) {
+            const fromContent = ownValue(content, contentKey);
+            if (fromContent !== undefined) {
+                return fromContent;
+            }
+        }
+    }
+    if (field.default !== undefined) {
+        const fallback = field.kind === "text" || field.kind === "textarea"
+            ? localize(field.default, locales)
+            : field.default;
+        if (fallback !== undefined) {
+            return fallback;
+        }
+    }
+    if (field.required === true) {
+        issues.push({
+            path: `${prefix}.${field.key}`,
+            code: "missing-required-prop",
+            message: `required field "${field.key}" has no value`,
+        });
+    }
+    return undefined;
+}
+/**
+ * What a writer may store: a value that passes the field's rules, or — for a
+ * translatable field — a per-language map whose every entry passes them, so no
+ * language can hold an unsafe link or a wrong type.
+ */
+export function checkStoredValue(field, value) {
+    if (!isTranslatable(field) || typeof value !== "object" || value === null || Array.isArray(value)) {
+        return checkFieldValue(field, value);
+    }
+    if (!isLocaleMap(value)) {
+        return { ok: false, message: "must be a string or a map from language tags to strings" };
+    }
+    for (const [locale, text] of Object.entries(value)) {
+        const checked = checkFieldValue(field, text);
+        if (!checked.ok)
+            return { ok: false, message: `(${locale}) ${checked.message}` };
+    }
+    return { ok: true, value };
+}
+/** Kind check shared by resolution and creation. */
+function checkFieldValue(field, value) {
+    switch (field.kind) {
+        case "text":
+        case "textarea":
+            return typeof value === "string"
+                ? { ok: true, value }
+                : { ok: false, message: "must be a string" };
+        case "number": {
+            if (typeof value !== "number" || !Number.isFinite(value)) {
+                return { ok: false, message: "must be a finite number" };
+            }
+            if (field.min !== undefined && value < field.min) {
+                return { ok: false, message: `must be >= ${field.min}` };
+            }
+            if (field.max !== undefined && value > field.max) {
+                return { ok: false, message: `must be <= ${field.max}` };
+            }
+            return { ok: true, value };
+        }
+        case "boolean":
+            return typeof value === "boolean"
+                ? { ok: true, value }
+                : { ok: false, message: "must be a boolean" };
+        case "url":
+            return typeof value === "string" && isSafeLinkTarget(value)
+                ? { ok: true, value }
+                : {
+                    ok: false,
+                    message: "must be a site path, #fragment, ?query, or an http(s), mailto or tel URL",
+                };
+        case "color":
+            return typeof value === "string" && COLOR_PATTERN.test(value)
+                ? { ok: true, value }
+                : { ok: false, message: "must be a hex color, #rgb or #rrggbb" };
+        case "menu":
+            return typeof value === "string" && MENU_HANDLE_PATTERN.test(value)
+                ? { ok: true, value }
+                : { ok: false, message: "must be a menu handle" };
+        case "select":
+            return typeof value === "string" && field.options.includes(value)
+                ? { ok: true, value }
+                : {
+                    ok: false,
+                    message: `must be one of ${field.options.map((option) => JSON.stringify(option)).join(", ")}`,
+                };
+    }
+}
+/** A slot's `allow` list keeps the permitted types and reports every other child. */
+function filterAllowed(slot, list, path, issues) {
+    if (slot.allow === undefined) {
+        return list;
+    }
+    const allowed = new Set(slot.allow);
+    return list.filter((child, index) => {
+        if (allowed.has(child.type)) {
+            return true;
+        }
+        issues.push({
+            path: `${path}[${index}]`,
+            code: "disallowed-child",
+            message: `"${child.type}" is not allowed in slot "${slot.name}"; dropped`,
+        });
+        return false;
+    });
+}
+/** `multiple: false` keeps the first child and reports the rest. */
+function applyMultiple(slot, list, path, issues) {
+    if (slot.multiple === false && list.length > 1) {
+        issues.push({
+            path,
+            code: "slot-not-multiple",
+            message: `slot "${slot.name}" allows at most one child; ${list.length - 1} dropped`,
+        });
+        return [list[0]];
+    }
+    return list;
+}
+/**
+ * Create a new instance with insertion-time defaults:
+ * materialises `field.default` values only — content-keyed fields stay unset
+ * until a merchant overrides them. Throws on programmer errors (empty id,
+ * unknown keys, wrong-typed values, a required field with nothing to fill
+ * it); the storefront never calls this. A required field with a `contentKey`
+ * is filled from the content pack at render, so it may be left unset here.
+ *
+ * Authored defaults are validated exactly like provided values: a default that
+ * fails its field's rules (out-of-range number, off-list select option) is an
+ * authoring bug, and `validateThemeDefinition` reports it at assembly time —
+ * baking it into an instance silently here would let the writer and the reader
+ * disagree.
+ */
+export function createInstance(definition, id, props = {}) {
+    if (typeof id !== "string" || id.length === 0) {
+        throw new TypeError("createInstance: `id` must be a non-empty string");
+    }
+    const fields = definition.fields ?? [];
+    const declaredFields = new Map(fields.map((field) => [field.key, field]));
+    for (const key of Object.keys(props)) {
+        if (!declaredFields.has(key)) {
+            throw new TypeError(`createInstance: "${key}" is not a declared field of "${definition.type}"`);
+        }
+    }
+    const materialized = {};
+    for (const field of fields) {
+        const provided = ownValue(props, field.key);
+        if (provided !== undefined) {
+            const checked = checkStoredValue(field, provided);
+            if (!checked.ok) {
+                throw new TypeError(`createInstance: "${field.key}" ${checked.message}`);
+            }
+            materialized[field.key] = provided;
+            continue;
+        }
+        if (field.default !== undefined) {
+            const checked = checkStoredValue(field, field.default);
+            if (!checked.ok) {
+                throw new TypeError(`createInstance: default for "${field.key}" ${checked.message}`);
+            }
+            materialized[field.key] = field.default;
+            continue;
+        }
+        const contentFilled = (field.kind === "text" || field.kind === "textarea") && field.contentKey !== undefined;
+        if (field.required === true && !contentFilled) {
+            throw new TypeError(`createInstance: required field "${field.key}" needs a value (it has no default or contentKey)`);
+        }
+    }
+    const instance = { id, type: definition.type };
+    if (Object.keys(materialized).length > 0) {
+        instance.props = materialized;
+    }
+    return instance;
+}

package/dist/locales.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Choosing the right language for a value. A plain string is the same in every
+ * language; a per-language map yields the entry for the first language in the
+ * preference list that it has.
+ */
+import type { LocaleCode, LocalizedText } from "./types.js";
+/**
+ * The text for the first language in `locales` that `value` has, or
+ * `undefined` when it has none of them. A plain string applies to every
+ * language. Pass the requested language first, then the fallback chain.
+ */
+export declare function localize(value: LocalizedText, locales: readonly LocaleCode[]): string | undefined;

package/dist/locales.js

@@ -0,0 +1,14 @@
+/**
+ * The text for the first language in `locales` that `value` has, or
+ * `undefined` when it has none of them. A plain string applies to every
+ * language. Pass the requested language first, then the fallback chain.
+ */
+export function localize(value, locales) {
+    if (typeof value === "string")
+        return value;
+    for (const locale of locales) {
+        if (Object.hasOwn(value, locale))
+            return value[locale];
+    }
+    return undefined;
+}

package/dist/manifest.d.ts

@@ -0,0 +1,178 @@
+/**
+ * The serializable half of the theme contract: a `ThemeDefinition` as data, for
+ * tooling that must read a theme without executing its modules.
+ *
+ * `themeManifest` derives the manifest from the code (one source of truth).
+ * `validateThemeManifest` is the boundary for a manifest that arrives as JSON:
+ * serializability is checked on the raw input, structure by `ThemeManifestSchema`
+ * (which also normalizes), and relational rules by `validateThemeDefinition` —
+ * so the manifest and assembly validators cannot disagree.
+ */
+import { z } from "zod";
+import type { ThemeDefinition, ThemeManifest, ThemeManifestResult } from "./types.js";
+/** Version of the manifest schema and its interpretation (not the theme's). */
+export declare const THEME_MANIFEST_CONTRACT_VERSION: 1;
+/** Derive the data-only manifest from a theme. `component` and `load` are dropped. */
+export declare function themeManifest(theme: ThemeDefinition): ThemeManifest;
+/**
+ * The manifest's structural shape. Unknown keys are stripped (the forward-compat
+ * tradeoff documented in the README); absent `fields`/`slots` normalize to `[]`.
+ * Rules that span fields are not here — `validateThemeManifest` applies them.
+ */
+export declare const ThemeManifestSchema: z.ZodObject<{
+    contractVersion: z.ZodLiteral<1>;
+    key: z.ZodString;
+    version: z.ZodString;
+    surfaces: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+    }, z.core.$strip>>>;
+    locales: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    settings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+        fields: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+            description: z.ZodExactOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+            required: z.ZodExactOptional<z.ZodBoolean>;
+            contentKey: z.ZodExactOptional<z.ZodString>;
+            default: z.ZodExactOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+            kind: z.ZodLiteral<"text">;
+        }, z.core.$strip>, z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+            description: z.ZodExactOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+            required: z.ZodExactOptional<z.ZodBoolean>;
+            contentKey: z.ZodExactOptional<z.ZodString>;
+            default: z.ZodExactOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+            kind: z.ZodLiteral<"textarea">;
+        }, z.core.$strip>, z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+            description: z.ZodExactOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+            required: z.ZodExactOptional<z.ZodBoolean>;
+            kind: z.ZodLiteral<"number">;
+            default: z.ZodExactOptional<z.ZodNumber>;
+            min: z.ZodExactOptional<z.ZodNumber>;
+            max: z.ZodExactOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+            description: z.ZodExactOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+            required: z.ZodExactOptional<z.ZodBoolean>;
+            kind: z.ZodLiteral<"boolean">;
+            default: z.ZodExactOptional<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+            description: z.ZodExactOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+            required: z.ZodExactOptional<z.ZodBoolean>;
+            kind: z.ZodLiteral<"select">;
+            options: z.ZodArray<z.ZodString>;
+            default: z.ZodExactOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+            description: z.ZodExactOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+            required: z.ZodExactOptional<z.ZodBoolean>;
+            kind: z.ZodLiteral<"url">;
+            default: z.ZodExactOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+            description: z.ZodExactOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+            required: z.ZodExactOptional<z.ZodBoolean>;
+            kind: z.ZodLiteral<"color">;
+            default: z.ZodExactOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+            description: z.ZodExactOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+            required: z.ZodExactOptional<z.ZodBoolean>;
+            kind: z.ZodLiteral<"menu">;
+            default: z.ZodExactOptional<z.ZodString>;
+        }, z.core.$strip>], "kind">>;
+    }, z.core.$strip>>>;
+    components: z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodString;
+        label: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+        group: z.ZodExactOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+        fields: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+            description: z.ZodExactOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+            required: z.ZodExactOptional<z.ZodBoolean>;
+            contentKey: z.ZodExactOptional<z.ZodString>;
+            default: z.ZodExactOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+            kind: z.ZodLiteral<"text">;
+        }, z.core.$strip>, z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+            description: z.ZodExactOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+            required: z.ZodExactOptional<z.ZodBoolean>;
+            contentKey: z.ZodExactOptional<z.ZodString>;
+            default: z.ZodExactOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+            kind: z.ZodLiteral<"textarea">;
+        }, z.core.$strip>, z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+            description: z.ZodExactOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+            required: z.ZodExactOptional<z.ZodBoolean>;
+            kind: z.ZodLiteral<"number">;
+            default: z.ZodExactOptional<z.ZodNumber>;
+            min: z.ZodExactOptional<z.ZodNumber>;
+            max: z.ZodExactOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+            description: z.ZodExactOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+            required: z.ZodExactOptional<z.ZodBoolean>;
+            kind: z.ZodLiteral<"boolean">;
+            default: z.ZodExactOptional<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+            description: z.ZodExactOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+            required: z.ZodExactOptional<z.ZodBoolean>;
+            kind: z.ZodLiteral<"select">;
+            options: z.ZodArray<z.ZodString>;
+            default: z.ZodExactOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+            description: z.ZodExactOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+            required: z.ZodExactOptional<z.ZodBoolean>;
+            kind: z.ZodLiteral<"url">;
+            default: z.ZodExactOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+            description: z.ZodExactOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+            required: z.ZodExactOptional<z.ZodBoolean>;
+            kind: z.ZodLiteral<"color">;
+            default: z.ZodExactOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+            description: z.ZodExactOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+            required: z.ZodExactOptional<z.ZodBoolean>;
+            kind: z.ZodLiteral<"menu">;
+            default: z.ZodExactOptional<z.ZodString>;
+        }, z.core.$strip>], "kind">>>;
+        slots: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            multiple: z.ZodExactOptional<z.ZodBoolean>;
+            allow: z.ZodExactOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        capabilities: z.ZodExactOptional<z.ZodObject<{
+            insertable: z.ZodExactOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Validate a manifest that arrived from outside the code. A structural failure
+ * returns `{ manifest: null, issues }`; a non-semver `version` is advisory and
+ * returns the manifest with an `invalid-version` issue.
+ */
+export declare function validateThemeManifest(input: unknown): ThemeManifestResult;