@holoscript/core 7.0.0 → 8.0.1

package/dist/chunk-MXFUTKCO.js

@@ -0,0 +1,56 @@
+// src/math/vec3.ts
+function vec3NormalizeInPlace(v) {
+  const len = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+  if (len > 1e-8) {
+    v[0] /= len;
+    v[1] /= len;
+    v[2] /= len;
+  }
+  return len;
+}
+function vec3Normalize(v) {
+  const len = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+  if (len === 0) return [0, 0, 0];
+  return [v[0] / len, v[1] / len, v[2] / len];
+}
+function vec3Length(v) {
+  return Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+}
+function vec3Cross(a, b) {
+  return [
+    a[1] * b[2] - a[2] * b[1],
+    a[2] * b[0] - a[0] * b[2],
+    a[0] * b[1] - a[1] * b[0]
+  ];
+}
+function vec3CrossArray(a, b) {
+  return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+}
+function vec3Sub(a, b) {
+  return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+function vec3SubArray(a, b) {
+  return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+function vec3Add(a, b) {
+  return [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+}
+function vec3Scale(v, s) {
+  return [v[0] * s, v[1] * s, v[2] * s];
+}
+function vec3ScaleArray(v, s) {
+  return [v[0] * s, v[1] * s, v[2] * s];
+}
+function vec3Distance(a, b) {
+  const dx = b[0] - a[0];
+  const dy = b[1] - a[1];
+  const dz = b[2] - a[2];
+  return Math.sqrt(dx * dx + dy * dy + dz * dz);
+}
+function vec3Dot(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+
+export { vec3Add, vec3Cross, vec3CrossArray, vec3Distance, vec3Dot, vec3Length, vec3Normalize, vec3NormalizeInPlace, vec3Scale, vec3ScaleArray, vec3Sub, vec3SubArray };
+//# sourceMappingURL=chunk-MXFUTKCO.js.map
+//# sourceMappingURL=chunk-MXFUTKCO.js.map

package/dist/chunk-MYY4PMWX.cjs

@@ -0,0 +1,264 @@
+'use strict';
+
+// src/traits/engines/motion-matching.ts
+var TRAJECTORY_HORIZON_FRAMES = 12;
+var TRAJECTORY_FRAME_DT = 1 / 30;
+function magnitude(v) {
+  return Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
+}
+function classifyGait(speed, energyEfficiency) {
+  const efficiencyPenalty = energyEfficiency > 1 ? 0.85 : 1;
+  const adjusted = speed * efficiencyPenalty;
+  if (adjusted < 0.05) return "idle";
+  if (adjusted < 1.4) return "walk";
+  if (adjusted < 3) return "trot";
+  return "run";
+}
+function projectLinearTrajectory(velocity) {
+  const trajectory = [];
+  for (let i = 1; i <= TRAJECTORY_HORIZON_FRAMES; i++) {
+    const t = i * TRAJECTORY_FRAME_DT;
+    trajectory.push([velocity.x * t, velocity.y * t, velocity.z * t]);
+  }
+  return trajectory;
+}
+var NullMotionMatchingEngine = class {
+  constructor(modelId) {
+    this.loaded = false;
+    this.modelId = modelId;
+  }
+  async load() {
+    this.loaded = true;
+  }
+  infer(input) {
+    const speed = magnitude(input.targetVelocity);
+    const energyEfficiency = input.energyEfficiency ?? 1;
+    const phaseAdvance = (speed * 0.3 + 0.5) * input.delta;
+    const phase = (input.currentPhase + phaseAdvance) % 1;
+    const leftFootContact = phase < 0.5;
+    const rightFootContact = phase >= 0.5;
+    return {
+      pose: { joints: {}, timestamp: Date.now() },
+      phase,
+      trajectory: projectLinearTrajectory(input.targetVelocity),
+      stability: 1,
+      contactFeatures: { leftFoot: leftFootContact, rightFoot: rightFootContact },
+      gait: classifyGait(speed, energyEfficiency),
+      kineticEnergyProxy: speed * speed * energyEfficiency
+    };
+  }
+  dispose() {
+    this.loaded = false;
+  }
+};
+function createNullMotionMatchingEngine(modelId) {
+  return new NullMotionMatchingEngine(modelId);
+}
+
+// src/traits/engines/synthetic-walk-cycle.ts
+var STRIDE_AMPLITUDE_RAD = 0.6;
+var KNEE_FLEXION_AMPLITUDE_RAD = 0.5;
+var HIP_BOB_AMPLITUDE = 0.04;
+var SYNTHETIC_WALK_JOINTS = [
+  "hip",
+  "left_thigh",
+  "right_thigh",
+  "left_knee",
+  "right_knee",
+  "left_foot",
+  "right_foot"
+];
+function buildSyntheticBipedPose(phase, speed) {
+  const leftSwing = Math.sin(phase * 2 * Math.PI);
+  const rightSwing = Math.sin((phase + 0.5) * 2 * Math.PI);
+  const speedScale = Math.min(speed, 6) / 6;
+  const hipY = 1 + Math.cos(phase * 4 * Math.PI) * HIP_BOB_AMPLITUDE * speedScale;
+  const hipYawRad = leftSwing * 0.05 * speedScale;
+  const hipQuat = [0, Math.sin(hipYawRad / 2), 0, Math.cos(hipYawRad / 2)];
+  const leftThighPitchRad = leftSwing * STRIDE_AMPLITUDE_RAD * speedScale;
+  const rightThighPitchRad = rightSwing * STRIDE_AMPLITUDE_RAD * speedScale;
+  const leftThighQuat = [Math.sin(leftThighPitchRad / 2), 0, 0, Math.cos(leftThighPitchRad / 2)];
+  const rightThighQuat = [Math.sin(rightThighPitchRad / 2), 0, 0, Math.cos(rightThighPitchRad / 2)];
+  const leftKneeRad = Math.max(0, leftSwing) * KNEE_FLEXION_AMPLITUDE_RAD * speedScale;
+  const rightKneeRad = Math.max(0, rightSwing) * KNEE_FLEXION_AMPLITUDE_RAD * speedScale;
+  const leftKneeQuat = [Math.sin(leftKneeRad / 2), 0, 0, Math.cos(leftKneeRad / 2)];
+  const rightKneeQuat = [Math.sin(rightKneeRad / 2), 0, 0, Math.cos(rightKneeRad / 2)];
+  const leftFootRad = -leftThighPitchRad * 0.5;
+  const rightFootRad = -rightThighPitchRad * 0.5;
+  const leftFootQuat = [Math.sin(leftFootRad / 2), 0, 0, Math.cos(leftFootRad / 2)];
+  const rightFootQuat = [Math.sin(rightFootRad / 2), 0, 0, Math.cos(rightFootRad / 2)];
+  return {
+    hip: { position: [0, hipY, 0], rotation: hipQuat },
+    left_thigh: { position: [0.1, hipY - 0.4, 0], rotation: leftThighQuat },
+    right_thigh: { position: [-0.1, hipY - 0.4, 0], rotation: rightThighQuat },
+    left_knee: { position: [0.1, hipY - 0.8, 0], rotation: leftKneeQuat },
+    right_knee: { position: [-0.1, hipY - 0.8, 0], rotation: rightKneeQuat },
+    left_foot: { position: [0.1, hipY - 1, 0], rotation: leftFootQuat },
+    right_foot: { position: [-0.1, hipY - 1, 0], rotation: rightFootQuat }
+  };
+}
+var SyntheticWalkCycleEngine = class {
+  constructor(modelId = "synthetic_biped_walk") {
+    this.loaded = false;
+    this.modelId = modelId;
+  }
+  async load() {
+    this.loaded = true;
+  }
+  infer(input) {
+    const speed = magnitude(input.targetVelocity);
+    const energyEfficiency = input.energyEfficiency ?? 1;
+    const phaseAdvance = Math.max(speed, 0.1) * 0.5 * input.delta;
+    const phase = (input.currentPhase + phaseAdvance) % 1;
+    const joints = buildSyntheticBipedPose(phase, speed);
+    const pose = { joints, timestamp: Date.now() };
+    const leftFoot = speed < 0.05 || phase < 0.5;
+    const rightFoot = speed < 0.05 || phase >= 0.5;
+    const contactFeatures = { leftFoot, rightFoot };
+    return {
+      pose,
+      phase,
+      trajectory: projectLinearTrajectory(input.targetVelocity),
+      stability: speed > 5 ? Math.max(0.1, 1 - (speed - 5) * 0.2) : 1,
+      contactFeatures,
+      gait: classifyGait(speed, energyEfficiency),
+      kineticEnergyProxy: speed * speed * energyEfficiency
+    };
+  }
+  dispose() {
+    this.loaded = false;
+  }
+};
+function createSyntheticWalkCycleEngine(modelId) {
+  return new SyntheticWalkCycleEngine(modelId);
+}
+
+// src/traits/engines/motion-data-schema.ts
+var MOTION_DATA_SCHEMA_VERSION = 1;
+function validateTrainingFrame(frame) {
+  if (typeof frame.frameIndex !== "number" || frame.frameIndex < 0) {
+    throw new Error(`TrainingFrame: frameIndex must be a non-negative number, got ${frame.frameIndex}`);
+  }
+  if (typeof frame.phase !== "number" || frame.phase < 0 || frame.phase >= 1) {
+    throw new Error(`TrainingFrame: phase must be in [0, 1), got ${frame.phase}`);
+  }
+  if (!frame.pose || typeof frame.pose !== "object" || !frame.pose.joints) {
+    throw new Error("TrainingFrame: pose.joints required");
+  }
+  if (!frame.contactFeatures || typeof frame.contactFeatures !== "object") {
+    throw new Error("TrainingFrame: contactFeatures required");
+  }
+  const validGaits = ["idle", "walk", "trot", "run", "crouch"];
+  if (!validGaits.includes(frame.gait)) {
+    throw new Error(`TrainingFrame: gait must be one of ${validGaits.join(", ")}, got ${frame.gait}`);
+  }
+}
+function validateMotionCapture(capture) {
+  if (capture.schemaVersion !== MOTION_DATA_SCHEMA_VERSION) {
+    throw new Error(
+      `MotionCapture: schemaVersion ${capture.schemaVersion} unsupported (current=${MOTION_DATA_SCHEMA_VERSION})`
+    );
+  }
+  if (!capture.captureId || typeof capture.captureId !== "string") {
+    throw new Error("MotionCapture: captureId required");
+  }
+  if (!capture.skeletonId || typeof capture.skeletonId !== "string") {
+    throw new Error("MotionCapture: skeletonId required");
+  }
+  if (capture.fps <= 0 || capture.fps > 240) {
+    throw new Error(`MotionCapture: fps must be in (0, 240], got ${capture.fps}`);
+  }
+  if (!capture.license || !capture.license.spdx) {
+    throw new Error(
+      "MotionCapture: license.spdx required \u2014 every training capture must declare a commercial-use-compatible license (refuses CC BY-NC, GPL viral, proprietary without explicit grant)"
+    );
+  }
+  const blockedSpdx = ["CC-BY-NC-4.0", "CC-BY-NC-SA-4.0", "CC-BY-NC-ND-4.0", "GPL-3.0", "AGPL-3.0"];
+  if (blockedSpdx.includes(capture.license.spdx)) {
+    throw new Error(
+      `MotionCapture: license ${capture.license.spdx} is incompatible with @holoscript/core commercial distribution. Permitted: MIT, Apache-2.0, BSD-3-Clause, CC-BY-4.0 (with attribution), proprietary-with-grant.`
+    );
+  }
+  if (!Array.isArray(capture.frames) || capture.frames.length === 0) {
+    throw new Error("MotionCapture: frames must be a non-empty array");
+  }
+  for (const frame of capture.frames) validateTrainingFrame(frame);
+}
+function validateTrainingCorpus(corpus) {
+  if (corpus.schemaVersion !== MOTION_DATA_SCHEMA_VERSION) {
+    throw new Error(`TrainingCorpus: schemaVersion ${corpus.schemaVersion} unsupported`);
+  }
+  if (!corpus.corpusId) throw new Error("TrainingCorpus: corpusId required");
+  if (!corpus.skeletonId) throw new Error("TrainingCorpus: skeletonId required");
+  if (!corpus.splits) throw new Error("TrainingCorpus: splits required");
+  const captureIds = new Set(corpus.captures.map((c) => c.captureId));
+  const splitIds = [...corpus.splits.train, ...corpus.splits.val, ...corpus.splits.test];
+  for (const id of splitIds) {
+    if (!captureIds.has(id)) {
+      throw new Error(`TrainingCorpus: split references unknown captureId ${id}`);
+    }
+  }
+  const seenInSplit = /* @__PURE__ */ new Set();
+  for (const id of splitIds) {
+    if (seenInSplit.has(id)) {
+      throw new Error(`TrainingCorpus: captureId ${id} appears in multiple splits \u2014 data leakage`);
+    }
+    seenInSplit.add(id);
+  }
+  for (const cap of corpus.captures) {
+    if (cap.skeletonId !== corpus.skeletonId) {
+      throw new Error(
+        `TrainingCorpus: capture ${cap.captureId} skeleton ${cap.skeletonId} differs from corpus skeleton ${corpus.skeletonId}`
+      );
+    }
+    validateMotionCapture(cap);
+  }
+}
+function inferenceFrameToTensor(frame, sortedJointNames) {
+  const headerLen = 8;
+  const jointLen = sortedJointNames.length * 7;
+  const out = new Float32Array(headerLen + jointLen);
+  out[0] = frame.phase;
+  out[1] = frame.rootVelocity.x;
+  out[2] = frame.rootVelocity.y;
+  out[3] = frame.rootVelocity.z;
+  out[4] = frame.rootAngularVelocity;
+  const terrain = frame.terrainNormal ?? { x: 0, y: 1, z: 0 };
+  out[5] = terrain.x;
+  out[6] = terrain.y;
+  out[7] = terrain.z;
+  for (let i = 0; i < sortedJointNames.length; i++) {
+    const jointName = sortedJointNames[i];
+    const joint = frame.pose.joints[jointName];
+    const base = headerLen + i * 7;
+    if (joint) {
+      out[base + 0] = joint.position[0];
+      out[base + 1] = joint.position[1];
+      out[base + 2] = joint.position[2];
+      out[base + 3] = joint.rotation[0];
+      out[base + 4] = joint.rotation[1];
+      out[base + 5] = joint.rotation[2];
+      out[base + 6] = joint.rotation[3];
+    }
+  }
+  return out;
+}
+
+exports.MOTION_DATA_SCHEMA_VERSION = MOTION_DATA_SCHEMA_VERSION;
+exports.NullMotionMatchingEngine = NullMotionMatchingEngine;
+exports.SYNTHETIC_WALK_JOINTS = SYNTHETIC_WALK_JOINTS;
+exports.SyntheticWalkCycleEngine = SyntheticWalkCycleEngine;
+exports.TRAJECTORY_FRAME_DT = TRAJECTORY_FRAME_DT;
+exports.TRAJECTORY_HORIZON_FRAMES = TRAJECTORY_HORIZON_FRAMES;
+exports.buildSyntheticBipedPose = buildSyntheticBipedPose;
+exports.classifyGait = classifyGait;
+exports.createNullMotionMatchingEngine = createNullMotionMatchingEngine;
+exports.createSyntheticWalkCycleEngine = createSyntheticWalkCycleEngine;
+exports.inferenceFrameToTensor = inferenceFrameToTensor;
+exports.magnitude = magnitude;
+exports.projectLinearTrajectory = projectLinearTrajectory;
+exports.validateMotionCapture = validateMotionCapture;
+exports.validateTrainingCorpus = validateTrainingCorpus;
+exports.validateTrainingFrame = validateTrainingFrame;
+//# sourceMappingURL=chunk-MYY4PMWX.cjs.map
+//# sourceMappingURL=chunk-MYY4PMWX.cjs.map

package/dist/chunk-N75IH2HY.js

@@ -0,0 +1,258 @@
+import { __esm } from './chunk-OL46QLBJ.js';
+
+// src/compiler/identity/AgentRiskRegistry.ts
+function getAgentRiskRegistry(config) {
+  if (!globalRegistry) {
+    globalRegistry = new AgentRiskRegistry(config);
+  }
+  return globalRegistry;
+}
+function isDangerousOperation(operation) {
+  return DANGEROUS_OPERATIONS.includes(operation);
+}
+var DEFAULT_THRESHOLDS, AgentRiskRegistry, globalRegistry, DANGEROUS_OPERATIONS, TIER_COMPOSITION_RISK_CAP;
+var init_AgentRiskRegistry = __esm({
+  "src/compiler/identity/AgentRiskRegistry.ts"() {
+    DEFAULT_THRESHOLDS = {
+      medium: 15,
+      high: 40,
+      quarantined: 75
+    };
+    AgentRiskRegistry = class {
+      constructor(config = {}) {
+        /** agentId -> ring of recent events (oldest first). */
+        this.events = /* @__PURE__ */ new Map();
+        /** Lifetime counters (not decayed). */
+        this.lifetimeEvents = /* @__PURE__ */ new Map();
+        this.lifetimeSuccesses = /* @__PURE__ */ new Map();
+        this.halfLifeMs = config.halfLifeMs ?? 60 * 60 * 1e3;
+        this.tierThresholds = {
+          medium: config.tierThresholds?.medium ?? DEFAULT_THRESHOLDS.medium,
+          high: config.tierThresholds?.high ?? DEFAULT_THRESHOLDS.high,
+          quarantined: config.tierThresholds?.quarantined ?? DEFAULT_THRESHOLDS.quarantined
+        };
+        this.successCreditPerOp = config.successCreditPerOp ?? 5;
+        this.maxEventsPerAgent = config.maxEventsPerAgent ?? 256;
+        this.now = config.now ?? (() => Date.now());
+        if (this.tierThresholds.medium >= this.tierThresholds.high) {
+          throw new Error("AgentRiskRegistry: tierThresholds.medium must be < high");
+        }
+        if (this.tierThresholds.high >= this.tierThresholds.quarantined) {
+          throw new Error("AgentRiskRegistry: tierThresholds.high must be < quarantined");
+        }
+        if (this.halfLifeMs <= 0) {
+          throw new Error("AgentRiskRegistry: halfLifeMs must be > 0");
+        }
+      }
+      /**
+       * Record a confabulation event from a `ConfabulationValidationResult`.
+       *
+       * Severity is taken from the result's `riskScore`. If the result is `valid`
+       * (no errors) this records a *success*, not a confabulation event — clean
+       * passes lower the agent's running score.
+       */
+      recordValidation(agentId, result) {
+        if (result.valid && result.errors.length === 0) {
+          this.recordSuccess(agentId);
+          return;
+        }
+        const severity = Math.max(1, Math.min(100, Math.round(result.riskScore)));
+        const reason = this.summarizeErrors(result.errors);
+        this.recordEvent({
+          agentId,
+          severity,
+          reason,
+          timestamp: this.now()
+        });
+      }
+      /**
+       * Record a custom risk event (e.g. from a downstream consumer that detected
+       * confabulation outside the standard validator path).
+       */
+      recordEvent(event) {
+        const ring = this.events.get(event.agentId) ?? [];
+        ring.push(event);
+        if (ring.length > this.maxEventsPerAgent) {
+          ring.shift();
+        }
+        this.events.set(event.agentId, ring);
+        this.lifetimeEvents.set(
+          event.agentId,
+          (this.lifetimeEvents.get(event.agentId) ?? 0) + 1
+        );
+      }
+      /**
+       * Record a successful (clean) operation. Reduces the agent's accrued score
+       * by `successCreditPerOp` (post-decay, floored at 0).
+       *
+       * Implemented as a synthetic *negative* event so that decay still applies:
+       * we push a sentinel with negative severity. `getScore` clamps to >=0.
+       */
+      recordSuccess(agentId) {
+        if (this.successCreditPerOp <= 0) {
+          this.lifetimeSuccesses.set(
+            agentId,
+            (this.lifetimeSuccesses.get(agentId) ?? 0) + 1
+          );
+          return;
+        }
+        const ring = this.events.get(agentId) ?? [];
+        ring.push({
+          agentId,
+          severity: -this.successCreditPerOp,
+          reason: "clean-validation",
+          timestamp: this.now()
+        });
+        if (ring.length > this.maxEventsPerAgent) {
+          ring.shift();
+        }
+        this.events.set(agentId, ring);
+        this.lifetimeSuccesses.set(
+          agentId,
+          (this.lifetimeSuccesses.get(agentId) ?? 0) + 1
+        );
+      }
+      /**
+       * Compute the current decayed risk score for an agent (0-100).
+       *
+       * Each event contributes `severity * 0.5 ^ (age / halfLifeMs)`. Negative
+       * (success) events reduce the running total. Final score is clamped to
+       * [0, 100].
+       */
+      getScore(agentId) {
+        const ring = this.events.get(agentId);
+        if (!ring || ring.length === 0) return 0;
+        const now = this.now();
+        let score = 0;
+        for (const ev of ring) {
+          const ageMs = Math.max(0, now - ev.timestamp);
+          const decay = Math.pow(0.5, ageMs / this.halfLifeMs);
+          score += ev.severity * decay;
+        }
+        return Math.max(0, Math.min(100, score));
+      }
+      /**
+       * Classify an agent into a `RiskTier`. Pure function of `getScore`.
+       */
+      getTier(agentId) {
+        const score = this.getScore(agentId);
+        if (score >= this.tierThresholds.quarantined) return "quarantined" /* QUARANTINED */;
+        if (score >= this.tierThresholds.high) return "high" /* HIGH */;
+        if (score >= this.tierThresholds.medium) return "medium" /* MEDIUM */;
+        return "low" /* LOW */;
+      }
+      /**
+       * Snapshot of an agent's current state (for diagnostics / dashboards).
+       */
+      getSnapshot(agentId) {
+        const ring = this.events.get(agentId) ?? [];
+        const positiveEvents = ring.filter((e) => e.severity > 0);
+        const lastPositive = positiveEvents[positiveEvents.length - 1];
+        return {
+          agentId,
+          score: this.getScore(agentId),
+          tier: this.getTier(agentId),
+          recentEventCount: positiveEvents.length,
+          lifetimeEventCount: this.lifetimeEvents.get(agentId) ?? 0,
+          lifetimeSuccessCount: this.lifetimeSuccesses.get(agentId) ?? 0,
+          lastEventAt: lastPositive ? lastPositive.timestamp : null
+        };
+      }
+      /**
+       * Force-set an agent's tier by clearing history and inserting a calibration
+       * event. Used by orchestrators to quarantine a known-bad agent or to
+       * reinstate a rehabilitated one.
+       *
+       * Note: this is an *administrative* operation, not a normal flow. The
+       * caller is responsible for authorization.
+       *
+       * The inserted event is severity = midpoint of the requested tier band
+       * so that small amounts of decay between `setTier` and the next read
+       * don't bump the agent into a lower tier.
+       */
+      setTier(agentId, tier) {
+        this.events.delete(agentId);
+        if (tier === "low" /* LOW */) {
+          return;
+        }
+        let severity;
+        switch (tier) {
+          case "medium" /* MEDIUM */:
+            severity = (this.tierThresholds.medium + this.tierThresholds.high) / 2;
+            break;
+          case "high" /* HIGH */:
+            severity = (this.tierThresholds.high + this.tierThresholds.quarantined) / 2;
+            break;
+          case "quarantined" /* QUARANTINED */:
+            severity = Math.min(100, this.tierThresholds.quarantined + 10);
+            break;
+        }
+        this.recordEvent({
+          agentId,
+          severity,
+          reason: `administrative:set-tier:${tier}`,
+          timestamp: this.now()
+        });
+      }
+      /**
+       * Clear all history for an agent. Resets to LOW tier.
+       */
+      clear(agentId) {
+        this.events.delete(agentId);
+        this.lifetimeEvents.delete(agentId);
+        this.lifetimeSuccesses.delete(agentId);
+      }
+      /**
+       * Clear all state in the registry. Useful for tests.
+       */
+      clearAll() {
+        this.events.clear();
+        this.lifetimeEvents.clear();
+        this.lifetimeSuccesses.clear();
+      }
+      /**
+       * List all agents currently tracked (have at least one event).
+       */
+      listAgents() {
+        return Array.from(this.events.keys());
+      }
+      /**
+       * Configured tier thresholds (read-only view).
+       */
+      getThresholds() {
+        return { ...this.tierThresholds };
+      }
+      /**
+       * Configured half-life in ms (read-only).
+       */
+      getHalfLifeMs() {
+        return this.halfLifeMs;
+      }
+      // ---------------------------------------------------------------------------
+      // PRIVATE HELPERS
+      // ---------------------------------------------------------------------------
+      summarizeErrors(errors) {
+        if (errors.length === 0) return "no-errors";
+        if (errors.length === 1) return errors[0].code;
+        return `${errors[0].code}+${errors.length - 1}-more`;
+      }
+    };
+    globalRegistry = null;
+    DANGEROUS_OPERATIONS = [
+      "write",
+      "transform",
+      "execute"
+    ];
+    TIER_COMPOSITION_RISK_CAP = {
+      ["low" /* LOW */]: 50,
+      ["medium" /* MEDIUM */]: 25,
+      ["high" /* HIGH */]: 10,
+      ["quarantined" /* QUARANTINED */]: -1
+      // sentinel: any composition denied
+    };
+  }
+});
+
+export { TIER_COMPOSITION_RISK_CAP, getAgentRiskRegistry, init_AgentRiskRegistry, isDangerousOperation };
+//# sourceMappingURL=chunk-N75IH2HY.js.map
+//# sourceMappingURL=chunk-N75IH2HY.js.map

package/dist/chunk-NCWCUZNS.cjs

@@ -0,0 +1,72 @@
+'use strict';
+
+var chunkXB274MW5_cjs = require('./chunk-XB274MW5.cjs');
+var chunkS3MDHNKB_cjs = require('./chunk-S3MDHNKB.cjs');
+var chunkROHLEP2W_cjs = require('./chunk-ROHLEP2W.cjs');
+var chunkKKP7JKN4_cjs = require('./chunk-KKP7JKN4.cjs');
+var ans = require('@holoscript/core-types/ans');
+
+// src/compiler/MultiLayerCompiler.ts
+chunkXB274MW5_cjs.init_VRRCompiler();
+chunkS3MDHNKB_cjs.init_ARCompiler();
+chunkROHLEP2W_cjs.init_BabylonCompiler();
+chunkKKP7JKN4_cjs.init_CompilerBase();
+var MultiLayerCompiler = class extends chunkKKP7JKN4_cjs.CompilerBase {
+  constructor(options) {
+    super();
+    this.compilerName = "MultiLayerCompiler";
+    this.options = options;
+  }
+  getRequiredCapability() {
+    return ans.ANSCapabilityPath.MULTI_LAYER;
+  }
+  compile(composition, agentToken, outputPath) {
+    this.validateCompilerAccess(agentToken, outputPath);
+    const result = {
+      success: true,
+      warnings: [],
+      errors: []
+    };
+    if (this.options.targets.includes("ar")) {
+      const arCompiler = new chunkS3MDHNKB_cjs.ARCompiler({
+        target: "webxr",
+        minify: this.options.minify,
+        source_maps: this.options.source_maps,
+        features: { hit_test: true, image_tracking: true }
+      });
+      const arResult = arCompiler.compile(composition, agentToken);
+      result.ar = arResult;
+      if (!arResult.success) result.success = false;
+    }
+    if (this.options.targets.includes("vrr")) {
+      const vrrCompiler = new chunkXB274MW5_cjs.VRRCompiler({
+        target: "threejs",
+        minify: this.options.minify,
+        source_maps: this.options.source_maps,
+        performance: { target_fps: 60, max_players: 1e3, lazy_loading: true },
+        api_integrations: {}
+        // Configured upstream based on @reality_mirror traits
+      });
+      const vrrResult = vrrCompiler.compile(composition, agentToken);
+      result.vrr = vrrResult;
+      if (!vrrResult.success) result.success = false;
+    }
+    if (this.options.targets.includes("vr")) {
+      const vrCompiler = new chunkROHLEP2W_cjs.BabylonCompiler({});
+      try {
+        const vrResult = vrCompiler.compile(composition, agentToken);
+        result.vr = vrResult;
+      } catch (err) {
+        result.success = false;
+        result.errors.push(
+          `VR Compilation Error: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    return result;
+  }
+};
+
+exports.MultiLayerCompiler = MultiLayerCompiler;
+//# sourceMappingURL=chunk-NCWCUZNS.cjs.map
+//# sourceMappingURL=chunk-NCWCUZNS.cjs.map