@holoscript/framework 6.0.3 → 6.0.4

package/dist/training/index.js

@@ -1,2687 +0,0 @@
-// src/training/SpatialTrainingDataGenerator.ts
-var SeededRandom = class {
-  state;
-  constructor(seed) {
-    this.state = seed;
-  }
-  /** Returns a float in [0, 1) */
-  next() {
-    this.state |= 0;
-    this.state = this.state + 1831565813 | 0;
-    let t = Math.imul(this.state ^ this.state >>> 15, 1 | this.state);
-    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
-    return ((t ^ t >>> 14) >>> 0) / 4294967296;
-  }
-  /** Returns an integer in [min, max] inclusive */
-  int(min, max) {
-    return Math.floor(this.next() * (max - min + 1)) + min;
-  }
-  /** Returns a float in [min, max) */
-  float(min, max) {
-    return this.next() * (max - min) + min;
-  }
-  /** Picks a random element from an array */
-  pick(array) {
-    return array[this.int(0, array.length - 1)];
-  }
-  /** Shuffles an array in place */
-  shuffle(array) {
-    const result = [...array];
-    for (let i = result.length - 1; i > 0; i--) {
-      const j = this.int(0, i);
-      [result[i], result[j]] = [result[j], result[i]];
-    }
-    return result;
-  }
-};
-var ADJACENT_QUESTION_TEMPLATES = [
-  {
-    question: (src, tgt, _d, maxDist) => `Is "${src}" within ${maxDist}m of "${tgt}" in this scene?`,
-    positiveAnswer: (src, tgt, dist, maxDist) => `Yes. "${src}" is ${dist.toFixed(1)}m from "${tgt}", which is within the ${maxDist}m adjacency constraint.`,
-    negativeAnswer: (src, tgt, dist, maxDist) => `No. "${src}" is ${dist.toFixed(1)}m from "${tgt}", which exceeds the ${maxDist}m adjacency constraint.`
-  },
-  {
-    question: (src, tgt) => `Are "${src}" and "${tgt}" adjacent to each other?`,
-    positiveAnswer: (src, tgt, dist) => `Yes, "${src}" and "${tgt}" are adjacent. They are ${dist.toFixed(1)}m apart, satisfying the adjacency constraint.`,
-    negativeAnswer: (src, tgt, dist, maxDist) => `No, "${src}" and "${tgt}" are not adjacent. At ${dist.toFixed(1)}m apart, they exceed the ${maxDist}m maximum distance.`
-  },
-  {
-    question: (src, tgt, _d, maxDist) => `Does the spatial_adjacent constraint between "${src}" and "${tgt}" (maxDistance: ${maxDist}m) pass?`,
-    positiveAnswer: (src, tgt, dist, maxDist) => `The constraint passes. The distance between "${src}" and "${tgt}" is ${dist.toFixed(1)}m, within the ${maxDist}m limit.`,
-    negativeAnswer: (src, tgt, dist, maxDist) => `The constraint fails. The distance between "${src}" and "${tgt}" is ${dist.toFixed(1)}m, exceeding the ${maxDist}m limit.`
-  },
-  {
-    question: (src, tgt) => `What is the spatial relationship between "${src}" and "${tgt}"? Are they close enough to interact?`,
-    positiveAnswer: (src, tgt, dist) => `"${src}" and "${tgt}" are close enough to interact. They are ${dist.toFixed(1)}m apart, within the adjacency threshold.`,
-    negativeAnswer: (src, tgt, dist) => `"${src}" and "${tgt}" are too far apart to interact. At ${dist.toFixed(1)}m apart, they fail the adjacency check.`
-  },
-  {
-    question: (src, tgt, _d, maxDist) => `Can "${src}" reach "${tgt}" given the ${maxDist}m adjacency requirement?`,
-    positiveAnswer: (src, tgt, dist) => `Yes, "${src}" can reach "${tgt}". The current distance of ${dist.toFixed(1)}m satisfies the adjacency requirement.`,
-    negativeAnswer: (src, tgt, dist, maxDist) => `No, "${src}" cannot reach "${tgt}". The ${dist.toFixed(1)}m distance exceeds the ${maxDist}m requirement.`
-  },
-  {
-    question: (src, tgt) => `In this HoloScript composition, evaluate whether "${src}" satisfies its adjacency constraint with "${tgt}".`,
-    positiveAnswer: (src, tgt, dist, maxDist) => `The adjacency constraint is satisfied. "${src}" is ${dist.toFixed(1)}m from "${tgt}" (max allowed: ${maxDist}m).`,
-    negativeAnswer: (src, tgt, dist, maxDist) => `The adjacency constraint is violated. "${src}" is ${dist.toFixed(1)}m from "${tgt}" but must be within ${maxDist}m.`
-  },
-  {
-    question: (_src, _tgt, _d, maxDist) => `Which objects in this scene are within ${maxDist}m of each other?`,
-    positiveAnswer: (src, tgt, dist) => `"${src}" and "${tgt}" are within range at ${dist.toFixed(1)}m apart.`,
-    negativeAnswer: (src, tgt, dist) => `"${src}" and "${tgt}" are NOT within range. They are ${dist.toFixed(1)}m apart.`
-  },
-  {
-    question: (src, tgt) => `If I move "${src}" to its current position, will it still be adjacent to "${tgt}"?`,
-    positiveAnswer: (_src, _tgt, dist, maxDist) => `Yes, at its current position the distance is ${dist.toFixed(1)}m, which maintains adjacency (max: ${maxDist}m).`,
-    negativeAnswer: (_src, _tgt, dist, maxDist) => `No, at its current position the distance is ${dist.toFixed(1)}m, which breaks the ${maxDist}m adjacency constraint.`
-  },
-  {
-    question: (src, tgt, _d, maxDist) => `How far is "${src}" from "${tgt}"? Is it within the ${maxDist}m threshold?`,
-    positiveAnswer: (src, tgt, dist, maxDist) => `"${src}" is ${dist.toFixed(1)}m from "${tgt}". This is within the ${maxDist}m threshold, so the adjacency holds.`,
-    negativeAnswer: (src, tgt, dist, maxDist) => `"${src}" is ${dist.toFixed(1)}m from "${tgt}". This exceeds the ${maxDist}m threshold, so adjacency is violated.`
-  },
-  {
-    question: (src, tgt) => `Analyze the spatial_adjacent constraint: is "${src}" properly positioned relative to "${tgt}"?`,
-    positiveAnswer: (src, tgt, dist, maxDist) => `"${src}" is properly positioned at ${dist.toFixed(1)}m from "${tgt}", satisfying the ${maxDist}m adjacency constraint.`,
-    negativeAnswer: (src, tgt, dist, maxDist) => `"${src}" is improperly positioned at ${dist.toFixed(1)}m from "${tgt}". It should be within ${maxDist}m.`
-  },
-  {
-    question: (src, tgt) => `Does the scene layout satisfy the proximity requirement between "${src}" and "${tgt}"?`,
-    positiveAnswer: (src, tgt, dist) => `Yes, the proximity requirement is satisfied. "${src}" and "${tgt}" are ${dist.toFixed(1)}m apart.`,
-    negativeAnswer: (src, tgt, dist, maxDist) => `No, the proximity requirement is not satisfied. "${src}" is ${dist.toFixed(1)}m from "${tgt}" (max: ${maxDist}m).`
-  },
-  {
-    question: (src, tgt, _d, maxDist) => `Given the HoloScript scene below, would placing "${src}" at its position violate the ${maxDist}m adjacency with "${tgt}"?`,
-    positiveAnswer: (_src, _tgt, dist, maxDist) => `No violation. The position results in a ${dist.toFixed(1)}m distance, within the ${maxDist}m limit.`,
-    negativeAnswer: (_src, _tgt, dist, maxDist) => `Violation detected. The position results in a ${dist.toFixed(1)}m distance, exceeding the ${maxDist}m limit.`
-  }
-];
-var CONTAINS_QUESTION_TEMPLATES = [
-  {
-    question: (container, contained) => `Is "${contained}" inside "${container}"?`,
-    positiveAnswer: (container, contained) => `Yes, "${contained}" is fully contained within "${container}"'s bounds.`,
-    negativeAnswer: (container, contained) => `No, "${contained}" is outside "${container}"'s bounds.`
-  },
-  {
-    question: (container, contained) => `Does "${container}" contain "${contained}" according to the spatial_contains constraint?`,
-    positiveAnswer: (container, contained) => `Yes, the spatial_contains constraint is satisfied. "${contained}" is within "${container}".`,
-    negativeAnswer: (container, contained) => `No, the spatial_contains constraint is violated. "${contained}" extends beyond "${container}"'s bounds.`
-  },
-  {
-    question: (container, contained) => `Verify whether "${contained}" fits entirely within "${container}"'s bounding volume.`,
-    positiveAnswer: (container, contained) => `Verified: "${contained}" fits entirely within "${container}"'s bounding volume.`,
-    negativeAnswer: (container, contained) => `Verification failed: "${contained}" does not fit within "${container}"'s bounding volume.`
-  },
-  {
-    question: (container) => `Which objects are inside "${container}" in this scene?`,
-    positiveAnswer: (container, contained) => `"${contained}" is inside "${container}", satisfying the containment constraint.`,
-    negativeAnswer: (container, contained) => `"${contained}" is NOT inside "${container}". It has moved outside the container bounds.`
-  },
-  {
-    question: (container, contained) => `If "${container}" has bounds from its declared size, is "${contained}" at its current position within those bounds?`,
-    positiveAnswer: (_container, contained) => `Yes, "${contained}" at its current position falls within the container's declared bounds.`,
-    negativeAnswer: (_container, contained) => `No, "${contained}" at its current position falls outside the container's declared bounds.`
-  },
-  {
-    question: (container, contained) => `Evaluate the containment relationship: does "${container}" enclose "${contained}"?`,
-    positiveAnswer: (container, contained) => `"${container}" successfully encloses "${contained}". The containment constraint is satisfied.`,
-    negativeAnswer: (container, contained) => `"${container}" does not enclose "${contained}". The containment constraint is violated.`
-  },
-  {
-    question: (container, contained) => `In this HoloScript composition, check if "${contained}" remains within the zone defined by "${container}".`,
-    positiveAnswer: (container, contained) => `"${contained}" remains within the zone defined by "${container}".`,
-    negativeAnswer: (container, contained) => `"${contained}" has left the zone defined by "${container}".`
-  },
-  {
-    question: (container, contained) => `Can "${contained}" exist at its current position without violating the containment constraint with "${container}"?`,
-    positiveAnswer: (_container, contained) => `Yes, "${contained}" can exist at its current position. It is within the container bounds.`,
-    negativeAnswer: (_container, contained) => `No, "${contained}" at its current position violates the containment constraint. It is outside the bounds.`
-  },
-  {
-    question: (container, contained) => `Does the bounding box of "${container}" fully enclose the position of "${contained}"?`,
-    positiveAnswer: (container, contained) => `Yes, "${container}"'s bounding box fully encloses "${contained}"'s position.`,
-    negativeAnswer: (container, contained) => `No, "${container}"'s bounding box does not enclose "${contained}"'s position.`
-  },
-  {
-    question: (container, contained) => `Analyze the spatial hierarchy: is "${contained}" a valid child within "${container}"'s spatial region?`,
-    positiveAnswer: (container, contained) => `"${contained}" is a valid child within "${container}"'s spatial region. Containment is satisfied.`,
-    negativeAnswer: (container, contained) => `"${contained}" is NOT a valid child within "${container}"'s spatial region. It extends outside the boundaries.`
-  },
-  {
-    question: (container, contained) => `Given the margin constraint, is "${contained}" properly contained within "${container}"?`,
-    positiveAnswer: (container, contained) => `With the margin applied, "${contained}" is properly contained within "${container}".`,
-    negativeAnswer: (container, contained) => `With the margin applied, "${contained}" is NOT properly contained within "${container}". It is too close to or beyond the boundary.`
-  },
-  {
-    question: (container, contained) => `Would moving "${contained}" to its declared position cause it to exit "${container}"?`,
-    positiveAnswer: (container, contained) => `No, "${contained}" at its declared position remains inside "${container}".`,
-    negativeAnswer: (container, contained) => `Yes, "${contained}" at its declared position would be outside "${container}".`
-  }
-];
-var REACHABLE_QUESTION_TEMPLATES = [
-  {
-    question: (src, tgt) => `Is there a clear path from "${src}" to "${tgt}"?`,
-    positiveAnswer: (src, tgt, pathLen) => `Yes, there is a clear path from "${src}" to "${tgt}" with a path length of ${pathLen.toFixed(1)}m.`,
-    negativeAnswer: (src, tgt, blocker) => `No, the path from "${src}" to "${tgt}" is blocked by "${blocker}".`
-  },
-  {
-    question: (src, tgt) => `Can "${src}" reach "${tgt}" without obstruction?`,
-    positiveAnswer: (src, tgt, pathLen) => `Yes, "${src}" can reach "${tgt}" unobstructed. The path length is ${pathLen.toFixed(1)}m.`,
-    negativeAnswer: (src, tgt, blocker) => `No, "${src}" cannot reach "${tgt}". The obstacle "${blocker}" blocks the path.`
-  },
-  {
-    question: (src, tgt) => `Does the spatial_reachable constraint between "${src}" and "${tgt}" pass?`,
-    positiveAnswer: (src, tgt, pathLen) => `The constraint passes. "${src}" can reach "${tgt}" via a ${pathLen.toFixed(1)}m path.`,
-    negativeAnswer: (src, tgt, blocker) => `The constraint fails. "${blocker}" obstructs the path between "${src}" and "${tgt}".`
-  },
-  {
-    question: (src, tgt, obstacles) => `Given obstacles [${obstacles.map((o) => `"${o}"`).join(", ")}], can "${src}" see "${tgt}"?`,
-    positiveAnswer: (src, tgt) => `Yes, despite the obstacles, "${src}" has line of sight to "${tgt}".`,
-    negativeAnswer: (src, tgt, blocker) => `No, "${blocker}" blocks the line of sight from "${src}" to "${tgt}".`
-  },
-  {
-    question: (src, tgt) => `Evaluate whether "${src}" has an unobstructed path to "${tgt}" in this scene.`,
-    positiveAnswer: (src, tgt, pathLen) => `"${src}" has an unobstructed path to "${tgt}" measuring ${pathLen.toFixed(1)}m.`,
-    negativeAnswer: (src, tgt, blocker) => `"${src}" does NOT have an unobstructed path to "${tgt}". "${blocker}" is in the way.`
-  },
-  {
-    question: (src, tgt) => `In this HoloScript scene, is "${tgt}" reachable from "${src}"?`,
-    positiveAnswer: (_src, tgt, pathLen) => `Yes, "${tgt}" is reachable with a direct path of ${pathLen.toFixed(1)}m.`,
-    negativeAnswer: (_src, tgt, blocker) => `No, "${tgt}" is not reachable. An obstacle ("${blocker}") blocks the direct path.`
-  },
-  {
-    question: (src, tgt) => `Check the reachability constraint: can "${src}" navigate to "${tgt}"?`,
-    positiveAnswer: (src, tgt, pathLen) => `Reachability check passed: "${src}" can navigate to "${tgt}" (${pathLen.toFixed(1)}m path).`,
-    negativeAnswer: (src, tgt, blocker) => `Reachability check failed: "${src}" cannot navigate to "${tgt}" due to "${blocker}".`
-  },
-  {
-    question: (src, tgt) => `Is the line of sight between "${src}" and "${tgt}" clear?`,
-    positiveAnswer: (src, tgt) => `Yes, line of sight between "${src}" and "${tgt}" is clear.`,
-    negativeAnswer: (src, tgt, blocker) => `No, line of sight is blocked. "${blocker}" obstructs the view from "${src}" to "${tgt}".`
-  },
-  {
-    question: (src, tgt, obstacles) => `Considering ${obstacles.length} obstacle(s) in the scene, determine if "${src}" can reach "${tgt}".`,
-    positiveAnswer: (src, tgt, pathLen) => `Despite the obstacles, "${src}" can reach "${tgt}" via a ${pathLen.toFixed(1)}m path that avoids all obstructions.`,
-    negativeAnswer: (src, tgt, blocker) => `"${src}" cannot reach "${tgt}". The path is blocked by "${blocker}".`
-  },
-  {
-    question: (src, tgt) => `Would placing a wall between "${src}" and "${tgt}" affect reachability? Analyze the current state.`,
-    positiveAnswer: (src, tgt) => `Currently, "${src}" and "${tgt}" are mutually reachable. Adding a wall could change this.`,
-    negativeAnswer: (src, tgt, blocker) => `Currently, "${src}" and "${tgt}" are NOT reachable due to "${blocker}". Adding more walls would not change this.`
-  },
-  {
-    question: (src, tgt) => `Analyze path connectivity: does an unblocked route exist from "${src}" to "${tgt}"?`,
-    positiveAnswer: (src, tgt, pathLen) => `An unblocked route exists from "${src}" to "${tgt}" with a total distance of ${pathLen.toFixed(1)}m.`,
-    negativeAnswer: (src, tgt, blocker) => `No unblocked route exists from "${src}" to "${tgt}". "${blocker}" creates a barrier.`
-  },
-  {
-    question: (src, tgt) => `For NPC pathfinding, can "${src}" walk to "${tgt}" in a straight line?`,
-    positiveAnswer: (src, tgt, pathLen) => `Yes, "${src}" can walk directly to "${tgt}" in a straight line (${pathLen.toFixed(1)}m).`,
-    negativeAnswer: (src, tgt, blocker) => `No, "${src}" cannot walk straight to "${tgt}". "${blocker}" is obstructing the direct path.`
-  }
-];
-var OBJECT_NAMES = [
-  "Table",
-  "Chair",
-  "Lamp",
-  "Bookshelf",
-  "Desk",
-  "Sofa",
-  "Cabinet",
-  "Mirror",
-  "Plant",
-  "Clock",
-  "Vase",
-  "Rug",
-  "Painting",
-  "Shelf",
-  "Stool",
-  "Bench",
-  "Chest",
-  "Barrel",
-  "Crate",
-  "Box",
-  "Pillar",
-  "Statue",
-  "Crystal",
-  "Orb",
-  "Pedestal",
-  "Platform",
-  "Beacon",
-  "Terminal",
-  "Console",
-  "Panel"
-];
-var ZONE_NAMES = [
-  "Room",
-  "Hall",
-  "Chamber",
-  "Arena",
-  "Gallery",
-  "Vault",
-  "Atrium",
-  "Courtyard",
-  "Alcove",
-  "Corridor",
-  "Laboratory",
-  "Workshop"
-];
-var OBSTACLE_NAMES = [
-  "Wall",
-  "Barrier",
-  "Fence",
-  "Pillar",
-  "Column",
-  "Boulder",
-  "Shield",
-  "Gate",
-  "Blockade",
-  "Partition",
-  "Divider",
-  "Screen"
-];
-var NPC_NAMES = [
-  "Guard",
-  "Merchant",
-  "Explorer",
-  "Scout",
-  "Villager",
-  "Artisan",
-  "Drone",
-  "Robot",
-  "Companion",
-  "Agent",
-  "Sentinel",
-  "Worker"
-];
-var GEOMETRY_TYPES = ["cube", "sphere", "cylinder", "torus", "cone", "prism"];
-var COLORS = [
-  "#ff0000",
-  "#00ff00",
-  "#0000ff",
-  "#ffff00",
-  "#ff00ff",
-  "#00ffff",
-  "#ff8800",
-  "#8800ff",
-  "#00ff88",
-  "#ff0088",
-  "#888888",
-  "#ffffff"
-];
-function generateObjectBlock(obj, indent = "  ") {
-  const lines = [];
-  lines.push(`${indent}object "${obj.id}" {`);
-  if (obj.geometry) {
-    lines.push(`${indent}  geometry: "${obj.geometry}"`);
-  }
-  lines.push(
-    `${indent}  position: [${obj.position.x.toFixed(1)}, ${obj.position.y.toFixed(1)}, ${obj.position.z.toFixed(1)}]`
-  );
-  if (obj.scale.x !== 1 || obj.scale.y !== 1 || obj.scale.z !== 1) {
-    lines.push(
-      `${indent}  scale: [${obj.scale.x.toFixed(1)}, ${obj.scale.y.toFixed(1)}, ${obj.scale.z.toFixed(1)}]`
-    );
-  }
-  if (obj.color) {
-    lines.push(`${indent}  color: "${obj.color}"`);
-  }
-  lines.push(`${indent}}`);
-  return lines.join("\n");
-}
-function generateZoneBlock(obj, indent = "  ") {
-  const lines = [];
-  lines.push(`${indent}zone "${obj.id}" {`);
-  lines.push(`${indent}  shape: "box"`);
-  const sx = obj.scale.x;
-  const sy = obj.scale.y;
-  const sz = obj.scale.z;
-  lines.push(`${indent}  size: [${sx.toFixed(1)}, ${sy.toFixed(1)}, ${sz.toFixed(1)}]`);
-  lines.push(
-    `${indent}  position: [${obj.position.x.toFixed(1)}, ${obj.position.y.toFixed(1)}, ${obj.position.z.toFixed(1)}]`
-  );
-  lines.push(`${indent}}`);
-  return lines.join("\n");
-}
-function generateAdjacentTrait(targetId, maxDist, axis) {
-  const parts = [`target: "${targetId}"`, `maxDistance: ${maxDist.toFixed(1)}m`];
-  if (axis && axis !== "xyz") {
-    parts.push(`axis: "${axis}"`);
-  }
-  return `@spatial_adjacent(${parts.join(", ")})`;
-}
-function generateContainsTrait(targetId, margin, strict) {
-  const parts = [`target: "${targetId}"`];
-  if (margin !== void 0 && margin > 0) {
-    parts.push(`margin: ${margin.toFixed(1)}m`);
-  }
-  if (strict) {
-    parts.push("strict: true");
-  }
-  return `@spatial_contains(${parts.join(", ")})`;
-}
-function generateReachableTrait(targetId, maxPathLength, obstacles, algorithm) {
-  const parts = [`target: "${targetId}"`];
-  if (maxPathLength !== void 0) {
-    parts.push(`maxPathLength: ${maxPathLength.toFixed(0)}m`);
-  }
-  if (obstacles && obstacles.length > 0) {
-    parts.push(`obstacles: [${obstacles.map((o) => `"${o}"`).join(", ")}]`);
-  }
-  if (algorithm) {
-    parts.push(`algorithm: "${algorithm}"`);
-  }
-  return `@spatial_reachable(${parts.join(", ")})`;
-}
-function computeDistance(a, b) {
-  const dx = b.x - a.x;
-  const dy = b.y - a.y;
-  const dz = b.z - a.z;
-  return Math.sqrt(dx * dx + dy * dy + dz * dz);
-}
-function isPointInBox(point, bounds, margin = 0) {
-  return point.x >= bounds.min.x + margin && point.x <= bounds.max.x - margin && point.y >= bounds.min.y + margin && point.y <= bounds.max.y - margin && point.z >= bounds.min.z + margin && point.z <= bounds.max.z - margin;
-}
-function lineIntersectsBox(a, b, box) {
-  const dir = { x: b.x - a.x, y: b.y - a.y, z: b.z - a.z };
-  const len = Math.sqrt(dir.x * dir.x + dir.y * dir.y + dir.z * dir.z);
-  if (len === 0) return false;
-  let tmin = 0;
-  let tmax = 1;
-  const axes = ["x", "y", "z"];
-  for (const axis of axes) {
-    const d = dir[axis];
-    const o = a[axis];
-    const bmin = box.min[axis];
-    const bmax = box.max[axis];
-    if (Math.abs(d) < 1e-10) {
-      if (o < bmin || o > bmax) return false;
-    } else {
-      let t1 = (bmin - o) / d;
-      let t2 = (bmax - o) / d;
-      if (t1 > t2) {
-        const tmp = t1;
-        t1 = t2;
-        t2 = tmp;
-      }
-      tmin = Math.max(tmin, t1);
-      tmax = Math.min(tmax, t2);
-      if (tmin > tmax) return false;
-    }
-  }
-  return true;
-}
-var SpatialTrainingDataGenerator = class {
-  config;
-  rng;
-  exampleCounter = 0;
-  constructor(config = {}) {
-    this.config = {
-      examplesPerCategory: config.examplesPerCategory ?? 10,
-      relationshipTypes: config.relationshipTypes ?? [
-        "spatial_adjacent",
-        "spatial_contains",
-        "spatial_reachable"
-      ],
-      difficultyLevels: config.difficultyLevels ?? ["basic", "intermediate", "advanced"],
-      positiveRatio: config.positiveRatio ?? 0.5,
-      seed: config.seed ?? Date.now(),
-      includeContext: config.includeContext ?? true
-    };
-    this.rng = new SeededRandom(this.config.seed);
-  }
-  // ---------------------------------------------------------------------------
-  // Public API
-  // ---------------------------------------------------------------------------
-  /**
-   * Generate all spatial training examples based on configuration.
-   */
-  generate() {
-    const examples = [];
-    this.exampleCounter = 0;
-    for (const relType of this.config.relationshipTypes) {
-      for (const difficulty of this.config.difficultyLevels) {
-        const count = this.config.examplesPerCategory;
-        for (let i = 0; i < count; i++) {
-          const isPositive = this.rng.next() < this.config.positiveRatio;
-          const scene = this.generateScene(relType, difficulty, isPositive);
-          const example = this.generateExample(scene, relType, isPositive, difficulty);
-          examples.push(example);
-        }
-      }
-    }
-    return examples;
-  }
-  /**
-   * Generate examples for a specific relationship type.
-   */
-  generateForRelationship(relType) {
-    const examples = [];
-    for (const difficulty of this.config.difficultyLevels) {
-      const count = this.config.examplesPerCategory;
-      for (let i = 0; i < count; i++) {
-        const isPositive = this.rng.next() < this.config.positiveRatio;
-        const scene = this.generateScene(relType, difficulty, isPositive);
-        const example = this.generateExample(scene, relType, isPositive, difficulty);
-        examples.push(example);
-      }
-    }
-    return examples;
-  }
-  /**
-   * Generate examples for a specific difficulty level.
-   */
-  generateForDifficulty(difficulty) {
-    const examples = [];
-    for (const relType of this.config.relationshipTypes) {
-      const count = this.config.examplesPerCategory;
-      for (let i = 0; i < count; i++) {
-        const isPositive = this.rng.next() < this.config.positiveRatio;
-        const scene = this.generateScene(relType, difficulty, isPositive);
-        const example = this.generateExample(scene, relType, isPositive, difficulty);
-        examples.push(example);
-      }
-    }
-    return examples;
-  }
-  /**
-   * Export examples as JSONL string (one JSON object per line).
-   */
-  exportJSONL(examples) {
-    return examples.map((ex) => {
-      const entry = {
-        instruction: this.config.includeContext ? `${ex.instruction}
-
-HoloScript Scene:
-\`\`\`holoscript
-${ex.context}
-\`\`\`` : ex.instruction,
-        response: ex.response,
-        metadata: {
-          id: ex.id,
-          relationship_type: ex.relationshipType,
-          is_positive: ex.isPositive,
-          difficulty: ex.difficulty,
-          tags: ex.tags
-        }
-      };
-      return JSON.stringify(entry);
-    }).join("\n");
-  }
-  /**
-   * Export examples as JSON array string.
-   */
-  exportJSON(examples) {
-    return JSON.stringify(examples, null, 2);
-  }
-  /**
-   * Get statistics about generated examples.
-   */
-  getStats(examples) {
-    const byRelationship = {
-      spatial_adjacent: 0,
-      spatial_contains: 0,
-      spatial_reachable: 0
-    };
-    const byDifficulty = {
-      basic: 0,
-      intermediate: 0,
-      advanced: 0
-    };
-    let positiveCount = 0;
-    let negativeCount = 0;
-    const templateIds = /* @__PURE__ */ new Set();
-    for (const ex of examples) {
-      byRelationship[ex.relationshipType]++;
-      byDifficulty[ex.difficulty]++;
-      if (ex.isPositive) positiveCount++;
-      else negativeCount++;
-      const tplTag = ex.tags.find((t) => t.startsWith("template:"));
-      if (tplTag) templateIds.add(tplTag);
-    }
-    return {
-      totalExamples: examples.length,
-      byRelationship,
-      byDifficulty,
-      positiveCount,
-      negativeCount,
-      uniqueTemplatesUsed: templateIds.size
-    };
-  }
-  /**
-   * Reset the generator with a new seed.
-   */
-  reseed(seed) {
-    this.rng = new SeededRandom(seed);
-    this.exampleCounter = 0;
-  }
-  // ---------------------------------------------------------------------------
-  // Scene Generation
-  // ---------------------------------------------------------------------------
-  /**
-   * Generate a spatial scene for the given relationship type and difficulty.
-   */
-  generateScene(relType, difficulty, isPositive) {
-    switch (relType) {
-      case "spatial_adjacent":
-        return this.generateAdjacentScene(difficulty, isPositive);
-      case "spatial_contains":
-        return this.generateContainsScene(difficulty, isPositive);
-      case "spatial_reachable":
-        return this.generateReachableScene(difficulty, isPositive);
-    }
-  }
-  // ---------------------------------------------------------------------------
-  // Adjacent Scene Generation
-  // ---------------------------------------------------------------------------
-  generateAdjacentScene(difficulty, isPositive) {
-    const objectCount = this.getObjectCount(difficulty);
-    const maxDistance = this.rng.float(1, 5);
-    const objects = [];
-    const relationships = [];
-    const srcName = this.rng.pick(OBJECT_NAMES);
-    const srcPos = this.randomPosition(difficulty);
-    const srcObj = {
-      id: srcName,
-      type: "object",
-      position: srcPos,
-      scale: this.randomScale(),
-      geometry: this.rng.pick(GEOMETRY_TYPES),
-      color: this.rng.pick(COLORS)
-    };
-    objects.push(srcObj);
-    const tgtName = this.pickUniqueName(OBJECT_NAMES, [srcName]);
-    let tgtPos;
-    if (isPositive) {
-      const angle = this.rng.float(0, Math.PI * 2);
-      const elevation = this.rng.float(-0.5, 0.5);
-      const dist = this.rng.float(0.5, maxDistance * 0.9);
-      tgtPos = {
-        x: srcPos.x + Math.cos(angle) * dist,
-        y: srcPos.y + elevation,
-        z: srcPos.z + Math.sin(angle) * dist
-      };
-    } else {
-      const angle = this.rng.float(0, Math.PI * 2);
-      const dist = this.rng.float(maxDistance * 1.5, maxDistance * 3);
-      tgtPos = {
-        x: srcPos.x + Math.cos(angle) * dist,
-        y: srcPos.y + this.rng.float(-1, 1),
-        z: srcPos.z + Math.sin(angle) * dist
-      };
-    }
-    const tgtObj = {
-      id: tgtName,
-      type: "object",
-      position: tgtPos,
-      scale: this.randomScale(),
-      geometry: this.rng.pick(GEOMETRY_TYPES),
-      color: this.rng.pick(COLORS)
-    };
-    objects.push(tgtObj);
-    const actualDist = computeDistance(srcPos, tgtPos);
-    relationships.push({
-      type: "spatial_adjacent",
-      sourceId: srcName,
-      targetId: tgtName,
-      satisfied: actualDist <= maxDistance,
-      params: { maxDistance }
-    });
-    const usedNames = [srcName, tgtName];
-    for (let i = 2; i < objectCount; i++) {
-      const name = this.pickUniqueName(OBJECT_NAMES, usedNames);
-      usedNames.push(name);
-      objects.push({
-        id: name,
-        type: "object",
-        position: this.randomPosition(difficulty),
-        scale: this.randomScale(),
-        geometry: this.rng.pick(GEOMETRY_TYPES),
-        color: this.rng.pick(COLORS)
-      });
-    }
-    const holoScript = this.buildAdjacentHoloScript(objects, srcName, tgtName, maxDistance);
-    return {
-      name: `AdjacentScene_${this.exampleCounter}`,
-      objects,
-      relationships,
-      difficulty,
-      holoScriptSource: holoScript
-    };
-  }
-  buildAdjacentHoloScript(objects, srcName, tgtName, maxDistance) {
-    const lines = [];
-    lines.push(`composition "SpatialScene" {`);
-    for (const obj of objects) {
-      if (obj.id === srcName) {
-        lines.push(`  object "${obj.id}" {`);
-        if (obj.geometry) lines.push(`    geometry: "${obj.geometry}"`);
-        lines.push(
-          `    position: [${obj.position.x.toFixed(1)}, ${obj.position.y.toFixed(1)}, ${obj.position.z.toFixed(1)}]`
-        );
-        if (obj.color) lines.push(`    color: "${obj.color}"`);
-        lines.push(`    ${generateAdjacentTrait(tgtName, maxDistance)}`);
-        lines.push("  }");
-      } else {
-        lines.push(generateObjectBlock(obj));
-      }
-      lines.push("");
-    }
-    lines.push("}");
-    return lines.join("\n");
-  }
-  // ---------------------------------------------------------------------------
-  // Contains Scene Generation
-  // ---------------------------------------------------------------------------
-  generateContainsScene(difficulty, isPositive) {
-    const objects = [];
-    const relationships = [];
-    const containerName = this.rng.pick(ZONE_NAMES);
-    const containerSize = {
-      x: this.rng.float(4, 12),
-      y: this.rng.float(3, 8),
-      z: this.rng.float(4, 12)
-    };
-    const containerPos = this.randomPosition(difficulty);
-    const margin = this.rng.float(0, 0.5);
-    const containerBounds = {
-      min: {
-        x: containerPos.x - containerSize.x / 2,
-        y: containerPos.y - containerSize.y / 2,
-        z: containerPos.z - containerSize.z / 2
-      },
-      max: {
-        x: containerPos.x + containerSize.x / 2,
-        y: containerPos.y + containerSize.y / 2,
-        z: containerPos.z + containerSize.z / 2
-      }
-    };
-    const containerObj = {
-      id: containerName,
-      type: "zone",
-      position: containerPos,
-      scale: containerSize,
-      bounds: containerBounds
-    };
-    objects.push(containerObj);
-    const objectCount = this.getObjectCount(difficulty);
-    const containedName = this.rng.pick(OBJECT_NAMES);
-    let containedPos;
-    if (isPositive) {
-      containedPos = {
-        x: this.rng.float(
-          containerBounds.min.x + margin + 0.5,
-          containerBounds.max.x - margin - 0.5
-        ),
-        y: this.rng.float(
-          containerBounds.min.y + margin + 0.5,
-          containerBounds.max.y - margin - 0.5
-        ),
-        z: this.rng.float(
-          containerBounds.min.z + margin + 0.5,
-          containerBounds.max.z - margin - 0.5
-        )
-      };
-    } else {
-      const side = this.rng.int(0, 5);
-      containedPos = { ...containerPos };
-      switch (side) {
-        case 0:
-          containedPos.x = containerBounds.max.x + this.rng.float(1, 5);
-          break;
-        case 1:
-          containedPos.x = containerBounds.min.x - this.rng.float(1, 5);
-          break;
-        case 2:
-          containedPos.y = containerBounds.max.y + this.rng.float(1, 5);
-          break;
-        case 3:
-          containedPos.y = containerBounds.min.y - this.rng.float(1, 5);
-          break;
-        case 4:
-          containedPos.z = containerBounds.max.z + this.rng.float(1, 5);
-          break;
-        case 5:
-          containedPos.z = containerBounds.min.z - this.rng.float(1, 5);
-          break;
-      }
-    }
-    const containedObj = {
-      id: containedName,
-      type: "object",
-      position: containedPos,
-      scale: this.randomScale(),
-      geometry: this.rng.pick(GEOMETRY_TYPES),
-      color: this.rng.pick(COLORS)
-    };
-    objects.push(containedObj);
-    const actuallyContained = isPointInBox(containedPos, containerBounds, margin);
-    relationships.push({
-      type: "spatial_contains",
-      sourceId: containerName,
-      targetId: containedName,
-      satisfied: actuallyContained,
-      params: { margin: margin > 0 ? margin : void 0 }
-    });
-    const usedNames = [containerName, containedName];
-    if (difficulty === "advanced") {
-      const innerContainerName = this.pickUniqueName(ZONE_NAMES, usedNames);
-      usedNames.push(innerContainerName);
-      const innerSize = {
-        x: containerSize.x * 0.4,
-        y: containerSize.y * 0.4,
-        z: containerSize.z * 0.4
-      };
-      const innerObj = {
-        id: innerContainerName,
-        type: "zone",
-        position: { ...containerPos },
-        scale: innerSize,
-        bounds: {
-          min: {
-            x: containerPos.x - innerSize.x / 2,
-            y: containerPos.y - innerSize.y / 2,
-            z: containerPos.z - innerSize.z / 2
-          },
-          max: {
-            x: containerPos.x + innerSize.x / 2,
-            y: containerPos.y + innerSize.y / 2,
-            z: containerPos.z + innerSize.z / 2
-          }
-        }
-      };
-      objects.push(innerObj);
-    }
-    for (let i = objects.length; i < objectCount; i++) {
-      const name = this.pickUniqueName(OBJECT_NAMES, usedNames);
-      usedNames.push(name);
-      objects.push({
-        id: name,
-        type: "object",
-        position: this.randomPosition(difficulty),
-        scale: this.randomScale(),
-        geometry: this.rng.pick(GEOMETRY_TYPES),
-        color: this.rng.pick(COLORS)
-      });
-    }
-    const holoScript = this.buildContainsHoloScript(objects, containerName, containedName, margin);
-    return {
-      name: `ContainsScene_${this.exampleCounter}`,
-      objects,
-      relationships,
-      difficulty,
-      holoScriptSource: holoScript
-    };
-  }
-  buildContainsHoloScript(objects, containerName, containedName, margin) {
-    const lines = [];
-    lines.push(`composition "SpatialScene" {`);
-    for (const obj of objects) {
-      if (obj.type === "zone") {
-        if (obj.id === containerName) {
-          lines.push(`  zone "${obj.id}" {`);
-          lines.push(`    shape: "box"`);
-          lines.push(
-            `    size: [${obj.scale.x.toFixed(1)}, ${obj.scale.y.toFixed(1)}, ${obj.scale.z.toFixed(1)}]`
-          );
-          lines.push(
-            `    position: [${obj.position.x.toFixed(1)}, ${obj.position.y.toFixed(1)}, ${obj.position.z.toFixed(1)}]`
-          );
-          lines.push(
-            `    ${generateContainsTrait(containedName, margin > 0 ? margin : void 0)}`
-          );
-          lines.push("  }");
-        } else {
-          lines.push(generateZoneBlock(obj));
-        }
-      } else {
-        lines.push(generateObjectBlock(obj));
-      }
-      lines.push("");
-    }
-    lines.push("}");
-    return lines.join("\n");
-  }
-  // ---------------------------------------------------------------------------
-  // Reachable Scene Generation
-  // ---------------------------------------------------------------------------
-  generateReachableScene(difficulty, isPositive) {
-    const objectCount = this.getObjectCount(difficulty);
-    const objects = [];
-    const relationships = [];
-    const srcName = this.rng.pick(NPC_NAMES);
-    const srcPos = this.randomPosition(difficulty);
-    objects.push({
-      id: srcName,
-      type: "npc",
-      position: srcPos,
-      scale: { x: 1, y: 1, z: 1 },
-      geometry: "sphere",
-      color: this.rng.pick(COLORS)
-    });
-    const tgtName = this.pickUniqueName([...OBJECT_NAMES, ...NPC_NAMES], [srcName]);
-    const tgtAngle = this.rng.float(0, Math.PI * 2);
-    const tgtDist = this.rng.float(5, 20);
-    const tgtPos = {
-      x: srcPos.x + Math.cos(tgtAngle) * tgtDist,
-      y: srcPos.y + this.rng.float(-1, 1),
-      z: srcPos.z + Math.sin(tgtAngle) * tgtDist
-    };
-    objects.push({
-      id: tgtName,
-      type: "object",
-      position: tgtPos,
-      scale: this.randomScale(),
-      geometry: this.rng.pick(GEOMETRY_TYPES),
-      color: this.rng.pick(COLORS)
-    });
-    const obstacleCount = difficulty === "basic" ? 0 : difficulty === "intermediate" ? this.rng.int(1, 2) : this.rng.int(2, 4);
-    const obstacleNames = [];
-    const usedNames = [srcName, tgtName];
-    let blockingObstacle = null;
-    for (let i = 0; i < obstacleCount; i++) {
-      const obsName = this.pickUniqueName(OBSTACLE_NAMES, usedNames);
-      usedNames.push(obsName);
-      obstacleNames.push(obsName);
-      const obsScale = {
-        x: this.rng.float(1.5, 4),
-        y: this.rng.float(2, 5),
-        z: this.rng.float(1.5, 4)
-      };
-      let obsPos;
-      if (!isPositive && i === 0) {
-        const t = this.rng.float(0.3, 0.7);
-        obsPos = {
-          x: srcPos.x + (tgtPos.x - srcPos.x) * t,
-          y: srcPos.y + (tgtPos.y - srcPos.y) * t,
-          z: srcPos.z + (tgtPos.z - srcPos.z) * t
-        };
-        blockingObstacle = obsName;
-      } else {
-        const offset = this.rng.float(3, 8);
-        const side = this.rng.next() > 0.5 ? 1 : -1;
-        const midpoint = {
-          x: (srcPos.x + tgtPos.x) / 2,
-          y: (srcPos.y + tgtPos.y) / 2,
-          z: (srcPos.z + tgtPos.z) / 2
-        };
-        const perpX = -(tgtPos.z - srcPos.z);
-        const perpZ = tgtPos.x - srcPos.x;
-        const perpLen = Math.sqrt(perpX * perpX + perpZ * perpZ);
-        if (perpLen > 0) {
-          obsPos = {
-            x: midpoint.x + perpX / perpLen * offset * side,
-            y: midpoint.y,
-            z: midpoint.z + perpZ / perpLen * offset * side
-          };
-        } else {
-          obsPos = {
-            x: midpoint.x + offset * side,
-            y: midpoint.y,
-            z: midpoint.z
-          };
-        }
-      }
-      const obsBounds = {
-        min: {
-          x: obsPos.x - obsScale.x / 2,
-          y: obsPos.y - obsScale.y / 2,
-          z: obsPos.z - obsScale.z / 2
-        },
-        max: {
-          x: obsPos.x + obsScale.x / 2,
-          y: obsPos.y + obsScale.y / 2,
-          z: obsPos.z + obsScale.z / 2
-        }
-      };
-      objects.push({
-        id: obsName,
-        type: "obstacle",
-        position: obsPos,
-        scale: obsScale,
-        bounds: obsBounds,
-        isObstacle: true,
-        geometry: "cube",
-        color: "#444444"
-      });
-    }
-    let actuallyReachable = true;
-    if (obstacleNames.length > 0) {
-      for (const obj of objects) {
-        if (obj.isObstacle && obj.bounds) {
-          if (lineIntersectsBox(srcPos, tgtPos, obj.bounds)) {
-            actuallyReachable = false;
-            if (!blockingObstacle) blockingObstacle = obj.id;
-            break;
-          }
-        }
-      }
-    }
-    const maxPathLength = this.rng.float(tgtDist * 1.2, tgtDist * 2);
-    relationships.push({
-      type: "spatial_reachable",
-      sourceId: srcName,
-      targetId: tgtName,
-      satisfied: actuallyReachable,
-      params: {
-        maxPathLength,
-        obstacleTypes: obstacleNames.length > 0 ? ["obstacle"] : void 0,
-        algorithm: "line_of_sight"
-      }
-    });
-    for (let i = objects.length; i < objectCount; i++) {
-      const name = this.pickUniqueName(OBJECT_NAMES, usedNames);
-      usedNames.push(name);
-      objects.push({
-        id: name,
-        type: "object",
-        position: this.randomPosition(difficulty),
-        scale: this.randomScale(),
-        geometry: this.rng.pick(GEOMETRY_TYPES),
-        color: this.rng.pick(COLORS)
-      });
-    }
-    const holoScript = this.buildReachableHoloScript(
-      objects,
-      srcName,
-      tgtName,
-      maxPathLength,
-      obstacleNames
-    );
-    return {
-      name: `ReachableScene_${this.exampleCounter}`,
-      objects,
-      relationships,
-      difficulty,
-      holoScriptSource: holoScript
-    };
-  }
-  buildReachableHoloScript(objects, srcName, tgtName, maxPathLength, obstacleNames) {
-    const lines = [];
-    lines.push(`composition "SpatialScene" {`);
-    for (const obj of objects) {
-      if (obj.id === srcName) {
-        lines.push(`  object "${obj.id}" {`);
-        if (obj.geometry) lines.push(`    geometry: "${obj.geometry}"`);
-        lines.push(
-          `    position: [${obj.position.x.toFixed(1)}, ${obj.position.y.toFixed(1)}, ${obj.position.z.toFixed(1)}]`
-        );
-        if (obj.color) lines.push(`    color: "${obj.color}"`);
-        lines.push(
-          `    ${generateReachableTrait(tgtName, maxPathLength, obstacleNames.length > 0 ? ["obstacle"] : void 0, "line_of_sight")}`
-        );
-        lines.push("  }");
-      } else if (obj.isObstacle) {
-        lines.push(`  object "${obj.id}" {`);
-        lines.push(`    geometry: "cube"`);
-        lines.push(
-          `    position: [${obj.position.x.toFixed(1)}, ${obj.position.y.toFixed(1)}, ${obj.position.z.toFixed(1)}]`
-        );
-        lines.push(
-          `    scale: [${obj.scale.x.toFixed(1)}, ${obj.scale.y.toFixed(1)}, ${obj.scale.z.toFixed(1)}]`
-        );
-        lines.push("    @static");
-        lines.push("    @collidable");
-        lines.push("  }");
-      } else {
-        lines.push(generateObjectBlock(obj));
-      }
-      lines.push("");
-    }
-    lines.push("}");
-    return lines.join("\n");
-  }
-  // ---------------------------------------------------------------------------
-  // Example Generation (instruction-response pairs)
-  // ---------------------------------------------------------------------------
-  generateExample(scene, relType, isPositive, difficulty) {
-    this.exampleCounter++;
-    const rel = scene.relationships[0];
-    let instruction;
-    let response;
-    let templateIndex;
-    switch (relType) {
-      case "spatial_adjacent": {
-        templateIndex = this.rng.int(0, ADJACENT_QUESTION_TEMPLATES.length - 1);
-        const template = ADJACENT_QUESTION_TEMPLATES[templateIndex];
-        const dist = computeDistance(
-          scene.objects.find((o) => o.id === rel.sourceId).position,
-          scene.objects.find((o) => o.id === rel.targetId).position
-        );
-        instruction = template.question(rel.sourceId, rel.targetId, dist, rel.params.maxDistance);
-        response = isPositive ? template.positiveAnswer(rel.sourceId, rel.targetId, dist, rel.params.maxDistance) : template.negativeAnswer(rel.sourceId, rel.targetId, dist, rel.params.maxDistance);
-        break;
-      }
-      case "spatial_contains": {
-        templateIndex = this.rng.int(0, CONTAINS_QUESTION_TEMPLATES.length - 1);
-        const template = CONTAINS_QUESTION_TEMPLATES[templateIndex];
-        instruction = template.question(rel.sourceId, rel.targetId);
-        response = isPositive ? template.positiveAnswer(rel.sourceId, rel.targetId) : template.negativeAnswer(rel.sourceId, rel.targetId);
-        break;
-      }
-      case "spatial_reachable": {
-        templateIndex = this.rng.int(0, REACHABLE_QUESTION_TEMPLATES.length - 1);
-        const template = REACHABLE_QUESTION_TEMPLATES[templateIndex];
-        const obstacles = scene.objects.filter((o) => o.isObstacle).map((o) => o.id);
-        const pathLen = computeDistance(
-          scene.objects.find((o) => o.id === rel.sourceId).position,
-          scene.objects.find((o) => o.id === rel.targetId).position
-        );
-        const blocker = scene.objects.find((o) => o.isObstacle)?.id ?? "unknown";
-        instruction = template.question(rel.sourceId, rel.targetId, obstacles);
-        response = isPositive ? template.positiveAnswer(rel.sourceId, rel.targetId, pathLen) : template.negativeAnswer(rel.sourceId, rel.targetId, blocker);
-        break;
-      }
-    }
-    return {
-      id: `spatial-${relType.replace("spatial_", "")}-${difficulty}-${this.exampleCounter}`,
-      instruction,
-      response,
-      context: scene.holoScriptSource,
-      relationshipType: relType,
-      isPositive,
-      difficulty,
-      tags: [
-        relType,
-        difficulty,
-        isPositive ? "positive" : "negative",
-        `template:${relType}-${templateIndex}`
-      ]
-    };
-  }
-  // ---------------------------------------------------------------------------
-  // Utility Methods
-  // ---------------------------------------------------------------------------
-  getObjectCount(difficulty) {
-    switch (difficulty) {
-      case "basic":
-        return 2;
-      case "intermediate":
-        return this.rng.int(3, 5);
-      case "advanced":
-        return this.rng.int(6, 9);
-    }
-  }
-  randomPosition(difficulty) {
-    const range = difficulty === "basic" ? 5 : difficulty === "intermediate" ? 10 : 20;
-    return {
-      x: this.rng.float(-range, range),
-      y: this.rng.float(0, range / 2),
-      z: this.rng.float(-range, range)
-    };
-  }
-  randomScale() {
-    const uniform = this.rng.next() > 0.5;
-    if (uniform) {
-      const s = this.rng.float(0.3, 2.5);
-      return { x: s, y: s, z: s };
-    }
-    return {
-      x: this.rng.float(0.3, 3),
-      y: this.rng.float(0.3, 3),
-      z: this.rng.float(0.3, 3)
-    };
-  }
-  pickUniqueName(pool, used) {
-    const available = pool.filter((n) => !used.includes(n));
-    if (available.length === 0) {
-      return `${this.rng.pick(pool)}_${this.rng.int(100, 999)}`;
-    }
-    return this.rng.pick(available);
-  }
-};
-function createSpatialTrainingDataGenerator(config) {
-  return new SpatialTrainingDataGenerator(config);
-}
-
-// src/training/SparsityMonitor.ts
-var DEFAULT_CONFIG = {
-  sparsityThreshold: 0.93,
-  windowSize: 50,
-  perLayerTracking: true,
-  energyMetricsEnabled: true,
-  avgSynapsesPerNeuron: 100,
-  opsPerSynapse: 2,
-  criticalThreshold: 0.85,
-  maxViolationHistory: 1e3
-};
-var SparsityMonitor = class {
-  config;
-  /** Current layer metrics indexed by layerId, latest values per layer */
-  currentLayerMetrics = /* @__PURE__ */ new Map();
-  /** Historical layer metrics: layerId -> array of metrics over time */
-  layerHistory = /* @__PURE__ */ new Map();
-  /** Snapshots taken over time */
-  snapshots = [];
-  /** Detected violations */
-  violations = [];
-  /** Rolling window of aggregate sparsity values for stats */
-  sparsityWindow = [];
-  /** Total timesteps recorded across all layers */
-  totalTimestepsRecorded = 0;
-  constructor(config = {}) {
-    this.config = { ...DEFAULT_CONFIG, ...config };
-  }
-  // ---------------------------------------------------------------------------
-  // Recording
-  // ---------------------------------------------------------------------------
-  /**
-   * Record activity for a single SNN layer at a given timestep.
-   *
-   * Computes spike rate and activation sparsity from the raw input,
-   * checks for threshold violations, and stores the metrics.
-   *
-   * @param layerId - Unique identifier for the layer
-   * @param input - Raw activity data (neuronCount, spikeCount, timestep)
-   * @returns The computed SNNLayerMetrics for this recording
-   */
-  recordLayerActivity(layerId, input) {
-    if (input.neuronCount <= 0) {
-      throw new Error(`neuronCount must be positive, got ${input.neuronCount}`);
-    }
-    if (input.spikeCount < 0) {
-      throw new Error(`spikeCount must be non-negative, got ${input.spikeCount}`);
-    }
-    if (input.spikeCount > input.neuronCount) {
-      throw new Error(
-        `spikeCount (${input.spikeCount}) cannot exceed neuronCount (${input.neuronCount})`
-      );
-    }
-    const spikeRate = input.spikeCount / input.neuronCount;
-    const activationSparsity = 1 - spikeRate;
-    const metrics = {
-      layerId,
-      neuronCount: input.neuronCount,
-      spikeCount: input.spikeCount,
-      spikeRate: roundTo4(spikeRate),
-      activationSparsity: roundTo4(activationSparsity),
-      avgMembranePotential: input.avgMembranePotential,
-      timestep: input.timestep
-    };
-    this.currentLayerMetrics.set(layerId, metrics);
-    if (this.config.perLayerTracking) {
-      if (!this.layerHistory.has(layerId)) {
-        this.layerHistory.set(layerId, []);
-      }
-      this.layerHistory.get(layerId).push(metrics);
-    }
-    this.totalTimestepsRecorded++;
-    this.checkViolation(metrics);
-    return metrics;
-  }
-  /**
-   * Record activity for multiple layers at the same timestep (batch recording).
-   *
-   * @param layerInputs - Map of layerId -> activity input
-   * @returns Array of computed metrics for each layer
-   */
-  recordBatchActivity(layerInputs) {
-    const entries = layerInputs instanceof Map ? Array.from(layerInputs.entries()) : Object.entries(layerInputs);
-    return entries.map(([layerId, input]) => this.recordLayerActivity(layerId, input));
-  }
-  // ---------------------------------------------------------------------------
-  // Snapshots
-  // ---------------------------------------------------------------------------
-  /**
-   * Take a point-in-time snapshot of all current layer metrics.
-   *
-   * The snapshot captures aggregate statistics across all tracked layers,
-   * computes energy efficiency, and checks for violations.
-   *
-   * @returns The snapshot, or null if no layer metrics have been recorded
-   */
-  takeSnapshot() {
-    if (this.currentLayerMetrics.size === 0) {
-      return null;
-    }
-    const layers = Array.from(this.currentLayerMetrics.values());
-    const totalNeurons = layers.reduce((sum, l) => sum + l.neuronCount, 0);
-    const totalSpikes = layers.reduce((sum, l) => sum + l.spikeCount, 0);
-    const aggregateSparsity = totalNeurons > 0 ? roundTo4(1 - totalSpikes / totalNeurons) : 1;
-    const aggregateSpikeRate = totalNeurons > 0 ? roundTo4(totalSpikes / totalNeurons) : 0;
-    const energyEfficiency = this.config.energyMetricsEnabled ? this.calculateEnergyEfficiency(layers) : createZeroEnergyMetrics();
-    const violations = this.detectViolationsForLayers(layers);
-    const snapshot = {
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      layers: layers.map((l) => ({ ...l })),
-      aggregateSparsity,
-      aggregateSpikeRate,
-      totalNeurons,
-      totalSpikes,
-      energyEfficiency,
-      violations
-    };
-    this.snapshots.push(snapshot);
-    this.sparsityWindow.push(aggregateSparsity);
-    if (this.sparsityWindow.length > this.config.windowSize) {
-      this.sparsityWindow.shift();
-    }
-    return snapshot;
-  }
-  // ---------------------------------------------------------------------------
-  // Energy Efficiency
-  // ---------------------------------------------------------------------------
-  /**
-   * Calculate theoretical energy efficiency metrics for the given layers.
-   *
-   * Dense ops = sum of (neuronCount * avgSynapsesPerNeuron * opsPerSynapse) per layer
-   * Sparse ops = sum of (spikeCount * avgSynapsesPerNeuron * opsPerSynapse) per layer
-   *
-   * The ratio of ops saved reflects the theoretical computational advantage
-   * of SNN sparsity over equivalent dense ANN computation.
-   */
-  calculateEnergyEfficiency(layers) {
-    const { avgSynapsesPerNeuron, opsPerSynapse } = this.config;
-    let denseOps = 0;
-    let sparseOps = 0;
-    for (const layer of layers) {
-      const layerDenseOps = layer.neuronCount * avgSynapsesPerNeuron * opsPerSynapse;
-      const layerSparseOps = layer.spikeCount * avgSynapsesPerNeuron * opsPerSynapse;
-      denseOps += layerDenseOps;
-      sparseOps += layerSparseOps;
-    }
-    const opsSaved = denseOps - sparseOps;
-    const efficiencyRatio = denseOps > 0 ? roundTo4(opsSaved / denseOps) : 0;
-    const energySavingsFactor = denseOps > 0 ? roundTo4(denseOps / Math.max(1, sparseOps)) : 1;
-    return {
-      denseOps,
-      sparseOps,
-      opsSaved,
-      efficiencyRatio,
-      energySavingsFactor
-    };
-  }
-  // ---------------------------------------------------------------------------
-  // Violation Detection
-  // ---------------------------------------------------------------------------
-  /**
-   * Check a single layer's metrics against the sparsity threshold.
-   * If a violation is detected, it is recorded in the violations history.
-   */
-  checkViolation(metrics) {
-    if (metrics.activationSparsity >= this.config.sparsityThreshold) {
-      return null;
-    }
-    const deficit = roundTo4(this.config.sparsityThreshold - metrics.activationSparsity);
-    const severity = metrics.activationSparsity < this.config.criticalThreshold ? "critical" : "warning";
-    const violation = {
-      layerId: metrics.layerId,
-      measuredSparsity: metrics.activationSparsity,
-      requiredThreshold: this.config.sparsityThreshold,
-      deficit,
-      severity,
-      detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      timestep: metrics.timestep
-    };
-    this.violations.push(violation);
-    if (this.violations.length > this.config.maxViolationHistory) {
-      this.violations = this.violations.slice(-this.config.maxViolationHistory);
-    }
-    return violation;
-  }
-  /**
-   * Detect violations for an array of layer metrics (used in snapshots).
-   */
-  detectViolationsForLayers(layers) {
-    const snapshotViolations = [];
-    for (const layer of layers) {
-      if (layer.activationSparsity < this.config.sparsityThreshold) {
-        const deficit = roundTo4(this.config.sparsityThreshold - layer.activationSparsity);
-        const severity = layer.activationSparsity < this.config.criticalThreshold ? "critical" : "warning";
-        snapshotViolations.push({
-          layerId: layer.layerId,
-          measuredSparsity: layer.activationSparsity,
-          requiredThreshold: this.config.sparsityThreshold,
-          deficit,
-          severity,
-          detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          timestep: layer.timestep
-        });
-      }
-    }
-    return snapshotViolations;
-  }
-  /**
-   * Get all violations currently affecting active layers
-   * (the most recent metric per layer that is below threshold).
-   */
-  getActiveViolations() {
-    const active = [];
-    for (const [, metrics] of this.currentLayerMetrics) {
-      if (metrics.activationSparsity < this.config.sparsityThreshold) {
-        const deficit = roundTo4(this.config.sparsityThreshold - metrics.activationSparsity);
-        const severity = metrics.activationSparsity < this.config.criticalThreshold ? "critical" : "warning";
-        active.push({
-          layerId: metrics.layerId,
-          measuredSparsity: metrics.activationSparsity,
-          requiredThreshold: this.config.sparsityThreshold,
-          deficit,
-          severity,
-          detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          timestep: metrics.timestep
-        });
-      }
-    }
-    return active;
-  }
-  /**
-   * Get all historical violations.
-   */
-  getViolationHistory() {
-    return [...this.violations];
-  }
-  // ---------------------------------------------------------------------------
-  // Statistics
-  // ---------------------------------------------------------------------------
-  /**
-   * Compute aggregate statistics across all recorded data.
-   */
-  getStats() {
-    const allSparsities = [];
-    const perLayerSums = {};
-    for (const [layerId, history] of this.layerHistory) {
-      for (const m of history) {
-        allSparsities.push(m.activationSparsity);
-        if (!perLayerSums[layerId]) {
-          perLayerSums[layerId] = { sum: 0, count: 0 };
-        }
-        perLayerSums[layerId].sum += m.activationSparsity;
-        perLayerSums[layerId].count++;
-      }
-    }
-    if (allSparsities.length === 0) {
-      for (const [layerId, m] of this.currentLayerMetrics) {
-        allSparsities.push(m.activationSparsity);
-        perLayerSums[layerId] = { sum: m.activationSparsity, count: 1 };
-      }
-    }
-    const meanSparsity = allSparsities.length > 0 ? roundTo4(allSparsities.reduce((a, b) => a + b, 0) / allSparsities.length) : 0;
-    const minSparsity = allSparsities.length > 0 ? Math.min(...allSparsities) : 0;
-    const maxSparsity = allSparsities.length > 0 ? Math.max(...allSparsities) : 0;
-    const stdDevSparsity = allSparsities.length > 1 ? roundTo4(standardDeviation(allSparsities)) : 0;
-    const perLayerMeanSparsity = {};
-    for (const [layerId, data] of Object.entries(perLayerSums)) {
-      perLayerMeanSparsity[layerId] = roundTo4(data.sum / data.count);
-    }
-    const warningCount = this.violations.filter((v) => v.severity === "warning").length;
-    const criticalCount = this.violations.filter((v) => v.severity === "critical").length;
-    const efficiencies = this.snapshots.map((s) => s.energyEfficiency.efficiencyRatio).filter((e) => e > 0);
-    const meanEnergyEfficiency = efficiencies.length > 0 ? roundTo4(efficiencies.reduce((a, b) => a + b, 0) / efficiencies.length) : 0;
-    const activeViolations = this.getActiveViolations();
-    return {
-      totalTimesteps: this.totalTimestepsRecorded,
-      totalSnapshots: this.snapshots.length,
-      trackedLayers: this.currentLayerMetrics.size,
-      meanSparsity,
-      minSparsity,
-      maxSparsity,
-      stdDevSparsity,
-      totalViolations: this.violations.length,
-      violationsBySeverity: {
-        warning: warningCount,
-        critical: criticalCount
-      },
-      perLayerMeanSparsity,
-      meanEnergyEfficiency,
-      inCompliance: activeViolations.length === 0
-    };
-  }
-  // ---------------------------------------------------------------------------
-  // Quality History Integration
-  // ---------------------------------------------------------------------------
-  /**
-   * Generate an entry compatible with the quality-history.json format.
-   *
-   * The composite score is based on the aggregate sparsity relative to
-   * the threshold: score = min(1, aggregateSparsity / threshold).
-   *
-   * @param cycle - The monitoring cycle number
-   * @returns A quality history entry with sparsity-specific metrics
-   */
-  toQualityHistoryEntry(cycle) {
-    const stats = this.getStats();
-    const latestSnapshot = this.snapshots.length > 0 ? this.snapshots[this.snapshots.length - 1] : null;
-    const aggregateSparsity = latestSnapshot?.aggregateSparsity ?? stats.meanSparsity;
-    const aggregateSpikeRate = latestSnapshot?.aggregateSpikeRate ?? 1 - stats.meanSparsity;
-    const composite = roundTo4(Math.min(1, aggregateSparsity / this.config.sparsityThreshold));
-    const grade = gradeFromComposite(composite);
-    const summary = this.generateSummary(stats, latestSnapshot, composite, grade);
-    return {
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      cycle,
-      composite,
-      grade,
-      focus: "snn-sparsity",
-      summary,
-      sparsityMetrics: {
-        aggregateSparsity,
-        aggregateSpikeRate: roundTo4(aggregateSpikeRate),
-        energyEfficiencyRatio: stats.meanEnergyEfficiency,
-        violationCount: stats.totalViolations,
-        layerCount: stats.trackedLayers,
-        totalNeurons: latestSnapshot?.totalNeurons ?? 0,
-        inCompliance: stats.inCompliance
-      }
-    };
-  }
-  /**
-   * Generate a human-readable summary string for the quality history entry.
-   */
-  generateSummary(stats, latestSnapshot, composite, grade) {
-    const lines = [];
-    lines.push(`SNN Sparsity Monitor - Grade: ${grade} (${(composite * 100).toFixed(1)}%)`);
-    lines.push(`Layers: ${stats.trackedLayers}, Timesteps: ${stats.totalTimesteps}`);
-    lines.push(
-      `Mean Sparsity: ${(stats.meanSparsity * 100).toFixed(1)}% (threshold: ${(this.config.sparsityThreshold * 100).toFixed(0)}%)`
-    );
-    lines.push(
-      `Range: [${(stats.minSparsity * 100).toFixed(1)}%, ${(stats.maxSparsity * 100).toFixed(1)}%]`
-    );
-    if (latestSnapshot) {
-      const eff = latestSnapshot.energyEfficiency;
-      lines.push(
-        `Energy Efficiency: ${(eff.efficiencyRatio * 100).toFixed(1)}% ops saved (${eff.energySavingsFactor.toFixed(1)}x factor)`
-      );
-    }
-    if (stats.totalViolations > 0) {
-      lines.push(
-        `Violations: ${stats.totalViolations} (${stats.violationsBySeverity.critical} critical, ${stats.violationsBySeverity.warning} warning)`
-      );
-    } else {
-      lines.push("Compliance: All layers within threshold");
-    }
-    return lines.join("\n");
-  }
-  // ---------------------------------------------------------------------------
-  // Harvester Integration
-  // ---------------------------------------------------------------------------
-  /**
-   * Get metrics formatted for integration with SelfImproveHarvester.
-   *
-   * Returns a record of key metrics that can be attached to harvest records
-   * as additional metadata for training data quality assessment.
-   */
-  getHarvesterMetrics() {
-    const stats = this.getStats();
-    return {
-      snn_mean_sparsity: stats.meanSparsity,
-      snn_min_sparsity: stats.minSparsity,
-      snn_max_sparsity: stats.maxSparsity,
-      snn_violation_count: stats.totalViolations,
-      snn_energy_efficiency: stats.meanEnergyEfficiency,
-      snn_in_compliance: stats.inCompliance,
-      snn_tracked_layers: stats.trackedLayers,
-      snn_total_timesteps: stats.totalTimesteps
-    };
-  }
-  // ---------------------------------------------------------------------------
-  // Accessors
-  // ---------------------------------------------------------------------------
-  /**
-   * Get all recorded snapshots.
-   */
-  getSnapshots() {
-    return [...this.snapshots];
-  }
-  /**
-   * Get the most recent snapshot, or null if none have been taken.
-   */
-  getLatestSnapshot() {
-    return this.snapshots.length > 0 ? { ...this.snapshots[this.snapshots.length - 1] } : null;
-  }
-  /**
-   * Get current layer metrics.
-   */
-  getCurrentLayerMetrics() {
-    return new Map(this.currentLayerMetrics);
-  }
-  /**
-   * Get history for a specific layer.
-   */
-  getLayerHistory(layerId) {
-    return [...this.layerHistory.get(layerId) ?? []];
-  }
-  /**
-   * Get the current configuration.
-   */
-  getConfig() {
-    return { ...this.config };
-  }
-  // ---------------------------------------------------------------------------
-  // Reset
-  // ---------------------------------------------------------------------------
-  /**
-   * Reset all recorded data and start fresh.
-   */
-  reset() {
-    this.currentLayerMetrics.clear();
-    this.layerHistory.clear();
-    this.snapshots = [];
-    this.violations = [];
-    this.sparsityWindow = [];
-    this.totalTimestepsRecorded = 0;
-  }
-};
-function roundTo4(value) {
-  return Math.round(value * 1e4) / 1e4;
-}
-function standardDeviation(values) {
-  if (values.length < 2) return 0;
-  const mean = values.reduce((a, b) => a + b, 0) / values.length;
-  const squaredDiffs = values.map((v) => (v - mean) ** 2);
-  const variance = squaredDiffs.reduce((a, b) => a + b, 0) / (values.length - 1);
-  return Math.sqrt(variance);
-}
-function gradeFromComposite(composite) {
-  if (composite >= 0.95) return "A";
-  if (composite >= 0.85) return "B";
-  if (composite >= 0.7) return "C";
-  if (composite >= 0.5) return "D";
-  return "F";
-}
-function createZeroEnergyMetrics() {
-  return {
-    denseOps: 0,
-    sparseOps: 0,
-    opsSaved: 0,
-    efficiencyRatio: 0,
-    energySavingsFactor: 1
-  };
-}
-function createSparsityMonitor(config) {
-  return new SparsityMonitor(config);
-}
-
-// src/training/SoftDedup.ts
-var DEFAULT_SOFTDEDUP_CONFIG = {
-  ngramSizes: [3, 5, 7],
-  wordLevel: false,
-  minWeight: 0.1,
-  maxWeight: 1,
-  temperature: 1,
-  commonThresholdPercentile: 0.7
-};
-var SoftDedup = class {
-  config;
-  constructor(config = {}) {
-    this.config = { ...DEFAULT_SOFTDEDUP_CONFIG, ...config };
-    this.validateConfig();
-  }
-  /**
-   * Process a dataset of text examples and compute sampling weights.
-   *
-   * @param examples - Array of text strings (training examples)
-   * @returns Array of SoftDedupResult with sampling weights
-   */
-  process(examples) {
-    if (examples.length === 0) {
-      return [];
-    }
-    if (examples.length === 1) {
-      return [
-        {
-          index: 0,
-          commonnessScore: 0,
-          samplingWeight: this.config.maxWeight,
-          ngramStats: {
-            totalNgrams: this.extractNgrams(examples[0]).length,
-            commonNgrams: 0,
-            commonRatio: 0
-          }
-        }
-      ];
-    }
-    const corpusFrequencies = this.buildCorpusFrequencies(examples);
-    const threshold = this.computeThreshold(corpusFrequencies);
-    const results = examples.map((example, index) => {
-      const ngrams = this.extractNgrams(example);
-      const totalNgrams = ngrams.length;
-      if (totalNgrams === 0) {
-        return {
-          index,
-          commonnessScore: 0,
-          samplingWeight: this.config.maxWeight,
-          ngramStats: { totalNgrams: 0, commonNgrams: 0, commonRatio: 0 }
-        };
-      }
-      let commonCount = 0;
-      for (const ngram of ngrams) {
-        const freq = corpusFrequencies.get(ngram) ?? 0;
-        if (freq >= threshold) {
-          commonCount++;
-        }
-      }
-      const commonRatio = commonCount / totalNgrams;
-      const commonnessScore = commonRatio;
-      const samplingWeight = this.commonnessToWeight(commonnessScore);
-      return {
-        index,
-        commonnessScore,
-        samplingWeight,
-        ngramStats: {
-          totalNgrams,
-          commonNgrams: commonCount,
-          commonRatio
-        }
-      };
-    });
-    return results;
-  }
-  /**
-   * Compute aggregate statistics for a set of SoftDedup results.
-   */
-  computeStats(results) {
-    if (results.length === 0) {
-      return {
-        totalExamples: 0,
-        meanWeight: 0,
-        medianWeight: 0,
-        stdWeight: 0,
-        atMinWeight: 0,
-        atMaxWeight: 0,
-        effectiveDatasetSize: 0,
-        reductionRatio: 0,
-        uniqueNgramsInCorpus: 0,
-        commonThresholdFrequency: 0
-      };
-    }
-    const weights = results.map((r) => r.samplingWeight);
-    const totalExamples = results.length;
-    const sum = weights.reduce((a, b) => a + b, 0);
-    const meanWeight = sum / totalExamples;
-    const sorted = [...weights].sort((a, b) => a - b);
-    const mid = Math.floor(sorted.length / 2);
-    const medianWeight = sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
-    const variance = weights.reduce((acc, w) => acc + (w - meanWeight) ** 2, 0) / totalExamples;
-    const stdWeight = Math.sqrt(variance);
-    const epsilon = 1e-9;
-    const atMinWeight = weights.filter((w) => Math.abs(w - this.config.minWeight) < epsilon).length;
-    const atMaxWeight = weights.filter((w) => Math.abs(w - this.config.maxWeight) < epsilon).length;
-    const effectiveDatasetSize = sum;
-    const reductionRatio = 1 - effectiveDatasetSize / totalExamples;
-    return {
-      totalExamples,
-      meanWeight,
-      medianWeight,
-      stdWeight,
-      atMinWeight,
-      atMaxWeight,
-      effectiveDatasetSize,
-      reductionRatio,
-      uniqueNgramsInCorpus: 0,
-      // filled by caller if needed
-      commonThresholdFrequency: 0
-      // filled by caller if needed
-    };
-  }
-  /**
-   * Get the current configuration.
-   */
-  getConfig() {
-    return { ...this.config };
-  }
-  // ===========================================================================
-  // INTERNAL METHODS
-  // ===========================================================================
-  /**
-   * Extract n-grams from a text string.
-   * Supports both character-level and word-level n-grams.
-   */
-  extractNgrams(text) {
-    const ngrams = [];
-    for (const n of this.config.ngramSizes) {
-      if (this.config.wordLevel) {
-        const words = text.split(/\s+/).filter((w) => w.length > 0);
-        for (let i = 0; i <= words.length - n; i++) {
-          ngrams.push(words.slice(i, i + n).join(" "));
-        }
-      } else {
-        const normalized = text.toLowerCase();
-        for (let i = 0; i <= normalized.length - n; i++) {
-          ngrams.push(normalized.substring(i, i + n));
-        }
-      }
-    }
-    return ngrams;
-  }
-  /**
-   * Build a frequency map of all n-grams across the entire corpus.
-   */
-  buildCorpusFrequencies(examples) {
-    const frequencies = /* @__PURE__ */ new Map();
-    for (const example of examples) {
-      const ngrams = this.extractNgrams(example);
-      for (const ngram of ngrams) {
-        frequencies.set(ngram, (frequencies.get(ngram) ?? 0) + 1);
-      }
-    }
-    return frequencies;
-  }
-  /**
-   * Compute the frequency threshold above which an n-gram is considered "common".
-   * Uses the configured percentile of the frequency distribution.
-   */
-  computeThreshold(frequencies) {
-    if (frequencies.size === 0) {
-      return 1;
-    }
-    const freqValues = Array.from(frequencies.values()).sort((a, b) => a - b);
-    const percentileIndex = Math.floor(freqValues.length * this.config.commonThresholdPercentile);
-    const clampedIndex = Math.min(percentileIndex, freqValues.length - 1);
-    return Math.max(freqValues[clampedIndex], 2);
-  }
-  /**
-   * Convert a commonness score (0-1) to a sampling weight.
-   *
-   * Uses exponential decay with temperature scaling:
-   *   weight = maxWeight * exp(-commonnessScore / temperature)
-   *
-   * Then clamps to [minWeight, maxWeight].
-   */
-  commonnessToWeight(commonnessScore) {
-    const { minWeight, maxWeight, temperature } = this.config;
-    const rawWeight = maxWeight * Math.exp(-commonnessScore / temperature);
-    return Math.max(minWeight, Math.min(maxWeight, rawWeight));
-  }
-  /**
-   * Validate configuration parameters.
-   * @throws Error if configuration is invalid
-   */
-  validateConfig() {
-    const { minWeight, maxWeight, temperature, commonThresholdPercentile, ngramSizes } = this.config;
-    if (minWeight <= 0 || minWeight > 1) {
-      throw new Error(`SoftDedup: minWeight must be in (0, 1], got ${minWeight}`);
-    }
-    if (maxWeight < minWeight || maxWeight > 1) {
-      throw new Error(`SoftDedup: maxWeight must be in [minWeight, 1], got ${maxWeight}`);
-    }
-    if (temperature <= 0) {
-      throw new Error(`SoftDedup: temperature must be > 0, got ${temperature}`);
-    }
-    if (commonThresholdPercentile < 0 || commonThresholdPercentile > 1) {
-      throw new Error(
-        `SoftDedup: commonThresholdPercentile must be in [0, 1], got ${commonThresholdPercentile}`
-      );
-    }
-    if (ngramSizes.length === 0) {
-      throw new Error("SoftDedup: ngramSizes must have at least one entry");
-    }
-    for (const n of ngramSizes) {
-      if (n < 1 || !Number.isInteger(n)) {
-        throw new Error(`SoftDedup: each ngramSize must be a positive integer, got ${n}`);
-      }
-    }
-  }
-};
-function createSoftDedup(config = {}) {
-  return new SoftDedup(config);
-}
-
-// src/training/LRScheduler.ts
-var DEFAULT_LR_SCHEDULER_CONFIG = {
-  baseLR: 2e-4,
-  totalSteps: 1e3,
-  warmupRatio: 0.1,
-  minLR: 0,
-  numCycles: 1
-};
-var GRPO_LR_SCHEDULER_CONFIG = {
-  baseLR: 1e-6,
-  totalSteps: 1e3,
-  warmupRatio: 0.1,
-  minLR: 0,
-  numCycles: 1
-};
-var LRScheduler = class {
-  config;
-  warmupSteps;
-  constructor(config = {}) {
-    this.config = { ...DEFAULT_LR_SCHEDULER_CONFIG, ...config };
-    this.validateConfig();
-    this.warmupSteps = Math.floor(this.config.totalSteps * this.config.warmupRatio);
-  }
-  /**
-   * Get the learning rate at a given training step.
-   *
-   * @param step - Current training step (0-indexed)
-   * @returns The learning rate at this step
-   */
-  getLR(step) {
-    const { baseLR, totalSteps, minLR, numCycles } = this.config;
-    const clampedStep = Math.max(0, Math.min(step, totalSteps));
-    if (clampedStep < this.warmupSteps) {
-      if (this.warmupSteps === 0) {
-        return baseLR;
-      }
-      return baseLR * (clampedStep / this.warmupSteps);
-    }
-    const decaySteps = totalSteps - this.warmupSteps;
-    if (decaySteps <= 0) {
-      return baseLR;
-    }
-    const decayProgress = (clampedStep - this.warmupSteps) / decaySteps;
-    const cosineArg = Math.PI * numCycles * decayProgress;
-    const cosineValue = (1 + Math.cos(cosineArg)) / 2;
-    return minLR + (baseLR - minLR) * cosineValue;
-  }
-  /**
-   * Get a detailed snapshot of the scheduler state at a given step.
-   *
-   * @param step - Current training step (0-indexed)
-   * @returns LRSchedulerSnapshot with full state information
-   */
-  getSnapshot(step) {
-    const { totalSteps } = this.config;
-    const clampedStep = Math.max(0, Math.min(step, totalSteps));
-    const learningRate = this.getLR(step);
-    const isWarmup = clampedStep < this.warmupSteps;
-    const phase = isWarmup ? "warmup" : "decay";
-    let phaseProgress;
-    if (isWarmup) {
-      phaseProgress = this.warmupSteps === 0 ? 1 : clampedStep / this.warmupSteps;
-    } else {
-      const decaySteps = totalSteps - this.warmupSteps;
-      phaseProgress = decaySteps <= 0 ? 1 : (clampedStep - this.warmupSteps) / decaySteps;
-    }
-    const overallProgress = totalSteps === 0 ? 1 : clampedStep / totalSteps;
-    return {
-      step: clampedStep,
-      learningRate,
-      phase,
-      phaseProgress,
-      overallProgress
-    };
-  }
-  /**
-   * Compute summary statistics for the full LR schedule.
-   * Samples every step to compute the average LR.
-   *
-   * For large totalSteps, this samples at most 10000 evenly-spaced points
-   * for efficiency.
-   */
-  getStats() {
-    const { baseLR, minLR, totalSteps } = this.config;
-    const decaySteps = totalSteps - this.warmupSteps;
-    let sumLR = 0;
-    const sampleCount = Math.min(totalSteps + 1, 1e4);
-    const stepSize = totalSteps / Math.max(sampleCount - 1, 1);
-    for (let i = 0; i < sampleCount; i++) {
-      const step = Math.round(i * stepSize);
-      sumLR += this.getLR(step);
-    }
-    const avgLR = sampleCount > 0 ? sumLR / sampleCount : 0;
-    return {
-      peakLR: baseLR,
-      minLR,
-      warmupSteps: this.warmupSteps,
-      decaySteps: Math.max(0, decaySteps),
-      totalSteps,
-      avgLR
-    };
-  }
-  /**
-   * Generate the full LR schedule as an array of [step, lr] pairs.
-   * Useful for plotting or debugging.
-   *
-   * @param numPoints - Number of points to sample (default: 100)
-   * @returns Array of [step, learningRate] tuples
-   */
-  getSchedule(numPoints = 100) {
-    const { totalSteps } = this.config;
-    const points = [];
-    const clampedPoints = Math.max(2, numPoints);
-    for (let i = 0; i < clampedPoints; i++) {
-      const step = Math.round(i / (clampedPoints - 1) * totalSteps);
-      points.push([step, this.getLR(step)]);
-    }
-    return points;
-  }
-  /**
-   * Get the number of warmup steps.
-   */
-  getWarmupSteps() {
-    return this.warmupSteps;
-  }
-  /**
-   * Get the current configuration.
-   */
-  getConfig() {
-    return { ...this.config };
-  }
-  // ===========================================================================
-  // INTERNAL METHODS
-  // ===========================================================================
-  /**
-   * Validate configuration parameters.
-   * @throws Error if configuration is invalid
-   */
-  validateConfig() {
-    const { baseLR, totalSteps, warmupRatio, minLR, numCycles } = this.config;
-    if (baseLR <= 0) {
-      throw new Error(`LRScheduler: baseLR must be > 0, got ${baseLR}`);
-    }
-    if (totalSteps < 0 || !Number.isInteger(totalSteps)) {
-      throw new Error(`LRScheduler: totalSteps must be a non-negative integer, got ${totalSteps}`);
-    }
-    if (warmupRatio < 0 || warmupRatio >= 1) {
-      throw new Error(`LRScheduler: warmupRatio must be in [0, 1), got ${warmupRatio}`);
-    }
-    if (minLR < 0 || minLR >= baseLR) {
-      throw new Error(`LRScheduler: minLR must be in [0, baseLR), got ${minLR}`);
-    }
-    if (numCycles < 1 || !Number.isInteger(numCycles)) {
-      throw new Error(`LRScheduler: numCycles must be a positive integer, got ${numCycles}`);
-    }
-  }
-};
-function createSFTScheduler(config = {}) {
-  return new LRScheduler({ ...DEFAULT_LR_SCHEDULER_CONFIG, ...config });
-}
-function createGRPOScheduler(config = {}) {
-  return new LRScheduler({ ...GRPO_LR_SCHEDULER_CONFIG, ...config });
-}
-
-// src/training/QualityScoringPipeline.ts
-var DEFAULT_SCORING_CONFIG = {
-  syntaxWeight: 0.4,
-  schemaWeight: 0.3,
-  semanticWeight: 0.3,
-  minPassScore: 0.7,
-  knownTraits: /* @__PURE__ */ new Set(["Grabbable", "Physics", "Animation", "GaussianSplat", "Tradeable", "NPC"]),
-  knownTypes: /* @__PURE__ */ new Set(["orb", "world", "composition", "template"])
-};
-var QualityScoringPipeline = class {
-  config;
-  constructor(config = {}) {
-    this.config = { ...DEFAULT_SCORING_CONFIG, ...config };
-  }
-  score(source) {
-    const details = [];
-    const syntax = this.scoreSyntax(source, details);
-    const schema = this.scoreSchema(source, details);
-    const semantic = this.scoreSemantic(source, details);
-    const composite = syntax * this.config.syntaxWeight + schema * this.config.schemaWeight + semantic * this.config.semanticWeight;
-    return {
-      syntaxValidity: syntax,
-      schemaCompliance: schema,
-      semanticCorrectness: semantic,
-      compositeScore: composite,
-      details
-    };
-  }
-  passes(score) {
-    return score.compositeScore >= this.config.minPassScore;
-  }
-  scoreSyntax(source, details) {
-    let score = 1;
-    if (!source.trim()) {
-      details.push({ metric: "syntax", score: 0, message: "Empty source" });
-      return 0;
-    }
-    const open = (source.match(/{/g) || []).length;
-    const close = (source.match(/}/g) || []).length;
-    if (open !== close) {
-      score -= 0.5;
-      details.push({
-        metric: "syntax",
-        score: 0.5,
-        message: `Unbalanced braces: ${open} open, ${close} close`
-      });
-    }
-    if (/composition\s+\w+/.test(source) || /orb\s+\w+/.test(source) || /world\s+\w+/.test(source)) {
-      details.push({ metric: "syntax", score: 1, message: "Valid composition structure" });
-    } else {
-      score -= 0.3;
-      details.push({
-        metric: "syntax",
-        score: 0.7,
-        message: "No recognized top-level declaration"
-      });
-    }
-    return Math.max(0, score);
-  }
-  scoreSchema(source, details) {
-    let score = 1;
-    const traitPattern = /(\w+)\s*{/g;
-    let match;
-    while ((match = traitPattern.exec(source)) !== null) {
-      const name = match[1];
-      if (this.config.knownTraits.has(name) || this.config.knownTypes.has(name)) continue;
-      if (/^[A-Z]/.test(name) && !this.config.knownTraits.has(name)) {
-        score -= 0.1;
-        details.push({ metric: "schema", score: 0.9, message: `Unknown trait: ${name}` });
-      }
-    }
-    return Math.max(0, score);
-  }
-  scoreSemantic(source, details) {
-    let score = 1;
-    if (/physics\s*{/.test(source) && !/mass|gravity|friction/.test(source)) {
-      score -= 0.2;
-      details.push({
-        metric: "semantic",
-        score: 0.8,
-        message: "Physics block without mass/gravity/friction"
-      });
-    }
-    if (/animation\s*{/.test(source) && !/clip|duration|speed/.test(source)) {
-      score -= 0.2;
-      details.push({
-        metric: "semantic",
-        score: 0.8,
-        message: "Animation block without clip/duration"
-      });
-    }
-    if (source.length < 20) {
-      score -= 0.3;
-      details.push({
-        metric: "semantic",
-        score: 0.7,
-        message: "Source too short for meaningful composition"
-      });
-    }
-    return Math.max(0, score);
-  }
-};
-
-// src/training/TrainingPipelineConfig.ts
-var DEFAULT_TRAINING_PIPELINE_CONFIG = {
-  qualityScoring: DEFAULT_SCORING_CONFIG,
-  softDedup: DEFAULT_SOFTDEDUP_CONFIG,
-  lrSchedule: DEFAULT_LR_SCHEDULER_CONFIG,
-  hyperparameters: {
-    learningRate: 2e-4,
-    epochs: 2,
-    optimizer: "paged_adamw_8bit",
-    microBatchSize: 8,
-    gradientAccumulationSteps: 4,
-    maxGradNorm: 1,
-    weightDecay: 0.01
-  },
-  pipeline: {
-    enableQualityFilter: true,
-    enableSoftDedup: true,
-    enableLRSchedule: true
-  }
-};
-function buildTrainingPipelineConfig(overrides = {}) {
-  return {
-    qualityScoring: {
-      ...DEFAULT_TRAINING_PIPELINE_CONFIG.qualityScoring,
-      ...overrides.qualityScoring
-    },
-    softDedup: {
-      ...DEFAULT_TRAINING_PIPELINE_CONFIG.softDedup,
-      ...overrides.softDedup
-    },
-    lrSchedule: {
-      ...DEFAULT_TRAINING_PIPELINE_CONFIG.lrSchedule,
-      ...overrides.lrSchedule
-    },
-    hyperparameters: {
-      ...DEFAULT_TRAINING_PIPELINE_CONFIG.hyperparameters,
-      ...overrides.hyperparameters
-    },
-    pipeline: {
-      ...DEFAULT_TRAINING_PIPELINE_CONFIG.pipeline,
-      ...overrides.pipeline
-    }
-  };
-}
-function computeTotalSteps(datasetSize, config) {
-  const { microBatchSize, gradientAccumulationSteps, epochs } = config.hyperparameters;
-  const effectiveBatchSize = microBatchSize * gradientAccumulationSteps;
-  const stepsPerEpoch = Math.ceil(datasetSize / effectiveBatchSize);
-  return stepsPerEpoch * epochs;
-}
-
-// src/training/trainingmonkey/TrainingMonkeyTypes.ts
-var DEFAULT_INTEGRATION_CONFIG = {
-  inputPath: "",
-  outputDir: "",
-  trainRatio: 0.9,
-  seed: 42,
-  enableSoftDedup: true,
-  modelName: "qwen7b",
-  stratify: true
-};
-
-// src/training/trainingmonkey/TrainingMonkeyIntegration.ts
-function createSeededRandom(seed) {
-  let state = seed | 0;
-  return () => {
-    state = state + 1831565813 | 0;
-    let t = Math.imul(state ^ state >>> 15, 1 | state);
-    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
-    return ((t ^ t >>> 14) >>> 0) / 4294967296;
-  };
-}
-var TrainingMonkeyIntegration = class {
-  config;
-  softDedup;
-  constructor(config = {}) {
-    this.config = { ...DEFAULT_INTEGRATION_CONFIG, ...config };
-    this.softDedup = new SoftDedup({
-      ngramSizes: [3, 5, 7],
-      wordLevel: false,
-      minWeight: 0.1,
-      maxWeight: 1,
-      temperature: 1,
-      commonThresholdPercentile: 0.7
-    });
-  }
-  // ===========================================================================
-  // PUBLIC API
-  // ===========================================================================
-  /**
-   * Run the full integration pipeline on raw JSONL content.
-   *
-   * @param jsonlContent - Raw JSONL string content from the dataset file
-   * @returns Complete IntegrationResult with split data, config, and serialized output
-   */
-  process(jsonlContent) {
-    const entries = this.readJsonl(jsonlContent);
-    const alpacaEntries = this.convertToAlpaca(entries);
-    const weightedEntries = this.config.enableSoftDedup ? this.applySoftDedup(alpacaEntries, entries) : alpacaEntries.map(
-      (entry, index) => ({
-        ...entry,
-        sampling_weight: 1,
-        metadata: entries[index]?.metadata
-      })
-    );
-    const split = this.splitDataset(weightedEntries);
-    const config = this.generateConfig(split);
-    const trainJsonl = this.serializeJsonl(split.train);
-    const validationJsonl = this.serializeJsonl(split.validation);
-    const configJson = JSON.stringify(config, null, 2);
-    return {
-      split,
-      config,
-      trainJsonl,
-      validationJsonl,
-      configJson
-    };
-  }
-  /**
-   * Parse raw JSONL content into SpatialTrainingJSONLEntry objects.
-   *
-   * @param jsonlContent - Raw JSONL string (one JSON object per line)
-   * @returns Array of parsed entries
-   * @throws Error if a line contains invalid JSON
-   */
-  readJsonl(jsonlContent) {
-    const lines = jsonlContent.split("\n").filter((line) => line.trim() !== "");
-    const entries = [];
-    for (let i = 0; i < lines.length; i++) {
-      try {
-        const parsed = JSON.parse(lines[i]);
-        if (!parsed.instruction || !parsed.response) {
-          throw new Error(`Missing required fields (instruction/response)`);
-        }
-        entries.push(parsed);
-      } catch (e) {
-        throw new Error(`Failed to parse JSONL line ${i + 1}: ${e.message}`);
-      }
-    }
-    return entries;
-  }
-  /**
-   * Convert spatial training entries to Alpaca format.
-   *
-   * Mapping:
-   *   instruction -> instruction (question/prompt)
-   *   input -> extracted HoloScript scene from instruction (if present)
-   *   output -> response (answer)
-   *
-   * @param entries - Parsed spatial training entries
-   * @returns Alpaca-formatted entries
-   */
-  convertToAlpaca(entries) {
-    return entries.map((entry) => {
-      const { questionPart, scenePart } = this.extractSceneFromInstruction(entry.instruction);
-      return {
-        instruction: questionPart,
-        input: scenePart,
-        output: entry.response
-      };
-    });
-  }
-  /**
-   * Apply SoftDedup (W.008) n-gram reweighting to Alpaca entries.
-   *
-   * Uses the instruction + output text to compute n-gram commonness scores
-   * and assigns sampling weights. Template-generated near-duplicates receive
-   * lower weights (min 0.1), while unique examples keep weight 1.0.
-   *
-   * @param alpacaEntries - Converted Alpaca entries
-   * @param originalEntries - Original JSONL entries (for metadata preservation)
-   * @returns Weighted Alpaca entries with sampling_weight and metadata
-   */
-  applySoftDedup(alpacaEntries, originalEntries) {
-    const textCorpus = alpacaEntries.map((entry) => `${entry.instruction} ${entry.output}`);
-    const dedupResults = this.softDedup.process(textCorpus);
-    return alpacaEntries.map((entry, index) => ({
-      ...entry,
-      sampling_weight: dedupResults[index]?.samplingWeight ?? 1,
-      metadata: originalEntries[index]?.metadata
-    }));
-  }
-  /**
-   * Split weighted entries into train/validation sets.
-   *
-   * When stratified=true, the split preserves the distribution of
-   * relationship_type and difficulty across both sets.
-   *
-   * @param entries - Weighted Alpaca entries
-   * @returns DatasetSplit with train, validation, and stats
-   */
-  splitDataset(entries) {
-    if (entries.length === 0) {
-      return {
-        train: [],
-        validation: [],
-        stats: {
-          totalExamples: 0,
-          trainCount: 0,
-          validationCount: 0,
-          trainRatio: 0,
-          validationRatio: 0,
-          stratified: this.config.stratify
-        }
-      };
-    }
-    const rng = createSeededRandom(this.config.seed);
-    let train;
-    let validation;
-    if (this.config.stratify && entries[0]?.metadata) {
-      ({ train, validation } = this.stratifiedSplit(entries, rng));
-    } else {
-      ({ train, validation } = this.randomSplit(entries, rng));
-    }
-    const stats = {
-      totalExamples: entries.length,
-      trainCount: train.length,
-      validationCount: validation.length,
-      trainRatio: train.length / entries.length,
-      validationRatio: validation.length / entries.length,
-      stratified: this.config.stratify && !!entries[0]?.metadata
-    };
-    return { train, validation, stats };
-  }
-  /**
-   * Generate a TrainingMonkey-compatible training configuration.
-   *
-   * Uses W.006 hyperparameters:
-   *   - Learning rate: 2e-4
-   *   - Epochs: 2
-   *   - Optimizer: paged_adamw_8bit
-   *
-   * Uses W.007 batch sizing:
-   *   - Micro-batch: 8
-   *   - Gradient accumulation: 4
-   *   - Effective batch: 32
-   *
-   * Uses W.009 LR schedule:
-   *   - Warmup: 10% of total steps
-   *   - Schedule: cosine decay
-   *
-   * @param split - The dataset split result
-   * @returns TrainingMonkey-compatible config
-   */
-  generateConfig(split) {
-    const microBatchSize = 8;
-    const gradientAccumulationSteps = 4;
-    const epochs = 2;
-    const effectiveBatchSize = microBatchSize * gradientAccumulationSteps;
-    const stepsPerEpoch = Math.ceil(split.stats.trainCount / effectiveBatchSize);
-    const totalSteps = stepsPerEpoch * epochs;
-    const weights = split.train.map((e) => e.sampling_weight);
-    const meanWeight = weights.length > 0 ? weights.reduce((sum, w) => sum + w, 0) / weights.length : 1;
-    const effectiveSize = weights.reduce((sum, w) => sum + w, 0);
-    const reductionRatio = weights.length > 0 ? 1 - effectiveSize / weights.length : 0;
-    return {
-      model: {
-        name: this.config.modelName,
-        maxSeqLength: 2048
-      },
-      hyperparameters: {
-        learningRate: 2e-4,
-        epochs,
-        optimizer: "paged_adamw_8bit",
-        microBatchSize,
-        gradientAccumulationSteps,
-        maxGradNorm: 1,
-        weightDecay: 0.01
-      },
-      lrSchedule: {
-        warmupRatio: 0.1,
-        type: "cosine"
-      },
-      dataset: {
-        trainPath: `${this.config.outputDir}/alpaca-train.jsonl`,
-        validationPath: `${this.config.outputDir}/alpaca-val.jsonl`,
-        trainCount: split.stats.trainCount,
-        validationCount: split.stats.validationCount,
-        totalSteps
-      },
-      softDedup: {
-        applied: this.config.enableSoftDedup,
-        meanWeight,
-        effectiveSize,
-        reductionRatio
-      }
-    };
-  }
-  /**
-   * Serialize weighted Alpaca entries to JSONL string.
-   *
-   * @param entries - Entries to serialize
-   * @returns JSONL string (one JSON object per line)
-   */
-  serializeJsonl(entries) {
-    return entries.map((entry) => JSON.stringify(entry)).join("\n");
-  }
-  /**
-   * Get the current integration configuration.
-   */
-  getConfig() {
-    return { ...this.config };
-  }
-  // ===========================================================================
-  // INTERNAL METHODS
-  // ===========================================================================
-  /**
-   * Extract the question part and HoloScript scene from an instruction string.
-   *
-   * The spatial reasoning dataset embeds HoloScript scenes in instructions:
-   * ```
-   * Does the spatial_adjacent constraint pass?
-   *
-   * HoloScript Scene:
-   * ```holoscript
-   * composition "SpatialScene" { ... }
-   * ```
-   * ```
-   *
-   * This method splits the instruction into the question (instruction field)
-   * and the scene source (input field) for the Alpaca format.
-   */
-  extractSceneFromInstruction(instruction) {
-    const sceneMarkerIndex = instruction.indexOf("HoloScript Scene:");
-    if (sceneMarkerIndex === -1) {
-      return { questionPart: instruction.trim(), scenePart: "" };
-    }
-    const questionPart = instruction.substring(0, sceneMarkerIndex).trim();
-    const scenePart = instruction.substring(sceneMarkerIndex).trim();
-    return { questionPart, scenePart };
-  }
-  /**
-   * Perform a stratified split preserving distribution of metadata fields.
-   * Groups by relationship_type + difficulty and splits each group proportionally.
-   */
-  stratifiedSplit(entries, rng) {
-    const groups = /* @__PURE__ */ new Map();
-    for (const entry of entries) {
-      const key = entry.metadata ? `${entry.metadata.relationship_type}:${entry.metadata.difficulty}` : "unknown";
-      if (!groups.has(key)) {
-        groups.set(key, []);
-      }
-      groups.get(key).push(entry);
-    }
-    const train = [];
-    const validation = [];
-    for (const [, groupEntries] of groups) {
-      const shuffled = this.fisherYatesShuffle([...groupEntries], rng);
-      const splitIndex = Math.round(shuffled.length * this.config.trainRatio);
-      train.push(...shuffled.slice(0, splitIndex));
-      validation.push(...shuffled.slice(splitIndex));
-    }
-    return { train, validation };
-  }
-  /**
-   * Perform a simple random split.
-   */
-  randomSplit(entries, rng) {
-    const shuffled = this.fisherYatesShuffle([...entries], rng);
-    const splitIndex = Math.round(shuffled.length * this.config.trainRatio);
-    return {
-      train: shuffled.slice(0, splitIndex),
-      validation: shuffled.slice(splitIndex)
-    };
-  }
-  /**
-   * Fisher-Yates shuffle with seeded PRNG for deterministic ordering.
-   */
-  fisherYatesShuffle(array, rng) {
-    for (let i = array.length - 1; i > 0; i--) {
-      const j = Math.floor(rng() * (i + 1));
-      [array[i], array[j]] = [array[j], array[i]];
-    }
-    return array;
-  }
-};
-function createTrainingMonkeyIntegration(config = {}) {
-  return new TrainingMonkeyIntegration(config);
-}
-
-// src/training/constants.ts
-var TRAINING_CATEGORIES = [
-  "vr-interaction",
-  "multiplayer",
-  "physics",
-  "ui-spatial",
-  "ai-agents",
-  "procedural",
-  "audio-spatial",
-  "visual-effects",
-  "game-mechanics"
-];
-var DIFFICULTY_LEVELS = ["beginner", "intermediate", "advanced", "production"];
-var QUALITY_THRESHOLDS = {
-  Excellent: { min: 90, max: 100 },
-  VeryGood: { min: 80, max: 89 },
-  Acceptable: { min: 70, max: 79 }
-};
-var DEFAULT_GENERATOR_THRESHOLDS = {
-  min_compression_ratio: 5,
-  max_compression_ratio: 15,
-  max_duplication_rate: 0.05,
-  min_templates_per_difficulty: 10,
-  min_quality_score: 0.7
-};
-var RULEFORGE_DOMAINS = [
-  "ai_agents",
-  "physics",
-  "robotics",
-  "audio",
-  "rendering",
-  "interaction",
-  "multiplayer",
-  "vr_ar"
-];
-function getQualityTier(score) {
-  if (score >= QUALITY_THRESHOLDS.Excellent.min) return "Excellent";
-  if (score >= QUALITY_THRESHOLDS.VeryGood.min) return "VeryGood";
-  if (score >= QUALITY_THRESHOLDS.Acceptable.min) return "Acceptable";
-  return "BelowAcceptable";
-}
-function isValidCategory(category) {
-  return TRAINING_CATEGORIES.includes(category);
-}
-function isValidDifficulty(difficulty) {
-  return DIFFICULTY_LEVELS.includes(difficulty);
-}
-
-// src/training/schema.ts
-function validateTrainingExample(example) {
-  const errors = [];
-  const warnings = [];
-  if (!example || typeof example !== "object") {
-    return {
-      valid: false,
-      errors: [{ field: "root", message: "Example must be an object", severity: "error" }],
-      warnings
-    };
-  }
-  const ex = example;
-  if (typeof ex.instruction !== "string" || ex.instruction.length === 0) {
-    errors.push({
-      field: "instruction",
-      message: "instruction must be a non-empty string",
-      severity: "error"
-    });
-  }
-  if (typeof ex.input !== "string") {
-    errors.push({ field: "input", message: "input must be a string", severity: "error" });
-  }
-  if (typeof ex.output !== "string" || ex.output.length === 0) {
-    errors.push({
-      field: "output",
-      message: "output must be a non-empty string",
-      severity: "error"
-    });
-  }
-  if (ex.metadata && typeof ex.metadata === "object") {
-    const meta = ex.metadata;
-    if (typeof meta.category !== "string") {
-      errors.push({
-        field: "metadata.category",
-        message: "category must be a string",
-        severity: "error"
-      });
-    }
-    if (typeof meta.difficulty !== "string") {
-      errors.push({
-        field: "metadata.difficulty",
-        message: "difficulty must be a string",
-        severity: "error"
-      });
-    }
-    if (!Array.isArray(meta.traits)) {
-      warnings.push("metadata.traits should be an array");
-    }
-  } else {
-    errors.push({ field: "metadata", message: "metadata must be an object", severity: "error" });
-  }
-  return { valid: errors.length === 0, errors, warnings };
-}
-
-// src/training/trait-mappings.ts
-var TM_REGISTERED_TRAITS = [
-  // V43 Tier 1 Core AI
-  "llm_agent",
-  "behavior_tree",
-  "goal_oriented",
-  "neural_link",
-  "neural_forge",
-  "spatial_awareness",
-  "shared_world",
-  "eye_tracked",
-  "hand_tracking",
-  "vision",
-  // V43 Tier 2 visionOS
-  "spatial_persona",
-  "shareplay",
-  "object_tracking",
-  "scene_reconstruction",
-  "realitykit_mesh",
-  "room_mesh",
-  "volumetric_window",
-  "spatial_navigation",
-  // V43 Tier 2 AI Generative
-  "stable_diffusion",
-  "controlnet",
-  "ai_texture_gen",
-  "diffusion_realtime",
-  "ai_inpainting",
-  "ai_upscaling",
-  // V5.1 Hololand Exclusive
-  "networked",
-  "render_network",
-  "openxr_hal",
-  "hitl",
-  "zora_coins",
-  "neural_upscaling",
-  "grabbable",
-  "throwable",
-  "pointable",
-  "drawable",
-  "attachable",
-  "socket",
-  "billboard",
-  "ui_panel",
-  "hud",
-  "glowing",
-  "physics",
-  "persistent",
-  "tool",
-  // Physics Patterns
-  "conversion_tracking",
-  "impact_physics",
-  "fragment_conversion",
-  "damage_falloff",
-  "cross_system_integration"
-];
-function validateTraitName(traitName, validTraits) {
-  const normalized = traitName.toLowerCase().replace(/@/g, "").trim();
-  const traitSet = validTraits instanceof Set ? validTraits : new Set(validTraits);
-  if (traitSet.has(normalized)) return normalized;
-  if (traitSet.has(traitName)) return traitName;
-  return null;
-}
-function generateValidationReport(tmTraits, hsTraits, deprecatedTraits) {
-  const hsSet = hsTraits instanceof Set ? hsTraits : new Set(hsTraits);
-  const depSet = deprecatedTraits ?? /* @__PURE__ */ new Set();
-  const details = [];
-  for (const tm of tmTraits) {
-    const normalized = tm.toLowerCase().replace(/@/g, "").trim();
-    if (depSet.has(normalized)) {
-      details.push({ tmName: tm, hsName: normalized, status: "deprecated" });
-    } else if (hsSet.has(normalized)) {
-      details.push({ tmName: tm, hsName: normalized, status: "matched" });
-    } else {
-      details.push({ tmName: tm, hsName: null, status: "unmatched" });
-    }
-  }
-  return {
-    matched: details.filter((d) => d.status === "matched").length,
-    unmatched: details.filter((d) => d.status === "unmatched").length,
-    deprecated: details.filter((d) => d.status === "deprecated").length,
-    total: details.length,
-    details
-  };
-}
-export {
-  DEFAULT_GENERATOR_THRESHOLDS,
-  DEFAULT_INTEGRATION_CONFIG,
-  DEFAULT_LR_SCHEDULER_CONFIG,
-  DEFAULT_SCORING_CONFIG,
-  DEFAULT_SOFTDEDUP_CONFIG,
-  DEFAULT_TRAINING_PIPELINE_CONFIG,
-  DIFFICULTY_LEVELS,
-  GRPO_LR_SCHEDULER_CONFIG,
-  LRScheduler,
-  QUALITY_THRESHOLDS,
-  QualityScoringPipeline,
-  RULEFORGE_DOMAINS,
-  SoftDedup,
-  SparsityMonitor,
-  SpatialTrainingDataGenerator,
-  TM_REGISTERED_TRAITS,
-  TRAINING_CATEGORIES,
-  TrainingMonkeyIntegration,
-  buildTrainingPipelineConfig,
-  computeTotalSteps,
-  createGRPOScheduler,
-  createSFTScheduler,
-  createSoftDedup,
-  createSparsityMonitor,
-  createSpatialTrainingDataGenerator,
-  createTrainingMonkeyIntegration,
-  generateValidationReport,
-  getQualityTier,
-  isValidCategory,
-  isValidDifficulty,
-  validateTrainingExample,
-  validateTraitName
-};