@pyreon/compiler 0.15.0 → 0.18.0

package/lib/types/index.d.ts

@@ -1,3 +1,73 @@
+//#region src/defer-inline.d.ts
+/**
+ * Inline-children transform for `<Defer>`.
+ *
+ * Rewrites:
+ *
+ *     import { Modal } from './Modal'
+ *     <Defer when={open()}><Modal /></Defer>
+ *
+ * into:
+ *
+ *     <Defer when={open()} chunk={() => import('./Modal').then(m => ({ default: m.Modal }))}>
+ *       {C => <C />}
+ *     </Defer>
+ *
+ * The static `import { Modal } from './Modal'` is removed when `Modal` is
+ * referenced ONLY inside the Defer subtree — otherwise Rolldown would
+ * bundle the module statically and the dynamic import becomes a no-op.
+ *
+ * Scope of v1 (this file):
+ *   - Single Defer element per file (no nested handling — bail otherwise).
+ *   - Children: exactly ONE JSXElement, self-closing, capitalised name
+ *     (component reference), no props. Props or multiple children → leave
+ *     the Defer untransformed (user must use the explicit `chunk` form).
+ *   - Imports: named OR default. Namespace imports (`import * as Mod`)
+ *     and destructured-renamed (`{ X as Y }`) not handled in v1.
+ *   - Triggers (`when={...}`, `on="visible"`, `on="idle"`) pass through.
+ *   - Other props on `<Defer>` (e.g. `fallback`) pass through.
+ *
+ * The transform is intentionally conservative — anything unusual leaves
+ * the source unchanged + emits a warning. v2 follow-ups can relax these
+ * constraints with closure-capture handling, namespace imports, etc.
+ *
+ * Pipeline: this runs BEFORE `transformJSX()` in the vite plugin. The
+ * output is still JSX — `transformJSX` then converts it to `h()` /
+ * `_tpl()` calls as usual.
+ */
+interface DeferInlineWarning {
+  message: string;
+  line: number;
+  column: number;
+  code: 'defer-inline/multiple-children' | 'defer-inline/non-component-child' | 'defer-inline/child-has-props' | 'defer-inline/import-not-found' | 'defer-inline/import-used-elsewhere' | 'defer-inline/unsupported-import-shape';
+}
+interface DeferInlineResult {
+  /** Transformed source — same as input when no transform applied. */
+  code: string;
+  /** True when at least one Defer JSX element was rewritten. */
+  changed: boolean;
+  /** Soft warnings for cases the transform deliberately skipped. */
+  warnings: DeferInlineWarning[];
+}
+/**
+ * Main entry. Returns the (possibly transformed) source plus the list
+ * of warnings for cases the transform deliberately skipped.
+ *
+ * Bails (returns input unchanged with `changed: false`) when:
+ *   - No `<Defer>` JSX element appears in the file (fast path).
+ *   - The file fails to parse (syntax error — let downstream handle).
+ *   - No `<Defer>` matches the inline-eligible shape.
+ *
+ * Per-Defer skips with a warning:
+ *   - Multiple children → user must use render-prop form
+ *   - Child has props → user must use render-prop form
+ *   - Child name isn't imported → can't resolve the chunk source
+ *   - Child binding is used outside the Defer subtree → can't remove
+ *     the static import (dynamic import would be a no-op via Rolldown's
+ *     same-module dedup)
+ */
+declare function transformDeferInline(code: string, filename?: string): DeferInlineResult;
+//#endregion
 //#region src/jsx.d.ts
 /**
  * JSX transform — wraps dynamic JSX expressions in `() =>` so the Pyreon runtime
@@ -206,6 +276,14 @@ declare function diagnoseError(error: string): ErrorDiagnosis | null;
  *  - `as-unknown-as-vnodechild` — defensive `as unknown as VNodeChild`
  *                       cast on JSX returns is unnecessary (`JSX.Element`
  *                       is already assignable to `VNodeChild`).
+ *  - `island-never-with-registry-entry` — an `island()` declared with
+ *                       `hydrate: 'never'` is also registered in the same
+ *                       file's `hydrateIslands({ ... })` call. The whole
+ *                       point of `'never'` is shipping zero client JS;
+ *                       registering pulls the component module into the
+ *                       client bundle graph (the runtime short-circuits
+ *                       and never calls the loader, but the bundler still
+ *                       includes the import). Drop the registry entry.
  *
  * Two-mode surface mirrors `react-intercept.ts`:
  *  - `detectPyreonPatterns(code)` — diagnostics only
@@ -226,7 +304,7 @@ declare function diagnoseError(error: string): ErrorDiagnosis | null;
  *  2. CLI `pyreon doctor`
  *  3. MCP server `validate` tool
  */
-type PyreonDiagnosticCode = 'for-missing-by' | 'for-with-key' | 'props-destructured' | 'process-dev-gate' | 'empty-theme' | 'raw-add-event-listener' | 'raw-remove-event-listener' | 'date-math-random-id' | 'on-click-undefined' | 'signal-write-as-call' | 'static-return-null-conditional' | 'as-unknown-as-vnodechild';
+type PyreonDiagnosticCode = 'for-missing-by' | 'for-with-key' | 'props-destructured' | 'process-dev-gate' | 'empty-theme' | 'raw-add-event-listener' | 'raw-remove-event-listener' | 'date-math-random-id' | 'on-click-undefined' | 'signal-write-as-call' | 'static-return-null-conditional' | 'as-unknown-as-vnodechild' | 'island-never-with-registry-entry';
 interface PyreonDiagnostic {
   /** Machine-readable code for filtering + programmatic handling */
   code: PyreonDiagnosticCode;
@@ -292,5 +370,92 @@ declare function formatTestAudit(result: TestAuditResult, {
   limit
 }?: AuditFormatOptions): string;
 //#endregion
-export { type AuditFormatOptions, type AuditRisk, type CompilerWarning, type ComponentInfo, type ErrorDiagnosis, type IslandInfo, type MigrationChange, type MigrationResult, type ProjectContext, type PyreonDiagnostic, type PyreonDiagnosticCode, type ReactDiagnostic, type ReactDiagnosticCode, type RouteInfo, type TestAuditEntry, type TestAuditResult, type TransformResult, auditTestEnvironment, detectPyreonPatterns, detectReactPatterns, diagnoseError, formatTestAudit, generateContext, hasPyreonPatterns, hasReactPatterns, migrateReactCode, transformJSX, transformJSX_JS };
+//#region src/island-audit.d.ts
+type IslandFindingCode = 'never-with-registry-entry' | 'duplicate-name' | 'registry-mismatch' | 'nested-island' | 'dead-island';
+interface IslandLocation {
+  /** Absolute path */
+  path: string;
+  /** Path relative to the repo root for readable reporting */
+  relPath: string;
+  /** 1-based line number */
+  line: number;
+  /** 1-based column number */
+  column: number;
+}
+interface IslandFinding {
+  code: IslandFindingCode;
+  /** One-paragraph human-readable explanation, including the fix path. */
+  message: string;
+  /** Where the finding surfaces. */
+  location: IslandLocation;
+  /**
+   * Companion locations for cross-file findings (`duplicate-name` lists
+   * the OTHER occurrence; `nested-island` lists the inner island's
+   * declaration; `never-with-registry-entry` lists the matching island
+   * declaration).
+   */
+  related?: IslandLocation[] | undefined;
+}
+interface IslandAuditResult {
+  root: string | null;
+  findings: IslandFinding[];
+  summary: {
+    filesScanned: number;
+    islandsDeclared: number;
+    registryEntries: number;
+    findingsByCode: Record<IslandFindingCode, number>;
+  };
+}
+declare function auditIslands(rootDir: string): IslandAuditResult;
+interface IslandAuditFormatOptions {
+  /** When true, emit JSON instead of markdown-ish text. */
+  json?: boolean | undefined;
+}
+declare function formatIslandAudit(result: IslandAuditResult, options?: IslandAuditFormatOptions): string;
+//#endregion
+//#region src/ssg-audit.d.ts
+type SsgFindingCode = '404-outside-layout-dir' | 'dynamic-route-missing-get-static-paths' | 'non-literal-revalidate-export';
+interface SsgLocation {
+  /** Absolute path */
+  path: string;
+  /** Path relative to the repo root for readable reporting */
+  relPath: string;
+  /** 1-based line number */
+  line: number;
+  /** 1-based column number */
+  column: number;
+}
+interface SsgFinding {
+  code: SsgFindingCode;
+  /** One-paragraph human-readable explanation, including the fix path. */
+  message: string;
+  /** Where the finding surfaces. */
+  location: SsgLocation;
+  /**
+   * Companion locations for cross-file findings. Not currently emitted
+   * by any detector but kept in the contract so future codes have the
+   * shape available without an API change.
+   */
+  related?: SsgLocation[] | undefined;
+}
+interface SsgAuditResult {
+  root: string | null;
+  findings: SsgFinding[];
+  summary: {
+    filesScanned: number;
+    routesScanned: number;
+    dynamicRoutes: number;
+    revalidateExports: number;
+    findingsByCode: Record<SsgFindingCode, number>;
+  };
+}
+declare function auditSsg(rootDir: string): SsgAuditResult;
+interface SsgAuditFormatOptions {
+  /** Filter findings to a minimum severity. Currently all SSG findings
+   *  are 'warning'-level; reserved for future severity tiers. */
+  minSeverity?: 'warning' | 'error' | undefined;
+}
+declare function formatSsgAudit(result: SsgAuditResult, _options?: SsgAuditFormatOptions): string;
+//#endregion
+export { type AuditFormatOptions, type AuditRisk, type CompilerWarning, type ComponentInfo, type DeferInlineResult, type DeferInlineWarning, type ErrorDiagnosis, type IslandAuditFormatOptions, type IslandAuditResult, type IslandFinding, type IslandFindingCode, type IslandInfo, type IslandLocation, type MigrationChange, type MigrationResult, type ProjectContext, type PyreonDiagnostic, type PyreonDiagnosticCode, type ReactDiagnostic, type ReactDiagnosticCode, type RouteInfo, type SsgAuditFormatOptions, type SsgAuditResult, type SsgFinding, type SsgFindingCode, type SsgLocation, type TestAuditEntry, type TestAuditResult, type TransformResult, auditIslands, auditSsg, auditTestEnvironment, detectPyreonPatterns, detectReactPatterns, diagnoseError, formatIslandAudit, formatSsgAudit, formatTestAudit, generateContext, hasPyreonPatterns, hasReactPatterns, migrateReactCode, transformDeferInline, transformJSX, transformJSX_JS };
 //# sourceMappingURL=index2.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pyreon/compiler",
-  "version": "0.15.0",
+  "version": "0.18.0",
   "description": "Template and JSX compiler for Pyreon",
   "homepage": "https://github.com/pyreon/pyreon/tree/main/packages/compiler#readme",
   "bugs": {
@@ -36,6 +36,7 @@
   },
   "scripts": {
     "build": "vl_rolldown_build",
+    "build:native": "bun scripts/build-native.ts",
     "dev": "vl_rolldown_build-watch",
     "test": "vitest run",
     "typecheck": "tsc --noEmit",
@@ -45,11 +46,20 @@
   "dependencies": {
     "oxc-parser": "^0.129.0"
   },
+  "optionalDependencies": {
+    "@pyreon/compiler-darwin-arm64": "workspace:^",
+    "@pyreon/compiler-darwin-x64": "workspace:^",
+    "@pyreon/compiler-linux-arm64-gnu": "workspace:^",
+    "@pyreon/compiler-linux-arm64-musl": "workspace:^",
+    "@pyreon/compiler-linux-x64-gnu": "workspace:^",
+    "@pyreon/compiler-linux-x64-musl": "workspace:^",
+    "@pyreon/compiler-win32-x64-msvc": "workspace:^"
+  },
   "devDependencies": {
-    "@pyreon/core": "^0.15.0",
-    "@pyreon/reactivity": "^0.15.0",
-    "@pyreon/runtime-dom": "^0.15.0",
-    "@pyreon/test-utils": "^0.13.2",
+    "@pyreon/core": "^0.18.0",
+    "@pyreon/reactivity": "^0.18.0",
+    "@pyreon/runtime-dom": "^0.18.0",
+    "@pyreon/test-utils": "^0.13.5",
     "happy-dom": "^20.8.3"
   },
   "peerDependencies": {

package/src/defer-inline.ts

@@ -0,0 +1,446 @@
+/**
+ * Inline-children transform for `<Defer>`.
+ *
+ * Rewrites:
+ *
+ *     import { Modal } from './Modal'
+ *     <Defer when={open()}><Modal /></Defer>
+ *
+ * into:
+ *
+ *     <Defer when={open()} chunk={() => import('./Modal').then(m => ({ default: m.Modal }))}>
+ *       {C => <C />}
+ *     </Defer>
+ *
+ * The static `import { Modal } from './Modal'` is removed when `Modal` is
+ * referenced ONLY inside the Defer subtree — otherwise Rolldown would
+ * bundle the module statically and the dynamic import becomes a no-op.
+ *
+ * Scope of v1 (this file):
+ *   - Single Defer element per file (no nested handling — bail otherwise).
+ *   - Children: exactly ONE JSXElement, self-closing, capitalised name
+ *     (component reference), no props. Props or multiple children → leave
+ *     the Defer untransformed (user must use the explicit `chunk` form).
+ *   - Imports: named OR default. Namespace imports (`import * as Mod`)
+ *     and destructured-renamed (`{ X as Y }`) not handled in v1.
+ *   - Triggers (`when={...}`, `on="visible"`, `on="idle"`) pass through.
+ *   - Other props on `<Defer>` (e.g. `fallback`) pass through.
+ *
+ * The transform is intentionally conservative — anything unusual leaves
+ * the source unchanged + emits a warning. v2 follow-ups can relax these
+ * constraints with closure-capture handling, namespace imports, etc.
+ *
+ * Pipeline: this runs BEFORE `transformJSX()` in the vite plugin. The
+ * output is still JSX — `transformJSX` then converts it to `h()` /
+ * `_tpl()` calls as usual.
+ */
+
+import { parseSync } from 'oxc-parser'
+
+export interface DeferInlineWarning {
+  message: string
+  line: number
+  column: number
+  code:
+    | 'defer-inline/multiple-children'
+    | 'defer-inline/non-component-child'
+    | 'defer-inline/child-has-props'
+    | 'defer-inline/import-not-found'
+    | 'defer-inline/import-used-elsewhere'
+    | 'defer-inline/unsupported-import-shape'
+}
+
+export interface DeferInlineResult {
+  /** Transformed source — same as input when no transform applied. */
+  code: string
+  /** True when at least one Defer JSX element was rewritten. */
+  changed: boolean
+  /** Soft warnings for cases the transform deliberately skipped. */
+  warnings: DeferInlineWarning[]
+}
+
+interface Node {
+  type: string
+  start: number
+  end: number
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  [key: string]: any
+}
+
+interface Edit {
+  start: number
+  end: number
+  replacement: string
+}
+
+/**
+ * Detect the language for `parseSync`. `oxc-parser` infers from filename
+ * by extension — we mirror the same logic for the few extensions we
+ * support so the parser is invoked correctly.
+ */
+function getLang(filename: string): 'ts' | 'tsx' | 'js' | 'jsx' {
+  if (filename.endsWith('.tsx')) return 'tsx'
+  if (filename.endsWith('.jsx')) return 'jsx'
+  if (filename.endsWith('.ts')) return 'ts'
+  return 'js'
+}
+
+/**
+ * Returns the JSX tag name as a string when the opening element's name
+ * is a simple identifier (the only shape we recognise as a "named JSX
+ * element"). Member-expression names (`<obj.X />`) and namespaced names
+ * (`<svg:rect />`) return null — the caller treats those as non-matches.
+ */
+function getJsxName(node: Node): string | null {
+  const open = node.openingElement as Node | undefined
+  if (!open) return null
+  const name = open.name as Node | undefined
+  if (!name || name.type !== 'JSXIdentifier') return null
+  return name.name as string
+}
+
+/**
+ * `<Tag />` qualifies as a "bare component reference child" when:
+ *   - It's a JSXElement (not text, fragment, or expression container).
+ *   - The opening name is a capitalised JSXIdentifier (component).
+ *   - It has no attributes (no props passed).
+ *   - It's self-closing OR has zero non-whitespace children.
+ */
+function isBareComponentChild(node: Node): { name: string } | null {
+  if (node.type !== 'JSXElement') return null
+  const tag = getJsxName(node)
+  if (!tag || !/^[A-Z]/.test(tag)) return null
+  const open = node.openingElement as Node
+  const attrs = (open.attributes as Node[] | undefined) ?? []
+  if (attrs.length > 0) return null
+  const children = (node.children as Node[] | undefined) ?? []
+  for (const child of children) {
+    if (child.type === 'JSXText' && /^\s*$/.test(child.value as string)) continue
+    return null
+  }
+  return { name: tag }
+}
+
+/**
+ * Filter whitespace-only JSXText nodes; return remaining children. JSX
+ * source like `<Defer>\n  <Modal />\n</Defer>` has 3 children at the AST
+ * level: text, element, text. The text nodes are formatting noise.
+ */
+function nonWhitespaceChildren(node: Node): Node[] {
+  const children = (node.children as Node[] | undefined) ?? []
+  return children.filter(
+    (c) => !(c.type === 'JSXText' && /^\s*$/.test(c.value as string)),
+  )
+}
+
+/**
+ * `<Defer chunk={...} ...>` qualifies for the inline transform when:
+ *   - The opening name is `Defer`.
+ *   - No attribute named `chunk` (otherwise user is using the explicit form).
+ *   - Exactly ONE non-whitespace child that is a bare component reference.
+ */
+interface DeferMatch {
+  /** The <Defer> JSXElement node. */
+  node: Node
+  /** The single child component element. */
+  child: Node
+  /** Component identifier name (e.g. 'Modal'). */
+  childName: string
+  /** Position where to insert the `chunk` attribute (just after `<Defer`). */
+  insertChunkAt: number
+  /** Range covering the child JSX element + surrounding whitespace inside Defer's open/close tags. */
+  childrenRange: { start: number; end: number }
+}
+
+function findDeferMatches(program: Node): DeferMatch[] {
+  const matches: DeferMatch[] = []
+
+  const walk = (node: Node | null | undefined): void => {
+    if (!node || typeof node !== 'object') return
+
+    if (node.type === 'JSXElement' && getJsxName(node) === 'Defer') {
+      const open = node.openingElement as Node
+      const attrs = (open.attributes as Node[] | undefined) ?? []
+      const hasChunk = attrs.some(
+        (a) =>
+          a.type === 'JSXAttribute' &&
+          (a.name as Node | undefined)?.type === 'JSXIdentifier' &&
+          (a.name as Node).name === 'chunk',
+      )
+      if (!hasChunk) {
+        const live = nonWhitespaceChildren(node)
+        if (live.length === 1) {
+          const childInfo = isBareComponentChild(live[0]!)
+          if (childInfo) {
+            const close = node.closingElement as Node | undefined
+            matches.push({
+              node,
+              child: live[0]!,
+              childName: childInfo.name,
+              // Insert chunk attribute right after the opening tag name.
+              // `<Defer when={x}>` — we want to insert just before the `>`
+              // (or `/>` if self-closing, though Defer is never self-closing
+              // when it has inline children). Use the closing `>` of the
+              // opening tag — that's `open.end - 1` for `<Defer ...>` form.
+              insertChunkAt: (open.end as number) - 1,
+              childrenRange: {
+                start: open.end as number,
+                end: (close?.start as number) ?? (node.end as number),
+              },
+            })
+          }
+        }
+      }
+    }
+
+    // Recurse — JSX children, prop expressions, statements, etc.
+    for (const key in node) {
+      if (key === 'parent') continue
+      const v = node[key]
+      if (Array.isArray(v)) {
+        for (const item of v) walk(item as Node)
+      } else if (v && typeof v === 'object' && typeof (v as Node).type === 'string') {
+        walk(v as Node)
+      }
+    }
+  }
+
+  walk(program)
+  return matches
+}
+
+/**
+ * Find ImportDeclarations matching a target identifier and classify them.
+ * Returns null when the binding can't be resolved or the import shape
+ * isn't one we handle (namespace, renamed destructure).
+ */
+interface ImportInfo {
+  /** The `ImportDeclaration` AST node. */
+  node: Node
+  /** The module source string (without quotes). */
+  source: string
+  /** 'default' or 'named' — controls how the rewrite resolves the chunk. */
+  kind: 'default' | 'named'
+}
+
+function findImportFor(program: Node, name: string): ImportInfo | null {
+  const body = (program.body as Node[] | undefined) ?? []
+  for (const stmt of body) {
+    if (stmt.type !== 'ImportDeclaration') continue
+    const specifiers = (stmt.specifiers as Node[] | undefined) ?? []
+    for (const spec of specifiers) {
+      if (spec.type === 'ImportDefaultSpecifier') {
+        const local = (spec.local as Node).name as string
+        if (local === name) {
+          return {
+            node: stmt,
+            source: (stmt.source as Node).value as string,
+            kind: 'default',
+          }
+        }
+      } else if (spec.type === 'ImportSpecifier') {
+        const local = (spec.local as Node).name as string
+        const imported = (spec.imported as Node | undefined)?.name as string | undefined
+        // Only handle the un-renamed case: `import { Modal } from ...`.
+        // `{ Modal as M }` — skip (would need to know the original export
+        // name for the chunk-resolution path; v1 bails).
+        if (local === name && imported !== undefined && imported === local) {
+          return {
+            node: stmt,
+            source: (stmt.source as Node).value as string,
+            kind: 'named',
+          }
+        }
+      }
+      // ImportNamespaceSpecifier (`import * as M`) — not handled in v1.
+    }
+  }
+  return null
+}
+
+/**
+ * Count references to `name` outside the given JSXElement subtree. The
+ * static import can only be safely removed if the binding is used
+ * EXCLUSIVELY inside that subtree.
+ */
+function countReferencesOutside(program: Node, name: string, skipSubtree: Node): number {
+  let count = 0
+  const skipStart = skipSubtree.start as number
+  const skipEnd = skipSubtree.end as number
+
+  // Walk every statement except ImportDeclarations (we don't want the
+  // import specifier itself to count as a usage). Within each statement
+  // walk recursively, skipping any subtree whose byte range falls
+  // entirely inside the Defer being rewritten.
+  const countInNode = (node: Node): void => {
+    if (!node || typeof node !== 'object') return
+    const ns = node.start as number | undefined
+    const ne = node.end as number | undefined
+    if (typeof ns === 'number' && typeof ne === 'number' && ns >= skipStart && ne <= skipEnd) {
+      return
+    }
+    if (node.type === 'Identifier' && (node.name as string) === name) count++
+    if (node.type === 'JSXIdentifier' && (node.name as string) === name) count++
+    for (const key in node) {
+      if (key === 'parent') continue
+      const v = node[key]
+      if (Array.isArray(v)) {
+        for (const item of v) countInNode(item as Node)
+      } else if (v && typeof v === 'object' && typeof (v as Node).type === 'string') {
+        countInNode(v as Node)
+      }
+    }
+  }
+  const body = (program.body as Node[] | undefined) ?? []
+  for (const stmt of body) {
+    if (stmt.type === 'ImportDeclaration') continue
+    countInNode(stmt)
+  }
+  return count
+}
+
+/** Build the chunk={...} attribute string for a default or named import. */
+function buildChunkAttr(source: string, kind: 'default' | 'named', name: string): string {
+  if (kind === 'default') {
+    return ` chunk={() => import('${source}')}`
+  }
+  // Named: re-wrap so the chunk's `default` is the named export.
+  return ` chunk={() => import('${source}').then((__m) => ({ default: __m.${name} }))}`
+}
+
+/**
+ * Apply edits to the source string. Edits MUST be non-overlapping; we
+ * sort by start descending and splice each into the source so earlier
+ * positions stay valid as we work backwards.
+ */
+function applyEdits(source: string, edits: Edit[]): string {
+  const sorted = [...edits].sort((a, b) => b.start - a.start)
+  let out = source
+  for (const e of sorted) {
+    out = out.slice(0, e.start) + e.replacement + out.slice(e.end)
+  }
+  return out
+}
+
+/**
+ * Main entry. Returns the (possibly transformed) source plus the list
+ * of warnings for cases the transform deliberately skipped.
+ *
+ * Bails (returns input unchanged with `changed: false`) when:
+ *   - No `<Defer>` JSX element appears in the file (fast path).
+ *   - The file fails to parse (syntax error — let downstream handle).
+ *   - No `<Defer>` matches the inline-eligible shape.
+ *
+ * Per-Defer skips with a warning:
+ *   - Multiple children → user must use render-prop form
+ *   - Child has props → user must use render-prop form
+ *   - Child name isn't imported → can't resolve the chunk source
+ *   - Child binding is used outside the Defer subtree → can't remove
+ *     the static import (dynamic import would be a no-op via Rolldown's
+ *     same-module dedup)
+ */
+export function transformDeferInline(
+  code: string,
+  filename = 'input.tsx',
+): DeferInlineResult {
+  const warnings: DeferInlineWarning[] = []
+
+  // Fast path — skip the parse entirely when the file has no Defer mention.
+  if (!code.includes('Defer')) {
+    return { code, changed: false, warnings }
+  }
+
+  let program: Node
+  try {
+    const result = parseSync(filename, code, {
+      sourceType: 'module',
+      lang: getLang(filename),
+    })
+    program = result.program as Node
+  } catch {
+    // Parse failure — leave to the downstream transformJSX which reports
+    // its own diagnostics.
+    return { code, changed: false, warnings }
+  }
+
+  const matches = findDeferMatches(program)
+  if (matches.length === 0) return { code, changed: false, warnings }
+
+  const edits: Edit[] = []
+  let changed = false
+
+  for (const m of matches) {
+    const importInfo = findImportFor(program, m.childName)
+    if (!importInfo) {
+      const loc = getLoc(code, (m.child.start as number) ?? 0)
+      warnings.push({
+        message: `<Defer>'s inline child <${m.childName} /> isn't imported — can't resolve a chunk source. Use the explicit \`chunk\` prop, or import ${m.childName} from a module.`,
+        line: loc.line,
+        column: loc.column,
+        code: 'defer-inline/import-not-found',
+      })
+      continue
+    }
+
+    const outsideUses = countReferencesOutside(program, m.childName, m.node)
+    if (outsideUses > 0) {
+      const loc = getLoc(code, (m.node.start as number) ?? 0)
+      warnings.push({
+        message: `<Defer>'s inline child <${m.childName} /> is also referenced elsewhere in this file. Inline form requires the import to be used exclusively inside this Defer. Use the explicit \`chunk\` prop form to split despite shared usage.`,
+        line: loc.line,
+        column: loc.column,
+        code: 'defer-inline/import-used-elsewhere',
+      })
+      continue
+    }
+
+    // 1. Insert chunk attribute just before the opening tag's `>`.
+    edits.push({
+      start: m.insertChunkAt,
+      end: m.insertChunkAt,
+      replacement: buildChunkAttr(importInfo.source, importInfo.kind, m.childName),
+    })
+
+    // 2. Replace the children (the bare `<Modal />`) with a render-prop
+    //    that invokes the loaded component. Preserve surrounding
+    //    whitespace by replacing only the JSX text region inside Defer's
+    //    open/close tags. Use a non-letter identifier for the render-prop
+    //    binding (`__C`) to avoid clashing with anything in scope.
+    edits.push({
+      start: m.childrenRange.start,
+      end: m.childrenRange.end,
+      replacement: `{(__C) => <__C />}`,
+    })
+
+    // 3. Remove the static import. Replace the entire ImportDeclaration
+    //    range with an empty string. Includes the trailing newline if
+    //    present so we don't leave a blank line.
+    const impStart = importInfo.node.start as number
+    let impEnd = importInfo.node.end as number
+    if (code[impEnd] === '\n') impEnd += 1
+    edits.push({
+      start: impStart,
+      end: impEnd,
+      replacement: '',
+    })
+
+    changed = true
+  }
+
+  if (!changed) return { code, changed: false, warnings }
+
+  return { code: applyEdits(code, edits), changed: true, warnings }
+}
+
+/** Resolve a byte offset into 1-based line + 0-based column. */
+function getLoc(code: string, offset: number): { line: number; column: number } {
+  let line = 1
+  let lastNl = -1
+  for (let i = 0; i < offset && i < code.length; i++) {
+    if (code.charCodeAt(i) === 10 /* \n */) {
+      line++
+      lastNl = i
+    }
+  }
+  return { line, column: offset - lastNl - 1 }
+}