@holoscript/framework 6.0.3

package/dist/training/index.js

@@ -0,0 +1,2687 @@
+// 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
+};