@holoscript/core 7.0.0 → 8.0.1

package/dist/chunk-OIQYIIO3.cjs

@@ -0,0 +1,473 @@
+'use strict';
+
+var chunkHCCQLAA4_cjs = require('./chunk-HCCQLAA4.cjs');
+
+// src/traits/visual/types.ts
+exports.VISUAL_LAYER_PRIORITY = void 0;
+var init_types = chunkHCCQLAA4_cjs.__esm({
+  "src/traits/visual/types.ts"() {
+    exports.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
+exports.TraitVisualRegistry = void 0;
+var init_TraitVisualRegistry = chunkHCCQLAA4_cjs.__esm({
+  "src/traits/visual/TraitVisualRegistry.ts"() {
+    exports.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
+exports.COMPOSITION_RULES = void 0;
+var init_composition_rules = chunkHCCQLAA4_cjs.__esm({
+  "src/traits/visual/composition-rules.ts"() {
+    exports.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
+exports.TraitCompositor = void 0;
+var init_TraitCompositor = chunkHCCQLAA4_cjs.__esm({
+  "src/traits/visual/TraitCompositor.ts"() {
+    init_types();
+    init_TraitVisualRegistry();
+    init_composition_rules();
+    exports.TraitCompositor = class {
+      constructor(registry, rules) {
+        this.registry = registry ?? exports.TraitVisualRegistry.getInstance();
+        this.rules = rules ?? exports.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 = exports.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);
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+exports.init_TraitCompositor = init_TraitCompositor;
+exports.init_TraitVisualRegistry = init_TraitVisualRegistry;
+exports.init_composition_rules = init_composition_rules;
+exports.init_types = init_types;
+//# sourceMappingURL=chunk-OIQYIIO3.cjs.map
+//# sourceMappingURL=chunk-OIQYIIO3.cjs.map

package/dist/chunk-OL46QLBJ.js

@@ -0,0 +1,61 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+
+export { __commonJS, __esm, __export, __privateAdd, __privateGet, __privateMethod, __privateSet, __privateWrapper, __publicField, __require, __toCommonJS, __toESM };
+//# sourceMappingURL=chunk-OL46QLBJ.js.map
+//# sourceMappingURL=chunk-OL46QLBJ.js.map