@holoscript/core 6.0.4 → 6.1.2

package/dist/chunk-XJAN7CZG.cjs

@@ -0,0 +1,432 @@
+'use strict';
+
+// src/traits/engines/tensor-ops.ts
+function sizeOf(shape) {
+  return shape.reduce((a, b) => a * b, 1);
+}
+function createTensor(shape, data) {
+  if (!Array.isArray(shape) || shape.length === 0 || shape.some((d) => !Number.isInteger(d) || d <= 0)) {
+    throw new Error(`tensor-ops: invalid shape ${JSON.stringify(shape)}`);
+  }
+  const size = sizeOf(shape);
+  const buf = new Float32Array(size);
+  if (data) {
+    const n = Math.min(size, data.length);
+    for (let i = 0; i < n; i++) buf[i] = data[i];
+  }
+  return { shape: shape.slice(), data: buf };
+}
+function add(a, b) {
+  if (a.data.length !== b.data.length) {
+    throw new Error(
+      `tensor-ops: add shape mismatch ${JSON.stringify(a.shape)} vs ${JSON.stringify(b.shape)}`
+    );
+  }
+  const out = new Float32Array(a.data.length);
+  for (let i = 0; i < out.length; i++) out[i] = a.data[i] + b.data[i];
+  return { shape: a.shape.slice(), data: out };
+}
+function matmul(a, b) {
+  if (a.shape.length !== 2 || b.shape.length !== 2) {
+    throw new Error("tensor-ops: matmul requires 2D tensors");
+  }
+  const [m, k] = a.shape;
+  const [k2, n] = b.shape;
+  if (k !== k2) {
+    throw new Error(`tensor-ops: matmul inner dim mismatch ${k} vs ${k2}`);
+  }
+  const out = new Float32Array(m * n);
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      let acc = 0;
+      for (let p = 0; p < k; p++) acc += a.data[i * k + p] * b.data[p * n + j];
+      out[i * n + j] = acc;
+    }
+  }
+  return { shape: [m, n], data: out };
+}
+
+// src/traits/engines/pfnn-network.ts
+var PHASE_CONTROL_POINTS = 4;
+var HIDDEN_DIM = 64;
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a |= 0;
+    a = a + 1831565813 | 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function eluInPlace(data) {
+  for (let i = 0; i < data.length; i++) {
+    const x = data[i];
+    data[i] = x >= 0 ? x : Math.exp(x) - 1;
+  }
+}
+function initWeight(rng, inDim, outDim) {
+  const limit = Math.sqrt(6 / (inDim + outDim));
+  const data = new Float32Array(inDim * outDim);
+  for (let i = 0; i < data.length; i++) data[i] = (rng() * 2 - 1) * limit;
+  return { shape: [inDim, outDim], data };
+}
+function initBias(rng, outDim) {
+  const data = new Float32Array(outDim);
+  for (let i = 0; i < data.length; i++) data[i] = (rng() * 2 - 1) * 0.01;
+  return { shape: [1, outDim], data };
+}
+var PfnnNetwork = class {
+  constructor(inputDim, outputDim, seed = 2654435769, hiddenDim = HIDDEN_DIM) {
+    this.inputDim = inputDim;
+    this.outputDim = outputDim;
+    this.hiddenDim = hiddenDim;
+    const rng = mulberry32(seed);
+    this.controlPoints = [];
+    for (let c = 0; c < PHASE_CONTROL_POINTS; c++) {
+      const layers = [
+        { weight: initWeight(rng, inputDim, hiddenDim), bias: initBias(rng, hiddenDim) },
+        { weight: initWeight(rng, hiddenDim, hiddenDim), bias: initBias(rng, hiddenDim) },
+        { weight: initWeight(rng, hiddenDim, outputDim), bias: initBias(rng, outputDim) }
+      ];
+      this.controlPoints.push({ layers });
+    }
+  }
+  /**
+   * Export the raw weights — used by the .onnx provisioning script so the
+   * ONNX graph carries the identical numbers. Returned arrays are copies.
+   */
+  exportWeights() {
+    return {
+      controlPoints: this.controlPoints.map((cp) => ({
+        layers: cp.layers.map((l) => ({
+          weight: Array.from(l.weight.data),
+          bias: Array.from(l.bias.data),
+          shape: [l.weight.shape[0], l.weight.shape[1]]
+        }))
+      }))
+    };
+  }
+  /**
+   * Cyclic cubic Catmull-Rom blend of the four control points at phase φ.
+   * Holden 2017 eq. 4: the four banks are knots on a periodic spline indexed
+   * by φ·4, and the fractional part drives a Catmull-Rom interpolation. We
+   * blend per-layer weight and bias buffers.
+   */
+  blendLayer(layerIdx, phase) {
+    const t = (phase % 1 + 1) % 1;
+    const scaled = t * PHASE_CONTROL_POINTS;
+    const k = Math.floor(scaled);
+    const f = scaled - k;
+    const mod = (n) => (n % PHASE_CONTROL_POINTS + PHASE_CONTROL_POINTS) % PHASE_CONTROL_POINTS;
+    const p0 = this.controlPoints[mod(k - 1)].layers[layerIdx];
+    const p1 = this.controlPoints[mod(k)].layers[layerIdx];
+    const p2 = this.controlPoints[mod(k + 1)].layers[layerIdx];
+    const p3 = this.controlPoints[mod(k + 2)].layers[layerIdx];
+    const f2 = f * f;
+    const f3 = f2 * f;
+    const w0 = -0.5 * f3 + f2 - 0.5 * f;
+    const w1 = 1.5 * f3 - 2.5 * f2 + 1;
+    const w2 = -1.5 * f3 + 2 * f2 + 0.5 * f;
+    const w3 = 0.5 * f3 - 0.5 * f2;
+    const blend = (a, b, c, d) => {
+      const out = new Float32Array(a.data.length);
+      for (let i = 0; i < out.length; i++) {
+        out[i] = w0 * a.data[i] + w1 * b.data[i] + w2 * c.data[i] + w3 * d.data[i];
+      }
+      return { shape: a.shape.slice(), data: out };
+    };
+    return {
+      weight: blend(p0.weight, p1.weight, p2.weight, p3.weight),
+      bias: blend(p0.bias, p1.bias, p2.bias, p3.bias)
+    };
+  }
+  /**
+   * Run a real forward pass. `input` is a Float32Array of length inputDim.
+   * `phase` ∈ [0,1) selects the blended weights. Returns a Float32Array of
+   * length outputDim. Pure, deterministic, no native deps.
+   */
+  forward(input, phase) {
+    if (input.length !== this.inputDim) {
+      throw new Error(
+        `PfnnNetwork.forward: input length ${input.length} != inputDim ${this.inputDim}`
+      );
+    }
+    let x = createTensor([1, this.inputDim], input);
+    const layer0 = this.blendLayer(0, phase);
+    const layer1 = this.blendLayer(1, phase);
+    const layer2 = this.blendLayer(2, phase);
+    x = add(matmul(x, layer0.weight), layer0.bias);
+    eluInPlace(x.data);
+    x = add(matmul(x, layer1.weight), layer1.bias);
+    eluInPlace(x.data);
+    x = add(matmul(x, layer2.weight), layer2.bias);
+    return x.data;
+  }
+  /**
+   * Forward pass using ONLY control point `cp` (no phase blending). This is the
+   * exact computation the provisioned .onnx graph encodes (it bakes a single
+   * control point). Used by the pure-JS ↔ ONNX numerical-parity test to prove
+   * both paths run the identical genuine forward pass.
+   */
+  forwardControlPoint(input, cp = 0) {
+    if (input.length !== this.inputDim) {
+      throw new Error(
+        `PfnnNetwork.forwardControlPoint: input length ${input.length} != inputDim ${this.inputDim}`
+      );
+    }
+    const layers = this.controlPoints[(cp % PHASE_CONTROL_POINTS + PHASE_CONTROL_POINTS) % PHASE_CONTROL_POINTS].layers;
+    let x = createTensor([1, this.inputDim], input);
+    x = add(matmul(x, layers[0].weight), layers[0].bias);
+    eluInPlace(x.data);
+    x = add(matmul(x, layers[1].weight), layers[1].bias);
+    eluInPlace(x.data);
+    x = add(matmul(x, layers[2].weight), layers[2].bias);
+    return x.data;
+  }
+};
+var BUNDLED_MODEL_SEED = 2654435769;
+function createBundledPfnn(inputDim, outputDim) {
+  return new PfnnNetwork(inputDim, outputDim, BUNDLED_MODEL_SEED);
+}
+
+// src/traits/engines/onnx-adapter.ts
+var NoOpInferenceAdapter = class {
+  constructor() {
+    this.name = "NoOpInferenceAdapter";
+    this.preferredProvider = "cpu";
+    this.loaded = false;
+    this.modelUrl = null;
+  }
+  async load(modelUrl) {
+    this.modelUrl = modelUrl;
+    this.loaded = true;
+  }
+  runSync(request) {
+    if (!this.loaded) {
+      throw new Error("NoOpInferenceAdapter: load() must be called before run()");
+    }
+    const inputNames = Object.keys(request.inputs);
+    if (inputNames.length === 0) {
+      throw new Error("NoOpInferenceAdapter: at least one input required");
+    }
+    const firstInput = request.inputs[inputNames[0]];
+    const outputNames = request.outputs && request.outputs.length > 0 ? request.outputs : ["output"];
+    const outputs = {};
+    for (const name of outputNames) {
+      outputs[name] = {
+        data: new Float32Array(firstInput.data.length),
+        shape: firstInput.shape
+      };
+    }
+    return {
+      outputs,
+      durationMs: 0,
+      providerUsed: this.preferredProvider
+    };
+  }
+  async run(request) {
+    return this.runSync(request);
+  }
+  dispose() {
+    this.loaded = false;
+    this.modelUrl = null;
+  }
+  /** Returns the URL the adapter was loaded with — diagnostic only. */
+  get loadedModelUrl() {
+    return this.modelUrl;
+  }
+};
+function createNoOpInferenceAdapter() {
+  return new NoOpInferenceAdapter();
+}
+var PureJsInferenceAdapter = class {
+  constructor(inputDim, outputDim) {
+    this.inputDim = inputDim;
+    this.outputDim = outputDim;
+    this.name = "PureJsInferenceAdapter";
+    this.preferredProvider = "cpu";
+    this.loaded = false;
+    this.net = null;
+    this.modelUrl = null;
+  }
+  async load(modelUrl) {
+    this.modelUrl = modelUrl;
+    if (this.inputDim != null && this.outputDim != null) {
+      this.net = createBundledPfnn(this.inputDim, this.outputDim);
+    }
+    this.loaded = true;
+  }
+  ensureNet(inputDim) {
+    if (this.net && this.net.inputDim === inputDim) return this.net;
+    const outDim = this.outputDim ?? MOTION_OUTPUT_DIM_DEFAULT;
+    this.net = createBundledPfnn(inputDim, outDim);
+    return this.net;
+  }
+  /** Recover the locomotion phase from the engine's phase channels. */
+  phaseFromInput(data) {
+    const n = data.length;
+    const sinP = data[n - 4] ?? 0;
+    const cosP = data[n - 3] ?? 1;
+    return (Math.atan2(sinP, cosP) / (2 * Math.PI) + 1) % 1;
+  }
+  runSync(request) {
+    if (!this.loaded) {
+      throw new Error("PureJsInferenceAdapter: load() must be called before run()");
+    }
+    const inputNames = Object.keys(request.inputs);
+    if (inputNames.length === 0) {
+      throw new Error("PureJsInferenceAdapter: at least one input required");
+    }
+    const input = request.inputs[inputNames[0]];
+    const net = this.ensureNet(input.data.length);
+    const phase = this.phaseFromInput(input.data);
+    const start = nowMs();
+    const out = net.forward(input.data, phase);
+    const durationMs = nowMs() - start;
+    const outName = request.outputs && request.outputs.length > 0 ? request.outputs[0] : "motion_output";
+    return {
+      outputs: { [outName]: { data: out, shape: [1, out.length] } },
+      durationMs,
+      providerUsed: this.preferredProvider
+    };
+  }
+  async run(request) {
+    return this.runSync(request);
+  }
+  dispose() {
+    this.loaded = false;
+    this.net = null;
+    this.modelUrl = null;
+  }
+};
+var MOTION_OUTPUT_DIM_DEFAULT = 50;
+function nowMs() {
+  return typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
+}
+function createPureJsInferenceAdapter(inputDim, outputDim) {
+  return new PureJsInferenceAdapter(inputDim, outputDim);
+}
+var OnnxNodeInferenceAdapter = class {
+  constructor(preferredProvider = "cpu") {
+    this.name = "OnnxNodeInferenceAdapter";
+    this.loaded = false;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    this.session = null;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    this.ort = null;
+    this.resolvedPath = null;
+    this.preferredProvider = preferredProvider;
+  }
+  async load(modelUrl) {
+    const path = await resolveOnnxModelPath(modelUrl);
+    if (!path) {
+      throw new Error(
+        `OnnxNodeInferenceAdapter: no .onnx model file resolved for "${modelUrl}". Provision it with scripts/provision-motion-model.mjs or set HOLOSCRIPT_MOTION_MODELS_DIR.`
+      );
+    }
+    this.ort = await import('onnxruntime-node');
+    this.session = await this.ort.InferenceSession.create(path);
+    this.resolvedPath = path;
+    this.loaded = true;
+  }
+  async run(request) {
+    if (!this.loaded || !this.session || !this.ort) {
+      throw new Error("OnnxNodeInferenceAdapter: load() must be called before run()");
+    }
+    const inputNames = Object.keys(request.inputs);
+    if (inputNames.length === 0) {
+      throw new Error("OnnxNodeInferenceAdapter: at least one input required");
+    }
+    const feeds = {};
+    const sessionInputs = this.session.inputNames ?? [];
+    const requestEntries = Object.entries(request.inputs);
+    requestEntries.forEach(([name, tensor], i) => {
+      const target = sessionInputs[i] ?? name;
+      feeds[target] = new this.ort.Tensor("float32", tensor.data, Array.from(tensor.shape));
+    });
+    const start = nowMs();
+    const results = await this.session.run(feeds);
+    const durationMs = nowMs() - start;
+    const sessionOutputs = this.session.outputNames ?? Object.keys(results);
+    const wanted = request.outputs && request.outputs.length > 0 ? request.outputs : sessionOutputs;
+    const outputs = {};
+    wanted.forEach((name, i) => {
+      const srcName = sessionOutputs[i] ?? name;
+      const t = results[srcName] ?? results[name];
+      if (t) {
+        outputs[name] = { data: t.data, shape: t.dims.slice() };
+      }
+    });
+    return { outputs, durationMs, providerUsed: this.preferredProvider };
+  }
+  dispose() {
+    if (this.session && typeof this.session.release === "function") {
+      try {
+        void this.session.release();
+      } catch {
+      }
+    }
+    this.session = null;
+    this.ort = null;
+    this.resolvedPath = null;
+    this.loaded = false;
+  }
+  /** The on-disk path the session was created from — diagnostic only. */
+  get loadedModelPath() {
+    return this.resolvedPath;
+  }
+};
+function createOnnxNodeInferenceAdapter(preferredProvider = "cpu") {
+  return new OnnxNodeInferenceAdapter(preferredProvider);
+}
+async function resolveOnnxModelPath(modelUrl) {
+  let fs;
+  let path;
+  try {
+    fs = await import('fs');
+    path = await import('path');
+  } catch {
+    return null;
+  }
+  const exists = (p) => {
+    try {
+      return fs.existsSync(p);
+    } catch {
+      return false;
+    }
+  };
+  if (!modelUrl.startsWith("bundled://") && exists(modelUrl)) return modelUrl;
+  const id = modelUrl.startsWith("bundled://") ? modelUrl.slice("bundled://".length) : path.basename(modelUrl);
+  const fileName = id.endsWith(".onnx") ? id : `${id}.onnx`;
+  const candidates = [];
+  const envDir = process?.env?.HOLOSCRIPT_MOTION_MODELS_DIR?.trim();
+  if (envDir) candidates.push(path.join(path.resolve(envDir), fileName));
+  let dir = process?.cwd?.() ?? ".";
+  for (let i = 0; i < 8; i++) {
+    candidates.push(path.join(dir, ".models", "motion", fileName));
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return candidates.find(exists) ?? null;
+}
+
+exports.BUNDLED_MODEL_SEED = BUNDLED_MODEL_SEED;
+exports.HIDDEN_DIM = HIDDEN_DIM;
+exports.NoOpInferenceAdapter = NoOpInferenceAdapter;
+exports.OnnxNodeInferenceAdapter = OnnxNodeInferenceAdapter;
+exports.PHASE_CONTROL_POINTS = PHASE_CONTROL_POINTS;
+exports.PfnnNetwork = PfnnNetwork;
+exports.PureJsInferenceAdapter = PureJsInferenceAdapter;
+exports.add = add;
+exports.createBundledPfnn = createBundledPfnn;
+exports.createNoOpInferenceAdapter = createNoOpInferenceAdapter;
+exports.createOnnxNodeInferenceAdapter = createOnnxNodeInferenceAdapter;
+exports.createPureJsInferenceAdapter = createPureJsInferenceAdapter;
+exports.createTensor = createTensor;
+exports.eluInPlace = eluInPlace;
+exports.matmul = matmul;
+exports.resolveOnnxModelPath = resolveOnnxModelPath;
+//# sourceMappingURL=chunk-XJAN7CZG.cjs.map
+//# sourceMappingURL=chunk-XJAN7CZG.cjs.map

package/dist/chunk-XL6INWKT.js

@@ -0,0 +1,121 @@
+// src/ReactiveState.ts
+var ReactiveState = class {
+  constructor(initialState = {}) {
+    this.subscribers = /* @__PURE__ */ new Set();
+    this.state = { ...initialState };
+    this.proxy = this.createReactiveProxy(this.state);
+  }
+  createReactiveProxy(target) {
+    const self = this;
+    return new Proxy(target, {
+      get(obj, key) {
+        const val = obj[key];
+        if (val && typeof val === "object" && !Array.isArray(val)) {
+          return self.createReactiveProxy(val);
+        }
+        return val;
+      },
+      set(obj, key, value) {
+        const oldVal = obj[key];
+        obj[key] = value;
+        if (oldVal !== value) {
+          self.notify();
+        }
+        return true;
+      }
+    });
+  }
+  get(key) {
+    return this.proxy[key];
+  }
+  set(key, value) {
+    this.proxy[key] = value;
+  }
+  has(key) {
+    return this.proxy[key] !== void 0;
+  }
+  update(updates) {
+    Object.assign(this.proxy, updates);
+  }
+  subscribe(callback) {
+    this.subscribers.add(callback);
+    return () => this.subscribers.delete(callback);
+  }
+  getSnapshot() {
+    return { ...this.state };
+  }
+  getProxy() {
+    return this.proxy;
+  }
+  notify() {
+    this.subscribers.forEach((cb) => cb(this.getSnapshot()));
+  }
+};
+var ExpressionEvaluator = class {
+  constructor(context = {}) {
+    this.context = context;
+  }
+  evaluate(expression) {
+    if (typeof expression !== "string") return expression;
+    const dangerousPatterns = [
+      /\beval\s*\(/,
+      /\brequire\s*\(/,
+      /\bimport\s*\(/,
+      /\bprocess\b/,
+      /\bglobalThis?\b/,
+      /\b__dirname\b/,
+      /\b__filename\b/,
+      /\bfs\b/,
+      /\bchild_process\b/,
+      // Prototype chain / constructor escape
+      /\bconstructor\b/,
+      /\b__proto__\b/,
+      /\bprototype\b/,
+      /\bObject\s*\.\s*(create|definePropert|getProto|assign|setProto)/,
+      /\bReflect\b/,
+      /\bProxy\b/,
+      /\bFunction\b/,
+      /\barguments\b/
+    ];
+    for (const pattern of dangerousPatterns) {
+      if (pattern.test(expression)) {
+        return void 0;
+      }
+    }
+    if (expression.includes("${")) {
+      const trimmed = expression.trim();
+      const match = trimmed.match(/^\$\{([^}]+)\}$/);
+      if (match) {
+        return this.evaluate(match[1]);
+      }
+      return this.interpolate(expression);
+    }
+    const keys = Object.keys(this.context);
+    const values = Object.values(this.context);
+    try {
+      const fn = new Function(...keys, `"use strict"; return (${expression});`);
+      return fn.call(null, ...values);
+    } catch (_e) {
+      return expression;
+    }
+  }
+  interpolate(str) {
+    return str.replace(/\$\{([^}]+)\}/g, (_, expr) => {
+      const val = this.evaluate(expr);
+      return val !== void 0 ? String(val) : "";
+    });
+  }
+  updateContext(updates) {
+    Object.assign(this.context, updates);
+  }
+  setContext(context) {
+    this.context = { ...context };
+  }
+};
+function createState(initial = {}) {
+  return new ReactiveState(initial);
+}
+
+export { ExpressionEvaluator, ReactiveState, createState };
+//# sourceMappingURL=chunk-XL6INWKT.js.map
+//# sourceMappingURL=chunk-XL6INWKT.js.map

package/dist/{chunk-E3UALNFA.js → chunk-XMWZG36H.js}

@@ -1,5 +1,5 @@
-import { HoloScriptRuntime } from './chunk-LSW7P7ML.js';
-import { HoloScriptCodeParser } from './chunk-BU7VWW2K.js';
+import { HoloScriptRuntime } from './chunk-IHESJZSW.js';
+import { HoloScriptCodeParser } from './chunk-URG2SJLK.js';
 
 // src/HoloScriptDebugger.ts
 var HoloScriptDebugger = class {
@@ -417,5 +417,5 @@ function createDebugger(runtime) {
 }
 
 export { HoloScriptDebugger, createDebugger };
-//# sourceMappingURL=chunk-E3UALNFA.js.map
-//# sourceMappingURL=chunk-E3UALNFA.js.map
+//# sourceMappingURL=chunk-XMWZG36H.js.map
+//# sourceMappingURL=chunk-XMWZG36H.js.map

package/dist/{chunk-BKIGPPVM.js → chunk-XSFNHP2E.js}

@@ -1,3 +1,5 @@
+import { init_safeJsonParse, readJson } from './chunk-VVKVQZI6.js';
+
 // src/traits/traitConstraints.ts
 var BUILTIN_CONSTRAINTS = [
   // =============================================================================
@@ -593,6 +595,7 @@ var BUILTIN_CONSTRAINTS = [
 ];
 
 // src/traits/constraintConfig.ts
+init_safeJsonParse();
 function loadConstraintsFromConfig(config) {
   if (!config || typeof config !== "object") return [];
   const raw = config;
@@ -617,7 +620,7 @@ async function loadConstraintsFromFile(configPath = "holoscript.config.json") {
   try {
     const { readFileSync } = await import('fs');
     const raw = readFileSync(configPath, "utf-8");
-    const parsed = JSON.parse(raw);
+    const parsed = readJson(raw);
     return loadConstraintsFromConfig(parsed);
   } catch {
     return [];
@@ -625,5 +628,5 @@ async function loadConstraintsFromFile(configPath = "holoscript.config.json") {
 }
 
 export { BUILTIN_CONSTRAINTS, loadConstraintsFromConfig, loadConstraintsFromFile };
-//# sourceMappingURL=chunk-BKIGPPVM.js.map
-//# sourceMappingURL=chunk-BKIGPPVM.js.map
+//# sourceMappingURL=chunk-XSFNHP2E.js.map
+//# sourceMappingURL=chunk-XSFNHP2E.js.map

package/dist/{chunk-H5Z7NASB.js → chunk-XT6JY5W5.js}

@@ -1,4 +1,4 @@
-import { __esm } from './chunk-2CWOLHTE.js';
+import { __esm } from './chunk-OL46QLBJ.js';
 
 // src/traits/visual/presets/material-properties.visual.ts
 var MATERIAL_PROPERTIES_VISUALS;
@@ -1541,6 +1541,12 @@ var init_gems_minerals_visual = __esm({
         tags: ["mineral", "transparent", "reflective"],
         layer: "base_material"
       },
+      gem_resonance: {
+        emissive: { color: "#88ffcc", intensity: 0.25 },
+        opacity: 0.72,
+        tags: ["gem", "audio", "harmonic"],
+        layer: "visual_effect"
+      },
       gold_material: {
         material: { roughness: 0.3, metalness: 1, color: "#FFD700", envMapIntensity: 1.5 },
         tags: ["metallic", "precious"],
@@ -1877,6 +1883,22 @@ var init_visual_effects_visual = __esm({
         tags: ["transparent", "emissive", "scifi"],
         layer: "visual_effect"
       },
+      holographic_mesh: {
+        material: {
+          roughness: 0.02,
+          metalness: 0.2,
+          transparent: true,
+          opacity: 0.65,
+          transmission: 0.75,
+          ior: 1.45,
+          emissive: "#00D6FF",
+          emissiveIntensity: 0.9,
+          iridescence: 0.35
+        },
+        shader: "hologram",
+        tags: ["transparent", "emissive", "refractive", "mesh", "scifi"],
+        layer: "visual_effect"
+      },
       outlined: {
         tags: ["post-process", "edge"],
         layer: "visual_effect"
@@ -9658,5 +9680,5 @@ var init_xr_platform_visual = __esm({
 });
 
 export { ACCESSIBILITY_EXTENDED_VISUALS, ACCESSIBILITY_VISUALS, AGE_CONDITION_VISUALS, ANIMALS_VISUALS, ARCHITECTURE_REALESTATE_VISUALS, AUDIO_VISUALS, CONSTRUCTION_BUILDING_VISUALS, CONTAINERS_STORAGE_VISUALS, COOKING_FOOD_VISUALS, CORE_VR_INTERACTION_VISUALS, CREATURES_MYTHICAL_VISUALS, DATA_VISUALIZATION_VISUALS, EDUCATION_LEARNING_VISUALS, EMOTION_MOOD_VISUALS, ENVIRONMENTAL_BIOME_VISUALS, ENVIRONMENT_INPUT_VISUALS, FABRIC_CLOTH_VISUALS, FURNITURE_DECOR_VISUALS, GAME_MECHANICS_VISUALS, GEMS_MINERALS_VISUALS, GEOSPATIAL_WEB3_VISUALS, HEALTHCARE_MEDICAL_VISUALS, HUMANOID_AVATAR_VISUALS, INTELLIGENCE_BEHAVIOR_VISUALS, INTEROP_COPRESENCE_VISUALS, IOT_AUTONOMOUS_AGENTS_VISUALS, LIGHTING_VISUALS, LOCOMOTION_MOVEMENT_VISUALS, MAGIC_FANTASY_VISUALS, MARITIME_NAVAL_VISUALS, MATERIAL_PROPERTIES_VISUALS, MEASUREMENT_SENSING_VISUALS, MEDIA_ANALYTICS_VISUALS, MULTISENSORY_HAPTIC_VISUALS, MUSICAL_SOUND_VISUALS, MUSIC_PERFORMANCE_VISUALS, NARRATIVE_STORYTELLING_VISUALS, NATURE_LIFE_VISUALS, NETWORKING_AI_VISUALS, NPC_ROLES_VISUALS, OBJECT_INTERACTION_VISUALS, PARSER_CORE_UI_VISUALS, PHYSICAL_AFFORDANCES_VISUALS, PHYSICS_EXPANSION_VISUALS, PROCEDURAL_GENERATION_VISUALS, RESOURCE_GATHERING_VISUALS, SAFETY_BOUNDARIES_VISUALS, SCIFI_TECHNOLOGY_VISUALS, SHAPE_FORM_VISUALS, SIGNS_COMMUNICATION_VISUALS, SIMPLE_MODIFIERS_VISUALS, SIZE_SCALE_VISUALS, SOCIAL_COMMERCE_VISUALS, SOCIAL_EFFECTS_VISUALS, SPORTS_FITNESS_VISUALS, STATE_PERSISTENCE_VISUALS, SURFACE_TEXTURE_VISUALS, TIME_PERIOD_VISUALS, TRANSPORTATION_VEHICLES_VISUALS, VISUAL_EFFECTS_VISUALS, VOLUMETRIC_WEBGPU_VISUALS, WATER_FLUID_VISUALS, WEATHER_PARTICLES_VISUALS, WEATHER_PHENOMENA_VISUALS, XR_PLATFORM_VISUALS, init_accessibility_extended_visual, init_accessibility_visual, init_age_condition_visual, init_animals_visual, init_architecture_realestate_visual, init_audio_visual, init_construction_building_visual, init_containers_storage_visual, init_cooking_food_visual, init_core_vr_interaction_visual, init_creatures_mythical_visual, init_data_visualization_visual, init_education_learning_visual, init_emotion_mood_visual, init_environment_input_visual, init_environmental_biome_visual, init_fabric_cloth_visual, init_furniture_decor_visual, init_game_mechanics_visual, init_gems_minerals_visual, init_geospatial_web3_visual, init_healthcare_medical_visual, init_humanoid_avatar_visual, init_intelligence_behavior_visual, init_interop_copresence_visual, init_iot_autonomous_agents_visual, init_lighting_visual, init_locomotion_movement_visual, init_magic_fantasy_visual, init_maritime_naval_visual, init_material_properties_visual, init_measurement_sensing_visual, init_media_analytics_visual, init_multisensory_haptic_visual, init_music_performance_visual, init_musical_sound_visual, init_narrative_storytelling_visual, init_nature_life_visual, init_networking_ai_visual, init_npc_roles_visual, init_object_interaction_visual, init_parser_core_ui_visual, init_physical_affordances_visual, init_physics_expansion_visual, init_procedural_generation_visual, init_resource_gathering_visual, init_safety_boundaries_visual, init_scifi_technology_visual, init_shape_form_visual, init_signs_communication_visual, init_simple_modifiers_visual, init_size_scale_visual, init_social_commerce_visual, init_social_effects_visual, init_sports_fitness_visual, init_state_persistence_visual, init_surface_texture_visual, init_time_period_visual, init_transportation_vehicles_visual, init_visual_effects_visual, init_volumetric_webgpu_visual, init_water_fluid_visual, init_weather_particles_visual, init_weather_phenomena_visual, init_xr_platform_visual };
-//# sourceMappingURL=chunk-H5Z7NASB.js.map
-//# sourceMappingURL=chunk-H5Z7NASB.js.map
+//# sourceMappingURL=chunk-XT6JY5W5.js.map
+//# sourceMappingURL=chunk-XT6JY5W5.js.map