@roblawn/devtool-runtime 0.1.0-alpha.0

package/dist/ak/runtime-surface.shared.js

@@ -0,0 +1,221 @@
+import { computed, shallowRef, unref } from 'vue';
+import { applyCssStateToClassString } from './ak.cssState.transform.js';
+export function makeRuntimeLayoutGetter(layoutRef) {
+    return (field) => {
+        const raw = layoutRef.value;
+        if (typeof raw !== 'object' || raw === null) {
+            return undefined;
+        }
+        return raw[field];
+    };
+}
+export function makeRuntimeAkValue(mode, getter) {
+    if (mode === 'static') {
+        return getter();
+    }
+    return computed(getter);
+}
+export function makeRuntimeAkRef(mode, getter) {
+    if (mode === 'static') {
+        return shallowRef(getter());
+    }
+    return computed(getter);
+}
+export function cx(...parts) {
+    return parts
+        .map((part) => {
+        if (part == null || part === false)
+            return '';
+        return unref(part).trim();
+    })
+        .filter((s) => s.length > 0)
+        .join(' ');
+}
+function createPassthroughCssApiRuntime(getValue, mode) {
+    const factoryCache = new Map();
+    const makeFactory = (_opKey) => {
+        return ((field, _def, _meta) => {
+            return makeRuntimeAkValue(mode, () => {
+                const raw = getValue(field);
+                return typeof raw === 'string' ? raw : '';
+            });
+        });
+    };
+    return new Proxy({}, {
+        get(_target, prop) {
+            if (typeof prop !== 'string')
+                return undefined;
+            let factory = factoryCache.get(prop);
+            if (!factory) {
+                factory = makeFactory(prop);
+                factoryCache.set(prop, factory);
+            }
+            return factory;
+        },
+    });
+}
+export function createCssApiRuntime(getValue, mode) {
+    return createPassthroughCssApiRuntime(getValue, mode);
+}
+function normalizeCssStateInput(state) {
+    const list = Array.isArray(state) ? state : [state];
+    return list.map((entry) => String(entry).trim()).filter((entry) => entry.length > 0);
+}
+const didWarnUnsupportedCssStateOpRuntime = new Set();
+function warnUnsupportedCssStateOpRuntimeOnce(op) {
+    const isDev = Boolean(import.meta.env?.DEV);
+    if (!isDev)
+        return;
+    if (didWarnUnsupportedCssStateOpRuntime.has(op))
+        return;
+    didWarnUnsupportedCssStateOpRuntime.add(op);
+    console.warn('[ak.cssState] unsupported op in cssState chain; falling back to empty class', { op });
+}
+export function createCssStateApiRuntime(css, mode, enabledOps) {
+    const stateApiCache = new Map();
+    const allowed = enabledOps ? new Set(enabledOps) : null;
+    return (stateInput) => {
+        const states = normalizeCssStateInput(stateInput);
+        const cacheKey = states.join('\u001f');
+        const cachedSurface = stateApiCache.get(cacheKey);
+        if (cachedSurface) {
+            return cachedSurface;
+        }
+        const opFactoryCache = new Map();
+        const noOpFactoryCache = new Map();
+        const getFallbackFactory = (op) => {
+            let fallback = noOpFactoryCache.get(op);
+            if (!fallback) {
+                fallback = ((_field) => {
+                    warnUnsupportedCssStateOpRuntimeOnce(op);
+                    return makeRuntimeAkValue(mode, () => '');
+                });
+                noOpFactoryCache.set(op, fallback);
+            }
+            return fallback;
+        };
+        const wrapped = new Proxy({}, {
+            get(_target, prop) {
+                if (typeof prop !== 'string')
+                    return undefined;
+                if (allowed && !allowed.has(prop))
+                    return getFallbackFactory(prop);
+                let factory = opFactoryCache.get(prop);
+                if (!factory) {
+                    const baseFactory = css[prop];
+                    if (typeof baseFactory !== 'function')
+                        return getFallbackFactory(prop);
+                    factory = ((field, def) => {
+                        const baseValue = baseFactory(field, def);
+                        return makeRuntimeAkValue(mode, () => applyCssStateToClassString(String(unref(baseValue) ?? ''), states));
+                    });
+                    opFactoryCache.set(prop, factory);
+                }
+                return factory;
+            },
+        });
+        stateApiCache.set(cacheKey, wrapped);
+        return wrapped;
+    };
+}
+export function makeDeclare(getValue, tokenFamilies, mode) {
+    const baseFor = (kind, field, defaultKey, resolver, _meta) => {
+        void kind;
+        return makeRuntimeAkValue(mode, () => {
+            const raw = getValue(field);
+            const rawString = typeof raw === 'string' ? raw : undefined;
+            const value = rawString ?? defaultKey;
+            return resolver(value);
+        });
+    };
+    const apiBase = {
+        for: baseFor,
+        enum(field, values, defaultValue, resolver, _meta) {
+            return makeRuntimeAkValue(mode, () => {
+                const raw = getValue(field);
+                if (typeof raw === 'string' && !values.includes(raw)) {
+                    return raw;
+                }
+                const value = pickEnumValue(raw, values, defaultValue);
+                return resolver(value);
+            });
+        },
+        boolean(field, defaultValue, resolver, _meta) {
+            return makeRuntimeAkValue(mode, () => {
+                const raw = getValue(field);
+                const value = pickBoolean(raw, defaultValue);
+                return resolver(value);
+            });
+        },
+    };
+    const api = apiBase;
+    const record = api;
+    for (const kind of tokenFamilies) {
+        record[kind] = (field, defaultKey, resolver, meta) => baseFor(kind, field, defaultKey, resolver, meta);
+    }
+    return api;
+}
+function pickEnumValue(raw, values, fallback) {
+    if (typeof raw === 'string' && values.includes(raw)) {
+        return raw;
+    }
+    return fallback;
+}
+function pickBoolean(raw, fallback) {
+    if (typeof raw === 'boolean')
+        return raw;
+    if (typeof raw === 'string') {
+        if (raw === 'true')
+            return true;
+        if (raw === 'false')
+            return false;
+    }
+    return fallback;
+}
+function pickString(raw, fallback) {
+    if (typeof raw === 'string')
+        return raw;
+    return fallback;
+}
+function pickNumber(raw, fallback) {
+    if (typeof raw === 'number')
+        return raw;
+    if (typeof raw === 'string') {
+        const parsed = Number(raw);
+        if (!Number.isNaN(parsed))
+            return parsed;
+    }
+    return fallback;
+}
+export function makeValue(getValue, mode) {
+    const booleanValue = (field, defaultValue, _meta) => {
+        return makeRuntimeAkRef(mode, () => {
+            const raw = getValue(field);
+            return pickBoolean(raw, defaultValue);
+        });
+    };
+    const stringValue = (field, defaultValue, _meta) => {
+        return makeRuntimeAkRef(mode, () => {
+            const raw = getValue(field);
+            return pickString(raw, defaultValue);
+        });
+    };
+    const numberValue = (field, defaultValue, _meta) => {
+        return makeRuntimeAkRef(mode, () => {
+            const raw = getValue(field);
+            return pickNumber(raw, defaultValue);
+        });
+    };
+    const enumValue = (field, values, defaultValue, _meta) => {
+        return makeRuntimeAkRef(mode, () => {
+            const raw = getValue(field);
+            return pickEnumValue(raw, values, defaultValue);
+        });
+    };
+    return {
+        boolean: booleanValue,
+        string: stringValue,
+        number: numberValue,
+        enum: enumValue,
+    };
+}

package/dist/ak/style-execution.d.ts

@@ -0,0 +1,13 @@
+import type { SetupStyleDefinition, StyleSetupResolvers } from './style-schema.js';
+export type StyleExecutionResolvedValue = string | string[];
+export interface StyleExecutionEntry {
+    readonly slotKeys: readonly string[];
+    resolveAll(props: Record<string, unknown>): Record<string, StyleExecutionResolvedValue>;
+}
+export type StyleExecutionDefinition = SetupStyleDefinition<StyleSetupResolvers>;
+type StyleExecutionRegistryInput = Record<string, StyleExecutionDefinition>;
+export declare function createStyleExecutionEntry(name: string, definition: StyleExecutionDefinition): StyleExecutionEntry;
+export declare function createStyleExecutionRegistry<TRegistry extends StyleExecutionRegistryInput>(definitions: TRegistry): {
+    readonly [Name in keyof TRegistry]: StyleExecutionEntry;
+};
+export {};

package/dist/ak/style-execution.js

@@ -0,0 +1,91 @@
+import { ref, unref } from 'vue';
+import { withScopedAkLayoutRef } from './useAk.shared.js';
+const EXECUTOR_CACHE = new WeakMap();
+function isObject(value) {
+    return typeof value === 'object' && value !== null;
+}
+function normalizeResolvedValue(value) {
+    const unwrapped = unref(value);
+    if (typeof unwrapped === 'string') {
+        return unwrapped.trim();
+    }
+    if (Array.isArray(unwrapped)) {
+        const values = unwrapped
+            .map((entry) => {
+            const resolved = unref(entry);
+            return typeof resolved === 'string' ? resolved.trim() : '';
+        })
+            .filter((entry) => entry.length > 0);
+        return values.length > 0 ? values : '';
+    }
+    return null;
+}
+function readSetupResolvers(name, definition, initialProps) {
+    const layoutRef = ref(initialProps);
+    const rawResolvers = withScopedAkLayoutRef(layoutRef, () => definition.setup());
+    if (!isObject(rawResolvers) || Array.isArray(rawResolvers)) {
+        throw new Error(`Style "${name}" setup did not return an object of resolvers.`);
+    }
+    const resolvers = {};
+    for (const [key, value] of Object.entries(rawResolvers)) {
+        if (typeof value !== 'function') {
+            throw new Error(`Style "${name}" output "${key}" was not a function.`);
+        }
+        resolvers[key] = value;
+    }
+    return resolvers;
+}
+function createSetupExecutor(name, definition) {
+    const slotKeys = Object.keys(readSetupResolvers(name, definition, {}));
+    return {
+        slotKeys,
+        resolveAll(props) {
+            const resolvers = readSetupResolvers(name, definition, props);
+            const resolved = {};
+            for (const [key, resolver] of Object.entries(resolvers)) {
+                const value = normalizeResolvedValue(resolver(props));
+                if (value === null)
+                    continue;
+                resolved[key] = value;
+            }
+            return resolved;
+        },
+    };
+}
+function getOrCreateExecutor(name, definition) {
+    if (typeof definition !== 'object' || definition === null) {
+        throw new Error(`Style "${name}" did not export a valid style definition object.`);
+    }
+    const cached = EXECUTOR_CACHE.get(definition);
+    if (cached) {
+        return cached;
+    }
+    const executor = typeof definition.setup === 'function'
+        ? createSetupExecutor(name, definition)
+        : (() => {
+            throw new Error(`Style "${name}" must export defineStyle(() => { ... }). Legacy config-style definitions are not supported.`);
+        })();
+    EXECUTOR_CACHE.set(definition, executor);
+    return executor;
+}
+export function createStyleExecutionEntry(name, definition) {
+    return {
+        get slotKeys() {
+            return getOrCreateExecutor(name, definition).slotKeys;
+        },
+        resolveAll(props) {
+            return getOrCreateExecutor(name, definition).resolveAll(props);
+        },
+    };
+}
+export function createStyleExecutionRegistry(definitions) {
+    const entries = {};
+    for (const [name, definition] of Object.entries(definitions)) {
+        Object.defineProperty(entries, name, {
+            enumerable: true,
+            configurable: false,
+            value: createStyleExecutionEntry(name, definition),
+        });
+    }
+    return entries;
+}

package/dist/ak/style-schema.d.ts

@@ -0,0 +1,16 @@
+import type { Ref } from 'vue';
+export type StyleClassValue = string | Ref<string>;
+export type StyleClassList = string[] | ReadonlyArray<StyleClassValue>;
+export type StyleResolverReturn = StyleClassValue | StyleClassList;
+export type OneArgStyleResolver<TStyle> = (style: TStyle) => StyleResolverReturn;
+export type StyleResolverLike<TStyle> = OneArgStyleResolver<TStyle>;
+export type StyleResolvers<TStyle> = Record<string, StyleResolverLike<TStyle>>;
+export type StyleSetupResolvers = Record<string, StyleResolverLike<any>>;
+export type SetupStyleDefinition<TResolvers extends StyleSetupResolvers = StyleSetupResolvers> = {
+    setup: () => TResolvers;
+    __stylePropsBrand: unknown;
+};
+export type InferStyleProps<T> = T extends {
+    __stylePropsBrand?: infer P;
+} ? P : never;
+export declare function defineStyle<TResolvers extends StyleSetupResolvers>(setup: () => TResolvers): SetupStyleDefinition<TResolvers>;

package/dist/ak/style-schema.js

@@ -0,0 +1,6 @@
+export function defineStyle(setup) {
+    return {
+        setup,
+        __stylePropsBrand: null,
+    };
+}

package/dist/ak/useAk.shared.d.ts

@@ -0,0 +1,3 @@
+import { type Ref } from 'vue';
+export declare function withScopedAkLayoutRef<T>(layoutRef: Ref<unknown>, run: () => T): T;
+export declare function resolveLayoutRef(layoutInput: unknown): Ref<unknown>;

package/dist/ak/useAk.shared.js

@@ -0,0 +1,36 @@
+import { getCurrentInstance, isRef, ref, toRef } from 'vue';
+const scopedLayoutRefStack = [];
+export function withScopedAkLayoutRef(layoutRef, run) {
+    scopedLayoutRefStack.push(layoutRef);
+    try {
+        return run();
+    }
+    finally {
+        const current = scopedLayoutRefStack.pop();
+        if (current !== layoutRef) {
+            throw new Error('AK scoped layout ref stack became unbalanced.');
+        }
+    }
+}
+export function resolveLayoutRef(layoutInput) {
+    if (isRef(layoutInput)) {
+        return layoutInput;
+    }
+    if (layoutInput === undefined) {
+        const scoped = scopedLayoutRefStack[scopedLayoutRefStack.length - 1];
+        if (scoped) {
+            return scoped;
+        }
+    }
+    const instance = getCurrentInstance();
+    if (!instance) {
+        throw new Error('useAk() must be called inside setup()');
+    }
+    if (layoutInput === undefined) {
+        return toRef(instance.props, 'layout');
+    }
+    if (typeof layoutInput === 'object' && layoutInput !== null && 'layout' in layoutInput) {
+        return toRef(layoutInput, 'layout');
+    }
+    return ref(layoutInput);
+}

package/dist/authoring/authoringEffectKinds.d.ts

@@ -0,0 +1,2 @@
+export declare const AUTHORING_EFFECT_KINDS: readonly ["element", "text", "text-style", "title-style", "text-alignment", "divide", "divide-x", "divide-y", "margin", "margin-top", "margin-right", "margin-bottom", "margin-left", "margin-x", "margin-y", "padding", "padding-top", "padding-right", "padding-bottom", "padding-left", "padding-x", "padding-y", "gap", "gap-x", "gap-y", "background", "color", "border", "border-top", "border-right", "border-bottom", "border-left", "ring", "shadow", "radius", "radius-top", "radius-right", "radius-bottom", "radius-left", "width", "height", "min-width", "min-height", "max-width", "max-height", "alignment"];
+export type AuthoringEffectKind = (typeof AUTHORING_EFFECT_KINDS)[number];

package/dist/authoring/authoringEffectKinds.js

@@ -0,0 +1,48 @@
+export const AUTHORING_EFFECT_KINDS = [
+    'element',
+    'text',
+    'text-style',
+    'title-style',
+    'text-alignment',
+    'divide',
+    'divide-x',
+    'divide-y',
+    'margin',
+    'margin-top',
+    'margin-right',
+    'margin-bottom',
+    'margin-left',
+    'margin-x',
+    'margin-y',
+    'padding',
+    'padding-top',
+    'padding-right',
+    'padding-bottom',
+    'padding-left',
+    'padding-x',
+    'padding-y',
+    'gap',
+    'gap-x',
+    'gap-y',
+    'background',
+    'color',
+    'border',
+    'border-top',
+    'border-right',
+    'border-bottom',
+    'border-left',
+    'ring',
+    'shadow',
+    'radius',
+    'radius-top',
+    'radius-right',
+    'radius-bottom',
+    'radius-left',
+    'width',
+    'height',
+    'min-width',
+    'min-height',
+    'max-width',
+    'max-height',
+    'alignment',
+];

package/dist/authoring/index.d.ts

@@ -0,0 +1 @@
+export * from './authoringEffectKinds.js';

package/dist/authoring/index.js

@@ -0,0 +1 @@
+export * from './authoringEffectKinds.js';

package/dist/cms/CMSPresenterSchemaTypes.d.ts

@@ -0,0 +1,108 @@
+import type { CMSFieldPreview, CMSSchema } from './CMSSchemaTypes.js';
+export interface PresenterGroup {
+    name: string;
+    label: string;
+}
+export type PresenterIcon = {
+    kind: 'emoji';
+    value: string;
+} | {
+    kind: 'lucide';
+    name: string;
+} | {
+    kind: 'url';
+    src: string;
+    alt?: string;
+};
+export interface PresenterMeta {
+    title: string;
+    subtitle?: string;
+    icon?: PresenterIcon;
+    previewRepresentative?: PreviewRepresentitive;
+    groups?: PresenterGroup[];
+}
+export type PresenterInlineFieldPatch = {
+    label?: string;
+    description?: string;
+    hidden?: boolean;
+    readOnly?: boolean;
+    group?: string;
+    preview?: Partial<CMSFieldPreview>;
+    required?: boolean;
+    setDefaultValue?: boolean;
+    defaultValue?: unknown;
+    hardCoded?: boolean;
+};
+export type PresenterWrapperPatch = {
+    label?: string;
+    description?: string;
+    group?: string;
+    collapsible?: boolean;
+    collapsed?: boolean;
+};
+export type PresenterFieldOverride = {
+    kind: 'omit';
+} | {
+    kind: 'patch';
+    patch: PresenterInlineFieldPatch;
+};
+export interface PresenterBlockInstance {
+    kind: 'block';
+    instanceId: string;
+    schemaRef: string;
+    displayMode?: 'block' | 'inline';
+    wrapper?: PresenterWrapperPatch;
+    overrides?: Record<string, PresenterFieldOverride>;
+}
+export interface PresenterModuleInstance {
+    kind: 'module';
+    instanceId: string;
+    moduleRef: {
+        subType: 'layout' | 'global' | 'collectionItem';
+        slug: string;
+    };
+    wrapper?: PresenterWrapperPatch;
+}
+export type PresenterInstance = PresenterBlockInstance | PresenterModuleInstance;
+export type MetaPreviewToken = 'meta:title' | 'meta:subtitle';
+export type PreviewRepresentitive = {
+    titleInstanceId?: string | MetaPreviewToken;
+    subtitleInstanceId?: string | MetaPreviewToken;
+    mediaInstanceId?: string;
+};
+export interface PresenterModuleRoot {
+    kind: 'module-root';
+    instanceId: string;
+    moduleRef: {
+        subType: 'layout' | 'global' | 'collectionItem';
+        slug: string;
+    };
+}
+export interface PresenterPageRoot {
+    kind: 'page-root';
+    instanceId: string;
+}
+export type PresenterDoc = {
+    scope: 'page';
+    name: string;
+    meta: PresenterMeta;
+    root?: PresenterPageRoot;
+    blocks: PresenterInstance[];
+    __deprecated?: Record<string, unknown>;
+} | {
+    scope: 'module';
+    name: string;
+    meta: PresenterMeta;
+    root: PresenterModuleRoot;
+    blocks: PresenterInstance[];
+    __deprecated?: Record<string, unknown>;
+};
+export interface CMSSchemaRegistry {
+    get(schemaName: string): CMSSchema | undefined;
+}
+export declare function isPagePresenter(doc: PresenterDoc): doc is Extract<PresenterDoc, {
+    scope: 'page';
+}>;
+export declare function isModulePresenter(doc: PresenterDoc): doc is Extract<PresenterDoc, {
+    scope: 'module';
+}>;

package/dist/cms/CMSPresenterSchemaTypes.js

@@ -0,0 +1,6 @@
+export function isPagePresenter(doc) {
+    return doc.scope === 'page';
+}
+export function isModulePresenter(doc) {
+    return doc.scope === 'module';
+}

package/dist/cms/CMSSchema.d.ts

@@ -0,0 +1,27 @@
+import { type CMSSchema, type CMSSchemaField, type CMSSchemaMeta, type TextCMSField, type NumberCMSField, type CheckboxCMSField, type SelectCMSField, type GroupCMSField, type ArrayCMSField, type TextArrayCMSField, type NumberArrayCMSField, type ImageCMSField, type IconCMSField, type RichTextField } from './CMSSchemaTypes.js';
+export type InferCmsFields<T> = T extends {
+    __fieldsBrand?: infer F;
+} ? F : never;
+export declare const cms: {
+    text: (label: string, init?: Partial<TextCMSField>) => TextCMSField;
+    textarea: (label: string, init?: Partial<TextCMSField>) => TextCMSField;
+    richtext: (label: string, init?: Partial<RichTextField>) => RichTextField;
+    number: (label: string, init?: Partial<NumberCMSField>) => NumberCMSField;
+    checkbox: (label: string, init?: Partial<CheckboxCMSField>) => CheckboxCMSField;
+    select: (label: string, options: SelectCMSField["options"], init?: Partial<SelectCMSField>) => SelectCMSField;
+    group: (label: string, fields: Record<string, CMSSchemaField>, init?: Partial<GroupCMSField>) => GroupCMSField;
+    array: (label: string, itemFields: Record<string, CMSSchemaField>, init?: Partial<ArrayCMSField>) => ArrayCMSField;
+    textArray: (label: string, init?: Partial<TextArrayCMSField>) => TextArrayCMSField;
+    numberArray: (label: string, init?: Partial<NumberArrayCMSField>) => NumberArrayCMSField;
+    image: (label: string, init?: Partial<ImageCMSField>) => ImageCMSField;
+    icon: (label: string, init?: Partial<IconCMSField>) => IconCMSField;
+};
+export declare function defineCMSSchema<const F extends Record<string, CMSSchemaField>>(config: {
+    name: string;
+    meta: CMSSchemaMeta;
+    fields: F & Record<string, CMSSchemaField>;
+    __deprecated?: Record<string, CMSSchemaField>;
+    omit?: boolean;
+}): CMSSchema & {
+    __fieldsBrand: F;
+};

package/dist/cms/CMSSchema.js

@@ -0,0 +1,89 @@
+import {} from './CMSSchemaTypes.js';
+function validateField(key, field, issues, path = key) {
+    if ('omit' in field && field.omit === true)
+        return;
+    switch (field.type) {
+        case 'select': {
+            if (!field.options || field.options.length === 0) {
+                issues.push(`"${path}": select requires non-empty options.`);
+            }
+            break;
+        }
+        case 'group': {
+            if (!field.fields || Object.keys(field.fields).length === 0) {
+                issues.push(`"${path}": group requires nested fields.`);
+            }
+            else {
+                for (const sub of Object.keys(field.fields)) {
+                    validateField(sub, field.fields[sub], issues, `${path}.${sub}`);
+                }
+            }
+            break;
+        }
+        case 'array': {
+            if (!field.fields || Object.keys(field.fields).length === 0) {
+                issues.push(`"${path}": array (of objects) requires nested fields (the item shape).`);
+            }
+            else {
+                for (const sub of Object.keys(field.fields)) {
+                    validateField(sub, field.fields[sub], issues, `${path}[].${sub}`);
+                }
+            }
+            break;
+        }
+        default:
+            break;
+    }
+}
+function validateSchema(_name, fields) {
+    const issues = [];
+    for (const key of Object.keys(fields)) {
+        validateField(key, fields[key], issues, key);
+    }
+    return issues;
+}
+export const cms = {
+    text: (label, init) => ({
+        type: 'text',
+        label,
+        input: init?.input ?? 'text',
+        ...init,
+    }),
+    textarea: (label, init) => cms.text(label, { ...init, input: 'textarea' }),
+    richtext: (label, init) => ({
+        type: 'richtext',
+        label,
+        ...init,
+    }),
+    number: (label, init) => ({ type: 'number', label, ...init }),
+    checkbox: (label, init) => ({ type: 'checkbox', label, ...init }),
+    select: (label, options, init) => ({
+        type: 'select',
+        label,
+        options,
+        display: init?.display ?? 'select',
+        ...init,
+    }),
+    group: (label, fields, init) => ({ type: 'group', label, fields, ...init }),
+    array: (label, itemFields, init) => ({
+        type: 'array',
+        label,
+        fields: itemFields,
+        ...init,
+    }),
+    textArray: (label, init) => ({ type: 'text-array', label, ...init }),
+    numberArray: (label, init) => ({ type: 'number-array', label, ...init }),
+    image: (label, init) => ({ type: 'image', label, ...init }),
+    icon: (label, init) => ({ type: 'icon', label, ...init }),
+};
+export function defineCMSSchema(config) {
+    const { name, meta, fields, __deprecated, omit } = config;
+    const issues = validateSchema(name, fields);
+    if (issues.length) {
+        console.warn(`[CMSSchema:${name}] Validation warnings:\n- ${issues.join('\n- ')}`);
+    }
+    const schema = { name, meta, fields, ...(omit ? { omit: true } : {}) };
+    if (__deprecated)
+        schema.__deprecated = __deprecated;
+    return Object.assign(schema, { __fieldsBrand: null });
+}