next-live 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1265 @@
+"use client";
+'use strict';
+
+var React = require('react');
+var JsxRuntime = require('react/jsx-runtime');
+var JsxDevRuntime = require('react/jsx-dev-runtime');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+var JsxRuntime__namespace = /*#__PURE__*/_interopNamespace(JsxRuntime);
+var JsxDevRuntime__namespace = /*#__PURE__*/_interopNamespace(JsxDevRuntime);
+
+var CONTEXT_KEY = /* @__PURE__ */ Symbol.for("next-live.LiveContext");
+function createLiveContext() {
+  const store = globalThis;
+  const existing = store[CONTEXT_KEY];
+  if (existing) return existing;
+  const context = React.createContext(null);
+  context.displayName = "LiveContext";
+  store[CONTEXT_KEY] = context;
+  return context;
+}
+var LiveContext = createLiveContext();
+
+// src/core/builtin-specifiers.ts
+var BUILTIN_SPECIFIERS = [
+  "react",
+  "react/jsx-runtime",
+  "react/jsx-dev-runtime"
+];
+
+// src/core/builtins.ts
+var builtinModules = {
+  [BUILTIN_SPECIFIERS[0]]: React__namespace,
+  [BUILTIN_SPECIFIERS[1]]: JsxRuntime__namespace,
+  [BUILTIN_SPECIFIERS[2]]: JsxDevRuntime__namespace
+};
+
+// src/core/errors.ts
+var LiveError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = new.target.name;
+    if (options?.cause !== void 0) this.cause = options.cause;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var LiveCompileError = class extends LiveError {
+  line;
+  column;
+  constructor(message, position, cause) {
+    super(message, { cause });
+    this.line = position?.line;
+    this.column = position?.column;
+  }
+};
+var LiveRuntimeError = class extends LiveError {
+};
+var RenderLoopError = class extends LiveRuntimeError {
+};
+var ModuleNotFoundError = class extends LiveError {
+  constructor(specifier, available) {
+    super(buildModuleNotFoundMessage(specifier, available));
+    this.specifier = specifier;
+    this.available = available;
+  }
+  specifier;
+  available;
+};
+var NoComponentError = class extends LiveError {
+};
+var TranspilerLoadError = class extends LiveError {
+  constructor(cause) {
+    super(
+      "next-live could not load its transpiler (sucrase). This is usually a network or code-splitting failure - check that the chunk is reachable.",
+      { cause }
+    );
+  }
+};
+var MAX_LISTED = 12;
+function buildModuleNotFoundMessage(specifier, available) {
+  const lines = [`Module '${specifier}' is not registered in the next-live scope.`];
+  const suggestion = nearestSpecifier(specifier, available);
+  if (suggestion) lines.push("", `Did you mean '${suggestion}'?`);
+  if (available.length > 0) {
+    const sorted = [...available].sort();
+    const shown = sorted.slice(0, MAX_LISTED);
+    const rest = sorted.length - shown.length;
+    lines.push(
+      "",
+      `Registered modules (${sorted.length}): ${shown.join(", ")}` + (rest > 0 ? `, \u2026and ${rest} more` : "")
+    );
+  } else {
+    lines.push("", "No modules are registered.");
+  }
+  if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
+    lines.push(
+      "",
+      "next-live does not bundle npm packages - pass them in explicitly:",
+      `  <LiveProvider modules={{ '${specifier}': theModule }} />`
+    );
+  }
+  return lines.join("\n");
+}
+function nearestSpecifier(specifier, available) {
+  const lower = specifier.toLowerCase();
+  const caseMatch = available.find((key) => key.toLowerCase() === lower);
+  if (caseMatch) return caseMatch;
+  const threshold = Math.max(1, Math.min(3, Math.floor(specifier.length / 3)));
+  let best;
+  let bestDistance = threshold + 1;
+  for (const key of available) {
+    if (Math.abs(key.length - specifier.length) > threshold) continue;
+    const distance = editDistance(lower, key.toLowerCase(), bestDistance);
+    if (distance < bestDistance) {
+      bestDistance = distance;
+      best = key;
+    }
+  }
+  return bestDistance <= threshold ? best : void 0;
+}
+function editDistance(a, b, limit) {
+  if (a === b) return 0;
+  let previous = new Array(b.length + 1);
+  let current = new Array(b.length + 1);
+  for (let j = 0; j <= b.length; j++) previous[j] = j;
+  for (let i = 1; i <= a.length; i++) {
+    current[0] = i;
+    let rowMin = i;
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a.charCodeAt(i - 1) === b.charCodeAt(j - 1) ? 0 : 1;
+      const value = Math.min(
+        current[j - 1] + 1,
+        previous[j] + 1,
+        previous[j - 1] + cost
+      );
+      current[j] = value;
+      if (value < rowMin) rowMin = value;
+    }
+    if (rowMin > limit) return limit + 1;
+    const swap = previous;
+    previous = current;
+    current = swap;
+  }
+  return previous[b.length];
+}
+
+// src/core/transpile.ts
+var transpilerPromise = null;
+function loadTranspiler() {
+  if (transpilerPromise === null) {
+    transpilerPromise = import('sucrase').catch((cause) => {
+      transpilerPromise = null;
+      throw new TranspilerLoadError(cause);
+    });
+  }
+  return transpilerPromise;
+}
+function preloadTranspiler() {
+  void loadTranspiler().catch(() => {
+  });
+}
+function setTranspiler(module) {
+  transpilerPromise = module === null ? null : Promise.resolve(module);
+}
+var defaultTranspileOptions = {
+  filePath: "LiveCode.tsx",
+  production: true,
+  jsxRuntime: "automatic",
+  jsxImportSource: "react"
+};
+var MODULE_SYNTAX_RE = /^[ \t]*(?:export\b|import\s*[({'"*]|import\s+[A-Za-z_$])/m;
+var RENDER_CALL_RE = /(^|[^.\w$])render\s*\(/m;
+function isModuleSource(source) {
+  return MODULE_SYNTAX_RE.test(source) || RENDER_CALL_RE.test(source);
+}
+function isBlankSource(source) {
+  const withoutComments = source.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/^[ \t]*\/\/.*$/gm, " ");
+  return withoutComments.trim() === "";
+}
+function sucraseOptions(options) {
+  return {
+    transforms: ["jsx", "typescript", "imports"],
+    jsxRuntime: options.jsxRuntime,
+    jsxImportSource: options.jsxImportSource,
+    production: options.production,
+    filePath: options.filePath,
+    // Leaving native `import()` intact would resolve against the *page* URL
+    // and 404 on './utils'; routing it through our shim is the only sane
+    // behaviour inside an evaluated snippet.
+    preserveDynamicImport: false
+  };
+}
+function runTranspile(transformFn, source, options) {
+  const opts = sucraseOptions(options);
+  if (!isModuleSource(source) && !isBlankSource(source)) {
+    try {
+      return {
+        code: transformFn(`export default (
+${source}
+)`, opts).code,
+        linePrefixOffset: 1,
+        expression: true
+      };
+    } catch {
+    }
+  }
+  return { code: transformFn(source, opts).code, linePrefixOffset: 0, expression: false };
+}
+async function transpile(source, options = {}, transform) {
+  const resolved = { ...defaultTranspileOptions, ...options };
+  if (transform) return transform(source, resolved);
+  const { transform: sucraseTransform } = await loadTranspiler();
+  try {
+    return runTranspile(sucraseTransform, source, resolved);
+  } catch (cause) {
+    throw toCompileError(cause);
+  }
+}
+function toCompileError(cause) {
+  const message = cause instanceof Error ? cause.message : String(cause);
+  const match = /\((\d+):(\d+)\)\s*$/.exec(message);
+  if (!match) return new LiveCompileError(message, void 0, cause);
+  return new LiveCompileError(
+    message.slice(0, match.index).trim(),
+    { line: Number(match[1]), column: Number(match[2]) },
+    cause
+  );
+}
+function scanTopLevelDeclarations(code) {
+  const names = [];
+  const patterns = [
+    /(?:^|;)\s*(?:async\s+)?function\s*\*?\s*([A-Za-z_$][\w$]*)/gm,
+    /(?:^|;)\s*class\s+([A-Za-z_$][\w$]*)/gm,
+    /(?:^|;)\s*(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=/gm
+  ];
+  for (const pattern of patterns) {
+    let match;
+    while ((match = pattern.exec(code)) !== null) {
+      const name = match[1];
+      if (name !== void 0 && !names.includes(name)) names.push(name);
+    }
+  }
+  return names;
+}
+function precompiledTransform(result) {
+  return () => result;
+}
+
+// src/core/evaluate.ts
+var RESERVED = /* @__PURE__ */ new Set(["module", "exports", "require", "React", "render", "__liveTick"]);
+var JS_RESERVED_WORDS = /* @__PURE__ */ new Set([
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "enum",
+  "export",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "import",
+  "in",
+  "instanceof",
+  "new",
+  "null",
+  "return",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with",
+  "yield",
+  "let",
+  "static",
+  "implements",
+  "interface",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "arguments",
+  "eval"
+]);
+var IDENTIFIER_RE = /^[A-Za-z_$][\w$]*$/;
+function usableScopeKeys(scope) {
+  const keys = [];
+  for (const key of Object.keys(scope)) {
+    if (!IDENTIFIER_RE.test(key) || JS_RESERVED_WORDS.has(key)) {
+      warn(`next-live: scope key ${JSON.stringify(key)} is not a valid identifier and was skipped.`);
+      continue;
+    }
+    if (RESERVED.has(key)) {
+      warn(`next-live: scope key "${key}" is reserved by next-live and was skipped.`);
+      continue;
+    }
+    keys.push(key);
+  }
+  return keys.sort();
+}
+function warn(message) {
+  if (typeof console !== "undefined") console.warn(message);
+}
+function evaluate(options) {
+  const { exports, rendered, recovered } = runModule(options);
+  return pickRenderable(exports, rendered, recovered);
+}
+function runModule(options) {
+  const { code, filePath, require: requireFn, scope, liveTick } = options;
+  const tick = liveTick ?? (code.includes("__liveTick") ? () => {
+  } : void 0);
+  const scopeKeys = usableScopeKeys(scope);
+  const epilogue = buildEpilogue(code);
+  const body = `${code}
+${epilogue}
+//# sourceURL=next-live:///${filePath}`;
+  const moduleObject = {
+    exports: /* @__PURE__ */ Object.create(null)
+  };
+  let rendered;
+  let didRender = false;
+  const render = (node) => {
+    rendered = node;
+    didRender = true;
+  };
+  const paramNames = ["module", "exports", "require", "React", "render"];
+  const paramValues = [
+    moduleObject,
+    moduleObject.exports,
+    requireFn,
+    React__namespace,
+    render
+  ];
+  if (tick) {
+    paramNames.push("__liveTick");
+    paramValues.push(tick);
+  }
+  paramNames.push(...scopeKeys);
+  paramValues.push(...scopeKeys.map((key) => scope[key]));
+  let factory;
+  try {
+    factory = new Function(...paramNames, body);
+  } catch (cause) {
+    if (isCspEvalBlock(cause)) throw cspError(cause);
+    throw new LiveRuntimeError(
+      cause instanceof Error ? cause.message : String(cause),
+      { cause }
+    );
+  }
+  factory(...paramValues);
+  return {
+    exports: moduleObject.exports,
+    ...didRender ? { rendered: { rendered } } : {},
+    ...moduleObject.__nextLiveRecovered === true ? { recovered: true } : {}
+  };
+}
+function buildEpilogue(code) {
+  if (/\bexports\./.test(code)) return "";
+  const declarations = scanTopLevelDeclarations(code);
+  if (declarations.length === 0) return "";
+  const ranked = rankCandidates(declarations);
+  return ranked.map(
+    (name) => `;if(!('default' in exports)){try{if(typeof ${name}!=='undefined'){exports.default=${name};module.__nextLiveRecovered=true}}catch(e){}}`
+  ).join("");
+}
+var PREFERRED_NAMES = ["App", "Component", "Main", "Demo", "Example", "Page"];
+function rankCandidates(names) {
+  const preferred = names.filter((name) => PREFERRED_NAMES.includes(name));
+  const pascal = names.filter(
+    (name) => !preferred.includes(name) && /^[A-Z]/.test(name)
+  );
+  const rest = names.filter(
+    (name) => !preferred.includes(name) && !pascal.includes(name)
+  );
+  return [...preferred, ...pascal.reverse(), ...rest.reverse()];
+}
+function pickRenderable(exports, renderCall, recovered) {
+  if (renderCall) {
+    const found = asRenderable(renderCall.rendered);
+    if (found) return { renderable: found, via: "render()" };
+    throw new NoComponentError(
+      "render() was called with something React cannot render."
+    );
+  }
+  const asCommonJs = asRenderable(exports);
+  if (asCommonJs) return { renderable: asCommonJs, via: "module.exports" };
+  const defaultExport = exports["default"];
+  if (defaultExport !== void 0) {
+    const found = asRenderable(defaultExport);
+    if (found) return { renderable: found, via: recovered ? "declaration" : "export default" };
+    throw new NoComponentError(
+      `The default export is ${describe(defaultExport)}, which React cannot render. Export a component or an element instead.`
+    );
+  }
+  const named = Object.keys(exports).filter((key) => key !== "__esModule");
+  const renderableNames = named.filter((key) => asRenderable(exports[key]) !== null);
+  if (renderableNames.length === 1) {
+    const only = renderableNames[0];
+    return { renderable: asRenderable(exports[only]), via: "named export" };
+  }
+  if (renderableNames.length > 1) {
+    const preferred = PREFERRED_NAMES.find((name) => renderableNames.includes(name));
+    if (preferred) {
+      return {
+        renderable: asRenderable(exports[preferred]),
+        via: "named export"
+      };
+    }
+    throw new NoComponentError(
+      `Several components were exported (${renderableNames.join(", ")}) and none is the default. Add \`export default\` to the one you want rendered.`
+    );
+  }
+  throw new NoComponentError(
+    named.length > 0 ? `Nothing renderable was exported. Found: ${named.join(", ")}. Add \`export default YourComponent\`.` : "The snippet did not produce a component. Add `export default YourComponent`, or end the snippet with a single JSX expression."
+  );
+}
+function describe(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "an array";
+  return `a ${typeof value}`;
+}
+function asRenderable(value) {
+  if (isReactElement(value)) return { kind: "element", element: value };
+  if (isRenderableComponent(value)) {
+    return { kind: "component", component: value };
+  }
+  return null;
+}
+var symbolFor = (name) => typeof Symbol === "function" && Symbol.for ? Symbol.for(name) : name;
+var COMPONENT_TYPES = /* @__PURE__ */ new Set([
+  symbolFor("react.memo"),
+  symbolFor("react.forward_ref"),
+  symbolFor("react.lazy"),
+  symbolFor("react.provider"),
+  symbolFor("react.context"),
+  symbolFor("react.suspense"),
+  symbolFor("react.suspense_list"),
+  symbolFor("react.fragment"),
+  symbolFor("react.profiler"),
+  symbolFor("react.client.reference")
+]);
+var ELEMENT_TYPES = /* @__PURE__ */ new Set([
+  symbolFor("react.transitional.element"),
+  // React 19
+  symbolFor("react.element"),
+  // React 18 and interop
+  symbolFor("react.portal")
+]);
+function isRenderableComponent(value) {
+  if (typeof value === "function") return true;
+  if (typeof value !== "object" || value === null) return false;
+  return COMPONENT_TYPES.has(value.$$typeof);
+}
+function isReactElement(value) {
+  if (typeof value !== "object" || value === null) return false;
+  return ELEMENT_TYPES.has(value.$$typeof);
+}
+function isCspEvalBlock(cause) {
+  if (cause instanceof EvalError) return true;
+  const message = cause instanceof Error ? cause.message : String(cause);
+  return /unsafe-eval|Refused to evaluate|call to eval/i.test(message);
+}
+function cspError(cause) {
+  return new LiveCompileError(
+    "next-live could not evaluate this snippet: the page's Content Security Policy blocks eval.\n\nAdd 'unsafe-eval' to script-src for the routes that run snippets (in proxy.ts). This is expected - next-live compiles code at runtime, so there is no way around the directive.\n\nNote that 'unsafe-eval' does not allow loading external scripts, and it does not need to apply to your whole application.",
+    void 0,
+    cause
+  );
+}
+
+// src/core/inject-render-budget.ts
+function injectRenderBudgetTick(source) {
+  let out = source;
+  out = out.replace(
+    /export\s+default\s+function\s+(\w*)\s*\([^)]*\)\s*\{/g,
+    (match) => `${match}
+  __liveTick();`
+  );
+  out = out.replace(
+    /export\s+default\s*(?:async\s+)?(?:function\s*)?\([^)]*\)\s*=>\s*\{/g,
+    (match) => `${match}
+  __liveTick();`
+  );
+  out = out.replace(
+    /^export\s+function\s+([A-Z]\w*)\s*\([^)]*\)\s*\{/gm,
+    (match) => `${match}
+  __liveTick();`
+  );
+  return out;
+}
+
+// src/core/resolver.ts
+var NORMALIZED = /* @__PURE__ */ Symbol.for("next-live.normalized");
+var LOADER = /* @__PURE__ */ Symbol.for("next-live.loader");
+var ASSET_RE = /\.(css|scss|sass|less|styl|svg|png|jpe?g|gif|webp|avif|woff2?)$/i;
+function defineLoader(load) {
+  return Object.defineProperty(load, LOADER, { value: true });
+}
+function isLoader(value) {
+  return typeof value === "function" && value[LOADER] === true;
+}
+function defineModule(shape) {
+  const record = /* @__PURE__ */ Object.create(null);
+  Object.defineProperty(record, "__esModule", { value: true });
+  Object.defineProperty(record, NORMALIZED, { value: true });
+  const defaultExport = "default" in shape ? shape.default : shape.exports?.["default"];
+  Object.defineProperty(record, "default", { value: defaultExport, enumerable: true });
+  for (const [key, value] of Object.entries(shape.exports ?? {})) {
+    if (key === "default") continue;
+    Object.defineProperty(record, key, { value, enumerable: true });
+  }
+  return record;
+}
+function normalizeModule(value) {
+  if (isNormalized(value)) return value;
+  if (value === null || value === void 0) {
+    return defineModule({ default: value });
+  }
+  if (typeof value !== "object" && typeof value !== "function") {
+    return defineModule({ default: value });
+  }
+  const source = value;
+  const record = /* @__PURE__ */ Object.create(null);
+  Object.defineProperty(record, "__esModule", { value: true });
+  Object.defineProperty(record, NORMALIZED, { value: true });
+  const defaultExport = "default" in source ? source["default"] : source;
+  Object.defineProperty(record, "default", {
+    get: () => defaultExport,
+    enumerable: true,
+    configurable: true
+  });
+  for (const key of ownEnumerableKeys(source)) {
+    if (key === "default" || key === "__esModule") continue;
+    Object.defineProperty(record, key, {
+      get: () => source[key],
+      enumerable: true,
+      configurable: true
+    });
+  }
+  return record;
+}
+function isNormalized(value) {
+  return typeof value === "object" && value !== null && value[NORMALIZED] === true;
+}
+function ownEnumerableKeys(source) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const key of Object.keys(source)) keys.add(key);
+  for (const key in source) keys.add(key);
+  return [...keys];
+}
+async function resolveModules(options) {
+  const { registry, specifiers, resolveSubpaths = false, signal } = options;
+  const resolved = /* @__PURE__ */ new Map();
+  const pending = [];
+  for (const specifier of specifiers) {
+    if (resolved.has(specifier)) continue;
+    const found = lookup(registry, specifier, resolveSubpaths);
+    if (found === MISSING) {
+      if (ASSET_RE.test(specifier)) resolved.set(specifier, defineModule({}));
+      continue;
+    }
+    if (isLoader(found)) {
+      pending.push(
+        Promise.resolve(found(specifier)).then((value) => {
+          resolved.set(specifier, normalizeModule(value));
+        })
+      );
+    } else {
+      resolved.set(specifier, normalizeModule(found));
+    }
+  }
+  if (pending.length > 0) await Promise.all(pending);
+  signal?.throwIfAborted();
+  const keys = Object.keys(registry);
+  return {
+    get: (specifier) => resolved.get(specifier),
+    keys
+  };
+}
+var MISSING = /* @__PURE__ */ Symbol("missing");
+function lookup(registry, specifier, resolveSubpaths) {
+  if (Object.prototype.hasOwnProperty.call(registry, specifier)) {
+    return registry[specifier];
+  }
+  let bestPrefix;
+  for (const key of Object.keys(registry)) {
+    if (!key.endsWith("/")) continue;
+    if (!specifier.startsWith(key)) continue;
+    if (bestPrefix === void 0 || key.length > bestPrefix.length) bestPrefix = key;
+  }
+  if (bestPrefix !== void 0) {
+    return registry[bestPrefix];
+  }
+  if (resolveSubpaths) {
+    const walked = walkSubpath(registry, specifier);
+    if (walked !== MISSING) return walked;
+  }
+  return MISSING;
+}
+function walkSubpath(registry, specifier) {
+  let base;
+  for (const key of Object.keys(registry)) {
+    if (!specifier.startsWith(key + "/")) continue;
+    if (base === void 0 || key.length > base.length) base = key;
+  }
+  if (base === void 0) return MISSING;
+  let current = registry[base];
+  if (isLoader(current)) return MISSING;
+  for (const segment of specifier.slice(base.length + 1).split("/")) {
+    if (current === null || current === void 0) return MISSING;
+    if (typeof current !== "object" && typeof current !== "function") return MISSING;
+    const next = current[segment];
+    if (next === void 0) return MISSING;
+    current = next;
+  }
+  return current;
+}
+function createRequire(resolved) {
+  return function require2(specifier) {
+    const found = resolved.get(specifier);
+    if (found === void 0) {
+      throw new ModuleNotFoundError(specifier, resolved.keys);
+    }
+    return found;
+  };
+}
+function scanRequires(code) {
+  const found = /* @__PURE__ */ new Set();
+  const re = /\brequire\s*\(\s*(['"])((?:(?!\1)[^\\]|\\.)*)\1\s*\)/g;
+  let match;
+  while ((match = re.exec(code)) !== null) {
+    const specifier = match[2];
+    if (specifier) found.add(specifier);
+  }
+  return found;
+}
+
+// src/core/stacks.ts
+var cachedOffset = null;
+function getFunctionLineOffset() {
+  if (cachedOffset !== null) return cachedOffset;
+  cachedOffset = 2;
+  try {
+    new Function('throw new Error("next-live-probe")')();
+  } catch (error) {
+    const line = firstFrameLine(error);
+    if (line !== null) cachedOffset = line - 1;
+  }
+  return cachedOffset;
+}
+var FRAME_PATTERNS = [
+  /(?::|@)(\d+):(\d+)\)?\s*$/
+  // V8 "at x (file:LINE:COL)" and SpiderMonkey "x@file:LINE:COL"
+];
+function firstFrameLine(error) {
+  const stack = error instanceof Error ? error.stack : void 0;
+  if (!stack) return null;
+  for (const raw of stack.split("\n").slice(1)) {
+    for (const pattern of FRAME_PATTERNS) {
+      const match = pattern.exec(raw.trim());
+      if (match?.[1]) return Number(match[1]);
+    }
+  }
+  return null;
+}
+function mapPosition(position, meta) {
+  if (meta.generatedLineCount !== meta.sourceLineCount + meta.linePrefixOffset * 2) {
+    return null;
+  }
+  const line = position.line - getFunctionLineOffset() - meta.linePrefixOffset;
+  if (line < 1 || line > meta.sourceLineCount) return null;
+  return line === 1 ? { line } : { line, column: position.column };
+}
+var SOURCE_URL_PREFIX = "next-live:///";
+function filterUserFrames(stack) {
+  if (!stack) return void 0;
+  const frames = stack.split("\n").filter((line) => line.includes(SOURCE_URL_PREFIX));
+  return frames.length > 0 ? frames.join("\n") : void 0;
+}
+
+// src/core/compile.ts
+async function compile(input) {
+  const prepared = await prepare(input);
+  try {
+    const { renderable, via } = evaluate(prepared.evaluateOptions);
+    return { renderable, via, code: prepared.code, imports: prepared.imports };
+  } catch (cause) {
+    throw enrichRuntimeError(cause, prepared.meta);
+  }
+}
+async function prepare(input) {
+  const {
+    code: source,
+    modules,
+    scope = {},
+    transform,
+    signal,
+    onRender,
+    resolveSubpaths = false,
+    ...transpileOptions
+  } = input;
+  const options = { ...defaultTranspileOptions, ...transpileOptions };
+  const budgetedSource = onRender ? injectRenderBudgetTick(source) : source;
+  const transformed = await transpile(budgetedSource, options, transform);
+  signal?.throwIfAborted();
+  const registry = { ...builtinModules, ...modules };
+  const imports = [...scanRequires(transformed.code)].sort();
+  const resolved = await resolveModules({
+    registry,
+    specifiers: imports,
+    resolveSubpaths,
+    ...signal ? { signal } : {}
+  });
+  signal?.throwIfAborted();
+  return {
+    code: transformed.code,
+    imports,
+    evaluateOptions: {
+      code: transformed.code,
+      filePath: options.filePath,
+      require: createRequire(resolved),
+      scope,
+      ...onRender ? { liveTick: onRender } : {}
+    },
+    meta: {
+      linePrefixOffset: transformed.linePrefixOffset,
+      generatedLineCount: countLines(transformed.code),
+      sourceLineCount: countLines(source)
+    }
+  };
+}
+async function compileModule(input) {
+  const prepared = await prepare(input);
+  try {
+    const { exports } = runModule(prepared.evaluateOptions);
+    return { exports, code: prepared.code, imports: prepared.imports };
+  } catch (cause) {
+    throw enrichRuntimeError(cause, prepared.meta);
+  }
+}
+function countLines(text) {
+  let count = 1;
+  for (let i = 0; i < text.length; i++) {
+    if (text.charCodeAt(i) === 10) count++;
+  }
+  return count;
+}
+function enrichRuntimeError(cause, meta) {
+  if (!(cause instanceof Error)) {
+    return new LiveRuntimeError(String(cause), { cause });
+  }
+  if (cause instanceof LiveError) return cause;
+  const position = positionFromStack(cause.stack);
+  const mapped = position ? mapPosition(position, meta) : null;
+  const error = new LiveRuntimeError(cause.message, { cause });
+  error.stack = filterUserFrames(cause.stack) ?? cause.stack;
+  if (mapped) {
+    Object.defineProperty(error, "line", { value: mapped.line, enumerable: true });
+    if (mapped.column !== void 0) {
+      Object.defineProperty(error, "column", { value: mapped.column, enumerable: true });
+    }
+  }
+  return error;
+}
+function positionFromStack(stack) {
+  if (!stack) return null;
+  for (const raw of stack.split("\n")) {
+    if (!raw.includes("next-live:///")) continue;
+    const match = /:(\d+):(\d+)\)?\s*$/.exec(raw.trim());
+    if (match?.[1]) {
+      return { line: Number(match[1]), column: match[2] ? Number(match[2]) : void 0 };
+    }
+  }
+  return null;
+}
+
+// src/core/guards.ts
+function createRenderBudget(options = {}) {
+  const maxRenders = options.maxRenders ?? 1e3;
+  const windowMs = options.windowMs ?? 1e3;
+  const message = `This component rendered more than ${maxRenders} times in ${windowMs}ms, so next-live stopped it to keep the page responsive.
+
+The usual causes are calling a state setter during render, or a useEffect that updates state without a correct dependency array.`;
+  let windowStart = 0;
+  let count = 0;
+  let tripped = false;
+  return function tick() {
+    if (tripped) throw new RenderLoopError(message);
+    const now = Date.now();
+    if (now - windowStart > windowMs) {
+      windowStart = now;
+      count = 0;
+    }
+    count += 1;
+    if (count > maxRenders) {
+      tripped = true;
+      throw new RenderLoopError(message);
+    }
+  };
+}
+var KEY_SEP = "\0";
+function compileSuccessInfo(result, compileId, durationMs) {
+  if (!result || typeof result !== "object" || !("imports" in result)) return null;
+  const typed = result;
+  return {
+    compileId,
+    imports: typed.imports,
+    ..."via" in typed && typed.via !== void 0 ? { via: typed.via } : {},
+    durationMs
+  };
+}
+function useCompileTask(options, run) {
+  const {
+    code: initialCode,
+    debounce = 150,
+    keepLastGood = true,
+    onCodeChange,
+    onCompileSuccess,
+    modules,
+    scope,
+    transform,
+    ...transpileOptions
+  } = options;
+  const [code, setCode] = React.useState(initialCode);
+  const [state, setState] = React.useState({
+    result: null,
+    error: null,
+    compileId: 0
+  });
+  const [isCompiling, setIsCompiling] = React.useState(false);
+  const compileIdRef = React.useRef(0);
+  const mountedRef = React.useRef(true);
+  React.useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  React.useEffect(() => {
+    setCode(initialCode);
+  }, [initialCode]);
+  const modulesKey = React.useMemo(
+    () => Object.keys(modules ?? {}).sort().join(KEY_SEP),
+    [modules]
+  );
+  const scopeKey = React.useMemo(
+    () => Object.keys(scope ?? {}).sort().join(KEY_SEP),
+    [scope]
+  );
+  const latest = React.useRef({
+    modules,
+    scope,
+    transform,
+    transpileOptions,
+    run,
+    onCodeChange,
+    onCompileSuccess
+  });
+  latest.current = {
+    modules,
+    scope,
+    transform,
+    transpileOptions,
+    run,
+    onCodeChange,
+    onCompileSuccess
+  };
+  const { filePath, production, jsxRuntime, jsxImportSource } = transpileOptions;
+  const prevFilePath = React.useRef(filePath);
+  React.useEffect(() => {
+    if (filePath === prevFilePath.current) return;
+    prevFilePath.current = filePath;
+    compileIdRef.current += 1;
+    if (!mountedRef.current) return;
+    setState({ result: null, error: null, compileId: compileIdRef.current });
+  }, [filePath]);
+  React.useEffect(() => {
+    const controller = new AbortController();
+    let cancelled = false;
+    const spinnerTimer = setTimeout(() => {
+      if (!cancelled && mountedRef.current) setIsCompiling(true);
+    }, 200);
+    const timer = setTimeout(() => {
+      const current = latest.current;
+      const startedAt = performance.now();
+      current.run({
+        code,
+        signal: controller.signal,
+        ...current.transpileOptions,
+        ...current.modules ? { modules: current.modules } : {},
+        ...current.scope ? { scope: current.scope } : {},
+        ...current.transform ? { transform: current.transform } : {}
+      }).then((result) => {
+        if (cancelled || !mountedRef.current) return;
+        const nextCompileId = compileIdRef.current + 1;
+        compileIdRef.current = nextCompileId;
+        setState({
+          result,
+          error: null,
+          compileId: nextCompileId
+        });
+        const info = compileSuccessInfo(result, nextCompileId, performance.now() - startedAt);
+        if (info && current.onCompileSuccess) {
+          try {
+            current.onCompileSuccess(info);
+          } catch {
+          }
+        }
+      }).catch((error) => {
+        if (cancelled || !mountedRef.current) return;
+        const asError = error instanceof Error ? error : new Error(String(error));
+        if (keepLastGood) {
+          setState((previous) => ({ ...previous, error: asError }));
+        } else {
+          const nextCompileId = compileIdRef.current + 1;
+          compileIdRef.current = nextCompileId;
+          setState({ result: null, error: asError, compileId: nextCompileId });
+        }
+      }).finally(() => {
+        if (cancelled || !mountedRef.current) return;
+        clearTimeout(spinnerTimer);
+        setIsCompiling(false);
+      });
+    }, debounce);
+    return () => {
+      cancelled = true;
+      controller.abort();
+      clearTimeout(timer);
+      clearTimeout(spinnerTimer);
+    };
+  }, [
+    code,
+    debounce,
+    keepLastGood,
+    modulesKey,
+    scopeKey,
+    filePath,
+    production,
+    jsxRuntime,
+    jsxImportSource,
+    transform
+  ]);
+  const setCodeStable = React.useCallback((next) => {
+    setCode(next);
+    latest.current.onCodeChange?.(next);
+  }, []);
+  return {
+    code,
+    setCode: setCodeStable,
+    result: state.result,
+    error: state.error,
+    isCompiling,
+    compileId: state.compileId
+  };
+}
+
+// src/hooks/useLiveRunner.ts
+function useLiveRunner(options) {
+  const { maxRendersPerSecond = 1e3, ...taskOptions } = options;
+  const run = React.useCallback(
+    (input) => (
+      // A fresh budget per compile, so fixing a snippet clears a tripped
+      // breaker without the user having to reload the page.
+      compile({ ...input, onRender: createRenderBudget({ maxRenders: maxRendersPerSecond }) })
+    ),
+    [maxRendersPerSecond]
+  );
+  const task = useCompileTask(taskOptions, run);
+  const renderable = task.result?.renderable ?? null;
+  return {
+    code: task.code,
+    setCode: task.setCode,
+    Component: renderable?.kind === "component" ? renderable.component : null,
+    element: renderable?.kind === "element" ? renderable.element : null,
+    error: task.error,
+    isCompiling: task.isCompiling,
+    compileId: task.compileId
+  };
+}
+var EMPTY_PROPS = {};
+function LiveProvider(props) {
+  const {
+    code,
+    props: componentProps,
+    language = "tsx",
+    onError,
+    fallback = null,
+    children,
+    ...runnerOptions
+  } = props;
+  const runner = useLiveRunner({ code, ...runnerOptions });
+  const [runtimeError, setRuntimeError] = React.useState(null);
+  const compileIdRef = React.useRef(runner.compileId);
+  compileIdRef.current = runner.compileId;
+  const mountedRef = React.useRef(true);
+  React.useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  const lastRuntimeReport = React.useRef(null);
+  const reportRuntimeError = React.useCallback(
+    (error) => {
+      if (!mountedRef.current) return;
+      const compileId = compileIdRef.current;
+      const last = lastRuntimeReport.current;
+      if (last !== null && last.compileId === compileId && last.message === error.message) {
+        return;
+      }
+      lastRuntimeReport.current = { compileId, message: error.message };
+      setRuntimeError({ error, compileId });
+      onError?.(error);
+    },
+    [onError]
+  );
+  const activeRuntimeError = runtimeError !== null && runtimeError.compileId === runner.compileId ? runtimeError.error : null;
+  const compileError = runner.error;
+  React.useEffect(() => {
+    if (compileError) onError?.(compileError);
+  }, [compileError, onError]);
+  const forwardedProps = componentProps ?? EMPTY_PROPS;
+  const value = React.useMemo(
+    () => ({
+      ...runner,
+      error: runner.error ?? activeRuntimeError,
+      props: forwardedProps,
+      language,
+      fallback,
+      reportRuntimeError
+    }),
+    [runner, activeRuntimeError, forwardedProps, language, fallback, reportRuntimeError]
+  );
+  return /* @__PURE__ */ JsxRuntime.jsx(LiveContext.Provider, { value, children });
+}
+var LiveErrorBoundary = class extends React.Component {
+  mounted = true;
+  constructor(props) {
+    super(props);
+    this.state = { error: null, resetKey: props.resetKey, recovering: false };
+  }
+  static getDerivedStateFromError(error) {
+    return { error, recovering: false };
+  }
+  static getDerivedStateFromProps(props, state) {
+    if (props.resetKey !== state.resetKey) {
+      return { resetKey: props.resetKey, recovering: true };
+    }
+    return null;
+  }
+  componentDidCatch(error, info) {
+    if (!this.mounted) return;
+    this.props.onError(error);
+    if (process.env.NODE_ENV !== "production") {
+      console.error("next-live: error in evaluated code\n", error, info.componentStack);
+    }
+  }
+  componentDidUpdate(_prevProps, prevState) {
+    if (prevState.recovering && this.state.recovering && this.state.error !== null) {
+      this.setState({ error: null, recovering: false });
+    }
+  }
+  componentWillUnmount() {
+    this.mounted = false;
+  }
+  render() {
+    if (this.state.error !== null && !this.state.recovering) {
+      return this.props.fallback ?? null;
+    }
+    return this.props.children;
+  }
+};
+function useLiveContext() {
+  const value = React.useContext(LiveContext);
+  if (value === null) {
+    throw new Error(
+      "useLiveContext must be called inside a <LiveProvider>. If you want to run code without the provider, use the useLiveRunner hook directly."
+    );
+  }
+  return value;
+}
+function LivePreview(props) {
+  const { as: Wrapper = "div", className, style, props: extraProps, fallback } = props;
+  const live = useLiveContext();
+  const merged = extraProps ? { ...live.props, ...extraProps } : live.props;
+  const placeholder = fallback !== void 0 ? fallback : live.fallback;
+  let content;
+  if (live.Component && isRenderableComponent(live.Component)) {
+    content = React.createElement(live.Component, merged);
+  } else if (live.element && React.isValidElement(live.element)) {
+    content = live.element;
+  } else {
+    content = placeholder;
+  }
+  return /* @__PURE__ */ JsxRuntime.jsx(Wrapper, { className, style, children: /* @__PURE__ */ JsxRuntime.jsx(
+    LiveErrorBoundary,
+    {
+      resetKey: live.compileId,
+      onError: live.reportRuntimeError,
+      fallback: null,
+      children: content
+    }
+  ) });
+}
+
+// src/core/positions.ts
+function errorPosition(error) {
+  if (error === null || error === void 0) return null;
+  const positioned = error;
+  if (positioned.line === void 0 || positioned.line < 1) return null;
+  return {
+    line: positioned.line,
+    ...positioned.column !== void 0 ? { column: positioned.column } : {}
+  };
+}
+function LiveError2(props) {
+  const { as: Wrapper = "pre", className, style, children } = props;
+  const live = useLiveContext();
+  if (!live.error) return null;
+  if (children) return /* @__PURE__ */ JsxRuntime.jsx(JsxRuntime.Fragment, { children: children(live.error) });
+  const position = errorPosition(live.error);
+  const location = position !== null ? `Line ${position.line}${position.column !== void 0 ? `:${position.column}` : ""} - ` : "";
+  return /* @__PURE__ */ JsxRuntime.jsxs(
+    Wrapper,
+    {
+      className,
+      role: "alert",
+      style: {
+        margin: 0,
+        padding: "0.75rem 1rem",
+        whiteSpace: "pre-wrap",
+        wordBreak: "break-word",
+        fontFamily: 'ui-monospace, SFMono-Regular, Menlo, Consolas, "Liberation Mono", monospace',
+        fontSize: "0.8125rem",
+        lineHeight: 1.5,
+        color: "#fff",
+        background: "#b3261e",
+        ...style
+      },
+      children: [
+        location,
+        live.error.message
+      ]
+    }
+  );
+}
+function useLiveModule(options) {
+  const run = React.useCallback(
+    (input) => compileModule(input),
+    []
+  );
+  const task = useCompileTask(options, run);
+  const exports = task.result?.exports ?? null;
+  return {
+    code: task.code,
+    setCode: task.setCode,
+    exports,
+    value: exports?.["default"],
+    error: task.error,
+    isCompiling: task.isCompiling,
+    compileId: task.compileId
+  };
+}
+
+// src/core/registry.ts
+function createRegistry(...groups) {
+  const merged = {};
+  if (process.env.NODE_ENV !== "production") {
+    const seen = /* @__PURE__ */ new Map();
+    groups.forEach((group, index) => {
+      for (const key of Object.keys(group)) {
+        const previous = seen.get(key);
+        if (previous !== void 0) {
+          console.warn(
+            `next-live: module '${key}' is defined in more than one registry group (group ${previous} and group ${index}). The later one wins.`
+          );
+        }
+        seen.set(key, index);
+      }
+    });
+  }
+  for (const group of groups) Object.assign(merged, group);
+  return merged;
+}
+function registryFromGlob(glob, toSpecifier) {
+  const registry = {};
+  for (const [path, load] of Object.entries(glob)) {
+    const specifier = toSpecifier(path);
+    if (specifier === null) continue;
+    if (process.env.NODE_ENV !== "production" && specifier in registry) {
+      console.warn(
+        `next-live: two files map to the module specifier '${specifier}'. Check the toSpecifier function for collisions.`
+      );
+    }
+    registry[specifier] = defineLoader(() => load());
+  }
+  return registry;
+}
+
+exports.LiveCompileError = LiveCompileError;
+exports.LiveContext = LiveContext;
+exports.LiveError = LiveError2;
+exports.LiveErrorBase = LiveError;
+exports.LiveErrorBoundary = LiveErrorBoundary;
+exports.LivePreview = LivePreview;
+exports.LiveProvider = LiveProvider;
+exports.LiveRuntimeError = LiveRuntimeError;
+exports.ModuleNotFoundError = ModuleNotFoundError;
+exports.NoComponentError = NoComponentError;
+exports.RenderLoopError = RenderLoopError;
+exports.TranspilerLoadError = TranspilerLoadError;
+exports.builtinModules = builtinModules;
+exports.compile = compile;
+exports.compileModule = compileModule;
+exports.createRegistry = createRegistry;
+exports.createRenderBudget = createRenderBudget;
+exports.createRequire = createRequire;
+exports.defineLoader = defineLoader;
+exports.defineModule = defineModule;
+exports.errorPosition = errorPosition;
+exports.normalizeModule = normalizeModule;
+exports.precompiledTransform = precompiledTransform;
+exports.preloadTranspiler = preloadTranspiler;
+exports.registryFromGlob = registryFromGlob;
+exports.resolveModules = resolveModules;
+exports.setTranspiler = setTranspiler;
+exports.transpile = transpile;
+exports.useLiveContext = useLiveContext;
+exports.useLiveModule = useLiveModule;
+exports.useLiveRunner = useLiveRunner;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map