@motion-proto/live-tokens 0.6.2 → 0.7.1

package/src/{component-editor → editor/component-editor}/scaffolding/linkedBlock.ts

@@ -3,8 +3,8 @@ import {
   isComponentPropertyLinked,
   getComponentPropertySiblings,
   editorState,
-} from '../../lib/editorStore';
-import type { CssVarRef } from '../../lib/editorTypes';
+} from '../../core/store/editorStore';
+import type { CssVarRef } from '../../core/store/editorTypes';
 import type { Token } from './types';
 
 function aliasKey(ref: CssVarRef | undefined): string {

package/src/{component-editor → editor/component-editor}/scaffolding/types.ts

@@ -13,6 +13,17 @@ export type Token = {
   /** When the linked block collapses several same-label same-value rows into one,
       the surviving row carries the other groupKey leads here so writes co-propagate. */
   mergeVariables?: string[];
+  /** When false, a padding-shaped token renders only the single-value control
+      (no split-to-sides affordance). For tokens consumed via a one-axis CSS
+      property like `padding-bottom: var(--x)`, splitting yields side values
+      that have nowhere to render — hide the toggle so users can't get into
+      that state. Defaults to true for padding-shaped tokens. */
+  splittable?: boolean;
+  /** Optional element grouping (e.g. 'frame', 'header', 'body'). When a state
+      has tokens or type-groups tagged with two or more distinct elements,
+      StateBlock partitions the panel into labeled subsections — typography
+      and properties for each element render together. */
+  element?: string;
 };
 
 /** Editor type-group: a fieldset containing a coordinated set of typography tokens
@@ -36,4 +47,7 @@ export type TypeGroupConfig = {
   outlineWidthLabel?: string;
   outlineColorVariable?: string;
   outlineColorLabel?: string;
+  /** See `Token.element` — when present, StateBlock groups this fieldset under
+      the matching element subsection. */
+  element?: string;
 };

package/src/{lib → editor/core/components}/componentConfigService.ts

@@ -1,5 +1,5 @@
-import type { ComponentConfig, ComponentConfigMeta } from './themeTypes';
-import { versionedFileResource } from './files/versionedFileResource';
+import type { ComponentConfig, ComponentConfigMeta } from '../themes/themeTypes';
+import { versionedFileResource } from '../storage/files/versionedFileResourceClient';
 
 /**
  * REST client for per-component config files. Parallel to `themeService.ts`

package/src/{lib → editor/core/components}/componentPersist.ts

@@ -1,8 +1,8 @@
 import { get } from 'svelte/store';
-import type { ComponentConfig } from './themeTypes';
-import { editorState, markComponentSaved } from './editorStore';
-import type { CssVarRef } from './editorTypes';
-import { CURRENT_COMPONENT_SCHEMA_VERSION } from './migrations';
+import type { ComponentConfig } from '../themes/themeTypes';
+import { editorState, markComponentSaved } from '../store/editorStore';
+import type { CssVarRef } from '../store/editorTypes';
+import { CURRENT_COMPONENT_SCHEMA_VERSION } from '../themes/migrations';
 import {
   listComponentConfigs,
   saveComponentConfig,
@@ -12,7 +12,7 @@ import {
 /**
  * Save the current in-memory state of a component to its active file. Mirrors
  * the `persist` flow inside `ComponentFileManager.svelte` so callers without a
- * file-manager instance (e.g. the unsaved-components dialog in PresetFileManager)
+ * file-manager instance (e.g. an unsaved-components dialog upstream)
  * can save a dirty component without duplicating the schema-version + aliases
  * stringification logic.
  *

package/src/editor/core/flashStatus.ts

@@ -0,0 +1,30 @@
+/**
+ * Centralised "flash a transient status, then revert to idle" helper for the
+ * file managers (theme / component / manifest). Each pulse — saved, error,
+ * adopted — shares the same timing so the UI stays in sync.
+ */
+
+export const FLASH_DURATION_MS = 2000;
+
+export interface FlashOptions<S extends string> {
+  /** State to revert to after the pulse. Defaults to `'idle'`. */
+  idleState?: S;
+  /** How long the transient state is shown before reverting. */
+  durationMs?: number;
+  /** Side effect fired alongside the revert (e.g. clear an inline message). */
+  onIdle?: () => void;
+}
+
+export function flashStatus<S extends string>(
+  set: (state: S) => void,
+  transientState: S,
+  options: FlashOptions<S> = {},
+): void {
+  const idleState = options.idleState ?? ('idle' as S);
+  const durationMs = options.durationMs ?? FLASH_DURATION_MS;
+  set(transientState);
+  setTimeout(() => {
+    set(idleState);
+    options.onIdle?.();
+  }, durationMs);
+}

package/src/{lib → editor/core/fonts}/fontLoader.ts

@@ -5,8 +5,8 @@ import type {
   FontStackSlot,
   FontStackVariable,
   SystemCascadePreset,
-} from './themeTypes';
-import { setCssVar, getSyncedDocuments } from './cssVarSync';
+} from '../themes/themeTypes';
+import { setCssVar, getSyncedDocuments } from '../cssVarSync';
 
 export const SYSTEM_CASCADES: Record<SystemCascadePreset, string> = {
   'system-ui-sans':

package/src/{lib → editor/core/fonts}/fontMigration.ts

@@ -1,7 +1,7 @@
-import type { FontFamily, FontSource, FontStack, Theme } from './themeTypes';
-import frauncesRomanLatin from '../styles/fonts/Fraunces/Fraunces-roman-latin.woff2?url';
-import frauncesItalicLatin from '../styles/fonts/Fraunces/Fraunces-italic-latin.woff2?url';
-import manropeLatin from '../styles/fonts/Manrope/Manrope-latin.woff2?url';
+import type { FontFamily, FontSource, FontStack, Theme } from '../themes/themeTypes';
+import frauncesRomanLatin from '../../../system/styles/fonts/Fraunces/Fraunces-roman-latin.woff2?url';
+import frauncesItalicLatin from '../../../system/styles/fonts/Fraunces/Fraunces-italic-latin.woff2?url';
+import manropeLatin from '../../../system/styles/fonts/Manrope/Manrope-latin.woff2?url';
 
 function makeId(prefix: string): string {
   return `${prefix}_${Math.random().toString(36).slice(2, 10)}`;

package/src/{lib → editor/core/fonts}/fontParse.ts

@@ -1,4 +1,4 @@
-import type { FontFamily, FontSource, FontSourceKind } from './themeTypes';
+import type { FontFamily, FontSource, FontSourceKind } from '../themes/themeTypes';
 
 export interface ParsedFamily {
   name: string;

package/src/editor/core/manifests/manifestService.ts

@@ -0,0 +1,116 @@
+import type { Manifest, ManifestMeta, Theme, ComponentConfig } from '../themes/themeTypes';
+import { versionedFileResource } from '../storage/files/versionedFileResourceClient';
+import { listComponents } from '../components/componentConfigService';
+import { getActiveTheme } from '../themes/themeService';
+
+/**
+ * REST client for manifest files. A manifest references one theme file +
+ * one config file per component (by basename). The active manifest is the
+ * single live snapshot: theme and component Adopts patch its refs server-side.
+ *
+ * `default` is the protected baseline — cannot be overwritten or deleted, and
+ * Adopts return 409 ACTIVE_IS_PROTECTED while it is active.
+ */
+
+const manifestsResource = versionedFileResource<Manifest, ManifestMeta, never>({
+  baseUrl: '/api/manifests',
+});
+
+export const listManifests = async (): Promise<ManifestMeta[]> => {
+  const data = await manifestsResource.list();
+  return data.files;
+};
+
+export const loadManifest = (fileName: string): Promise<Manifest> =>
+  manifestsResource.load(fileName);
+export const saveManifest = (fileName: string, data: Manifest): Promise<void> =>
+  manifestsResource.save(fileName, data);
+export const deleteManifest = (fileName: string): Promise<void> =>
+  manifestsResource.remove(fileName);
+export const getActiveManifest = (): Promise<Manifest | null> => manifestsResource.getActive();
+export const setActiveManifest = (fileName: string): Promise<void> =>
+  manifestsResource.setActive(fileName);
+
+export interface ApplyManifestResult {
+  ok: boolean;
+  manifest: Manifest;
+  theme: Theme;
+  componentConfigs: Record<string, ComponentConfig>;
+}
+
+/**
+ * Server-side atomic apply: validate every referenced file exists, flip the
+ * theme + each component's `_active.json` pointer, mark the manifest active,
+ * and return the resolved theme + component configs in one payload. Clients
+ * usually follow with a full page reload — manifest load is a "blow up the
+ * world" action.
+ */
+export async function applyManifest(fileName: string): Promise<ApplyManifestResult> {
+  const res = await fetch(`/api/manifests/${encodeURIComponent(fileName)}/apply`, {
+    method: 'PUT',
+  });
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({ error: 'Apply failed' }));
+    throw new Error(err.error || 'Apply failed');
+  }
+  return res.json();
+}
+
+/**
+ * Snapshot the currently-active theme + component-config file pointers into
+ * a new manifest file and set it active. Used by the manifest panel's Save As
+ * action and by the SaveAs-then-Adopt recovery flow when active is `default`.
+ */
+export async function saveAsManifest(
+  fileName: string,
+  displayName: string,
+): Promise<void> {
+  const activeTheme = await getActiveTheme();
+  if (!activeTheme || !activeTheme._fileName) {
+    throw new Error('No active theme on disk to capture');
+  }
+  const components = await listComponents();
+  const componentConfigs: Record<string, string> = {};
+  for (const c of components) {
+    componentConfigs[c.name] = c.activeFile || 'default';
+  }
+  const now = new Date().toISOString();
+  const manifest: Manifest = {
+    name: displayName,
+    createdAt: now,
+    updatedAt: now,
+    theme: activeTheme._fileName,
+    componentConfigs,
+  };
+  await saveManifest(fileName, manifest);
+  await setActiveManifest(fileName);
+}
+
+/**
+ * Re-snapshot the editor's current active pointers into the *currently active*
+ * manifest file. Used by the manifest panel's Save action. Server rejects with
+ * 403 if active is `default` (protected).
+ */
+export async function saveActiveManifest(displayName?: string): Promise<void> {
+  const active = await getActiveManifest();
+  if (!active || !active._fileName) {
+    throw new Error('No active manifest');
+  }
+  const activeTheme = await getActiveTheme();
+  if (!activeTheme || !activeTheme._fileName) {
+    throw new Error('No active theme on disk');
+  }
+  const components = await listComponents();
+  const componentConfigs: Record<string, string> = {};
+  for (const c of components) {
+    componentConfigs[c.name] = c.activeFile || 'default';
+  }
+  const manifest: Manifest = {
+    name: displayName ?? active.name,
+    createdAt: active.createdAt,
+    updatedAt: new Date().toISOString(),
+    theme: activeTheme._fileName,
+    componentConfigs,
+  };
+  await saveManifest(active._fileName, manifest);
+}

package/src/{lib → editor/core/palettes}/paletteDerivation.ts

@@ -14,8 +14,8 @@
  */
 
 import { hexToOklch, oklchToHex, gamutClamp } from './oklch';
-import { type CurveAnchor, sampleCurve, makeAnchor } from '../ui/curveEngine';
-import type { PaletteConfig } from './themeTypes';
+import { type CurveAnchor, sampleCurve, makeAnchor } from '../../ui/curveEngine';
+import type { PaletteConfig } from '../themes/themeTypes';
 
 export type PaletteMode = 'chromatic' | 'gray';
 

package/src/{lib → editor/core/palettes}/tokenRegistry.ts

@@ -19,17 +19,17 @@
  */
 
 import { derived, type Readable } from 'svelte/store';
-import tokensCss from '../styles/tokens.css?raw';
-import { editorState } from './editorStore';
-import type { EditorState } from './editorTypes';
-import { extractGlobalRootBody } from './parsers/globalRootBlock';
+import tokensCss from '../../../system/styles/tokens.css?raw';
+import { editorState } from '../store/editorStore';
+import type { EditorState } from '../store/editorTypes';
+import { extractGlobalRootBody } from '../themes/parsers/globalRootBlock';
 
 // Re-exported for tests and downstream consumers that previously imported it
 // from this module. The canonical implementation lives in `./parsers/globalRootBlock`
 // so the dev-server vite plugin can share it.
 export { extractGlobalRootBody };
 
-const componentSources = import.meta.glob('../components/*.svelte', {
+const componentSources = import.meta.glob('../../../system/components/*.svelte', {
   query: '?raw',
   import: 'default',
   eager: true,

package/src/editor/core/productionPulse.ts

@@ -0,0 +1,37 @@
+import { writable } from 'svelte/store';
+import type { ProductionInfo } from './themes/themeService';
+import type { ManifestMeta } from './themes/themeTypes';
+
+/**
+ * Monotonic counter that ticks every time a production pointer flips —
+ * theme production or a component's production. UI surfaces that need to
+ * react to a sibling Adopt subscribe to this so they refresh without
+ * per-pair wiring.
+ *
+ * Bumpers: `ThemeFileManager.handleApplyToProduction`,
+ * `ComponentFileManager.handleUpdateProduction`. Anyone setting
+ * `_production.json` should bump.
+ */
+export const productionRevision = writable(0);
+
+export function bumpProductionRevision(): void {
+  productionRevision.update((n) => n + 1);
+}
+
+/**
+ * Cached production-state stores. The Theme and Manifest file managers live in
+ * the sidebar footer, swapping in/out of the DOM as the user toggles between
+ * the tokens and components views. Keeping the last-known production state in
+ * module-level Svelte stores means a remount renders the correct Adopt-button
+ * state on the first frame instead of flashing through "not in sync" while a
+ * fresh fetch resolves.
+ */
+export const themeProductionInfo = writable<ProductionInfo | null>(null);
+
+/**
+ * Last-known active manifest meta. Bumped by ManifestFileManager whenever the
+ * active manifest changes (load, save, save-as) and whenever a theme or
+ * component Adopt completes (the server patches the active manifest as a
+ * side-effect, so consumers re-read it on `productionRevision` ticks).
+ */
+export const activeManifest = writable<ManifestMeta | null>(null);

package/src/{lib → editor/core/routing}/router.ts

@@ -1,5 +1,5 @@
 import { writable } from 'svelte/store';
-import { storageKey } from './editorConfig';
+import { storageKey } from '../store/editorConfig';
 
 function prevKey(): string {
   return storageKey('prev-route');

package/src/{lib/files/versionedFileResource.ts → editor/core/storage/files/versionedFileResourceClient.ts}

@@ -118,7 +118,14 @@ export function versionedFileResource<TItem, TMeta, TProductionInfo>(
       body: JSON.stringify({ name: fileName }),
     });
     if (!res.ok) {
-      throw new Error(await readJsonError(res, 'Set production failed'));
+      const body = await res.json().catch(() => ({}));
+      const err = new Error(body.error || 'Set production failed') as Error & {
+        status?: number;
+        code?: string;
+      };
+      err.status = res.status;
+      if (body.code) err.code = body.code;
+      throw err;
     }
     return res.json();
   }

package/src/{lib → editor/core/store}/editorCore.ts

@@ -260,21 +260,37 @@ export function mutate(label: string, fn: (draft: EditorState) => void): void {
   if (import.meta.env.DEV && !label) {
     console.warn('[editorStore] mutate() called without a label');
   }
+  // Svelte 5's `$derived` uses strict `===` for equality (see
+  // node_modules/svelte/src/internal/client/reactivity/deriveds.js → equality.js).
+  // If we mutated `s` in place and emitted the same top-level reference, any
+  // intermediate `$derived($editorState.someSlice.someObj)` in a component
+  // would return the same object reference and short-circuit the whole
+  // downstream chain — swatches and previews would freeze even while the
+  // renderer's direct `editorState.subscribe(...)` (which uses `safe_not_equal`,
+  // always-different for objects) continued to write CSS vars to :root.
+  //
+  // Cloning the draft before mutation guarantees every nested reference is
+  // fresh, so `$derived` chains everywhere propagate correctly. The previous
+  // live state (`current`) becomes the immutable history snapshot — no second
+  // structuredClone needed.
   if (transactionScope) {
-    // Inside a non-clipping scope: don't push individually; just mark the
-    // scope dirty and apply. The scope's commit pushes one collapsed entry.
     transactionScope.changed = true;
     if (clippingScope) clippingScope.changed = true;
-    store.update((s) => { fn(s); return s; });
+    store.update((s) => {
+      const next = structuredClone(s);
+      fn(next);
+      return next;
+    });
     return;
   }
-  // No transaction scope: each mutate is its own history entry. Inside a
-  // clipping scope this still pushes per-mutate entries (so undo within the
-  // scope walks them back), and the scope's commit will collapse them.
   if (clippingScope) clippingScope.changed = true;
   const current = get(store);
-  pushPast(structuredClone(current));
-  store.update((s) => { fn(s); return s; });
+  pushPast(current);
+  store.update((s) => {
+    const next = structuredClone(s);
+    fn(next);
+    return next;
+  });
   bumpTick();
   persistHook();
 }

package/src/{lib → editor/core/store}/editorPersistence.ts

@@ -17,9 +17,9 @@ import { get } from 'svelte/store';
 import type { EditorState } from './editorTypes';
 import { storageKey } from './editorConfig';
 import { store } from './editorCore';
-import { quietGet, quietSet } from './storage';
-import { makeDefaultGradients } from './slices/gradients';
-import { seedShadowsFromDom } from './slices/shadows';
+import { quietGet, quietSet } from '../storage/storage';
+import { makeDefaultGradients } from '../themes/slices/gradients';
+import { seedShadowsFromDom } from '../themes/slices/shadows';
 
 // Resolve the persist key lazily (per-call) so library consumers that invoke
 // `configureEditor({storagePrefix})` before the first store write get the

package/src/{lib → editor/core/store}/editorRenderer.ts

@@ -12,8 +12,8 @@
  */
 
 import type { EditorState } from './editorTypes';
-import { setCssVar, removeCssVar } from './cssVarSync';
-import { palettesToVars } from './paletteDerivation';
+import { setCssVar, removeCssVar } from '../cssVarSync';
+import { palettesToVars } from '../palettes/paletteDerivation';
 import {
   editorState,
   columnsToVars,

package/src/{lib → editor/core/store}/editorStore.ts

@@ -19,14 +19,14 @@
  */
 
 import type { CssVarRef, EditorState } from './editorTypes';
-import type { Theme } from './themeTypes';
-import { KNOWN_COMPONENT_CONFIG_KEYS } from './componentConfigKeys';
+import type { Theme } from '../themes/themeTypes';
+import { KNOWN_COMPONENT_CONFIG_KEYS } from '../components/componentConfigKeys';
 import {
   CURRENT_THEME_SCHEMA_VERSION,
   CURRENT_COMPONENT_SCHEMA_VERSION,
   runMigrations,
-} from './migrations';
-import { renamePrimaryPaletteKey } from './migrations/2026-05-13-primary-to-brand';
+} from '../themes/migrations';
+import { renamePrimaryPaletteKey } from '../themes/migrations/2026-05-13-primary-to-brand';
 import { __resetRendererCacheForTests, installRenderer } from './editorRenderer';
 import {
   store,
@@ -47,25 +47,25 @@ import {
   columnsEqualsDefault,
   columnsToVars,
   loadColumnsFromVars,
-} from './slices/columns';
+} from '../themes/slices/columns';
 import {
   loadOverlaysFromVars,
   makeDefaultOverlaysState,
   overlaysEqualsDefault,
   overlaysToVars,
-} from './slices/overlays';
+} from '../themes/slices/overlays';
 import {
   loadShadowsFromVars,
   shadowsToVars,
-} from './slices/shadows';
-import { makeDefaultGradients } from './slices/gradients';
+} from '../themes/slices/shadows';
+import { makeDefaultGradients } from '../themes/slices/gradients';
 import {
   componentBaseline,
   loadComponentsFromVars,
   notifyComponentSavedChanged,
   setSavedComponentBaseline,
   __resetComponentsForTests,
-} from './slices/components';
+} from '../themes/slices/components';
 
 function emptyState(): EditorState {
   return {
@@ -121,7 +121,7 @@ store.set(emptyState());
 
 export {
   DOMAIN_VAR_NAMES,
-} from './slices/domainVars';
+} from '../themes/slices/domainVars';
 
 export {
   columnsToVars,
@@ -129,7 +129,7 @@ export {
   COLUMN_VAR_NAMES,
   DEFAULT_COLUMNS,
   parseColumnVars,
-} from './slices/columns';
+} from '../themes/slices/columns';
 
 export {
   overlaysToVars,
@@ -141,7 +141,7 @@ export {
   parseRgba,
   RGBA_RE,
   HEX_RE,
-} from './slices/overlays';
+} from '../themes/slices/overlays';
 
 export {
   shadowsToVars,
@@ -153,7 +153,7 @@ export {
   defaultShadowOverride,
   parseShadowCss,
   seedShadowsFromDom,
-} from './slices/shadows';
+} from '../themes/slices/shadows';
 
 export {
   gradientsToVars,
@@ -166,7 +166,7 @@ export {
   removeGradientStop,
   addGradientToken,
   removeGradientToken,
-} from './slices/gradients';
+} from '../themes/slices/gradients';
 
 export {
   componentsToVars,
@@ -184,18 +184,18 @@ export {
   unlinkComponentProperty,
   relinkComponentProperty,
   markComponentSaved,
-} from './slices/components';
+} from '../themes/slices/components';
 
 export {
   setFontSources,
   setFontStacks,
   seedFontsFromTheme,
-} from './slices/fonts';
+} from '../themes/slices/fonts';
 
 export {
   setPaletteConfig,
   seedPalettesFromTheme,
-} from './slices/palettes';
+} from '../themes/slices/palettes';
 
 // ── Component-config load orchestration ───────────────────────────────────
 //

package/src/{lib → editor/core/store}/editorTypes.ts

@@ -1,4 +1,4 @@
-import type { PaletteConfig, FontSource, FontStack } from './themeTypes';
+import type { PaletteConfig, FontSource, FontStack } from '../themes/themeTypes';
 
 export interface ShadowGlobals {
   angle: number;

package/src/{lib → editor/core/themes}/slices/columns.ts

@@ -4,7 +4,7 @@
  * the default we leave tokens.css in charge so the `clamp()` in
  * `--columns-gutter` survives until the editor overrides it.
  */
-import type { ColumnsState } from '../editorTypes';
+import type { ColumnsState } from '../../store/editorTypes';
 
 export const DEFAULT_COLUMNS: ColumnsState = { count: 12, maxWidth: 1440, gutter: 16, margin: 0 };
 
@@ -50,7 +50,7 @@ export function parseColumnVars(vars: Record<string, string>): Partial<ColumnsSt
  * single-source. Mutates `next` and `rawVars` in place.
  */
 export function loadColumnsFromVars(
-  next: import('../editorTypes').EditorState,
+  next: import('../../store/editorTypes').EditorState,
   rawVars: Record<string, string>,
 ): void {
   const overrides = parseColumnVars(rawVars);

package/src/{lib → editor/core/themes}/slices/components.ts

@@ -30,8 +30,8 @@
  * pipeline.
  */
 import { writable, derived, get, type Readable } from 'svelte/store';
-import type { CssVarRef, EditorState } from '../editorTypes';
-import { store, mutate } from '../editorCore';
+import type { CssVarRef, EditorState } from '../../store/editorTypes';
+import { store, mutate } from '../../store/editorCore';
 
 const EMPTY_COMPONENT_BASELINE = JSON.stringify({ aliases: {}, config: {} });
 

package/src/{lib → editor/core/themes}/slices/fonts.ts

@@ -6,7 +6,7 @@
  * after mutating.
  */
 import type { FontSource, FontStack } from '../themeTypes';
-import { store, mutate, persist } from '../editorCore';
+import { store, mutate, persist } from '../../store/editorCore';
 
 export function setFontSources(sources: FontSource[]): void {
   mutate('update font sources', (s) => { s.fonts.sources = sources; });

package/src/{lib → editor/core/themes}/slices/gradients.ts

@@ -4,8 +4,8 @@
  * (`--color-brand-500`); the renderer wraps them in `var(...)` so palette
  * edits flow through.
  */
-import type { EditorState, GradientToken, GradientTokenStop, GradientType } from '../editorTypes';
-import { mutate } from '../editorCore';
+import type { EditorState, GradientToken, GradientTokenStop, GradientType } from '../../store/editorTypes';
+import { mutate } from '../../store/editorCore';
 
 export function makeDefaultGradients(): GradientToken[] {
   return [

package/src/{lib → editor/core/themes}/slices/overlays.ts

@@ -4,7 +4,7 @@
  * and diverge from tokens.css by design: the editor starts with a neutral
  * palette and tokens.css continues to win until first edit.
  */
-import type { EditorState, OverlayToken } from '../editorTypes';
+import type { EditorState, OverlayToken } from '../../store/editorTypes';
 
 export function makeDefaultOverlayTokens(): OverlayToken[] {
   return [

package/src/{lib → editor/core/themes}/slices/palettes.ts

@@ -5,7 +5,7 @@
  * (palette derivation involves OKLCH + bezier curves) at render time.
  */
 import type { PaletteConfig } from '../themeTypes';
-import { store, mutate, persist } from '../editorCore';
+import { store, mutate, persist } from '../../store/editorCore';
 
 export function setPaletteConfig(label: string, config: PaletteConfig): void {
   mutate(`update palette ${label}`, (s) => {

package/src/{lib → editor/core/themes}/slices/shadows.ts

@@ -8,8 +8,8 @@
  * x/y/blur/spread/hsla fields.
  */
 import { get } from 'svelte/store';
-import type { EditorState, ShadowToken } from '../editorTypes';
-import { store, persist } from '../editorCore';
+import type { EditorState, ShadowToken } from '../../store/editorTypes';
+import { store, persist } from '../../store/editorCore';
 
 export const SHADOW_VAR_NAMES = [
   '--shadow-sm', '--shadow-md', '--shadow-lg', '--shadow-xl', '--shadow-2xl',
@@ -38,7 +38,7 @@ export function shadowTokenCss(t: ShadowToken): string {
   return `${t.x}px ${t.y}px ${t.blur}px ${t.spread}px hsla(${t.hue}, ${t.saturation}%, ${t.lightness}%, ${t.opacity})`;
 }
 
-export function defaultShadowOverride(): import('../editorTypes').ShadowOverrideFlags {
+export function defaultShadowOverride(): import('../../store/editorTypes').ShadowOverrideFlags {
   return { angle: false, opacity: false, color: false, distance: false, blur: false, size: false };
 }