@holoscript/core 8.0.7 → 8.0.9

package/dist/chunk-OIQYIIO3.cjs

@@ -1,473 +0,0 @@
-'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

@@ -1,61 +0,0 @@
-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