@ankhorage/zora 18.0.1 → 19.0.1

package/src/features/authoring/featureManifest.test.ts

@@ -0,0 +1,99 @@
+import { existsSync } from 'node:fs';
+
+import { expect, test } from 'bun:test';
+
+import { ZORA_CORE_PLUGIN_METADATA } from '../plugin/ZORA_CORE_PLUGIN_METADATA';
+import { ZORA_COMPONENT_META } from './componentMeta';
+import { FEATURE_MANIFEST_ELEMENTS } from './constants';
+
+test('every selected feature element is directly authorable through its canonical public facade', async () => {
+  const catalog = new Map(Object.entries(ZORA_COMPONENT_META));
+  for (const [family, names] of Object.entries(FEATURE_MANIFEST_ELEMENTS)) {
+    const source = await Bun.file(`src/features/${family}/public.ts`).text();
+    for (const name of names) {
+      const meta = catalog.get(name);
+      const hasAuthorableShape =
+        Object.keys(meta?.props ?? {}).length > 0 || (meta?.allowedChildren.length ?? 0) > 0;
+      expect(meta?.directManifestNode, name).toBe(true);
+      expect(hasAuthorableShape, name).toBe(true);
+      expect(source, name).toContain(name);
+    }
+  }
+});
+
+test('feature ownership has no remaining legacy ownership roots', () => {
+  expect(existsSync('src/components')).toBe(false);
+  expect(existsSync('src/patterns')).toBe(false);
+});
+
+test('form composition has one canonical feature owner', () => {
+  expect(existsSync('src/components/form')).toBe(false);
+  expect(existsSync('src/patterns/form-field')).toBe(false);
+});
+
+test('migrated picker and presentation elements have one canonical feature owner', () => {
+  for (const legacyPath of [
+    'src/components/gradient',
+    'src/components/date-picker',
+    'src/components/skeleton',
+    'src/components/time-picker',
+    'src/patterns/hero',
+    'src/patterns/missing-element',
+    'src/patterns/auth',
+  ]) {
+    expect(existsSync(legacyPath), legacyPath).toBe(false);
+  }
+});
+
+test('existing interactive authoring retains bindings after plugin composition', () => {
+  const meta = ZORA_CORE_PLUGIN_METADATA.componentMeta;
+  expect(meta.DataTable?.bindings?.props?.sort?.value.type).toBe('object');
+  expect(meta.DataTable?.bindings?.props?.rows?.value.type).toBe('array');
+  expect(meta.Uploader?.bindings?.props?.value?.value.type).toBe('object');
+  expect(meta.Uploader?.bindings?.events?.uploadRequest?.payload?.fields).toContainEqual({
+    path: 'asset',
+    type: 'object',
+  });
+  expect(meta.BottomSheet?.bindings?.props?.open?.value.type).toBe('boolean');
+});
+
+test('final ownership data components retain bindings after plugin composition', () => {
+  const meta = ZORA_CORE_PLUGIN_METADATA.componentMeta;
+  expect(meta.Dialog?.bindings?.props?.visible?.value.type).toBe('boolean');
+  expect(meta.Dialog?.bindings?.events?.dismiss?.payload?.eventType).toBe('dialog.dismiss');
+  expect(meta.Pagination?.bindings?.props?.page?.value.type).toBe('number');
+  expect(meta.Pagination?.bindings?.events?.pageChange?.payload?.eventType).toBe(
+    'pagination.pageChange',
+  );
+  expect(meta.Rating?.bindings?.props?.value?.value.type).toBe('number');
+});
+
+test('final ownership form and tab components retain bindings after plugin composition', () => {
+  const meta = ZORA_CORE_PLUGIN_METADATA.componentMeta;
+  expect(meta.SearchInput?.bindings?.props?.value?.value.type).toBe('string');
+  expect(meta.SearchInput?.bindings?.events?.submit?.payload?.eventType).toBe('searchInput.submit');
+  expect(meta.Tabs?.bindings?.props?.value?.value.type).toBe('string');
+  expect(meta.Tabs?.bindings?.events?.valueChange?.payload?.eventType).toBe('tabs.valueChange');
+});
+
+test('existing scalar authoring bindings remain available after plugin composition', () => {
+  const meta = ZORA_CORE_PLUGIN_METADATA.componentMeta;
+  expect(meta.Heading?.bindings?.props?.level?.value.type).toBe('number');
+  expect(meta.Image?.bindings?.props?.radius?.value.type).toBe('unknown');
+});
+
+test('authoring schemas omit layout and avatar options ignored by the underlying components', () => {
+  const meta = ZORA_CORE_PLUGIN_METADATA.componentMeta;
+  expect(meta.Divider?.props).not.toHaveProperty('width');
+  expect(meta.Container?.props).not.toHaveProperty('width');
+  expect(meta.AvatarGroup?.props.items?.itemSchema?.map(({ key }) => key)).not.toContain('size');
+  expect(meta.AvatarGroup?.props.items?.itemSchema?.map(({ key }) => key)).not.toContain('shape');
+});
+
+test('ContentRail accepts chips and all card elements and offers intrinsic-width scrolling', () => {
+  const rail = ZORA_COMPONENT_META.ContentRail;
+  for (const child of ['ChipGroup', ...FEATURE_MANIFEST_ELEMENTS.card])
+    expect(rail.allowedChildren).toContain(child);
+  expect(rail.props.itemSize?.enum).toContain('content');
+  expect(rail.props).not.toHaveProperty('stickyHeaderIndices');
+});

package/src/features/authoring/index.ts

@@ -0,0 +1,41 @@
+export type {
+  ZoraComponentBlueprint,
+  ZoraComponentCategory,
+  ZoraComponentEventMeta,
+  ZoraComponentEventPayloadFieldMeta,
+  ZoraComponentEventPayloadFieldType,
+  ZoraComponentEventPayloadKind,
+  ZoraComponentI18nMeta,
+  ZoraComponentManifestPolicy,
+  ZoraComponentMeta,
+  ZoraComponentMetaRegistry,
+  ZoraComponentPropArrayItemSchema,
+  ZoraComponentPropAuthoring,
+  ZoraComponentPropSchema,
+  ZoraComponentPropType,
+  ZoraComponentPropValue,
+  ZoraComponentSlotMeta,
+} from '../../types/authoring';
+export type {
+  ComposedZoraPluginMetadataCatalog,
+  ZoraPluginMetadata,
+  ZoraPluginPlacement,
+} from '../../types/plugin';
+export type {
+  ZoraThemeRecipeBooleanFieldMeta,
+  ZoraThemeRecipeChoiceFieldMeta,
+  ZoraThemeRecipeFieldMeta,
+  ZoraThemeRecipeKind,
+  ZoraThemeRecipeMeta,
+  ZoraThemeRecipeMetaRegistry,
+  ZoraThemeRecipeTokenFieldMeta,
+  ZoraThemeTokenFamily,
+} from '../../types/theme-recipe';
+export { composeZoraPluginMetadata } from '../plugin/application/use-cases/composeZoraPluginMetadata';
+export { ZoraPluginCompositionError } from '../plugin/domain/ZoraPluginCompositionError';
+export { ZORA_CORE_PLUGIN_METADATA } from '../plugin/ZORA_CORE_PLUGIN_METADATA';
+export type { ZoraBindableComponentType } from './bindableComponentMeta';
+export { ZORA_BINDABLE_COMPONENT_META } from './bindableComponentMeta';
+export { ZORA_COMPONENT_META } from './componentMeta';
+export { ZORA_THEME_TOKEN_FAMILIES } from './constants';
+export { ZORA_THEME_RECIPE_META } from './themeRecipeMeta';

package/src/features/authoring/radioGroupReachability.test.ts

@@ -0,0 +1,19 @@
+import { expect, test } from 'bun:test';
+
+import { ZORA_COMPONENT_META } from '.';
+
+const containers = [
+  ['Screen', ZORA_COMPONENT_META.Screen],
+  ['ScreenSection', ZORA_COMPONENT_META.ScreenSection],
+  ['View', ZORA_COMPONENT_META.View],
+  ['ScrollView', ZORA_COMPONENT_META.ScrollView],
+  ['Card', ZORA_COMPONENT_META.Card],
+] as const;
+
+test('keeps manifest RadioGroup reachable through canonical container composition', () => {
+  expect(ZORA_COMPONENT_META.RadioGroup.directManifestNode).toBe(true);
+
+  for (const [name, metadata] of containers) {
+    expect(metadata.allowedChildren, `${name} should allow RadioGroup`).toContain('RadioGroup');
+  }
+});

package/src/features/authoring/themeRecipeMeta.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, test } from 'bun:test';
+
+import { ZORA_COMPONENT_META, ZORA_THEME_RECIPE_META, ZORA_THEME_TOKEN_FAMILIES } from '.';
+
+const tokenFamilies = new Set<string>(ZORA_THEME_TOKEN_FAMILIES);
+const recipeMetaByName = new Map(Object.entries(ZORA_THEME_RECIPE_META));
+
+describe('ZORA_THEME_RECIPE_META', () => {
+  test('exports every current component/pattern theme-authority recipe', () => {
+    expect(Object.keys(ZORA_THEME_RECIPE_META)).toEqual([
+      'Button',
+      'Card',
+      'Heading',
+      'RadioGroup',
+      'Text',
+    ]);
+
+    for (const [name, componentMeta] of Object.entries(ZORA_COMPONENT_META)) {
+      const themeProps = Object.entries(componentMeta.props).filter(
+        ([, prop]) => prop.authoring?.authority === 'theme' && prop.authoring.scope !== 'global',
+      );
+      if (themeProps.length === 0) continue;
+
+      const recipe = recipeMetaByName.get(name);
+      expect(recipe, `${name} has theme props but no theme recipe`).toBeDefined();
+      expect(recipe?.kind).toBe(componentMeta.category === 'pattern' ? 'pattern' : 'component');
+      const fields = new Map(Object.entries(recipe?.fields ?? {}));
+      for (const [propName] of themeProps) {
+        expect(
+          fields.get(propName),
+          `${name}.${propName} is missing from its recipe`,
+        ).toBeDefined();
+      }
+    }
+  });
+
+  test('references only canonical token families and valid declared defaults', () => {
+    for (const meta of Object.values(ZORA_THEME_RECIPE_META)) {
+      for (const field of Object.values(meta.fields)) {
+        if (field.type === 'token') {
+          expect(tokenFamilies.has(field.tokenFamily), `${meta.name}.${field.label}`).toBe(true);
+        }
+        if (field.type === 'choice' && field.default !== undefined) {
+          expect(field.options).toContain(field.default);
+        }
+      }
+    }
+  });
+
+  test('keeps recipe defaults aligned with existing runtime behavior', () => {
+    expect(ZORA_THEME_RECIPE_META.Button?.fields.size?.default).toBe('l');
+    expect(ZORA_THEME_RECIPE_META.Card?.fields.padding?.default).toBeUndefined();
+    expect(ZORA_THEME_RECIPE_META.RadioGroup?.fields.gap?.default).toBe('s');
+    expect(ZORA_THEME_RECIPE_META.RadioGroup?.fields.color?.default).toBe('primary');
+    expect(ZORA_THEME_RECIPE_META.RadioGroup?.fields.size?.default).toBe('m');
+    expect(ZORA_THEME_RECIPE_META.Text?.fields.weight?.default).toBeUndefined();
+    expect(ZORA_THEME_RECIPE_META.Heading?.fields.size?.default).toBeUndefined();
+  });
+
+  test('does not persist theme-owned defaults into new instance blueprints', () => {
+    for (const [name, meta] of Object.entries(ZORA_COMPONENT_META)) {
+      const props = new Map(Object.entries(meta.props));
+      for (const propName of Object.keys(meta.blueprint?.defaultProps ?? {})) {
+        expect(
+          props.get(propName)?.authoring?.authority,
+          `${name}.${propName} blueprint must not pin a theme-owned value`,
+        ).not.toBe('theme');
+      }
+    }
+  });
+
+  test('is serializable for downstream authoring consumers', () => {
+    expect(() => JSON.stringify(ZORA_THEME_RECIPE_META)).not.toThrow();
+  });
+});

package/src/features/authoring/themeRecipeMeta.ts

@@ -0,0 +1,14 @@
+import type { ZoraThemeRecipeMetaRegistry } from '../../types/theme-recipe';
+import { buttonThemeRecipeMeta } from '../button/utils/themeRecipeMeta';
+import { cardThemeRecipeMeta } from '../card/utils/themeRecipeMeta';
+import { radioGroupThemeRecipeMeta } from '../form/radio/themeRecipeMeta';
+import { headingThemeRecipeMeta } from '../typography/utils/headingThemeRecipeMeta';
+import { textThemeRecipeMeta } from '../typography/utils/textThemeRecipeMeta';
+
+export const ZORA_THEME_RECIPE_META: ZoraThemeRecipeMetaRegistry = {
+  Button: buttonThemeRecipeMeta,
+  Card: cardThemeRecipeMeta,
+  Heading: headingThemeRecipeMeta,
+  RadioGroup: radioGroupThemeRecipeMeta,
+  Text: textThemeRecipeMeta,
+};

package/src/features/authoring/utils/createManifestBindings.ts

@@ -0,0 +1,47 @@
+import type { UiComponentBindingMeta } from '@ankhorage/contracts';
+
+import type { ZoraComponentMeta } from '../../../types/authoring';
+
+/*** Derives scalar bindings and normalized events from explicit component authoring schemas. */
+export function createManifestBindings(
+  props: ZoraComponentMeta['props'],
+  events: ZoraComponentMeta['events'] = {},
+): UiComponentBindingMeta {
+  return {
+    props: Object.fromEntries(
+      Object.entries(props)
+        .filter(([, schema]) => schema.type !== 'action')
+        .map(([key, schema]) => [
+          key,
+          {
+            label: schema.label ?? key,
+            acceptsFallback: true,
+            acceptsTransforms: true,
+            value: {
+              type:
+                schema.type === 'boolean' || schema.type === 'number' || schema.type === 'array'
+                  ? schema.type
+                  : schema.type === 'media' || schema.type === 'imageAsset'
+                    ? 'imageAsset'
+                    : schema.type === 'spacing' || schema.type === 'radius'
+                      ? 'unknown'
+                      : schema.type === 'enum' &&
+                          schema.enum?.length &&
+                          schema.enum.every((value) => typeof value === 'number')
+                        ? 'number'
+                        : 'string',
+            },
+          },
+        ]),
+    ),
+    events: Object.fromEntries(
+      Object.entries(events).map(([key, event]) => [
+        key,
+        {
+          label: event.label,
+          payload: { eventType: event.eventType, fields: event.payloadFields ?? [] },
+        },
+      ]),
+    ),
+  };
+}

package/src/features/authoring/utils/finalizeFeatureMetadata.ts

@@ -0,0 +1,26 @@
+import type { ZoraComponentMetaRegistry } from '../../../types/authoring';
+import { FEATURE_MANIFEST_ELEMENTS } from '../constants';
+import { createManifestBindings } from './createManifestBindings';
+
+/*** Completes feature bindings while preserving each component's explicit value contracts. */
+export function finalizeFeatureMetadata(
+  registry: ZoraComponentMetaRegistry,
+): ZoraComponentMetaRegistry {
+  const names: ReadonlySet<string> = new Set(Object.values(FEATURE_MANIFEST_ELEMENTS).flat());
+  return Object.fromEntries(
+    Object.entries(registry).map(([name, meta]) => {
+      if (!names.has(name)) return [name, meta];
+      const bindings = createManifestBindings(meta.props, meta.events);
+      return [
+        name,
+        {
+          ...meta,
+          bindings: {
+            props: { ...bindings.props, ...meta.bindings?.props },
+            events: { ...bindings.events, ...meta.bindings?.events },
+          },
+        },
+      ];
+    }),
+  );
+}

package/src/features/avatar/adapters/inbound/Avatar.tsx

@@ -2,12 +2,12 @@ import type { RoleSemantics, SurfaceTheme } from '@ankhorage/surface';
 import React from 'react';
 import { Image } from 'react-native';
 
-import type { ZoraColor } from '../../../../internal/recipes';
-import { useZoraTheme } from '../../../../theme/useZoraTheme';
-import { withZoraThemeScope } from '../../../../theme/withZoraThemeScope';
 import type { AvatarProps, AvatarShape, AvatarSize } from '../../../../types/avatar';
+import type { ZoraColor } from '../../../../types/theme';
 import { Icon } from '../../../icon/public';
 import { View } from '../../../layout/public';
+import { withZoraThemeScope } from '../../../theme/adapters/inbound/withZoraThemeScope';
+import { useZoraTheme } from '../../../theme/composition/useZoraTheme';
 import { Text, type TextVariant } from '../../../typography/public';
 import { resolveAvatarInitials } from '../../utils/resolveAvatarInitials';
 /***

package/src/features/avatar/adapters/inbound/AvatarGroup.tsx

@@ -1,9 +1,9 @@
 import React from 'react';
 
-import { useZoraTheme } from '../../../../theme/useZoraTheme';
-import { withZoraThemeScope } from '../../../../theme/withZoraThemeScope';
 import type { AvatarGroupItem, AvatarGroupProps } from '../../../../types/avatar-group';
 import { View } from '../../../layout/public';
+import { withZoraThemeScope } from '../../../theme/adapters/inbound/withZoraThemeScope';
+import { useZoraTheme } from '../../../theme/composition/useZoraTheme';
 import { Avatar } from '../../public';
 /***
  * Renders a compact group of avatars with optional overflow handling.

package/src/features/avatar/avatarGroupMeta.ts

@@ -1,4 +1,4 @@
-import type { ZoraComponentMeta } from '../../metadata/types';
+import type { ZoraComponentMeta } from '../../types/authoring';
 import { avatarMeta } from './avatarMeta';
 
 export const avatarGroupMeta = {

package/src/features/avatar/avatarMeta.ts

@@ -1,4 +1,4 @@
-import type { ZoraComponentMeta } from '../../metadata/types';
+import type { ZoraComponentMeta } from '../../types/authoring';
 
 export const avatarMeta = {
   name: 'Avatar',

package/src/features/badge/adapters/inbound/Badge.tsx

@@ -1,9 +1,9 @@
 import { Badge as SurfaceBadge } from '@ankhorage/surface';
 import React from 'react';
 
-import { resolveBadgeRecipe } from '../../../../internal/recipes';
-import { withZoraThemeScope } from '../../../../theme/withZoraThemeScope';
 import type { BadgeProps } from '../../../../types/badge';
+import { withZoraThemeScope } from '../../../theme/adapters/inbound/withZoraThemeScope';
+import { resolveBadgeRecipe } from '../../utils/resolveBadgeRecipe';
 /***
  * Shows a small status, label, or count indicator.
  */

package/src/features/badge/badgeMeta.ts

@@ -1,4 +1,4 @@
-import type { ZoraComponentMeta } from '../../metadata/types';
+import type { ZoraComponentMeta } from '../../types/authoring';
 
 export const badgeMeta = {
   name: 'Badge',

package/src/features/badge/utils/resolveBadgeRecipe.test.ts

@@ -0,0 +1,9 @@
+import { describe, expect, test } from 'bun:test';
+
+import { resolveBadgeRecipe } from './resolveBadgeRecipe';
+
+describe('resolveBadgeRecipe', () => {
+  test('maps defaults to a soft medium primary badge', () => {
+    expect(resolveBadgeRecipe({})).toEqual({ size: 'm', color: 'primary', variant: 'soft' });
+  });
+});

package/src/features/badge/utils/resolveBadgeRecipe.ts

@@ -0,0 +1,17 @@
+import type { BadgeProps as SurfaceBadgeProps } from '@ankhorage/surface';
+
+import type { ZoraBadgeVariant } from '../../../types/badge';
+import type { ZoraControlSize } from '../../../types/control';
+import type { ZoraColor } from '../../../types/theme';
+
+export function resolveBadgeRecipe({
+  color = 'primary',
+  variant = 'soft',
+  size = 'm',
+}: {
+  color?: ZoraColor;
+  variant?: ZoraBadgeVariant;
+  size?: ZoraControlSize;
+}): Pick<SurfaceBadgeProps, 'size' | 'color' | 'variant'> {
+  return { size, color, variant };
+}

package/src/features/bottom-sheet/adapters/inbound/BottomSheet.tsx

@@ -1,11 +1,11 @@
 import { useBottomSheet } from '@ankhorage/surface/bottom-sheet';
 import React from 'react';
 
-import { useZoraTheme } from '../../../../theme/useZoraTheme';
-import { withZoraThemeScope } from '../../../../theme/withZoraThemeScope';
-import { useZoraThemeRuntime } from '../../../../theme/ZoraThemeRuntimeContext';
 import type { BottomSheetProps } from '../../../../types/manifest-bottom-sheet';
 import { View } from '../../../layout/public';
+import { withZoraThemeScope } from '../../../theme/adapters/inbound/withZoraThemeScope';
+import { useZoraTheme } from '../../../theme/composition/useZoraTheme';
+import { useZoraThemeRuntime } from '../../../theme/composition/ZoraThemeRuntimeContext';
 
 /*** Presents declarative manifest children through the shared Surface sheet host. */
 export const BottomSheet = withZoraThemeScope(BottomSheetInner);

package/src/features/bottom-sheet/bottomSheetMeta.ts

@@ -1,5 +1,5 @@
-import { CONTAINER_ALLOWED_CHILDREN } from '../../metadata/allowedChildren';
-import type { ZoraComponentMeta } from '../../metadata/types';
+import type { ZoraComponentMeta } from '../../types/authoring';
+import { CONTAINER_ALLOWED_CHILDREN } from '../authoring/allowedChildren';
 
 export const bottomSheetMeta = {
   name: 'BottomSheet',

package/src/features/bottom-sheet/public.test.ts

@@ -34,9 +34,9 @@ describe('ZORA BottomSheet public contract', () => {
   test('installs BottomSheet only in the enabled native runtime capability host', async () => {
     const [provider, nativeCapabilities, webCapabilities, nativeDatePicker, nativeTimePicker] =
       await Promise.all([
-        Bun.file('src/theme/ZoraProvider.tsx').text(),
-        Bun.file('src/theme/ZoraRuntimeCapabilities.native.tsx').text(),
-        Bun.file('src/theme/ZoraRuntimeCapabilities.web.tsx').text(),
+        Bun.file('src/features/theme/adapters/inbound/ZoraProvider.tsx').text(),
+        Bun.file('src/features/theme/composition/ZoraRuntimeCapabilities.native.tsx').text(),
+        Bun.file('src/features/theme/composition/ZoraRuntimeCapabilities.web.tsx').text(),
         Bun.file('src/features/date-picker/adapters/inbound/DatePicker.native.tsx').text(),
         Bun.file('src/features/time-picker/adapters/inbound/TimePicker.native.tsx').text(),
       ]);

package/src/features/breadcrumbs/adapters/inbound/Breadcrumbs.tsx

@@ -1,8 +1,5 @@
 import React from 'react';
 
-import { resolveIconSize } from '../../../../internal/recipes';
-import { useZoraTheme } from '../../../../theme/useZoraTheme';
-import { withZoraThemeScope } from '../../../../theme/withZoraThemeScope';
 import type {
   BreadcrumbItem,
   BreadcrumbPressEvent,
@@ -10,7 +7,10 @@ import type {
 } from '../../../../types/breadcrumbs';
 import { Button } from '../../../button/public';
 import { Icon } from '../../../icon/public';
+import { resolveIconSize } from '../../../icon/utils/resolveIconSize';
 import { View } from '../../../layout/public';
+import { withZoraThemeScope } from '../../../theme/adapters/inbound/withZoraThemeScope';
+import { useZoraTheme } from '../../../theme/composition/useZoraTheme';
 import { Text } from '../../../typography/public';
 
 /*** Renders a breadcrumb trail whose final item represents the current location. */

package/src/features/breadcrumbs/breadcrumbsMeta.ts

@@ -1,4 +1,4 @@
-import type { ZoraComponentMeta } from '../../metadata';
+import type { ZoraComponentMeta } from '../authoring';
 
 export const breadcrumbsMeta = {
   name: 'Breadcrumbs',

package/src/features/button/adapters/inbound/Button.tsx

@@ -1,9 +1,9 @@
 import { Button as SurfaceButton } from '@ankhorage/surface';
 import React from 'react';
 
-import { useZoraThemeRecipe } from '../../../../theme/useZoraThemeRecipe';
-import { withZoraThemeScope } from '../../../../theme/withZoraThemeScope';
 import type { ButtonProps } from '../../../../types/button';
+import { withZoraThemeScope } from '../../../theme/adapters/inbound/withZoraThemeScope';
+import { useZoraThemeRecipe } from '../../../theme/composition/useZoraThemeRecipe';
 import { resolveButtonThemeRecipe } from '../../utils/resolveButtonThemeRecipe';
 /***
  * Theme-aware action control for primary, secondary, destructive, and neutral actions.

package/src/features/button/adapters/inbound/ButtonGroup.tsx

@@ -1,12 +1,12 @@
 import React from 'react';
 
-import { withZoraThemeScope } from '../../../../theme/withZoraThemeScope';
 import type {
   ButtonGroupAlign,
   ButtonGroupOrientation,
   ButtonGroupProps,
 } from '../../../../types/button-group';
 import { View } from '../../../layout/public';
+import { withZoraThemeScope } from '../../../theme/adapters/inbound/withZoraThemeScope';
 /***
  * Groups multiple `Button` elements with consistent spacing and alignment.
  */

package/src/features/button/adapters/inbound/IconButton.tsx

@@ -1,9 +1,9 @@
 import { IconButton as SurfaceIconButton } from '@ankhorage/surface';
 import React from 'react';
 
-import { resolveButtonRecipe } from '../../../../internal/recipes';
-import { withZoraThemeScope } from '../../../../theme/withZoraThemeScope';
 import type { IconButtonProps } from '../../../../types/icon-button';
+import { withZoraThemeScope } from '../../../theme/adapters/inbound/withZoraThemeScope';
+import { resolveButtonRecipe } from '../../utils/resolveButtonRecipe';
 /***
  * Icon-only button for compact actions; requires an accessible `label`.
  */

package/src/features/button/buttonGroupMeta.ts

@@ -1,4 +1,4 @@
-import type { ZoraComponentMeta } from '../../metadata';
+import type { ZoraComponentMeta } from '../authoring';
 
 export const buttonGroupMeta = {
   name: 'ButtonGroup',

package/src/features/button/buttonMeta.ts

@@ -1,6 +1,6 @@
-import { COMPONENT_THEME_AUTHORING } from '../../constants';
-import { ZORA_COLORS } from '../../internal/colorModel';
-import type { ZoraComponentMeta } from '../../metadata';
+import type { ZoraComponentMeta } from '../authoring';
+import { COMPONENT_THEME_AUTHORING } from '../authoring/constants';
+import { ZORA_COLORS } from '../theme/colorModel';
 
 export const buttonMeta = {
   name: 'Button',

package/src/features/button/iconButtonMeta.ts

@@ -1,4 +1,4 @@
-import type { ZoraComponentMeta } from '../../metadata/types';
+import type { ZoraComponentMeta } from '../../types/authoring';
 
 export const iconButtonMeta = {
   name: 'IconButton',

package/src/features/button/utils/resolveButtonRecipe.test.ts

@@ -0,0 +1,9 @@
+import { describe, expect, test } from 'bun:test';
+
+import { resolveButtonRecipe } from './resolveButtonRecipe';
+
+describe('resolveButtonRecipe', () => {
+  test('maps defaults to a large solid primary button', () => {
+    expect(resolveButtonRecipe({})).toEqual({ size: 'l', color: 'primary', variant: 'solid' });
+  });
+});

package/src/features/button/utils/resolveButtonRecipe.ts

@@ -0,0 +1,17 @@
+import type { ButtonProps as SurfaceButtonProps } from '@ankhorage/surface';
+
+import type { ZoraButtonVariant } from '../../../types/button';
+import type { ZoraControlSize } from '../../../types/control';
+import type { ZoraColor } from '../../../types/theme';
+
+export function resolveButtonRecipe({
+  color = 'primary',
+  variant = 'solid',
+  size = 'l',
+}: {
+  color?: ZoraColor;
+  variant?: ZoraButtonVariant;
+  size?: ZoraControlSize;
+}): Pick<SurfaceButtonProps, 'size' | 'color' | 'variant'> {
+  return { size, color, variant };
+}

package/src/features/button/utils/resolveButtonThemeRecipe.ts

@@ -1,11 +1,9 @@
 import type { ThemeRecipeOverrideValue } from '@ankhorage/contracts';
 
-import {
-  resolveButtonRecipe,
-  type ZoraButtonVariant,
-  type ZoraColor,
-  type ZoraControlSize,
-} from '../../../internal/recipes';
+import type { ZoraButtonVariant } from '../../../types/button';
+import type { ZoraControlSize } from '../../../types/control';
+import type { ZoraColor } from '../../../types/theme';
+import { resolveButtonRecipe } from './resolveButtonRecipe';
 
 export function resolveButtonThemeRecipe(input: {
   readonly color?: ZoraColor;

package/src/features/button/utils/themeRecipeMeta.ts

@@ -1,5 +1,5 @@
-import { ZORA_COLORS } from '../../../internal/colorModel';
-import type { ZoraThemeRecipeMeta } from '../../../metadata/themeRecipeTypes';
+import type { ZoraThemeRecipeMeta } from '../../../types/theme-recipe';
+import { ZORA_COLORS } from '../../theme/colorModel';
 
 export const buttonThemeRecipeMeta = {
   name: 'Button',

package/src/features/card/adapters/inbound/Card.tsx

@@ -1,14 +1,14 @@
 import { Card as SurfaceCard } from '@ankhorage/surface';
 import React from 'react';
 
-import { resolveCardVariant } from '../../../../internal/recipes';
-import { useZoraThemeRecipe } from '../../../../theme/useZoraThemeRecipe';
-import { withZoraThemeScope } from '../../../../theme/withZoraThemeScope';
 import type { CardProps } from '../../../../types/card';
 import { View } from '../../../layout/public';
+import { withZoraThemeScope } from '../../../theme/adapters/inbound/withZoraThemeScope';
+import { useZoraThemeRecipe } from '../../../theme/composition/useZoraThemeRecipe';
 import { Heading } from '../../../typography/public';
 import { Text } from '../../../typography/public';
 import { resolveCardThemeRecipe } from '../../utils/resolveCardThemeRecipe';
+import { resolveCardVariant } from '../../utils/resolveCardVariant';
 /***
  * Structured content container with built-in heading, description, actions, and footer slots.
  *