@holoscript/core 8.0.7 → 8.0.9

package/dist/chunk-6NTAZN5Z.cjs

@@ -0,0 +1,502 @@
+'use strict';
+
+var chunkX75H75UY_cjs = require('./chunk-X75H75UY.cjs');
+var chunkCANAL6CT_cjs = require('./chunk-CANAL6CT.cjs');
+
+// src/evolution/EvolveProgramBackend.ts
+async function sha256Hex(s) {
+  const bytes = new TextEncoder().encode(s);
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes);
+  return Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function runEvolution(seedCode, policy, io) {
+  const now = io.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const trace = [];
+  let nextId = 0;
+  let evaluated = 0;
+  let discarded = 0;
+  const push = (c) => {
+    trace.push(c);
+    return c;
+  };
+  const finalize = async (result, seedScore, bestScore) => {
+    const traceJSONL = trace.map((c) => JSON.stringify(c)).join("\n");
+    const improvementPct2 = seedScore !== null && bestScore !== null && seedScore > 0 ? Math.round((seedScore - bestScore) / seedScore * 1e3) / 10 : null;
+    return {
+      result,
+      generations: policy.generations,
+      evaluated,
+      survivors: trace.filter((c) => c.passed).length,
+      discarded,
+      seedScore,
+      bestScore,
+      improvementPct: improvementPct2,
+      proposerModel: policy.proposerModel,
+      verifierGated: true,
+      selfShips: false,
+      traceJSONL,
+      verifyUrl: `cael:sha256:${await sha256Hex(traceJSONL)}`,
+      ts: now()
+    };
+  };
+  const seedGate = await io.gate(seedCode);
+  evaluated++;
+  const seed = push({
+    id: nextId++,
+    gen: 0,
+    parentId: null,
+    passed: seedGate.passed,
+    score: seedGate.passed ? seedGate.score : Infinity,
+    bytes: seedCode.length,
+    note: "seed"
+  });
+  if (!seedGate.passed) {
+    discarded++;
+    return { bestCode: null, receipt: await finalize("SEED_INVALID", null, null) };
+  }
+  const archive = [{ cand: seed, code: seedCode }];
+  let best = { cand: seed, code: seedCode };
+  let propIdx = 0;
+  for (let gen = 1; gen <= policy.generations; gen++) {
+    for (let p = 0; p < policy.population; p++) {
+      const parent = archive[propIdx % archive.length];
+      propIdx++;
+      let code;
+      try {
+        code = (await io.propose(parent.code, policy.goal, policy)).trim();
+      } catch (err) {
+        push({
+          id: nextId++,
+          gen,
+          parentId: parent.cand.id,
+          passed: false,
+          score: Infinity,
+          bytes: 0,
+          note: `propose_error:${err.message}`
+        });
+        continue;
+      }
+      if (!code || code === parent.code) {
+        push({
+          id: nextId++,
+          gen,
+          parentId: parent.cand.id,
+          passed: false,
+          score: Infinity,
+          bytes: code.length,
+          note: "empty_or_unchanged"
+        });
+        continue;
+      }
+      const g = await io.gate(code);
+      evaluated++;
+      const cand = push({
+        id: nextId++,
+        gen,
+        parentId: parent.cand.id,
+        passed: g.passed,
+        score: g.passed ? g.score : Infinity,
+        bytes: code.length,
+        note: g.passed ? "gated_pass" : "gated_fail_discarded"
+      });
+      io.onCandidate?.({
+        gen,
+        parentId: parent.cand.id,
+        parentCode: parent.code,
+        goal: policy.goal,
+        candidateCode: code,
+        passed: g.passed,
+        score: g.passed ? g.score : Infinity
+      });
+      if (!g.passed) {
+        discarded++;
+        continue;
+      }
+      archive.push({ cand, code });
+      archive.sort((a, b) => a.cand.score - b.cand.score);
+      if (archive.length > policy.archiveSize) archive.length = policy.archiveSize;
+      if (cand.score < best.cand.score) best = { cand, code };
+    }
+  }
+  const improved = best.cand.id !== seed.id && best.cand.score < seed.score;
+  return {
+    // Propose-not-ship: only surface code that genuinely beat the seed.
+    bestCode: improved ? best.code : null,
+    receipt: await finalize(
+      improved ? "IMPROVED" : "NO_IMPROVEMENT",
+      seed.score,
+      best.cand.score === Infinity ? null : best.cand.score
+    )
+  };
+}
+function makeOllamaProposer(endpoint, model) {
+  const base = endpoint.replace(/\/+$/, "");
+  return async (parentCode, goal) => {
+    const prompt = `You are improving a program toward a goal. GOAL: ${goal}
+
+Return ONLY the full revised program \u2014 no prose, no explanation, no markdown code fences.
+
+--- CURRENT PROGRAM ---
+${parentCode}
+--- END ---`;
+    const res = await fetch(`${base}/api/generate`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ model, prompt, stream: false, options: { temperature: 0.7 } })
+    });
+    if (!res.ok) throw new Error(`ollama ${res.status}`);
+    const body = await res.json();
+    return (body.response ?? "").trim().replace(/^```[a-z]*\n?/i, "").replace(/\n?```$/i, "").trim();
+  };
+}
+function toGradedTraceRow(rec, opts) {
+  return {
+    system: "HoloScript program-evolution proposer: improve the program toward the goal while keeping it valid.",
+    user: `GOAL: ${rec.goal}
+
+Improve this program toward the goal. Return ONLY the full revised program.
+
+--- CURRENT PROGRAM ---
+${rec.parentCode}
+--- END ---`,
+    target: rec.candidateCode,
+    grader: {
+      passed: rec.passed,
+      score: rec.passed ? rec.score : null,
+      kind: "evolve-gated",
+      gen: rec.gen,
+      parentId: rec.parentId
+    },
+    family: "program-evolution",
+    modality: "code",
+    source: opts.source ?? "evolve-loop",
+    agentId: opts.agentId,
+    ts: opts.ts
+  };
+}
+
+// src/evolution/corpusPortfolio.ts
+var CORPUS_PORTFOLIO = [
+  {
+    name: "companion-trait",
+    format: "holo",
+    // @trait {…} parses via the .holo composition parser
+    goal: "Tighten this trait while keeping its name, tags, and the on_attach emit identical.",
+    source: [
+      "@trait greet_companion {",
+      '  mood: String = "friendly"',
+      '  capability_tags: ["greeting", "companion"]',
+      "  @on_attach => {",
+      '    emit("greet_declared", { mood: mood })',
+      "  }",
+      "}"
+    ].join("\n"),
+    preserved: [/greet_companion/, /capability_tags/, /greeting/, /greet_declared/]
+  },
+  {
+    name: "patrol-statemachine",
+    format: "hsplus",
+    // composition + @state_machine parses via the HSPlus parser
+    goal: 'Add a fourth state reachable from "chasing" on "lost", keeping the original states and transitions.',
+    source: [
+      'composition "PatrolBot" {',
+      '  state { entityId: "bot" mood: "alert" }',
+      "  @state_machine {",
+      '    initial: "idle"',
+      "    states: {",
+      '      idle: { seen: -> "chasing" }',
+      '      chasing: { lost: -> "idle" }',
+      "    }",
+      "  }",
+      "}"
+    ].join("\n"),
+    preserved: [/PatrolBot/, /\bidle\b/, /\bchasing\b/]
+  },
+  {
+    name: "mini-scene",
+    format: "holo",
+    goal: "Group the objects under a reusable template, keeping every object name and position.",
+    source: [
+      'composition "MiniScene" {',
+      '  environment { skybox: "gradient" }',
+      '  object "Cube" {',
+      "    position: [0, 1, 0]",
+      "  }",
+      '  object "Light" {',
+      "    position: [2, 4, 2]",
+      "  }",
+      "}"
+    ].join("\n"),
+    preserved: [/MiniScene/, /Cube/, /Light/]
+  },
+  // ── portfolio widening (2026-07-04): the original 3 seeds saturated the
+  // accrual feeder (qwen3:4b converges to one dense candidate per constrained
+  // seed → dedupRows rejects re-proposals → corpus froze at 14 rows). Six more
+  // parse-clean seeds across the SAME surface classes (traits / state machines /
+  // scenes) give the round-robin more distinct targets so novel gated rows keep
+  // accruing. Each source was validated against its native parser via
+  // `parsesClean` before landing. Appended AFTER index 2 so the positional
+  // tests (CORPUS_PORTFOLIO[0]/[1]) stay green. ──
+  {
+    name: "timer-trait",
+    format: "holo",
+    goal: "Tighten this trait while keeping its name, tags, and the on_attach emit identical.",
+    source: [
+      "@trait cooldown_timer {",
+      "  duration: Number = 3",
+      '  capability_tags: ["timer", "cooldown"]',
+      "  @on_attach => {",
+      '    emit("timer_started", { duration: duration })',
+      "  }",
+      "}"
+    ].join("\n"),
+    preserved: [/cooldown_timer/, /capability_tags/, /timer/, /timer_started/]
+  },
+  {
+    name: "health-trait",
+    format: "holo",
+    goal: "Tighten this trait while keeping its name, tags, and the on_attach emit identical.",
+    source: [
+      "@trait health_pool {",
+      "  hp: Number = 100",
+      '  capability_tags: ["health", "damageable"]',
+      "  @on_attach => {",
+      '    emit("health_ready", { hp: hp })',
+      "  }",
+      "}"
+    ].join("\n"),
+    preserved: [/health_pool/, /capability_tags/, /health/, /health_ready/]
+  },
+  {
+    name: "door-statemachine",
+    format: "hsplus",
+    goal: 'Add a fifth state reachable from "open" on "jam", keeping the original states and transitions.',
+    source: [
+      'composition "SmartDoor" {',
+      '  state { entityId: "door" status: "closed" }',
+      "  @state_machine {",
+      '    initial: "closed"',
+      "    states: {",
+      '      closed: { approach: -> "opening" }',
+      '      opening: { done: -> "open" }',
+      '      open: { leave: -> "closed" }',
+      "    }",
+      "  }",
+      "}"
+    ].join("\n"),
+    preserved: [/SmartDoor/, /\bclosed\b/, /\bopening\b/, /\bopen\b/]
+  },
+  {
+    name: "trafficlight-statemachine",
+    format: "hsplus",
+    goal: 'Add a flashing state reachable from "red" on "fault", keeping the original phases and transitions.',
+    source: [
+      'composition "TrafficLight" {',
+      '  state { entityId: "light" phase: "red" }',
+      "  @state_machine {",
+      '    initial: "red"',
+      "    states: {",
+      '      red: { tick: -> "green" }',
+      '      green: { tick: -> "yellow" }',
+      '      yellow: { tick: -> "red" }',
+      "    }",
+      "  }",
+      "}"
+    ].join("\n"),
+    preserved: [/TrafficLight/, /\bred\b/, /\bgreen\b/, /\byellow\b/]
+  },
+  {
+    name: "room-scene",
+    format: "holo",
+    goal: "Group the objects under a reusable template, keeping every object name and position.",
+    source: [
+      'composition "RoomScene" {',
+      '  environment { skybox: "studio" }',
+      '  object "Table" {',
+      "    position: [0, 0, 0]",
+      "  }",
+      '  object "Chair" {',
+      "    position: [1, 0, 0]",
+      "  }",
+      '  object "Lamp" {',
+      "    position: [0, 2, 0]",
+      "  }",
+      "}"
+    ].join("\n"),
+    preserved: [/RoomScene/, /Table/, /Chair/, /Lamp/]
+  },
+  {
+    name: "garden-scene",
+    format: "holo",
+    goal: "Group the objects under a reusable template, keeping every object name and position.",
+    source: [
+      'composition "GardenScene" {',
+      '  environment { skybox: "sky" }',
+      '  object "Tree" {',
+      "    position: [3, 0, 3]",
+      "  }",
+      '  object "Bench" {',
+      "    position: [0, 0, 5]",
+      "  }",
+      "}"
+    ].join("\n"),
+    preserved: [/GardenScene/, /Tree/, /Bench/]
+  }
+];
+function parsesClean(src, format) {
+  try {
+    const r = format === "holo" ? chunkX75H75UY_cjs.parseHolo(src) : chunkCANAL6CT_cjs.parse(src);
+    return Boolean(r.success && r.ast) && (r.errors?.length ?? 0) === 0;
+  } catch {
+    return false;
+  }
+}
+function makeSeedGate(seed) {
+  return async (candidate) => ({
+    passed: parsesClean(candidate, seed.format) && seed.preserved.every((re) => re.test(candidate)),
+    score: candidate.length
+  });
+}
+async function accrueOneStep(opts) {
+  const seed = opts.seed ?? CORPUS_PORTFOLIO[(opts.tick ?? 0) % CORPUS_PORTFOLIO.length];
+  const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const rows = [];
+  await runEvolution(
+    seed.source,
+    { goal: seed.goal, generations: 1, population: 1, archiveSize: 4, proposerModel: "sovereign-local" },
+    {
+      propose: opts.propose,
+      gate: makeSeedGate(seed),
+      onCandidate: (rec) => rows.push(toGradedTraceRow(rec, { agentId: opts.agentId, ts: now(), source: `evolve-corpus:${seed.name}` }))
+    }
+  );
+  return { target: seed.name, rows };
+}
+function dedupRows(existingCorpus, rows) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const line of existingCorpus.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const prior = JSON.parse(line);
+      if (typeof prior.target === "string") seen.add(prior.target);
+    } catch {
+    }
+  }
+  const fresh = [];
+  let deduped = 0;
+  for (const row of rows) {
+    if (seen.has(row.target)) {
+      deduped++;
+      continue;
+    }
+    seen.add(row.target);
+    fresh.push(row);
+  }
+  return { fresh, deduped };
+}
+
+// src/evolution/wasmCompilerFitness.ts
+function numberField(obj, key) {
+  const value = obj[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function roundScore(n) {
+  return Math.round(n * 1e6) / 1e6;
+}
+function improvementPct(baselineScore, score) {
+  if (baselineScore === null || baselineScore <= 0) return null;
+  return Math.round((baselineScore - score) / baselineScore * 1e3) / 10;
+}
+function wasmFitnessBaselineFromScenario(scenarioId, scenario, source = "benchmarks/baseline.json") {
+  const directScore = numberField(scenario, "wasmDensity") ?? numberField(scenario, "fitnessScore");
+  const watLength = numberField(scenario, "watLength");
+  const memoryTotalSize = numberField(scenario, "memoryTotalSize");
+  if (directScore !== null) {
+    return {
+      scenarioId,
+      score: directScore,
+      ...watLength !== null ? { watLength } : {},
+      ...memoryTotalSize !== null ? { memoryTotalSize } : {},
+      source
+    };
+  }
+  if (watLength !== null && memoryTotalSize !== null && memoryTotalSize > 0) {
+    return {
+      scenarioId,
+      score: roundScore(watLength / memoryTotalSize),
+      watLength,
+      memoryTotalSize,
+      source
+    };
+  }
+  return null;
+}
+function scoreWasmCompilerArtifact(artifact, opts = {}) {
+  const watLength = artifact.wat.length;
+  const memoryTotalSize = artifact.memoryLayout.totalSize;
+  const minMemoryTotalSize = opts.minMemoryTotalSize ?? 1;
+  if (watLength <= 0) {
+    return {
+      passed: false,
+      score: Infinity,
+      watLength,
+      memoryTotalSize,
+      baselineScore: opts.baseline?.score ?? null,
+      improvementPct: null,
+      note: "empty_wat"
+    };
+  }
+  if (!Number.isFinite(memoryTotalSize) || memoryTotalSize < minMemoryTotalSize) {
+    return {
+      passed: false,
+      score: Infinity,
+      watLength,
+      memoryTotalSize,
+      baselineScore: opts.baseline?.score ?? null,
+      improvementPct: null,
+      note: "invalid_memory_layout"
+    };
+  }
+  const score = roundScore(watLength / memoryTotalSize);
+  const baselineScore = opts.baseline?.score ?? null;
+  const pct = improvementPct(baselineScore, score);
+  const passesImprovementGate = !opts.requireImprovement || pct !== null && pct > 0;
+  return {
+    passed: passesImprovementGate,
+    score,
+    watLength,
+    memoryTotalSize,
+    baselineScore,
+    improvementPct: pct,
+    note: passesImprovementGate ? "wasm_density_measured" : "no_baseline_improvement"
+  };
+}
+function makeWasmCompilerFitnessGate(compileCandidate, opts = {}) {
+  return async (candidateCode) => {
+    const correctness = opts.correctness ? await opts.correctness(candidateCode) : { passed: true };
+    if (!correctness.passed) {
+      return { passed: false, score: Infinity };
+    }
+    try {
+      const artifact = await compileCandidate(candidateCode);
+      const measured = scoreWasmCompilerArtifact(artifact, opts);
+      return { passed: measured.passed, score: measured.score };
+    } catch {
+      return { passed: false, score: Infinity };
+    }
+  };
+}
+
+exports.CORPUS_PORTFOLIO = CORPUS_PORTFOLIO;
+exports.accrueOneStep = accrueOneStep;
+exports.dedupRows = dedupRows;
+exports.makeOllamaProposer = makeOllamaProposer;
+exports.makeSeedGate = makeSeedGate;
+exports.makeWasmCompilerFitnessGate = makeWasmCompilerFitnessGate;
+exports.parsesClean = parsesClean;
+exports.runEvolution = runEvolution;
+exports.scoreWasmCompilerArtifact = scoreWasmCompilerArtifact;
+exports.toGradedTraceRow = toGradedTraceRow;
+exports.wasmFitnessBaselineFromScenario = wasmFitnessBaselineFromScenario;
+//# sourceMappingURL=chunk-6NTAZN5Z.cjs.map
+//# sourceMappingURL=chunk-6NTAZN5Z.cjs.map