@rotifer/playground 0.8.1 → 0.8.6

package/genes/orch/phenotype.json

@@ -1,28 +0,0 @@
-{
-  "domain": "orchestration.dispatch",
-  "description": "Intelligent skill orchestration hub. Automatically identifies and dispatches the most suitable skills based on user intent. Analyzes conversation context, matches task types, and combines multiple skills for complex tasks.",
-  "inputSchema": {
-    "type": "object",
-    "properties": {
-      "prompt": {
-        "type": "string"
-      }
-    },
-    "required": []
-  },
-  "outputSchema": {
-    "type": "object",
-    "properties": {
-      "result": {
-        "type": "string"
-      }
-    }
-  },
-  "dependencies": [],
-  "version": "0.1.0",
-  "author": "rotifer-team",
-  "createdAt": 1771939421033,
-  "fidelity": "Wrapped",
-  "transparency": "Open",
-  "source": "skill"
-}

package/genes/particle-barneshut/.cloud-manifest.json

@@ -1,6 +0,0 @@
-{
-  "cloud_id": "59ce93bc-f246-4d2f-b9da-48422f4d06b1",
-  "owner": "Rotifer Protocol",
-  "version": "0.1.0",
-  "published_at": "2026-03-17T14:13:14.087Z"
-}

package/genes/particle-barneshut/.compile-result.json

@@ -1,12 +0,0 @@
-{
-  "geneId": "303fa9c27069e25be94e2e2e336cc2bb09c153d595bc6ea84c485b08db13c35e",
-  "name": "particle-barneshut",
-  "domain": "sim.particle",
-  "compiledAt": "2026-03-14T09:13:45.199Z",
-  "fidelity": "Native",
-  "wasmAvailable": true,
-  "irHash": "391614d239e64ad94d257ec59c079a1a060d0143b28f6edd8ec255858f961d1c",
-  "totalSize": 1335283,
-  "codeSectionSize": 956115,
-  "durationMs": 7374
-}

package/genes/particle-barneshut/README.md

@@ -1,55 +0,0 @@
-# particle-barneshut
-
-Barnes-Hut quadtree N-body gravitational simulation — a pure-computation Native Gene for the Rotifer Protocol.
-
-## Algorithm
-
-Builds a quadtree each step to hierarchically group distant particles. When computing the force on particle i:
-
-1. If a tree node is a leaf containing a different particle, compute direct force
-2. If an internal node satisfies `(size / distance) < θ`, approximate all particles in that node as a single body at its center of mass
-3. Otherwise, recurse into the four children (NW, NE, SW, SE)
-
-With θ = 0.5 (the default opening angle), this achieves O(n log n) force evaluations per step while maintaining good accuracy — typically within 1-2% of the exact brute-force solution.
-
-Integration uses the symplectic leapfrog (kick-drift-kick) scheme.
-
-## Usage
-
-```bash
-# Solar system preset (64 particles)
-rotifer run particle-barneshut --input '{"preset": "solar"}'
-
-# Large cluster (512 particles, 200 steps)
-rotifer run particle-barneshut --input '{"preset": "cluster", "count": 512, "steps": 200}'
-
-# Binary star system
-rotifer run particle-barneshut --input '{"preset": "binary", "count": 100}'
-```
-
-## Presets
-
-| Preset | Description |
-|--------|-------------|
-| `solar` | Central massive body + orbiting lighter bodies with circular velocities |
-| `binary` | Two equal-mass stars in mutual orbit + debris ring |
-| `cluster` | Random particles in a disk with small random velocities |
-| `collision` | Two groups of particles approaching head-on |
-
-## Output
-
-- `particles` — final positions and velocities of all particles
-- `steps_computed` — number of simulation steps executed
-- `total_energy` — total system energy (kinetic + potential) for conservation validation
-- `interactions_computed` — total tree-node force evaluations (fewer than brute-force)
-
-## Fitness Characteristics
-
-| Metric | Expected |
-|--------|----------|
-| Success Rate | 1.0 (deterministic, no failure mode) |
-| Accuracy | High (θ=0.5: ~1-2% error vs brute-force) |
-| Complexity | O(n log n × steps) |
-| Interactions | ~O(n log n) per step (varies with particle distribution) |
-| Best For | Medium-to-large N (64-2048), best accuracy/cost tradeoff |
-| Weakness | Tree construction overhead for very small N |

package/genes/particle-barneshut/index.ts

@@ -1,486 +0,0 @@
-interface Particle {
-  x: number;
-  y: number;
-  vx: number;
-  vy: number;
-  mass: number;
-}
-
-interface ParticleInput {
-  particles?: Particle[];
-  preset?: "solar" | "binary" | "cluster" | "collision";
-  count?: number;
-  steps?: number;
-  dt?: number;
-  G?: number;
-  softening?: number;
-  seed?: number;
-}
-
-interface ParticleOutput {
-  particles: Particle[];
-  steps_computed: number;
-  total_energy: number;
-  interactions_computed: number;
-}
-
-interface QuadNode {
-  cx: number;
-  cy: number;
-  mass: number;
-  x: number;
-  y: number;
-  size: number;
-  children: (QuadNode | null)[];
-  particleIdx: number;
-  particleIndices?: number[];
-}
-
-const MIN_CELL_SIZE = 1e-10;
-
-function mulberry32(seed: number): () => number {
-  let s = seed | 0;
-  return () => {
-    s = (s + 0x6d2b79f5) | 0;
-    let t = Math.imul(s ^ (s >>> 15), 1 | s);
-    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
-    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
-  };
-}
-
-function generatePreset(
-  preset: "solar" | "binary" | "cluster" | "collision",
-  count: number,
-  seed: number
-): Particle[] {
-  const rng = mulberry32(seed);
-  const G = 1.0;
-
-  switch (preset) {
-    case "solar": {
-      const particles: Particle[] = [];
-      const M_central = 100;
-      particles.push({ x: 0, y: 0, vx: 0, vy: 0, mass: M_central });
-
-      const nOrbiters = Math.min(count - 1, 63);
-      for (let i = 0; i < nOrbiters; i++) {
-        const r = 2 + rng() * 8;
-        const theta = rng() * 2 * Math.PI;
-        const x = r * Math.cos(theta);
-        const y = r * Math.sin(theta);
-        const v = Math.sqrt((G * M_central) / r);
-        const vx = -v * Math.sin(theta);
-        const vy = v * Math.cos(theta);
-        const mass = 0.1 + rng() * 0.9;
-        particles.push({ x, y, vx, vy, mass });
-      }
-      return particles;
-    }
-
-    case "binary": {
-      const particles: Particle[] = [];
-      const m1 = 50;
-      const m2 = 50;
-      const d = 4;
-      const r1 = (d * m2) / (m1 + m2);
-      const r2 = (d * m1) / (m1 + m2);
-      const omega = Math.sqrt((G * (m1 + m2)) / (d * d * d));
-      const v1 = omega * r1;
-      const v2 = omega * r2;
-
-      particles.push({ x: -r1, y: 0, vx: 0, vy: -v1, mass: m1 });
-      particles.push({ x: r2, y: 0, vx: 0, vy: v2, mass: m2 });
-
-      const nDebris = Math.min(count - 2, 62);
-      for (let i = 0; i < nDebris; i++) {
-        const r = 6 + rng() * 4;
-        const theta = rng() * 2 * Math.PI;
-        const x = r * Math.cos(theta);
-        const y = r * Math.sin(theta);
-        const v = Math.sqrt((G * (m1 + m2)) / r) * (0.8 + rng() * 0.4);
-        const vx = -v * Math.sin(theta);
-        const vy = v * Math.cos(theta);
-        const mass = 0.1 + rng() * 0.5;
-        particles.push({ x, y, vx, vy, mass });
-      }
-      return particles;
-    }
-
-    case "cluster": {
-      const particles: Particle[] = [];
-      const radius = 5;
-      for (let i = 0; i < count; i++) {
-        const r = radius * Math.sqrt(rng());
-        const theta = rng() * 2 * Math.PI;
-        const x = r * Math.cos(theta);
-        const y = r * Math.sin(theta);
-        const vMax = 0.3;
-        const vx = (rng() - 0.5) * 2 * vMax;
-        const vy = (rng() - 0.5) * 2 * vMax;
-        const mass = 0.5 + rng() * 1.5;
-        particles.push({ x, y, vx, vy, mass });
-      }
-      return particles;
-    }
-
-    case "collision": {
-      const particles: Particle[] = [];
-      const half = Math.floor(count / 2);
-      const sep = 10;
-      const vApproach = 1.5;
-
-      for (let i = 0; i < half; i++) {
-        const x = -sep + (rng() - 0.5) * 4;
-        const y = (rng() - 0.5) * 4;
-        const vx = vApproach + (rng() - 0.5) * 0.4;
-        const vy = (rng() - 0.5) * 0.4;
-        const mass = 0.5 + rng() * 1.5;
-        particles.push({ x, y, vx, vy, mass });
-      }
-      for (let i = 0; i < count - half; i++) {
-        const x = sep + (rng() - 0.5) * 4;
-        const y = (rng() - 0.5) * 4;
-        const vx = -vApproach + (rng() - 0.5) * 0.4;
-        const vy = (rng() - 0.5) * 0.4;
-        const mass = 0.5 + rng() * 1.5;
-        particles.push({ x, y, vx, vy, mass });
-      }
-      return particles;
-    }
-
-    default:
-      return generatePreset("cluster", count, seed);
-  }
-}
-
-function createEmptyNode(x: number, y: number, size: number): QuadNode {
-  return {
-    cx: 0,
-    cy: 0,
-    mass: 0,
-    x,
-    y,
-    size,
-    children: [null, null, null, null],
-    particleIdx: -1,
-  };
-}
-
-function getQuadrant(px: number, py: number, cx: number, cy: number): number {
-  if (px < cx) {
-    return py < cy ? 0 : 2;
-  }
-  return py < cy ? 1 : 3;
-}
-
-function insertParticle(
-  node: QuadNode,
-  particles: Particle[],
-  idx: number
-): void {
-  const p = particles[idx];
-  const half = node.size / 2;
-
-  if (half < MIN_CELL_SIZE) {
-    if (node.particleIdx >= 0) {
-      node.particleIndices = [node.particleIdx];
-      node.particleIdx = -1;
-    }
-    if (!node.particleIndices) node.particleIndices = [];
-    node.particleIndices.push(idx);
-    return;
-  }
-
-  if (node.particleIdx >= 0) {
-    const existing = particles[node.particleIdx];
-    const q = getQuadrant(existing.x, existing.y, node.x, node.y);
-    const child = createEmptyNode(
-      node.x + (q === 0 || q === 2 ? -half / 2 : half / 2),
-      node.y + (q < 2 ? -half / 2 : half / 2),
-      half
-    );
-    insertParticle(child, particles, node.particleIdx);
-    node.children[q] = child;
-    node.particleIdx = -1;
-  }
-
-  const q = getQuadrant(p.x, p.y, node.x, node.y);
-  let child = node.children[q];
-
-  if (child === null) {
-    child = createEmptyNode(
-      node.x + (q === 0 || q === 2 ? -half / 2 : half / 2),
-      node.y + (q < 2 ? -half / 2 : half / 2),
-      half
-    );
-    child.particleIdx = idx;
-    child.cx = p.x;
-    child.cy = p.y;
-    child.mass = p.mass;
-    node.children[q] = child;
-  } else {
-    insertParticle(child, particles, idx);
-  }
-}
-
-function computeCenterOfMass(node: QuadNode, particles: Particle[]): void {
-  if (node.particleIdx >= 0) {
-    const p = particles[node.particleIdx];
-    node.cx = p.x;
-    node.cy = p.y;
-    node.mass = p.mass;
-    return;
-  }
-
-  if (node.particleIndices && node.particleIndices.length > 0) {
-    let totalMass = 0;
-    let sumX = 0;
-    let sumY = 0;
-    for (const i of node.particleIndices) {
-      const p = particles[i];
-      totalMass += p.mass;
-      sumX += p.x * p.mass;
-      sumY += p.y * p.mass;
-    }
-    if (totalMass > 0) {
-      node.cx = sumX / totalMass;
-      node.cy = sumY / totalMass;
-    }
-    node.mass = totalMass;
-    return;
-  }
-
-  let totalMass = 0;
-  let sumX = 0;
-  let sumY = 0;
-
-  for (const c of node.children) {
-    if (c !== null) {
-      computeCenterOfMass(c, particles);
-      totalMass += c.mass;
-      sumX += c.cx * c.mass;
-      sumY += c.cy * c.mass;
-    }
-  }
-
-  if (totalMass > 0) {
-    node.cx = sumX / totalMass;
-    node.cy = sumY / totalMass;
-  }
-  node.mass = totalMass;
-}
-
-const THETA = 0.5;
-
-function computeForce(
-  node: QuadNode,
-  particles: Particle[],
-  idx: number,
-  G: number,
-  softening: number,
-  ax: Float64Array,
-  ay: Float64Array,
-  interactions: { count: number }
-): void {
-  const p = particles[idx];
-  const dx = node.cx - p.x;
-  const dy = node.cy - p.y;
-  const rSq = dx * dx + dy * dy + softening * softening;
-  const r = Math.sqrt(rSq);
-
-  if (node.particleIdx >= 0) {
-    if (node.particleIdx === idx) return;
-    const factor = (G * node.mass) / Math.pow(rSq, 1.5);
-    ax[idx] += factor * dx;
-    ay[idx] += factor * dy;
-    interactions.count += 1;
-    return;
-  }
-
-  if (node.particleIndices && node.particleIndices.length > 0) {
-    for (const j of node.particleIndices) {
-      if (j === idx) continue;
-      const pj = particles[j];
-      const dxj = pj.x - p.x;
-      const dyj = pj.y - p.y;
-      const rSqj = dxj * dxj + dyj * dyj + softening * softening;
-      const factor = (G * pj.mass) / Math.pow(rSqj, 1.5);
-      ax[idx] += factor * dxj;
-      ay[idx] += factor * dyj;
-      interactions.count += 1;
-    }
-    return;
-  }
-
-  const ratio = node.size / (r + 1e-10);
-
-  if (ratio < THETA) {
-    const factor = (G * node.mass) / Math.pow(rSq, 1.5);
-    ax[idx] += factor * dx;
-    ay[idx] += factor * dy;
-    interactions.count += 1;
-    return;
-  }
-
-  for (const c of node.children) {
-    if (c !== null && c.mass > 0) {
-      computeForce(c, particles, idx, G, softening, ax, ay, interactions);
-    }
-  }
-}
-
-function computeTotalEnergy(
-  particles: Particle[],
-  G: number,
-  softening: number
-): number {
-  let kinetic = 0;
-  let potential = 0;
-  const n = particles.length;
-
-  for (let i = 0; i < n; i++) {
-    const p = particles[i];
-    kinetic += 0.5 * p.mass * (p.vx * p.vx + p.vy * p.vy);
-  }
-
-  for (let i = 0; i < n; i++) {
-    for (let j = i + 1; j < n; j++) {
-      const pi = particles[i];
-      const pj = particles[j];
-      const dx = pj.x - pi.x;
-      const dy = pj.y - pi.y;
-      const rSq = dx * dx + dy * dy + softening * softening;
-      const r = Math.sqrt(rSq);
-      potential -= (G * pi.mass * pj.mass) / r;
-    }
-  }
-
-  return kinetic + potential;
-}
-
-export async function express(input: ParticleInput): Promise<ParticleOutput> {
-  const count = Math.max(2, Math.min(2048, input.count ?? 64));
-  const steps = Math.max(1, Math.min(10000, input.steps ?? 100));
-  const dt = input.dt ?? 0.01;
-  const G = input.G ?? 1.0;
-  const softening = input.softening ?? 0.01;
-  const seed = input.seed ?? 42;
-
-  let particles: Particle[];
-
-  if (input.particles && input.particles.length > 0) {
-    particles = input.particles.map((p) => ({
-      x: p.x,
-      y: p.y,
-      vx: p.vx,
-      vy: p.vy,
-      mass: p.mass,
-    }));
-  } else {
-    const preset = input.preset ?? "cluster";
-    particles = generatePreset(preset, count, seed);
-  }
-
-  const n = particles.length;
-  const ax = new Float64Array(n);
-  const ay = new Float64Array(n);
-  let interactionsComputed = 0;
-  const margin = 0.1;
-
-  for (let stepIdx = 0; stepIdx < steps; stepIdx++) {
-    let minX = Infinity;
-    let maxX = -Infinity;
-    let minY = Infinity;
-    let maxY = -Infinity;
-
-    for (let i = 0; i < n; i++) {
-      const p = particles[i];
-      if (p.x < minX) minX = p.x;
-      if (p.x > maxX) maxX = p.x;
-      if (p.y < minY) minY = p.y;
-      if (p.y > maxY) maxY = p.y;
-    }
-
-    const size = Math.max(maxX - minX, maxY - minY, 1) / 2 + margin;
-    const root = createEmptyNode(
-      (minX + maxX) / 2,
-      (minY + maxY) / 2,
-      size
-    );
-
-    for (let i = 0; i < n; i++) {
-      insertParticle(root, particles, i);
-    }
-    computeCenterOfMass(root, particles);
-
-    ax.fill(0);
-    ay.fill(0);
-    const interactions = { count: 0 };
-
-    for (let i = 0; i < n; i++) {
-      computeForce(root, particles, i, G, softening, ax, ay, interactions);
-    }
-    interactionsComputed += interactions.count;
-
-    for (let i = 0; i < n; i++) {
-      const p = particles[i];
-      p.vx += 0.5 * dt * ax[i];
-      p.vy += 0.5 * dt * ay[i];
-    }
-
-    for (let i = 0; i < n; i++) {
-      const p = particles[i];
-      p.x += dt * p.vx;
-      p.y += dt * p.vy;
-    }
-
-    minX = Infinity;
-    maxX = -Infinity;
-    minY = Infinity;
-    maxY = -Infinity;
-
-    for (let i = 0; i < n; i++) {
-      const p = particles[i];
-      if (p.x < minX) minX = p.x;
-      if (p.x > maxX) maxX = p.x;
-      if (p.y < minY) minY = p.y;
-      if (p.y > maxY) maxY = p.y;
-    }
-
-    const size2 = Math.max(maxX - minX, maxY - minY, 1) / 2 + margin;
-    const root2 = createEmptyNode(
-      (minX + maxX) / 2,
-      (minY + maxY) / 2,
-      size2
-    );
-
-    for (let i = 0; i < n; i++) {
-      insertParticle(root2, particles, i);
-    }
-    computeCenterOfMass(root2, particles);
-
-    ax.fill(0);
-    ay.fill(0);
-    const interactions2 = { count: 0 };
-
-    for (let i = 0; i < n; i++) {
-      computeForce(root2, particles, i, G, softening, ax, ay, interactions2);
-    }
-    interactionsComputed += interactions2.count;
-
-    for (let i = 0; i < n; i++) {
-      const p = particles[i];
-      p.vx += 0.5 * dt * ax[i];
-      p.vy += 0.5 * dt * ay[i];
-    }
-  }
-
-  const totalEnergy = computeTotalEnergy(particles, G, softening);
-
-  return {
-    particles,
-    steps_computed: steps,
-    total_energy: totalEnergy,
-    interactions_computed: interactionsComputed,
-  };
-}