@pure-ds/core 0.4.37 → 0.5.2

package/src/js/pds.js

@@ -5,7 +5,7 @@
  *
  * This object exposes the core runtime building blocks for the Pure Design System.
  * It intentionally provides a small, stable surface area so consuming apps can:
- * - programmatically generate design system artifacts (via `Generator`),
+ * - programmatically generate design system artifacts (via `getGenerator()` in live mode),
  * - adopt styles into Shadow DOM (via `adoptLayers` / `adoptPrimitives`),
  * - query runtime mode and obtain constructable stylesheets (via `registry`).
  *
@@ -21,14 +21,13 @@
  *   `CSSStyleSheet.replaceSync()` — callers should guard invalid input or wrap calls in try/catch.
  *
  * @typedef {Object} PDSAPI
- * @property {typeof import("./pds-core/pds-generator.js").Generator} Generator - Generator class to produce design system assets
  * @property {import("./pds-core/pds-registry.js").PDSRegistry} registry - Singleton runtime registry for live/static mode
- * @property {any} ontology - Ontology helpers and metadata for components
+ * @property {(generator?: import("./pds-core/pds-generator.js").Generator) => void} applyStyles - Apply generated styles to the document (live-only)
  * @property {(shadowRoot: ShadowRoot, layers?: string[], additionalSheets?: CSSStyleSheet[]) => Promise<void>} adoptLayers - Adopt multiple layers into a ShadowRoot. May log errors and fallback to additionalSheets when static imports fail.
  * @property {(shadowRoot: ShadowRoot, additionalSheets?: CSSStyleSheet[]) => Promise<void>} adoptPrimitives - Adopt primitives layer into a ShadowRoot. Designed as a convenience for components.
  * @property {(css:string) => CSSStyleSheet} createStylesheet - Create a constructable stylesheet from CSS text. @throws {DOMException} on invalid CSS in some browsers.
  * @property {() => boolean} isLiveMode - Returns true when running in live/designer-backed mode
- * @property {(el: Element) => import("./pds-core/pds-ontology.js").ComponentDef | null} findComponentForElement - Helper to find a component definition for a DOM element
+ * @property {() => Promise<typeof import("./pds-core/pds-generator.js").Generator>} getGenerator - Live-only accessor for the Generator class
  */
 
 /**
@@ -45,35 +44,28 @@ PDS.initializing = false;
 PDS.currentPreset = null;
 
 import {
-  Generator,
   adoptLayers,
   adoptPrimitives,
   createStylesheet,
-} from "./pds-core/pds-generator.js";
+} from "./pds-core/pds-runtime.js";
 import { registry } from "./pds-core/pds-registry.js";
-import ontology from "./pds-core/pds-ontology.js";
-import { findComponentForElement } from "./pds-core/pds-ontology.js";
-import { presets, defaultLog } from "./pds-core/pds-config.js";
-import { enums } from "./pds-core/pds-enums.js";
 import { ask } from "./common/ask.js";
 import { toast } from "./common/toast.js";
-import { PDSQuery } from "./pds-core/pds-query.js";
-import * as common from "./common/common.js";
 import { defaultPDSEnhancers } from "./pds-core/pds-enhancers.js";
 import { resolvePublicAssetURL } from "./pds-core/pds-paths.js";
-
-// Font loading utilities
-import { loadTypographyFonts } from "./common/font-loader.js";
-
-/** Generator class — use to programmatically create design system assets from a config */
-PDS.Generator = Generator;
+import {
+  ensureAbsoluteAssetURL,
+  ensureTrailingSlash,
+  normalizeInitConfig,
+  resolveRuntimeAssetRoot,
+  resolveThemeAndApply,
+  setupAutoDefinerAndEnhancers,
+  stripFunctions,
+} from "./pds-core/pds-start-helpers.js";
 
 /** Singleton runtime registry. Use `registry.setLiveMode()` to enable live mode or `registry.setStaticMode()` for static assets */
 PDS.registry = registry;
 
-/** Ontology and metadata about components and tokens */
-PDS.ontology = ontology;
-
 /** Adopt a set of layered stylesheets into a ShadowRoot */
 PDS.adoptLayers = adoptLayers;
 
@@ -83,35 +75,12 @@ PDS.adoptPrimitives = adoptPrimitives;
 /** Create a constructable CSSStyleSheet from a CSS string */
 PDS.createStylesheet = createStylesheet;
 
+
 /** Return true when running inside a live/designer-backed environment */
 PDS.isLiveMode = () => registry.isLive;
-PDS.enums = enums;
-
 PDS.ask = ask;
 PDS.toast = toast;
 
-// Expose common utilities (deepMerge, isObject, etc.)
-PDS.common = common;
-
-// Expose presets object directly
-PDS.presets = presets;
-
-/** Find a component definition (ontology) for a given DOM element */
-PDS.findComponentForElement = findComponentForElement;
-
-/** 
- * Smart query interface for design system questions
- * @param {string} question - Natural language query about tokens, components, utilities, or patterns
- * @returns {Promise<Array>} Array of results with text, value, icon, category, code examples
- * @example
- * const results = await PDS.query("what is the focus border color on inputs?");
- * const results = await PDS.query("how do I create an icon-only button?");
- */
-PDS.query = async function(question) {
-  const queryEngine = new PDSQuery(PDS);
-  return await queryEngine.search(question);
-};
-
 function __emitPDSReady(detail) {
   const hasCustomEvent = typeof CustomEvent === "function";
 
@@ -150,56 +119,12 @@ Object.defineProperty(PDS, "currentConfig", {
   configurable: false,
 });
 
-/** 
- * Compiled design system state - provides structured access to all generated tokens, 
- * layers, and metadata. Available in live mode when a generator is active.
- * Returns the generator's compiled representation or null if not in live mode.
- * 
- * Structure includes:
- * - tokens: All generated token groups (colors, spacing, typography, etc.)
- * - layers: CSS content and metadata for each layer (tokens, primitives, components, utilities)
- * - config: Configuration snapshot used to generate the current state
- * - capabilities: Runtime environment capabilities
- * - references: Links to ontology and enums for introspection
- * - meta: Computed metadata about the design system
- * - helpers: Utility methods to query the compiled state
- */
-Object.defineProperty(PDS, "compiled", {
-  get() {
-    // Only available in live mode when we have a generator
-    if (PDS.registry?.isLive && Generator.instance) {
-      return Generator.instance.compiled;
-    }
-    return null;
-  },
-  enumerable: true,
-  configurable: false,
-});
-
 // Always expose PDS on the window in browser contexts so consumers can access it in both live and static modes
 if (typeof window !== "undefined") {
   // @ts-ignore
   window.PDS = PDS;
 }
 
-// ---------------------------------------------------------------------------
-// FOUC Prevention: Add pds-ready class when PDS is fully initialized in live mode
-// This works in conjunction with CSS injected by the live() function
-if (typeof document !== "undefined") {
-  PDS.addEventListener("pds:ready", (event) => {
-    const mode = event.detail?.mode;
-    if (mode) {
-      // Add mode-specific class (pds-live or pds-static)
-      document.documentElement.classList.add(`pds-${mode}`);
-      
-      // Only add pds-ready class in live mode for FOUC prevention
-      if (mode === "live") {
-        document.documentElement.classList.add("pds-ready");
-      }
-    }
-  });
-}
-
 // ---------------------------------------------------------------------------
 // Theme management (centralized on PDS.theme)
 // Consumers may read/write `PDS.theme` with values: 'system' | 'light' | 'dark'
@@ -313,6 +238,10 @@ Object.defineProperty(PDS, "theme", {
   },
 });
 
+// Internal theme helpers (used by configurator/live tooling)
+PDS._applyResolvedTheme = __applyResolvedTheme;
+PDS._setupSystemListenerIfNeeded = __setupSystemListenerIfNeeded;
+
 // ----------------------------------------------------------------------------
 // Default Enhancers — first-class citizens alongside AutoDefiner
 // ----------------------------------------------------------------------------
@@ -323,264 +252,7 @@ Object.defineProperty(PDS, "theme", {
  */
 PDS.defaultEnhancers = defaultPDSEnhancers;
 
-/**
- * Validate a design configuration for accessibility sanity checks.
- * Currently validates color contrast for primary buttons and base surface text
- * in both light and dark themes.
- *
- * @param {object} designConfig - A full or partial PDS config object
- * @param {object} [options]
- * @param {number} [options.minContrast=4.5] - Minimum contrast ratio for normal text
- * @returns {{ ok: boolean, issues: Array<{path:string, message:string, ratio:number, min:number, context?:string}> }}
- */
-function validateDesign(designConfig = {}, options = {}) {
-  const MIN = Number(options.minContrast || 4.5);
 
-  // Local helpers (keep public; no dependency on private Generator methods)
-  const hexToRgb = (hex) => {
-    const h = String(hex || "").replace("#", "");
-    const full =
-      h.length === 3
-        ? h
-            .split("")
-            .map((c) => c + c)
-            .join("")
-        : h;
-    const num = parseInt(full || "0", 16);
-    return { r: (num >> 16) & 255, g: (num >> 8) & 255, b: num & 255 };
-  };
-  const luminance = (hex) => {
-    const { r, g, b } = hexToRgb(hex);
-    const srgb = [r / 255, g / 255, b / 255].map((v) =>
-      v <= 0.03928 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4)
-    );
-    return 0.2126 * srgb[0] + 0.7152 * srgb[1] + 0.0722 * srgb[2];
-  };
-  const contrast = (a, b) => {
-    if (!a || !b) return 0;
-    const L1 = luminance(a);
-    const L2 = luminance(b);
-    const lighter = Math.max(L1, L2);
-    const darker = Math.min(L1, L2);
-    return (lighter + 0.05) / (darker + 0.05);
-  };
-
-  const issues = [];
-  try {
-    // Build tokens from the candidate config
-    const gen = new PDS.Generator({ design: structuredClone(designConfig) });
-    const c = gen.tokens.colors;
-
-    // Light theme checks - use computed interactive tokens
-    const light = {
-      surfaceBg: c.surface?.base,
-      surfaceText: c.gray?.[900] || "#000000",
-      primaryFill: c.interactive?.light?.fill || c.primary?.[600],
-      primaryText: c.interactive?.light?.text || c.primary?.[600],
-    };
-
-    // Primary button (light): check button fill with white text
-    const lightBtnRatio = contrast(light.primaryFill, "#ffffff");
-    if (lightBtnRatio < MIN) {
-      issues.push({
-        path: "/colors/primary",
-        message: `Primary button contrast too low in light theme (${lightBtnRatio.toFixed(
-          2
-        )} < ${MIN}). Choose a darker primary.`,
-        ratio: lightBtnRatio,
-        min: MIN,
-        context: "light/btn-primary",
-      });
-    }
-
-    // Surface text (light): text vs surface base
-    const lightTextRatio = contrast(light.surfaceBg, light.surfaceText);
-    if (lightTextRatio < MIN) {
-      issues.push({
-        path: "/colors/background",
-        message: `Base text contrast on surface (light) is too low (${lightTextRatio.toFixed(
-          2
-        )} < ${MIN}). Adjust background or secondary (gray).`,
-        ratio: lightTextRatio,
-        min: MIN,
-        context: "light/surface-text",
-      });
-    }
-
-    // Primary text for outline/link: check link text on surface
-    const lightOutlineRatio = contrast(light.primaryText, light.surfaceBg);
-    if (lightOutlineRatio < MIN) {
-      issues.push({
-        path: "/colors/primary",
-        message: `Primary text on surface is too low for outline/link styles (light) (${lightOutlineRatio.toFixed(
-          2
-        )} < ${MIN}). Choose a darker primary or lighter surface.`,
-        ratio: lightOutlineRatio,
-        min: MIN,
-        context: "light/outline",
-      });
-    }
-
-    // Dark theme checks - use computed interactive tokens
-    const d = c.dark;
-    if (d) {
-      const dark = {
-        surfaceBg: d.surface?.base || c.surface?.inverse,
-        primaryFill: c.interactive?.dark?.fill || d.primary?.[600],
-        primaryText: c.interactive?.dark?.text || d.primary?.[600],
-      };
-      
-      // Primary button (dark): check button fill with white text
-      const darkBtnRatio = contrast(dark.primaryFill, "#ffffff");
-      if (darkBtnRatio < MIN) {
-        issues.push({
-          path: "/colors/darkMode/primary",
-          message: `Primary button contrast too low in dark theme (${darkBtnRatio.toFixed(
-            2
-          )} < ${MIN}). Override darkMode.primary or pick a brighter hue.`,
-          ratio: darkBtnRatio,
-          min: MIN,
-          context: "dark/btn-primary",
-        });
-      }
-
-      // Outline/link style in dark: check link text on dark surface
-      const darkOutlineRatio = contrast(dark.primaryText, dark.surfaceBg);
-      if (darkOutlineRatio < MIN) {
-        issues.push({
-          path: "/colors/darkMode/primary",
-          message: `Primary text on surface is too low for outline/link styles (dark) (${darkOutlineRatio.toFixed(
-            2
-          )} < ${MIN}). Override darkMode.primary/background.`,
-          ratio: darkOutlineRatio,
-          min: MIN,
-          context: "dark/outline",
-        });
-      }
-    }
-  } catch (err) {
-    issues.push({
-      path: "/",
-      message: `Validation failed: ${String(err?.message || err)}`,
-      ratio: 0,
-      min: 0,
-    });
-  }
-
-  return { ok: issues.length === 0, issues };
-}
-
-/** Expose validator on the public API */
-PDS.validateDesign = validateDesign;
-
-/**
- * Validate multiple design configurations at once.
- * Useful for build-time enforcement of preset compliance.
- *
- * @param {Array<object>} designs - Array of design configs; items may include an optional `name` property.
- * @param {object} [options] - Options forwarded to validateDesign (e.g., { minContrast })
- * @returns {{ ok: boolean, results: Array<{ name?: string, ok: boolean, issues: Array<{path:string, message:string, ratio:number, min:number, context?:string}> }> }}
- */
-function validateDesigns(designs = [], options = {}) {
-  const results = [];
-
-  const list = Array.isArray(designs)
-    ? designs
-    : designs && typeof designs === "object"
-    ? Object.values(designs)
-    : [];
-
-  for (const item of list) {
-    let name;
-    let configToValidate = null;
-
-    // Accept a few shapes:
-    // - string => treat as preset id/name
-    // - { preset, design?, name? } => resolve preset then merge overrides
-    // - full config object (legacy) => validate directly
-    if (typeof item === "string") {
-      const id = String(item).toLowerCase();
-      const found =
-        presets?.[id] ||
-        Object.values(presets || {}).find(
-          (p) =>
-            __slugify(p.name) === id ||
-            String(p.name || "").toLowerCase() === id
-        );
-      if (!found) {
-        results.push({
-          name: item,
-          ok: false,
-          issues: [
-            {
-              path: "/",
-              message: `Preset not found: ${item}`,
-              ratio: 0,
-              min: 0,
-            },
-          ],
-        });
-        continue;
-      }
-      name = found.name || id;
-      configToValidate = structuredClone(found);
-    } else if (item && typeof item === "object") {
-      name = item.name || item.preset || undefined;
-      if ("preset" in item || "design" in item) {
-        const effectivePreset = String(item.preset || "default").toLowerCase();
-        const found =
-          presets?.[effectivePreset] ||
-          Object.values(presets || {}).find(
-            (p) =>
-              __slugify(p.name) === effectivePreset ||
-              String(p.name || "").toLowerCase() === effectivePreset
-          );
-        if (!found) {
-          results.push({
-            name,
-            ok: false,
-            issues: [
-              {
-                path: "/",
-                message: `Preset not found: ${item.preset}`,
-                ratio: 0,
-                min: 0,
-              },
-            ],
-          });
-          continue;
-        }
-        let base = structuredClone(found);
-        if (item.design && typeof item.design === "object") {
-          base = __deepMerge(base, structuredClone(item.design));
-        }
-        configToValidate = base;
-      } else {
-        // Assume a full config object
-        configToValidate = item;
-      }
-    }
-
-    if (!configToValidate) {
-      results.push({
-        name,
-        ok: false,
-        issues: [
-          { path: "/", message: "Invalid design entry", ratio: 0, min: 0 },
-        ],
-      });
-      continue;
-    }
-
-    const { ok, issues } = validateDesign(configToValidate, options);
-    results.push({ name, ok, issues });
-  }
-
-  return { ok: results.every((r) => r.ok), results };
-}
-
-/** Expose batch validator on the public API */
-PDS.validateDesigns = validateDesigns;
 
 /**
  * Initialize PDS in live mode with the given configuration (new unified shape).
@@ -615,677 +287,6 @@ PDS.validateDesigns = validateDesigns;
  *   autoDefine: { predefine: ['pds-icon'] }
  * });
  */
-// Internal: resolve theme and set html[data-theme], return resolvedTheme and storedTheme
-function __resolveThemeAndApply({ manageTheme, themeStorageKey }) {
-  let resolvedTheme = "light";
-  let storedTheme = null;
-  if (manageTheme && typeof window !== "undefined") {
-    // Read raw preference (may be null, 'system', 'light', 'dark') using provided storage key
-    try {
-      storedTheme = localStorage.getItem(themeStorageKey) || null;
-    } catch (e) {
-      storedTheme = null;
-    }
-
-    // Apply the resolved theme and ensure system listener exists when needed
-    try {
-      __applyResolvedTheme(storedTheme);
-      __setupSystemListenerIfNeeded(storedTheme);
-    } catch (e) {}
-
-    // Compute explicit resolvedTheme to return
-    if (storedTheme) {
-      if (storedTheme === "system") {
-        const prefersDark =
-          window.matchMedia &&
-          window.matchMedia("(prefers-color-scheme: dark)").matches;
-        resolvedTheme = prefersDark ? "dark" : "light";
-      } else {
-        resolvedTheme = storedTheme;
-      }
-    } else {
-      const prefersDark =
-        window.matchMedia &&
-        window.matchMedia("(prefers-color-scheme: dark)").matches;
-      resolvedTheme = prefersDark ? "dark" : "light";
-    }
-  }
-  return { resolvedTheme, storedTheme };
-}
-
-// Internal: deep merge utility (arrays replace; objects merge)
-function __deepMerge(target = {}, source = {}) {
-  if (!source || typeof source !== "object") return target;
-  const out = Array.isArray(target) ? [...target] : { ...target };
-  for (const [key, value] of Object.entries(source)) {
-    if (value && typeof value === "object" && !Array.isArray(value)) {
-      out[key] = __deepMerge(
-        out[key] && typeof out[key] === "object" ? out[key] : {},
-        value
-      );
-    } else {
-      out[key] = value;
-    }
-  }
-  return out;
-}
-
-// Internal: create a slug for matching names like "Paper & Ink" -> "paper-and-ink"
-function __slugify(str = "") {
-  return String(str)
-    .toLowerCase()
-    .replace(/&/g, " and ")
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "");
-}
-
-// Internal: recursively remove functions from an object to make it cloneable
-function __stripFunctions(obj) {
-  if (obj === null || obj === undefined) return obj;
-  if (typeof obj === "function") return undefined;
-  if (typeof obj !== "object") return obj;
-  
-  if (Array.isArray(obj)) {
-    return obj.map(item => __stripFunctions(item)).filter(item => item !== undefined);
-  }
-  
-  const result = {};
-  for (const key in obj) {
-    if (obj.hasOwnProperty(key)) {
-      const value = obj[key];
-      if (typeof value !== "function") {
-        const stripped = __stripFunctions(value);
-        if (stripped !== undefined) {
-          result[key] = stripped;
-        }
-      }
-    }
-  }
-  return result;
-}
-
-const __ABSOLUTE_URL_PATTERN__ = /^[a-z][a-z0-9+\-.]*:\/\//i;
-const __MODULE_URL__ = (() => {
-  try {
-    return import.meta.url;
-  } catch (e) {
-    return undefined;
-  }
-})();
-
-function __ensureAbsoluteAssetURL(value, options = {}) {
-  if (!value || __ABSOLUTE_URL_PATTERN__.test(value)) {
-    return value;
-  }
-
-  const { preferModule = true } = options;
-
-  const tryModule = () => {
-    if (!__MODULE_URL__) return null;
-    try {
-      return new URL(value, __MODULE_URL__).href;
-    } catch (e) {
-      return null;
-    }
-  };
-
-  const tryWindow = () => {
-    if (typeof window === "undefined" || !window.location?.origin) {
-      return null;
-    }
-    try {
-      return new URL(value, window.location.origin).href;
-    } catch (e) {
-      return null;
-    }
-  };
-
-  const resolved = preferModule
-    ? tryModule() || tryWindow()
-    : tryWindow() || tryModule();
-
-  return resolved || value;
-}
-
-const __ensureTrailingSlash = (value) =>
-  typeof value === "string" && value.length && !value.endsWith("/")
-    ? `${value}/`
-    : value;
-
-const __MODULE_DEFAULT_ASSET_ROOT__ = (() => {
-  if (!__MODULE_URL__) return undefined;
-  try {
-    const parsed = new URL(__MODULE_URL__);
-    if (/\/public\/assets\/js\//.test(parsed.pathname)) {
-      return new URL("../pds/", __MODULE_URL__).href;
-    }
-  } catch (e) {
-    return undefined;
-  }
-  return undefined;
-})();
-
-function __resolveRuntimeAssetRoot(config) {
-  const hasCustomRoot = Boolean(config?.public?.root || config?.static?.root);
-  let candidate = resolvePublicAssetURL(config);
-
-  if (!hasCustomRoot && __MODULE_DEFAULT_ASSET_ROOT__) {
-    candidate = __MODULE_DEFAULT_ASSET_ROOT__;
-  }
-
-  return __ensureTrailingSlash(__ensureAbsoluteAssetURL(candidate));
-}
-
-// Internal: normalize first-arg config to a full generator config and extract enhancers if provided inline
-function __normalizeInitConfig(inputConfig = {}, options = {}) {
-  // If caller passed a plain design config (legacy), keep as-is
-  const hasDesignKeys =
-    typeof inputConfig === "object" &&
-    ("colors" in inputConfig ||
-      "typography" in inputConfig ||
-      "spatialRhythm" in inputConfig ||
-      "shape" in inputConfig ||
-      "behavior" in inputConfig ||
-      "layout" in inputConfig ||
-      "advanced" in inputConfig ||
-      "a11y" in inputConfig ||
-      "components" in inputConfig ||
-      "icons" in inputConfig);
-
-  // Extract potential inline enhancers from config; prefer inline over options
-  let inlineEnhancers = inputConfig && inputConfig.enhancers;
-  if (inlineEnhancers && !Array.isArray(inlineEnhancers)) {
-    // If an object was provided, convert to array of values
-    inlineEnhancers = Object.values(inlineEnhancers);
-  }
-  const enhancers = inlineEnhancers ?? options.enhancers ?? [];
-
-  // New API: { preset?: string, design?: object }
-  const presetId = inputConfig && inputConfig.preset;
-  const designOverrides = inputConfig && inputConfig.design;
-
-  const hasNewShape =
-    "preset" in (inputConfig || {}) ||
-    "design" in (inputConfig || {}) ||
-    "enhancers" in (inputConfig || {});
-
-  let generatorConfig;
-  let presetInfo = null;
-
-  if (hasNewShape) {
-    // Always resolve a preset; default if none provided
-    const effectivePreset = String(presetId || "default").toLowerCase();
-    const found =
-      presets?.[effectivePreset] ||
-      Object.values(presets || {}).find(
-        (p) =>
-          __slugify(p.name) === effectivePreset ||
-          String(p.name || "").toLowerCase() === effectivePreset
-      );
-    if (!found)
-      throw new Error(`PDS preset not found: "${presetId || "default"}"`);
-
-    presetInfo = {
-      id: found.id || __slugify(found.name),
-      name: found.name || found.id || String(effectivePreset),
-    };
-
-    // Merge preset with design overrides
-    let mergedDesign = structuredClone(found);
-    if (designOverrides && typeof designOverrides === "object") {
-      // Strip functions before cloning to avoid DataCloneError
-      const cloneableDesign = __stripFunctions(designOverrides);
-      mergedDesign = __deepMerge(mergedDesign, structuredClone(cloneableDesign));
-    }
-    
-    // Build structured config with design nested
-    // Exclude runtime-specific properties that shouldn't be passed to Generator
-    const { 
-      mode, autoDefine, applyGlobalStyles, manageTheme, 
-      themeStorageKey, preloadStyles, criticalLayers, 
-      preset: _preset, design: _design, enhancers: _enhancers,
-      log: userLog,  // Extract log if provided at root
-      ...otherProps 
-    } = inputConfig;
-    
-    generatorConfig = {
-      ...otherProps, // Keep only generator-relevant properties
-      design: mergedDesign,
-      preset: presetInfo.name,
-      // Add log method at root level (use user's or default)
-      log: userLog || defaultLog,
-    };
-  } else if (hasDesignKeys) {
-    // Back-compat: treat the provided object as the full design, wrap it
-    // Extract log before cloning to avoid DataCloneError
-    const { log: userLog, ...designConfig } = inputConfig;
-    generatorConfig = {
-      design: structuredClone(designConfig),
-      log: userLog || defaultLog,
-    };
-  } else {
-    // Nothing recognizable: use default preset
-    const foundDefault =
-      presets?.["default"] ||
-      Object.values(presets || {}).find((p) => __slugify(p.name) === "default");
-    if (!foundDefault) throw new Error("PDS default preset not available");
-    presetInfo = {
-      id: foundDefault.id || "default",
-      name: foundDefault.name || "Default",
-    };
-    generatorConfig = {
-      design: structuredClone(foundDefault),
-      preset: presetInfo.name,
-      log: defaultLog,
-    };
-  }
-
-  return { generatorConfig, enhancers, presetInfo };
-}
-
-// Internal: setup AutoDefiner and run enhancers
-async function __setupAutoDefinerAndEnhancers(options) {
-  const {
-    autoDefineBaseURL = "/auto-define/",
-    autoDefinePreload = [],
-    autoDefineMapper = null,
-    enhancers = [],
-    // New: raw overrides for AutoDefiner config (scanExisting, observeShadows, etc.)
-    autoDefineOverrides = null,
-    autoDefinePreferModule = true,
-  } = options;
-
-  // // Warn if assets not present (best-effort)
-  // try {
-  //   if (typeof window !== "undefined") {
-  //     const response = await fetch(`${autoDefineBaseURL}pds-icon.js`, {
-  //       method: "HEAD",
-  //     });
-  //     if (!response.ok) {
-  //       // No config available in this context, using console
-  //       console.warn("⚠️ PDS components not found in auto-define directory.");
-  //     }
-  //   }
-  // } catch {}
-
-  // Merge defaults with user enhancers (user overrides by selector)
-  const mergedEnhancers = (() => {
-    const map = new Map();
-    (PDS.defaultEnhancers || []).forEach((e) => map.set(e.selector, e));
-    (enhancers || []).forEach((e) => map.set(e.selector, e));
-    return Array.from(map.values());
-  })();
-
-  // Setup AutoDefiner in browser context (it already observes shadow DOMs)
-  let autoDefiner = null;
-  if (typeof window !== "undefined" && typeof document !== "undefined") {
-    // Dynamically import AutoDefiner to avoid Node/CJS interop at build time
-    let AutoDefinerCtor = null;
-    try {
-      const mod = await import("pure-web/auto-definer");
-      AutoDefinerCtor =
-        mod?.AutoDefiner || mod?.default?.AutoDefiner || mod?.default || null;
-    } catch (e) {
-      // No config available in this context, using console
-      console.warn("AutoDefiner not available:", e?.message || e);
-    }
-
-    const defaultMapper = (tag) => {
-      switch (tag) {
-        case "pds-tabpanel":
-          return "pds-tabstrip.js";
-        default:
-          return `${tag}.js`;
-      }
-    };
-
-    // Respect user overrides but never allow them to overwrite our mapper wrapper.
-    const { mapper: _overrideMapperIgnored, ...restAutoDefineOverrides } =
-      autoDefineOverrides && typeof autoDefineOverrides === "object"
-        ? autoDefineOverrides
-        : {};
-
-    const normalizedBaseURL = autoDefineBaseURL
-      ? __ensureTrailingSlash(
-          __ensureAbsoluteAssetURL(autoDefineBaseURL, {
-            preferModule: autoDefinePreferModule,
-          })
-        )
-      : autoDefineBaseURL;
-
-    const autoDefineConfig = {
-      baseURL: normalizedBaseURL,
-      predefine: autoDefinePreload,
-      scanExisting: true,
-      observeShadows: true,
-      patchAttachShadow: true,
-      debounceMs: 16,
-      enhancers: mergedEnhancers,
-      onError: (tag, err) => {
-        if (typeof tag === "string" && tag.startsWith("pds-")) {
-          // Check if this is a Lit-dependent component with missing #pds/lit import map
-          const litDependentComponents = ['pds-form', 'pds-drawer'];
-          const isLitComponent = litDependentComponents.includes(tag);
-          const isMissingLitError = err?.message?.includes('#pds/lit') || 
-                                     err?.message?.includes('Failed to resolve module specifier');
-          
-          if (isLitComponent && isMissingLitError) {
-            console.error(
-              `❌ PDS component <${tag}> requires Lit but #pds/lit is not in import map.\n` +
-              `Add this to your HTML <head>:\n` +
-              `<script type="importmap">\n` +
-              `  { "imports": { "#pds/lit": "./path/to/lit.js" } }\n` +
-              `</script>\n` +
-              `See: https://github.com/pure-ds/core#lit-components`
-            );
-          } else {
-            // Generic component not found warning
-            console.warn(
-              `⚠️ PDS component <${tag}> not found. Assets may not be installed.`
-            );
-          }
-        } else {
-          console.error(`❌ Auto-define error for <${tag}>:`, err);
-        }
-      },
-      // Apply all user overrides except mapper so we can still wrap it
-      ...restAutoDefineOverrides,
-      mapper: (tag) => {
-        // If already defined, do nothing
-        if (customElements.get(tag)) return null;
-
-        // If a custom mapper exists, let it try first; if it returns a non-value, fallback to default
-        if (typeof autoDefineMapper === "function") {
-          try {
-            const mapped = autoDefineMapper(tag);
-            if (mapped === undefined) {
-              return defaultMapper(tag);
-            }
-            return mapped;
-          } catch (e) {
-            // Be resilient: if custom mapper throws, fall back to default
-            console.warn(
-              "Custom autoDefine.mapper error; falling back to default:",
-              e?.message || e
-            );
-            return defaultMapper(tag);
-          }
-        }
-
-        // No custom mapper provided — use default
-        return defaultMapper(tag);
-      },
-    };
-
-    if (AutoDefinerCtor) {
-      autoDefiner = new AutoDefinerCtor(autoDefineConfig);
-      if (
-        autoDefinePreload.length > 0 &&
-        typeof AutoDefinerCtor.define === "function"
-      ) {
-        await AutoDefinerCtor.define(...autoDefinePreload, {
-          baseURL: autoDefineBaseURL,
-          mapper: autoDefineConfig.mapper,
-          onError: autoDefineConfig.onError,
-        });
-      }
-    }
-  }
-  // Rely on AutoDefiner to run enhancers across light and shadow DOMs
-
-  return { autoDefiner, mergedEnhancers };
-}
-
-async function live(config) {
-  if (!config || typeof config !== "object") {
-    throw new Error(
-      "PDS.start({ mode: 'live', ... }) requires a valid configuration object"
-    );
-  }
-
-  // FOUC Prevention: Use constructable stylesheet for synchronous, immediate effect
-  if (typeof document !== "undefined" && document.adoptedStyleSheets) {
-    const css = /*css*/`
-          html { opacity: 0; }
-          html.pds-ready { opacity: 1; transition: opacity 0.3s ease-in; }
-        `
-    try {
-      // Check if we've already added the FOUC prevention sheet
-      const hasFoucSheet = document.adoptedStyleSheets.some(sheet => sheet._pdsFouc);
-      if (!hasFoucSheet) {
-        const foucSheet = new CSSStyleSheet();
-        foucSheet.replaceSync(css);
-        foucSheet._pdsFouc = true;
-        document.adoptedStyleSheets = [foucSheet, ...document.adoptedStyleSheets];
-      }
-    } catch (e) {
-      // Fallback for browsers that don't support constructable stylesheets
-      // No config available here, using console
-      console.warn("Constructable stylesheets not supported, using <style> tag fallback:", e);
-      const existingFoucStyle = document.head.querySelector("style[data-pds-fouc]");
-      if (!existingFoucStyle) {
-        const foucStyle = document.createElement("style");
-        foucStyle.setAttribute("data-pds-fouc", "");
-        foucStyle.textContent = css;
-        document.head.insertBefore(foucStyle, document.head.firstChild);
-      }
-    }
-  }
-
-  // PDS is exposed on window at module init for both modes
-
-  // Extract runtime flags directly from unified config
-  let applyGlobalStyles = config.applyGlobalStyles ?? true;
-  let manageTheme = config.manageTheme ?? true;
-  let themeStorageKey = config.themeStorageKey ?? "pure-ds-theme";
-  let preloadStyles = config.preloadStyles ?? false;
-  let criticalLayers = config.criticalLayers ?? ["tokens", "primitives"];
-
-  // New unified shape: autoDefine inside the first argument
-  const cfgAuto = (config && config.autoDefine) || null;
-  if (cfgAuto && typeof cfgAuto === "object") {
-    // no-op here; resolved below for __setupAutoDefinerAndEnhancers
-  }
-
-  try {
-    // 1) Handle theme preference
-    const { resolvedTheme, storedTheme } = __resolveThemeAndApply({
-      manageTheme,
-      themeStorageKey,
-    });
-
-    // 2) Normalize first-arg API: support { preset, design, enhancers }
-    const normalized = __normalizeInitConfig(config, {});
-    const userEnhancers = normalized.enhancers;
-    // Extract log function before cloning to avoid DataCloneError
-    const { log: logFn, ...configToClone } = normalized.generatorConfig;
-    const generatorConfig = structuredClone(configToClone);
-    // Add log back after cloning
-    generatorConfig.log = logFn;
-    if (manageTheme) {
-      generatorConfig.theme = resolvedTheme;
-    }
-
-    const generator = new PDS.Generator(generatorConfig);
-
-    // 3) Load fonts from Google Fonts if needed (before applying styles)
-    if (generatorConfig.design?.typography) {
-      try {
-        await loadTypographyFonts(generatorConfig.design.typography);
-      } catch (ex) {
-        generatorConfig?.log?.("warn", "Failed to load some fonts from Google Fonts:", ex);
-        // Continue anyway - the system will fall back to default fonts
-      }
-    }
-
-    // 4) Preload critical styles synchronously to prevent flash
-    if (preloadStyles && typeof window !== "undefined" && document.head) {
-      try {
-        // Generate critical CSS layers synchronously
-        const criticalCSS = criticalLayers
-          .map((layer) => {
-            try {
-              return generator.css?.[layer] || "";
-            } catch (e) {
-              generatorConfig?.log?.(
-                "warn",
-                `Failed to generate critical CSS for layer "${layer}":`,
-                e
-              );
-              return "";
-            }
-          })
-          .filter((css) => css.trim())
-          .join("\n");
-
-        if (criticalCSS) {
-          // Remove any existing PDS critical styles
-          const existingCritical = document.head.querySelector(
-            "style[data-pds-critical]"
-          );
-          if (existingCritical) {
-            existingCritical.remove();
-          }
-
-          // Inject critical CSS as a <style> tag in head
-          const styleEl = document.createElement("style");
-          styleEl.setAttribute("data-pds-critical", "");
-          styleEl.textContent = criticalCSS;
-
-          // Insert early in head, but after charset/viewport if present
-          const insertAfter = document.head.querySelector(
-            'meta[charset], meta[name="viewport"]'
-          );
-          if (insertAfter) {
-            insertAfter.parentNode.insertBefore(
-              styleEl,
-              insertAfter.nextSibling
-            );
-          } else {
-            document.head.insertBefore(styleEl, document.head.firstChild);
-          }
-        }
-      } catch (error) {
-        generatorConfig?.log?.("warn", "Failed to preload critical styles:", error);
-        // Continue without critical styles - better than crashing
-      }
-    }
-
-    // Set the registry to live mode
-    PDS.registry.setLiveMode();
-
-    // Log preset info if available
-    if (normalized.presetInfo?.name) {
-      generatorConfig?.log?.("log", `PDS live with preset "${normalized.presetInfo.name}"`);
-    } else {
-      generatorConfig?.log?.("log", "PDS live with custom config");
-    }
-
-    // Apply styles globally if requested (default behavior)
-    if (applyGlobalStyles) {
-      await PDS.Generator.applyStyles();
-
-      // Clean up critical styles after adoptedStyleSheets are applied
-      if (typeof window !== "undefined") {
-        // Small delay to ensure adoptedStyleSheets have taken effect
-        setTimeout(() => {
-          // Remove any previously inlined critical/preload styles that were unlayered
-          const criticalStyle = document.head.querySelector(
-            "style[data-pds-critical]"
-          );
-          if (criticalStyle) criticalStyle.remove();
-
-          const preloadStyle = document.head.querySelector(
-            "style[data-pds-preload]"
-          );
-          if (preloadStyle) preloadStyle.remove();
-
-          // Remove legacy fallback runtime style tag if present
-          const legacyRuntime = document.getElementById(
-            "pds-runtime-stylesheet"
-          );
-          if (legacyRuntime) legacyRuntime.remove();
-        }, 100);
-      }
-    }
-
-    // Note: auto-define base URL is used internally; no globals are written
-
-    // Derive a sensible default AutoDefiner base for LIVE mode too when not provided.
-    // Use the normalized public asset root so live and static modes share the same directory layout.
-    const assetRootURL = __resolveRuntimeAssetRoot(config);
-
-    let derivedAutoDefineBaseURL;
-    if (cfgAuto && cfgAuto.baseURL) {
-      derivedAutoDefineBaseURL = __ensureTrailingSlash(
-        __ensureAbsoluteAssetURL(cfgAuto.baseURL, { preferModule: false })
-      );
-    } else {
-      derivedAutoDefineBaseURL = `${assetRootURL}components/`;
-    }
-
-    // 5) Set up AutoDefiner + run enhancers (defaults merged with user)
-    let autoDefiner = null;
-    let mergedEnhancers = [];
-    try {
-      const res = await __setupAutoDefinerAndEnhancers({
-        autoDefineBaseURL: derivedAutoDefineBaseURL,
-        autoDefinePreload:
-          (cfgAuto && Array.isArray(cfgAuto.predefine) && cfgAuto.predefine) ||
-          [],
-        autoDefineMapper:
-          (cfgAuto && typeof cfgAuto.mapper === "function" && cfgAuto.mapper) ||
-          null,
-        enhancers: userEnhancers,
-        autoDefineOverrides: cfgAuto || null,
-        autoDefinePreferModule: !(cfgAuto && cfgAuto.baseURL),
-      });
-      autoDefiner = res.autoDefiner;
-      mergedEnhancers = res.mergedEnhancers || [];
-    } catch (error) {
-      generatorConfig?.log?.("error", "❌ Failed to initialize AutoDefiner/Enhancers:", error);
-    }
-
-    // Determine resolved config to expose (generator stores input as options)
-    const resolvedConfig = generator?.options || generatorConfig;
-
-    // Expose current config as frozen read-only on PDS, preserving input shape
-    // Strip functions before cloning to avoid DataCloneError
-    const cloneableConfig = __stripFunctions(config);
-    PDS.currentConfig = Object.freeze({
-      mode: "live",
-      ...structuredClone(cloneableConfig),
-      design: structuredClone(normalized.generatorConfig.design),
-      preset: normalized.generatorConfig.preset,
-      theme: resolvedTheme,
-      enhancers: mergedEnhancers,
-    });
-
-    // Emit event to notify that PDS is ready (unified)
-    __emitPDSReady({
-      mode: "live",
-      generator,
-      config: resolvedConfig,
-      theme: resolvedTheme,
-      autoDefiner,
-    });
-
-    return {
-      generator,
-      config: resolvedConfig,
-      theme: resolvedTheme,
-      autoDefiner,
-    };
-  } catch (error) {
-    // Emit error event
-    PDS.dispatchEvent(
-      new CustomEvent("pds:error", {
-        detail: { error },
-      })
-    );
-    throw error;
-  }
-}
 
 /**
  * Start PDS given a unified configuration and an explicit mode.
@@ -1298,7 +299,19 @@ async function start(config) {
   const mode = (config && config.mode) || "live";
   const { mode: _omit, ...rest } = config || {};
   if (mode === "static") return staticInit(rest);
-  return live(rest);
+  const assetRootURL = resolveRuntimeAssetRoot(rest, { resolvePublicAssetURL });
+  const managerUrl =
+    rest?.managerURL ||
+    rest?.public?.managerURL ||
+    rest?.manager?.url ||
+    new URL("core/pds-manager.js", assetRootURL).href ||
+    new URL("./pds-manager.js", import.meta.url).href;
+  const { startLive } = await import(managerUrl);
+  return startLive(PDS, rest, {
+    emitReady: __emitPDSReady,
+    applyResolvedTheme: __applyResolvedTheme,
+    setupSystemListenerIfNeeded: __setupSystemListenerIfNeeded,
+  });
 }
 
 /** Primary unified entry point */
@@ -1337,12 +350,12 @@ async function staticInit(config) {
   const manageTheme = config.manageTheme ?? true;
   const themeStorageKey = config.themeStorageKey ?? "pure-ds-theme";
   let staticPaths = config.staticPaths ?? {};
-  const assetRootURL = __resolveRuntimeAssetRoot(config);
+  const assetRootURL = resolveRuntimeAssetRoot(config, { resolvePublicAssetURL });
   const cfgAuto = (config && config.autoDefine) || null;
   let autoDefineBaseURL;
   if (cfgAuto && cfgAuto.baseURL) {
-    autoDefineBaseURL = __ensureTrailingSlash(
-      __ensureAbsoluteAssetURL(cfgAuto.baseURL, { preferModule: false })
+    autoDefineBaseURL = ensureTrailingSlash(
+      ensureAbsoluteAssetURL(cfgAuto.baseURL, { preferModule: false })
     );
   } else {
     autoDefineBaseURL = `${assetRootURL}components/`;
@@ -1354,13 +367,16 @@ async function staticInit(config) {
 
   try {
     // 1) Theme
-    const { resolvedTheme } = __resolveThemeAndApply({
+    const { resolvedTheme } = resolveThemeAndApply({
       manageTheme,
       themeStorageKey,
+      applyResolvedTheme: __applyResolvedTheme,
+      setupSystemListenerIfNeeded: __setupSystemListenerIfNeeded,
     });
 
     // Normalize first-arg to allow { preset, design, enhancers }
-    const normalized = __normalizeInitConfig(config, {});
+    const { presets, defaultLog } = await import("./pds-core/pds-config.js");
+    const normalized = normalizeInitConfig(config, {}, { presets, defaultLog });
     const userEnhancers = normalized.enhancers;
 
     // 2) Derive static asset URLs from the normalized public root
@@ -1399,14 +415,14 @@ async function staticInit(config) {
     let autoDefiner = null;
     let mergedEnhancers = [];
     try {
-      const res = await __setupAutoDefinerAndEnhancers({
+      const res = await setupAutoDefinerAndEnhancers({
         autoDefineBaseURL,
         autoDefinePreload,
         autoDefineMapper,
         enhancers: userEnhancers,
         autoDefineOverrides: cfgAuto || null,
         autoDefinePreferModule: !(cfgAuto && cfgAuto.baseURL),
-      });
+      }, { baseEnhancers: defaultPDSEnhancers });
       autoDefiner = res.autoDefiner;
       mergedEnhancers = res.mergedEnhancers || [];
     } catch (error) {
@@ -1419,7 +435,7 @@ async function staticInit(config) {
 
     // Expose current config as frozen read-only on PDS, preserving input shape
     // Strip functions before cloning to avoid DataCloneError
-    const cloneableConfig = __stripFunctions(config);
+    const cloneableConfig = stripFunctions(config);
     PDS.currentConfig = Object.freeze({
       mode: "static",
       ...structuredClone(cloneableConfig),
@@ -1449,163 +465,8 @@ async function staticInit(config) {
 
 // Note: PDS.static is not exported. Use PDS.start({ mode: 'static', ... }).
 
-/**
- * Change the current theme programmatically.
- * This updates localStorage, the data-theme attribute, and regenerates styles if in live mode.
- *
- * @param {string} theme - Theme to apply: 'light', 'dark', or 'system'
- * @param {object} [options] - Optional settings
- * @param {string} [options.storageKey='pure-ds-theme'] - localStorage key for theme preference
- * @param {boolean} [options.persist=true] - Whether to save to localStorage
- * @returns {Promise<string>} The resolved theme ('light' or 'dark')
- */
-async function setTheme(theme, options = {}) {
-  const { storageKey = "pure-ds-theme", persist = true } = options;
-
-  if (!["light", "dark", "system"].includes(theme)) {
-    throw new Error(
-      `Invalid theme "${theme}". Must be "light", "dark", or "system".`
-    );
-  }
-
-  if (typeof window === "undefined") {
-    return theme === "system" ? "light" : theme;
-  }
-
-  let resolvedTheme = theme;
-
-  // Resolve 'system' to actual preference
-  if (theme === "system") {
-    const prefersDark =
-      window.matchMedia &&
-      window.matchMedia("(prefers-color-scheme: dark)").matches;
-    resolvedTheme = prefersDark ? "dark" : "light";
-  }
-
-  // Update data-theme attribute
-  document.documentElement.setAttribute("data-theme", resolvedTheme);
-
-  // Persist to localStorage if requested
-  if (persist) {
-    localStorage.setItem(storageKey, theme);
-  }
-
-  // If we're in live mode, regenerate styles with new theme
-  if (PDS.registry.isLive && Generator.instance) {
-    try {
-      const currentGenerator = Generator.instance;
-      if (currentGenerator && currentGenerator.configure) {
-        // Update the generator's config with new theme
-        const newConfig = { ...currentGenerator.config, theme: resolvedTheme };
-        currentGenerator.configure(newConfig);
-
-        // Reapply styles
-        await PDS.Generator.applyStyles();
-      }
-    } catch (error) {
-      console.warn("Failed to update styles for new theme:", error);
-    }
-  }
-
-  // Emit theme change event (unified)
-  PDS.dispatchEvent(
-    new CustomEvent("pds:theme:changed", {
-      detail: {
-        theme: resolvedTheme,
-        requested: theme,
-        source: "programmatic",
-      },
-    })
-  );
-
-  return resolvedTheme;
-}
-
-/** Change the current theme programmatically */
-PDS.setTheme = setTheme;
-
-/**
- * Preload minimal CSS to prevent flash of unstyled content.
- * Call this BEFORE any DOM content is rendered for best results.
- * This is a lightweight alternative to full PDS.start({ mode: 'live' }) initialization.
- *
- * @param {object} config - Minimal PDS config (colors at minimum)
- * @param {object} [options] - Optional settings
- * @param {string} [options.theme] - Theme to generate for ('light', 'dark', or 'system')
- * @param {string[]} [options.layers=['tokens']] - Which CSS layers to preload
- * @returns {void}
- *
- * @example
- * ```html
- * <script type="module">
- *   import { PDS } from 'pure-ds/pds-core';
- *   // Call immediately to prevent flash
- *   PDS.preloadCritical({ colors: { primary: '#007acc' } });
- * </script>
- * ```
- */
-function preloadCritical(config, options = {}) {
-  if (typeof window === "undefined" || !document.head || !config) {
-    return;
-  }
-
-  const { theme, layers = ["tokens"] } = options;
-
-  try {
-    // Resolve theme quickly
-    let resolvedTheme = theme || "light";
-    if (theme === "system" || !theme) {
-      const prefersDark =
-        window.matchMedia &&
-        window.matchMedia("(prefers-color-scheme: dark)").matches;
-      resolvedTheme = prefersDark ? "dark" : "light";
-    }
-
-    // Set theme attribute immediately
-    document.documentElement.setAttribute("data-theme", resolvedTheme);
-
-    // Generate minimal CSS synchronously
-    // Normalize config to ensure design property exists
-    const tempConfig = config.design 
-      ? { ...config, theme: resolvedTheme }
-      : { design: config, theme: resolvedTheme };
-    const tempGenerator = new PDS.Generator(tempConfig);
-
-    const criticalCSS = layers
-      .map((layer) => {
-        try {
-          return tempGenerator.css?.[layer] || "";
-        } catch (e) {
-          return "";
-        }
-      })
-      .filter((css) => css.trim())
-      .join("\n");
-
-    if (criticalCSS) {
-      // Remove any existing critical styles
-      const existing = document.head.querySelector("style[data-pds-preload]");
-      if (existing) existing.remove();
-
-      // Inject immediately
-      const styleEl = document.createElement("style");
-      styleEl.setAttribute("data-pds-preload", "");
-      styleEl.textContent = criticalCSS;
-
-      // Insert as early as possible
-      document.head.insertBefore(styleEl, document.head.firstChild);
-    }
-  } catch (error) {
-    // Fail silently - better than blocking page load
-    // No config available in this context, using console
-    console.warn("PDS preload failed:", error);
-  }
-}
-
-/** Preload minimal CSS to prevent flash of unstyled content */
-PDS.preloadCritical = preloadCritical;
 
 // Note: PDS object is not frozen to allow runtime properties like currentConfig
 // to be set during initialization. The config object itself is frozen for immutability.
 
-export { PDS, validateDesign };
+export { PDS };