@almadar/shell-web 0.0.0-stage → 0.1.0

package/dist/chunk-P4LNHAFI.js

@@ -0,0 +1,1051 @@
+import { perfStore, pushPerfEntry } from './chunk-DYEKAA4L.js';
+import { isMotionEnabled } from './chunk-MBQAMMSE.js';
+import { useRef, useLayoutEffect, useSyncExternalStore } from 'react';
+import { ENTER_DELAY_STEPS, ENTER_ANIMATIONS, isFileValue } from '@almadar/core';
+export { getNestedValue } from '@almadar/core';
+import { createLogger, isLogLevelEnabled } from '@almadar/logger';
+
+var ENTER_SLOT_CLASS = "almadar-enter-slot";
+function asEnterAnimation(value) {
+  return ENTER_ANIMATIONS.find((e) => e === value);
+}
+var MAX_ENTER_DELAY = ENTER_DELAY_STEPS.length;
+function enterClassName(enter, enterDelay) {
+  if (enter === void 0 || enter === "none" || !isMotionEnabled()) return void 0;
+  const base = `almadar-enter-${enter}`;
+  if (enterDelay === void 0 || !Number.isInteger(enterDelay) || enterDelay < 1 || enterDelay > MAX_ENTER_DELAY) return base;
+  return `${base} almadar-enter-delay-${enterDelay}`;
+}
+function slotPlaysDefaultEnter(rootEnter) {
+  return rootEnter === void 0 && isMotionEnabled();
+}
+function useSlotEnterRestart(ref, contentKey, active) {
+  const lastKey = useRef(contentKey);
+  useLayoutEffect(() => {
+    if (lastKey.current === contentKey) return;
+    lastKey.current = contentKey;
+    const el = ref.current;
+    if (!el || !active) return;
+    el.classList.remove(ENTER_SLOT_CLASS);
+    void el.offsetWidth;
+    el.classList.add(ENTER_SLOT_CLASS);
+  }, [contentKey, active, ref]);
+}
+
+// src/lib/editorMotions.ts
+var EDITOR_MOTIONS = [
+  "left",
+  "right",
+  "up",
+  "down",
+  "word-forward",
+  "word-back",
+  "word-end",
+  "line-start",
+  "line-end",
+  "first-nonblank",
+  "doc-start",
+  "doc-end",
+  "paragraph-forward",
+  "paragraph-back",
+  "line",
+  "selection",
+  "match-bracket"
+];
+var EDITOR_OPERATORS = [
+  "delete",
+  "yank",
+  "change",
+  "put",
+  "put-before",
+  "undo",
+  "redo",
+  "join",
+  "toggle-case",
+  "indent",
+  "dedent",
+  "replace"
+];
+var EDITOR_MOTION_SET = new Set(EDITOR_MOTIONS);
+var EDITOR_OPERATOR_SET = new Set(EDITOR_OPERATORS);
+function isEditorMotion(value) {
+  return EDITOR_MOTION_SET.has(value);
+}
+function isEditorOperator(value) {
+  return EDITOR_OPERATOR_SET.has(value);
+}
+var INDENT_UNIT = "  ";
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function computeLines(text) {
+  const lines = [];
+  let start = 0;
+  for (let i = 0; i <= text.length; i++) {
+    if (i === text.length || text[i] === "\n") {
+      lines.push({ start, end: i });
+      start = i + 1;
+    }
+  }
+  return lines;
+}
+function lineIndexAt(lines, pos) {
+  for (let i = 0; i < lines.length; i++) {
+    if (pos <= lines[i].end) return i;
+  }
+  return lines.length - 1;
+}
+function findWords(text) {
+  const words = [];
+  const re = /\w+|\S+/g;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    words.push({ start: m.index, end: m.index + m[0].length });
+  }
+  return words;
+}
+function nextWordStart(text, pos) {
+  for (const w of findWords(text)) {
+    if (w.start > pos) return w.start;
+  }
+  return text.length;
+}
+function prevWordStart(text, pos) {
+  let result = 0;
+  for (const w of findWords(text)) {
+    if (w.start < pos) result = w.start;
+    else break;
+  }
+  return result;
+}
+function nextWordEnd(text, pos) {
+  for (const w of findWords(text)) {
+    const lastChar = w.end - 1;
+    if (lastChar > pos) return lastChar;
+  }
+  return text.length > 0 ? text.length - 1 : 0;
+}
+function firstNonBlank(text, line) {
+  let i = line.start;
+  while (i < line.end && (text[i] === " " || text[i] === "	")) i++;
+  return i;
+}
+function nextParagraphBoundary(lines, fromLineIdx, textLength) {
+  for (let i = fromLineIdx + 1; i < lines.length; i++) {
+    if (lines[i].start === lines[i].end) return lines[i].start;
+  }
+  return textLength;
+}
+function prevParagraphBoundary(lines, fromLineIdx) {
+  for (let i = fromLineIdx - 1; i >= 0; i--) {
+    if (lines[i].start === lines[i].end) return lines[i].start;
+  }
+  return 0;
+}
+var BRACKET_PARTNER = {
+  "(": ")",
+  ")": "(",
+  "[": "]",
+  "]": "[",
+  "{": "}",
+  "}": "{"
+};
+var OPEN_BRACKETS = /* @__PURE__ */ new Set(["(", "[", "{"]);
+function matchBracket(text, pos) {
+  const ch = text[pos];
+  const partner = ch !== void 0 ? BRACKET_PARTNER[ch] : void 0;
+  if (partner === void 0) return null;
+  let depth = 1;
+  if (OPEN_BRACKETS.has(ch)) {
+    for (let i = pos + 1; i < text.length; i++) {
+      if (text[i] === ch) depth++;
+      else if (text[i] === partner) {
+        depth--;
+        if (depth === 0) return i;
+      }
+    }
+  } else {
+    for (let i = pos - 1; i >= 0; i--) {
+      if (text[i] === ch) depth++;
+      else if (text[i] === partner) {
+        depth--;
+        if (depth === 0) return i;
+      }
+    }
+  }
+  return null;
+}
+function applyMotion(text, caret, motion, count) {
+  const n = Math.max(1, count);
+  const lines = computeLines(text);
+  const lineIdx = lineIndexAt(lines, caret);
+  const line = lines[lineIdx];
+  switch (motion) {
+    case "left":
+      return clamp(caret - n, line.start, line.end);
+    case "right":
+      return clamp(caret + n, line.start, line.end);
+    case "up": {
+      const col = caret - line.start;
+      const targetIdx = clamp(lineIdx - n, 0, lines.length - 1);
+      const target = lines[targetIdx];
+      return clamp(target.start + col, target.start, target.end);
+    }
+    case "down": {
+      const col = caret - line.start;
+      const targetIdx = clamp(lineIdx + n, 0, lines.length - 1);
+      const target = lines[targetIdx];
+      return clamp(target.start + col, target.start, target.end);
+    }
+    case "word-forward": {
+      let pos = caret;
+      for (let i = 0; i < n; i++) pos = nextWordStart(text, pos);
+      return pos;
+    }
+    case "word-back": {
+      let pos = caret;
+      for (let i = 0; i < n; i++) pos = prevWordStart(text, pos);
+      return pos;
+    }
+    case "word-end": {
+      let pos = caret;
+      for (let i = 0; i < n; i++) pos = nextWordEnd(text, pos);
+      return pos;
+    }
+    case "line-start":
+      return line.start;
+    case "line-end":
+      return line.end > line.start ? line.end - 1 : line.start;
+    case "first-nonblank":
+      return firstNonBlank(text, line);
+    case "doc-start":
+      return 0;
+    case "doc-end":
+      return text.length;
+    case "paragraph-forward": {
+      let pos = caret;
+      for (let i = 0; i < n; i++) {
+        pos = nextParagraphBoundary(lines, lineIndexAt(lines, pos), text.length);
+      }
+      return pos;
+    }
+    case "paragraph-back": {
+      let pos = caret;
+      for (let i = 0; i < n; i++) {
+        pos = prevParagraphBoundary(lines, lineIndexAt(lines, pos));
+      }
+      return pos;
+    }
+    case "match-bracket": {
+      const chAtCaret = text[caret];
+      if (chAtCaret !== void 0 && BRACKET_PARTNER[chAtCaret] !== void 0) {
+        const target = matchBracket(text, caret);
+        return target === null ? caret : target;
+      }
+      for (let i = caret; i < line.end; i++) {
+        if (BRACKET_PARTNER[text[i]] !== void 0) {
+          const target = matchBracket(text, i);
+          return target === null ? caret : target;
+        }
+      }
+      return caret;
+    }
+    case "line":
+    case "selection":
+      return caret;
+    default: {
+      const _exhaustive = motion;
+      return _exhaustive;
+    }
+  }
+}
+function motionRange(text, caret, motion, count, selection) {
+  if (motion === "selection") {
+    if (!selection) return [caret, caret];
+    return [Math.min(selection[0], selection[1]), Math.max(selection[0], selection[1])];
+  }
+  const lines = computeLines(text);
+  if (motion === "line") {
+    const n = Math.max(1, count);
+    const startIdx = lineIndexAt(lines, caret);
+    const endIdx = clamp(startIdx + n - 1, 0, lines.length - 1);
+    const start2 = lines[startIdx].start;
+    const rawEnd = lines[endIdx].end;
+    const end2 = rawEnd < text.length ? rawEnd + 1 : rawEnd;
+    return [start2, end2];
+  }
+  const newCaret = applyMotion(text, caret, motion, count);
+  let start = Math.min(caret, newCaret);
+  let end = Math.max(caret, newCaret);
+  if ((motion === "word-end" || motion === "line-end" || motion === "match-bracket") && newCaret !== caret) {
+    end = Math.min(Math.max(caret, newCaret) + 1, text.length);
+  } else if (motion === "word-forward" && newCaret > caret) {
+    const startLine = lineIndexAt(lines, caret);
+    const endLine = lineIndexAt(lines, newCaret);
+    if (endLine !== startLine) {
+      end = lines[startLine].end;
+    }
+  }
+  return [start, end];
+}
+function toggleCase(s) {
+  return s.replace(/[a-zA-Z]/g, (c) => c === c.toUpperCase() ? c.toLowerCase() : c.toUpperCase());
+}
+function applyJoin(text, caret, count, register, registerLinewise) {
+  const lines = computeLines(text);
+  const startIdx = lineIndexAt(lines, caret);
+  const n = Math.max(2, count);
+  const endIdx = clamp(startIdx + n - 1, 0, lines.length - 1);
+  if (endIdx <= startIdx) {
+    return { text, caret, register, registerLinewise };
+  }
+  const joinCaret = lines[startIdx].end;
+  let joined = text.slice(lines[startIdx].start, lines[startIdx].end);
+  for (let i = startIdx + 1; i <= endIdx; i++) {
+    const raw = text.slice(lines[i].start, lines[i].end);
+    joined += " " + raw.replace(/^[ \t]+/, "");
+  }
+  const newText = text.slice(0, lines[startIdx].start) + joined + text.slice(lines[endIdx].end);
+  return { text: newText, caret: joinCaret, register, registerLinewise };
+}
+function applyIndent(text, start, end, operator, register, registerLinewise) {
+  const lines = computeLines(text);
+  const startLineIdx = lineIndexAt(lines, start);
+  const lastTouchedPos = end > start ? end - 1 : start;
+  const endLineIdx = lineIndexAt(lines, lastTouchedPos);
+  let result = text;
+  for (let i = endLineIdx; i >= startLineIdx; i--) {
+    const lineStart = lines[i].start;
+    if (operator === "indent") {
+      result = result.slice(0, lineStart) + INDENT_UNIT + result.slice(lineStart);
+    } else if (result[lineStart] === "	") {
+      result = result.slice(0, lineStart) + result.slice(lineStart + 1);
+    } else {
+      let removeCount = 0;
+      while (removeCount < INDENT_UNIT.length && result[lineStart + removeCount] === " ") removeCount++;
+      result = result.slice(0, lineStart) + result.slice(lineStart + removeCount);
+    }
+  }
+  const newLines = computeLines(result);
+  const caret = firstNonBlank(result, newLines[startLineIdx]);
+  return { text: result, caret, register, registerLinewise };
+}
+function applyPut(text, caret, operator, register, registerLinewise, count) {
+  if (register.length === 0) {
+    return { text, caret, register, registerLinewise };
+  }
+  const content = register.repeat(count);
+  const lines = computeLines(text);
+  const line = lines[lineIndexAt(lines, caret)];
+  if (registerLinewise) {
+    if (operator === "put-before") {
+      const insertPos3 = line.start;
+      return {
+        text: text.slice(0, insertPos3) + content + text.slice(insertPos3),
+        caret: insertPos3,
+        register,
+        registerLinewise
+      };
+    }
+    const nextLineIdx = lineIndexAt(lines, caret) + 1;
+    if (nextLineIdx < lines.length) {
+      const insertPos3 = lines[nextLineIdx].start;
+      return {
+        text: text.slice(0, insertPos3) + content + text.slice(insertPos3),
+        caret: insertPos3,
+        register,
+        registerLinewise
+      };
+    }
+    const insertPos2 = text.length;
+    return {
+      text: text.slice(0, insertPos2) + "\n" + content,
+      caret: insertPos2 + 1,
+      register,
+      registerLinewise
+    };
+  }
+  const insertPos = operator === "put-before" ? clamp(caret, 0, text.length) : clamp(caret + 1, line.start, line.end);
+  return {
+    text: text.slice(0, insertPos) + content + text.slice(insertPos),
+    caret: insertPos + content.length - 1,
+    register,
+    registerLinewise
+  };
+}
+function applyOperator(input) {
+  const { text, caret, operator, motion, register, registerLinewise } = input;
+  const count = Math.max(1, input.count);
+  const start = clamp(input.range[0], 0, text.length);
+  const end = clamp(input.range[1], start, text.length);
+  switch (operator) {
+    case "yank":
+      return { text, caret: start, register: text.slice(start, end), registerLinewise: motion === "line" };
+    case "delete":
+    case "replace": {
+      const removed = text.slice(start, end);
+      return {
+        text: text.slice(0, start) + text.slice(end),
+        caret: start,
+        register: removed,
+        registerLinewise: motion === "line"
+      };
+    }
+    case "change": {
+      if (motion === "line") {
+        const hasTrailingNewline = end > start && text[end - 1] === "\n";
+        const removeEnd = hasTrailingNewline ? end - 1 : end;
+        const removed2 = text.slice(start, removeEnd);
+        return {
+          text: text.slice(0, start) + text.slice(removeEnd),
+          caret: start,
+          register: removed2,
+          registerLinewise: true
+        };
+      }
+      const removed = text.slice(start, end);
+      return {
+        text: text.slice(0, start) + text.slice(end),
+        caret: start,
+        register: removed,
+        registerLinewise: false
+      };
+    }
+    case "put":
+    case "put-before":
+      return applyPut(text, caret, operator, register, registerLinewise, count);
+    case "join":
+      return applyJoin(text, caret, count, register, registerLinewise);
+    case "toggle-case": {
+      const toggled = toggleCase(text.slice(start, end));
+      return { text: text.slice(0, start) + toggled + text.slice(end), caret: end, register, registerLinewise };
+    }
+    case "indent":
+    case "dedent":
+      return applyIndent(text, start, end, operator, register, registerLinewise);
+    case "undo":
+    case "redo":
+      return { text, caret, register, registerLinewise };
+    default: {
+      const _exhaustive = operator;
+      return _exhaustive;
+    }
+  }
+}
+
+// src/lib/lineDiff.ts
+var linesOf = (text) => text === "" ? [] : text.split("\n");
+function computeLineDiff(before, after) {
+  const a = linesOf(before);
+  const b = linesOf(after);
+  const ops = [];
+  diffRange(a, 0, a.length, b, 0, b.length, ops);
+  const out = [];
+  let bn = 1;
+  let an = 1;
+  for (const op of ops) {
+    if (op.type === "unchanged") out.push({ type: "unchanged", beforeLineNumber: bn++, afterLineNumber: an++, content: a[op.index] });
+    else if (op.type === "removed") out.push({ type: "removed", beforeLineNumber: bn++, content: a[op.index] });
+    else out.push({ type: "added", afterLineNumber: an++, content: b[op.index] });
+  }
+  return out;
+}
+function diffRange(a, aLo, aHi, b, bLo, bHi, ops) {
+  let prefix = 0;
+  while (aLo + prefix < aHi && bLo + prefix < bHi && a[aLo + prefix] === b[bLo + prefix]) prefix++;
+  for (let i = 0; i < prefix; i++) ops.push({ type: "unchanged", index: aLo + i });
+  aLo += prefix;
+  bLo += prefix;
+  let suffix = 0;
+  while (aHi - suffix > aLo && bHi - suffix > bLo && a[aHi - suffix - 1] === b[bHi - suffix - 1]) suffix++;
+  const tail = aHi - suffix;
+  aHi -= suffix;
+  bHi -= suffix;
+  if (aLo === aHi) for (let j = bLo; j < bHi; j++) ops.push({ type: "added", index: j });
+  else if (bLo === bHi) for (let i = aLo; i < aHi; i++) ops.push({ type: "removed", index: i });
+  else {
+    const [x, y, u, v] = middleSnake(a, aLo, aHi, b, bLo, bHi);
+    diffRange(a, aLo, x, b, bLo, y, ops);
+    for (let i = x; i < u; i++) ops.push({ type: "unchanged", index: i });
+    diffRange(a, u, aHi, b, v, bHi, ops);
+  }
+  for (let i = 0; i < suffix; i++) ops.push({ type: "unchanged", index: tail + i });
+}
+function middleSnake(a, aLo, aHi, b, bLo, bHi) {
+  const n = aHi - aLo;
+  const m = bHi - bLo;
+  const delta = n - m;
+  const odd = (delta & 1) !== 0;
+  const max = Math.ceil((n + m) / 2);
+  const offset = max + 1;
+  const forward = new Int32Array(2 * max + 3);
+  const backward = new Int32Array(2 * max + 3);
+  for (let d = 0; d <= max; d++) {
+    for (let k = -d; k <= d; k += 2) {
+      let x = k === -d || k !== d && forward[offset + k - 1] < forward[offset + k + 1] ? forward[offset + k + 1] : forward[offset + k - 1] + 1;
+      let y = x - k;
+      const x0 = x;
+      const y0 = y;
+      while (x < n && y < m && a[aLo + x] === b[bLo + y]) {
+        x++;
+        y++;
+      }
+      forward[offset + k] = x;
+      const kb = delta - k;
+      if (odd && kb >= -(d - 1) && kb <= d - 1 && x + backward[offset + kb] >= n) {
+        return [aLo + x0, bLo + y0, aLo + x, bLo + y];
+      }
+    }
+    for (let k = -d; k <= d; k += 2) {
+      let x = k === -d || k !== d && backward[offset + k - 1] < backward[offset + k + 1] ? backward[offset + k + 1] : backward[offset + k - 1] + 1;
+      let y = x - k;
+      const x0 = x;
+      const y0 = y;
+      while (x < n && y < m && a[aHi - 1 - x] === b[bHi - 1 - y]) {
+        x++;
+        y++;
+      }
+      backward[offset + k] = x;
+      const kf = delta - k;
+      if (!odd && kf >= -d && kf <= d && x + forward[offset + kf] >= n) {
+        return [aHi - x, bHi - y, aHi - x0, bHi - y0];
+      }
+    }
+  }
+  throw new Error("computeLineDiff: no middle snake \u2014 unreachable for differing texts");
+}
+function usePerfBuffer() {
+  return useSyncExternalStore(perfStore.subscribe, perfStore.getSnapshot, perfStore.getSnapshot);
+}
+var profilerOnRender = (id, phase, actualDuration, baseDuration, _startTime, commitTime) => {
+  pushPerfEntry({
+    name: `profiler:${id}:${phase}`,
+    durationMs: actualDuration,
+    ts: commitTime,
+    detail: { baseDuration }
+  });
+};
+
+// src/lib/lessonSegmentUtils.ts
+function parseMarkdownWithCodeBlocks(content) {
+  const segments = [];
+  const codeBlockRegex = /```([^\n\r]*)\r?\n([\s\S]*?)```/g;
+  let lastIndex = 0;
+  let match;
+  while ((match = codeBlockRegex.exec(content)) !== null) {
+    const before = content.slice(lastIndex, match.index);
+    if (before.trim()) {
+      segments.push({ type: "markdown", content: before });
+    }
+    const tokens = match[1].trim().split(/\s+/).filter(Boolean);
+    let rawLanguage = tokens[0] ?? "text";
+    const suffixRunnable = rawLanguage.endsWith("-runnable");
+    const runnable = suffixRunnable || tokens.includes("run");
+    const baseLanguage = suffixRunnable ? rawLanguage.slice(0, -"-runnable".length) || "text" : rawLanguage;
+    segments.push({ type: "code", language: baseLanguage, content: match[2].trim(), runnable });
+    lastIndex = codeBlockRegex.lastIndex;
+  }
+  const remaining = content.slice(lastIndex);
+  if (remaining.trim()) {
+    segments.push({ type: "markdown", content: remaining });
+  }
+  return segments;
+}
+function resolveImageUrl(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (isFileValue(value)) {
+    return value.url;
+  }
+  return void 0;
+}
+
+// src/lib/parseContentSegments.ts
+function tryParseOrbitalSchema(code) {
+  try {
+    const parsed = JSON.parse(code);
+    if (typeof parsed !== "object" || parsed === null) return null;
+    if ("states" in parsed && "transitions" in parsed || Array.isArray(parsed.orbitals)) {
+      return parsed;
+    }
+  } catch {
+  }
+  return null;
+}
+function parseMarkdownWithCodeBlocks2(content) {
+  if (!content) return [];
+  const segments = [];
+  const codeBlockRegex = /```(\w+)?\n([\s\S]*?)```/g;
+  let lastIndex = 0;
+  let match;
+  while ((match = codeBlockRegex.exec(content)) !== null) {
+    const before = content.slice(lastIndex, match.index);
+    if (before.trim()) {
+      segments.push({ type: "markdown", content: before });
+    }
+    const language = match[1] || "text";
+    const code = match[2].trim();
+    if (language === "json" || language === "orb") {
+      const schema = tryParseOrbitalSchema(code);
+      if (schema) {
+        segments.push({ type: "orbital", language, content: code, schema });
+        lastIndex = codeBlockRegex.lastIndex;
+        continue;
+      }
+    }
+    segments.push({ type: "code", language, content: code });
+    lastIndex = codeBlockRegex.lastIndex;
+  }
+  const remaining = content.slice(lastIndex);
+  if (remaining.trim()) {
+    segments.push({ type: "markdown", content: remaining });
+  }
+  return segments;
+}
+function parseContentSegments(content) {
+  if (!content) return [];
+  const segments = [];
+  const tagRegex = /<question>([\s\S]*?)<\/question>\s*<answer>([\s\S]*?)<\/answer>/gi;
+  let lastIndex = 0;
+  let match;
+  while ((match = tagRegex.exec(content)) !== null) {
+    const before = content.slice(lastIndex, match.index);
+    if (before.trim()) {
+      segments.push(...parseMarkdownWithCodeBlocks2(before));
+    }
+    segments.push({
+      type: "quiz",
+      question: match[1].trim(),
+      answer: match[2].trim()
+    });
+    lastIndex = tagRegex.lastIndex;
+  }
+  const remaining = content.slice(lastIndex);
+  if (remaining.trim()) {
+    segments.push(...parseMarkdownWithCodeBlocks2(remaining));
+  }
+  return segments;
+}
+var NAMESPACE = "almadar:ui:debug";
+var log = createLogger(NAMESPACE);
+var inputLog = createLogger("almadar:ui:debug:input");
+var collisionLog = createLogger("almadar:ui:debug:collision");
+var physicsLog = createLogger("almadar:ui:debug:physics");
+var gameStateLog = createLogger("almadar:ui:debug:game-state");
+function gateEnabled(level, ns = NAMESPACE) {
+  return isLogLevelEnabled(level, ns);
+}
+function isDebugEnabled() {
+  return gateEnabled("DEBUG");
+}
+function debug(...args) {
+  if (!gateEnabled("DEBUG")) return;
+  const [first, ...rest] = args;
+  const message = typeof first === "string" ? first : "<debug>";
+  if (rest.length === 0 && typeof first === "string") {
+    log.debug(message);
+  } else {
+    log.debug(message, { args: rest.length > 0 ? formatArgs(rest) : formatArgs([first]) });
+  }
+}
+function debugGroup(label) {
+  if (gateEnabled("DEBUG")) console.group(`[${NAMESPACE}] ${label}`);
+}
+function debugGroupEnd() {
+  if (gateEnabled("DEBUG")) console.groupEnd();
+}
+function debugWarn(...args) {
+  if (!gateEnabled("WARN")) return;
+  const [first, ...rest] = args;
+  const message = typeof first === "string" ? first : "<warn>";
+  log.warn(message, rest.length > 0 ? { args: formatArgs(rest) } : void 0);
+}
+function debugError(...args) {
+  if (!gateEnabled("ERROR")) return;
+  const [first, ...rest] = args;
+  const message = typeof first === "string" ? first : "<error>";
+  log.error(message, rest.length > 0 ? { args: formatArgs(rest) } : void 0);
+}
+function debugTable(data) {
+  if (gateEnabled("DEBUG")) console.table(data);
+}
+function debugTime(label) {
+  if (gateEnabled("DEBUG")) console.time(`[${NAMESPACE}] ${label}`);
+}
+function debugTimeEnd(label) {
+  if (gateEnabled("DEBUG")) console.timeEnd(`[${NAMESPACE}] ${label}`);
+}
+function debugInput(inputType, data) {
+  inputLog.debug(inputType, { data: formatArgs([data]) });
+}
+function debugCollision(entityA, entityB, details) {
+  collisionLog.debug("collision", () => ({
+    a: entityA.type ?? entityA.id ?? null,
+    b: entityB.type ?? entityB.id ?? null,
+    details: details === void 0 ? null : formatArgs([details])
+  }));
+}
+function debugPhysics(entityId, physics) {
+  physicsLog.debug("physics", { entityId, data: formatArgs([physics]) });
+}
+function debugGameState(stateName, value) {
+  gameStateLog.debug(stateName, { value: formatArgs([value]) });
+}
+function formatArgs(values) {
+  if (values.length === 1) return toLogMetaValue(values[0]);
+  return values.map(toLogMetaValue);
+}
+function toLogMetaValue(v) {
+  if (v === null || v === void 0) return v;
+  if (v instanceof Error) return v;
+  const t = typeof v;
+  if (t === "string" || t === "number" || t === "boolean") return v;
+  if (Array.isArray(v)) return v.map(toLogMetaValue);
+  if (t === "object") {
+    const out = {};
+    for (const [k, val] of Object.entries(v)) {
+      out[k] = toLogMetaValue(val);
+    }
+    return out;
+  }
+  return String(v);
+}
+
+// src/lib/traitRegistry.ts
+var traits = /* @__PURE__ */ new Map();
+var listeners = /* @__PURE__ */ new Set();
+function notifyListeners() {
+  listeners.forEach((listener) => listener());
+}
+function registerTrait(info) {
+  traits.set(info.id, info);
+  notifyListeners();
+}
+function updateTraitState(id, newState) {
+  const trait = traits.get(id);
+  if (trait) {
+    trait.currentState = newState;
+    trait.transitionCount++;
+    notifyListeners();
+  }
+}
+function updateGuardResult(traitId, guardName, result) {
+  const trait = traits.get(traitId);
+  if (trait) {
+    const guard = trait.guards.find((g) => g.name === guardName);
+    if (guard) {
+      guard.lastResult = result;
+      notifyListeners();
+    }
+  }
+}
+function unregisterTrait(id) {
+  traits.delete(id);
+  notifyListeners();
+}
+function getAllTraits() {
+  return Array.from(traits.values());
+}
+function getTrait(id) {
+  return traits.get(id);
+}
+function subscribeToTraitChanges(listener) {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+function clearTraits() {
+  traits.clear();
+  notifyListeners();
+}
+
+// src/lib/tickRegistry.ts
+var ticks = /* @__PURE__ */ new Map();
+var listeners2 = /* @__PURE__ */ new Set();
+function notifyListeners2() {
+  listeners2.forEach((listener) => listener());
+}
+function registerTick(tick) {
+  ticks.set(tick.id, tick);
+  notifyListeners2();
+}
+function updateTickExecution(id, timestamp) {
+  const tick = ticks.get(id);
+  if (tick) {
+    tick.lastExecuted = timestamp;
+    tick.nextExecution = timestamp + tick.interval;
+    tick.executionCount++;
+    notifyListeners2();
+  }
+}
+function setTickActive(id, isActive) {
+  const tick = ticks.get(id);
+  if (tick) {
+    tick.isActive = isActive;
+    notifyListeners2();
+  }
+}
+function unregisterTick(id) {
+  ticks.delete(id);
+  notifyListeners2();
+}
+function getAllTicks() {
+  return Array.from(ticks.values());
+}
+function getTick(id) {
+  return ticks.get(id);
+}
+function subscribeToTickChanges(listener) {
+  listeners2.add(listener);
+  return () => listeners2.delete(listener);
+}
+function clearTicks() {
+  ticks.clear();
+  notifyListeners2();
+}
+
+// src/lib/guardRegistry.ts
+var guardHistory = [];
+var listeners3 = /* @__PURE__ */ new Set();
+var MAX_HISTORY = 100;
+function notifyListeners3() {
+  listeners3.forEach((listener) => listener());
+}
+function recordGuardEvaluation(evaluation) {
+  const entry = {
+    ...evaluation,
+    id: `guard-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+    timestamp: Date.now()
+  };
+  guardHistory.unshift(entry);
+  if (guardHistory.length > MAX_HISTORY) {
+    guardHistory.pop();
+  }
+  notifyListeners3();
+}
+function getGuardHistory() {
+  return [...guardHistory];
+}
+function getRecentGuardEvaluations(count) {
+  return guardHistory.slice(0, count);
+}
+function getGuardEvaluationsForTrait(traitName) {
+  return guardHistory.filter((g) => g.traitName === traitName);
+}
+function subscribeToGuardChanges(listener) {
+  listeners3.add(listener);
+  return () => listeners3.delete(listener);
+}
+function clearGuardHistory() {
+  guardHistory.length = 0;
+  notifyListeners3();
+}
+
+// src/lib/entityDebug.ts
+var entityProvider = null;
+function setEntityProvider(provider) {
+  entityProvider = provider;
+}
+function clearEntityProvider() {
+  entityProvider = null;
+}
+function getEntitySnapshot() {
+  if (!entityProvider) {
+    return null;
+  }
+  const entities = entityProvider();
+  return {
+    entities,
+    timestamp: Date.now(),
+    totalCount: entities.length,
+    singletons: {},
+    runtime: entities.map((e) => ({ id: e.id, type: e.type, data: e.fields })),
+    persistent: {}
+  };
+}
+function getEntityById(id) {
+  if (!entityProvider) {
+    return void 0;
+  }
+  return entityProvider().find((e) => e.id === id);
+}
+function getEntitiesByType(type) {
+  if (!entityProvider) {
+    return [];
+  }
+  return entityProvider().filter((e) => e.type === type);
+}
+
+// src/lib/debugRegistry.ts
+var events = [];
+var listeners4 = /* @__PURE__ */ new Set();
+var MAX_EVENTS = 500;
+function notifyListeners4() {
+  listeners4.forEach((listener) => listener());
+}
+function logDebugEvent(type, source, message, data) {
+  const event = {
+    id: `event-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+    type,
+    source,
+    message,
+    data,
+    timestamp: Date.now()
+  };
+  events.unshift(event);
+  if (events.length > MAX_EVENTS) {
+    events.pop();
+  }
+  notifyListeners4();
+}
+function logStateChange(source, from, to, event) {
+  logDebugEvent("state-change", source, `${from} \u2192 ${to}`, { from, to, event: event ?? null });
+}
+function logEventFired(source, eventName, payload) {
+  logDebugEvent("event-fired", source, eventName, { eventName, payload: payload ?? null });
+}
+function logEffectExecuted(source, effectType, details) {
+  logDebugEvent("effect-executed", source, effectType, { effectType, details: details ?? null });
+}
+function logError(source, message, error) {
+  logDebugEvent("error", source, message, { error: error?.message ?? null });
+}
+function logWarning(source, message, data) {
+  logDebugEvent("warning", source, message, data);
+}
+function logInfo(source, message, data) {
+  logDebugEvent("info", source, message, data);
+}
+function getDebugEvents() {
+  return [...events];
+}
+function getRecentEvents(count) {
+  return events.slice(0, count);
+}
+function getEventsByType(type) {
+  return events.filter((e) => e.type === type);
+}
+function getEventsBySource(source) {
+  return events.filter((e) => e.source === source);
+}
+function subscribeToDebugEvents(listener) {
+  listeners4.add(listener);
+  return () => listeners4.delete(listener);
+}
+function clearDebugEvents() {
+  events.length = 0;
+  notifyListeners4();
+}
+
+// src/lib/debugUtils.ts
+var DEBUG_STORAGE_KEY = "orbital-debug";
+var listeners5 = /* @__PURE__ */ new Set();
+function isDebugEnabled2() {
+  if (typeof window === "undefined") return false;
+  return localStorage.getItem(DEBUG_STORAGE_KEY) === "true";
+}
+function setDebugEnabled(enabled) {
+  if (typeof window === "undefined") return;
+  localStorage.setItem(DEBUG_STORAGE_KEY, String(enabled));
+  listeners5.forEach((listener) => listener(enabled));
+}
+function toggleDebug() {
+  const newValue = !isDebugEnabled2();
+  setDebugEnabled(newValue);
+  return newValue;
+}
+function onDebugToggle(listener) {
+  listeners5.add(listener);
+  return () => listeners5.delete(listener);
+}
+function initDebugShortcut() {
+  if (typeof window === "undefined") return () => {
+  };
+  const handleKeyDown = (e) => {
+    if (e.ctrlKey && e.shiftKey && e.key === "D") {
+      e.preventDefault();
+      toggleDebug();
+    }
+  };
+  window.addEventListener("keydown", handleKeyDown);
+  return () => window.removeEventListener("keydown", handleKeyDown);
+}
+
+// src/lib/parseLessonSegments.ts
+function extractTagContent(content, tagName) {
+  const closedTagRegex = new RegExp(`<${tagName}>([\\s\\S]*?)<\\/${tagName}>`, "i");
+  const closedMatch = content.match(closedTagRegex);
+  if (closedMatch) {
+    return { content: closedMatch[1].trim(), fullMatch: closedMatch[0] };
+  }
+  const unclosedTagRegex = new RegExp(
+    `<${tagName}>([\\s\\S]*?)(?=<(?:activate|connect|reflect|bloom|prq|question|answer|visualize)|\\n\\n#|$)`,
+    "i"
+  );
+  const unclosedMatch = content.match(unclosedTagRegex);
+  if (unclosedMatch) {
+    return { content: unclosedMatch[1].trim(), fullMatch: unclosedMatch[0] };
+  }
+  return null;
+}
+function parseLessonSegments(lesson) {
+  if (!lesson) return [];
+  let content = lesson.replace(/<prq>[\s\S]*?<\/prq>/gi, "").trim();
+  const segments = [];
+  const activateResult = extractTagContent(content, "activate");
+  if (activateResult) {
+    segments.push({ type: "activate", question: activateResult.content });
+    content = content.replace(activateResult.fullMatch, "").trim();
+  }
+  const connectResult = extractTagContent(content, "connect");
+  if (connectResult) {
+    segments.push({ type: "connect", content: connectResult.content });
+    content = content.replace(connectResult.fullMatch, "").trim();
+  }
+  const tagRegex = new RegExp(
+    '(?<reflect><reflect>(?<reflectClosed>[\\s\\S]*?)<\\/reflect>)|(?<reflectUnclosed><reflect>(?<reflectOpen>[\\s\\S]*?)(?=<(?:activate|connect|reflect|bloom|prq|question|answer|visualize)|\\n\\n#|$))|(?<bloom><bloom\\s+level="(?<bloomLevel>remember|understand|apply|analyze|evaluate|create)">(?<bloomClosed>[\\s\\S]*?)<\\/bloom>)|(?<bloomUnclosed><bloom\\s+level="(?<bloomLevelUn>remember|understand|apply|analyze|evaluate|create)">(?<bloomOpen>[\\s\\S]*?)(?=<(?:activate|connect|reflect|bloom|prq|question|answer|visualize)|\\n\\n#|$))|(?<quiz><question>(?<quizQuestion>[\\s\\S]*?)<\\/question>\\s*<answer>(?<quizAnswer>[\\s\\S]*?)<\\/answer>)|(?<visualize><visualize\\s+type="(?<vizType>algorithms|math|physics|biology|chemistry|probability)"\\s+description="(?<vizDesc>[^"]*?)"\\s*\\/?>)',
+    "gi"
+  );
+  let lastIndex = 0;
+  let match;
+  while ((match = tagRegex.exec(content)) !== null) {
+    const before = content.slice(lastIndex, match.index);
+    if (before.trim()) {
+      segments.push(...parseMarkdownWithCodeBlocks(before));
+    }
+    const g = match.groups ?? {};
+    if (g.reflect || g.reflectUnclosed) {
+      const prompt = (g.reflectClosed ?? g.reflectOpen ?? "").trim();
+      if (prompt) segments.push({ type: "reflect", prompt });
+    } else if (g.bloom || g.bloomUnclosed) {
+      const level = g.bloomLevel ?? g.bloomLevelUn;
+      const bloomContent = g.bloomClosed ?? g.bloomOpen ?? "";
+      if (level && bloomContent) {
+        const qMatch = bloomContent.match(/<question>([\s\S]*?)<\/question>/i);
+        const aMatch = bloomContent.match(/<answer>([\s\S]*?)<\/answer>/i);
+        if (qMatch && aMatch) {
+          segments.push({ type: "bloom", level, question: qMatch[1].trim(), answer: aMatch[1].trim() });
+        } else if (qMatch) {
+          segments.push({ type: "bloom", level, question: qMatch[1].trim(), answer: "(Answer not provided)" });
+        } else {
+          const clean = bloomContent.replace(/^\*\*Question\s*\d*:?\*\*\s*/i, "").replace(/^\*\*Q\d*:?\*\*\s*/i, "").trim();
+          if (clean) segments.push({ type: "bloom", level, question: clean, answer: "(See answers section below)" });
+        }
+      }
+    } else if (g.quiz) {
+      segments.push({ type: "quiz", question: g.quizQuestion.trim(), answer: g.quizAnswer.trim() });
+    } else if (g.visualize) {
+      segments.push({
+        type: "visualization",
+        visualizationType: g.vizType,
+        description: g.vizDesc ?? ""
+      });
+    }
+    lastIndex = tagRegex.lastIndex;
+  }
+  const remaining = content.slice(lastIndex);
+  if (remaining.trim()) segments.push(...parseMarkdownWithCodeBlocks(remaining));
+  return segments;
+}
+
+export { EDITOR_MOTIONS, EDITOR_OPERATORS, ENTER_SLOT_CLASS, INDENT_UNIT, MAX_ENTER_DELAY, applyMotion, applyOperator, asEnterAnimation, clearDebugEvents, clearEntityProvider, clearGuardHistory, clearTicks, clearTraits, computeLineDiff, debug, debugCollision, debugError, debugGameState, debugGroup, debugGroupEnd, debugInput, debugPhysics, debugTable, debugTime, debugTimeEnd, debugWarn, enterClassName, getAllTicks, getAllTraits, getDebugEvents, getEntitiesByType, getEntityById, getEntitySnapshot, getEventsBySource, getEventsByType, getGuardEvaluationsForTrait, getGuardHistory, getRecentEvents, getRecentGuardEvaluations, getTick, getTrait, initDebugShortcut, isDebugEnabled, isDebugEnabled2, isEditorMotion, isEditorOperator, logDebugEvent, logEffectExecuted, logError, logEventFired, logInfo, logStateChange, logWarning, motionRange, onDebugToggle, parseContentSegments, parseLessonSegments, parseMarkdownWithCodeBlocks, parseMarkdownWithCodeBlocks2, profilerOnRender, recordGuardEvaluation, registerTick, registerTrait, resolveImageUrl, setDebugEnabled, setEntityProvider, setTickActive, slotPlaysDefaultEnter, subscribeToDebugEvents, subscribeToGuardChanges, subscribeToTickChanges, subscribeToTraitChanges, toggleDebug, unregisterTick, unregisterTrait, updateGuardResult, updateTickExecution, updateTraitState, usePerfBuffer, useSlotEnterRestart };