@farm.js/plugin 0.1.0-beta.10 → 0.1.0-beta.13

package/dist/rsc/automatic-optimized-boundary.js

@@ -0,0 +1,162 @@
+import { parseAst } from "vite";
+const JSX_RUNTIME_MODULES = new Set(["react/jsx-runtime", "react/jsx-dev-runtime"]);
+const JSX_FACTORY_EXPORTS = new Set(["jsx", "jsxs", "jsxDEV"]);
+const AUTOMATIC_BOUNDARY_TAGS = new Set([
+    "article",
+    "aside",
+    "div",
+    "footer",
+    "header",
+    "main",
+    "nav",
+    "section",
+    "span",
+]);
+const AUTOMATIC_BOUNDARY_IMPORT = "@farm.js/plugin/rsc/optimized-boundary";
+function nodeName(node) {
+    if (!node || typeof node !== "object")
+        return undefined;
+    const candidate = node;
+    if (typeof candidate.name === "string")
+        return candidate.name;
+    if (typeof candidate.value === "string")
+        return candidate.value;
+    return undefined;
+}
+function isClientModule(body) {
+    for (const statement of body) {
+        if (statement.type === "ImportDeclaration")
+            return false;
+        if (statement.type !== "ExpressionStatement")
+            return false;
+        const expression = statement.expression;
+        if (expression?.type !== "Literal")
+            return false;
+        if (expression.value === "use client")
+            return true;
+    }
+    return false;
+}
+function collectJsxFactories(body) {
+    const factories = new Set();
+    for (const statement of body) {
+        if (statement.type !== "ImportDeclaration")
+            continue;
+        const source = nodeName(statement.source);
+        if (!source || !JSX_RUNTIME_MODULES.has(source))
+            continue;
+        for (const specifier of statement.specifiers || []) {
+            if (specifier.type !== "ImportSpecifier")
+                continue;
+            const imported = nodeName(specifier.imported);
+            const local = nodeName(specifier.local);
+            if (imported && local && JSX_FACTORY_EXPORTS.has(imported))
+                factories.add(local);
+        }
+    }
+    return factories;
+}
+function collectBoundaryCalls(node, factories, calls) {
+    if (!node || typeof node !== "object")
+        return;
+    if (Array.isArray(node)) {
+        for (const child of node)
+            collectBoundaryCalls(child, factories, calls);
+        return;
+    }
+    const candidate = node;
+    if (candidate.type === "CallExpression") {
+        const callee = candidate.callee;
+        const args = candidate.arguments || [];
+        const tag = args[0];
+        if (callee?.type === "Identifier" &&
+            factories.has(nodeName(callee) || "") &&
+            tag?.type === "Literal" &&
+            AUTOMATIC_BOUNDARY_TAGS.has(String(tag.value)) &&
+            typeof candidate.start === "number" &&
+            typeof candidate.end === "number") {
+            calls.push(candidate);
+        }
+    }
+    for (const [key, value] of Object.entries(candidate)) {
+        if (key === "start" || key === "end" || key === "loc")
+            continue;
+        collectBoundaryCalls(value, factories, calls);
+    }
+}
+function createHelperName(code) {
+    const base = "__farmOptimizeBoundary";
+    let name = base;
+    let suffix = 1;
+    while (new RegExp(`\\b${name}\\b`).test(code))
+        name = `${base}${suffix++}`;
+    return name;
+}
+function importInsertionPoint(body) {
+    let position = 0;
+    for (const statement of body) {
+        if (statement.type === "ImportDeclaration" && typeof statement.end === "number") {
+            position = statement.end;
+            continue;
+        }
+        if (statement.type === "ExpressionStatement") {
+            const expression = statement.expression;
+            if (expression?.type === "Literal" && typeof statement.end === "number") {
+                position = statement.end;
+                continue;
+            }
+        }
+        break;
+    }
+    return position;
+}
+/**
+ * Wrap React JSX-runtime calls for native host boundaries with Farm's
+ * server-only optimizer. Eligibility is decided against the fully evaluated
+ * React element at runtime, so unsupported trees retain normal React behavior.
+ */
+export function transformAutomaticOptimizedBoundaries(code, id) {
+    const cleanId = id.split("?", 1)[0].replace(/\\/g, "/");
+    if (!/\.[cm]?[jt]sx?$/.test(cleanId))
+        return null;
+    if (cleanId.includes("/node_modules/") || cleanId.includes("/.farm/"))
+        return null;
+    if (!code.includes("react/jsx-runtime") && !code.includes("react/jsx-dev-runtime"))
+        return null;
+    let ast;
+    try {
+        ast = parseAst(code);
+    }
+    catch {
+        return null;
+    }
+    const body = ast.body || [];
+    if (isClientModule(body))
+        return null;
+    const factories = collectJsxFactories(body);
+    if (factories.size === 0)
+        return null;
+    const calls = [];
+    collectBoundaryCalls(ast, factories, calls);
+    if (calls.length === 0)
+        return null;
+    const helperName = createHelperName(code);
+    const insertions = [];
+    for (const call of calls) {
+        insertions.push({ position: call.start, text: `${helperName}(`, order: 1 });
+        insertions.push({ position: call.end, text: ")", order: 0 });
+    }
+    insertions.push({
+        position: importInsertionPoint(body),
+        text: `${importInsertionPoint(body) === 0 ? "" : "\n"}import { _optimizeBoundary as ${helperName} } from ${JSON.stringify(AUTOMATIC_BOUNDARY_IMPORT)};\n`,
+        order: 2,
+    });
+    let transformed = code;
+    for (const insertion of insertions.sort((left, right) => right.position - left.position || left.order - right.order)) {
+        transformed =
+            transformed.slice(0, insertion.position) +
+                insertion.text +
+                transformed.slice(insertion.position);
+    }
+    return { code: transformed, boundaryCount: calls.length };
+}

package/dist/rsc/build-paths.d.ts

@@ -0,0 +1,3 @@
+/** Resolve a Vite environment outDir without prefixing an already-absolute path. */
+export declare function resolveRscBuildOutputPath(root: string, outDir: string, ...segments: string[]): string;
+//# sourceMappingURL=build-paths.d.ts.map

package/dist/rsc/build-paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-paths.d.ts","sourceRoot":"","sources":["../../src/rsc/build-paths.ts"],"names":[],"mappings":"AAEA,oFAAoF;AACpF,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,GAAG,QAAQ,EAAE,MAAM,EAAE,GACpB,MAAM,CAKR"}

package/dist/rsc/build-paths.js

@@ -0,0 +1,8 @@
+import path from "path";
+/** Resolve a Vite environment outDir without prefixing an already-absolute path. */
+export function resolveRscBuildOutputPath(root, outDir, ...segments) {
+    const resolvedOutDir = path.isAbsolute(outDir)
+        ? path.normalize(outDir)
+        : path.resolve(root, outDir);
+    return path.join(resolvedOutDir, ...segments);
+}

package/dist/rsc/compatibility.d.ts

@@ -0,0 +1,8 @@
+/**
+ * React's framework-level RSC APIs do not follow semver. Keep the complete
+ * renderer/decoder toolchain on the exact combination exercised by Farm's
+ * integration tests instead of accepting a potentially incompatible or
+ * vulnerable package resolution.
+ */
+export declare function assertRscPackageCompatibility(root: string): void;
+//# sourceMappingURL=compatibility.d.ts.map

package/dist/rsc/compatibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compatibility.d.ts","sourceRoot":"","sources":["../../src/rsc/compatibility.ts"],"names":[],"mappings":"AA0BA;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAgChE"}

package/dist/rsc/compatibility.js

@@ -0,0 +1,46 @@
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+const RSC_PACKAGE_VERSIONS = {
+    react: "19.2.8",
+    "react-dom": "19.2.8",
+    "react-server-dom-webpack": "19.2.8",
+    "@vitejs/plugin-rsc": "0.5.32",
+};
+function readPackageVersion(projectRequire, packageName) {
+    const manifestPath = projectRequire.resolve(`${packageName}/package.json`);
+    const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+    return typeof manifest.version === "string" ? manifest.version : undefined;
+}
+/**
+ * React's framework-level RSC APIs do not follow semver. Keep the complete
+ * renderer/decoder toolchain on the exact combination exercised by Farm's
+ * integration tests instead of accepting a potentially incompatible or
+ * vulnerable package resolution.
+ */
+export function assertRscPackageCompatibility(root) {
+    const projectRequire = createRequire(path.join(path.resolve(root), "__farm_rsc_check__.cjs"));
+    const problems = [];
+    for (const [packageName, expectedVersion] of Object.entries(RSC_PACKAGE_VERSIONS)) {
+        try {
+            const actualVersion = readPackageVersion(projectRequire, packageName);
+            if (actualVersion !== expectedVersion) {
+                problems.push(`${packageName}: expected ${expectedVersion}, found ${actualVersion ?? "unknown"}`);
+            }
+        }
+        catch {
+            problems.push(`${packageName}: expected ${expectedVersion}, package is not installed`);
+        }
+    }
+    if (problems.length === 0)
+        return;
+    throw new Error([
+        "[Farm.js] Unsupported React Server Components package combination.",
+        ...problems.map((problem) => `- ${problem}`),
+        "",
+        "Farm pins the framework-level RSC APIs to one supported, integration-tested combination.",
+        "Install the supported versions with:",
+        "pnpm add react@19.2.8 react-dom@19.2.8 react-server-dom-webpack@19.2.8",
+        "pnpm add -D @vitejs/plugin-rsc@0.5.32",
+    ].join("\n"));
+}

package/dist/rsc/entries/client.d.ts

@@ -0,0 +1,14 @@
+import type { EntryContext } from "../types.js";
+/**
+ * Generates the browser entry file.
+ *
+ * This entry file:
+ * - Reads the embedded RSC payload from the HTML (via rsc-html-stream)
+ * - Deserializes it to React elements
+ * - Sets up client-side navigation (intercepts links, handles popstate)
+ * - Registers server action callback if enabled
+ * - Hydrates the page
+ * - Listens for HMR updates from server components
+ */
+export declare function generateClientEntry(ctx: EntryContext): string;
+//# sourceMappingURL=client.d.ts.map

package/dist/rsc/entries/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/rsc/entries/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAiR7D"}

package/dist/rsc/entries/client.js

@@ -0,0 +1,283 @@
+/**
+ * Generates the browser entry file.
+ *
+ * This entry file:
+ * - Reads the embedded RSC payload from the HTML (via rsc-html-stream)
+ * - Deserializes it to React elements
+ * - Sets up client-side navigation (intercepts links, handles popstate)
+ * - Registers server action callback if enabled
+ * - Hydrates the page
+ * - Listens for HMR updates from server components
+ */
+export function generateClientEntry(ctx) {
+    const debugLog = `// Debug disabled`;
+    const globalStylesheetImport = ctx.globalCssPath
+        ? `const farmGlobalStylesheets = import.meta.glob(${JSON.stringify(ctx.globalCssPath)}, {
+  eager: true,
+  import: 'default',
+  query: '?url',
+});
+export const farmGlobalStylesheet = Object.values(farmGlobalStylesheets)[0];
+`
+        : "";
+    let imports = `${globalStylesheetImport}
+import React from 'react';
+import { hydrateRoot } from 'react-dom/client';
+import { createFromReadableStream } from '@vitejs/plugin-rsc/browser';
+import { rscStream } from 'rsc-html-stream/client';
+import {
+  createFarmDeploymentMismatchError,
+  createFarmDeploymentRequestHeaders,
+  isFarmDeploymentMismatchResponse,
+} from '@farm.js/core/deployment';
+`;
+    if (ctx.actionsEnabled) {
+        imports += `import { setServerCallback, encodeReply, createTemporaryReferenceSet } from '@vitejs/plugin-rsc/browser';
+import { applyFarmCacheInvalidations } from '@farm.js/core/cache';
+import {
+  beginFarmServerQueryAction,
+  completeFarmServerQueryAction,
+} from '@farm.js/core/server-query/client';
+`;
+    }
+    // Module-level ref so the server-action callback can update UI (assigned in BrowserRoot useEffect).
+    // Set __viteRscCallServer immediately so it's never undefined when other chunks call it (then replace with real impl).
+    let actionSetup = "";
+    if (ctx.actionsEnabled) {
+        actionSetup = `
+// Ref for payload setter (used by server action callback and refetch)
+const setPayloadRef = { current: null };
+
+// Ensure __viteRscCallServer is a function before any other chunk may call it (avoids "is not a function")
+if (typeof globalThis.__viteRscCallServer !== 'function') {
+  globalThis.__viteRscCallServer = () => Promise.reject(new Error('Farm.js: server actions not ready'));
+}
+// Register real callback (replaces placeholder above)
+setServerCallback(async (id, args) => {
+  debug('Invoking server action:', id);
+  const serverQueryInvocation = beginFarmServerQueryAction(id, args);
+  const refs = createTemporaryReferenceSet();
+  const body = await encodeReply(args, { temporaryReferences: refs });
+  const headers = createFarmDeploymentRequestHeaders(farmDeploymentId, {
+    'x-farm-action-id': id,
+    'Accept': 'text/x-component',
+  });
+  if (typeof body === 'string') headers.set('Content-Type', 'text/plain; charset=utf-8');
+  else if (!(body instanceof FormData)) headers.set('Content-Type', 'application/octet-stream');
+  const res = await fetch(location.href, {
+    method: 'POST',
+    headers,
+    body,
+    cache: 'no-store',
+    credentials: 'same-origin',
+    redirect: 'error',
+  });
+  if (isFarmDeploymentMismatchResponse(res, farmDeploymentId)) {
+    throw reportDeploymentMismatch(res);
+  }
+  if (!res.ok) {
+    const text = await res.text();
+    console.error('[Farm.js] Server action request failed:', res.status, text);
+    throw new Error('Server action failed: ' + res.status);
+  }
+  let p;
+  try {
+    p = await createFromReadableStream(res.body, { temporaryReferences: refs });
+  } catch (e) {
+    console.error('[Farm.js] Failed to deserialize action response:', e);
+    throw e;
+  }
+  const hasContent = p && (typeof p.root !== 'undefined' || typeof p.rootContent !== 'undefined');
+  if (!hasContent) {
+    console.error('[Farm.js] Action response missing payload.root / payload.rootContent');
+    return;
+  }
+  setPayloadRef.current?.(p);
+  applyFarmCacheInvalidations(p.returnValue?.invalidations);
+  if (!p.returnValue || !p.returnValue.ok) {
+    debug('Server action failed:', id);
+    const error = new Error(p.returnValue?.data?.message || 'Server function failed');
+    error.name = 'ServerActionError';
+    throw error;
+  }
+  return completeFarmServerQueryAction(serverQueryInvocation, p.returnValue.data);
+});
+`;
+    }
+    else {
+        actionSetup = `
+const setPayloadRef = { current: null };
+`;
+    }
+    return `${imports}
+${actionSetup}
+const farmDeploymentId = ${JSON.stringify(ctx.deploymentId)};
+
+function reportDeploymentMismatch(response) {
+  const error = createFarmDeploymentMismatchError(response, farmDeploymentId);
+  globalThis.dispatchEvent?.(new CustomEvent('farm:deployment-mismatch', { detail: error }));
+  return error;
+}
+
+// Debug logging helper
+function debug(...args) {
+  ${debugLog}
+}
+
+async function main() {
+  // Prevent double execution (e.g. script loaded twice)
+  if (globalThis.__FARM_RSC_HYDRATED) return;
+  
+  debug('Starting client hydration');
+  
+  // Clean duplicate DOM as early as possible (server may have sent two blocks)
+  const rootEl = document.getElementById('root');
+  if (rootEl) {
+    while (rootEl.children.length > 1) rootEl.lastElementChild.remove();
+    while (rootEl.nextElementSibling) rootEl.nextElementSibling.remove();
+  }
+  
+  // Deserialize the initial RSC payload embedded in HTML
+  // rscStream extracts the payload from <script> tags added by SSR
+  let initial;
+  try {
+    initial = await createFromReadableStream(rscStream);
+    debug('Initial RSC payload deserialized');
+  } catch (e) {
+    console.error('[Farm.js] Failed to deserialize RSC payload:', e);
+    return;
+  }
+  
+  // Root component that manages RSC state
+  function BrowserRoot() {
+    const [payload, set] = React.useState(initial);
+    
+    // Expose setter for external updates (navigation, actions, HMR)
+    React.useEffect(() => {
+      setPayloadRef.current = (p) => React.startTransition(() => set(p));
+    }, []);
+
+    // Keep document metadata in sync when an RSC navigation swaps only #root.
+    React.useEffect(() => {
+      if (typeof payload.metadata?.title === 'string') {
+        document.title = payload.metadata.title;
+      } else {
+        document.title = '';
+      }
+      let description = document.querySelector('meta[name="description"]');
+      if (typeof payload.metadata?.description === 'string') {
+        if (!description) {
+          description = document.createElement('meta');
+          description.setAttribute('name', 'description');
+          document.head.appendChild(description);
+        }
+        description.setAttribute('content', payload.metadata.description);
+      } else {
+        description?.remove();
+      }
+    }, [payload.metadata?.title, payload.metadata?.description]);
+    
+    // Set up client-side navigation
+    React.useEffect(() => {
+      // Re-fetch RSC when URL changes
+      const nav = () => refetch(location.href);
+      
+      // Handle browser back/forward
+      window.addEventListener('popstate', nav);
+      
+      // Intercept link clicks for client-side navigation
+      const handleClick = (e) => {
+        const a = e.target.closest('a');
+        if (a?.href && a.origin === location.origin && !a.download && !a.target) {
+          // Check for special attributes that should skip SPA navigation
+          if (a.hasAttribute('data-native') || a.hasAttribute('data-reload')) {
+            return;
+          }
+          
+          e.preventDefault();
+          history.pushState(null, '', a.href);
+          nav();
+        }
+      };
+      
+      document.addEventListener('click', handleClick, true);
+      
+      return () => {
+        window.removeEventListener('popstate', nav);
+        document.removeEventListener('click', handleClick, true);
+      };
+    }, []);
+    
+    // Never render payload.root (full document) on the client - it creates a second visible block (entire page duplicated below).
+    // Only render rootContent (layout+page for #root).
+    const content = payload.rootContent;
+    if (content == null) {
+      if (payload.root != null) console.warn('[Farm.js] payload.rootContent missing; not using payload.root to avoid duplicate block. Keys:', Object.keys(payload));
+      return null;
+    }
+    return content;
+  }
+  
+  // Fetch new RSC payload for a URL
+  async function refetch(url) {
+    debug('Fetching RSC for:', url);
+    
+    try {
+      // Request RSC format instead of HTML
+      const res = await fetch(url, {
+        headers: createFarmDeploymentRequestHeaders(farmDeploymentId, {
+          Accept: 'text/x-component',
+        }),
+      });
+      if (isFarmDeploymentMismatchResponse(res, farmDeploymentId)) {
+        reportDeploymentMismatch(res);
+        location.assign(url);
+        return;
+      }
+      
+      if (!res.ok) {
+        console.error('[Farm.js] RSC fetch failed:', res.status);
+        // Fall back to full page navigation
+        location.href = url;
+        return;
+      }
+      
+      const newPayload = await createFromReadableStream(res.body);
+      setPayloadRef.current?.(newPayload);
+      debug('RSC navigation complete');
+    } catch (e) {
+      console.error('[Farm.js] RSC navigation failed:', e);
+      // Fall back to full page navigation
+      location.href = url;
+    }
+  }
+  const rootElForHydrate = document.getElementById('root');
+  if (!rootElForHydrate) {
+    console.error('[Farm.js] #root element not found');
+    return;
+  }
+  // Final cleanup pass before hydrate (in case DOM changed during async)
+  while (rootElForHydrate.children.length > 1) rootElForHydrate.lastElementChild.remove();
+  while (rootElForHydrate.nextElementSibling) rootElForHydrate.nextElementSibling.remove();
+  debug('Hydrating application');
+  globalThis.__FARM_RSC_HYDRATED = true;
+  hydrateRoot(rootElForHydrate, React.createElement(BrowserRoot), {
+    formState: initial.formState,
+  });
+  
+  // Handle HMR for server components
+  // When server code changes, re-fetch and re-render
+  if (import.meta.hot) {
+    import.meta.hot.on('rsc:update', () => {
+      debug('HMR update received, refetching...');
+      refetch(location.href);
+    });
+  }
+}
+
+// Start the application
+main().catch((e) => {
+  console.error('[Farm.js] Client initialization failed:', e);
+});
+`;
+}

package/dist/rsc/entries/rsc.d.ts

@@ -0,0 +1,13 @@
+import type { EntryContext } from "../types.js";
+/**
+ * Generates the RSC environment entry file.
+ *
+ * This entry file:
+ * - Auto-discovers page files using import.meta.glob
+ * - Implements file-based routing by matching URL paths to page files
+ * - Handles server actions if enabled (decoding arguments, executing, returning results)
+ * - Renders the React tree to an RSC stream
+ * - Either returns the stream directly (for client navigation) or delegates to SSR (for initial page load)
+ */
+export declare function generateRscEntry(ctx: EntryContext): string;
+//# sourceMappingURL=rsc.d.ts.map

package/dist/rsc/entries/rsc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rsc.d.ts","sourceRoot":"","sources":["../../../src/rsc/entries/rsc.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAg7B1D"}