@fluixi/compiler 1.0.0-alpha.100

package/dist/transform/source-locations.js

@@ -0,0 +1,303 @@
+/**
+ * Record where each reactive primitive was created, for the devtools graph.
+ *
+ *   const count = signal(0);
+ *   → globalThis.__fx_source?.("src/App.ts",1,14,"count"); const count = signal(0);
+ *
+ * A statement in front of the one that creates the node, not a wrapper round the call: the
+ * call may already be being rewritten: `$signal` becomes `signal`, and two passes editing
+ * one span is a splice over a splice.
+ *
+ * A global rather than an import, so the author's modules do not each take a dependency on
+ * @fluixi/devtools to carry a debug string. Nothing installs it by default.
+ *
+ * Positions come from the original source, before any pass moves anything.
+ *
+ * Development only, and one mark per statement: the runtime keeps a single slot, so
+ * marking two calls in one statement would hand the first node the second's location.
+ */
+import { INTRINSICS, isIntrinsicName } from '../analyze/intrinsics.js';
+import { resolveReactiveBindings } from '../analyze/reactive-bindings.js';
+/** Installed by @fluixi/devtools; undefined everywhere else. */
+export const SOURCE_MARKER = '__fx_source';
+/** Where a component was declared. Keyed by name, since that is all the runtime carries. */
+export const COMPONENT_MARKER = '__fx_component';
+/**
+ * Where a class that extends another was declared, keyed by the class itself: a custom
+ * element's definition, which the runtime can only reach through `element.constructor`.
+ */
+export const CLASS_MARKER = '__fx_class';
+/**
+ * Where one reactive hole was written. This one wraps: the position has to travel with the
+ * accessor to wherever the dom wires it up. A template is emitted as one overwrite, so the
+ * source map has a single entry for the root and every hole traces back to it.
+ *
+ * `?? (f => f)` and not `?.()`: the value is the accessor, and returning undefined would
+ * delete the binding.
+ */
+export const HOLE_MARKER = '__fx_hole';
+/**
+ * `_(() => x(), 9, 25)`, or the accessor untouched when nothing is watching.
+ *
+ * `name` is the source text the value came from, for a `ref` where knowing which variable
+ * holds the element is the whole question.
+ */
+export const markHole = (accessor, line, column, name) => `(globalThis.${HOLE_MARKER} ?? ((f) => f))(${accessor},${line},${column}${name === undefined ? '' : `,${JSON.stringify(name)}`})`;
+/**
+ * Where each prop of a component tag was written.
+ *
+ * The props object is built as getters, so nothing in it can carry a position of its own.
+ * The marker takes the object and a name-to-position map, and hands the object straight
+ * back: devtools keeps the map, and a build without it passes the object through.
+ */
+export const PROPS_MARKER = '__fx_props';
+/** `_({ get a() {…} }, {"a":[9,25]})`, or the object untouched when nothing is watching. */
+export const markProps = (object, at) => `(globalThis.${PROPS_MARKER} ?? ((p) => p))(${object},${JSON.stringify(at)})`;
+/** The runtime names that make a node. */
+const RUNTIME_PRIMITIVES = new Set([
+    'signal', 'memo', 'effect', 'store', 'resource', 'watch',
+    'createSignal', 'createMemo', 'createEffect', 'createStore', 'createResource',
+]);
+/** Whether a module has anything to mark: a primitive call or a subclass. Cheap enough to run before parsing. */
+export function mayHaveSourceMarks(code) {
+    for (const name of RUNTIME_PRIMITIVES) {
+        if (code.includes(name))
+            return true;
+    }
+    if (code.includes('$signal') || code.includes('$memo') || code.includes('$effect') || code.includes('$store'))
+        return true;
+    // A subclass gets a declaration mark, so an element with no signal of its own is still found.
+    return /\bclass\b[^{;]*\bextends\b/.test(code);
+}
+/** Positions where the grammar allows exactly one statement, so a second one changes it. */
+const SINGLE_STATEMENT_PARENTS = new Set([
+    'IfStatement', 'ForStatement', 'ForInStatement', 'ForOfStatement',
+    'WhileStatement', 'DoWhileStatement', 'LabeledStatement', 'WithStatement',
+]);
+function isLoneBranch(statement, parent) {
+    if (!parent || statement.type === 'BlockStatement')
+        return false;
+    return SINGLE_STATEMENT_PARENTS.has(parent.type);
+}
+function isExport(node) {
+    return node.type === 'ExportNamedDeclaration' || node.type === 'ExportDefaultDeclaration';
+}
+/** Where a class holds a per-instance initializer: the value of a field. */
+const CLASS_FIELDS = new Set(['PropertyDefinition', 'ClassProperty', 'ClassPrivateProperty', 'AccessorProperty']);
+function isStatement(node) {
+    return node.type.endsWith('Statement') || node.type === 'VariableDeclaration';
+}
+function walk(node, visit, stack = []) {
+    if (!node || typeof node.type !== 'string')
+        return;
+    visit(node, stack);
+    stack.push(node);
+    for (const key of Object.keys(node)) {
+        if (key === 'loc' || key === 'parent')
+            continue;
+        const value = node[key];
+        if (Array.isArray(value)) {
+            for (const child of value)
+                walk(child, visit, stack);
+        }
+        else if (value && typeof value.type === 'string') {
+            walk(value, visit, stack);
+        }
+    }
+    stack.pop();
+}
+/**
+ *   const count = signal(0)      → count
+ *   const [count, setCount] = …  → count, the accessor rather than the setter
+ *   effect(() => …)              → nothing
+ */
+function nameFor(stack) {
+    const declarator = stack[stack.length - 1];
+    // `#count = signal(0)` and `count = signal(0)`: the field's name, without the `#`.
+    if (declarator && CLASS_FIELDS.has(declarator.type)) {
+        const key = declarator.key;
+        if (key?.type === 'Identifier' || key?.type === 'PrivateIdentifier' || key?.type === 'PrivateName') {
+            const name = (key.name ?? key.id?.name);
+            return name;
+        }
+        return undefined;
+    }
+    if (declarator?.type !== 'VariableDeclarator')
+        return undefined;
+    const id = declarator.id;
+    if (id?.type === 'Identifier')
+        return id.name;
+    if (id?.type === 'ArrayPattern') {
+        const first = id.elements?.[0];
+        if (first?.type === 'Identifier')
+            return first.name;
+    }
+    return undefined;
+}
+/** A capitalised function is how JSX tells a component from an element. */
+function componentName(node) {
+    if (node.type === 'FunctionDeclaration') {
+        const name = node.id?.name;
+        return name && name[0] === name[0]?.toUpperCase() ? name : undefined;
+    }
+    if (node.type === 'VariableDeclarator') {
+        const id = node.id;
+        const init = node.init;
+        if (id?.type !== 'Identifier' || !init)
+            return undefined;
+        if (init.type !== 'ArrowFunctionExpression' && init.type !== 'FunctionExpression')
+            return undefined;
+        const name = id.name;
+        return name[0] === name[0]?.toUpperCase() ? name : undefined;
+    }
+    return undefined;
+}
+export function collectSourceEdits(program, filename) {
+    const edits = [];
+    // A single slot cannot describe more than the first primitive in a statement.
+    const claimed = new Set();
+    const { primitives, shadowed } = resolveReactiveBindings(program);
+    walk(program, (node, stack) => {
+        // The compiler wraps every component in a memo, and the memo is what the graph sees. It
+        // has no way back to the declaration, so the declaration says where it is by name.
+        const component = componentName(node);
+        if (component) {
+            const at = node.loc?.start;
+            // After the whole declaration, not after the function: `const Row = () => <b/>` ends
+            // where its jsx ends, and an insertion on that boundary is inside the span the
+            // template pass overwrites.
+            //
+            // Only through what wraps a declaration. Anything else above it is a block or an
+            // argument list, and a statement appended there lands outside the grammar , 
+            // `function Page(){}` inside `it('…', () => { … })` ended up between the `}` and the
+            // `)`, which is a syntax error in a file that compiled a moment earlier.
+            let end = node.end;
+            for (let i = stack.length - 1; i >= 0; i--) {
+                const up = stack[i];
+                if (up.type !== 'VariableDeclaration' &&
+                    up.type !== 'ExportNamedDeclaration' &&
+                    up.type !== 'ExportDefaultDeclaration') {
+                    break;
+                }
+                end = up.end;
+            }
+            if (at) {
+                edits.push({
+                    start: end,
+                    end,
+                    code: `;globalThis.${COMPONENT_MARKER}?.(${JSON.stringify(component)},${JSON.stringify(filename)},${at.line},${at.column});`,
+                });
+            }
+        }
+        // A static block at the top of the body runs once, when the class is defined, with `this`
+        // bound to the class. Only a subclass: that covers every custom element and keeps the mark
+        // off plain classes. An ambient `declare class` has no body to run.
+        if ((node.type === 'ClassDeclaration' || node.type === 'ClassExpression') && node.superClass && !node.declare) {
+            const at = node.loc?.start;
+            const body = node.body;
+            if (at && body) {
+                edits.push({
+                    start: body.start + 1,
+                    end: body.start + 1,
+                    code: `static{globalThis.${CLASS_MARKER}?.(this,${JSON.stringify(filename)},${at.line},${at.column});}`,
+                });
+            }
+        }
+        if (node.type !== 'CallExpression')
+            return;
+        const callee = node.callee;
+        if (callee?.type !== 'Identifier')
+            return;
+        const name = callee.name;
+        // The same test the intrinsics pass makes, so the two agree on what is a primitive.
+        const intrinsic = isIntrinsicName(name) && !shadowed.has(name) ? INTRINSICS[name] : undefined;
+        // resolveReactiveBindings has followed the import, so `signal as state` is covered and
+        // a local function of the same name is not.
+        const imported = primitives.has(name) || RUNTIME_PRIMITIVES.has(name);
+        if (!intrinsic && !imported)
+            return;
+        const position = node.loc?.start;
+        if (!position)
+            return;
+        // A class field (`#count = signal(0)`) runs once per instance, and the class body has no
+        // statement to put the mark in front of. Hoisting it before the class runs it once, at
+        // definition, and the next node created anywhere took its name and line; inside a function
+        // (a mixin) the nearest statement was the function's body block, and the mark landed in
+        // front of the `{`. The call itself carries the mark instead, so it runs right before the
+        // node it describes.
+        for (let i = stack.length - 1; i >= 0; i--) {
+            const up = stack[i];
+            if (isStatement(up))
+                break;
+            if (CLASS_FIELDS.has(up.type)) {
+                if (claimed.has(node.start))
+                    return;
+                claimed.add(node.start);
+                const label = nameFor(stack);
+                // An instance field also hands over `this`: the constructor runs before a custom
+                // element opens its scope, and the instance is what ties the node to it later.
+                const own = !up.static;
+                const args = [
+                    JSON.stringify(filename),
+                    String(position.line),
+                    String(position.column),
+                    label ? JSON.stringify(label) : own ? 'undefined' : undefined,
+                    own ? 'this' : undefined,
+                ]
+                    .filter((a) => a !== undefined)
+                    .join(',');
+                edits.push({ start: node.start, end: node.start, code: `(globalThis.${SOURCE_MARKER}?.(${args}),` });
+                edits.push({ start: node.end, end: node.end, code: ')' });
+                return;
+            }
+        }
+        // The mark goes in front of the statement, clear of any span another pass rewrites.
+        let statement;
+        let parent;
+        let index = -1;
+        for (let i = stack.length - 1; i >= 0; i--) {
+            if (isStatement(stack[i]) || isExport(stack[i])) {
+                statement = stack[i];
+                parent = stack[i - 1];
+                index = i;
+                break;
+            }
+        }
+        if (!statement)
+            return;
+        // `export const [cart] = createStore(…)` finds the declaration, which starts after the
+        // keyword: a mark there splits `export` from what it exports.
+        let start = statement.start;
+        let end = statement.end;
+        for (let i = index - 1; i >= 0; i--) {
+            if (!isExport(stack[i]))
+                break;
+            start = stack[i].start;
+            end = stack[i].end;
+            parent = stack[i - 1];
+        }
+        if (claimed.has(start))
+            return;
+        claimed.add(start);
+        const label = nameFor(stack);
+        const args = [
+            JSON.stringify(filename),
+            String(position.line),
+            String(position.column),
+            label ? JSON.stringify(label) : undefined,
+        ]
+            .filter((a) => a !== undefined)
+            .join(',');
+        const mark = `globalThis.${SOURCE_MARKER}?.(${args});`;
+        // `if (c) effect(…)` has one statement where the grammar allows one statement, so
+        // putting the mark in front of it moves the branch body out of the branch. Braces are
+        // added around both rather than skipping the mark.
+        if (isLoneBranch(statement, parent)) {
+            edits.push({ start, end: start, code: `{${mark}` });
+            edits.push({ start: end, end, code: '}' });
+            return;
+        }
+        edits.push({ start, end: start, code: mark });
+    });
+    return { edits, marked: edits.length };
+}

package/dist/transform/source-locations.mjs

@@ -0,0 +1,370 @@
+// src/analyze/intrinsics.ts
+var REACTIVE_MODULE = "@fluixi/reactive/signal";
+var INTRINSICS = {
+  $signal: { export: "signal", module: REACTIVE_MODULE, returns: "signal-handle" },
+  $memo: { export: "memo", module: REACTIVE_MODULE, returns: "memo-handle" },
+  $effect: { export: "effect", module: REACTIVE_MODULE, returns: "effect" },
+  $store: { export: "store", module: "@fluixi/reactive/store", returns: "store-handle" },
+  $resource: { export: "resource", module: REACTIVE_MODULE, returns: "resource-handle" },
+  $cachedResource: { export: "cachedResource", module: "@fluixi/reactive/cached-resource", returns: "resource-handle" },
+  // No short runtime form for these yet, so the intrinsic stands for the `create*`
+  // name. Still worth having: no import to write, and when a shorter form is
+  // designed, the change is this line rather than a compiler pass.
+  $selector: { export: "createSelector", module: REACTIVE_MODULE, returns: "memo-accessor" },
+  $deferred: { export: "createDeferred", module: REACTIVE_MODULE, returns: "memo-accessor" },
+  // Not value constructors, but the compiler has to know them: they change what a read
+  // does. `untrack` suppresses dependency collection, which is exactly the kind of thing
+  // dependency analysis must not guess at.
+  $untrack: { export: "untrack", module: REACTIVE_MODULE, returns: "plain" },
+  $untrackStore: { export: "untrackStore", module: "@fluixi/reactive/store", returns: "plain" },
+  // Scopes, scheduling and lifecycle: no value to classify, but the same authoring promise,
+  // no import to write. `$cleanup` registers a callback on the current owner (`onCleanup`).
+  $batch: { export: "batch", module: REACTIVE_MODULE, returns: "plain" },
+  $cleanup: { export: "onCleanup", module: REACTIVE_MODULE, returns: "plain" },
+  $root: { export: "root", module: REACTIVE_MODULE, returns: "plain" },
+  $context: { export: "context", module: REACTIVE_MODULE, returns: "plain" },
+  $renderEffect: { export: "renderEffect", module: REACTIVE_MODULE, returns: "effect" },
+  $computed: { export: "computed", module: REACTIVE_MODULE, returns: "effect" },
+  // Storage for where the code runs, and a signal kept in it. `$persisted` is a signal
+  // handle as far as reads go: the same accessor with `set` on it.
+  $storage: { export: "useStorage", module: "@fluixi/core/storage", returns: "plain" },
+  $asyncStorage: { export: "useAsyncStorage", module: "@fluixi/core/storage", returns: "plain" },
+  $persisted: { export: "persisted", module: "@fluixi/core/storage", returns: "signal-handle" },
+  // An environment variable, public or server-only; the browser build refuses a secret.
+  $env: { export: "env", module: "@fluixi/start/env", returns: "plain" }
+};
+var RUNTIME_PRIMITIVES = {
+  signal: "signal-handle",
+  memo: "memo-handle",
+  effect: "effect",
+  store: "store-handle",
+  createSignal: ["signal-accessor", "signal-setter"],
+  createMemo: "memo-accessor",
+  createEffect: "effect",
+  createRenderEffect: "effect",
+  renderEffect: "effect",
+  computed: "effect",
+  createStore: "reactive-object",
+  resource: "resource-handle",
+  cachedResource: "resource-handle",
+  createResource: "reactive-object",
+  createSelector: "memo-accessor",
+  createDeferred: "memo-accessor"
+};
+var PRIMITIVE_MODULES = [
+  "@fluixi/reactive",
+  "@fluixi/reactive/signal",
+  "@fluixi/reactive/store",
+  "@fluixi/reactive/cached-resource",
+  "@fluixi/core"
+];
+var INTRINSIC_CALL = new RegExp(`\\$(?:${Object.keys(INTRINSICS).map((n) => n.slice(1)).join("|")})\\s*\\(`);
+function isIntrinsicName(name) {
+  return Object.prototype.hasOwnProperty.call(INTRINSICS, name);
+}
+function isPrimitiveModule(source) {
+  return PRIMITIVE_MODULES.includes(source);
+}
+
+// src/analyze/reactive-bindings.ts
+function patternNames(node, out) {
+  if (!node) return;
+  switch (node.type) {
+    case "Identifier":
+      out.add(node.name);
+      return;
+    case "ObjectPattern":
+      for (const p of node.properties ?? []) {
+        if (p.type === "RestElement") patternNames(p.argument, out);
+        else patternNames(p.value, out);
+      }
+      return;
+    case "ArrayPattern":
+      for (const e of node.elements ?? []) patternNames(e, out);
+      return;
+    case "AssignmentPattern":
+      patternNames(node.left, out);
+      return;
+    case "RestElement":
+      patternNames(node.argument, out);
+      return;
+  }
+}
+function walk(root, visit) {
+  if (!root || typeof root !== "object" || typeof root.type !== "string") return;
+  visit(root);
+  for (const key of Object.keys(root)) {
+    if (key === "loc" || key === "leadingComments" || key === "trailingComments") continue;
+    const value = root[key];
+    if (Array.isArray(value)) for (const item of value) walk(item, visit);
+    else if (value && typeof value === "object") walk(value, visit);
+  }
+}
+function calledPrimitive(node, bindings) {
+  if (node.type !== "CallExpression") return void 0;
+  const callee = node.callee;
+  if (callee?.type !== "Identifier") return void 0;
+  const name = callee.name;
+  const imported = bindings.primitives.get(name);
+  if (imported) return imported;
+  const intrinsic = INTRINSICS[name];
+  if (intrinsic && !bindings.shadowed.has(name)) return intrinsic.returns;
+  return void 0;
+}
+function classify(id, returns, kinds) {
+  if (Array.isArray(returns)) {
+    if (id.type === "ArrayPattern") {
+      id.elements.forEach((element, index) => {
+        const kind = returns[index];
+        if (element?.type === "Identifier" && kind) kinds.set(element.name, kind);
+      });
+    }
+    return;
+  }
+  if (id.type === "Identifier") kinds.set(id.name, returns);
+}
+function resolveReactiveBindings(program) {
+  const bindings = { kinds: /* @__PURE__ */ new Map(), primitives: /* @__PURE__ */ new Map(), shadowed: /* @__PURE__ */ new Set() };
+  const root = program;
+  walk(root, (node) => {
+    const names = /* @__PURE__ */ new Set();
+    if (node.type === "VariableDeclarator") patternNames(node.id, names);
+    else if (node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") patternNames(node.id, names);
+    else if (node.type === "ImportDefaultSpecifier" || node.type === "ImportNamespaceSpecifier") patternNames(node.local, names);
+    else if (node.type === "ImportSpecifier") patternNames(node.local, names);
+    else if (node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration") {
+      for (const p of node.params ?? []) patternNames(p, names);
+    }
+    for (const name of names) if (INTRINSICS[name]) bindings.shadowed.add(name);
+  });
+  for (const statement of root.body ?? []) {
+    if (statement.type !== "ImportDeclaration") continue;
+    if (!isPrimitiveModule(statement.source?.value)) continue;
+    for (const specifier of statement.specifiers ?? []) {
+      if (specifier.type !== "ImportSpecifier") continue;
+      const importedNode = specifier.imported;
+      const imported = importedNode.type === "Identifier" ? importedNode.name : importedNode.value;
+      const returns = RUNTIME_PRIMITIVES[imported];
+      if (returns) bindings.primitives.set(specifier.local.name, returns);
+    }
+  }
+  walk(root, (node) => {
+    if (node.type !== "VariableDeclarator" || !node.init) return;
+    const returns = calledPrimitive(node.init, bindings);
+    if (returns) classify(node.id, returns, bindings.kinds);
+  });
+  return bindings;
+}
+
+// src/transform/source-locations.ts
+var SOURCE_MARKER = "__fx_source";
+var COMPONENT_MARKER = "__fx_component";
+var CLASS_MARKER = "__fx_class";
+var HOLE_MARKER = "__fx_hole";
+var markHole = (accessor, line, column, name) => `(globalThis.${HOLE_MARKER} ?? ((f) => f))(${accessor},${line},${column}${name === void 0 ? "" : `,${JSON.stringify(name)}`})`;
+var PROPS_MARKER = "__fx_props";
+var markProps = (object, at) => `(globalThis.${PROPS_MARKER} ?? ((p) => p))(${object},${JSON.stringify(at)})`;
+var RUNTIME_PRIMITIVES2 = /* @__PURE__ */ new Set([
+  "signal",
+  "memo",
+  "effect",
+  "store",
+  "resource",
+  "watch",
+  "createSignal",
+  "createMemo",
+  "createEffect",
+  "createStore",
+  "createResource"
+]);
+function mayHaveSourceMarks(code) {
+  for (const name of RUNTIME_PRIMITIVES2) {
+    if (code.includes(name)) return true;
+  }
+  if (code.includes("$signal") || code.includes("$memo") || code.includes("$effect") || code.includes("$store")) return true;
+  return /\bclass\b[^{;]*\bextends\b/.test(code);
+}
+var SINGLE_STATEMENT_PARENTS = /* @__PURE__ */ new Set([
+  "IfStatement",
+  "ForStatement",
+  "ForInStatement",
+  "ForOfStatement",
+  "WhileStatement",
+  "DoWhileStatement",
+  "LabeledStatement",
+  "WithStatement"
+]);
+function isLoneBranch(statement, parent) {
+  if (!parent || statement.type === "BlockStatement") return false;
+  return SINGLE_STATEMENT_PARENTS.has(parent.type);
+}
+function isExport(node) {
+  return node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration";
+}
+var CLASS_FIELDS = /* @__PURE__ */ new Set(["PropertyDefinition", "ClassProperty", "ClassPrivateProperty", "AccessorProperty"]);
+function isStatement(node) {
+  return node.type.endsWith("Statement") || node.type === "VariableDeclaration";
+}
+function walk2(node, visit, stack = []) {
+  if (!node || typeof node.type !== "string") return;
+  visit(node, stack);
+  stack.push(node);
+  for (const key of Object.keys(node)) {
+    if (key === "loc" || key === "parent") continue;
+    const value = node[key];
+    if (Array.isArray(value)) {
+      for (const child of value) walk2(child, visit, stack);
+    } else if (value && typeof value.type === "string") {
+      walk2(value, visit, stack);
+    }
+  }
+  stack.pop();
+}
+function nameFor(stack) {
+  const declarator = stack[stack.length - 1];
+  if (declarator && CLASS_FIELDS.has(declarator.type)) {
+    const key = declarator.key;
+    if (key?.type === "Identifier" || key?.type === "PrivateIdentifier" || key?.type === "PrivateName") {
+      const name = key.name ?? key.id?.name;
+      return name;
+    }
+    return void 0;
+  }
+  if (declarator?.type !== "VariableDeclarator") return void 0;
+  const id = declarator.id;
+  if (id?.type === "Identifier") return id.name;
+  if (id?.type === "ArrayPattern") {
+    const first = id.elements?.[0];
+    if (first?.type === "Identifier") return first.name;
+  }
+  return void 0;
+}
+function componentName(node) {
+  if (node.type === "FunctionDeclaration") {
+    const name = node.id?.name;
+    return name && name[0] === name[0]?.toUpperCase() ? name : void 0;
+  }
+  if (node.type === "VariableDeclarator") {
+    const id = node.id;
+    const init = node.init;
+    if (id?.type !== "Identifier" || !init) return void 0;
+    if (init.type !== "ArrowFunctionExpression" && init.type !== "FunctionExpression") return void 0;
+    const name = id.name;
+    return name[0] === name[0]?.toUpperCase() ? name : void 0;
+  }
+  return void 0;
+}
+function collectSourceEdits(program, filename) {
+  const edits = [];
+  const claimed = /* @__PURE__ */ new Set();
+  const { primitives, shadowed } = resolveReactiveBindings(program);
+  walk2(program, (node, stack) => {
+    const component = componentName(node);
+    if (component) {
+      const at = node.loc?.start;
+      let end2 = node.end;
+      for (let i = stack.length - 1; i >= 0; i--) {
+        const up = stack[i];
+        if (up.type !== "VariableDeclaration" && up.type !== "ExportNamedDeclaration" && up.type !== "ExportDefaultDeclaration") {
+          break;
+        }
+        end2 = up.end;
+      }
+      if (at) {
+        edits.push({
+          start: end2,
+          end: end2,
+          code: `;globalThis.${COMPONENT_MARKER}?.(${JSON.stringify(component)},${JSON.stringify(filename)},${at.line},${at.column});`
+        });
+      }
+    }
+    if ((node.type === "ClassDeclaration" || node.type === "ClassExpression") && node.superClass && !node.declare) {
+      const at = node.loc?.start;
+      const body = node.body;
+      if (at && body) {
+        edits.push({
+          start: body.start + 1,
+          end: body.start + 1,
+          code: `static{globalThis.${CLASS_MARKER}?.(this,${JSON.stringify(filename)},${at.line},${at.column});}`
+        });
+      }
+    }
+    if (node.type !== "CallExpression") return;
+    const callee = node.callee;
+    if (callee?.type !== "Identifier") return;
+    const name = callee.name;
+    const intrinsic = isIntrinsicName(name) && !shadowed.has(name) ? INTRINSICS[name] : void 0;
+    const imported = primitives.has(name) || RUNTIME_PRIMITIVES2.has(name);
+    if (!intrinsic && !imported) return;
+    const position = node.loc?.start;
+    if (!position) return;
+    for (let i = stack.length - 1; i >= 0; i--) {
+      const up = stack[i];
+      if (isStatement(up)) break;
+      if (CLASS_FIELDS.has(up.type)) {
+        if (claimed.has(node.start)) return;
+        claimed.add(node.start);
+        const label2 = nameFor(stack);
+        const own = !up.static;
+        const args2 = [
+          JSON.stringify(filename),
+          String(position.line),
+          String(position.column),
+          label2 ? JSON.stringify(label2) : own ? "undefined" : void 0,
+          own ? "this" : void 0
+        ].filter((a) => a !== void 0).join(",");
+        edits.push({ start: node.start, end: node.start, code: `(globalThis.${SOURCE_MARKER}?.(${args2}),` });
+        edits.push({ start: node.end, end: node.end, code: ")" });
+        return;
+      }
+    }
+    let statement;
+    let parent;
+    let index = -1;
+    for (let i = stack.length - 1; i >= 0; i--) {
+      if (isStatement(stack[i]) || isExport(stack[i])) {
+        statement = stack[i];
+        parent = stack[i - 1];
+        index = i;
+        break;
+      }
+    }
+    if (!statement) return;
+    let start = statement.start;
+    let end = statement.end;
+    for (let i = index - 1; i >= 0; i--) {
+      if (!isExport(stack[i])) break;
+      start = stack[i].start;
+      end = stack[i].end;
+      parent = stack[i - 1];
+    }
+    if (claimed.has(start)) return;
+    claimed.add(start);
+    const label = nameFor(stack);
+    const args = [
+      JSON.stringify(filename),
+      String(position.line),
+      String(position.column),
+      label ? JSON.stringify(label) : void 0
+    ].filter((a) => a !== void 0).join(",");
+    const mark = `globalThis.${SOURCE_MARKER}?.(${args});`;
+    if (isLoneBranch(statement, parent)) {
+      edits.push({ start, end: start, code: `{${mark}` });
+      edits.push({ start: end, end, code: "}" });
+      return;
+    }
+    edits.push({ start, end: start, code: mark });
+  });
+  return { edits, marked: edits.length };
+}
+export {
+  CLASS_MARKER,
+  COMPONENT_MARKER,
+  HOLE_MARKER,
+  PROPS_MARKER,
+  SOURCE_MARKER,
+  collectSourceEdits,
+  markHole,
+  markProps,
+  mayHaveSourceMarks
+};