@pure-ds/core 0.7.30 → 0.7.33

package/src/js/common/msg.js

@@ -0,0 +1,9 @@
+export {
+  msg,
+  str,
+  joinStringsAndValues,
+  configureLocalization,
+  loadLocale,
+  setLocale,
+  getLocalizationState,
+} from "./localization.js";

package/src/js/common/pds-core/pds.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Runtime registry singleton that controls live vs static behavior.
+ * Consumers can call `registry.setDesigner(designer)` to enable live mode
+ * or `registry.setStaticMode(paths)` to point to static asset modules.
+ */
+export interface PDSRegistry {
+  /** Attach a designer instance and switch the registry to live mode. */
+  setDesigner(designer: any, meta?: { presetName?: string }): void;
+  /** Switch to static mode and override static paths (keys: tokens, primitives, components, utilities, styles) */
+  setStaticMode(paths?: Record<string, string>): void;
+  /** Return a constructable stylesheet for the requested layer or null on failure. */
+  getStylesheet(layer: string): Promise<CSSStyleSheet | null>;
+  /** Return a BLOB URL (live mode only) for layer imports used in CSS */
+  getBlobURL(layer: string): string | null;
+  /** 'live' or 'static' */
+  readonly mode: string;
+  /** true when a live designer instance is registered */
+  readonly isLive: boolean;
+  /** true when a designer instance exists */
+  readonly hasDesigner: boolean;
+}
+
+/** A small shape describing component metadata used by the PDS ontology. */
+export interface ComponentDef {
+  /** canonical name of the component (e.g., 'Button') */
+  name: string;
+  /** optional HTML tag name for the component ('pds-button') */
+  tag?: string;
+  /** documented props and their types/metadata */
+  props?: Record<string, any>;
+  /** human-friendly description used by the designer */
+  description?: string;
+}
+
+/**
+ * Generator - programmatic API to produce tokens, layered CSS and helper modules from a config.
+ * Typical usage:
+ * const g = new Generator({ example: true });
+ * // tokens may be returned synchronously or via a Promise
+ * const tokens = await g.generateTokens?.();
+ * const css = await g.generateCSS?.();
+ */
+export class Generator {
+  constructor(options?: any);
+  /** runtime options / config passed to the generator */
+  options: any;
+  /** generated token object */
+  tokens: Record<string, any>;
+  /** concatenated CSS (layered) */
+  css: string;
+  /** Generate the token map (may be async in some implementations) */
+  generateTokens?(): Record<string, any> | Promise<Record<string, any>>;
+  /** Generate the CSS string (may be async) */
+  generateCSS?(): string | Promise<string>;
+}
+
+/** Public runtime surface exported as `PDS` */
+export interface PDSEventMap {
+  'pds:ready': CustomEvent<{ mode: 'live' | 'static'; generator?: Generator; config: any; theme: string; autoDefiner?: any }>;
+  'pds:error': CustomEvent<{ error: any }>;
+  'pds:theme:changed': CustomEvent<{ theme: string; requested?: string; source: 'system' | 'programmatic' }>;
+  'pds:config-changed': CustomEvent<{ at: number; mode?: 'live' | 'static'; source?: string; preset?: string }>;
+  'pds:design:updated': CustomEvent<{ config: any; designer?: any }>;
+  'pds:design:field:changed': CustomEvent<{ field: string; config: any }>;
+  'pds:inspector:mode:changed': CustomEvent<{ active: boolean }>;
+  'pds:inspector:deactivate': CustomEvent<{}>;
+  'pds:docs:view': CustomEvent<{ file: string }>;
+}
+
+export const PDS: {
+  /** Registry singleton to query/adopt styles and control live/static behavior. */
+  registry: PDSRegistry;
+  /** Live-only accessor for the Generator class. */
+  getGenerator?: () => Promise<typeof Generator>;
+  /** Presets keyed by id (lowercased). Available in live mode. */
+  presets?: Record<string, any>;
+  /** Ontology metadata about components (live mode). */
+  ontology?: any;
+  /** Apply generated styles to the document (live mode). */
+  applyStyles?: (generator?: Generator) => void;
+  /** Adopt multiple named layers into a ShadowRoot. See `LAYER-ARCHITECTURE.md` for layer ordering. */
+  adoptLayers: (shadowRoot: ShadowRoot, layers?: string[], additionalSheets?: CSSStyleSheet[]) => Promise<void>;
+  /** Convenience to adopt only primitives/styles commonly needed by components. */
+  adoptPrimitives: (shadowRoot: ShadowRoot, additionalSheets?: CSSStyleSheet[]) => Promise<void>;
+  /** Create a constructable stylesheet from a CSS string. May throw on invalid CSS in some browsers. */
+  createStylesheet: (css: string) => CSSStyleSheet;
+  /** Utility to inspect whether runtime is running in live mode. */
+  isLiveMode: () => boolean;
+  /** Find a component definition for a given DOM element, or null if not matched (live mode). */
+  findComponentForElement?: (el: Element) => ComponentDef | null;
+  /** Primary unified entry point to start PDS in live or static mode. Default mode is 'live'. */
+  start: (config: {
+    mode?: 'live' | 'static';
+    preset?: string;
+    design?: any;
+    autoDefine?: {
+      /** AutoDefiner is bundled with PDS core; external moduleURL overrides are not supported. */
+      baseURL?: string;
+      predefine?: string[];
+  mapper?: (tag: string) => string | undefined | null | false;
+      scanExisting?: boolean;
+      observeShadows?: boolean;
+      patchAttachShadow?: boolean;
+      debounceMs?: number;
+      onError?: (tag: string, err: any) => void;
+    };
+    applyGlobalStyles?: boolean;
+    manageTheme?: boolean;
+    themeStorageKey?: string;
+    // live-only
+    preloadStyles?: boolean;
+    criticalLayers?: string[];
+    // static-only
+    staticPaths?: Record<string, string>;
+    enhancers?: Array<any>;
+  }) => Promise<{ generator?: Generator; config: any; theme: string; autoDefiner?: any }>;
+  /** Preload minimal CSS to prevent flash of unstyled content. Call before DOM content renders. */
+  preloadCritical?: (config: any, options?: {
+    theme?: string;
+    layers?: string[];
+  }) => void;
+  /** EventTarget API (strongly typed for common PDS events). */
+  addEventListener: <K extends keyof PDSEventMap>(type: K, listener: (ev: PDSEventMap[K]) => any, options?: boolean | AddEventListenerOptions) => void;
+  removeEventListener: <K extends keyof PDSEventMap>(type: K, listener: (ev: PDSEventMap[K]) => any, options?: boolean | EventListenerOptions) => void;
+  dispatchEvent: (event: PDSEventMap[keyof PDSEventMap] | Event) => boolean;
+};
+
+export { PDS as default };

package/src/js/common/pds-log.js

@@ -0,0 +1,144 @@
+const __SUPPORTED_LOG_LEVELS = new Set(["log", "warn", "error", "debug", "info"]);
+const __PDS_SINGLETON_KEY = "__PURE_DS_PDS_SINGLETON__";
+
+let __logProvider = null;
+let __contextProvider = null;
+
+function __resolveGlobalPDS() {
+  try {
+    const scope = typeof globalThis !== "undefined" ? globalThis : window;
+    const candidate = scope?.[__PDS_SINGLETON_KEY];
+    if (candidate && typeof candidate === "object") {
+      return candidate;
+    }
+  } catch (error) {
+    return null;
+  }
+  return null;
+}
+
+function __normalizeContext(context) {
+  if (!context || typeof context !== "object") {
+    return null;
+  }
+  return {
+    mode: context.mode === "live" || context.mode === "static" ? context.mode : null,
+    debug: context.debug === true,
+    thisArg: context.thisArg,
+  };
+}
+
+function __normalizeLevel(level) {
+  if (typeof level !== "string") return "log";
+  const normalized = level.toLowerCase();
+  return __SUPPORTED_LOG_LEVELS.has(normalized) ? normalized : "log";
+}
+
+function __resolveContext() {
+  if (typeof __contextProvider === "function") {
+    try {
+      const configuredContext = __normalizeContext(__contextProvider());
+      if (configuredContext) {
+        return configuredContext;
+      }
+    } catch (error) {}
+  }
+
+  const globalPDS = __resolveGlobalPDS();
+  if (globalPDS) {
+    const mode =
+      globalPDS?.mode ||
+      globalPDS?.compiled?.mode ||
+      (globalPDS?.registry?.isLive ? "live" : "static");
+    const debug =
+      (globalPDS?.debug ||
+        globalPDS?.currentConfig?.debug ||
+        globalPDS?.currentConfig?.design?.debug ||
+        globalPDS?.compiled?.debug ||
+        globalPDS?.compiled?.design?.debug ||
+        false) === true;
+    return {
+      mode,
+      debug,
+      thisArg: globalPDS,
+    };
+  }
+
+  return { mode: null, debug: false };
+}
+
+function __resolveLogger() {
+  if (typeof __logProvider === "function") {
+    try {
+      const logger = __logProvider();
+      if (typeof logger === "function") {
+        return logger;
+      }
+    } catch (error) {}
+  }
+
+  const globalPDS = __resolveGlobalPDS();
+  if (typeof globalPDS?.logHandler === "function") {
+    return globalPDS.logHandler;
+  }
+
+  return null;
+}
+
+function __consoleLog(level, message, ...data) {
+  if (typeof console === "undefined") return;
+  const method =
+    typeof console[level] === "function"
+      ? console[level].bind(console)
+      : typeof console.log === "function"
+        ? console.log.bind(console)
+        : null;
+  if (!method) return;
+
+  if (data.length > 0) {
+    method(message, ...data);
+  } else {
+    method(message);
+  }
+}
+
+function __shouldUseConsoleFallback(level, context) {
+  const debugEnabled = context?.debug === true;
+  const staticMode = context?.mode === "static";
+
+  if (staticMode && !debugEnabled) {
+    return false;
+  }
+
+  if (!debugEnabled && level !== "error" && level !== "warn") {
+    return false;
+  }
+
+  return true;
+}
+
+export function configurePDSLogger({ getLogger, getContext } = {}) {
+  __logProvider = typeof getLogger === "function" ? getLogger : null;
+  __contextProvider = typeof getContext === "function" ? getContext : null;
+}
+
+export function pdsLog(level = "log", message, ...data) {
+  const normalizedLevel = __normalizeLevel(level);
+  const context = __resolveContext();
+  const customLogger = __resolveLogger();
+
+  if (customLogger) {
+    try {
+      customLogger.call(context?.thisArg, normalizedLevel, message, ...data);
+      return;
+    } catch (error) {
+      __consoleLog("error", "Custom log handler failed:", error);
+    }
+  }
+
+  if (!__shouldUseConsoleFallback(normalizedLevel, context)) {
+    return;
+  }
+
+  __consoleLog(normalizedLevel, message, ...data);
+}

package/src/js/common/toast.js

@@ -0,0 +1,122 @@
+/**
+ * Toast notification utilities for PDS
+ * Ensures pds-toaster component is properly initialized before use
+ */
+
+/**
+ * Ensures pds-toaster exists in DOM and is fully loaded
+ * @returns {Promise<HTMLElement>} The pds-toaster element
+ * @private
+ */
+async function ensureToaster() {
+  let toaster = document.querySelector('pds-toaster');
+  if (!toaster) {
+    toaster = document.createElement('pds-toaster');
+    document.body.appendChild(toaster);
+    await customElements.whenDefined('pds-toaster');
+  }
+  return toaster;
+}
+
+/**
+ * Display a toast notification
+ * 
+ * This method automatically ensures the pds-toaster component exists and is loaded
+ * before displaying the notification. The toaster element is appended to document.body
+ * if not already present.
+ * 
+ * @param {string} message - The message to display
+ * @param {Object} [options={}] - Toast configuration
+ * @param {"information"|"success"|"warning"|"error"} [options.type="information"] - Toast type/severity
+ * @param {number} [options.duration] - Duration in milliseconds (auto-calculated if not provided based on message length)
+ * @param {boolean} [options.closable=true] - Whether the toast can be manually closed
+ * @param {boolean} [options.persistent=false] - If true, toast won't auto-dismiss (requires manual close)
+ * @param {boolean} [options.html=false] - Render `message` as HTML (trusted content only)
+ * @param {{label: string, onClick?: Function, dismissOnClick?: boolean}} [options.action] - Optional action button config
+ * @returns {Promise<string>} Toast ID (can be used to dismiss programmatically)
+ * 
+ * @example
+ * // Simple success toast
+ * await PDS.toast('Changes saved successfully!', { type: 'success' });
+ * 
+ * @example
+ * // Error with custom duration
+ * await PDS.toast('Failed to save changes', { 
+ *   type: 'error',
+ *   duration: 8000 
+ * });
+ * 
+ * @example
+ * // Persistent warning (must be manually closed)
+ * await PDS.toast('This action cannot be undone', { 
+ *   type: 'warning',
+ *   persistent: true 
+ * });
+ * 
+ * @example
+ * // Get toast ID to dismiss later
+ * const toastId = await PDS.toast('Processing...', { persistent: true });
+ * // ... later
+ * const toaster = document.querySelector('pds-toaster');
+ * toaster.dismissToast(toastId);
+ */
+export async function toast(message, options = {}) {
+  const toaster = await ensureToaster();
+  return toaster.toast(message, options);
+}
+
+/**
+ * Display a success toast (convenience method)
+ * 
+ * @param {string} message - The success message
+ * @param {Object} [options={}] - Additional toast options (type is preset to 'success')
+ * @returns {Promise<string>} Toast ID
+ * 
+ * @example
+ * await PDS.toast.success('Profile updated!');
+ */
+toast.success = async function(message, options = {}) {
+  return toast(message, { ...options, type: 'success' });
+};
+
+/**
+ * Display an error toast (convenience method)
+ * 
+ * @param {string} message - The error message
+ * @param {Object} [options={}] - Additional toast options (type is preset to 'error')
+ * @returns {Promise<string>} Toast ID
+ * 
+ * @example
+ * await PDS.toast.error('Failed to connect to server');
+ */
+toast.error = async function(message, options = {}) {
+  return toast(message, { ...options, type: 'error' });
+};
+
+/**
+ * Display a warning toast (convenience method)
+ * 
+ * @param {string} message - The warning message
+ * @param {Object} [options={}] - Additional toast options (type is preset to 'warning')
+ * @returns {Promise<string>} Toast ID
+ * 
+ * @example
+ * await PDS.toast.warning('Session will expire in 5 minutes');
+ */
+toast.warning = async function(message, options = {}) {
+  return toast(message, { ...options, type: 'warning' });
+};
+
+/**
+ * Display an information toast (convenience method)
+ * 
+ * @param {string} message - The information message
+ * @param {Object} [options={}] - Additional toast options (type is preset to 'information')
+ * @returns {Promise<string>} Toast ID
+ * 
+ * @example
+ * await PDS.toast.info('New features available!');
+ */
+toast.info = async function(message, options = {}) {
+  return toast(message, { ...options, type: 'information' });
+};

package/src/js/pds-core/pds-config.js

@@ -247,6 +247,24 @@ import { enums } from "./pds-enums.js";
  * @property {boolean} [debug]
  */
 
+/**
+ * @typedef {Object} PDSLocalizationProvider
+ * @property {(context: { key: string, values: any[], options?: Record<string, any>, locale: string, defaultLocale: string, messages: Record<string, string>, messagesByLocale?: Record<string, Record<string, string>>, template?: { strings: string[], values: any[] } | null }) => (string | undefined | null)} [translate]
+ * @property {(context: { locale: string, defaultLocale: string, reason?: string, loadedLocales?: string[], messages?: Record<string, string>, load?: boolean }) => (Promise<Record<string, string | { content?: string }>> | Record<string, string | { content?: string }> | void)} [loadLocale]
+ * @property {(context: { locale: string, defaultLocale: string, reason?: string, loadedLocales?: string[], messages?: Record<string, string>, load?: boolean }) => (Promise<Record<string, string | { content?: string }>> | Record<string, string | { content?: string }> | void)} [setLocale]
+ */
+
+/**
+ * @typedef {Object} PDSLocalizationConfig
+ * @property {string} [locale]
+ * @property {string[]} [locales]
+ * @property {Record<string, string | { content?: string }>} [messages]
+ * @property {PDSLocalizationProvider} [provider]
+ * @property {PDSLocalizationProvider["translate"]} [translate]
+ * @property {PDSLocalizationProvider["loadLocale"]} [loadLocale]
+ * @property {PDSLocalizationProvider["setLocale"]} [setLocale]
+ */
+
 /**
  * @typedef {Object} PDSInitConfig
  * @property {string} [mode]
@@ -262,6 +280,7 @@ import { enums } from "./pds-enums.js";
  * @property {string} [managerURL]
  * @property {any} [manager]
  * @property {boolean} [liveEdit]
+ * @property {PDSLocalizationConfig} [localization]
  * @property {any} [log]
  */
 
@@ -794,6 +813,19 @@ const __INIT_CONFIG_SPEC__ = {
     managerURL: { type: "string" },
     manager: { type: __ANY_TYPE__ },
     liveEdit: { type: "boolean" },
+    localization: {
+      type: "object",
+      allowUnknown: false,
+      properties: {
+        locale: { type: "string" },
+        locales: { type: "array", items: { type: "string" } },
+        messages: { type: "object", allowUnknown: true },
+        provider: { type: __ANY_TYPE__ },
+        translate: { type: __ANY_TYPE__ },
+        loadLocale: { type: __ANY_TYPE__ },
+        setLocale: { type: __ANY_TYPE__ },
+      },
+    },
     log: { type: __ANY_TYPE__ },
   },
 };
@@ -2641,15 +2673,24 @@ export const PDS_DEFAULT_CONFIG_FORM_SCHEMA = buildDesignConfigFormSchema(
  * @param {...any} data - additional data to log
  */
 export function defaultLog(level = "log", message, ...data) {
-  // Access debug from 'this' context when called as method, or check for common locations
-  const debug = this?.debug || this?.design?.debug || false;
-  
-  if (debug || level === "error" || level === "warn") {
-    const method = console[level] || console.log;
-    if (data.length > 0) {
-      method(message, ...data);
-    } else {
-      method(message);
-    }
+  const runtimeLogger = globalThis?.PDS?.log;
+  if (typeof runtimeLogger === "function") {
+    runtimeLogger(level, message, ...data);
+    return;
+  }
+
+  if (typeof console === "undefined") return;
+  const method =
+    typeof console[level] === "function"
+      ? console[level].bind(console)
+      : typeof console.log === "function"
+        ? console.log.bind(console)
+        : null;
+  if (!method) return;
+
+  if (data.length > 0) {
+    method(message, ...data);
+  } else {
+    method(message);
   }
 }

package/src/js/pds-core/pds-enhancers.js

@@ -1,3 +1,5 @@
+import { msg } from "../common/localization.js";
+
 /**
  * PDS Enhancers - Single Source of Truth
  *
@@ -502,7 +504,7 @@ function enhanceColorInput(elem) {
 
     if (isUnset) {
       output.value = "";
-      output.textContent = "not set";
+      output.textContent = msg("not set");
       control.dataset.value = "";
       control.dataset.unset = "1";
       swatch.dataset.unset = "1";
@@ -686,7 +688,7 @@ function enhanceRequired(elem) {
     if (form && !form.querySelector(".required-legend")) {
       const legend = document.createElement("small");
       legend.classList.add("required-legend");
-      legend.textContent = "* Required fields";
+      legend.textContent = msg("* Required fields");
       form.insertBefore(
         legend,
         form.querySelector(".form-actions") || form.lastElementChild,
@@ -707,7 +709,7 @@ function enhanceOpenGroup(elem) {
 
   const addInput = document.createElement("input");
   addInput.type = "text";
-  addInput.placeholder = "Add item...";
+  addInput.placeholder = msg("Add item...");
   addInput.classList.add("input-text", "input-sm");
   addInput.style.width = "auto";
 

package/src/js/pds-core/pds-live.js

@@ -751,7 +751,7 @@ async function __attachLiveAPIs(PDS, { applyResolvedTheme, setupSystemListenerIf
   PDS.applyLivePreset = async function(presetId, options = {}) {
     if (!presetId) return false;
     if (!PDS.registry?.isLive) {
-      console.warn("PDS.applyLivePreset is only available in live mode.");
+      PDS.log("warn", "PDS.applyLivePreset is only available in live mode.");
       return false;
     }
 
@@ -775,7 +775,8 @@ async function __attachLiveAPIs(PDS, { applyResolvedTheme, setupSystemListenerIf
         normalized.presetInfo?.name ||
         normalized.generatorConfig?.design?.name ||
         presetId;
-      console.warn(
+      PDS.log(
+        "warn",
         `PDS theme "${resolvedTheme}" not supported by preset "${presetName}".`
       );
     }
@@ -886,7 +887,7 @@ async function __attachLiveAPIs(PDS, { applyResolvedTheme, setupSystemListenerIf
         document.head.insertBefore(styleEl, document.head.firstChild);
       }
     } catch (error) {
-      console.warn("PDS preload failed:", error);
+      PDS.log("warn", "PDS preload failed:", error);
     }
   };
 
@@ -947,7 +948,7 @@ export async function startLive(PDS, config, { emitReady, emitConfigChanged, app
         document.adoptedStyleSheets = [foucSheet, ...document.adoptedStyleSheets];
       }
     } catch (e) {
-      console.warn("Constructable stylesheets not supported, using <style> tag fallback:", e);
+      PDS.log("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");
@@ -989,7 +990,8 @@ export async function startLive(PDS, config, { emitReady, emitConfigChanged, app
         normalized.generatorConfig?.design?.name ||
         normalized.generatorConfig?.preset ||
         "current preset";
-      console.warn(
+      PDS.log(
+        "warn",
         `PDS theme "${resolvedTheme}" not supported by preset "${presetName}".`
       );
     }

package/src/js/pds-core/pds-registry.js

@@ -3,6 +3,8 @@
 // PDS REGISTRY - Global mode manager for live vs static mode
 // ============================================================================
 
+import { PDS } from "../pds-singleton.js";
+
 class PDSRegistry {
   constructor() {
     this._mode = "static"; // Default to static mode
@@ -46,10 +48,10 @@ class PDSRegistry {
         const module = await import(/* @vite-ignore */ this._staticPaths[layer]);
         return module[layer]; // Return exported stylesheet
       } catch (error) {
-        // No access to config in static mode, fall back to console
-        console.error(`[PDS Registry] Failed to load static ${layer}:`, error);
-        console.error(`[PDS Registry] Looking for: ${this._staticPaths[layer]}`);
-        console.error(`[PDS Registry] Make sure you've run 'npm run pds:build' and configured PDS.start() with the correct static.root path`);
+        // Route through centralized logger fallback behavior
+        PDS.log("error", `Registry: failed to load static ${layer}:`, error);
+        PDS.log("error", `Registry: looking for ${this._staticPaths[layer]}`);
+        PDS.log("error", "Registry: make sure you've run 'npm run pds:build' and configured PDS.start() with the correct static.root path");
         // Return empty stylesheet as fallback
         const fallback = new CSSStyleSheet();
         fallback.replaceSync("/* Failed to load " + layer + " */");

package/src/js/pds-core/pds-runtime.js

@@ -4,6 +4,7 @@
  * generator bundle lean and optional.
  */
 import { registry as pdsRegistry } from "./pds-registry.js";
+import { PDS } from "../pds-singleton.js";
 
 /**
  * Install runtime styles for PDS using constructable stylesheets when
@@ -48,7 +49,7 @@ export function installRuntimeStyles(cssText) {
     // Update the stylesheet content in place
     el.textContent = cssText;
   } catch (err) {
-    console.warn("installRuntimeStyles failed:", err);
+    PDS.log("warn", "installRuntimeStyles failed:", err);
   }
 }
 
@@ -60,8 +61,9 @@ export function applyStyles(generator) {
   const target = generator;
 
   if (!target || typeof target !== "object") {
-    console.error(
-      "[Runtime] applyStyles requires an explicit generator instance in live mode"
+    PDS.log(
+      "error",
+      "Runtime applyStyles requires an explicit generator instance in live mode"
     );
     return;
   }
@@ -72,7 +74,7 @@ export function applyStyles(generator) {
   if (!cssText) {
     target.options?.log?.(
       "warn",
-      "[Runtime] No CSS available on generator to apply"
+      "Runtime: no CSS available on generator to apply"
     );
     return;
   }
@@ -108,8 +110,9 @@ export async function adoptPrimitives(
     shadowRoot.adoptedStyleSheets = [primitives, ...additionalSheets];
   } catch (error) {
     const componentName = shadowRoot.host?.tagName?.toLowerCase() || "unknown";
-    console.error(
-      `[PDS Adopter] <${componentName}> failed to adopt primitives:`,
+    PDS.log(
+      "error",
+      `Adopter: <${componentName}> failed to adopt primitives:`,
       error
     );
     // Continue with just additional sheets as fallback
@@ -177,8 +180,9 @@ export async function adoptLayers(
     shadowRoot.adoptedStyleSheets = [...validStylesheets, ...safeAdditionalSheets];
   } catch (error) {
     const componentName = shadowRoot.host?.tagName?.toLowerCase() || "unknown";
-    console.error(
-      `[PDS Adopter] <${componentName}> failed to adopt layers:`,
+    PDS.log(
+      "error",
+      `Adopter: <${componentName}> failed to adopt layers:`,
       error
     );
     // Continue with just additional sheets as fallback