@terminals-tech/sdk 1.0.0-rc.2 → 1.0.0

package/dist/index.js

@@ -5,7 +5,7 @@ import {
   getSkillCount,
   getSkillsByCategory,
   registerSkill
-} from "./chunk-UKVUPKZP.js";
+} from "./chunk-L45BSQDJ.js";
 import {
   createDAG,
   createDelegationChain,
@@ -24,7 +24,7 @@ import {
   wrapTo2Pi,
   wrapToPi
 } from "./chunk-WU4OTGJE.js";
-import "./chunk-3CEM77QZ.js";
+import "./chunk-OCLSAUCD.js";
 import "./chunk-BYXBJQAS.js";
 import {
   SKILL_CATEGORIES,
@@ -938,6 +938,85 @@ __export(brain_exports, {
   wrapToPi: () => wrapToPi
 });
 
+// ../../lib/terminals-tech/core/primitives/coherence-heuristics.ts
+var DEFAULT_HEDGING_PATTERNS = [
+  /\bi think\b/gi,
+  /\bmaybe\b/gi,
+  /\bperhaps\b/gi,
+  /\bpossibly\b/gi,
+  /\buncertain\b/gi,
+  /\bmight\b/gi
+];
+var DEFAULT_CONTRADICTION_PATTERNS = [
+  /\bhowever\b.*\bnot\b/gi,
+  /\bbut\b.*\bnot\b/gi,
+  /\bcontrary\b/gi,
+  /\bcontradicts?\b/gi
+];
+var DEFAULT_STRUCTURE_PATTERN = /[-*\u2022]\s|^\d+\.|#{1,3}\s/m;
+var DEFAULT_ACTION_PATTERN = /\b(do|make|create|implement|use|try|start|begin|ensure|verify)\b/gi;
+var DEFAULT_QUALIFIER_PATTERN = /\b(very|really|extremely|quite|somewhat|fairly)\b/gi;
+function detectHedging(text, patterns = DEFAULT_HEDGING_PATTERNS) {
+  const hedgeCount = patterns.reduce(
+    (count, pattern) => count + (text.match(pattern)?.length ?? 0),
+    0
+  );
+  const wordCount = text.split(/\s+/).length;
+  const hedgeRatio = hedgeCount / Math.max(wordCount / 50, 1);
+  return Math.min(1, hedgeRatio * 0.2);
+}
+function detectContradictions(text, patterns = DEFAULT_CONTRADICTION_PATTERNS) {
+  let score = 0;
+  for (const pattern of patterns) {
+    const matches = text.match(pattern);
+    if (matches) {
+      score += matches.length * 0.1;
+    }
+  }
+  return Math.min(1, score);
+}
+function measureTopicDivergence(current, history) {
+  if (history.length === 0) return 0;
+  const currentTerms = new Set(current.toLowerCase().split(/\s+/));
+  const historyTerms = new Set(
+    history.flatMap((h) => h.toLowerCase().split(/\s+/))
+  );
+  const overlap = [...currentTerms].filter((t) => historyTerms.has(t)).length;
+  const overlapRatio = overlap / currentTerms.size;
+  return overlapRatio < 0.1 ? 0.2 : 0;
+}
+function scoreStructure(text, config) {
+  const structurePattern = config?.structurePattern ?? DEFAULT_STRUCTURE_PATTERN;
+  const actionPattern = config?.actionPattern ?? DEFAULT_ACTION_PATTERN;
+  const qualifierPattern = config?.qualifierPattern ?? DEFAULT_QUALIFIER_PATTERN;
+  const minWords = config?.minWords ?? 10;
+  const maxWords = config?.maxWords ?? 500;
+  let adjustment = 0;
+  const wordCount = text.split(/\s+/).length;
+  if (wordCount < minWords) adjustment -= 0.2;
+  if (wordCount > maxWords) adjustment -= 0.1;
+  if (structurePattern.test(text)) adjustment += 0.1;
+  const actionMatches = text.match(actionPattern);
+  if (actionMatches && actionMatches.length > 2) adjustment += 0.1;
+  const qualifierCount = (text.match(qualifierPattern) ?? []).length;
+  if (qualifierCount > 5) adjustment -= 0.1;
+  return adjustment;
+}
+function computeFactOverlap(text, facts) {
+  if (facts.length === 0) return 0;
+  const textTerms = new Set(
+    text.toLowerCase().split(/\W+/).filter((t) => t.length > 2)
+  );
+  let totalOverlap = 0;
+  for (const fact of facts) {
+    const factTerms = fact.toLowerCase().split(/\W+/).filter((t) => t.length > 2);
+    if (factTerms.length === 0) continue;
+    const matched = factTerms.filter((t) => textTerms.has(t)).length;
+    totalOverlap += matched / factTerms.length;
+  }
+  return totalOverlap / facts.length;
+}
+
 // ../../lib/terminals-tech/brains/core/core.brain.coherence.ts
 var DEFAULT_CONFIG = {
   groundingWeight: 0.4,
@@ -947,75 +1026,20 @@ var DEFAULT_CONFIG = {
 };
 function calculateGrounding(output, groundTruth) {
   if (!groundTruth || groundTruth.length === 0) {
-    const hedgingPatterns = [
-      /\bi think\b/gi,
-      /\bmaybe\b/gi,
-      /\bperhaps\b/gi,
-      /\bpossibly\b/gi,
-      /\buncertain\b/gi,
-      /\bmight\b/gi
-    ];
-    const hedgeCount = hedgingPatterns.reduce(
-      (count, pattern) => count + (output.match(pattern)?.length || 0),
-      0
-    );
-    const wordCount = output.split(/\s+/).length;
-    const hedgeRatio = hedgeCount / Math.max(wordCount / 50, 1);
-    return Math.max(0, 1 - hedgeRatio * 0.2);
+    return Math.max(0, 1 - detectHedging(output));
   }
-  const outputTerms = new Set(
-    output.toLowerCase().split(/\W+/).filter((t) => t.length > 2)
-  );
-  let totalOverlap = 0;
-  for (const fact of groundTruth) {
-    const factTerms = fact.toLowerCase().split(/\W+/).filter((t) => t.length > 2);
-    if (factTerms.length === 0) continue;
-    const matched = factTerms.filter((t) => outputTerms.has(t)).length;
-    totalOverlap += matched / factTerms.length;
-  }
-  return totalOverlap / groundTruth.length;
+  return computeFactOverlap(output, groundTruth);
 }
 function calculateInternal(output, history) {
   const sentences = output.split(/[.!?]+/).filter((s) => s.trim());
   if (sentences.length < 2) return 1;
-  const negations = [
-    /\bhowever\b.*\bnot\b/gi,
-    /\bbut\b.*\bnot\b/gi,
-    /\bcontrary\b/gi,
-    /\bcontradicts?\b/gi
-  ];
-  let contradictionScore = 0;
-  for (const pattern of negations) {
-    const matches = output.match(pattern);
-    if (matches) {
-      contradictionScore += matches.length * 0.1;
-    }
-  }
-  if (history && history.length > 0) {
-    const currentTerms = new Set(output.toLowerCase().split(/\s+/));
-    const historyTerms = new Set(history.flatMap((h) => h.toLowerCase().split(/\s+/)));
-    const overlap = [...currentTerms].filter((t) => historyTerms.has(t)).length;
-    const overlapRatio = overlap / currentTerms.size;
-    if (overlapRatio < 0.1) {
-      contradictionScore += 0.2;
-    }
-  }
-  return Math.max(0, 1 - contradictionScore);
+  const contradictionPenalty = detectContradictions(output);
+  const divergencePenalty = history && history.length > 0 ? measureTopicDivergence(output, history) : 0;
+  return Math.max(0, 1 - contradictionPenalty - divergencePenalty);
 }
 function calculateCrystallization(output) {
-  let score = 1;
-  const wordCount = output.split(/\s+/).length;
-  if (wordCount < 10) score -= 0.2;
-  if (wordCount > 500) score -= 0.1;
-  const hasStructure = /[-*•]\s|^\d+\.|#{1,3}\s/m.test(output);
-  if (hasStructure) score += 0.1;
-  const actionWords = /\b(do|make|create|implement|use|try|start|begin|ensure|verify)\b/gi;
-  const actionMatches = output.match(actionWords);
-  if (actionMatches && actionMatches.length > 2) score += 0.1;
-  const qualifiers = /\b(very|really|extremely|quite|somewhat|fairly)\b/gi;
-  const qualifierCount = (output.match(qualifiers) || []).length;
-  if (qualifierCount > 5) score -= 0.1;
-  return Math.max(0, Math.min(1, score));
+  const adjustment = scoreStructure(output);
+  return Math.max(0, Math.min(1, 1 + adjustment));
 }
 function calculateCoherence(input, config = {}) {
   const cfg = { ...DEFAULT_CONFIG, ...config };
@@ -1269,6 +1293,2061 @@ var SIGNAL_CODE_TO_EVENT = {
   [SKILL_SIGNAL_CODES.SKILL_ERROR]: "skill:error"
 };
 
+// ../../lib/terminals-tech/sdk/manifold.ts
+var manifold_exports = {};
+__export(manifold_exports, {
+  annihilate: () => annihilate,
+  manifold: () => manifold
+});
+
+// ../../lib/terminals-tech/core/L0/dmt-55dim-combinatorial.ts
+var DMT55CombinatorialEngine = class {
+  constructor() {
+  }
+  /**
+   * Treat the observer configuration mapping:
+   * 1 sat = 18 ordinal dimensions = 37 DMT
+   */
+  getObserverConfiguration(sats) {
+    const ordinalDimensions = sats * 18;
+    const dmtDimensions = sats * 37;
+    return {
+      sats,
+      ordinalDimensions,
+      dmtDimensions,
+      totalDimensions: ordinalDimensions + dmtDimensions
+      // 55 per sat
+    };
+  }
+  /**
+   * Continuous generation of evidence via MicroLM architecture
+   */
+  generateMicroLMEvidence(sats) {
+    const config = this.getObserverConfiguration(sats);
+    const manifoldState = Array.from(
+      { length: config.totalDimensions },
+      () => Math.random() * 2 - 1
+    );
+    const evidence = {
+      evidenceId: `microlm-ev-${Date.now()}-${Math.floor(Math.random() * 1e3)}`,
+      confidence: 0.85 + Math.random() * 0.14,
+      manifoldState,
+      timestamp: Date.now()
+    };
+    emitSignal("mesh_update", "L1", "L3", {
+      node: "DMT55Engine",
+      evidence,
+      config
+    });
+    return evidence;
+  }
+};
+var dmt55Engine = new DMT55CombinatorialEngine();
+
+// ../../lib/terminals-tech/brains/state-mirror.ts
+import { BehaviorSubject } from "rxjs";
+var DEFAULT_STATE = {
+  activeUrl: "/",
+  focusedComponent: null,
+  recentIntents: [],
+  audioEntropy: 0.5,
+  nanoFoldActive: false,
+  coherenceR: 0,
+  activeProject: null
+};
+var StateMirror = class {
+  state$ = new BehaviorSubject(DEFAULT_STATE);
+  bridgeOwnerId = null;
+  bridgeOrder = [];
+  constructor() {
+    this.initSubscriptions();
+  }
+  initSubscriptions() {
+    if (typeof window === "undefined") return;
+    const bus = getSignalBus();
+    bus.subscribe("audio_metrics_update", (signal) => {
+      const payload = signal.payload;
+      if (payload && typeof payload.entropy === "number") {
+        this.update({ audioEntropy: payload.entropy });
+      }
+    });
+    bus.subscribe("ui_surface_opened", (signal) => {
+      const payload = signal.payload;
+      if (payload && payload.surface) {
+        this.update({ focusedComponent: payload.surface });
+      }
+    });
+    bus.subscribe("intent_signal_emitted", (signal) => {
+      const payload = signal.payload;
+      if (payload && payload.intent) {
+        const current = this.state$.value.recentIntents;
+        this.update({ recentIntents: [payload.intent, ...current].slice(0, 5) });
+      }
+    });
+  }
+  /** Gets the observable stream of state changes */
+  get stream$() {
+    return this.state$.asObservable();
+  }
+  /** Gets a synchronous snapshot of the current state */
+  get snapshot() {
+    return this.state$.value;
+  }
+  claimBridge(bridgeId) {
+    this.bridgeOrder = [...this.bridgeOrder.filter((id) => id !== bridgeId), bridgeId];
+    this.bridgeOwnerId = bridgeId;
+  }
+  releaseBridge(bridgeId) {
+    this.bridgeOrder = this.bridgeOrder.filter((id) => id !== bridgeId);
+    if (this.bridgeOwnerId === bridgeId) {
+      this.bridgeOwnerId = this.bridgeOrder[this.bridgeOrder.length - 1] ?? null;
+    }
+  }
+  /** Partially updates the mirror state */
+  update(partial) {
+    const next = { ...this.state$.value, ...partial };
+    this.state$.next(next);
+  }
+  /**
+   * Bridge-scoped update to prevent multiple mounted app shells from racing
+   * against the same singleton mirror.
+   */
+  updateFromBridge(bridgeId, partial) {
+    if (!this.bridgeOrder.includes(bridgeId)) {
+      this.claimBridge(bridgeId);
+    }
+    if (this.bridgeOwnerId && this.bridgeOwnerId !== bridgeId) {
+      return;
+    }
+    this.bridgeOwnerId = bridgeId;
+    this.update(partial);
+  }
+  /**
+   * Flattens the continuous state into a dense text manifold.
+   * This is passed to the ObserverKernel to ground it in the immediate UI/UX reality.
+   */
+  encodeToManifold() {
+    const s = this.snapshot;
+    return `
+[StateMirror: Active]
+Location: ${s.activeUrl}
+Focus: ${s.focusedComponent || "ambient"}
+Workspace: ${s.activeProject || "global"}
+Acoustic Entropy: ${s.audioEntropy.toFixed(3)}
+Resonance R: ${s.coherenceR.toFixed(3)}
+NanoFold Topology: ${s.nanoFoldActive ? "Rendering" : "Collapsed"}
+Recent Intents: ${s.recentIntents.length > 0 ? s.recentIntents.join(" -> ") : "None"}
+    `.trim();
+  }
+};
+var globalStateMirror = new StateMirror();
+
+// ../../lib/terminals-tech/brains/observable-evidence.ts
+function metricToneFromValue(value, invert = false) {
+  const normalized = invert ? 1 - value : value;
+  if (normalized >= 0.85) return "mint";
+  if (normalized >= 0.6) return "cyan";
+  if (normalized >= 0.35) return "violet";
+  return "amber";
+}
+function toneColor(tone) {
+  switch (tone) {
+    case "mint":
+      return "#6EE7B7";
+    case "cyan":
+      return "#67E8F9";
+    case "violet":
+      return "#A78BFA";
+    case "amber":
+      return "#FBBF24";
+    default:
+      return "#67E8F9";
+  }
+}
+function buildStatus(constructive, witness) {
+  if (constructive) return "constructive";
+  if (witness.converged || witness.R >= 0.75) return "stable";
+  if (witness.R >= 0.35) return "searching";
+  return "ambient";
+}
+function buildThoughtspace(witness, constructive, strategyLabel, entropyLabel) {
+  const stabilityTone = metricToneFromValue(witness.R);
+  const entropyTone = metricToneFromValue(witness.activationEntropy, true);
+  const routeTone = constructive ? "violet" : "amber";
+  return [
+    {
+      id: "stability",
+      shape: "circle",
+      label: "Core",
+      detail: `This dot is the center of the thought. Bigger + brighter means the pattern is holding together (R=${witness.R.toFixed(2)}).`,
+      color: toneColor(stabilityTone),
+      x: 52,
+      y: 44,
+      size: 12 + witness.R * 10,
+      opacity: 0.65 + witness.R * 0.3
+    },
+    {
+      id: "entropy",
+      shape: "diamond",
+      label: "Search",
+      detail: `This shape shows how noisy the signal is. ${entropyLabel}`,
+      color: toneColor(entropyTone),
+      x: 22 + witness.activationEntropy * 18,
+      y: 78 - witness.activationEntropy * 18,
+      size: 8 + witness.activationEntropy * 9,
+      opacity: 0.45 + witness.activationEntropy * 0.4
+    },
+    {
+      id: "route",
+      shape: "triangle",
+      label: "Route",
+      detail: `This pointer shows which engine is carrying the thought right now: ${strategyLabel}.`,
+      color: toneColor(routeTone),
+      x: 82,
+      y: constructive ? 30 : 62,
+      size: 10 + (constructive ? 4 : 0),
+      opacity: constructive ? 0.9 : 0.6
+    }
+  ];
+}
+function parseFoldedPayload(payload) {
+  if (typeof payload !== "string") return payload;
+  try {
+    return JSON.parse(payload);
+  } catch {
+    return payload;
+  }
+}
+function toReduction(payload) {
+  if (!payload || typeof payload !== "object") return {};
+  const reduction = payload.reduction;
+  if (!reduction || typeof reduction !== "object") return {};
+  return reduction;
+}
+function toContextHint(payload) {
+  if (!payload || typeof payload !== "object") return void 0;
+  const candidate = payload.contextSnapshot;
+  return typeof candidate === "string" && candidate.length > 0 ? candidate : void 0;
+}
+function buildObservableEvidenceFromSematon(sematon, title) {
+  const payload = parseFoldedPayload(sematon.payload);
+  const reduction = toReduction(payload);
+  const status = buildStatus(sematon.constructive, sematon.witness);
+  const strategyLabel = reduction.strategy ?? reduction.runtime ?? sematon.source;
+  const entropyLabel = sematon.witness.activationEntropy >= 0.7 ? "Higher means the system is still exploring a lot of possibilities." : "Lower means the system has narrowed into a smaller, steadier shape.";
+  return {
+    id: sematon.id,
+    source: sematon.source,
+    title: title ?? (sematon.source.includes("ohm") || sematon.source.includes("Ohm") ? "Ohm Thoughtspace" : "Observable Evidence"),
+    summary: sematon.constructive ? "The pattern held together and can be built on again." : sematon.witness.converged ? "The pattern is stable, but it is not yet a reusable construction." : "The system is still searching for a stable shape.",
+    status,
+    constructive: sematon.constructive,
+    witness: sematon.witness,
+    strategy: reduction.strategy,
+    runtime: reduction.runtime,
+    durationMs: reduction.durationMs,
+    metrics: [
+      {
+        id: "stability",
+        label: "Stability",
+        value: sematon.witness.R.toFixed(2),
+        detail: "How locked-in the thought is. Closer to 1 means the pattern is holding together instead of wobbling.",
+        tone: metricToneFromValue(sematon.witness.R)
+      },
+      {
+        id: "signal",
+        label: "Signal",
+        value: sematon.witness.activationEntropy.toFixed(2),
+        detail: "How noisy the search still is. Higher means more exploring, lower means more focus.",
+        tone: metricToneFromValue(sematon.witness.activationEntropy, true)
+      },
+      {
+        id: "route",
+        label: "Route",
+        value: strategyLabel,
+        detail: "Which engine is carrying the construction right now. This tells you where the work actually happened.",
+        tone: sematon.constructive ? "violet" : "amber"
+      },
+      {
+        id: "buildable",
+        label: "Buildable",
+        value: sematon.constructive ? "yes" : "not yet",
+        detail: "If this says yes, the result can be reused and extended instead of collapsing when you touch it.",
+        tone: sematon.constructive ? "mint" : "amber"
+      }
+    ],
+    thoughtspace: buildThoughtspace(
+      sematon.witness,
+      sematon.constructive,
+      strategyLabel,
+      entropyLabel
+    ),
+    contextHint: toContextHint(payload),
+    observedAt: sematon.createdAt ?? Date.now()
+  };
+}
+
+// ../../lib/py2bend/parser.ts
+function tokenizeLines(source) {
+  return source.split("\n").map((raw, i) => {
+    const text = raw;
+    const trimmed = raw.trimStart();
+    const indent2 = raw.length - trimmed.length;
+    return { text: trimmed, indent: indent2, lineNo: i + 1 };
+  }).filter((l) => l.text.length > 0 && !l.text.startsWith("#"));
+}
+var Cursor = class {
+  constructor(lines, pos = 0) {
+    this.lines = lines;
+    this.pos = pos;
+  }
+  done() {
+    return this.pos >= this.lines.length;
+  }
+  peek() {
+    return this.done() ? null : this.lines[this.pos];
+  }
+  advance() {
+    return this.lines[this.pos++];
+  }
+  /** Collect the body block: all lines with indent > parentIndent */
+  collectBlock(parentIndent) {
+    const block = [];
+    while (!this.done()) {
+      const next = this.peek();
+      if (next.indent <= parentIndent) break;
+      block.push(this.advance());
+    }
+    return block;
+  }
+};
+var UNSUPPORTED_KEYWORDS = [
+  /^async\s+def\b/,
+  /^await\b/,
+  /^yield\b/,
+  /^import\b/,
+  /^from\s+\S+\s+import\b/,
+  /^with\b/,
+  /^assert\b/,
+  /^raise\b/,
+  /^del\b/,
+  /^global\b/,
+  /^nonlocal\b/
+];
+function parsePython(source) {
+  const errors = [];
+  const lines = tokenizeLines(source);
+  validateIndentation(lines, errors);
+  if (errors.some((error) => error.severity === "error")) {
+    return { ast: null, errors };
+  }
+  try {
+    const cursor = new Cursor(lines);
+    const body = parseBlock(cursor, -1, errors);
+    return { ast: { type: "Module", body }, errors };
+  } catch (e) {
+    errors.push({
+      message: e.message,
+      severity: "error"
+    });
+    return { ast: null, errors };
+  }
+}
+function parseBlock(cursor, parentIndent, errors) {
+  const stmts = [];
+  while (!cursor.done()) {
+    const line = cursor.peek();
+    if (line.indent <= parentIndent) break;
+    cursor.advance();
+    const stmt = parseStatement(line, cursor, errors);
+    if (stmt) stmts.push(stmt);
+  }
+  return stmts;
+}
+function parseStatement(line, cursor, errors) {
+  const text = line.text;
+  for (const pattern of UNSUPPORTED_KEYWORDS) {
+    if (pattern.test(text)) {
+      errors.push({
+        message: `Unsupported syntax: ${text}`,
+        line: line.lineNo,
+        severity: "error"
+      });
+      cursor.collectBlock(line.indent);
+      return null;
+    }
+  }
+  if (text.startsWith("@")) {
+    const decorators = [text.slice(1).trim()];
+    while (!cursor.done() && cursor.peek().text.startsWith("@")) {
+      decorators.push(cursor.advance().text.slice(1).trim());
+    }
+    if (!cursor.done()) {
+      const defLine = cursor.advance();
+      const stmt = parseStatement(defLine, cursor, errors);
+      if (stmt && stmt.type === "FunctionDef") {
+        stmt.decorators = decorators;
+      }
+      return stmt;
+    }
+    return null;
+  }
+  if (text.startsWith("def ")) {
+    return parseFunctionDef(text, line, cursor, errors);
+  }
+  if (text.startsWith("class ")) {
+    return parseClassDef(text, line, cursor, errors);
+  }
+  if (text.startsWith("if ")) {
+    return parseIf(text, line, cursor, errors);
+  }
+  if (text.startsWith("for ")) {
+    return parseFor(text, line, cursor, errors);
+  }
+  if (text.startsWith("while ")) {
+    return parseWhile(text, line, cursor, errors);
+  }
+  if (text.startsWith("try:")) {
+    return parseTry(line, cursor, errors);
+  }
+  if (text === "return" || text.startsWith("return ")) {
+    return parseReturn(text, line, errors);
+  }
+  if (text === "pass") {
+    return null;
+  }
+  if (text.startsWith("elif ") || text === "else:" || text.startsWith("except")) {
+    cursor.collectBlock(line.indent);
+    return null;
+  }
+  const augMatch = text.match(
+    /^([A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*)\s*(\+\=|\-\=|\*\=|\/\=|\/\/\=|%\=|\*\*\=|&\=|\|\=)\s*(.+)$/
+  );
+  if (augMatch) {
+    return {
+      type: "AugAssign",
+      target: augMatch[1],
+      op: augMatch[2],
+      value: parseExpr(augMatch[3].trim(), line.lineNo, errors)
+    };
+  }
+  const assignMatch = text.match(
+    /^([A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*(?:\[[^\]]+\])?)\s*=\s*(.+)$/
+  );
+  if (assignMatch) {
+    const afterTarget = text.slice(assignMatch[1].length).trimStart();
+    if (afterTarget.startsWith("==")) {
+    } else {
+      return {
+        type: "Assign",
+        target: assignMatch[1],
+        value: parseExpr(assignMatch[2].trim(), line.lineNo, errors)
+      };
+    }
+  }
+  const expr = parseExpr(text, line.lineNo, errors);
+  return {
+    type: "Expr",
+    value: expr
+  };
+}
+function parseFunctionDef(text, line, cursor, errors) {
+  const nameMatch = text.match(/^def\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(/);
+  const openParenIdx = text.indexOf("(");
+  const closeParenIdx = openParenIdx >= 0 ? findMatchingClose(text, openParenIdx, "(", ")") : -1;
+  if (!nameMatch || openParenIdx < 0 || closeParenIdx < 0) {
+    errors.push({
+      message: `Invalid function definition: ${text}`,
+      line: line.lineNo,
+      severity: "error"
+    });
+    cursor.collectBlock(line.indent);
+    return {
+      type: "FunctionDef",
+      name: "unknown",
+      params: [],
+      body: [],
+      decorators: []
+    };
+  }
+  const trailing = text.slice(closeParenIdx + 1).trim();
+  if (!trailing.startsWith(":")) {
+    errors.push({
+      message: `Invalid function definition: ${text}`,
+      line: line.lineNo,
+      severity: "error"
+    });
+    cursor.collectBlock(line.indent);
+    return {
+      type: "FunctionDef",
+      name: nameMatch[1],
+      params: [],
+      body: [],
+      decorators: []
+    };
+  }
+  const name = nameMatch[1];
+  const paramsStr = text.slice(openParenIdx + 1, closeParenIdx).trim();
+  const params = paramsStr ? splitArgs(paramsStr).map((param) => extractParameterName(param)).filter((param) => Boolean(param)) : [];
+  const bodyLines = cursor.collectBlock(line.indent);
+  const bodyCursor = new Cursor(bodyLines);
+  const body = parseBlock(bodyCursor, line.indent, errors);
+  return {
+    type: "FunctionDef",
+    name,
+    params,
+    body,
+    decorators: []
+  };
+}
+function parseClassDef(text, line, cursor, errors) {
+  const match = text.match(/^class\s+([A-Za-z_][A-Za-z0-9_]*)(?:\(([^)]*)\))?\s*:/);
+  if (!match) {
+    errors.push({
+      message: `Invalid class definition: ${text}`,
+      line: line.lineNo,
+      severity: "error"
+    });
+    cursor.collectBlock(line.indent);
+    return { type: "ClassDef", name: "unknown", bases: [], body: [] };
+  }
+  const name = match[1];
+  const basesStr = match[2]?.trim() ?? "";
+  const bases = basesStr ? basesStr.split(",").map((b) => b.trim()) : [];
+  const bodyLines = cursor.collectBlock(line.indent);
+  const bodyCursor = new Cursor(bodyLines);
+  const body = parseBlock(bodyCursor, line.indent, errors);
+  return { type: "ClassDef", name, bases, body };
+}
+function parseIf(text, line, cursor, errors) {
+  const condStr = text.replace(/^if\s+/, "").replace(/\s*:\s*$/, "");
+  const test = parseExpr(condStr, line.lineNo, errors);
+  const bodyLines = cursor.collectBlock(line.indent);
+  const bodyCursor = new Cursor(bodyLines);
+  const body = parseBlock(bodyCursor, line.indent, errors);
+  let orelse = [];
+  if (!cursor.done()) {
+    const next = cursor.peek();
+    if (next.indent === line.indent && next.text.startsWith("elif ")) {
+      cursor.advance();
+      const elifText = next.text.replace(/^elif\s+/, "if ");
+      const elifIf = parseIf(elifText, next, cursor, errors);
+      orelse = [elifIf];
+    } else if (next.indent === line.indent && next.text === "else:") {
+      cursor.advance();
+      const elseLines = cursor.collectBlock(line.indent);
+      const elseCursor = new Cursor(elseLines);
+      orelse = parseBlock(elseCursor, line.indent, errors);
+    }
+  }
+  return { type: "If", test, body, orelse };
+}
+function parseFor(text, line, cursor, errors) {
+  const match = text.match(/^for\s+([A-Za-z_][A-Za-z0-9_]*)\s+in\s+(.+)\s*:\s*$/);
+  if (!match) {
+    errors.push({
+      message: `Invalid for loop: ${text}`,
+      line: line.lineNo,
+      severity: "error"
+    });
+    cursor.collectBlock(line.indent);
+    return {
+      type: "For",
+      target: "unknown",
+      iter: { type: "Name", id: "unknown" },
+      body: []
+    };
+  }
+  const target = match[1];
+  const iterExpr = parseExpr(match[2].trim(), line.lineNo, errors);
+  const bodyLines = cursor.collectBlock(line.indent);
+  const bodyCursor = new Cursor(bodyLines);
+  const body = parseBlock(bodyCursor, line.indent, errors);
+  return { type: "For", target, iter: iterExpr, body };
+}
+function parseWhile(text, line, cursor, errors) {
+  const condStr = text.replace(/^while\s+/, "").replace(/\s*:\s*$/, "");
+  const test = parseExpr(condStr, line.lineNo, errors);
+  const bodyLines = cursor.collectBlock(line.indent);
+  const bodyCursor = new Cursor(bodyLines);
+  const body = parseBlock(bodyCursor, line.indent, errors);
+  return { type: "While", test, body };
+}
+function parseTry(line, cursor, errors) {
+  const tryBodyLines = cursor.collectBlock(line.indent);
+  const tryCursor = new Cursor(tryBodyLines);
+  const tryBody = parseBlock(tryCursor, line.indent, errors);
+  let handler = null;
+  if (!cursor.done()) {
+    const next = cursor.peek();
+    if (next.indent === line.indent && next.text.startsWith("except")) {
+      cursor.advance();
+      const exceptMatch = next.text.match(
+        /^except\s*(?:([A-Za-z_][A-Za-z0-9_]*))?(?:\s+as\s+([A-Za-z_][A-Za-z0-9_]*))?\s*:\s*$/
+      );
+      const handlerType = exceptMatch?.[1] ?? null;
+      const handlerName = exceptMatch?.[2] ?? null;
+      const handlerBodyLines = cursor.collectBlock(line.indent);
+      const handlerCursor = new Cursor(handlerBodyLines);
+      const handlerBody = parseBlock(handlerCursor, line.indent, errors);
+      handler = { type: handlerType, name: handlerName, body: handlerBody };
+    }
+  }
+  return { type: "Try", body: tryBody, handler };
+}
+function parseReturn(text, line, errors) {
+  const valueStr = text.replace(/^return\s*/, "").trim();
+  if (!valueStr) {
+    return { type: "Return", value: null };
+  }
+  return { type: "Return", value: parseExpr(valueStr, line.lineNo, errors) };
+}
+function parseExpr(text, lineNo, errors) {
+  text = text.trim();
+  if (!text) {
+    return { type: "Constant", value: null, kind: "none" };
+  }
+  if (text.startsWith("lambda")) {
+    return parseLambda(text, lineNo, errors);
+  }
+  return parseBoolOr(text, lineNo, errors);
+}
+function parseLambda(text, lineNo, errors) {
+  const match = text.match(/^lambda\s*([^:]*)\s*:\s*(.+)$/);
+  if (!match) {
+    return {
+      type: "Lambda",
+      params: [],
+      body: { type: "Constant", value: null, kind: "none" }
+    };
+  }
+  const paramsStr = match[1].trim();
+  const params = paramsStr ? paramsStr.split(",").map((p) => p.trim()) : [];
+  const body = parseExpr(match[2].trim(), lineNo, errors);
+  return { type: "Lambda", params, body };
+}
+function parseBoolOr(text, lineNo, errors) {
+  const parts = splitTopLevel(text, " or ");
+  if (parts.length === 1) return parseBoolAnd(parts[0], lineNo, errors);
+  const values = parts.map((p) => parseBoolAnd(p, lineNo, errors));
+  return { type: "BoolOp", op: "or", values };
+}
+function parseBoolAnd(text, lineNo, errors) {
+  const parts = splitTopLevel(text, " and ");
+  if (parts.length === 1) return parseNot(parts[0], lineNo, errors);
+  const values = parts.map((p) => parseNot(p, lineNo, errors));
+  return { type: "BoolOp", op: "and", values };
+}
+function parseNot(text, lineNo, errors) {
+  text = text.trim();
+  if (text.startsWith("not ")) {
+    const operand = parseNot(text.slice(4).trim(), lineNo, errors);
+    return { type: "UnaryOp", op: "not", operand };
+  }
+  return parseComparison(text, lineNo, errors);
+}
+var COMPARISON_OPS = [" not in ", " in ", "<=", ">=", "!=", "==", "<", ">"];
+function parseComparison(text, lineNo, errors) {
+  let bestIdx = -1;
+  let bestOp = "";
+  for (const op of COMPARISON_OPS) {
+    const idx = findTopLevel(text, op);
+    if (idx !== -1 && (bestIdx === -1 || idx < bestIdx)) {
+      bestIdx = idx;
+      bestOp = op;
+    }
+  }
+  if (bestIdx === -1) {
+    return parseAddSub(text, lineNo, errors);
+  }
+  const left2 = parseAddSub(text.slice(0, bestIdx).trim(), lineNo, errors);
+  const right2 = parseComparison(text.slice(bestIdx + bestOp.length).trim(), lineNo, errors);
+  if (right2.type === "Compare") {
+    const rightCmp = right2;
+    return {
+      type: "Compare",
+      left: left2,
+      ops: [bestOp.trim(), ...rightCmp.ops],
+      comparators: [rightCmp.left, ...rightCmp.comparators]
+    };
+  }
+  return {
+    type: "Compare",
+    left: left2,
+    ops: [bestOp.trim()],
+    comparators: [right2]
+  };
+}
+function parseAddSub(text, lineNo, errors) {
+  let parenDepth = 0;
+  let bracketDepth = 0;
+  let braceDepth = 0;
+  let inStr = null;
+  let splitIdx = -1;
+  let splitOp = "";
+  for (let i = text.length - 1; i >= 1; i--) {
+    const ch = text[i];
+    if ((ch === '"' || ch === "'") && text[i - 1] !== "\\") {
+      if (inStr === ch) {
+        inStr = null;
+        continue;
+      } else if (!inStr) {
+        inStr = ch;
+        continue;
+      }
+    }
+    if (inStr) continue;
+    if (ch === ")") parenDepth++;
+    else if (ch === "(") parenDepth--;
+    else if (ch === "]") bracketDepth++;
+    else if (ch === "[") bracketDepth--;
+    else if (ch === "}") braceDepth++;
+    else if (ch === "{") braceDepth--;
+    if (parenDepth === 0 && bracketDepth === 0 && braceDepth === 0) {
+      if ((ch === "+" || ch === "-") && text[i - 1] !== "*" && text[i + 1] !== "=" && text[i - 1] !== "=") {
+        const before = text.slice(0, i).trim();
+        if (before.length > 0 && !before.endsWith("(") && !before.endsWith(",") && !before.endsWith("[")) {
+          splitIdx = i;
+          splitOp = ch;
+          break;
+        }
+      }
+    }
+  }
+  if (splitIdx === -1) {
+    return parseMulDiv(text, lineNo, errors);
+  }
+  const left2 = parseAddSub(text.slice(0, splitIdx).trim(), lineNo, errors);
+  const right2 = parseMulDiv(text.slice(splitIdx + 1).trim(), lineNo, errors);
+  return { type: "BinOp", left: left2, op: splitOp, right: right2 };
+}
+function parseMulDiv(text, lineNo, errors) {
+  let parenDepth = 0;
+  let bracketDepth = 0;
+  let braceDepth = 0;
+  let inStr = null;
+  let splitIdx = -1;
+  let splitOp = "";
+  for (let i = text.length - 1; i >= 0; i--) {
+    const ch = text[i];
+    if ((ch === '"' || ch === "'") && (i === 0 || text[i - 1] !== "\\")) {
+      if (inStr === ch) {
+        inStr = null;
+        continue;
+      } else if (!inStr) {
+        inStr = ch;
+        continue;
+      }
+    }
+    if (inStr) continue;
+    if (ch === ")") parenDepth++;
+    else if (ch === "(") parenDepth--;
+    else if (ch === "]") bracketDepth++;
+    else if (ch === "[") bracketDepth--;
+    else if (ch === "}") braceDepth++;
+    else if (ch === "{") braceDepth--;
+    if (parenDepth === 0 && bracketDepth === 0 && braceDepth === 0) {
+      if (ch === "*" && i > 0 && text[i - 1] !== "*" && (i + 1 >= text.length || text[i + 1] !== "*")) {
+        splitIdx = i;
+        splitOp = "*";
+        break;
+      }
+      if (ch === "/" && i > 0) {
+        if (text[i - 1] === "/") {
+          splitIdx = i - 1;
+          splitOp = "//";
+          break;
+        }
+        splitIdx = i;
+        splitOp = "/";
+        break;
+      }
+      if (ch === "%") {
+        splitIdx = i;
+        splitOp = "%";
+        break;
+      }
+    }
+  }
+  if (splitIdx === -1) {
+    return parsePower(text, lineNo, errors);
+  }
+  const left2 = parseMulDiv(text.slice(0, splitIdx).trim(), lineNo, errors);
+  const right2 = parsePower(text.slice(splitIdx + splitOp.length).trim(), lineNo, errors);
+  return { type: "BinOp", left: left2, op: splitOp, right: right2 };
+}
+function parsePower(text, lineNo, errors) {
+  const idx = findTopLevel(text, "**");
+  if (idx === -1) {
+    return parseUnary(text, lineNo, errors);
+  }
+  const left2 = parseUnary(text.slice(0, idx).trim(), lineNo, errors);
+  const right2 = parsePower(text.slice(idx + 2).trim(), lineNo, errors);
+  return { type: "BinOp", left: left2, op: "**", right: right2 };
+}
+function parseUnary(text, lineNo, errors) {
+  text = text.trim();
+  if (text.startsWith("-") && text.length > 1) {
+    const rest = text.slice(1).trim();
+    if (rest && !/^\d/.test(rest)) {
+      const operand = parseUnary(rest, lineNo, errors);
+      return { type: "UnaryOp", op: "-", operand };
+    }
+  }
+  if (text.startsWith("+") && text.length > 1) {
+    const rest = text.slice(1).trim();
+    if (rest && !/^\d/.test(rest)) {
+      const operand = parseUnary(rest, lineNo, errors);
+      return { type: "UnaryOp", op: "+", operand };
+    }
+  }
+  return parsePostfix(text, lineNo, errors);
+}
+function parsePostfix(text, lineNo, errors) {
+  text = text.trim();
+  let node = parsePrimary(text, lineNo, errors);
+  const parsed = parsePrimaryWithPostfix(text, lineNo, errors);
+  return parsed;
+}
+function parsePrimaryWithPostfix(text, lineNo, errors) {
+  text = text.trim();
+  let pos = 0;
+  const { node, endPos } = parsePrimaryAt(text, pos, lineNo, errors);
+  pos = endPos;
+  let current = node;
+  while (pos < text.length) {
+    const ch = text[pos];
+    if (ch === ".") {
+      pos++;
+      const attrMatch = text.slice(pos).match(/^[A-Za-z_][A-Za-z0-9_]*/);
+      if (attrMatch) {
+        const attr = attrMatch[0];
+        pos += attr.length;
+        current = { type: "Attribute", value: current, attr };
+      } else {
+        break;
+      }
+    } else if (ch === "[") {
+      const closeIdx = findMatchingClose(text, pos, "[", "]");
+      if (closeIdx === -1) break;
+      const sliceStr = text.slice(pos + 1, closeIdx).trim();
+      const sliceNode = parseExpr(sliceStr, lineNo, errors);
+      current = { type: "Subscript", value: current, slice: sliceNode };
+      pos = closeIdx + 1;
+    } else if (ch === "(") {
+      const closeIdx = findMatchingClose(text, pos, "(", ")");
+      if (closeIdx === -1) break;
+      const argsStr = text.slice(pos + 1, closeIdx).trim();
+      const { args, kwargs } = parseCallArgs(argsStr, lineNo, errors);
+      current = { type: "Call", func: current, args, kwargs };
+      pos = closeIdx + 1;
+    } else if (ch === " " || ch === "	") {
+      pos++;
+    } else {
+      break;
+    }
+  }
+  return current;
+}
+function parsePrimaryAt(text, pos, lineNo, errors) {
+  while (pos < text.length && (text[pos] === " " || text[pos] === "	")) pos++;
+  if (pos >= text.length) {
+    return {
+      node: { type: "Constant", value: null, kind: "none" },
+      endPos: pos
+    };
+  }
+  const remaining = text.slice(pos);
+  if (remaining[0] === "(") {
+    const closeIdx = findMatchingClose(text, pos, "(", ")");
+    if (closeIdx !== -1) {
+      const inner = text.slice(pos + 1, closeIdx).trim();
+      const node = parseExpr(inner, lineNo, errors);
+      return { node, endPos: closeIdx + 1 };
+    }
+  }
+  if (remaining[0] === "[") {
+    const closeIdx = findMatchingClose(text, pos, "[", "]");
+    if (closeIdx !== -1) {
+      const inner = text.slice(pos + 1, closeIdx).trim();
+      const elts = inner ? splitArgs(inner).map((e) => parseExpr(e.trim(), lineNo, errors)) : [];
+      return {
+        node: { type: "List", elts },
+        endPos: closeIdx + 1
+      };
+    }
+  }
+  if (remaining[0] === "{") {
+    const closeIdx = findMatchingClose(text, pos, "{", "}");
+    if (closeIdx !== -1) {
+      const inner = text.slice(pos + 1, closeIdx).trim();
+      const keys = [];
+      const values = [];
+      if (inner) {
+        const entries = splitArgs(inner);
+        for (const entry of entries) {
+          const colonIdx = findTopLevel(entry, ":");
+          if (colonIdx !== -1) {
+            keys.push(parseExpr(entry.slice(0, colonIdx).trim(), lineNo, errors));
+            values.push(parseExpr(entry.slice(colonIdx + 1).trim(), lineNo, errors));
+          }
+        }
+      }
+      return {
+        node: { type: "Dict", keys, values },
+        endPos: closeIdx + 1
+      };
+    }
+  }
+  if (remaining[0] === '"' || remaining[0] === "'") {
+    const quote = remaining[0];
+    if (remaining.startsWith(quote + quote + quote)) {
+      const endQuote = remaining.indexOf(quote + quote + quote, 3);
+      if (endQuote !== -1) {
+        const value = remaining.slice(3, endQuote);
+        return {
+          node: { type: "Constant", value, kind: "str" },
+          endPos: pos + endQuote + 3
+        };
+      }
+    }
+    let i = 1;
+    while (i < remaining.length) {
+      if (remaining[i] === "\\" && i + 1 < remaining.length) {
+        i += 2;
+        continue;
+      }
+      if (remaining[i] === quote) {
+        const value = remaining.slice(1, i);
+        return {
+          node: { type: "Constant", value, kind: "str" },
+          endPos: pos + i + 1
+        };
+      }
+      i++;
+    }
+    return {
+      node: {
+        type: "Constant",
+        value: remaining.slice(1),
+        kind: "str"
+      },
+      endPos: pos + remaining.length
+    };
+  }
+  if ((remaining[0] === "f" || remaining[0] === "F") && remaining.length > 1 && (remaining[1] === '"' || remaining[1] === "'")) {
+    const quote = remaining[1];
+    let i = 2;
+    while (i < remaining.length) {
+      if (remaining[i] === "\\" && i + 1 < remaining.length) {
+        i += 2;
+        continue;
+      }
+      if (remaining[i] === quote) {
+        const value = remaining.slice(2, i);
+        return {
+          node: { type: "Constant", value, kind: "str" },
+          endPos: pos + i + 1
+        };
+      }
+      i++;
+    }
+    return {
+      node: {
+        type: "Constant",
+        value: remaining.slice(2),
+        kind: "str"
+      },
+      endPos: pos + remaining.length
+    };
+  }
+  const numMatch = remaining.match(/^-?\d+(\.\d+)?/);
+  if (numMatch) {
+    const numStr = numMatch[0];
+    const isFloat = numStr.includes(".");
+    return {
+      node: {
+        type: "Constant",
+        value: isFloat ? parseFloat(numStr) : parseInt(numStr, 10),
+        kind: isFloat ? "float" : "int"
+      },
+      endPos: pos + numStr.length
+    };
+  }
+  const identMatch = remaining.match(/^[A-Za-z_][A-Za-z0-9_]*/);
+  if (identMatch) {
+    const id = identMatch[0];
+    const endPos = pos + id.length;
+    if (id === "True") {
+      return {
+        node: { type: "Constant", value: true, kind: "bool" },
+        endPos
+      };
+    }
+    if (id === "False") {
+      return {
+        node: { type: "Constant", value: false, kind: "bool" },
+        endPos
+      };
+    }
+    if (id === "None") {
+      return {
+        node: { type: "Constant", value: null, kind: "none" },
+        endPos
+      };
+    }
+    return {
+      node: { type: "Name", id },
+      endPos
+    };
+  }
+  errors.push({
+    message: `Unexpected token: ${remaining.slice(0, 20)}`,
+    line: lineNo,
+    severity: "error"
+  });
+  return {
+    node: { type: "Name", id: remaining.trim() },
+    endPos: pos + remaining.length
+  };
+}
+function parsePrimary(text, lineNo, errors) {
+  const { node } = parsePrimaryAt(text, 0, lineNo, errors);
+  return node;
+}
+function splitTopLevel(text, delimiter) {
+  const parts = [];
+  let parenDepth = 0;
+  let bracketDepth = 0;
+  let braceDepth = 0;
+  let inStr = null;
+  let start = 0;
+  for (let i = 0; i <= text.length - delimiter.length; i++) {
+    const ch = text[i];
+    if ((ch === '"' || ch === "'") && (i === 0 || text[i - 1] !== "\\")) {
+      if (inStr === ch) {
+        inStr = null;
+        continue;
+      } else if (!inStr) {
+        inStr = ch;
+        continue;
+      }
+    }
+    if (inStr) continue;
+    if (ch === "(") parenDepth++;
+    else if (ch === ")") parenDepth--;
+    else if (ch === "[") bracketDepth++;
+    else if (ch === "]") bracketDepth--;
+    else if (ch === "{") braceDepth++;
+    else if (ch === "}") braceDepth--;
+    if (parenDepth === 0 && bracketDepth === 0 && braceDepth === 0 && text.slice(i, i + delimiter.length) === delimiter) {
+      parts.push(text.slice(start, i).trim());
+      start = i + delimiter.length;
+      i = start - 1;
+    }
+  }
+  parts.push(text.slice(start).trim());
+  return parts;
+}
+function findTopLevel(text, needle) {
+  let parenDepth = 0;
+  let bracketDepth = 0;
+  let braceDepth = 0;
+  let inStr = null;
+  for (let i = 0; i <= text.length - needle.length; i++) {
+    const ch = text[i];
+    if ((ch === '"' || ch === "'") && (i === 0 || text[i - 1] !== "\\")) {
+      if (inStr === ch) {
+        inStr = null;
+        continue;
+      } else if (!inStr) {
+        inStr = ch;
+        continue;
+      }
+    }
+    if (inStr) continue;
+    if (ch === "(") parenDepth++;
+    else if (ch === ")") parenDepth--;
+    else if (ch === "[") bracketDepth++;
+    else if (ch === "]") bracketDepth--;
+    else if (ch === "{") braceDepth++;
+    else if (ch === "}") braceDepth--;
+    if (parenDepth === 0 && bracketDepth === 0 && braceDepth === 0 && text.slice(i, i + needle.length) === needle) {
+      return i;
+    }
+  }
+  return -1;
+}
+function findMatchingClose(text, openIdx, open, close) {
+  let depth = 0;
+  let inStr = null;
+  for (let i = openIdx; i < text.length; i++) {
+    const ch = text[i];
+    if ((ch === '"' || ch === "'") && (i === 0 || text[i - 1] !== "\\")) {
+      if (inStr === ch) {
+        inStr = null;
+        continue;
+      } else if (!inStr) {
+        inStr = ch;
+        continue;
+      }
+    }
+    if (inStr) continue;
+    if (ch === open) depth++;
+    else if (ch === close) {
+      depth--;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+function splitArgs(text) {
+  return splitTopLevel(text, ",");
+}
+function extractParameterName(param) {
+  const trimmed = param.trim();
+  if (!trimmed || trimmed === "*" || trimmed === "/") return null;
+  const match = trimmed.match(/^\*{0,2}([A-Za-z_][A-Za-z0-9_]*)/);
+  return match?.[1] ?? null;
+}
+function opensBlock(text) {
+  return text === "else:" || text.startsWith("except") || /^(def|class|if|elif|for|while)\b/.test(text) && text.trimEnd().endsWith(":") || text === "try:";
+}
+function validateIndentation(lines, errors) {
+  const indentStack = [0];
+  let indentUnit = null;
+  let previousOpenedBlock = false;
+  for (const line of lines) {
+    const currentIndent = line.indent;
+    let topIndent = indentStack[indentStack.length - 1];
+    if (currentIndent > topIndent) {
+      const delta = currentIndent - topIndent;
+      if (!previousOpenedBlock) {
+        errors.push({
+          message: `Unexpected indentation on line ${line.lineNo}`,
+          line: line.lineNo,
+          severity: "error"
+        });
+      }
+      if (indentUnit === null) {
+        indentUnit = delta;
+      } else if (delta !== indentUnit) {
+        errors.push({
+          message: `Inconsistent indentation width on line ${line.lineNo}`,
+          line: line.lineNo,
+          severity: "error"
+        });
+      }
+      indentStack.push(currentIndent);
+      topIndent = currentIndent;
+    } else if (currentIndent < topIndent) {
+      while (indentStack.length > 1 && currentIndent < topIndent) {
+        indentStack.pop();
+        topIndent = indentStack[indentStack.length - 1];
+      }
+      if (currentIndent !== topIndent) {
+        errors.push({
+          message: `Inconsistent dedent on line ${line.lineNo}`,
+          line: line.lineNo,
+          severity: "error"
+        });
+      }
+    }
+    previousOpenedBlock = opensBlock(line.text);
+  }
+}
+function parseCallArgs(text, lineNo, errors) {
+  if (!text.trim()) return { args: [], kwargs: [] };
+  const parts = splitArgs(text);
+  const args = [];
+  const kwargs = [];
+  for (const part of parts) {
+    const trimmed = part.trim();
+    const kwMatch = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=(?!=)\s*(.+)$/);
+    if (kwMatch) {
+      kwargs.push({
+        key: kwMatch[1],
+        value: parseExpr(kwMatch[2].trim(), lineNo, errors)
+      });
+    } else {
+      args.push(parseExpr(trimmed, lineNo, errors));
+    }
+  }
+  return { args, kwargs };
+}
+
+// ../../lib/py2bend/transforms.ts
+function transformModule(ast) {
+  return {
+    type: "BendModule",
+    source: "Module",
+    body: transformNodes(ast.body)
+  };
+}
+function transformNodes(nodes) {
+  return nodes.map(transformNode);
+}
+function transformNode(node) {
+  switch (node.type) {
+    case "FunctionDef":
+      return transformFunctionDef(node);
+    case "For":
+      return transformFor(node);
+    case "While":
+      return transformWhile(node);
+    case "ClassDef":
+      return transformClass(node);
+    case "Try":
+      return transformTry(node);
+    default:
+      return passthrough(node);
+  }
+}
+function transformFunctionDef(node) {
+  return {
+    type: "BendFunctionDef",
+    source: "FunctionDef",
+    name: node.name,
+    params: node.params,
+    body: transformNodes(node.body),
+    decorators: node.decorators
+  };
+}
+function transformFor(node) {
+  const accumulator = findAccumulator(node.body);
+  return {
+    type: "BendFold",
+    source: "For",
+    target: node.target,
+    iter: node.iter,
+    body: transformNodes(node.body),
+    accumulator
+  };
+}
+function findAccumulator(body) {
+  for (const stmt of body) {
+    if (stmt.type === "AugAssign") {
+      return stmt.target;
+    }
+  }
+  return null;
+}
+function transformWhile(node) {
+  return {
+    type: "BendLoop",
+    source: "While",
+    test: node.test,
+    body: transformNodes(node.body),
+    stateVars: collectLoopStateVars(node.body)
+  };
+}
+function collectLoopStateVars(body) {
+  const vars = /* @__PURE__ */ new Set();
+  for (const stmt of body) {
+    if (stmt.type === "Assign") {
+      const target = stmt.target;
+      if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(target)) {
+        vars.add(target);
+      }
+    }
+    if (stmt.type === "AugAssign") {
+      const target = stmt.target;
+      if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(target)) {
+        vars.add(target);
+      }
+    }
+  }
+  return Array.from(vars);
+}
+function transformClass(node) {
+  const fields = extractFields(node.body);
+  const methods = [];
+  for (const member of node.body) {
+    if (member.type === "FunctionDef") {
+      methods.push(transformFunctionDef(member));
+    }
+  }
+  return {
+    type: "BendObject",
+    source: "ClassDef",
+    name: node.name,
+    bases: node.bases,
+    fields,
+    methods
+  };
+}
+function extractFields(body) {
+  const fields = [];
+  const initMethod = body.find(
+    (n) => n.type === "FunctionDef" && n.name === "__init__"
+  );
+  if (!initMethod) return fields;
+  for (const stmt of initMethod.body) {
+    if (stmt.type === "Assign") {
+      const assign = stmt;
+      const fieldMatch = assign.target.match(/^self\.([A-Za-z_][A-Za-z0-9_]*)$/);
+      if (fieldMatch) {
+        fields.push(fieldMatch[1]);
+      }
+    }
+  }
+  return fields;
+}
+function transformTry(node) {
+  return {
+    type: "BendWith",
+    source: "Try",
+    body: transformNodes(node.body),
+    handler: node.handler ? {
+      name: node.handler.name,
+      type: node.handler.type,
+      body: transformNodes(node.handler.body)
+    } : null
+  };
+}
+function passthrough(node) {
+  return {
+    type: "BendPassthrough",
+    source: node.type,
+    node
+  };
+}
+
+// ../../lib/py2bend/media-stdlib.ts
+var MEDIA_BUILTIN_MAP = {
+  // Frame generation
+  "render_frame": "Media/render_frame",
+  "encode_video": "Media/encode_video",
+  "encode_audio": "Media/encode_audio",
+  // Kuramoto utilities
+  "kuramoto_step": "Phase/kuramoto_step",
+  "order_parameter": "Phase/order_parameter",
+  // Audio synthesis
+  "oscillator": "Audio/oscillator",
+  "mix_channels": "Audio/mix",
+  "soft_clip": "Audio/soft_clip",
+  "fade": "Audio/fade",
+  // Math shortcuts
+  "linspace": "List/linspace",
+  "zeros": "List/zeros",
+  "sin": "Num/sin",
+  "cos": "Num/cos",
+  "tanh": "Num/tanh",
+  "exp": "Num/exp",
+  "log2": "Num/log2",
+  "pi": "Num/pi"
+};
+
+// ../../lib/py2bend/stdlib.ts
+var BUILTIN_MAP = {
+  len: "List/len",
+  print: "IO/print",
+  range: "List/range",
+  int: "Num/to_int",
+  float: "Num/to_float",
+  str: "Str/from",
+  bool: "Bool/from",
+  abs: "Num/abs",
+  min: "Num/min",
+  max: "Num/max",
+  sum: "List/sum",
+  sorted: "List/sort",
+  reversed: "List/reverse",
+  enumerate: "List/enumerate",
+  zip: "List/zip",
+  map: "List/map",
+  filter: "List/filter",
+  any: "List/any",
+  all: "List/all",
+  isinstance: "Type/is",
+  type: "Type/of",
+  input: "IO/input",
+  open: "IO/open",
+  round: "Num/round",
+  list: "List/from",
+  dict: "Map/from",
+  tuple: "Tuple/from",
+  set: "Set/from",
+  // Media builtins (from media-stdlib.ts)
+  ...MEDIA_BUILTIN_MAP
+};
+var OP_MAP = {
+  "+": "+",
+  "-": "-",
+  "*": "*",
+  "/": "/",
+  "//": "/",
+  "%": "%",
+  "**": "**",
+  "&": "&",
+  "|": "|",
+  "==": "==",
+  "!=": "!=",
+  "<": "<",
+  ">": ">",
+  "<=": "<=",
+  ">=": ">=",
+  and: "&",
+  or: "|",
+  not: "!",
+  in: "List/contains",
+  "not in": "List/not_contains"
+};
+
+// ../../lib/py2bend/codegen.ts
+function generateBend(module) {
+  const lines = [];
+  for (const node of module.body) {
+    lines.push(generateNode(node, 0));
+  }
+  return lines.join("\n\n") + "\n";
+}
+function generateNode(node, depth) {
+  switch (node.type) {
+    case "BendFunctionDef":
+      return generateFunctionDef(node, depth);
+    case "BendFold":
+      return generateFold(node, depth);
+    case "BendLoop":
+      return generateLoop(node, depth);
+    case "BendObject":
+      return generateObject(node, depth);
+    case "BendWith":
+      return generateWith(node, depth);
+    case "BendPassthrough":
+      return generatePassthrough(node, depth);
+    default:
+      return indent(depth) + `# unsupported: ${node.type}`;
+  }
+}
+function generateFunctionDef(node, depth) {
+  const params = node.params.join(", ");
+  const head = `${indent(depth)}def ${node.name}(${params}):`;
+  const bodyLines = node.body.map((n) => generateNode(n, depth + 1));
+  if (bodyLines.length === 0) {
+    return head + "\n" + indent(depth + 1) + "return *";
+  }
+  return head + "\n" + bodyLines.join("\n");
+}
+function generateFold(node, depth) {
+  const iterExpr = generateExpr(node.iter, depth);
+  const head = `${indent(depth)}fold ${iterExpr}:`;
+  const consCase = `${indent(depth + 1)}case List/Cons:`;
+  const bodyLines = node.body.map((n) => generateNode(n, depth + 2));
+  const nilCase = `${indent(depth + 1)}case List/Nil:`;
+  const nilBody = node.accumulator ? `${indent(depth + 2)}${node.accumulator}` : `${indent(depth + 2)}*`;
+  return [head, consCase, ...bodyLines, nilCase, nilBody].join("\n");
+}
+function generateLoop(node, depth) {
+  const testExpr = generateExpr(node.test, depth);
+  const head = `${indent(depth)}bend x = 0:`;
+  const whenLine = `${indent(depth + 1)}when ${testExpr}:`;
+  const bodyLines = node.body.map((n) => generateNode(n, depth + 2));
+  const forkLine = `${indent(depth + 2)}fork(x + 1)`;
+  const elseLine = `${indent(depth + 1)}else:`;
+  const elseBody = `${indent(depth + 2)}x`;
+  return [head, whenLine, ...bodyLines, forkLine, elseLine, elseBody].join(
+    "\n"
+  );
+}
+function generateObject(node, depth) {
+  const fieldsStr = node.fields.length > 0 ? ` { ${node.fields.join(", ")} }` : "";
+  const head = `${indent(depth)}object ${node.name}${fieldsStr}`;
+  if (node.methods.length === 0) {
+    return head;
+  }
+  const nonInitMethods = node.methods.filter((m) => m.name !== "__init__");
+  if (nonInitMethods.length === 0) {
+    return head;
+  }
+  const methodLines = nonInitMethods.map(
+    (m) => generateFunctionDef(m, depth)
+  );
+  return head + "\n\n" + methodLines.join("\n\n");
+}
+function generateWith(node, depth) {
+  const head = `${indent(depth)}with Result:`;
+  const bodyLines = node.body.map((n) => generateNode(n, depth + 1));
+  if (!node.handler) {
+    return [head, ...bodyLines].join("\n");
+  }
+  const handlerLines = node.handler.body.map(
+    (n) => generateNode(n, depth + 1)
+  );
+  const handlerHead = node.handler.name ? `${indent(depth)}catch ${node.handler.name}:` : `${indent(depth)}catch _err:`;
+  return [head, ...bodyLines, handlerHead, ...handlerLines].join("\n");
+}
+function generatePassthrough(node, depth) {
+  return generatePyStatement(node.node, depth);
+}
+function generatePyStatement(node, depth) {
+  switch (node.type) {
+    case "Return":
+      return generateReturn(node, depth);
+    case "Assign":
+      return generateAssign(node, depth);
+    case "AugAssign":
+      return generateAugAssign(node, depth);
+    case "If":
+      return generateIf(node, depth);
+    case "Expr":
+      return indent(depth) + generateExpr(node.value, depth);
+    default:
+      return indent(depth) + generateExpr(node, depth);
+  }
+}
+function generateReturn(node, depth) {
+  if (!node.value) {
+    return `${indent(depth)}return *`;
+  }
+  return `${indent(depth)}return ${generateExpr(node.value, depth)}`;
+}
+function generateAssign(node, depth) {
+  return `${indent(depth)}let ${node.target} = ${generateExpr(node.value, depth)}`;
+}
+function generateAugAssign(node, depth) {
+  const op = node.op.slice(0, -1);
+  const mappedOp = OP_MAP[op] ?? op;
+  return `${indent(depth)}let ${node.target} = (${node.target} ${mappedOp} ${generateExpr(node.value, depth)})`;
+}
+function generateIf(node, depth) {
+  const testExpr = generateExpr(node.test, depth);
+  const head = `${indent(depth)}if ${testExpr}:`;
+  const bodyLines = node.body.map(
+    (n) => generatePyStatement(n, depth + 1)
+  );
+  if (!node.orelse || node.orelse.length === 0) {
+    return [head, ...bodyLines].join("\n");
+  }
+  const elseLine = `${indent(depth)}else:`;
+  const elseLines = node.orelse.map(
+    (n) => generatePyStatement(n, depth + 1)
+  );
+  return [head, ...bodyLines, elseLine, ...elseLines].join("\n");
+}
+function generateExpr(node, _depth) {
+  switch (node.type) {
+    case "Name":
+      return node.id;
+    case "Constant":
+      return generateConstant(node);
+    case "BinOp": {
+      const binop = node;
+      const mappedOp = OP_MAP[binop.op] ?? binop.op;
+      return `(${generateExpr(binop.left, _depth)} ${mappedOp} ${generateExpr(binop.right, _depth)})`;
+    }
+    case "UnaryOp": {
+      const unary = node;
+      const mappedOp = OP_MAP[unary.op] ?? unary.op;
+      if (mappedOp === "!") {
+        return `(!${generateExpr(unary.operand, _depth)})`;
+      }
+      return `(${mappedOp}${generateExpr(unary.operand, _depth)})`;
+    }
+    case "Compare": {
+      const cmp = node;
+      if (cmp.ops.length === 1) {
+        const mappedOp = OP_MAP[cmp.ops[0]] ?? cmp.ops[0];
+        return `(${generateExpr(cmp.left, _depth)} ${mappedOp} ${generateExpr(cmp.comparators[0], _depth)})`;
+      }
+      const parts = [];
+      let prevExpr = generateExpr(cmp.left, _depth);
+      for (let i = 0; i < cmp.ops.length; i++) {
+        const mappedOp = OP_MAP[cmp.ops[i]] ?? cmp.ops[i];
+        const rightExpr = generateExpr(cmp.comparators[i], _depth);
+        parts.push(`(${prevExpr} ${mappedOp} ${rightExpr})`);
+        prevExpr = rightExpr;
+      }
+      return parts.join(" & ");
+    }
+    case "BoolOp": {
+      const boolop = node;
+      const mappedOp = OP_MAP[boolop.op] ?? boolop.op;
+      const exprs = boolop.values.map((v) => generateExpr(v, _depth));
+      return `(${exprs.join(` ${mappedOp} `)})`;
+    }
+    case "Call": {
+      const call = node;
+      const funcName = generateExpr(call.func, _depth);
+      const mappedName = BUILTIN_MAP[funcName] ?? funcName;
+      const args = call.args.map((a) => generateExpr(a, _depth));
+      const kwargs = call.kwargs.map(
+        (kw) => `${kw.key}=${generateExpr(kw.value, _depth)}`
+      );
+      const allArgs = [...args, ...kwargs].join(", ");
+      return `${mappedName}(${allArgs})`;
+    }
+    case "Attribute": {
+      const attr = node;
+      return `${generateExpr(attr.value, _depth)}.${attr.attr}`;
+    }
+    case "Subscript": {
+      const sub = node;
+      return `List/get(${generateExpr(sub.value, _depth)}, ${generateExpr(sub.slice, _depth)})`;
+    }
+    case "List": {
+      const list = node;
+      const elts = list.elts.map((e) => generateExpr(e, _depth));
+      return `[${elts.join(", ")}]`;
+    }
+    case "Dict": {
+      const dict = node;
+      const entries = dict.keys.map(
+        (k, i) => `${generateExpr(k, _depth)}: ${generateExpr(dict.values[i], _depth)}`
+      );
+      return `{${entries.join(", ")}}`;
+    }
+    case "Lambda": {
+      const lam = node;
+      const params = lam.params.join(", ");
+      return `@${params} ${generateExpr(lam.body, _depth)}`;
+    }
+    default:
+      return `/* unsupported: ${node.type} */`;
+  }
+}
+function generateConstant(node) {
+  switch (node.kind) {
+    case "str":
+      return `"${String(node.value).replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+    case "int":
+    case "float":
+      return String(node.value);
+    case "bool":
+      return node.value ? "True" : "False";
+    case "none":
+      return "*";
+    default:
+      return String(node.value);
+  }
+}
+function indent(depth) {
+  return "  ".repeat(depth);
+}
+
+// ../../lib/py2bend/index.ts
+function compile(pythonSource) {
+  const warnings = [];
+  const { ast, errors: parseErrors } = parsePython(pythonSource);
+  if (!ast) {
+    return {
+      bend: "",
+      errors: parseErrors,
+      warnings
+    };
+  }
+  const errors = parseErrors.filter((e) => e.severity === "error");
+  const parseWarnings = parseErrors.filter((e) => e.severity === "warning");
+  warnings.push(...parseWarnings.map((w) => w.message));
+  const bendModule = transformModule(ast);
+  const bend = generateBend(bendModule);
+  return {
+    bend,
+    errors,
+    warnings
+  };
+}
+
+// ../../lib/hermes/hvm-bridge.ts
+var HermesHVMBridge = class {
+  metrics = {
+    totalReductions: 0,
+    lastDurationMs: 0,
+    avgDurationMs: 0,
+    lastStrategy: "none"
+  };
+  /**
+   * Create an HVM-compatible manifest from Bend source.
+   * Returns a NodeManifestV0 with a "wasm-hvm" entrypoint pointing
+   * to an .hvm module for the HVM runner to execute.
+   */
+  createManifest(bendSource) {
+    return {
+      id: `hermes-bend-${Date.now()}`,
+      version: "1.0.0",
+      kind: "custom",
+      name: "Hermes Bend Execution",
+      runtimes: ["wasm-hvm"],
+      entrypoints: {
+        "wasm-hvm": {
+          module: "hermes-compiled.hvm",
+          function: "main"
+        }
+      },
+      metadata: {
+        source: "py2bend",
+        bendSource
+      }
+    };
+  }
+  /**
+   * Compute logit bias hints from py2bend compilation structure.
+   * Analyzes the Bend output for structural features (fold count,
+   * bend count, object count) and maps them to control token bias
+   * hints that downstream adapters can translate into provider-specific
+   * logit_bias token IDs.
+   */
+  computeLogitBias(compiled) {
+    const lines = compiled.bend.split("\n");
+    const bias = {};
+    let foldCount = 0;
+    let bendCount = 0;
+    let objectCount = 0;
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("fold")) foldCount++;
+      if (trimmed.startsWith("bend")) bendCount++;
+      if (trimmed.startsWith("object")) objectCount++;
+    }
+    if (foldCount > 0) {
+      bias["control:decompose"] = 0.15 * Math.min(foldCount, 5);
+      bias["control:structure"] = 0.1;
+    }
+    if (bendCount > 0) {
+      bias["control:parallel"] = 0.15 * Math.min(bendCount, 5);
+      bias["control:branch"] = 0.1;
+    }
+    if (objectCount > 0) {
+      bias["control:synthesize"] = 0.1 * Math.min(objectCount, 5);
+    }
+    return bias;
+  }
+  /**
+   * Execute Bend source through the HVM runner.
+   * Dynamically imports runInHVM, creates a manifest, executes,
+   * and updates internal reduction metrics.
+   */
+  async executeBend(bendSource) {
+    const manifest = this.createManifest(bendSource);
+    try {
+      const { runInHVM } = await import("./hvm-CBEP3M4F.js");
+      const output = await runInHVM(
+        manifest,
+        { bendSource },
+        { stackId: "hermes", nodeId: "bend-exec" }
+      );
+      const hvmResult = output != null && typeof output === "object" ? output : {};
+      const rawHvm = hvmResult._hvm;
+      const hvm = rawHvm != null && typeof rawHvm === "object" ? rawHvm : {};
+      const durationMs = typeof hvm.durationMs === "number" ? hvm.durationMs : 0;
+      this.metrics.totalReductions++;
+      this.metrics.lastDurationMs = durationMs;
+      this.metrics.lastStrategy = typeof hvm.strategy === "string" ? hvm.strategy : "unknown";
+      this.metrics.avgDurationMs = (this.metrics.avgDurationMs * (this.metrics.totalReductions - 1) + durationMs) / this.metrics.totalReductions;
+      return {
+        result: hvmResult.result,
+        reduced: typeof hvm.reduced === "boolean" ? hvm.reduced : false,
+        strategy: typeof hvm.strategy === "string" ? hvm.strategy : "unknown",
+        durationMs,
+        ...typeof hvmResult.error === "string" ? { error: hvmResult.error } : {}
+      };
+    } catch (error) {
+      console.warn("[HermesHVMBridge] executeBend failed:", error);
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        result: null,
+        reduced: false,
+        strategy: "error",
+        durationMs: 0,
+        error: message
+      };
+    }
+  }
+  /** Returns a snapshot of current reduction metrics */
+  getMetrics() {
+    return { ...this.metrics };
+  }
+};
+
+// ../../lib/terminals-tech/sdk/manifold.ts
+function now() {
+  return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function normalizeWhitespace(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function toPythonProjection(intent, context) {
+  const normalizedIntent = normalizeWhitespace(intent);
+  const normalizedContext = normalizeWhitespace(context).slice(0, 180);
+  const target = normalizeWhitespace(intent.replace(/[^a-zA-Z0-9 ]/g, "")).slice(0, 80);
+  return [
+    "def collapsed_intent(context_state):",
+    `    # Intent: ${normalizedIntent.replace(/#/g, "")}`,
+    `    # Context: ${normalizedContext.replace(/#/g, "")}`,
+    `    target = ${JSON.stringify(target || normalizedIntent || "resolve")}`,
+    "    return target"
+  ].join("\n");
+}
+function computeNormalizedEntropy(value) {
+  if (!value) return 0;
+  const counts = /* @__PURE__ */ new Map();
+  for (const ch of value) {
+    counts.set(ch, (counts.get(ch) ?? 0) + 1);
+  }
+  let bits = 0;
+  for (const count of counts.values()) {
+    const p = count / value.length;
+    bits -= p * Math.log2(p);
+  }
+  return clamp(bits / 6, 0, 1);
+}
+function deriveSteps(bend, maxSteps, durationMs) {
+  const structuralLines = bend.split("\n").map((line) => line.trim()).filter(Boolean).length;
+  const runtimeUnits = durationMs ? Math.ceil(durationMs) : 0;
+  return clamp(Math.max(structuralLines, runtimeUnits, 1), 1, maxSteps);
+}
+function buildResultMessage(reduction, steps) {
+  if (reduction.reduced) {
+    return `Manifold annihilated through ${reduction.strategy} in ${reduction.durationMs.toFixed(2)}ms across ${steps} reduction units.`;
+  }
+  if (reduction.errors.length > 0) {
+    return `Manifold annihilation failed after compilation: ${reduction.errors[0]}`;
+  }
+  if (reduction.compiled) {
+    return `Manifold compiled to Bend but did not reduce in HVM. Strategy: ${reduction.strategy}.`;
+  }
+  return reduction.errors[0] ? `Manifold annihilation failed at compile boundary: ${reduction.errors[0]}` : "Manifold annihilation failed before structural reduction.";
+}
+async function annihilate(intent, context, options = {}) {
+  const maxSteps = options.maxSteps ?? 2e3;
+  const threshold = options.convergenceThreshold ?? 0.9;
+  const gravity = options.gravity ?? 2.5;
+  const gravityScale = clamp(gravity / 2.5, 0.5, 1.5);
+  const resolvedContext = context ?? globalStateMirror.encodeToManifold();
+  const config = dmt55Engine.getObserverConfiguration(1);
+  const evidence = dmt55Engine.generateMicroLMEvidence(1);
+  emitSignal("mesh_update", "L4", "L3", {
+    type: "manifold_annihilation_start",
+    intentLength: intent.length,
+    contextLength: resolvedContext.length,
+    dimensions: config.totalDimensions,
+    gravity
+  });
+  const pythonSource = intent.includes("def ") || intent.includes("class ") ? intent : toPythonProjection(intent, resolvedContext);
+  const compileStart = now();
+  const compileResult = compile(pythonSource);
+  const compileDurationMs = now() - compileStart;
+  const compileErrors = compileResult.errors.map((error) => error.message);
+  const hvmBridge = new HermesHVMBridge();
+  const logitBias = hvmBridge.computeLogitBias(compileResult);
+  let reduction = {
+    compiled: compileErrors.length === 0,
+    reduced: false,
+    strategy: "compile-only",
+    runtime: "compile-only",
+    durationMs: compileDurationMs,
+    warnings: [...compileResult.warnings],
+    errors: compileErrors,
+    logitBias
+  };
+  if (reduction.compiled && compileResult.bend.trim().length > 0) {
+    const hvmExecution = await hvmBridge.executeBend(compileResult.bend);
+    const runtimeErrors = [...compileErrors, ...hvmExecution.error ? [hvmExecution.error] : []];
+    reduction = {
+      compiled: true,
+      reduced: hvmExecution.reduced,
+      strategy: hvmExecution.strategy,
+      runtime: "wasm-hvm",
+      durationMs: hvmExecution.durationMs || compileDurationMs,
+      warnings: [...compileResult.warnings],
+      errors: hvmExecution.reduced ? [] : runtimeErrors,
+      logitBias
+    };
+  }
+  const steps = deriveSteps(compileResult.bend, maxSteps, reduction.durationMs);
+  const entropySeed = reduction.reduced ? `${compileResult.bend}
+${JSON.stringify(reduction.logitBias)}` : reduction.errors.join(" | ") || compileErrors.join(" | ") || intent;
+  const activationEntropy = computeNormalizedEntropy(entropySeed);
+  let R = evidence.confidence;
+  if (!reduction.compiled) {
+    R = clamp(
+      0.18 + compileResult.warnings.length * 0.01 - compileErrors.length * 0.03 + (gravityScale - 1) * 0.04,
+      0.05,
+      0.58
+    );
+  } else if (reduction.reduced) {
+    const speedBonus = clamp((0.08 - reduction.durationMs / 2500) * gravityScale, 0, 0.08);
+    const strategyBonus = reduction.strategy === "wasm" || reduction.strategy === "hvm-core" ? 0.03 : 0;
+    const warningPenalty = Math.min(reduction.warnings.length * 0.01, 0.05);
+    R = clamp(threshold + 0.02 + speedBonus + strategyBonus - warningPenalty, threshold, 0.99);
+  } else {
+    R = clamp(
+      0.62 - reduction.warnings.length * 0.02 + (gravityScale - 1) * 0.03,
+      0.3,
+      threshold - 0.01
+    );
+  }
+  const result = buildResultMessage(reduction, steps);
+  const sematon = createSematon({
+    kind: "interaction",
+    payload: {
+      result,
+      steps,
+      intent,
+      contextSnapshot: resolvedContext.substring(0, 140),
+      bendCode: reduction.compiled ? compileResult.bend : void 0,
+      reduction
+    },
+    witness: {
+      R,
+      activationEntropy,
+      converged: reduction.reduced && R >= threshold,
+      step: steps
+    },
+    source: "manifold_annihilation"
+  });
+  const observableEvidence = buildObservableEvidenceFromSematon(sematon, "Reduction Witness");
+  emitSignal("sematon_created", "L4", "L3", {
+    sematonId: sematon.id,
+    source: "manifold_annihilation"
+  });
+  emitSignal("sematon_realized", "L4", "L3", {
+    sematonId: sematon.id,
+    converged: sematon.witness.converged
+  });
+  emitSignal("mesh_update", "L4", "L3", {
+    type: "manifold_annihilation_complete",
+    sematonId: sematon.id,
+    R,
+    durationMs: reduction.durationMs,
+    strategy: reduction.strategy,
+    observableEvidence
+  });
+  return sematon;
+}
+var manifold = {
+  annihilate
+};
+
+// ../../lib/terminals-tech/sdk/observer.ts
+var observer_exports = {};
+__export(observer_exports, {
+  ObserverKernel: () => ObserverKernel,
+  disposeObserverKernel: () => disposeObserverKernel,
+  getObserverKernel: () => getObserverKernel
+});
+import { BehaviorSubject as BehaviorSubject2 } from "rxjs";
+var ObserverKernel = class {
+  id;
+  heartbeatHz;
+  mirror;
+  activeNeurons = /* @__PURE__ */ new Map();
+  coherenceR$ = new BehaviorSubject2(0);
+  pulseTimer = null;
+  constructor(config) {
+    this.id = config.id;
+    this.heartbeatHz = config.heartbeatHz ?? 60;
+    this.mirror = config.stateMirror ?? globalStateMirror;
+  }
+  get coherence() {
+    return this.coherenceR$.value;
+  }
+  get isRunning() {
+    return this.pulseTimer !== null;
+  }
+  /** Starts the continuous heartbeat */
+  start() {
+    if (this.pulseTimer) return;
+    const intervalMs = 1e3 / this.heartbeatHz;
+    this.pulseTimer = setInterval(() => this.pulse(), intervalMs);
+    getSignalBus().emit("mesh_update", "L4", "L3", {
+      type: "observer_started",
+      observerId: this.id
+    });
+  }
+  /** Stops the heartbeat */
+  stop() {
+    if (this.pulseTimer) {
+      clearInterval(this.pulseTimer);
+      this.pulseTimer = null;
+    }
+  }
+  /** The continuous observation loop */
+  pulse() {
+    const state = this.mirror.snapshot;
+    const targetR = state.coherenceR;
+    const currentR = this.coherenceR$.value;
+    const nextR = currentR * 0.95 + targetR * 0.05;
+    this.coherenceR$.next(nextR);
+  }
+  /** Equips a new geometric constraint (Neuron) onto the observer */
+  equipNeuron(neuron) {
+    this.activeNeurons.set(neuron.id, neuron);
+    getSignalBus().emit("mesh_update", "L4", "L3", {
+      type: "neuron_equipped",
+      observerId: this.id,
+      neuronId: neuron.id
+    });
+  }
+  /** Unequips a Neuron */
+  unequipNeuron(neuronId) {
+    this.activeNeurons.delete(neuronId);
+  }
+  /** Replace the active neuron field in one operation. */
+  syncNeurons(neurons) {
+    this.activeNeurons.clear();
+    for (const neuron of neurons) {
+      this.activeNeurons.set(neuron.id, neuron);
+    }
+    getSignalBus().emit("mesh_update", "L4", "L3", {
+      type: "observer_field_synced",
+      observerId: this.id,
+      neuronCount: neurons.length
+    });
+  }
+  /**
+   * The core execution path:
+   * Flattens the active Neurons + StateMirror context, then drops them into the Annihilator.
+   */
+  async resolve(intent) {
+    this.pulse();
+    const contextManifold = this.mirror.encodeToManifold();
+    let injectedIntent = intent;
+    if (this.activeNeurons.size > 0) {
+      const neuronIds = Array.from(this.activeNeurons.keys()).join(", ");
+      injectedIntent = `
+@apply_neurons(${neuronIds})
+${intent}
+      `.trim();
+    }
+    return await annihilate(injectedIntent, contextManifold, {
+      convergenceThreshold: 0.9,
+      gravity: 2.5
+    });
+  }
+};
+var OBSERVER_IDLE_TTL_MS = 5 * 60 * 1e3;
+var observerRegistry = /* @__PURE__ */ new Map();
+function pruneObserverRegistry(now2) {
+  for (const [id, entry] of observerRegistry.entries()) {
+    if (entry.kernel.isRunning) continue;
+    if (now2 - entry.lastUsedAt > OBSERVER_IDLE_TTL_MS) {
+      observerRegistry.delete(id);
+    }
+  }
+}
+function disposeObserverKernel(id) {
+  const entry = observerRegistry.get(id);
+  if (!entry) return;
+  entry.kernel.stop();
+  observerRegistry.delete(id);
+}
+function getObserverKernel(id, config = {}) {
+  const now2 = Date.now();
+  pruneObserverRegistry(now2);
+  const existing = observerRegistry.get(id);
+  if (existing) {
+    existing.lastUsedAt = now2;
+    return existing.kernel;
+  }
+  const kernel = new ObserverKernel({ id, ...config });
+  observerRegistry.set(id, { kernel, lastUsedAt: now2 });
+  return kernel;
+}
+
 // ../../lib/terminals-tech/axon/protocol.ts
 var AXON_CONSTANTS = {
   HEADER_SIZE: 16,
@@ -1817,13 +3896,15 @@ function createAxonBus() {
 }
 
 // src/index.ts
-var SDK_VERSION = "1.0.0-rc.1";
+var SDK_VERSION = "1.0.0";
 export {
   brain_exports as Brain,
   core_exports as Core,
   InMemoryAxonBus,
   L0_exports as L0,
+  manifold_exports as Manifold,
   mesh_exports as Mesh,
+  observer_exports as Observer,
   protocol_exports as Protocol,
   ProtocolBridge,
   SDK_VERSION,