phantom-build 0.1.0

package/dist/classify/lazy-llm.d.ts

@@ -0,0 +1,122 @@
+/**
+ * LLM Lazy Optimization — IR schema, response schema, system prompt, and merge logic.
+ *
+ * Defines the compact IR sent to the LLM for the ~20% of decisions that static
+ * analysis can't make well: Suspense grouping, cross-component state awareness,
+ * and prefetch strategy refinement.
+ *
+ * Supports batched multi-module analysis — a single LLM call can process
+ * candidates from every module in the build for cross-module awareness.
+ */
+import type { LazyCandidate } from '../types.js';
+export interface LazyIR {
+    /** The parent component being analyzed */
+    parent: string;
+    file: string;
+    /** Child components that passed deterministic filtering */
+    candidates: Array<{
+        name: string;
+        source: string;
+        jsxPosition: number;
+        conditional: boolean;
+        /** From ComponentProfile (if available) */
+        hasHandlers: boolean;
+        hasState: boolean;
+        hasEffects: boolean;
+        handlerCount: number;
+        estimatedSize: number;
+        /** Heuristic assignment (LLM can override) */
+        heuristicPrefetch: string;
+        heuristicReason: string;
+    }>;
+    /** Components that were kept static (for LLM awareness) */
+    keptStatic: Array<{
+        name: string;
+        reason: string;
+    }>;
+    /** Cross-component state relationships detected statically */
+    sharedState: Array<{
+        components: string[];
+        stateDescription: string;
+    }>;
+}
+export interface BatchedLazyIR {
+    /** All modules with lazy candidates in this build */
+    modules: LazyIR[];
+    /** Total candidate count across all modules */
+    totalCandidates: number;
+}
+/** Per-candidate decision from the LLM */
+export interface LazyLLMDecision {
+    name: string;
+    /** Override the heuristic strategy (or confirm it) */
+    prefetch: 'immediate' | 'viewport' | 'interaction' | 'idle';
+    /** Group ID — components with same group share a Suspense boundary */
+    suspenseGroup: string | null;
+    /** Confidence 0-1 that this decision is correct */
+    confidence: number;
+    /** Brief reason */
+    reason: string;
+}
+/** Single-module LLM response */
+export interface LazyLLMResponse {
+    /** Optimized decisions for each candidate */
+    decisions: LazyLLMDecision[];
+    /** Any candidates the LLM thinks should be moved to keepStatic */
+    overrideToStatic: Array<{
+        name: string;
+        reason: string;
+    }>;
+    /** Cross-component insights */
+    insights: string[];
+}
+/** Batched response — one LazyLLMResponse per module, keyed by file path */
+export interface BatchedLazyLLMResponse {
+    modules: Record<string, LazyLLMResponse>;
+    /** Global insights that span multiple modules */
+    globalInsights: string[];
+}
+export declare const LAZY_SYSTEM_PROMPT = "You are a React performance optimization assistant. You receive a JSON object describing a React component's child imports that have been identified as candidates for React.lazy() wrapping.\n\nYour job:\n1. Confirm or override the heuristic prefetch strategy for each candidate\n2. Assign suspense groups \u2014 components that share state or must hydrate together should share a group ID\n3. Flag any candidates that should actually be kept static (the heuristic may have been too aggressive)\n\nGrouping rules:\n- Components sharing mutable state MUST be in the same Suspense group\n- Adjacent siblings with no shared state CAN be grouped (reduces boundaries)\n- Conditionally rendered components should NEVER be grouped with unconditionally rendered ones\n- Context consumers that depend on the same provider can be grouped\n\nStrategy definitions:\n- \"immediate\": Component is critical path, must hydrate ASAP\n- \"viewport\": Component is below fold but visible on scroll\n- \"interaction\": Component only renders on user action (conditional)\n- \"idle\": Component can load when browser is idle (low priority, background)\n\nRespond with ONLY a valid JSON object matching this schema:\n{\n  \"decisions\": [{ \"name\": string, \"prefetch\": string, \"suspenseGroup\": string|null, \"confidence\": number, \"reason\": string }],\n  \"overrideToStatic\": [{ \"name\": string, \"reason\": string }],\n  \"insights\": [string]\n}";
+export declare const LAZY_BATCHED_SYSTEM_PROMPT = "You are a React performance optimization assistant. You receive a JSON object containing MULTIPLE modules from a single build, each with child component imports identified as candidates for React.lazy() wrapping.\n\nBecause you see ALL modules at once, you can make cross-module decisions:\n- Detect shared state between components in different modules\n- Identify common import patterns across the application\n- Make globally consistent Suspense grouping decisions\n\nYour job for EACH module:\n1. Confirm or override the heuristic prefetch strategy for each candidate\n2. Assign suspense groups \u2014 components that share state or must hydrate together should share a group ID\n3. Flag any candidates that should actually be kept static (the heuristic may have been too aggressive)\n\nGrouping rules:\n- Components sharing mutable state MUST be in the same Suspense group\n- Adjacent siblings with no shared state CAN be grouped (reduces boundaries)\n- Conditionally rendered components should NEVER be grouped with unconditionally rendered ones\n- Context consumers that depend on the same provider can be grouped\n- Components imported in MULTIPLE modules should have consistent strategies\n\nStrategy definitions:\n- \"immediate\": Component is critical path, must hydrate ASAP\n- \"viewport\": Component is below fold but visible on scroll\n- \"interaction\": Component only renders on user action (conditional)\n- \"idle\": Component can load when browser is idle (low priority, background)\n\nRespond with ONLY a valid JSON object matching this schema:\n{\n  \"modules\": {\n    \"<file_path>\": {\n      \"decisions\": [{ \"name\": string, \"prefetch\": string, \"suspenseGroup\": string|null, \"confidence\": number, \"reason\": string }],\n      \"overrideToStatic\": [{ \"name\": string, \"reason\": string }],\n      \"insights\": [string]\n    }\n  },\n  \"globalInsights\": [string]\n}";
+/**
+ * Build a BatchedLazyIR from multiple modules' stashed data.
+ * Used by the plugin to construct the single LLM call payload.
+ */
+export declare function buildBatchedIR(moduleData: Array<{
+    ir: LazyIR;
+}>): BatchedLazyIR;
+/**
+ * Apply a batched LLM response to each module's candidates.
+ * Returns a map of file path → merged results.
+ */
+export declare function mergeBatchedLLMDecisions(moduleStash: Map<string, {
+    candidates: LazyCandidate[];
+    keepStatic: Array<{
+        localName: string;
+        source: string;
+        reason: string;
+    }>;
+}>, batchedResponse: BatchedLazyLLMResponse, confidenceThreshold?: number): Map<string, {
+    updated: LazyCandidate[];
+    movedToStatic: Array<{
+        localName: string;
+        source: string;
+        reason: string;
+    }>;
+    insights: string[];
+}>;
+/**
+ * Merge LLM optimization response into the heuristic lazy candidates.
+ *
+ * Called after inference returns. Updates prefetch strategies, suspense
+ * groups, and filters out any candidates the LLM thinks should be static.
+ */
+export declare function mergeLLMDecisions(candidates: LazyCandidate[], llmResponse: LazyLLMResponse, confidenceThreshold?: number): {
+    updated: LazyCandidate[];
+    movedToStatic: Array<{
+        localName: string;
+        source: string;
+        reason: string;
+    }>;
+};
+//# sourceMappingURL=lazy-llm.d.ts.map

package/dist/classify/lazy-llm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy-llm.d.ts","sourceRoot":"","sources":["../../src/classify/lazy-llm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAIjD,MAAM,WAAW,MAAM;IACrB,0CAA0C;IAC1C,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IAEb,2DAA2D;IAC3D,UAAU,EAAE,KAAK,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,EAAE,OAAO,CAAC;QAErB,2CAA2C;QAC3C,WAAW,EAAE,OAAO,CAAC;QACrB,QAAQ,EAAE,OAAO,CAAC;QAClB,UAAU,EAAE,OAAO,CAAC;QACpB,YAAY,EAAE,MAAM,CAAC;QACrB,aAAa,EAAE,MAAM,CAAC;QAEtB,8CAA8C;QAC9C,iBAAiB,EAAE,MAAM,CAAC;QAC1B,eAAe,EAAE,MAAM,CAAC;KACzB,CAAC,CAAC;IAEH,2DAA2D;IAC3D,UAAU,EAAE,KAAK,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC,CAAC;IAEH,8DAA8D;IAC9D,WAAW,EAAE,KAAK,CAAC;QACjB,UAAU,EAAE,MAAM,EAAE,CAAC;QACrB,gBAAgB,EAAE,MAAM,CAAC;KAC1B,CAAC,CAAC;CACJ;AAID,MAAM,WAAW,aAAa;IAC5B,qDAAqD;IACrD,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,+CAA+C;IAC/C,eAAe,EAAE,MAAM,CAAC;CACzB;AAID,0CAA0C;AAC1C,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,sDAAsD;IACtD,QAAQ,EAAE,WAAW,GAAG,UAAU,GAAG,aAAa,GAAG,MAAM,CAAC;IAC5D,sEAAsE;IACtE,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,mDAAmD;IACnD,UAAU,EAAE,MAAM,CAAC;IACnB,mBAAmB;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,iCAAiC;AACjC,MAAM,WAAW,eAAe;IAC9B,6CAA6C;IAC7C,SAAS,EAAE,eAAe,EAAE,CAAC;IAE7B,kEAAkE;IAClE,gBAAgB,EAAE,KAAK,CAAC;QACtB,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC,CAAC;IAEH,+BAA+B;IAC/B,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,4EAA4E;AAC5E,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IACzC,iDAAiD;IACjD,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B;AAID,eAAO,MAAM,kBAAkB,+5CAwB7B,CAAC;AAEH,eAAO,MAAM,0BAA0B,o3DAmCrC,CAAC;AAEH;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,KAAK,CAAC;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC,GAChC,aAAa,CAOf;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE;IAAE,UAAU,EAAE,aAAa,EAAE,CAAC;IAAC,UAAU,EAAE,KAAK,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAE,CAAC,EACnI,eAAe,EAAE,sBAAsB,EACvC,mBAAmB,GAAE,MAAY,GAChC,GAAG,CAAC,MAAM,EAAE;IAAE,OAAO,EAAE,aAAa,EAAE,CAAC;IAAC,aAAa,EAAE,KAAK,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CA6B5I;AAID;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,aAAa,EAAE,EAC3B,WAAW,EAAE,eAAe,EAC5B,mBAAmB,GAAE,MAAY,GAChC;IAAE,OAAO,EAAE,aAAa,EAAE,CAAC;IAAC,aAAa,EAAE,KAAK,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAE,CAoC3G"}

package/dist/classify/lazy-llm.js

@@ -0,0 +1,142 @@
+/**
+ * LLM Lazy Optimization — IR schema, response schema, system prompt, and merge logic.
+ *
+ * Defines the compact IR sent to the LLM for the ~20% of decisions that static
+ * analysis can't make well: Suspense grouping, cross-component state awareness,
+ * and prefetch strategy refinement.
+ *
+ * Supports batched multi-module analysis — a single LLM call can process
+ * candidates from every module in the build for cross-module awareness.
+ */
+// ── System prompt ────────────────────────────────────────────────────────
+export const LAZY_SYSTEM_PROMPT = `You are a React performance optimization assistant. You receive a JSON object describing a React component's child imports that have been identified as candidates for React.lazy() wrapping.
+
+Your job:
+1. Confirm or override the heuristic prefetch strategy for each candidate
+2. Assign suspense groups — components that share state or must hydrate together should share a group ID
+3. Flag any candidates that should actually be kept static (the heuristic may have been too aggressive)
+
+Grouping rules:
+- Components sharing mutable state MUST be in the same Suspense group
+- Adjacent siblings with no shared state CAN be grouped (reduces boundaries)
+- Conditionally rendered components should NEVER be grouped with unconditionally rendered ones
+- Context consumers that depend on the same provider can be grouped
+
+Strategy definitions:
+- "immediate": Component is critical path, must hydrate ASAP
+- "viewport": Component is below fold but visible on scroll
+- "interaction": Component only renders on user action (conditional)
+- "idle": Component can load when browser is idle (low priority, background)
+
+Respond with ONLY a valid JSON object matching this schema:
+{
+  "decisions": [{ "name": string, "prefetch": string, "suspenseGroup": string|null, "confidence": number, "reason": string }],
+  "overrideToStatic": [{ "name": string, "reason": string }],
+  "insights": [string]
+}`;
+export const LAZY_BATCHED_SYSTEM_PROMPT = `You are a React performance optimization assistant. You receive a JSON object containing MULTIPLE modules from a single build, each with child component imports identified as candidates for React.lazy() wrapping.
+
+Because you see ALL modules at once, you can make cross-module decisions:
+- Detect shared state between components in different modules
+- Identify common import patterns across the application
+- Make globally consistent Suspense grouping decisions
+
+Your job for EACH module:
+1. Confirm or override the heuristic prefetch strategy for each candidate
+2. Assign suspense groups — components that share state or must hydrate together should share a group ID
+3. Flag any candidates that should actually be kept static (the heuristic may have been too aggressive)
+
+Grouping rules:
+- Components sharing mutable state MUST be in the same Suspense group
+- Adjacent siblings with no shared state CAN be grouped (reduces boundaries)
+- Conditionally rendered components should NEVER be grouped with unconditionally rendered ones
+- Context consumers that depend on the same provider can be grouped
+- Components imported in MULTIPLE modules should have consistent strategies
+
+Strategy definitions:
+- "immediate": Component is critical path, must hydrate ASAP
+- "viewport": Component is below fold but visible on scroll
+- "interaction": Component only renders on user action (conditional)
+- "idle": Component can load when browser is idle (low priority, background)
+
+Respond with ONLY a valid JSON object matching this schema:
+{
+  "modules": {
+    "<file_path>": {
+      "decisions": [{ "name": string, "prefetch": string, "suspenseGroup": string|null, "confidence": number, "reason": string }],
+      "overrideToStatic": [{ "name": string, "reason": string }],
+      "insights": [string]
+    }
+  },
+  "globalInsights": [string]
+}`;
+/**
+ * Build a BatchedLazyIR from multiple modules' stashed data.
+ * Used by the plugin to construct the single LLM call payload.
+ */
+export function buildBatchedIR(moduleData) {
+    const modules = moduleData.map((d) => d.ir);
+    const totalCandidates = modules.reduce((sum, m) => sum + m.candidates.length, 0);
+    return { modules, totalCandidates };
+}
+/**
+ * Apply a batched LLM response to each module's candidates.
+ * Returns a map of file path → merged results.
+ */
+export function mergeBatchedLLMDecisions(moduleStash, batchedResponse, confidenceThreshold = 0.8) {
+    const results = new Map();
+    for (const [filePath, stashed] of moduleStash) {
+        const moduleResponse = batchedResponse.modules[filePath];
+        if (!moduleResponse) {
+            // LLM didn't return data for this module — keep heuristic decisions
+            results.set(filePath, {
+                updated: stashed.candidates,
+                movedToStatic: [],
+                insights: [],
+            });
+            continue;
+        }
+        const { updated, movedToStatic } = mergeLLMDecisions(stashed.candidates, moduleResponse, confidenceThreshold);
+        results.set(filePath, {
+            updated,
+            movedToStatic,
+            insights: moduleResponse.insights ?? [],
+        });
+    }
+    return results;
+}
+// ── Merge function ───────────────────────────────────────────────────────
+/**
+ * Merge LLM optimization response into the heuristic lazy candidates.
+ *
+ * Called after inference returns. Updates prefetch strategies, suspense
+ * groups, and filters out any candidates the LLM thinks should be static.
+ */
+export function mergeLLMDecisions(candidates, llmResponse, confidenceThreshold = 0.8) {
+    const movedToStatic = [];
+    // Build lookup from LLM decisions
+    const decisionMap = new Map(llmResponse.decisions.map((d) => [d.name, d]));
+    const remaining = [];
+    for (const candidate of candidates) {
+        // Check if LLM wants to move this to static
+        const override = llmResponse.overrideToStatic.find((o) => o.name === candidate.localName);
+        if (override) {
+            movedToStatic.push({
+                localName: candidate.localName,
+                source: candidate.source,
+                reason: `LLM override: ${override.reason}`,
+            });
+            continue;
+        }
+        // Apply LLM decision if confidence is above threshold
+        const decision = decisionMap.get(candidate.localName);
+        if (decision && decision.confidence >= confidenceThreshold) {
+            candidate.prefetch = decision.prefetch;
+            candidate.suspenseGroup = decision.suspenseGroup;
+            candidate.reason = `LLM: ${decision.reason}`;
+        }
+        remaining.push(candidate);
+    }
+    return { updated: remaining, movedToStatic };
+}
+//# sourceMappingURL=lazy-llm.js.map

package/dist/classify/lazy-llm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy-llm.js","sourceRoot":"","sources":["../../src/classify/lazy-llm.ts"],"names":[],"mappings":"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"}

package/dist/classify/lazy.d.ts

@@ -0,0 +1,23 @@
+import type { AnalyzedModule, ClassifiedSegment, LazyCandidateResult, ComponentProfile } from '../types.js';
+/** Re-export map type: barrel file path → (exportedName → { source, importedName }) */
+type ReExportMap = Map<string, Map<string, {
+    source: string;
+    importedName: string;
+}>>;
+/**
+ * Detect which imported child components are candidates for React.lazy wrapping.
+ *
+ * Runs after segment classification so it can use handler/effect counts
+ * from sibling modules (via componentProfiles). Works standalone with
+ * heuristics when profiles aren't available.
+ *
+ * @param analyzed    - The parsed + scope-analyzed module
+ * @param sourceCode  - Raw source text
+ * @param segments    - Already-classified segments for THIS module
+ * @param componentProfiles - Optional: analysis results from imported modules
+ *                            (keyed by resolved file path or import source)
+ * @param reExportMap - Optional: barrel file re-export mappings accumulated during build
+ */
+export declare function detectLazyCandidates(analyzed: AnalyzedModule, sourceCode: string, segments: ClassifiedSegment[], componentProfiles?: Map<string, ComponentProfile>, reExportMap?: ReExportMap): LazyCandidateResult;
+export {};
+//# sourceMappingURL=lazy.d.ts.map

package/dist/classify/lazy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy.d.ts","sourceRoot":"","sources":["../../src/classify/lazy.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,cAAc,EACd,iBAAiB,EAEjB,mBAAmB,EACnB,gBAAgB,EAEjB,MAAM,aAAa,CAAC;AAErB,uFAAuF;AACvF,KAAK,WAAW,GAAG,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAAC;AAiCtF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,cAAc,EACxB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,iBAAiB,EAAE,EAC7B,iBAAiB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,EACjD,WAAW,CAAC,EAAE,WAAW,GACxB,mBAAmB,CAqGrB"}