@roblawn/devtool-runtime 0.1.0-alpha.0

package/LICENSE.md

@@ -0,0 +1,11 @@
+Proprietary Alpha License
+
+Copyright (c) 2026 Rob Lawn. All rights reserved.
+
+Permission is granted to install and use this package as a runtime dependency of generated visual site authoring projects.
+
+This package is proprietary. No ownership or copyright interest is transferred. You may not redistribute, resell, sublicense, or repackage this package as a competing runtime, framework, scaffold, starter, or component product without prior written permission.
+
+This software is provided "as is", without warranty of any kind, express or implied, including but not limited to warranties of merchantability, fitness for a particular purpose, non-infringement, availability, security, or correctness. Use is at your own risk.
+
+In no event shall the copyright holder or contributors be liable for any claim, damages, data loss, business interruption, or other liability arising from use of this software.

package/README.md

@@ -0,0 +1,7 @@
+# @roblawn/devtool-runtime
+
+Alpha runtime primitives for generated visual site authoring projects.
+
+This package is intended to be installed by a compatible starter creator and consumed by generated sites.
+
+This package is proprietary alpha software, supplied as-is. See `LICENSE.md`.

package/dist/ak/ak.cssState.transform.d.ts

@@ -0,0 +1,2 @@
+import type { AkCssStateInput } from './ak.cssState.types.js';
+export declare function applyCssStateToClassString(classString: string, state: AkCssStateInput): string;

package/dist/ak/ak.cssState.transform.js

@@ -0,0 +1,60 @@
+function normalizeCssStateInput(state) {
+    const list = Array.isArray(state) ? state : [state];
+    return list.map((entry) => String(entry).trim()).filter((entry) => entry.length > 0);
+}
+function splitVariants(token) {
+    let bracketDepth = 0;
+    let parenDepth = 0;
+    let braceDepth = 0;
+    let current = '';
+    const segments = [];
+    for (const ch of token) {
+        if (ch === '[')
+            bracketDepth += 1;
+        else if (ch === ']')
+            bracketDepth = Math.max(0, bracketDepth - 1);
+        else if (ch === '(')
+            parenDepth += 1;
+        else if (ch === ')')
+            parenDepth = Math.max(0, parenDepth - 1);
+        else if (ch === '{')
+            braceDepth += 1;
+        else if (ch === '}')
+            braceDepth = Math.max(0, braceDepth - 1);
+        if (ch === ':' && bracketDepth === 0 && parenDepth === 0 && braceDepth === 0) {
+            segments.push(current);
+            current = '';
+            continue;
+        }
+        current += ch;
+    }
+    segments.push(current);
+    if (segments.length === 0) {
+        return { variants: [], utility: '' };
+    }
+    if (segments.length === 1) {
+        return { variants: [], utility: segments[0] };
+    }
+    const utility = segments.pop() ?? '';
+    return {
+        variants: segments.filter((segment) => segment.length > 0),
+        utility,
+    };
+}
+export function applyCssStateToClassString(classString, state) {
+    const states = normalizeCssStateInput(state);
+    const trimmed = classString.trim();
+    if (trimmed.length === 0 || states.length === 0) {
+        return trimmed;
+    }
+    const tokens = trimmed.split(/\s+/).filter((token) => token.length > 0);
+    return tokens
+        .map((token) => {
+        const { variants, utility } = splitVariants(token);
+        if (utility.length === 0)
+            return '';
+        return [...variants, ...states, utility].join(':');
+    })
+        .filter((token) => token.length > 0)
+        .join(' ');
+}

package/dist/ak/ak.cssState.types.d.ts

@@ -0,0 +1,2 @@
+export type AkCssStatePrefix = 'hover' | 'focus' | 'focus-visible' | 'active' | 'disabled' | 'checked' | 'invalid' | 'required' | 'first' | 'last' | 'odd' | 'even' | 'open' | 'dark' | 'motion-reduce' | 'print' | 'group-hover' | 'group-focus' | 'peer-focus' | 'peer-checked' | `data-[${string}]` | `aria-[${string}]`;
+export type AkCssStateInput = AkCssStatePrefix | readonly AkCssStatePrefix[];

package/dist/ak/ak.cssState.types.js

@@ -0,0 +1 @@
+export {};

package/dist/ak/ak.responsive.types.d.ts

@@ -0,0 +1,18 @@
+export type ResponsiveMode = 'compute' | 'lookup' | 'hybrid';
+export type ResponsiveOverridesForToken<TokenKey extends string = string> = Readonly<Record<string, TokenKey | undefined>>;
+export type AuthorKitResponsiveWiring<TOp extends string = string, TToken extends string = string> = {
+    readonly mode: 'lookup';
+    readonly enabledOps: readonly TOp[];
+} | {
+    readonly mode: 'compute' | 'hybrid';
+    readonly enabledOps: readonly TOp[];
+    readonly breakpointOrder: readonly string[];
+    getOverrides(op: TOp, baseToken: TToken): ResponsiveOverridesForToken<TToken>;
+    buildClassString(args: {
+        readonly op: TOp;
+        readonly baseToken: TToken;
+        readonly overrides: ResponsiveOverridesForToken<TToken>;
+        readonly breakpointOrder: readonly string[];
+        readonly resolveTokenToClasses: (op: string, token: string) => string;
+    }): string;
+};

package/dist/ak/ak.responsive.types.js

@@ -0,0 +1 @@
+export {};

package/dist/ak/ak.tokens.d.ts

@@ -0,0 +1,10 @@
+export interface SnapshotTokenSource {
+    getTokensForFamily(family: string): readonly string[];
+    getTokensForOp(op: string): readonly string[];
+}
+interface SnapshotTokensLike {
+    family(familyName: string): readonly string[];
+    op(opKey: string): readonly string[];
+}
+export declare function createAkTokensFromSnapshot(snapshot: SnapshotTokenSource): SnapshotTokensLike;
+export {};

package/dist/ak/ak.tokens.js

@@ -0,0 +1,10 @@
+export function createAkTokensFromSnapshot(snapshot) {
+    return {
+        family(family) {
+            return snapshot.getTokensForFamily(String(family));
+        },
+        op(op) {
+            return snapshot.getTokensForOp(String(op));
+        },
+    };
+}

package/dist/ak/ak.tokens.registry.d.ts

@@ -0,0 +1,10 @@
+export interface AuthorKitTokensLike {
+    family(familyName: string): readonly string[];
+    op(opKey: string): readonly string[];
+}
+export declare function createAkTokensFromRegistry(args: {
+    registryFamilies: Record<string, unknown>;
+    registryTokens: Record<string, Record<string, unknown>>;
+    coreFamilies: Record<string, readonly string[]>;
+    opToFamily: Readonly<Record<string, string>>;
+}): AuthorKitTokensLike;

package/dist/ak/ak.tokens.registry.js

@@ -0,0 +1,45 @@
+export function createAkTokensFromRegistry(args) {
+    const familyCache = new Map();
+    const opCache = new Map();
+    const family = (familyName) => {
+        const cached = familyCache.get(familyName);
+        if (cached) {
+            return cached;
+        }
+        const core = args.coreFamilies[familyName];
+        if (Array.isArray(core)) {
+            familyCache.set(familyName, core);
+            return core;
+        }
+        const reg = args.registryTokens[familyName];
+        if (reg && typeof reg === 'object') {
+            const keys = Object.keys(reg);
+            familyCache.set(familyName, keys);
+            return keys;
+        }
+        familyCache.set(familyName, []);
+        return [];
+    };
+    const op = (opKey) => {
+        const cached = opCache.get(opKey);
+        if (cached) {
+            return cached;
+        }
+        const familyName = args.opToFamily[opKey];
+        if (!familyName) {
+            opCache.set(opKey, []);
+            return [];
+        }
+        const keys = family(familyName);
+        opCache.set(opKey, keys);
+        return keys;
+    };
+    return {
+        family(familyName) {
+            return family(String(familyName));
+        },
+        op(opKey) {
+            return op(String(opKey));
+        },
+    };
+}

package/dist/ak/authoring-surface.shared.d.ts

@@ -0,0 +1,31 @@
+import type { AkCssStateInput } from './ak.cssState.types.js';
+import type { AuthorKitResponsiveWiring } from './ak.responsive.types.js';
+import type { RuntimeAkClass, RuntimeAkMode, RuntimeDeclareApi, RuntimeLayoutGetter } from './runtime-surface.shared.js';
+export type BoundCssResolver = (field: string, value?: string | number) => string;
+export type BoundCssFactory = <Field extends string>(field: Field, def?: string | number, meta?: unknown) => RuntimeAkClass;
+export type BoundCssApi = Record<string, BoundCssFactory>;
+export type BoundCssStateApi = (state: AkCssStateInput) => BoundCssApi;
+export type ResolveBoundCssValue<TOp extends string = string, TValue extends string | number = string> = (args: {
+    readonly op: TOp;
+    readonly field: string;
+    readonly def?: TValue;
+    readonly raw: unknown;
+    readonly resolver: BoundCssResolver;
+}) => string;
+export interface DeclareBoundOptions {
+    enumPassthroughUnknownString?: boolean | (() => boolean);
+    parseBooleanStrings?: boolean;
+}
+export declare function makeDeclareBound(getValue: RuntimeLayoutGetter, tokenFamilies: readonly string[], mode: RuntimeAkMode, options?: DeclareBoundOptions): RuntimeDeclareApi;
+export declare function createCssApiBound<TOp extends string = string, TValue extends string | number = string>(core: Record<TOp, BoundCssResolver>, getValue: RuntimeLayoutGetter, mode: RuntimeAkMode, resolveValue: ResolveBoundCssValue<TOp, TValue>): Record<TOp, BoundCssFactory>;
+export declare function createCssStateApiBound<TOp extends string = string>(css: Record<TOp, BoundCssFactory>, mode: RuntimeAkMode, enabledOps?: readonly TOp[]): (state: AkCssStateInput) => Record<TOp, BoundCssFactory>;
+export type ResolveResponsiveCssValue<TOp extends string = string, TToken extends string = string> = (args: {
+    readonly op: TOp;
+    readonly field: string;
+    readonly def?: TToken;
+    readonly raw: unknown;
+    readonly computeResolver: BoundCssResolver;
+    readonly wiring: AuthorKitResponsiveWiring<TOp, TToken>;
+}) => string;
+export declare function createResponsiveCssApiBound<TOp extends string = string, TToken extends string = string>(computeCore: Record<TOp, BoundCssResolver>, getValue: RuntimeLayoutGetter, wiring: AuthorKitResponsiveWiring<TOp, TToken>, mode: RuntimeAkMode, resolveValue: ResolveResponsiveCssValue<TOp, TToken>): Partial<Record<TOp, BoundCssFactory>>;
+export declare function mergeCssApiWithResponsive<TOp extends string = string>(cssBase: Record<TOp, BoundCssFactory>, responsiveCss: Partial<Record<TOp, BoundCssFactory>>, enabledOps: readonly string[]): Record<TOp, BoundCssFactory>;

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

@@ -0,0 +1,185 @@
+import { unref } from 'vue';
+import { applyCssStateToClassString } from './ak.cssState.transform.js';
+import { makeRuntimeAkValue } from './runtime-surface.shared.js';
+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 readDynamicBoolean(value, fallback) {
+    if (typeof value === 'function') {
+        return value();
+    }
+    return value ?? fallback;
+}
+export function makeDeclareBound(getValue, tokenFamilies, mode, options) {
+    const parseBooleanStrings = options?.parseBooleanStrings ?? true;
+    const baseFor = (kind, field, defaultKey, resolver) => {
+        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) {
+            return makeRuntimeAkValue(mode, () => {
+                const raw = getValue(field);
+                const enumPassthroughUnknownString = readDynamicBoolean(options?.enumPassthroughUnknownString, false);
+                if (enumPassthroughUnknownString && typeof raw === 'string' && !values.includes(raw)) {
+                    return raw;
+                }
+                const value = pickEnumValue(raw, values, defaultValue);
+                return resolver(value);
+            });
+        },
+        boolean(field, defaultValue, resolver) {
+            return makeRuntimeAkValue(mode, () => {
+                const raw = getValue(field);
+                const enumPassthroughUnknownString = readDynamicBoolean(options?.enumPassthroughUnknownString, false);
+                if (enumPassthroughUnknownString && typeof raw === 'string' && raw !== 'true' && raw !== 'false') {
+                    return raw;
+                }
+                const value = parseBooleanStrings ? pickBoolean(raw, defaultValue) : typeof raw === 'boolean' ? raw : defaultValue;
+                return resolver(value);
+            });
+        },
+    };
+    const api = apiBase;
+    const record = api;
+    for (const kind of tokenFamilies) {
+        record[kind] = (field, defaultKey, resolver) => baseFor(kind, field, defaultKey, resolver);
+    }
+    return api;
+}
+export function createCssApiBound(core, getValue, mode, resolveValue) {
+    const api = {};
+    const opKeys = Object.keys(core);
+    for (const opKey of opKeys) {
+        const resolver = core[opKey];
+        api[opKey] = ((field, def) => {
+            return makeRuntimeAkValue(mode, () => {
+                const raw = getValue(field);
+                return resolveValue({
+                    op: opKey,
+                    field,
+                    def: def,
+                    raw,
+                    resolver,
+                });
+            });
+        });
+    }
+    return api;
+}
+function normalizeCssStateInput(state) {
+    const list = Array.isArray(state) ? state : [state];
+    return list.map((entry) => String(entry).trim()).filter((entry) => entry.length > 0);
+}
+const didWarnUnsupportedCssStateOp = new Set();
+function warnUnsupportedCssStateOpOnce(op) {
+    const isDev = Boolean(import.meta.env?.DEV);
+    if (!isDev)
+        return;
+    if (didWarnUnsupportedCssStateOp.has(op))
+        return;
+    didWarnUnsupportedCssStateOp.add(op);
+    console.warn('[ak.cssState] unsupported op in cssState chain; falling back to empty class', { op });
+}
+export function createCssStateApiBound(css, mode, enabledOps) {
+    const cache = new Map();
+    const opKeys = (enabledOps ?? Object.keys(css)).filter((op) => typeof css[op] === 'function');
+    return (state) => {
+        const states = normalizeCssStateInput(state);
+        const cacheKey = states.join('\u001f');
+        const existing = cache.get(cacheKey);
+        if (existing) {
+            return existing;
+        }
+        const api = {};
+        for (const opKey of opKeys) {
+            const resolver = css[opKey];
+            api[opKey] = ((field, def) => {
+                const baseValue = resolver(field, def);
+                return makeRuntimeAkValue(mode, () => applyCssStateToClassString(String(unref(baseValue) ?? ''), states));
+            });
+        }
+        const noOpFactoryCache = new Map();
+        const typed = new Proxy(api, {
+            get(target, prop) {
+                if (typeof prop !== 'string') {
+                    return Reflect.get(target, prop);
+                }
+                const existingValue = target[prop];
+                if (typeof existingValue === 'function') {
+                    return existingValue;
+                }
+                let fallback = noOpFactoryCache.get(prop);
+                if (!fallback) {
+                    fallback = ((_field) => {
+                        warnUnsupportedCssStateOpOnce(prop);
+                        return makeRuntimeAkValue(mode, () => '');
+                    });
+                    noOpFactoryCache.set(prop, fallback);
+                }
+                return fallback;
+            },
+        });
+        cache.set(cacheKey, typed);
+        return typed;
+    };
+}
+export function createResponsiveCssApiBound(computeCore, getValue, wiring, mode, resolveValue) {
+    const api = {};
+    const enabled = wiring.enabledOps;
+    for (const opKey of enabled) {
+        const computeResolver = computeCore[opKey];
+        api[opKey] = ((field, def) => {
+            return makeRuntimeAkValue(mode, () => {
+                const raw = getValue(field);
+                return resolveValue({
+                    op: opKey,
+                    field,
+                    def: def,
+                    raw,
+                    computeResolver,
+                    wiring,
+                });
+            });
+        });
+    }
+    return api;
+}
+export function mergeCssApiWithResponsive(cssBase, responsiveCss, enabledOps) {
+    const enabled = new Set(enabledOps);
+    const responsiveRecord = responsiveCss;
+    return new Proxy(cssBase, {
+        get(target, prop, receiver) {
+            if (typeof prop !== 'string') {
+                return Reflect.get(target, prop, receiver);
+            }
+            if (enabled.has(prop)) {
+                const responsiveFactory = responsiveRecord[prop];
+                if (typeof responsiveFactory === 'function') {
+                    return responsiveFactory;
+                }
+            }
+            return Reflect.get(target, prop, receiver);
+        },
+    });
+}

package/dist/ak/configured-core.shared.d.ts

@@ -0,0 +1,7 @@
+import type { Ref } from 'vue';
+import type { BoundCssResolver } from './authoring-surface.shared.js';
+export declare function createConfiguredAkCore(args: {
+    readonly layoutRef: Ref<unknown>;
+    readonly ops: readonly string[];
+    readonly resolve: (op: string, value: string | number) => string;
+}): Record<string, BoundCssResolver>;

package/dist/ak/configured-core.shared.js

@@ -0,0 +1,16 @@
+export function createConfiguredAkCore(args) {
+    const core = {};
+    for (const op of args.ops) {
+        core[op] = (field, tokenKey) => {
+            const record = args.layoutRef.value;
+            const explicit = typeof tokenKey === 'string' || typeof tokenKey === 'number' ? tokenKey : undefined;
+            const raw = record?.[field];
+            const fromLayout = typeof raw === 'string' || typeof raw === 'number' ? raw : typeof raw === 'boolean' ? String(raw) : undefined;
+            const value = explicit ?? fromLayout;
+            if (value === undefined || value === '')
+                return '';
+            return args.resolve(op, value);
+        };
+    }
+    return core;
+}

package/dist/ak/configured-surfaces.shared.d.ts

@@ -0,0 +1,67 @@
+import type { Ref } from 'vue';
+import type { AuthorKitResponsiveWiring } from './ak.responsive.types.js';
+import type { AuthorKitTokensLike } from './ak.tokens.registry.js';
+import { type BoundCssApi, type BoundCssResolver, type DeclareBoundOptions, type ResolveBoundCssValue, type ResolveResponsiveCssValue } from './authoring-surface.shared.js';
+import { type RuntimeAkMode, type RuntimeLayoutGetter, type RuntimeCssApi } from './runtime-surface.shared.js';
+export interface RuntimeSurfaceFactoryArgs {
+    readonly layoutRef: Ref<unknown>;
+    readonly mode: RuntimeAkMode;
+    readonly acceptPlainResolvedObject: boolean;
+}
+export type RuntimeSurfaceFactory<TSurface> = (args: RuntimeSurfaceFactoryArgs) => TSurface;
+export interface RuntimeEditorApi {
+    binding(policy: unknown): void;
+    section(section: unknown): void;
+}
+export interface RuntimeAuthorKitShape {
+    readonly css: BoundCssApi | RuntimeCssApi;
+    readonly cssBase: BoundCssApi | RuntimeCssApi;
+    readonly cssState: ((state: unknown) => BoundCssApi | RuntimeCssApi) | ((state: unknown) => RuntimeCssApi);
+    cx(...parts: Array<unknown>): string;
+    readonly declare: unknown;
+    readonly value: unknown;
+    readonly wrapper: unknown;
+    readonly style: unknown;
+    readonly editor: RuntimeEditorApi;
+    readonly tokens: AuthorKitTokensLike;
+    write?: 'destructive' | 'additive';
+}
+export declare function createConfiguredAuthorKitSurface(args: {
+    readonly layoutRef: Ref<unknown>;
+    readonly tokenFamilies: readonly string[];
+    readonly tokens: AuthorKitTokensLike;
+    readonly getValue: RuntimeLayoutGetter;
+    readonly cssBase: BoundCssApi;
+    readonly cssStateSource: BoundCssApi;
+    readonly cssStateEnabledOps?: readonly string[];
+    readonly mode?: RuntimeAkMode;
+    readonly createStyleApi: RuntimeSurfaceFactory<unknown>;
+    readonly createWrapperApi: RuntimeSurfaceFactory<unknown>;
+    readonly createDeclareOptions?: DeclareBoundOptions;
+}): RuntimeAuthorKitShape;
+export declare function createConfiguredResponsiveAuthorKitSurface(args: {
+    readonly core: Record<string, BoundCssResolver>;
+    readonly computeCanonical?: Record<string, BoundCssResolver>;
+    readonly layoutRef: Ref<unknown>;
+    readonly getValue: RuntimeLayoutGetter;
+    readonly tokenFamilies: readonly string[];
+    readonly tokens: AuthorKitTokensLike;
+    readonly responsiveWiring: AuthorKitResponsiveWiring<string, string>;
+    readonly resolveCssValue: ResolveBoundCssValue<string, string>;
+    readonly resolveResponsiveCssValue: ResolveResponsiveCssValue<string, string>;
+    readonly cssStateEnabledOps?: readonly string[];
+    readonly mode?: RuntimeAkMode;
+    readonly createStyleApi: RuntimeSurfaceFactory<unknown>;
+    readonly createWrapperApi: RuntimeSurfaceFactory<unknown>;
+    readonly createDeclareOptions?: DeclareBoundOptions;
+    readonly acceptPlainResolvedObject?: boolean;
+}): RuntimeAuthorKitShape;
+export declare function createConfiguredRuntimeAuthorKitSurface(args: {
+    readonly layoutRef: Ref<unknown>;
+    readonly tokenFamilies: readonly string[];
+    readonly tokens: AuthorKitTokensLike;
+    readonly cssStateEnabledOps?: readonly string[];
+    readonly mode?: RuntimeAkMode;
+    readonly createStyleApi: RuntimeSurfaceFactory<unknown>;
+    readonly createWrapperApi: RuntimeSurfaceFactory<unknown>;
+}): RuntimeAuthorKitShape;

package/dist/ak/configured-surfaces.shared.js

@@ -0,0 +1,144 @@
+import { createCssApiBound, createCssStateApiBound, createResponsiveCssApiBound, makeDeclareBound, mergeCssApiWithResponsive, } from './authoring-surface.shared.js';
+import { createCssApiRuntime, createCssStateApiRuntime, cx, makeDeclare, makeRuntimeLayoutGetter, makeValue as makeRuntimeValue, } from './runtime-surface.shared.js';
+function createEditorApi() {
+    return {
+        binding() {
+        },
+        section() {
+        },
+    };
+}
+function createAuthorKitShape(args) {
+    let cachedDeclare = null;
+    let cachedStyle = null;
+    let cachedWrapper = null;
+    let cachedValue = null;
+    return {
+        css: args.css,
+        cssBase: args.cssBase,
+        cssState: args.cssState,
+        cx,
+        get declare() {
+            if (!cachedDeclare) {
+                cachedDeclare = args.createDeclareApi({
+                    getValue: args.getValue,
+                    tokenFamilies: args.tokenFamilies,
+                    mode: args.mode,
+                });
+            }
+            return cachedDeclare;
+        },
+        get value() {
+            if (!cachedValue) {
+                cachedValue = args.createValueApi({
+                    getValue: args.getValue,
+                    mode: args.mode,
+                });
+            }
+            return cachedValue;
+        },
+        get wrapper() {
+            if (!cachedWrapper) {
+                cachedWrapper = args.createWrapperApi({
+                    layoutRef: args.layoutRef,
+                    mode: args.mode,
+                    acceptPlainResolvedObject: false,
+                });
+            }
+            return cachedWrapper;
+        },
+        get style() {
+            if (!cachedStyle) {
+                cachedStyle = args.createStyleApi({
+                    layoutRef: args.layoutRef,
+                    mode: args.mode,
+                    acceptPlainResolvedObject: false,
+                });
+            }
+            return cachedStyle;
+        },
+        editor: createEditorApi(),
+        tokens: args.tokens,
+        write: 'destructive',
+    };
+}
+export function createConfiguredAuthorKitSurface(args) {
+    const mode = args.mode ?? 'reactive';
+    const cssState = createCssStateApiBound(args.cssStateSource, mode, args.cssStateEnabledOps);
+    return createAuthorKitShape({
+        layoutRef: args.layoutRef,
+        mode,
+        tokenFamilies: args.tokenFamilies,
+        tokens: args.tokens,
+        getValue: args.getValue,
+        css: args.cssBase,
+        cssBase: args.cssBase,
+        cssState: cssState,
+        createStyleApi: args.createStyleApi,
+        createWrapperApi: args.createWrapperApi,
+        createDeclareApi: ({ getValue, tokenFamilies, mode }) => makeDeclareBound(getValue, tokenFamilies, mode, args.createDeclareOptions),
+        createValueApi: ({ getValue, mode }) => makeRuntimeValue(getValue, mode),
+    });
+}
+export function createConfiguredResponsiveAuthorKitSurface(args) {
+    const mode = args.mode ?? 'reactive';
+    const canonicalCore = args.computeCanonical ?? args.core;
+    const cssBase = createCssApiBound(args.core, args.getValue, mode, args.resolveCssValue);
+    const cssResponsive = createResponsiveCssApiBound(args.core, args.getValue, args.responsiveWiring, mode, args.resolveResponsiveCssValue);
+    const css = mergeCssApiWithResponsive(cssBase, cssResponsive, args.responsiveWiring.enabledOps);
+    const cssStateBase = createCssApiBound(canonicalCore, args.getValue, mode, args.resolveCssValue);
+    const cssStateResponsive = createResponsiveCssApiBound(canonicalCore, args.getValue, args.responsiveWiring, mode, args.resolveResponsiveCssValue);
+    const cssStateSource = mergeCssApiWithResponsive(cssStateBase, cssStateResponsive, args.responsiveWiring.enabledOps);
+    const cssState = createCssStateApiBound(cssStateSource, mode, args.cssStateEnabledOps);
+    return createAuthorKitShape({
+        layoutRef: args.layoutRef,
+        mode,
+        tokenFamilies: args.tokenFamilies,
+        tokens: args.tokens,
+        getValue: args.getValue,
+        css,
+        cssBase,
+        cssState: cssState,
+        createStyleApi: ({ layoutRef, mode }) => args.createStyleApi({
+            layoutRef,
+            mode,
+            acceptPlainResolvedObject: args.acceptPlainResolvedObject ?? false,
+        }),
+        createWrapperApi: ({ layoutRef, mode }) => args.createWrapperApi({
+            layoutRef,
+            mode,
+            acceptPlainResolvedObject: args.acceptPlainResolvedObject ?? false,
+        }),
+        createDeclareApi: ({ getValue, tokenFamilies, mode }) => makeDeclareBound(getValue, tokenFamilies, mode, args.createDeclareOptions),
+        createValueApi: ({ getValue, mode }) => makeRuntimeValue(getValue, mode),
+    });
+}
+export function createConfiguredRuntimeAuthorKitSurface(args) {
+    const mode = args.mode ?? 'static';
+    const getValue = makeRuntimeLayoutGetter(args.layoutRef);
+    const css = createCssApiRuntime(getValue, mode);
+    const cssBase = createCssApiRuntime(getValue, mode);
+    const cssState = createCssStateApiRuntime(css, mode, args.cssStateEnabledOps);
+    return createAuthorKitShape({
+        layoutRef: args.layoutRef,
+        mode,
+        tokenFamilies: args.tokenFamilies,
+        tokens: args.tokens,
+        getValue,
+        css,
+        cssBase,
+        cssState: cssState,
+        createStyleApi: ({ layoutRef, mode }) => args.createStyleApi({
+            layoutRef,
+            mode,
+            acceptPlainResolvedObject: true,
+        }),
+        createWrapperApi: ({ layoutRef, mode }) => args.createWrapperApi({
+            layoutRef,
+            mode,
+            acceptPlainResolvedObject: false,
+        }),
+        createDeclareApi: ({ getValue, tokenFamilies, mode }) => makeDeclare(getValue, tokenFamilies, mode),
+        createValueApi: ({ getValue, mode }) => makeRuntimeValue(getValue, mode),
+    });
+}

package/dist/ak/index.d.ts

@@ -0,0 +1,16 @@
+export * from './ak.cssState.types.js';
+export * from './ak.cssState.transform.js';
+export * from './ak.responsive.types.js';
+export * from './ak.tokens.registry.js';
+export * from './ak.tokens.js';
+export * from './authoring-surface.shared.js';
+export * from './configured-core.shared.js';
+export * from './configured-surfaces.shared.js';
+export * from './project-entry.js';
+export * from './project-surface-adapters.shared.js';
+export * from './public-entry.shared.js';
+export * from './resolved-layout-marker.shared.js';
+export * from './style-schema.js';
+export * from './runtime-surface.shared.js';
+export * from './style-execution.js';
+export * from './useAk.shared.js';