@damarkuncoro/meta-architecture-style-engine 0.1.0 → 0.1.1

package/lib/esm/index.js

@@ -1,199 +1,276 @@
-// src/domain/strategies/TokenExistenceValidator.ts
-var TokenExistenceValidator = class {
-  constructor(tokenRegistry) {
-    this.tokenRegistry = tokenRegistry;
+// src/data/tokens.ts
+var TOKENS = {
+  // Colors - Intent based
+  "color.primary": { id: "color.primary", domain: "color", value: "bg-blue-600" },
+  "color.secondary": { id: "color.secondary", domain: "color", value: "bg-gray-600" },
+  "color.danger": { id: "color.danger", domain: "color", value: "bg-red-600" },
+  // Spacing - Scale based
+  "space.sm": { id: "space.sm", domain: "layout", value: "p-2" },
+  "space.md": { id: "space.md", domain: "layout", value: "p-4" },
+  "space.lg": { id: "space.lg", domain: "layout", value: "p-6" },
+  // Forbidden/Raw tokens (for demo)
+  "raw.hex": { id: "raw.hex", domain: "color", value: "bg-[#123456]" },
+  // Illegal
+  // Surface (Theme Aware!)
+  "surface.card": {
+    id: "surface.card",
+    domain: "color",
+    value: {
+      light: "bg-white",
+      dark: "bg-slate-800"
+    }
+  },
+  "surface.ground": {
+    id: "surface.ground",
+    domain: "color",
+    value: {
+      light: "bg-gray-50",
+      dark: "bg-slate-900"
+    }
+  },
+  "surface.paper": {
+    id: "surface.paper",
+    domain: "color",
+    value: {
+      light: "bg-white",
+      dark: "bg-slate-700"
+    }
+  },
+  // Text (Theme Aware!)
+  "text.light": {
+    id: "text.light",
+    domain: "color",
+    value: {
+      light: "text-white",
+      dark: "text-gray-100"
+    }
+  },
+  "text.dark": {
+    id: "text.dark",
+    domain: "color",
+    value: {
+      light: "text-gray-900",
+      dark: "text-white"
+    }
+  },
+  "text.primary": {
+    id: "text.primary",
+    domain: "color",
+    value: {
+      light: "text-gray-900",
+      dark: "text-gray-50"
+    }
+  },
+  "text.secondary": {
+    id: "text.secondary",
+    domain: "color",
+    value: {
+      light: "text-gray-500",
+      dark: "text-gray-400"
+    }
+  },
+  "shadow.sm": { id: "shadow.sm", domain: "effect", value: "shadow-sm" },
+  "shadow.md": { id: "shadow.md", domain: "effect", value: "shadow-md" },
+  "shadow.lg": { id: "shadow.lg", domain: "effect", value: "shadow-lg" },
+  // Radius
+  "radius.md": { id: "radius.md", domain: "layout", value: "rounded-md" },
+  "radius.lg": { id: "radius.lg", domain: "layout", value: "rounded-lg" }
+};
+
+// src/domain/registry/TokenRegistry.ts
+var TokenRegistry = class {
+  constructor(tokens = TOKENS) {
+    this.tokens = Object.freeze({ ...tokens });
   }
   /**
-   * Validate that token exists
+   * Get token by ID
+   * @throws Error if token not found
    */
-  validate(property, tokenId, rule, context) {
-    if (!this.tokenRegistry.hasToken(tokenId)) {
-      return {
-        rule: "invalid-token",
-        message: `Token '${tokenId}' does not exist in Registry.`,
-        severity: "error",
-        semantic: `${property}.${tokenId}`,
-        context: context ? { ...context } : void 0
-      };
+  getToken(id) {
+    const token = this.tokens[id];
+    if (!token) {
+      throw new Error(`Token '${id}' not found in registry`);
     }
-    return null;
+    return token;
   }
   /**
-   * Get strategy name
+   * Check if token exists
    */
-  getName() {
-    return "TokenExistenceValidator";
+  hasToken(id) {
+    return id in this.tokens;
+  }
+  /**
+   * Get all tokens (immutable)
+   */
+  getAllTokens() {
+    return this.tokens;
   }
 };
 
-// src/domain/strategies/DomainValidator.ts
-var DomainValidator = class {
-  constructor(tokenRegistry) {
-    this.tokenRegistry = tokenRegistry;
-  }
+// src/domain/resolution/ThemeResolver.ts
+var ThemeResolver = class {
   /**
-   * Validate that token domain matches rule domain
+   * Resolve theme value based on current theme
    */
-  validate(property, tokenId, rule, context) {
-    const token = this.tokenRegistry.getToken(tokenId);
-    if (token.domain !== rule.domain) {
-      return {
-        rule: "domain-violation",
-        message: `Property '${property}' expects domain '${rule.domain}', but got token from '${token.domain}'.`,
-        severity: "error",
-        semantic: `${property}.${tokenId}`,
-        context: context ? { ...context } : void 0
-      };
+  resolve(value, theme) {
+    if (typeof value === "string") {
+      return value;
     }
-    return null;
+    if (theme in value) {
+      return value[theme];
+    }
+    throw new Error(`Theme '${theme}' not found in value. Available themes: ${Object.keys(value).join(", ")}`);
   }
   /**
-   * Get strategy name
+   * Get current theme from context
+   * Defaults to 'light' if not specified
    */
-  getName() {
-    return "DomainValidator";
+  getCurrentTheme(context) {
+    return context?.theme || "light";
   }
 };
 
-// src/domain/strategies/AllowedTokenValidator.ts
-var AllowedTokenValidator = class {
+// src/domain/resolution/ContextBinder.ts
+var ContextBinder = class {
+  constructor(graph, bindingRules = []) {
+    this.graph = graph;
+    this.bindingRules = bindingRules;
+  }
   /**
-   * Validate that token is allowed
+   * Bind graph to a specific context
+   * @param context - Style context to bind to
+   * @returns Bound context with active contracts and disabled variants
    */
-  validate(property, tokenId, rule, context) {
-    if (!rule.allowedTokens.includes(tokenId)) {
-      return {
-        rule: "illegal-token-usage",
-        message: `Token '${tokenId}' is NOT allowed for property '${property}'. Allowed: ${rule.allowedTokens.join(", ")}`,
-        severity: "error",
-        semantic: `${property}.${tokenId}`,
-        context: context ? { ...context } : void 0
-      };
+  bind(context) {
+    const activeContracts = /* @__PURE__ */ new Set();
+    const disabledVariants = /* @__PURE__ */ new Map();
+    for (const rule of this.bindingRules) {
+      const isActive = rule.condition(context);
+      if (isActive) {
+        activeContracts.add(rule.contract);
+        if (rule.disabledVariants && rule.disabledVariants.length > 0) {
+          disabledVariants.set(rule.contract, rule.disabledVariants);
+        }
+      }
     }
-    return null;
+    const graphView = this.createGraphView(activeContracts, disabledVariants);
+    return {
+      context,
+      activeContracts,
+      disabledVariants,
+      graphView
+    };
   }
   /**
-   * Get strategy name
+   * Bind graph to multiple contexts
+   * @param contexts - Array of style contexts
+   * @returns Array of bound contexts
    */
-  getName() {
-    return "AllowedTokenValidator";
-  }
-};
-
-// src/domain/StyleResolutionEngine.ts
-var StyleResolutionEngine = class {
-  constructor(tokenRegistry, themeResolver, validators) {
-    this.tokenRegistry = tokenRegistry;
-    this.themeResolver = themeResolver;
-    this.validators = validators || [
-      new TokenExistenceValidator(tokenRegistry),
-      new DomainValidator(tokenRegistry),
-      new AllowedTokenValidator()
-    ];
+  bindMultiple(contexts) {
+    return contexts.map((ctx) => this.bind(ctx));
   }
   /**
-   * resolve()
-   * Main function: Validates style contract against constitution
-   * 
-   * @param contract - Style contract definition
-   * @param constitution - Component constitution
-   * @param context - Optional style context
-   * @returns Resolution result with nodes, violations, and className
+   * Create immutable view of the graph
+   * @param activeContracts - Set of active contract names
+   * @param disabledVariants - Map of disabled variants per contract
+   * @returns Immutable array of nodes
    */
-  resolve(contract, constitution, context) {
-    const violations = [];
-    const nodes = [];
-    const validClassNames = [];
-    for (const [property, rawValue] of Object.entries(contract)) {
-      const rule = constitution.rules.find((r) => r.property === property);
-      if (!rule) {
-        violations.push({
-          rule: "unknown-property",
-          message: `Property '${property}' is not defined in ${constitution.componentName} constitution.`,
-          severity: "warning",
-          semantic: `${property}`
-        });
+  createGraphView(activeContracts, disabledVariants) {
+    const allNodes = this.graph.getAllNodes();
+    const view = [];
+    for (const node of allNodes) {
+      if (!activeContracts.has(node.contractRef)) {
         continue;
       }
-      if (typeof rawValue === "string") {
-        this.validateAndResolve(
-          property,
-          rawValue,
-          rule,
-          constitution,
-          violations,
-          nodes,
-          validClassNames,
-          void 0,
-          context
-        );
-      } else if (typeof rawValue === "object" && rawValue !== null) {
-        for (const [bp, tokenId] of Object.entries(rawValue)) {
-          this.validateAndResolve(
-            property,
-            tokenId,
-            rule,
-            constitution,
-            violations,
-            nodes,
-            validClassNames,
-            bp,
-            context
-          );
+      const disabledForContract = disabledVariants.get(node.contractRef);
+      if (disabledForContract && disabledForContract.length > 0) {
+        const variant = this.extractVariant(node.id);
+        if (variant && disabledForContract.includes(variant)) {
+          continue;
         }
       }
+      view.push(node);
     }
-    return {
-      valid: violations.length === 0,
-      nodes: Object.freeze(nodes),
-      violations: Object.freeze(violations),
-      className: validClassNames.join(" ")
-    };
+    return Object.freeze(view);
   }
   /**
-   * validateAndResolve()
-   * Internal helper to validate and resolve a single token
+   * Extract variant from node ID
+   * @param nodeId - Node ID (e.g., "Button.padding.md")
+   * @returns Variant (e.g., "md") or null
    */
-  validateAndResolve(property, tokenId, rule, constitution, violations, nodes, validClassNames, breakpoint, context) {
-    for (const validator of this.validators) {
-      const violation = validator.validate(property, tokenId, rule, context);
-      if (violation) {
-        violations.push({
-          ...violation,
-          context: breakpoint ? { breakpoint } : void 0
-        });
-        return;
-      }
+  extractVariant(nodeId) {
+    const parts = nodeId.split(".");
+    if (parts.length >= 3) {
+      return parts[2];
     }
-    const token = this.tokenRegistry.getToken(tokenId);
-    nodes.push({
-      domain: token.domain,
-      semantic: `${constitution.componentName}.${property}`,
-      tokenRef: token.id,
-      source: "SRE.v2",
-      breakpoint
-    });
-    const materializedValue = this.materializeToken(token, breakpoint, context);
-    validClassNames.push(materializedValue);
+    return null;
   }
   /**
-   * materializeToken()
-   * Resolve token value based on context (Theme/Breakpoint)
-   * 
-   * NOTE: This is temporary materialization logic.
-   * In Phase 5, this will be replaced by StyleMaterializationEngine (SME).
+   * Add a binding rule
+   * @param rule - Context binding rule
+   */
+  addBindingRule(rule) {
+    this.bindingRules.push(rule);
+  }
+  /**
+   * Remove a binding rule
+   * @param contract - Contract name
+   * @param property - Property name
    */
-  materializeToken(token, breakpoint, context) {
-    const theme = this.themeResolver.getCurrentTheme(context);
-    const baseValue = this.themeResolver.resolve(token.value, theme);
-    if (breakpoint) {
-      return `${breakpoint}:${baseValue}`;
+  removeBindingRule(contract, property) {
+    const index = this.bindingRules.findIndex(
+      (r) => r.contract === contract && r.property === property
+    );
+    if (index !== -1) {
+      this.bindingRules.splice(index, 1);
     }
-    return baseValue;
+  }
+  /**
+   * Get all binding rules
+   * @returns Immutable array of binding rules
+   */
+  getBindingRules() {
+    return Object.freeze([...this.bindingRules]);
+  }
+  /**
+   * Create default binding rules for common scenarios
+   * @returns Array of default binding rules
+   */
+  static createDefaultRules() {
+    return [
+      // Mobile: Disable large spacing
+      {
+        contract: "Card",
+        property: "padding",
+        condition: (ctx) => ctx.device === "mobile",
+        disabledVariants: ["lg", "xl", "2xl"]
+      },
+      // Mobile: Disable large shadows
+      {
+        contract: "Card",
+        property: "shadow",
+        condition: (ctx) => ctx.device === "mobile",
+        disabledVariants: ["lg", "xl"]
+      },
+      // Dark mode: Disable light surfaces
+      {
+        contract: "Card",
+        property: "background",
+        condition: (ctx) => ctx.theme === "dark",
+        disabledVariants: ["surface.white", "surface.gray"]
+      },
+      // Reduced motion: Disable animations
+      {
+        contract: "Button",
+        property: "effect",
+        condition: (ctx) => ctx.state === "disabled",
+        disabledVariants: ["animate", "transition"]
+      }
+    ];
   }
 };
 
-// src/domain/CanonicalStyleGraph.ts
+// src/domain/resolution/CanonicalStyleGraph.ts
 var CanonicalStyleGraph = class {
   constructor(contracts, tokenRegistry) {
     this.nodes = /* @__PURE__ */ new Map();
@@ -366,357 +443,242 @@ var CanonicalStyleGraph = class {
       const nodeId = queue.shift();
       result.push(nodeId);
       visited.add(nodeId);
-      const node = this.nodes.get(nodeId);
-      if (node) {
-        for (const edge of node.dependencies) {
-          const neighborId = edge.to;
-          const current = inDegree.get(neighborId) || 0;
-          inDegree.set(neighborId, current - 1);
-          if (current - 1 === 0) {
-            queue.push(neighborId);
-          }
-        }
-      }
-    }
-    if (visited.size !== this.nodes.size) {
-      throw new Error("Cannot resolve order: graph contains cycles");
-    }
-    return result;
-  }
-  /**
-   * Get node by ID
-   */
-  getNode(id) {
-    return this.nodes.get(id);
-  }
-  /**
-   * Get all nodes
-   */
-  getAllNodes() {
-    return Array.from(this.nodes.values());
-  }
-  /**
-   * Get all edges
-   */
-  getAllEdges() {
-    return this.edges;
-  }
-  /**
-   * Get constitution by component name
-   */
-  getConstitution(componentName) {
-    return this.constitutionsMap.get(componentName);
-  }
-  /**
-   * Get all constitutions
-   */
-  getAllConstitutions() {
-    return Array.from(this.constitutionsMap.values());
-  }
-  /**
-   * Check if graph is empty
-   */
-  isEmpty() {
-    return this.nodes.size === 0;
-  }
-  /**
-   * Get graph size
-   */
-  size() {
-    return this.nodes.size;
-  }
-};
-
-// src/domain/ContextBinder.ts
-var ContextBinder = class {
-  constructor(graph, bindingRules = []) {
-    this.graph = graph;
-    this.bindingRules = bindingRules;
-  }
-  /**
-   * Bind graph to a specific context
-   * @param context - Style context to bind to
-   * @returns Bound context with active contracts and disabled variants
-   */
-  bind(context) {
-    const activeContracts = /* @__PURE__ */ new Set();
-    const disabledVariants = /* @__PURE__ */ new Map();
-    for (const rule of this.bindingRules) {
-      const isActive = rule.condition(context);
-      if (isActive) {
-        activeContracts.add(rule.contract);
-        if (rule.disabledVariants && rule.disabledVariants.length > 0) {
-          disabledVariants.set(rule.contract, rule.disabledVariants);
+      const node = this.nodes.get(nodeId);
+      if (node) {
+        for (const edge of node.dependencies) {
+          const neighborId = edge.to;
+          const current = inDegree.get(neighborId) || 0;
+          inDegree.set(neighborId, current - 1);
+          if (current - 1 === 0) {
+            queue.push(neighborId);
+          }
         }
       }
     }
-    const graphView = this.createGraphView(activeContracts, disabledVariants);
-    return {
-      context,
-      activeContracts,
-      disabledVariants,
-      graphView
-    };
+    if (visited.size !== this.nodes.size) {
+      throw new Error("Cannot resolve order: graph contains cycles");
+    }
+    return result;
   }
   /**
-   * Bind graph to multiple contexts
-   * @param contexts - Array of style contexts
-   * @returns Array of bound contexts
+   * Get node by ID
    */
-  bindMultiple(contexts) {
-    return contexts.map((ctx) => this.bind(ctx));
+  getNode(id) {
+    return this.nodes.get(id);
   }
   /**
-   * Create immutable view of the graph
-   * @param activeContracts - Set of active contract names
-   * @param disabledVariants - Map of disabled variants per contract
-   * @returns Immutable array of nodes
+   * Get all nodes
    */
-  createGraphView(activeContracts, disabledVariants) {
-    const allNodes = this.graph.getAllNodes();
-    const view = [];
-    for (const node of allNodes) {
-      if (!activeContracts.has(node.contractRef)) {
-        continue;
-      }
-      const disabledForContract = disabledVariants.get(node.contractRef);
-      if (disabledForContract && disabledForContract.length > 0) {
-        const variant = this.extractVariant(node.id);
-        if (variant && disabledForContract.includes(variant)) {
-          continue;
-        }
-      }
-      view.push(node);
-    }
-    return Object.freeze(view);
+  getAllNodes() {
+    return Array.from(this.nodes.values());
   }
   /**
-   * Extract variant from node ID
-   * @param nodeId - Node ID (e.g., "Button.padding.md")
-   * @returns Variant (e.g., "md") or null
+   * Get all edges
    */
-  extractVariant(nodeId) {
-    const parts = nodeId.split(".");
-    if (parts.length >= 3) {
-      return parts[2];
-    }
-    return null;
+  getAllEdges() {
+    return this.edges;
   }
   /**
-   * Add a binding rule
-   * @param rule - Context binding rule
+   * Get constitution by component name
    */
-  addBindingRule(rule) {
-    this.bindingRules.push(rule);
+  getConstitution(componentName) {
+    return this.constitutionsMap.get(componentName);
   }
   /**
-   * Remove a binding rule
-   * @param contract - Contract name
-   * @param property - Property name
+   * Get all constitutions
    */
-  removeBindingRule(contract, property) {
-    const index = this.bindingRules.findIndex(
-      (r) => r.contract === contract && r.property === property
-    );
-    if (index !== -1) {
-      this.bindingRules.splice(index, 1);
-    }
+  getAllConstitutions() {
+    return Array.from(this.constitutionsMap.values());
   }
   /**
-   * Get all binding rules
-   * @returns Immutable array of binding rules
+   * Check if graph is empty
    */
-  getBindingRules() {
-    return Object.freeze([...this.bindingRules]);
+  isEmpty() {
+    return this.nodes.size === 0;
   }
   /**
-   * Create default binding rules for common scenarios
-   * @returns Array of default binding rules
+   * Get graph size
    */
-  static createDefaultRules() {
-    return [
-      // Mobile: Disable large spacing
-      {
-        contract: "Card",
-        property: "padding",
-        condition: (ctx) => ctx.device === "mobile",
-        disabledVariants: ["lg", "xl", "2xl"]
-      },
-      // Mobile: Disable large shadows
-      {
-        contract: "Card",
-        property: "shadow",
-        condition: (ctx) => ctx.device === "mobile",
-        disabledVariants: ["lg", "xl"]
-      },
-      // Dark mode: Disable light surfaces
-      {
-        contract: "Card",
-        property: "background",
-        condition: (ctx) => ctx.theme === "dark",
-        disabledVariants: ["surface.white", "surface.gray"]
-      },
-      // Reduced motion: Disable animations
-      {
-        contract: "Button",
-        property: "effect",
-        condition: (ctx) => ctx.state === "disabled",
-        disabledVariants: ["animate", "transition"]
-      }
-    ];
+  size() {
+    return this.nodes.size;
   }
 };
 
-// src/domain/ViolationEngine.ts
-var ViolationEngine = class {
-  constructor(defaultAction = "reject", handlers) {
-    this.defaultAction = defaultAction;
-    this.handlers = /* @__PURE__ */ new Map();
-    if (handlers) {
-      for (const handler of handlers) {
-        this.handlers.set(handler.constructor.name, handler);
-      }
-    }
+// src/domain/governance/strategies/TokenExistenceValidator.ts
+var TokenExistenceValidator = class {
+  constructor(tokenRegistry) {
+    this.tokenRegistry = tokenRegistry;
   }
   /**
-   * Handle a violation
-   * @param violation - The violation to handle
-   * @returns Outcome (decision, not execution)
+   * Validate that token exists
    */
-  handle(violation) {
-    const handler = this.handlers.get(violation.rule);
-    if (handler) {
-      return handler.handle(violation);
+  validate(property, tokenId, rule, context) {
+    if (!this.tokenRegistry.hasToken(tokenId)) {
+      return {
+        rule: "invalid-token",
+        message: `Token '${tokenId}' does not exist in Registry.`,
+        severity: "error",
+        semantic: `${property}.${tokenId}`,
+        context: context ? { ...context } : void 0
+      };
     }
-    return this.createDefaultOutcome(violation);
-  }
-  /**
-   * Handle multiple violations
-   * @param violations - Array of violations
-   * @returns Array of outcomes
-   */
-  handleMultiple(violations) {
-    return violations.map((v) => this.handle(v));
+    return null;
   }
   /**
-   * Get current default action
-   * @returns Current default action
+   * Get strategy name
    */
-  getCurrentDefaultAction() {
-    return this.defaultAction;
+  getName() {
+    return "TokenExistenceValidator";
   }
-  /**
-   * Create default outcome based on default action
-   * @param violation - The violation
-   * @returns Default outcome
-   */
-  createDefaultOutcome(violation) {
-    const currentAction = this.getCurrentDefaultAction();
-    switch (currentAction) {
-      case "reject":
-        return {
-          action: "reject",
-          metadata: {
-            contract: violation.semantic || "unknown",
-            reason: violation.message,
-            context: violation.context || {},
-            severity: violation.severity
-          }
-        };
-      case "fallback":
-        return {
-          action: "fallback",
-          replacement: this.determineFallbackValue(violation),
-          metadata: {
-            contract: violation.semantic || "unknown",
-            reason: violation.message,
-            context: violation.context || {},
-            severity: "warning"
-          }
-        };
-      case "override":
-        return {
-          action: "override",
-          metadata: {
-            contract: violation.semantic || "unknown",
-            reason: violation.message,
-            context: violation.context || {},
-            severity: "warning"
-          }
-        };
-      case "warn":
-        return {
-          action: "warn",
-          metadata: {
-            contract: violation.semantic || "unknown",
-            reason: violation.message,
-            context: violation.context || {},
-            severity: "warning"
-          }
-        };
-      default:
-        throw new Error(`Unknown action: ${currentAction}`);
-    }
+};
+
+// src/domain/governance/strategies/DomainValidator.ts
+var DomainValidator = class {
+  constructor(tokenRegistry) {
+    this.tokenRegistry = tokenRegistry;
   }
   /**
-   * Determine fallback value for a violation
-   * @param violation - The violation
-   * @returns Fallback value or undefined
-   */
-  determineFallbackValue(violation) {
-    const match = violation.message.match(/fallback to \[([^\]]+)\]/i);
-    if (match && match[1]) {
-      return match[1];
-    }
-    if (violation.semantic) {
-      const parts = violation.semantic.split(".");
-      if (parts.length >= 2) {
-        const property = parts[parts.length - 1];
-        const fallbacks = {
-          "padding": "md",
-          "margin": "md",
-          "spacing": "md",
-          "radius": "md",
-          "shadow": "md",
-          "background": "surface.card",
-          "color": "color.primary"
-        };
-        if (property in fallbacks) {
-          return fallbacks[property];
-        }
-      }
+   * Validate that token domain matches rule domain
+   */
+  validate(property, tokenId, rule, context) {
+    const token = this.tokenRegistry.getToken(tokenId);
+    if (token.domain !== rule.domain) {
+      return {
+        rule: "domain-violation",
+        message: `Property '${property}' expects domain '${rule.domain}', but got token from '${token.domain}'.`,
+        severity: "error",
+        semantic: `${property}.${tokenId}`,
+        context: context ? { ...context } : void 0
+      };
     }
-    return void 0;
+    return null;
   }
   /**
-   * Register a handler
-   * @param handler - The handler to register
+   * Get strategy name
    */
-  registerHandler(handler) {
-    this.handlers.set(handler.constructor.name, handler);
+  getName() {
+    return "DomainValidator";
   }
+};
+
+// src/domain/governance/strategies/AllowedTokenValidator.ts
+var AllowedTokenValidator = class {
   /**
-   * Unregister a handler
-   * @param handlerName - Name of handler to unregister
+   * Validate that token is allowed
    */
-  unregisterHandler(handlerName) {
-    this.handlers.delete(handlerName);
+  validate(property, tokenId, rule, context) {
+    if (!rule.allowedTokens.includes(tokenId)) {
+      return {
+        rule: "illegal-token-usage",
+        message: `Token '${tokenId}' is NOT allowed for property '${property}'. Allowed: ${rule.allowedTokens.join(", ")}`,
+        severity: "error",
+        semantic: `${property}.${tokenId}`,
+        context: context ? { ...context } : void 0
+      };
+    }
+    return null;
   }
   /**
-   * Get all registered handlers
-   * @returns Array of handler names
+   * Get strategy name
    */
-  getHandlers() {
-    return Array.from(this.handlers.keys());
+  getName() {
+    return "AllowedTokenValidator";
+  }
+};
+
+// src/domain/resolution/StyleResolutionEngine.ts
+var StyleResolutionEngine = class {
+  constructor(tokenRegistry, themeResolver, validators) {
+    this.tokenRegistry = tokenRegistry;
+    this.themeResolver = themeResolver;
+    this.validators = validators || [
+      new TokenExistenceValidator(tokenRegistry),
+      new DomainValidator(tokenRegistry),
+      new AllowedTokenValidator()
+    ];
   }
   /**
-   * Set default action
-   * @param action - The default action
+   * resolve()
+   * Main function: Validates style contract against constitution
+   * 
+   * @param contract - Style contract definition
+   * @param constitution - Component constitution
+   * @param context - Optional style context
+   * @returns Resolution result with nodes and violations
    */
-  setDefaultAction(action) {
-    this.defaultAction = action;
+  resolve(contract, constitution, context) {
+    const violations = [];
+    const nodes = [];
+    for (const [property, rawValue] of Object.entries(contract)) {
+      const rule = constitution.rules.find((r) => r.property === property);
+      if (!rule) {
+        violations.push({
+          rule: "unknown-property",
+          message: `Property '${property}' is not defined in ${constitution.componentName} constitution.`,
+          severity: "warning",
+          semantic: `${property}`
+        });
+        continue;
+      }
+      if (typeof rawValue === "string") {
+        this.validateAndResolve(
+          property,
+          rawValue,
+          rule,
+          constitution,
+          violations,
+          nodes,
+          void 0,
+          context
+        );
+      } else if (typeof rawValue === "object" && rawValue !== null) {
+        for (const [bp, tokenId] of Object.entries(rawValue)) {
+          this.validateAndResolve(
+            property,
+            tokenId,
+            rule,
+            constitution,
+            violations,
+            nodes,
+            bp,
+            context
+          );
+        }
+      }
+    }
+    return {
+      valid: violations.length === 0,
+      nodes: Object.freeze(nodes),
+      violations: Object.freeze(violations)
+    };
+  }
+  /**
+   * validateAndResolve()
+   * Internal helper to validate and resolve a single token
+   */
+  validateAndResolve(property, tokenId, rule, constitution, violations, nodes, breakpoint, context) {
+    for (const validator of this.validators) {
+      const violation = validator.validate(property, tokenId, rule, context);
+      if (violation) {
+        violations.push({
+          ...violation,
+          context: breakpoint ? { breakpoint } : void 0
+        });
+        return;
+      }
+    }
+    const token = this.tokenRegistry.getToken(tokenId);
+    nodes.push({
+      domain: token.domain,
+      semantic: `${constitution.componentName}.${property}`,
+      tokenRef: token.id,
+      source: "SRE.v2",
+      breakpoint
+    });
   }
 };
+
+// src/domain/governance/DefaultViolationHandlers.ts
 var DefaultViolationHandlers = class {
 };
 /**
@@ -792,139 +754,158 @@ DefaultViolationHandlers.ContextViolationHandler = {
   }
 };
 
-// src/data/tokens.ts
-var TOKENS = {
-  // Colors - Intent based
-  "color.primary": { id: "color.primary", domain: "color", value: "bg-blue-600" },
-  "color.secondary": { id: "color.secondary", domain: "color", value: "bg-gray-600" },
-  "color.danger": { id: "color.danger", domain: "color", value: "bg-red-600" },
-  // Spacing - Scale based
-  "space.sm": { id: "space.sm", domain: "layout", value: "p-2" },
-  "space.md": { id: "space.md", domain: "layout", value: "p-4" },
-  "space.lg": { id: "space.lg", domain: "layout", value: "p-6" },
-  // Forbidden/Raw tokens (for demo)
-  "raw.hex": { id: "raw.hex", domain: "color", value: "bg-[#123456]" },
-  // Illegal
-  // Surface (Theme Aware!)
-  "surface.card": {
-    id: "surface.card",
-    domain: "color",
-    value: {
-      light: "bg-white",
-      dark: "bg-slate-800"
-    }
-  },
-  "surface.ground": {
-    id: "surface.ground",
-    domain: "color",
-    value: {
-      light: "bg-gray-50",
-      dark: "bg-slate-900"
-    }
-  },
-  "surface.paper": {
-    id: "surface.paper",
-    domain: "color",
-    value: {
-      light: "bg-white",
-      dark: "bg-slate-700"
-    }
-  },
-  // Text (Theme Aware!)
-  "text.light": {
-    id: "text.light",
-    domain: "color",
-    value: {
-      light: "text-white",
-      dark: "text-gray-100"
-    }
-  },
-  "text.dark": {
-    id: "text.dark",
-    domain: "color",
-    value: {
-      light: "text-gray-900",
-      dark: "text-white"
+// src/domain/governance/ViolationEngine.ts
+var ViolationEngine = class {
+  constructor(defaultAction = "reject", handlers) {
+    this.defaultAction = defaultAction;
+    this.handlers = /* @__PURE__ */ new Map();
+    if (handlers) {
+      for (const handler of handlers) {
+        this.handlers.set(handler.constructor.name, handler);
+      }
     }
-  },
-  "text.primary": {
-    id: "text.primary",
-    domain: "color",
-    value: {
-      light: "text-gray-900",
-      dark: "text-gray-50"
+  }
+  /**
+   * Handle a violation
+   * @param violation - The violation to handle
+   * @returns Outcome (decision, not execution)
+   */
+  handle(violation) {
+    const handler = this.handlers.get(violation.rule);
+    if (handler) {
+      return handler.handle(violation);
     }
-  },
-  "text.secondary": {
-    id: "text.secondary",
-    domain: "color",
-    value: {
-      light: "text-gray-500",
-      dark: "text-gray-400"
+    return this.createDefaultOutcome(violation);
+  }
+  /**
+   * Handle multiple violations
+   * @param violations - Array of violations
+   * @returns Array of outcomes
+   */
+  handleMultiple(violations) {
+    return violations.map((v) => this.handle(v));
+  }
+  /**
+   * Get current default action
+   * @returns Current default action
+   */
+  getCurrentDefaultAction() {
+    return this.defaultAction;
+  }
+  /**
+   * Create default outcome based on default action
+   * @param violation - The violation
+   * @returns Default outcome
+   */
+  createDefaultOutcome(violation) {
+    const currentAction = this.getCurrentDefaultAction();
+    switch (currentAction) {
+      case "reject":
+        return {
+          action: "reject",
+          metadata: {
+            contract: violation.semantic || "unknown",
+            reason: violation.message,
+            context: violation.context || {},
+            severity: violation.severity
+          }
+        };
+      case "fallback":
+        return {
+          action: "fallback",
+          replacement: this.determineFallbackValue(violation),
+          metadata: {
+            contract: violation.semantic || "unknown",
+            reason: violation.message,
+            context: violation.context || {},
+            severity: "warning"
+          }
+        };
+      case "override":
+        return {
+          action: "override",
+          metadata: {
+            contract: violation.semantic || "unknown",
+            reason: violation.message,
+            context: violation.context || {},
+            severity: "warning"
+          }
+        };
+      case "warn":
+        return {
+          action: "warn",
+          metadata: {
+            contract: violation.semantic || "unknown",
+            reason: violation.message,
+            context: violation.context || {},
+            severity: "warning"
+          }
+        };
+      default:
+        throw new Error(`Unknown action: ${currentAction}`);
     }
-  },
-  "shadow.sm": { id: "shadow.sm", domain: "effect", value: "shadow-sm" },
-  "shadow.md": { id: "shadow.md", domain: "effect", value: "shadow-md" },
-  "shadow.lg": { id: "shadow.lg", domain: "effect", value: "shadow-lg" },
-  // Radius
-  "radius.md": { id: "radius.md", domain: "layout", value: "rounded-md" },
-  "radius.lg": { id: "radius.lg", domain: "layout", value: "rounded-lg" }
-};
-
-// src/domain/TokenRegistry.ts
-var TokenRegistry = class {
-  constructor(tokens = TOKENS) {
-    this.tokens = Object.freeze({ ...tokens });
   }
   /**
-   * Get token by ID
-   * @throws Error if token not found
+   * Determine fallback value for a violation
+   * @param violation - The violation
+   * @returns Fallback value or undefined
    */
-  getToken(id) {
-    const token = this.tokens[id];
-    if (!token) {
-      throw new Error(`Token '${id}' not found in registry`);
+  determineFallbackValue(violation) {
+    const match = violation.message.match(/fallback to \[([^\]]+)\]/i);
+    if (match && match[1]) {
+      return match[1];
     }
-    return token;
+    if (violation.semantic) {
+      const parts = violation.semantic.split(".");
+      if (parts.length >= 2) {
+        const property = parts[parts.length - 1];
+        const fallbacks = {
+          "padding": "md",
+          "margin": "md",
+          "spacing": "md",
+          "radius": "md",
+          "shadow": "md",
+          "background": "surface.card",
+          "color": "color.primary"
+        };
+        if (property in fallbacks) {
+          return fallbacks[property];
+        }
+      }
+    }
+    return void 0;
   }
   /**
-   * Check if token exists
+   * Register a handler
+   * @param handler - The handler to register
    */
-  hasToken(id) {
-    return id in this.tokens;
+  registerHandler(handler) {
+    this.handlers.set(handler.constructor.name, handler);
   }
   /**
-   * Get all tokens (immutable)
+   * Unregister a handler
+   * @param handlerName - Name of handler to unregister
    */
-  getAllTokens() {
-    return this.tokens;
+  unregisterHandler(handlerName) {
+    this.handlers.delete(handlerName);
   }
-};
-
-// src/domain/ThemeResolver.ts
-var ThemeResolver = class {
   /**
-   * Resolve theme value based on current theme
+   * Get all registered handlers
+   * @returns Array of handler names
    */
-  resolve(value, theme) {
-    if (typeof value === "string") {
-      return value;
-    }
-    if (theme in value) {
-      return value[theme];
-    }
-    throw new Error(`Theme '${theme}' not found in value. Available themes: ${Object.keys(value).join(", ")}`);
+  getHandlers() {
+    return Array.from(this.handlers.keys());
   }
   /**
-   * Get current theme from context
-   * Defaults to 'light' if not specified
+   * Set default action
+   * @param action - The default action
    */
-  getCurrentTheme(context) {
-    return context?.theme || "light";
+  setDefaultAction(action) {
+    this.defaultAction = action;
   }
 };
 
-// src/domain/ContextFactory.ts
+// src/domain/factories/ContextFactory.ts
 var ContextFactory = class {
   /**
    * Create a style context with all required fields
@@ -971,7 +952,7 @@ var ContextFactory = class {
   }
 };
 
-// src/runtime/StyleContract.ts
+// src/runtime/core/StyleContract.ts
 var StyleContract = class {
   constructor(contract, constitution, engine) {
     this.contract = contract;
@@ -1068,8 +1049,51 @@ var StyleContract = class {
   }
 };
 
-// src/runtime/StyleProvider.tsx
-import { createContext, useContext, useEffect, useState } from "react";
+// src/runtime/react/StyleProvider.tsx
+import { createContext, useContext, useEffect, useState, useMemo } from "react";
+
+// src/runtime/adapters/WebPlatformAdapter.ts
+var WebPlatformAdapter = class {
+  constructor() {
+    this.platform = "web";
+  }
+  getInitialDevice() {
+    if (typeof window === "undefined") return "desktop";
+    const width = window.innerWidth;
+    if (width < 768) return "mobile";
+    if (width < 1024) return "tablet";
+    return "desktop";
+  }
+  subscribeToResize(callback) {
+    if (typeof window === "undefined") {
+      return () => {
+      };
+    }
+    const handleResize = () => {
+      const width = window.innerWidth;
+      let device = "desktop";
+      if (width < 768) device = "mobile";
+      else if (width < 1024) device = "tablet";
+      callback(device);
+    };
+    window.addEventListener("resize", handleResize);
+    handleResize();
+    return () => {
+      window.removeEventListener("resize", handleResize);
+    };
+  }
+  applyTheme(theme) {
+    if (typeof document === "undefined") return;
+    const root = document.documentElement;
+    if (theme === "dark") {
+      root.classList.add("dark");
+    } else {
+      root.classList.remove("dark");
+    }
+  }
+};
+
+// src/runtime/react/StyleProvider.tsx
 import { jsx } from "react/jsx-runtime";
 var defaultContext = {
   platform: "web",
@@ -1081,27 +1105,29 @@ var defaultContext = {
   }
 };
 var StyleEngineContext = createContext(defaultContext);
-var StyleProvider = ({ children, initialTheme = "light" }) => {
+var StyleProvider = ({
+  children,
+  initialTheme = "light",
+  adapter
+}) => {
+  const platformAdapter = useMemo(() => adapter || new WebPlatformAdapter(), [adapter]);
   const [theme, setThemeState] = useState(initialTheme);
-  const [device, setDevice] = useState("desktop");
+  const [device, setDevice] = useState(() => {
+    try {
+      return platformAdapter.getInitialDevice();
+    } catch {
+      return "desktop";
+    }
+  });
   useEffect(() => {
-    const handleResize = () => {
-      const width = window.innerWidth;
-      if (width < 640) setDevice("mobile");
-      else if (width < 1024) setDevice("tablet");
-      else setDevice("desktop");
-    };
-    handleResize();
-    window.addEventListener("resize", handleResize);
-    return () => window.removeEventListener("resize", handleResize);
-  }, []);
+    const unsubscribe = platformAdapter.subscribeToResize((newDevice) => {
+      setDevice(newDevice);
+    });
+    return unsubscribe;
+  }, [platformAdapter]);
   useEffect(() => {
-    if (theme === "dark") {
-      document.documentElement.classList.add("dark");
-    } else {
-      document.documentElement.classList.remove("dark");
-    }
-  }, [theme]);
+    platformAdapter.applyTheme(theme);
+  }, [theme, platformAdapter]);
   const toggleTheme = () => {
     setThemeState((prev) => prev === "light" ? "dark" : "light");
   };
@@ -1109,7 +1135,7 @@ var StyleProvider = ({ children, initialTheme = "light" }) => {
     setThemeState(newTheme);
   };
   const value = {
-    platform: "web",
+    platform: platformAdapter.platform,
     theme,
     device,
     toggleTheme,
@@ -1119,7 +1145,23 @@ var StyleProvider = ({ children, initialTheme = "light" }) => {
 };
 var useStyleContext = () => useContext(StyleEngineContext);
 
-// src/adapter/MasePlugin.ts
+// src/runtime/adapters/NativePlatformAdapter.ts
+var NativePlatformAdapter = class {
+  constructor() {
+    this.platform = "native";
+  }
+  getInitialDevice() {
+    return "mobile";
+  }
+  subscribeToResize(callback) {
+    return () => {
+    };
+  }
+  applyTheme(theme) {
+  }
+};
+
+// src/adapter/meta-architecture/rules/MaseValidationRule.ts
 import {
   ValidationError
 } from "@damarkuncoro/meta-architecture";
@@ -1167,6 +1209,8 @@ var MaseValidationRule = class {
     );
   }
 };
+
+// src/adapter/meta-architecture/MasePlugin.ts
 var MaseGraphValidationPlugin = class {
   constructor() {
     this.metadata = {
@@ -1188,7 +1232,46 @@ var MaseGraphValidationPlugin = class {
   }
 };
 
-// src/adapter/pipeline-factory.ts
+// src/adapter/meta-architecture/errors/MaseValidationError.ts
+var MaseValidationError = class extends Error {
+  constructor(message, code, field) {
+    super(message);
+    this.name = "ValidationError";
+    this.code = code;
+    this.field = field;
+  }
+};
+
+// src/adapter/meta-architecture/rules/MaseGovernanceRule.ts
+var MaseGovernanceRule = class {
+  constructor() {
+    this.name = "MASE-Constitutional-Compliance";
+    this.description = "Enforces strict adherence to Component Constitution using MASE SRE.";
+    this.category = "business";
+    // It's a business rule (Design System Law)
+    this.severity = "error";
+    const tokenRegistry = new TokenRegistry();
+    const themeResolver = new ThemeResolver();
+    this.engine = new StyleResolutionEngine(tokenRegistry, themeResolver);
+  }
+  async validate(target, _context) {
+    const result = this.engine.resolve(target.contract, target.constitution);
+    if (result.valid) {
+      return null;
+    }
+    const primaryViolation = result.violations[0];
+    const messages = result.violations.map((v) => `[${v.rule}] ${v.message} (${v.semantic})`).join("; ");
+    return new MaseValidationError(
+      messages,
+      primaryViolation.rule,
+      // code
+      target.constitution.componentName
+      // field/target
+    );
+  }
+};
+
+// src/adapter/meta-architecture/factories/CompliancePipelineFactory.ts
 import { ValidationPipeline } from "@damarkuncoro/meta-architecture";
 
 // src/data/constitutions/CardConstitution.ts
@@ -1219,7 +1302,7 @@ var CardConstitution = {
   ]
 };
 
-// src/adapter/pipeline-factory.ts
+// src/adapter/meta-architecture/factories/CompliancePipelineFactory.ts
 var CompliancePipelineFactory = class {
   static async createPipeline() {
     const pipeline = new ValidationPipeline();
@@ -1278,43 +1361,6 @@ var CompliancePipelineFactory = class {
   }
 };
 
-// src/adapter/rules.ts
-var MaseValidationError = class extends Error {
-  constructor(message, code, field) {
-    super(message);
-    this.name = "ValidationError";
-    this.code = code;
-    this.field = field;
-  }
-};
-var MaseGovernanceRule = class {
-  constructor() {
-    this.name = "MASE-Constitutional-Compliance";
-    this.description = "Enforces strict adherence to Component Constitution using MASE SRE.";
-    this.category = "business";
-    // It's a business rule (Design System Law)
-    this.severity = "error";
-    const tokenRegistry = new TokenRegistry();
-    const themeResolver = new ThemeResolver();
-    this.engine = new StyleResolutionEngine(tokenRegistry, themeResolver);
-  }
-  async validate(target, _context) {
-    const result = this.engine.resolve(target.contract, target.constitution);
-    if (result.valid) {
-      return null;
-    }
-    const primaryViolation = result.violations[0];
-    const messages = result.violations.map((v) => `[${v.rule}] ${v.message} (${v.semantic})`).join("; ");
-    return new MaseValidationError(
-      messages,
-      primaryViolation.rule,
-      // code
-      target.constitution.componentName
-      // field/target
-    );
-  }
-};
-
 // src/data/constitutions/ButtonConstitution.ts
 var ButtonConstitution = {
   componentName: "Button",
@@ -1340,7 +1386,17 @@ var ButtonConstitution = {
   ]
 };
 
-// src/dsl/Tokenizer.ts
+// src/dsl/lexer/TokenizerError.ts
+var TokenizerError = class extends Error {
+  constructor(message, line, column) {
+    super(message);
+    this.name = "TokenizerError";
+    this.line = line;
+    this.column = column;
+  }
+};
+
+// src/dsl/lexer/Tokenizer.ts
 var TokenType = {
   // Keywords
   CONTRACT: "CONTRACT",
@@ -1382,14 +1438,6 @@ var TokenType = {
   EOF: "EOF",
   UNKNOWN: "UNKNOWN"
 };
-var TokenizerError = class extends Error {
-  constructor(message, line, column) {
-    super(message);
-    this.name = "TokenizerError";
-    this.line = line;
-    this.column = column;
-  }
-};
 var ContractDSLTokenizer = class {
   constructor() {
     this.source = "";
@@ -1413,7 +1461,7 @@ var ContractDSLTokenizer = class {
       ["web", TokenType.WEB],
       ["native", TokenType.NATIVE],
       ["canvas", TokenType.CANVAS],
-      ["default", TokenType.DEFAULT_CTX],
+      // ['default', TokenType.DEFAULT_CTX], // Removed duplicate mapping
       ["hover", TokenType.HOVER],
       ["active", TokenType.ACTIVE],
       ["disabled", TokenType.DISABLED],
@@ -1573,7 +1621,7 @@ var ContractDSLTokenizer = class {
   }
 };
 
-// src/dsl/Parser.ts
+// src/dsl/parser/ParserError.ts
 var ParserError = class extends Error {
   constructor(message, line, column) {
     super(message);
@@ -1582,6 +1630,8 @@ var ParserError = class extends Error {
     this.column = column;
   }
 };
+
+// src/dsl/parser/Parser.ts
 var ContractDSLParser = class {
   constructor() {
     this.tokens = [];
@@ -1626,7 +1676,7 @@ var ContractDSLParser = class {
   parseDomain() {
     this.expect(TokenType.DOMAIN);
     this.expect(TokenType.COLON);
-    const domain = this.expectIdentifier();
+    const domain = this.expectDomain();
     this.expect(TokenType.SEMICOLON);
     return domain;
   }
@@ -1763,13 +1813,29 @@ var ContractDSLParser = class {
     this.advance();
     return token.value;
   }
+  /**
+   * Expect domain token
+   * @returns Domain value
+   */
+  expectDomain() {
+    const token = this.peek();
+    if (!token || token.type !== TokenType.LAYOUT && token.type !== TokenType.TYPOGRAPHY && token.type !== TokenType.COLOR && token.type !== TokenType.EFFECT && token.type !== TokenType.INTERACTION && token.type !== TokenType.IDENTIFIER) {
+      throw new ParserError(
+        `Expected domain, got ${token?.type || "EOF"}`,
+        token?.line || 0,
+        token?.column || 0
+      );
+    }
+    this.advance();
+    return token.value;
+  }
   /**
    * Expect context token
    * @returns Context value
    */
   expectContext() {
     const token = this.peek();
-    if (!token || token.type !== TokenType.MOBILE && token.type !== TokenType.TABLET && token.type !== TokenType.DESKTOP && token.type !== TokenType.LIGHT && token.type !== TokenType.DARK && token.type !== TokenType.WEB && token.type !== TokenType.NATIVE && token.type !== TokenType.CANVAS && token.type !== TokenType.DEFAULT_CTX && token.type !== TokenType.HOVER && token.type !== TokenType.ACTIVE && token.type !== TokenType.DISABLED) {
+    if (!token || token.type !== TokenType.MOBILE && token.type !== TokenType.TABLET && token.type !== TokenType.DESKTOP && token.type !== TokenType.LIGHT && token.type !== TokenType.DARK && token.type !== TokenType.WEB && token.type !== TokenType.NATIVE && token.type !== TokenType.CANVAS && token.type !== TokenType.DEFAULT_CTX && token.type !== TokenType.DEFAULT && token.type !== TokenType.HOVER && token.type !== TokenType.ACTIVE && token.type !== TokenType.DISABLED) {
       throw new ParserError(
         `Expected context, got ${token?.type || "EOF"}`,
         token?.line || 0,
@@ -1809,7 +1875,7 @@ var ContractDSLParser = class {
   }
 };
 
-// src/dsl/Validator.ts
+// src/dsl/validator/ValidationError.ts
 var ValidationError2 = class extends Error {
   constructor(message, path) {
     super(message);
@@ -1817,6 +1883,8 @@ var ValidationError2 = class extends Error {
     this.path = path;
   }
 };
+
+// src/dsl/validator/Validator.ts
 var ContractDSLValidator = class {
   constructor() {
     this.validDomains = /* @__PURE__ */ new Set([
@@ -2099,7 +2167,7 @@ var ContractDSLValidator = class {
   }
 };
 
-// src/dsl/Compiler.ts
+// src/dsl/compiler/Compiler.ts
 var ContractDSLCompiler = class {
   /**
    * Compile AST to ComponentConstitution and StyleContractDefinition
@@ -2254,7 +2322,7 @@ var ContractDSLCompiler = class {
   }
 };
 
-// src/materializer/Materializer.ts
+// src/materializer/core/MaterializationError.ts
 var MaterializationError = class extends Error {
   constructor(message, platform, semantic) {
     super(message);
@@ -2264,7 +2332,7 @@ var MaterializationError = class extends Error {
   }
 };
 
-// src/materializer/CSSMaterializer.ts
+// src/materializer/targets/CSSMaterializer.ts
 var CSSMaterializer = class {
   constructor() {
     this.semanticToCSS = this.buildSemanticToCSSMapping();
@@ -2426,7 +2494,7 @@ var CSSMaterializer = class {
   }
 };
 
-// src/materializer/RNMaterializer.ts
+// src/materializer/targets/RNMaterializer.ts
 var RNMaterializer = class {
   constructor() {
     this.semanticToRN = this.buildSemanticToRNMapping();
@@ -2541,7 +2609,7 @@ var RNMaterializer = class {
   }
 };
 
-// src/materializer/PDFMaterializer.ts
+// src/materializer/targets/PDFMaterializer.ts
 var PDFMaterializer = class {
   constructor() {
     this.semanticToPDF = this.buildSemanticToPDFMapping();
@@ -2656,6 +2724,7 @@ var PDFMaterializer = class {
   }
 };
 export {
+  AllowedTokenValidator,
   ButtonConstitution,
   CSSMaterializer,
   CanonicalStyleGraph,
@@ -2668,11 +2737,13 @@ export {
   ContractDSLTokenizer,
   ContractDSLValidator,
   DefaultViolationHandlers,
+  DomainValidator,
   MaseGovernanceRule,
   MaseGraphValidationPlugin,
   MaseValidationError,
   MaseValidationRule,
   MaterializationError,
+  NativePlatformAdapter,
   PDFMaterializer,
   RNMaterializer,
   StyleContract,
@@ -2680,8 +2751,10 @@ export {
   StyleResolutionEngine,
   TOKENS,
   ThemeResolver,
+  TokenExistenceValidator,
   TokenRegistry,
   ViolationEngine,
+  WebPlatformAdapter,
   useStyleContext
 };
 //# sourceMappingURL=index.js.map