@farm.js/plugin 0.1.0-beta.1 → 0.1.0-beta.100

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/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/dev-response.d.ts

@@ -0,0 +1,3 @@
+import type { ServerResponse } from "node:http";
+export declare function sendRscDevelopmentResponse(res: ServerResponse, response: Response): Promise<void>;
+//# sourceMappingURL=dev-response.d.ts.map

package/dist/rsc/dev-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev-response.d.ts","sourceRoot":"","sources":["../../src/rsc/dev-response.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAGhD,wBAAsB,0BAA0B,CAC9C,GAAG,EAAE,cAAc,EACnB,QAAQ,EAAE,QAAQ,GACjB,OAAO,CAAC,IAAI,CAAC,CAYf"}

package/dist/rsc/dev-response.js

@@ -0,0 +1,10 @@
+import { sendWebResponse } from "@farm.js/core/server";
+export async function sendRscDevelopmentResponse(res, response) {
+    const headers = new Headers(response.headers);
+    headers.delete("transfer-encoding");
+    await sendWebResponse(res, new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers,
+    }));
+}

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

@@ -1,4 +1,5 @@
 import type { EntryContext } from "../types.js";
+export declare const serverFnTransportErrorClientRuntime = "function createFarmServerFnTransportError(value) {\n  const message = value && typeof value === 'object' && typeof value.message === 'string'\n    ? value.message\n    : 'Server function failed';\n  const error = new Error(message);\n\n  if (\n    value &&\n    typeof value === 'object' &&\n    value.name === 'ServerFnFailure' &&\n    typeof value.code === 'string' &&\n    Number.isInteger(value.status) &&\n    value.status >= 400 &&\n    value.status <= 599 &&\n    Object.prototype.hasOwnProperty.call(value, 'data')\n  ) {\n    error.name = 'ServerFnFailure';\n    error.code = value.code;\n    error.status = value.status;\n    error.data = value.data;\n    Object.defineProperty(error, Symbol.for('farm.server-fn.failure'), {\n      value: true,\n      enumerable: false,\n    });\n    return error;\n  }\n\n  error.name = 'ServerActionError';\n  return error;\n}";
 /**
  * Generates the browser entry file.
  *

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

@@ -1 +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"}
+{"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,eAAO,MAAM,mCAAmC,62BA6B9C,CAAC;AAEH;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAwR7D"}

package/dist/rsc/entries/client.js

@@ -1,3 +1,33 @@
+export const serverFnTransportErrorClientRuntime = `function createFarmServerFnTransportError(value) {
+  const message = value && typeof value === 'object' && typeof value.message === 'string'
+    ? value.message
+    : 'Server function failed';
+  const error = new Error(message);
+
+  if (
+    value &&
+    typeof value === 'object' &&
+    value.name === 'ServerFnFailure' &&
+    typeof value.code === 'string' &&
+    Number.isInteger(value.status) &&
+    value.status >= 400 &&
+    value.status <= 599 &&
+    Object.prototype.hasOwnProperty.call(value, 'data')
+  ) {
+    error.name = 'ServerFnFailure';
+    error.code = value.code;
+    error.status = value.status;
+    error.data = value.data;
+    Object.defineProperty(error, Symbol.for('farm.server-fn.failure'), {
+      value: true,
+      enumerable: false,
+    });
+    return error;
+  }
+
+  error.name = 'ServerActionError';
+  return error;
+}`;
 /**
  * Generates the browser entry file.
  *
@@ -37,6 +67,7 @@ import { applyFarmCacheInvalidations } from '@farm.js/core/cache';
 import {
   beginFarmServerQueryAction,
   completeFarmServerQueryAction,
+  shouldApplyFarmServerQueryActionResult,
 } from '@farm.js/core/server-query/client';
 `;
     }
@@ -45,6 +76,8 @@ import {
     let actionSetup = "";
     if (ctx.actionsEnabled) {
         actionSetup = `
+${serverFnTransportErrorClientRuntime}
+
 // Ref for payload setter (used by server action callback and refetch)
 const setPayloadRef = { current: null };
 
@@ -92,13 +125,13 @@ setServerCallback(async (id, args) => {
     console.error('[Farm.js] Action response missing payload.root / payload.rootContent');
     return;
   }
-  setPayloadRef.current?.(p);
-  applyFarmCacheInvalidations(p.returnValue?.invalidations);
+  if (shouldApplyFarmServerQueryActionResult(serverQueryInvocation)) {
+    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;
+    throw createFarmServerFnTransportError(p.returnValue?.data);
   }
   return completeFarmServerQueryAction(serverQueryInvocation, p.returnValue.data);
 });
@@ -110,7 +143,9 @@ const setPayloadRef = { current: null };
 `;
     }
     return `${imports}
+${ctx.clientCachePersistence?.imports ?? ""}
 ${actionSetup}
+${ctx.clientCachePersistence?.init ?? ""}
 const farmDeploymentId = ${JSON.stringify(ctx.deploymentId)};
 
 function reportDeploymentMismatch(response) {
@@ -193,6 +228,8 @@ async function main() {
           if (a.hasAttribute('data-native') || a.hasAttribute('data-reload')) {
             return;
           }
+          if (e.metaKey || e.altKey || e.ctrlKey || e.shiftKey) return;
+          if (e.button !== 0) return;
           
           e.preventDefault();
           history.pushState(null, '', a.href);

package/dist/rsc/entries/error-fallback.d.ts

@@ -0,0 +1,3 @@
+/** Client-owned reset callbacks must not be serialized from the RSC server. */
+export declare function generateErrorFallbackEntry(): string;
+//# sourceMappingURL=error-fallback.d.ts.map

package/dist/rsc/entries/error-fallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-fallback.d.ts","sourceRoot":"","sources":["../../../src/rsc/entries/error-fallback.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,wBAAgB,0BAA0B,IAAI,MAAM,CAUnD"}

package/dist/rsc/entries/error-fallback.js

@@ -0,0 +1,12 @@
+/** Client-owned reset callbacks must not be serialized from the RSC server. */
+export function generateErrorFallbackEntry() {
+    return `"use client";
+import React from 'react';
+
+export default function ServerErrorFallback({ Fallback, message, fallbackProps }) {
+  const error = new Error(message);
+  const reset = () => window.location.reload();
+  return React.createElement(Fallback, { ...fallbackProps, error, reset });
+}
+`;
+}

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

@@ -1 +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"}
+{"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,CA86B1D"}