@holoscript/core 7.0.0 → 8.0.0

package/dist/chunk-3WZEJHUQ.cjs

@@ -0,0 +1,116 @@
+'use strict';
+
+var chunkKKP7JKN4_cjs = require('./chunk-KKP7JKN4.cjs');
+var chunkHCCQLAA4_cjs = require('./chunk-HCCQLAA4.cjs');
+
+// src/compiler/StateCompiler.ts
+var StateCompiler_exports = {};
+chunkHCCQLAA4_cjs.__export(StateCompiler_exports, {
+  StateCompiler: () => exports.StateCompiler,
+  UnauthorizedStateCompilerAccessError: () => exports.UnauthorizedStateCompilerAccessError
+});
+exports.StateCompiler = void 0; exports.UnauthorizedStateCompilerAccessError = void 0;
+var init_StateCompiler = chunkHCCQLAA4_cjs.__esm({
+  "src/compiler/StateCompiler.ts"() {
+    chunkKKP7JKN4_cjs.init_AgentRBAC();
+    chunkKKP7JKN4_cjs.init_CompilerBase();
+    exports.StateCompiler = class {
+      constructor() {
+        this.anonCounter = 0;
+      }
+      /**
+       * Walk an entire HSPlusAST and extract all per-node stateBlocks.
+       *
+       * @param ast - The parse result returned by HoloScriptPlusParser.
+       * @param agentToken - JWT token proving agent identity (optional for backwards compatibility).
+       * @returns A StateShapeMap keyed by node.name (or a generated id).
+       * @throws UnauthorizedStateCompilerAccessError if token is provided but invalid.
+       */
+      compile(ast, agentToken) {
+        this.validateAccess(agentToken);
+        const shapes = /* @__PURE__ */ new Map();
+        this.walkNode(ast.root, shapes);
+        return shapes;
+      }
+      // ---------------------------------------------------------------------------
+      // RBAC enforcement
+      // ---------------------------------------------------------------------------
+      /**
+       * Validate agent has permission to compile state blocks.
+       * Skips validation when no token is provided (backwards compatibility / testing).
+       */
+      validateAccess(agentToken) {
+        if (!agentToken) return;
+        const rbac = chunkKKP7JKN4_cjs.getRBAC();
+        const decision = rbac.checkAccess({
+          token: agentToken,
+          resourceType: "ast" /* AST */,
+          operation: "read",
+          expectedWorkflowStep: "generate_assembly" /* GENERATE_ASSEMBLY */
+        });
+        if (!decision.allowed) {
+          throw new exports.UnauthorizedStateCompilerAccessError(decision, "StateCompiler");
+        }
+      }
+      /**
+       * Compile a single HSPlusNode subtree.
+       * Useful when only a portion of the AST is being (re-)compiled.
+       */
+      compileNode(node) {
+        if (!node.stateBlock || Object.keys(node.stateBlock).length === 0) {
+          return null;
+        }
+        return this.buildShape(node);
+      }
+      // ---------------------------------------------------------------------------
+      // Private helpers
+      // ---------------------------------------------------------------------------
+      walkNode(node, out) {
+        if (!node) return;
+        if (node.stateBlock && Object.keys(node.stateBlock).length > 0) {
+          const shape = this.buildShape(node);
+          out.set(shape.nodeId, shape);
+        }
+        if (Array.isArray(node.children)) {
+          for (const child of node.children) {
+            this.walkNode(child, out);
+          }
+        }
+        if (node.body && typeof node.body === "object" && !Array.isArray(node.body)) {
+          if (node.body.type) {
+            this.walkNode(node.body, out);
+          }
+        }
+      }
+      buildShape(node) {
+        const nodeId = this.resolveNodeId(node);
+        const stateBlock = node.stateBlock ?? {};
+        const vars = [];
+        const initialState = {};
+        for (const [key, value] of Object.entries(stateBlock)) {
+          if (key.startsWith("__spread_")) continue;
+          vars.push({ name: key, initialValue: value });
+          initialState[key] = value;
+        }
+        return { nodeId, initialState, vars };
+      }
+      resolveNodeId(node) {
+        if (node.name) return node.name;
+        const loc = node.loc;
+        if (loc) return `${node.type}@${loc.start.line}:${loc.start.column}`;
+        return `${node.type}_${this.anonCounter++}`;
+      }
+    };
+    exports.UnauthorizedStateCompilerAccessError = class extends chunkKKP7JKN4_cjs.UnauthorizedCompilerAccessError {
+      constructor(decision, compilerName) {
+        super(decision, "state compilation", compilerName);
+        this.name = "UnauthorizedStateCompilerAccessError";
+      }
+    };
+  }
+});
+
+exports.StateCompiler_exports = StateCompiler_exports;
+exports.init_StateCompiler = init_StateCompiler;
+//# sourceMappingURL=chunk-3WZEJHUQ.cjs.map
+//# sourceMappingURL=chunk-3WZEJHUQ.cjs.map

package/dist/chunk-4C57PR42.js

@@ -0,0 +1,468 @@
+import { __esm } from './chunk-OL46QLBJ.js';
+
+// src/traits/visual/types.ts
+var VISUAL_LAYER_PRIORITY;
+var init_types = __esm({
+  "src/traits/visual/types.ts"() {
+    VISUAL_LAYER_PRIORITY = {
+      base_material: 0,
+      surface: 1,
+      condition: 2,
+      physical: 3,
+      scale: 4,
+      lighting: 5,
+      visual_effect: 6,
+      environmental: 7,
+      mood: 8
+    };
+  }
+});
+
+// src/traits/visual/TraitVisualRegistry.ts
+var TraitVisualRegistry;
+var init_TraitVisualRegistry = __esm({
+  "src/traits/visual/TraitVisualRegistry.ts"() {
+    TraitVisualRegistry = class _TraitVisualRegistry {
+      constructor() {
+        this.configs = /* @__PURE__ */ new Map();
+      }
+      /** Get the singleton instance. */
+      static getInstance() {
+        if (!_TraitVisualRegistry.instance) {
+          _TraitVisualRegistry.instance = new _TraitVisualRegistry();
+        }
+        return _TraitVisualRegistry.instance;
+      }
+      /** Register a single trait's visual configuration. */
+      register(traitName, config) {
+        this.configs.set(traitName, config);
+      }
+      /** Register multiple trait visual configs at once. */
+      registerBatch(entries) {
+        for (const [name, config] of Object.entries(entries)) {
+          this.configs.set(name, config);
+        }
+      }
+      /** Look up a trait's visual config. Returns undefined if not registered. */
+      get(traitName) {
+        return this.configs.get(traitName);
+      }
+      /** Check if a trait has a registered visual config. */
+      has(traitName) {
+        return this.configs.has(traitName);
+      }
+      /** Get all registered configs (read-only). */
+      getAll() {
+        return this.configs;
+      }
+      /** Number of registered trait visuals. */
+      get size() {
+        return this.configs.size;
+      }
+      /** Reset the registry (primarily for testing). */
+      reset() {
+        this.configs.clear();
+      }
+    };
+  }
+});
+
+// src/traits/visual/composition-rules.ts
+var COMPOSITION_RULES;
+var init_composition_rules = __esm({
+  "src/traits/visual/composition-rules.ts"() {
+    COMPOSITION_RULES = [
+      // ══════════════════════════════════════════════════════════════════
+      // REQUIREMENT RULES — trait only applies if another trait provides
+      // the required tag (a trait cannot self-satisfy its own requirement)
+      // ══════════════════════════════════════════════════════════════════
+      // Corrosion traits only apply to objects with a metallic base
+      { trait: "rusted", requires: { tags: ["metallic"] } },
+      { trait: "tarnished", requires: { tags: ["metallic"] } },
+      { trait: "corroded", requires: { tags: ["metallic"] } },
+      // Metal finishing requires a metallic base
+      { trait: "brushed", requires: { tags: ["metallic"] } },
+      { trait: "hammered", requires: { tags: ["metallic"] } },
+      // Organic overgrowth requires an organic or mineral base
+      { trait: "moss_covered", requires: { tags: ["organic", "mineral", "stone"] } },
+      { trait: "vine_covered", requires: { tags: ["organic", "mineral", "stone"] } },
+      // Biological processes require organic base
+      { trait: "decayed", requires: { tags: ["organic"] } },
+      { trait: "fossilized", requires: { tags: ["organic"] } },
+      { trait: "witherable", requires: { tags: ["organic"] } },
+      { trait: "bloomable", requires: { tags: ["organic"] } },
+      // ══════════════════════════════════════════════════════════════════
+      // SUPPRESSION RULES — trait removes listed traits from consideration
+      // ══════════════════════════════════════════════════════════════════
+      // Pristine/brand_new suppress all damage/wear states
+      {
+        trait: "pristine",
+        suppresses: [
+          "rusted",
+          "worn",
+          "weathered",
+          "decayed",
+          "tarnished",
+          "corroded",
+          "crumbling",
+          "faded",
+          "stained",
+          "scratched",
+          "dented",
+          "chipped",
+          "cracked",
+          "shattered",
+          "battle_scarred",
+          "charred",
+          "tattered",
+          "dust_covered",
+          "moss_covered",
+          "vine_covered"
+        ]
+      },
+      {
+        trait: "brand_new",
+        suppresses: [
+          "rusted",
+          "worn",
+          "weathered",
+          "decayed",
+          "tarnished",
+          "corroded",
+          "faded",
+          "stained",
+          "scratched",
+          "dented",
+          "chipped",
+          "antique",
+          "dust_covered"
+        ]
+      },
+      // Restored suppresses active decay (but not cosmetic scars)
+      {
+        trait: "restored",
+        suppresses: ["decayed", "crumbling", "corroded", "rusted"]
+      },
+      // Mirrored overrides surface textures
+      {
+        trait: "mirrored",
+        suppresses: ["matte_surface", "frosted_surface", "brushed"]
+      },
+      // Temperature conflicts — fire and ice cancel each other
+      {
+        trait: "frozen_liquid",
+        suppresses: ["fiery", "elemental_fire", "volcanic_eruption", "boiling", "charred"]
+      },
+      {
+        trait: "elemental_fire",
+        suppresses: ["frozen_liquid", "elemental_ice", "frosted_surface"]
+      },
+      // Visibility — invisible/cloaking suppress visual effects
+      {
+        trait: "invisible",
+        suppresses: ["glowing", "neon_glow", "luminous", "bioluminescent", "holographic", "outlined"]
+      },
+      {
+        trait: "cloaking",
+        suppresses: ["glowing", "neon_glow", "holographic", "outlined"]
+      },
+      // Petrification/fossilization suppress living traits
+      {
+        trait: "petrified",
+        suppresses: ["growable", "bloomable", "photosynthetic", "witherable"]
+      },
+      {
+        trait: "fossilized",
+        suppresses: ["growable", "bloomable", "bioluminescent", "photosynthetic"]
+      },
+      // Crystallization suppresses soft surface textures
+      {
+        trait: "crystallized",
+        suppresses: ["furry", "velvety", "woolly", "silky"]
+      },
+      // Magic conflicts — blessed and cursed cancel each other
+      { trait: "cursed", suppresses: ["blessed"] },
+      { trait: "blessed", suppresses: ["cursed"] },
+      // Environmental conflicts
+      {
+        trait: "drought",
+        suppresses: ["leaking", "overflowing", "moss_covered"]
+      },
+      {
+        trait: "flood",
+        suppresses: ["drought", "dust_covered", "sandstorm"]
+      },
+      {
+        trait: "underwater",
+        suppresses: ["fiery", "elemental_fire"]
+      },
+      // ══════════════════════════════════════════════════════════════════
+      // ADDITIVE RULES — extra properties blended on top
+      // ══════════════════════════════════════════════════════════════════
+      // Frozen adds blue tint
+      { trait: "frozen_liquid", additive: { color: "#D6EAF8" } },
+      // Enchanted adds a subtle purple shimmer
+      { trait: "enchanted", additive: { emissive: "#9966FF", emissiveIntensity: 0.3 } },
+      // Ghostly adds transparency
+      { trait: "ghostly", additive: { opacity: 0.3, transparent: true } },
+      // Electric adds blue-white emissive
+      { trait: "electric_arc", additive: { emissive: "#00BFFF", emissiveIntensity: 0.5 } },
+      // Bioluminescence adds green glow
+      { trait: "bioluminescent", additive: { emissive: "#00FFAA", emissiveIntensity: 0.4 } },
+      // Iridescent/pearlescent add color-shift sheen
+      { trait: "iridescent", additive: { iridescence: 0.5 } },
+      { trait: "pearlescent", additive: { iridescence: 0.8 } },
+      // ══════════════════════════════════════════════════════════════════
+      // MULTI-TRAIT MERGE RULES — when all listed traits are present,
+      // override merged material with these values (applied last)
+      // ══════════════════════════════════════════════════════════════════
+      // ── Metal synergies ─────────────────────────────────────────────
+      // Iron + rusted = corroded bronze appearance
+      {
+        traits: ["rusted", "iron_material"],
+        merge: { color: "#6B3A1F", roughness: 0.9, metalness: 0.5 }
+      },
+      // Copper + rusted = verdigris patina
+      {
+        traits: ["rusted", "copper_material"],
+        merge: { color: "#5C8A7A", roughness: 0.7, metalness: 0.6 }
+      },
+      // Gold + polished = high-shine gold
+      {
+        traits: ["gold_material", "polished"],
+        merge: { roughness: 0.05, envMapIntensity: 2 }
+      },
+      // ── Elemental synergies ─────────────────────────────────────────
+      // Water + frozen = deep ice
+      {
+        traits: ["elemental_water", "frozen_liquid"],
+        merge: { color: "#B0D4E8", transmission: 0.85, roughness: 0.05 }
+      },
+      // Fire + angry = rage inferno
+      {
+        traits: ["elemental_fire", "angry"],
+        merge: { emissive: "#FF1100", emissiveIntensity: 3.5 }
+      },
+      // Lightning + thunderstorm = storm energy
+      {
+        traits: ["elemental_lightning", "thunderstorm"],
+        merge: { emissive: "#FFFFFF", emissiveIntensity: 4.5 }
+      },
+      // Earth + ancient = primordial stone
+      {
+        traits: ["elemental_earth", "ancient"],
+        merge: { roughness: 1, color: "#5A4A3A" }
+      },
+      // ── Magic synergies ─────────────────────────────────────────────
+      // Enchanted + ancient = magical artifact
+      {
+        traits: ["enchanted", "ancient"],
+        merge: { emissive: "#9966FF", emissiveIntensity: 0.5, color: "#8B6914" }
+      },
+      // Blessed + gold = holy golden artifact
+      {
+        traits: ["blessed", "gold_material"],
+        merge: { emissive: "#FFFACD", emissiveIntensity: 0.8, envMapIntensity: 2 }
+      },
+      // Enchanted + diamond = spellbound gem
+      {
+        traits: ["enchanted", "diamond_gem"],
+        merge: { emissive: "#CC88FF", emissiveIntensity: 0.6, iridescence: 1 }
+      },
+      // Crystal + enchanted = magical crystal
+      {
+        traits: ["crystal_gem", "enchanted"],
+        merge: { emissive: "#CC88FF", emissiveIntensity: 1, iridescence: 1 }
+      },
+      // Cursed + blood stained = profane artifact
+      {
+        traits: ["cursed", "blood_stained"],
+        merge: { emissive: "#660000", emissiveIntensity: 0.8, color: "#4A0000" }
+      },
+      // ── Age + condition synergies ───────────────────────────────────
+      // Ancient + weathered = time-worn relic
+      {
+        traits: ["ancient", "weathered"],
+        merge: { roughness: 0.95, color: "#6B5A4A" }
+      },
+      // Ancient + moss = ancient overgrown ruins
+      {
+        traits: ["ancient", "moss_covered"],
+        merge: { roughness: 0.95, color: "#3A6A2F" }
+      },
+      // Pristine + crystal = flawless crystal
+      {
+        traits: ["pristine", "crystal_gem"],
+        merge: { roughness: 0, transmission: 0.98, envMapIntensity: 2.5 }
+      },
+      // ── Nature synergies ────────────────────────────────────────────
+      // Bioluminescent + aquatic = glowing sea creature
+      {
+        traits: ["bioluminescent", "aquatic"],
+        merge: { emissive: "#00CCAA", emissiveIntensity: 1.2 }
+      },
+      // Venomous + glowing = toxic glow
+      {
+        traits: ["venomous", "glowing"],
+        merge: { emissive: "#00FF00", emissiveIntensity: 0.8, color: "#3A5A1A" }
+      },
+      // Wildfire + wooden = burning wood
+      {
+        traits: ["wildfire", "wooden"],
+        merge: { emissive: "#FF4500", emissiveIntensity: 2.5, roughness: 0.9 }
+      },
+      // ── Visual effect synergies ─────────────────────────────────────
+      // Emissive + angry mood = intense red emissive
+      {
+        traits: ["emissive", "angry"],
+        merge: { emissive: "#FF2200", emissiveIntensity: 2.5 }
+      },
+      // Holographic + ghostly = spectral hologram
+      {
+        traits: ["holographic", "ghostly"],
+        merge: { opacity: 0.2, emissive: "#88BBFF", emissiveIntensity: 1.5 }
+      },
+      // Holographic + neon = vibrant holographic display
+      {
+        traits: ["holographic", "neon_glow"],
+        merge: { emissive: "#00FFFF", emissiveIntensity: 2, opacity: 0.5 }
+      },
+      // Frozen + crystalline = ice crystal formation
+      {
+        traits: ["frozen_liquid", "crystalline"],
+        merge: { transmission: 0.9, ior: 1.31, iridescence: 0.7 }
+      },
+      // Eerie + ghostly = spectral haunting
+      {
+        traits: ["eerie", "ghostly"],
+        merge: { emissive: "#6633AA", emissiveIntensity: 0.5, opacity: 0.25 }
+      },
+      // ── Sci-fi synergies ────────────────────────────────────────────
+      // Plasma + force field = plasma barrier
+      {
+        traits: ["plasma", "force_field"],
+        merge: { emissive: "#FF00FF", emissiveIntensity: 2.5, opacity: 0.4 }
+      }
+    ];
+  }
+});
+
+// src/traits/visual/TraitCompositor.ts
+var TraitCompositor;
+var init_TraitCompositor = __esm({
+  "src/traits/visual/TraitCompositor.ts"() {
+    init_types();
+    init_TraitVisualRegistry();
+    init_composition_rules();
+    TraitCompositor = class {
+      constructor(registry, rules) {
+        this.registry = registry ?? TraitVisualRegistry.getInstance();
+        this.rules = rules ?? COMPOSITION_RULES;
+      }
+      /**
+       * Compose multiple trait visuals into a single material config.
+       * Returns only the properties that were explicitly set by at least one trait.
+       */
+      compose(traitNames) {
+        const entries = [];
+        for (const name of traitNames) {
+          const config = this.registry.get(name);
+          if (!config) continue;
+          const layer = config.layer ?? "visual_effect";
+          const priority = VISUAL_LAYER_PRIORITY[layer];
+          entries.push({ name, config, priority });
+        }
+        const suppressedTraits = this.getSuppressedTraits(traitNames);
+        const activeEntries = entries.filter((e) => !suppressedTraits.has(e.name));
+        const tagProviders = /* @__PURE__ */ new Map();
+        for (const entry of activeEntries) {
+          if (entry.config.tags) {
+            for (const tag of entry.config.tags) {
+              if (!tagProviders.has(tag)) tagProviders.set(tag, /* @__PURE__ */ new Set());
+              tagProviders.get(tag).add(entry.name);
+            }
+          }
+        }
+        const filteredEntries = activeEntries.filter((e) => {
+          return this.meetsRequirements(e.name, tagProviders);
+        });
+        filteredEntries.sort((a, b) => a.priority - b.priority);
+        const merged = {};
+        for (const entry of filteredEntries) {
+          if (entry.config.material) {
+            Object.assign(merged, entry.config.material);
+          }
+          if (entry.config.emissive) {
+            merged.emissive = entry.config.emissive.color;
+            merged.emissiveIntensity = entry.config.emissive.intensity;
+          }
+          if (entry.config.opacity !== void 0) {
+            merged.opacity = entry.config.opacity;
+            merged.transparent = entry.config.opacity < 1;
+          }
+        }
+        const activeTraitNames = filteredEntries.map((e) => e.name);
+        const activeTags = /* @__PURE__ */ new Set();
+        for (const entry of filteredEntries) {
+          if (entry.config.tags) {
+            for (const tag of entry.config.tags) {
+              activeTags.add(tag);
+            }
+          }
+        }
+        this.applyAdditiveRules(activeTraitNames, activeTags, merged);
+        return merged;
+      }
+      /** Get set of trait names suppressed by other active traits. */
+      getSuppressedTraits(traitNames) {
+        const suppressed = /* @__PURE__ */ new Set();
+        const nameSet = new Set(traitNames);
+        for (const rule of this.rules) {
+          if ("suppresses" in rule && rule.suppresses && nameSet.has(rule.trait)) {
+            for (const s of rule.suppresses) {
+              suppressed.add(s);
+            }
+          }
+        }
+        return suppressed;
+      }
+      /** Check if a trait's requirement rules are satisfied by OTHER traits' tags. */
+      meetsRequirements(traitName, tagProviders) {
+        for (const rule of this.rules) {
+          if (!("requires" in rule) || rule.trait !== traitName || !rule.requires) continue;
+          if (rule.requires.tags) {
+            const hasRequired = rule.requires.tags.some((tag) => {
+              const providers = tagProviders.get(tag);
+              if (!providers) return false;
+              for (const provider of providers) {
+                if (provider !== traitName) return true;
+              }
+              return false;
+            });
+            if (!hasRequired) return false;
+          }
+        }
+        return true;
+      }
+      /** Apply additive rules and multi-trait merge overrides. */
+      applyAdditiveRules(traitNames, allTags, merged) {
+        const nameSet = new Set(traitNames);
+        for (const rule of this.rules) {
+          if ("additive" in rule && rule.additive && nameSet.has(rule.trait)) {
+            Object.assign(merged, rule.additive);
+          }
+          if ("traits" in rule && rule.traits && "merge" in rule && rule.merge) {
+            const allPresent = rule.traits.every((t) => nameSet.has(t));
+            if (allPresent) {
+              Object.assign(merged, rule.merge);
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+export { COMPOSITION_RULES, TraitCompositor, TraitVisualRegistry, VISUAL_LAYER_PRIORITY, init_TraitCompositor, init_TraitVisualRegistry, init_composition_rules, init_types };
+//# sourceMappingURL=chunk-4C57PR42.js.map
+//# sourceMappingURL=chunk-4C57PR42.js.map