@holoscript/core 8.0.8 → 8.0.9

package/dist/chunk-QQFB4RT2.cjs

@@ -0,0 +1,448 @@
+'use strict';
+
+// src/traits/visual/types.ts
+var 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 = 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 = [
+  // ══════════════════════════════════════════════════════════════════
+  // 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 = 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);
+        }
+      }
+    }
+  }
+};
+
+exports.COMPOSITION_RULES = COMPOSITION_RULES;
+exports.TraitCompositor = TraitCompositor;
+exports.TraitVisualRegistry = TraitVisualRegistry;
+exports.VISUAL_LAYER_PRIORITY = VISUAL_LAYER_PRIORITY;
+//# sourceMappingURL=chunk-QQFB4RT2.cjs.map
+//# sourceMappingURL=chunk-QQFB4RT2.cjs.map

package/dist/chunk-QSYBHQAD.cjs

@@ -0,0 +1,196 @@
+'use strict';
+
+// src/traits/ControlLoopTrait.ts
+function identityN(n) {
+  const I = new Array(n * n).fill(0);
+  for (let i = 0; i < n; i++) I[i * n + i] = 1;
+  return I;
+}
+function matMul(A, r, k, B, c) {
+  const C = new Array(r * c).fill(0);
+  for (let i = 0; i < r; i++) {
+    for (let j = 0; j < c; j++) {
+      for (let l = 0; l < k; l++) {
+        C[i * c + j] += A[i * k + l] * B[l * c + j];
+      }
+    }
+  }
+  return C;
+}
+function matT(A, r, c) {
+  const T = new Array(r * c).fill(0);
+  for (let i = 0; i < r; i++) {
+    for (let j = 0; j < c; j++) {
+      T[j * r + i] = A[i * c + j];
+    }
+  }
+  return T;
+}
+function matAdd(A, B) {
+  return A.map((v, i) => v + B[i]);
+}
+function solveLinear(A, n, b) {
+  const a = Array.from({ length: n }, (_, i) => A.slice(i * n, i * n + n));
+  const x = [...b];
+  for (let k = 0; k < n; k++) {
+    let maxVal = Math.abs(a[k][k]);
+    let maxRow = k;
+    for (let i = k + 1; i < n; i++) {
+      if (Math.abs(a[i][k]) > maxVal) {
+        maxVal = Math.abs(a[i][k]);
+        maxRow = i;
+      }
+    }
+    [a[k], a[maxRow]] = [a[maxRow], a[k]];
+    [x[k], x[maxRow]] = [x[maxRow], x[k]];
+    for (let i = k + 1; i < n; i++) {
+      if (Math.abs(a[k][k]) < 1e-14) continue;
+      const f = a[i][k] / a[k][k];
+      for (let j = k; j < n; j++) a[i][j] -= f * a[k][j];
+      x[i] -= f * x[k];
+    }
+  }
+  const result = new Array(n).fill(0);
+  for (let i = n - 1; i >= 0; i--) {
+    if (Math.abs(a[i][i]) < 1e-14) {
+      result[i] = 0;
+      continue;
+    }
+    result[i] = x[i];
+    for (let j = i + 1; j < n; j++) result[i] -= a[i][j] * result[j];
+    result[i] /= a[i][i];
+  }
+  return result;
+}
+function matVec(A, r, c, x) {
+  const y = new Array(r).fill(0);
+  for (let i = 0; i < r; i++) {
+    for (let j = 0; j < c; j++) y[i] += A[i * c + j] * x[j];
+  }
+  return y;
+}
+function matScale(A, s) {
+  return A.map((v) => v * s);
+}
+function stepPid(params, setpoint, measurement, dt, state) {
+  const { Kp, Ki, Kd } = params;
+  const iMax = params.iMax ?? Infinity;
+  const alpha = params.filterCoeff ?? 1;
+  const outMin = params.outputMin ?? -Infinity;
+  const outMax = params.outputMax ?? Infinity;
+  const error = setpoint - measurement;
+  state.integralAccum += error * dt;
+  state.integralAccum = Math.max(-iMax, Math.min(iMax, state.integralAccum));
+  const rawDeriv = dt > 0 ? (error - state.prevError) / dt : 0;
+  const filtDeriv = alpha * rawDeriv + (1 - alpha) * state.prevDerivative;
+  state.prevError = error;
+  state.prevDerivative = filtDeriv;
+  const proportional = Kp * error;
+  const integral = Ki * state.integralAccum;
+  const derivative = Kd * filtDeriv;
+  const u = Math.max(outMin, Math.min(outMax, proportional + integral + derivative));
+  return { u, type: "pid", proportional, integral, derivative };
+}
+function stepMpc(params, state) {
+  const { model } = params;
+  const { A, B, n, m } = model;
+  const H = params.horizon ?? 10;
+  const Q = params.Q ?? identityN(n);
+  const Qf = params.Qf ?? Q;
+  const R = params.R ?? identityN(m);
+  const uMin = params.uMin ?? new Array(m).fill(-Infinity);
+  const uMax = params.uMax ?? new Array(m).fill(Infinity);
+  const BT = matT(B, n, m);
+  const AT = matT(A, n, n);
+  let P = [...Qf];
+  const gains = [];
+  for (let t = H - 1; t >= 0; t--) {
+    const BTP = matMul(BT, m, n, P, n);
+    const S = matMul(BTP, m, n, B, m);
+    const SpR = matAdd(S, R);
+    const BTPA = matMul(BTP, m, n, A, n);
+    const K = new Array(m * n).fill(0);
+    for (let col = 0; col < n; col++) {
+      const rhs = new Array(m).fill(0);
+      for (let row = 0; row < m; row++) rhs[row] = BTPA[row * n + col];
+      const kcol = solveLinear(SpR, m, rhs);
+      for (let row = 0; row < m; row++) K[row * n + col] = kcol[row];
+    }
+    gains[t] = K;
+    const BK = matMul(B, n, m, K, n);
+    const AmBK = A.map((v, i) => v - BK[i]);
+    const PAmBK = matMul(P, n, n, AmBK, n);
+    const ATPAmBK = matMul(AT, n, n, PAmBK, n);
+    P = matAdd(Q, ATPAmBK);
+  }
+  const horizon = [];
+  let x = [...state];
+  for (let t = 0; t < H; t++) {
+    const K = gains[t];
+    const u_raw = matVec(matScale(K, -1), m, n, x);
+    const u_t = u_raw.map((v, i) => Math.max(uMin[i], Math.min(uMax[i], v)));
+    horizon.push(...u_t);
+    const Ax = matVec(A, n, n, x);
+    const Bu = matVec(B, n, m, u_t);
+    x = Ax.map((v, i) => v + Bu[i]);
+  }
+  const firstU = horizon.slice(0, m);
+  const u = m === 1 ? firstU[0] : firstU[0];
+  return { u, type: "mpc", horizon };
+}
+function getPidState(node) {
+  let ns = node.__control_state;
+  if (!ns) {
+    ns = {};
+    node.__control_state = ns;
+  }
+  if (!ns.pid) ns.pid = { integralAccum: 0, prevError: 0, prevDerivative: 0 };
+  return ns.pid;
+}
+function resetPidState(node) {
+  const ns = node.__control_state;
+  if (ns?.pid) ns.pid = { integralAccum: 0, prevError: 0, prevDerivative: 0 };
+}
+var controlLoopHandler = {
+  name: "control_loop",
+  defaultConfig: {},
+  onAttach(node) {
+    node.__control_state = {};
+    node.__control_output = null;
+  },
+  onEvent(node, config, _ctx, event) {
+    const n = node;
+    if (event.type === "control_loop.reset") {
+      resetPidState(n);
+      n.__control_output = null;
+      return;
+    }
+    if (event.type === "control_loop.pid_step") {
+      const req = event;
+      const params = req.params ?? config.pid;
+      if (!params) return;
+      const state = getPidState(n);
+      n.__control_output = stepPid(
+        params,
+        req.setpoint,
+        req.measurement,
+        req.dt ?? 1,
+        state
+      );
+      return;
+    }
+    if (event.type === "control_loop.mpc_step") {
+      const req = event;
+      const params = req.params ?? config.mpc;
+      if (!params) return;
+      n.__control_output = stepMpc(params, req.state);
+      return;
+    }
+  }
+};
+
+exports.controlLoopHandler = controlLoopHandler;
+exports.stepMpc = stepMpc;
+exports.stepPid = stepPid;
+//# sourceMappingURL=chunk-QSYBHQAD.cjs.map
+//# sourceMappingURL=chunk-QSYBHQAD.cjs.map