@farm.js/plugin 0.1.0-beta.0

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

@@ -0,0 +1,36 @@
+/**
+ * Nitro-based production build for RSC (React Server Components).
+ * Wraps the built RSC entry (fetch handler) in a Nitro server for Vercel etc.
+ * Based on: https://github.com/hi-ogawa/vite-plugins (packages/nitro), vite-plugin-rsc-deploy-example.
+ */
+/**
+ * Register a server runtime owned by the Farm plugin so production output is
+ * self-contained even when the application does not install it directly.
+ */
+export declare function registerRscNitroRuntimePackage(root: string, packageName: string, packageRoot: string): void;
+/**
+ * Wait for the RSC plugin to write the assets manifest to dist/rsc (it may run after closeBundle(ssr)).
+ * Polls until the file exists and size > MIN_MANIFEST_BYTES or timeout.
+ */
+export declare function waitForRscManifest(root: string, outDir: string, options?: {
+    intervalMs?: number;
+    timeoutMs?: number;
+}): Promise<void>;
+/**
+ * Wait until all RSC build outputs exist (rsc index, ssr index, manifest). Use in buildEnd(ssr) after a short delay.
+ */
+export declare function waitForRscOutputs(root: string, outDir: string, options?: {
+    intervalMs?: number;
+    timeoutMs?: number;
+}): Promise<void>;
+export type BuildRscNitroOptions = {
+    rendererPath: string;
+    publicDir: string;
+    ssrPath?: string;
+    assetsDir?: string;
+    root: string;
+    outputDir?: string;
+    preset?: string;
+};
+export declare function buildRscNitro(options: BuildRscNitroOptions): Promise<void>;
+//# sourceMappingURL=nitro-build.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nitro-build.d.ts","sourceRoot":"","sources":["../../src/rsc/nitro-build.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAwBH;;;GAGG;AACH,wBAAgB,8BAA8B,CAC5C,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,GAClB,IAAI,CAKN;AAwFD;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,GACxD,OAAO,CAAC,IAAI,CAAC,CA0Bf;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,GACxD,OAAO,CAAC,IAAI,CAAC,CAgCf;AA+DD,MAAM,MAAM,oBAAoB,GAAG;IACjC,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,wBAAsB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC,CAqMhF"}

package/dist/rsc/nitro-build.js

@@ -0,0 +1,396 @@
+/**
+ * Nitro-based production build for RSC (React Server Components).
+ * Wraps the built RSC entry (fetch handler) in a Nitro server for Vercel etc.
+ * Based on: https://github.com/hi-ogawa/vite-plugins (packages/nitro), vite-plugin-rsc-deploy-example.
+ */
+import path from "path";
+import { createRequire } from "node:module";
+import { writeFileSync, readFileSync, mkdirSync, copyFileSync, existsSync, readdirSync, statSync, } from "fs";
+import { resolveRscBuildOutputPath } from "./build-paths.js";
+const MANIFEST_FILENAME = "__vite_rsc_assets_manifest.js";
+const MIN_MANIFEST_BYTES = 100; // real manifest is ~500+, stub is 64
+const POLL_INTERVAL_MS = 50;
+const POLL_TIMEOUT_MS = 15_000;
+const BUNDLED_RSC_RUNTIMES = ["@farming-labs/strata"];
+const runtimeRequire = createRequire(import.meta.url);
+const runtimePackagesByRoot = new Map();
+/**
+ * Register a server runtime owned by the Farm plugin so production output is
+ * self-contained even when the application does not install it directly.
+ */
+export function registerRscNitroRuntimePackage(root, packageName, packageRoot) {
+    const resolvedRoot = path.resolve(root);
+    const packages = runtimePackagesByRoot.get(resolvedRoot) ?? new Map();
+    packages.set(packageName, path.resolve(packageRoot));
+    runtimePackagesByRoot.set(resolvedRoot, packages);
+}
+function copyDir(src, dest, ignoredNames = new Set()) {
+    if (!existsSync(src))
+        return;
+    mkdirSync(dest, { recursive: true });
+    for (const name of readdirSync(src)) {
+        if (ignoredNames.has(name))
+            continue;
+        const srcPath = path.join(src, name);
+        const destPath = path.join(dest, name);
+        if (statSync(srcPath).isDirectory())
+            copyDir(srcPath, destPath, ignoredNames);
+        else
+            copyFileSync(srcPath, destPath);
+    }
+}
+function detectBundledRscRuntimes(rendererPath) {
+    const packages = new Map();
+    const rendererDir = path.dirname(path.resolve(rendererPath));
+    const files = [];
+    const collectJavaScript = (dir) => {
+        if (!existsSync(dir))
+            return;
+        for (const name of readdirSync(dir)) {
+            const candidate = path.join(dir, name);
+            if (statSync(candidate).isDirectory())
+                collectJavaScript(candidate);
+            else if (/\.(?:c|m)?js$/.test(name))
+                files.push(candidate);
+        }
+    };
+    collectJavaScript(rendererDir);
+    const source = files.map((file) => readFileSync(file, "utf-8")).join("\n");
+    for (const packageName of BUNDLED_RSC_RUNTIMES) {
+        if (!source.includes(packageName))
+            continue;
+        try {
+            const manifestPath = runtimeRequire.resolve(`${packageName}/package.json`);
+            packages.set(packageName, path.dirname(manifestPath));
+        }
+        catch {
+            throw new Error(`[Farm.js] The RSC bundle uses ${packageName}, but Farm could not locate its bundled runtime.`);
+        }
+    }
+    return packages;
+}
+function copyRuntimePackages(serverDir, packages) {
+    if (packages.size === 0)
+        return;
+    const outputPackagePath = path.join(serverDir, "package.json");
+    const outputPackage = JSON.parse(readFileSync(outputPackagePath, "utf-8"));
+    outputPackage.dependencies ??= {};
+    const copiedPackages = new Set();
+    const copyPackage = (packageName, packageRoot) => {
+        if (copiedPackages.has(packageName))
+            return;
+        const manifestPath = path.join(packageRoot, "package.json");
+        const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+        copyDir(packageRoot, path.join(serverDir, "node_modules", ...packageName.split("/")), new Set(["node_modules"]));
+        outputPackage.dependencies[packageName] = manifest.version ?? "0.0.0";
+        copiedPackages.add(packageName);
+        const packageRequire = createRequire(manifestPath);
+        for (const optionalDependency of Object.keys(manifest.optionalDependencies ?? {})) {
+            try {
+                const optionalManifestPath = packageRequire.resolve(`${optionalDependency}/package.json`);
+                copyPackage(optionalDependency, path.dirname(optionalManifestPath));
+            }
+            catch {
+                // Package managers only install optional dependencies for the current
+                // build platform. Missing platform packages are expected.
+            }
+        }
+    };
+    for (const [packageName, packageRoot] of packages) {
+        copyPackage(packageName, packageRoot);
+    }
+    writeFileSync(outputPackagePath, JSON.stringify(outputPackage, null, 2), "utf-8");
+}
+/**
+ * Wait for the RSC plugin to write the assets manifest to dist/rsc (it may run after closeBundle(ssr)).
+ * Polls until the file exists and size > MIN_MANIFEST_BYTES or timeout.
+ */
+export function waitForRscManifest(root, outDir, options = {}) {
+    const intervalMs = options.intervalMs ?? POLL_INTERVAL_MS;
+    const timeoutMs = options.timeoutMs ?? POLL_TIMEOUT_MS;
+    const manifestPath = resolveRscBuildOutputPath(root, outDir, "rsc", MANIFEST_FILENAME);
+    const deadline = Date.now() + timeoutMs;
+    return new Promise((resolve, reject) => {
+        const check = () => {
+            try {
+                if (existsSync(manifestPath)) {
+                    const size = statSync(manifestPath).size;
+                    if (size >= MIN_MANIFEST_BYTES) {
+                        resolve();
+                        return;
+                    }
+                }
+            }
+            catch {
+                // ignore
+            }
+            if (Date.now() >= deadline) {
+                reject(new Error(`Timeout waiting for RSC manifest at ${manifestPath}`));
+                return;
+            }
+            setTimeout(check, intervalMs);
+        };
+        check();
+    });
+}
+/**
+ * Wait until all RSC build outputs exist (rsc index, ssr index, manifest). Use in buildEnd(ssr) after a short delay.
+ */
+export function waitForRscOutputs(root, outDir, options = {}) {
+    const intervalMs = options.intervalMs ?? POLL_INTERVAL_MS;
+    const timeoutMs = options.timeoutMs ?? 20_000;
+    const rendererPath = resolveRscBuildOutputPath(root, outDir, "rsc", "index.js");
+    const ssrPath = resolveRscBuildOutputPath(root, outDir, "ssr", "index.js");
+    const manifestInRsc = resolveRscBuildOutputPath(root, outDir, "rsc", MANIFEST_FILENAME);
+    const manifestInSsr = resolveRscBuildOutputPath(root, outDir, "ssr", MANIFEST_FILENAME);
+    const deadline = Date.now() + timeoutMs;
+    return new Promise((resolve, reject) => {
+        const check = () => {
+            try {
+                const manifestPath = existsSync(manifestInRsc) ? manifestInRsc : manifestInSsr;
+                if (existsSync(rendererPath) &&
+                    existsSync(ssrPath) &&
+                    existsSync(manifestPath) &&
+                    statSync(manifestPath).size >= MIN_MANIFEST_BYTES) {
+                    resolve();
+                    return;
+                }
+            }
+            catch {
+                // ignore
+            }
+            if (Date.now() >= deadline) {
+                reject(new Error(`Timeout waiting for RSC outputs under ${path.join(root, outDir)}`));
+                return;
+            }
+            setTimeout(check, intervalMs);
+        };
+        check();
+    });
+}
+/** Write a physical entry file. Use relative imports so we can externalize and copy dist into output. */
+function writeRscEntryFile(buildDir, rendererPath, ssrPath) {
+    const resolvedRenderer = path.resolve(rendererPath);
+    const resolvedSsr = ssrPath ? path.resolve(ssrPath) : null;
+    // Relative to buildDir (.nitro) -> e.g. ../dist/rsc/index.js
+    const relRenderer = path.relative(buildDir, resolvedRenderer).replace(/\\/g, "/");
+    const relSsr = resolvedSsr ? path.relative(buildDir, resolvedSsr).replace(/\\/g, "/") : null;
+    const setSsLoader = relSsr
+        ? `globalThis.__VITE_RSC_LOAD_SSR__ = () => import("./${relSsr}");`
+        : "";
+    const code = `
+${setSsLoader}
+import * as entryExports from "./${relRenderer}";
+import { defineEventHandler } from "h3";
+
+function getFetchHandler(exports) {
+  const def = exports?.default;
+  if (def && typeof def === "object" && "fetch" in def && typeof def.fetch === "function") return def.fetch;
+  if (typeof def === "function") return def;
+  throw new Error("Invalid RSC server handler: expected default.fetch or default function");
+}
+
+const handler = getFetchHandler(entryExports);
+
+function createRscRequest(event) {
+  const node = event.node;
+  if (!node?.req || !node?.res) return event.req;
+
+  const controller = new AbortController();
+  const cleanup = () => {
+    node.req.off("aborted", abort);
+    node.res.off("close", close);
+    node.res.off("finish", cleanup);
+  };
+  const abort = () => {
+    if (!controller.signal.aborted) controller.abort();
+    cleanup();
+  };
+  const close = () => {
+    if (!node.res.writableEnded) abort();
+    else cleanup();
+  };
+
+  node.req.once("aborted", abort);
+  node.res.once("close", close);
+  node.res.once("finish", cleanup);
+  if (node.req.aborted) abort();
+
+  return new Request(event.req, { signal: controller.signal });
+}
+
+export default defineEventHandler((event) => handler(createRscRequest(event), {
+  waitUntil: (promise) => event.waitUntil(promise),
+}));
+`.trim();
+    const entryPath = path.join(buildDir, "rsc-entry.mjs");
+    mkdirSync(buildDir, { recursive: true });
+    writeFileSync(entryPath, code, "utf-8");
+    return entryPath;
+}
+export async function buildRscNitro(options) {
+    const { rendererPath, publicDir, ssrPath, assetsDir, root, outputDir = path.join(root, ".output"), preset = "vercel", } = options;
+    const { build, copyPublicAssets, createNitro, prepare } = await import("nitro");
+    console.log(`[FARM] Building RSC server with Nitro (preset: ${preset})...`);
+    const buildDir = path.join(root, ".nitro");
+    const serverDir = path.join(outputDir, "server");
+    const publicOutDir = path.join(outputDir, "public");
+    const entryPath = writeRscEntryFile(buildDir, rendererPath, ssrPath);
+    const registeredRuntimePackages = new Map(runtimePackagesByRoot.get(path.resolve(root)) ?? []);
+    for (const [packageName, packageRoot] of detectBundledRscRuntimes(rendererPath)) {
+        registeredRuntimePackages.set(packageName, packageRoot);
+    }
+    const publicAssets = [
+        { dir: publicDir, baseURL: "/", maxAge: 31536000 },
+    ];
+    if (assetsDir) {
+        publicAssets.push({
+            dir: path.join(publicDir, assetsDir),
+            baseURL: `/${assetsDir}`,
+            maxAge: 31536000,
+        });
+    }
+    const config = {
+        preset,
+        rootDir: root,
+        srcDir: root,
+        buildDir,
+        dev: false,
+        output: {
+            dir: outputDir,
+            serverDir,
+            publicDir: publicOutDir,
+        },
+        publicAssets,
+        renderer: { entry: entryPath },
+        // The prebuilt RSC/SSR bundles are copied after Nitro finishes, so Nitro's
+        // module graph cannot otherwise see their bare package imports. Trace both
+        // entry points explicitly to keep node-server output self-contained.
+        externals: {
+            traceInclude: [rendererPath, ...(ssrPath ? [ssrPath] : [])],
+        },
+        // Externalize rsc/ssr so we don't bundle (they reference Vite-generated manifest). We copy dist into server output after build.
+        rollupConfig: {
+            external: (id) => id.includes("../dist/") || id.includes("dist/rsc") || id.includes("dist/ssr"),
+        },
+        compatibilityDate: "2024-12-01",
+        minify: true,
+    };
+    const nitro = await createNitro(config);
+    await prepare(nitro);
+    await copyPublicAssets(nitro);
+    await build(nitro);
+    await nitro.close();
+    copyRuntimePackages(serverDir, registeredRuntimePackages);
+    // Copy dist into server so runtime relative imports resolve. Handle missing dir (e.g. buildApp order).
+    const serverDistDir = path.join(serverDir, "dist");
+    const rscSrc = path.dirname(path.resolve(rendererPath));
+    const ssrSrc = ssrPath ? path.dirname(path.resolve(ssrPath)) : null;
+    mkdirSync(serverDistDir, { recursive: true });
+    copyDir(rscSrc, path.join(serverDistDir, "rsc"));
+    if (ssrSrc)
+        copyDir(ssrSrc, path.join(serverDistDir, "ssr"));
+    // Stub manifest if missing (RSC plugin may write it after our hook runs)
+    const rscDestDir = path.join(serverDistDir, "rsc");
+    const manifestDest = path.join(rscDestDir, "__vite_rsc_assets_manifest.js");
+    if (!existsSync(manifestDest)) {
+        mkdirSync(rscDestDir, { recursive: true });
+        writeFileSync(manifestDest, "export default { serverResources: {}, clientReferenceDeps: {} };", "utf-8");
+    }
+    // Nitro may group the entry under chunks/build or chunks/_ depending on the
+    // selected builder. Find it by name and make copied-dist imports relative to
+    // the emitted chunk so the output survives being moved away from the project.
+    const entryChunkPaths = [];
+    const findEntryChunks = (dir) => {
+        if (!existsSync(dir))
+            return;
+        for (const name of readdirSync(dir)) {
+            const candidate = path.join(dir, name);
+            if (statSync(candidate).isDirectory())
+                findEntryChunks(candidate);
+            else if (name === "rsc-entry.mjs")
+                entryChunkPaths.push(candidate);
+        }
+    };
+    findEntryChunks(path.join(serverDir, "chunks"));
+    for (const entryChunkPath of entryChunkPaths) {
+        let code = readFileSync(entryChunkPath, "utf-8");
+        const relativeImport = (target) => {
+            const relative = path.relative(path.dirname(entryChunkPath), target).replace(/\\/g, "/");
+            return relative.startsWith(".") ? relative : `./${relative}`;
+        };
+        // Match any path that ends with dist/rsc/index.js or dist/ssr/index.js (minified, no spaces)
+        code = code.replace(/(["'`])[^"'`]*?dist\/rsc\/index\.js\1/g, JSON.stringify(relativeImport(path.join(serverDistDir, "rsc", "index.js"))));
+        code = code.replace(/(["'`])[^"'`]*?dist\/ssr\/index\.js\1/g, JSON.stringify(relativeImport(path.join(serverDistDir, "ssr", "index.js"))));
+        writeFileSync(entryChunkPath, code, "utf-8");
+    }
+    // Patch SSR bundle: inject production client CSS href and bootstrap script so HTML has styles and hydration works
+    const ssrIndexPath = path.join(serverDistDir, "ssr", "index.js");
+    const manifestPath = path.join(serverDistDir, "rsc", MANIFEST_FILENAME);
+    let bootstrapScriptContent = "";
+    let clientEntryHref = "";
+    const RSC_CALL_SERVER_PLACEHOLDER = "(function(){if(typeof globalThis.__viteRscCallServer!=='function'){globalThis.__viteRscCallServer=function(){return Promise.reject(new Error(\"Farm.js: server actions not ready\"));}}})();\n";
+    if (existsSync(manifestPath)) {
+        try {
+            const manifestContent = readFileSync(manifestPath, "utf-8");
+            const start = manifestContent.indexOf("{");
+            const end = manifestContent.lastIndexOf("}") + 1;
+            if (start >= 0 && end > start) {
+                const manifest = JSON.parse(manifestContent.slice(start, end));
+                bootstrapScriptContent = manifest.bootstrapScriptContent || "";
+                const importMatch = bootstrapScriptContent.match(/^import\s*\(\s*["']([^"']+)["']\s*\)\s*$/);
+                if (importMatch)
+                    clientEntryHref = importMatch[1];
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    const fullBootstrap = bootstrapScriptContent
+        ? RSC_CALL_SERVER_PLACEHOLDER + bootstrapScriptContent
+        : "";
+    // Patch manifest so production SSR gets bootstrap with __viteRscCallServer placeholder (SSR reads assetsManifest.bootstrapScriptContent)
+    if (fullBootstrap && existsSync(manifestPath)) {
+        try {
+            let manifestCode = readFileSync(manifestPath, "utf-8");
+            const escaped = JSON.stringify(bootstrapScriptContent);
+            const escapedFull = JSON.stringify(fullBootstrap);
+            if (manifestCode.includes(escaped) && escaped !== escapedFull) {
+                manifestCode = manifestCode.replace(escaped, escapedFull);
+                writeFileSync(manifestPath, manifestCode, "utf-8");
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    if (existsSync(ssrIndexPath)) {
+        const assetsDir = path.join(publicDir, "assets");
+        let clientCssHref = "";
+        if (existsSync(assetsDir)) {
+            const files = readdirSync(assetsDir);
+            const cssFile = files.find((f) => f.endsWith(".css"));
+            if (cssFile)
+                clientCssHref = "/assets/" + cssFile;
+        }
+        try {
+            let ssrCode = readFileSync(ssrIndexPath, "utf-8");
+            if (ssrCode.includes("__FARM_CLIENT_CSS_HREF__")) {
+                ssrCode = ssrCode.replace("__FARM_CLIENT_CSS_HREF__", clientCssHref);
+            }
+            if (clientEntryHref && ssrCode.includes("__FARM_CLIENT_ENTRY_HREF__")) {
+                ssrCode = ssrCode.replace(/(CLIENT_ENTRY_HREF\s*=\s*)"__FARM_CLIENT_ENTRY_HREF__"/, "$1" + JSON.stringify(clientEntryHref));
+            }
+            if (fullBootstrap && ssrCode.includes("__FARM_BOOTSTRAP_SCRIPT__")) {
+                ssrCode = ssrCode.replace(/=\s*["']__FARM_BOOTSTRAP_SCRIPT__["']/, "= " + JSON.stringify(fullBootstrap));
+            }
+            writeFileSync(ssrIndexPath, ssrCode, "utf-8");
+        }
+        catch {
+            // ignore
+        }
+    }
+    console.log("[FARM] RSC Nitro build completed");
+    console.log(`[FARM] Output: ${outputDir}`);
+}

package/dist/rsc/optimized-boundary.d.ts

@@ -0,0 +1,20 @@
+import { type RenderOptions, type StrataDocument } from "@farming-labs/strata";
+import { type StaticFragmentBoundary, type StaticFragmentProps } from "@farming-labs/strata/react-server";
+export type { RenderOptions, StrataDocument, StrataElement, StrataNode, StrataTag, StrataText, } from "@farming-labs/strata";
+export interface OptimizedBoundaryProps extends Omit<StaticFragmentProps, "content"> {
+    /**
+     * Typed host-only content. Client Components, refs, effects, and event
+     * handlers must remain outside the boundary.
+     */
+    document: StrataDocument;
+    renderOptions?: RenderOptions;
+}
+/**
+ * Render a typed host-only document with the optimized native runtime and
+ * place it inside an opaque React-owned boundary.
+ *
+ * Enable `experimental.optimizedBoundary` before importing this component.
+ */
+export declare function OptimizedBoundary({ document, renderOptions, ...props }: OptimizedBoundaryProps): import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+export type OptimizedBoundaryTag = StaticFragmentBoundary;
+//# sourceMappingURL=optimized-boundary.d.ts.map

package/dist/rsc/optimized-boundary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimized-boundary.d.ts","sourceRoot":"","sources":["../../src/rsc/optimized-boundary.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,aAAa,EAAE,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACvF,OAAO,EAEL,KAAK,sBAAsB,EAC3B,KAAK,mBAAmB,EACzB,MAAM,mCAAmC,CAAC;AAE3C,YAAY,EACV,aAAa,EACb,cAAc,EACd,aAAa,EACb,UAAU,EACV,SAAS,EACT,UAAU,GACX,MAAM,sBAAsB,CAAC;AAE9B,MAAM,WAAW,sBAAuB,SAAQ,IAAI,CAAC,mBAAmB,EAAE,SAAS,CAAC;IAClF;;;OAGG;IACH,QAAQ,EAAE,cAAc,CAAC;IACzB,aAAa,CAAC,EAAE,aAAa,CAAC;CAC/B;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,QAAQ,EAAE,aAAa,EAAE,GAAG,KAAK,EAAE,EAAE,sBAAsB,0FAM9F;AAED,MAAM,MAAM,oBAAoB,GAAG,sBAAsB,CAAC"}

package/dist/rsc/optimized-boundary.js

@@ -0,0 +1,15 @@
+import { render } from "@farming-labs/strata";
+import { StaticFragment, } from "@farming-labs/strata/react-server";
+/**
+ * Render a typed host-only document with the optimized native runtime and
+ * place it inside an opaque React-owned boundary.
+ *
+ * Enable `experimental.optimizedBoundary` before importing this component.
+ */
+export function OptimizedBoundary({ document, renderOptions, ...props }) {
+    const content = render(document, renderOptions);
+    return StaticFragment({
+        ...props,
+        content,
+    });
+}

package/dist/rsc/server-fn-transform.d.ts

@@ -0,0 +1,6 @@
+export type FarmServerFnTransformResult = {
+    code: string;
+    exports: string[];
+};
+export declare function transformFarmServerFns(code: string, id: string): FarmServerFnTransformResult | null;
+//# sourceMappingURL=server-fn-transform.d.ts.map

package/dist/rsc/server-fn-transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-fn-transform.d.ts","sourceRoot":"","sources":["../../src/rsc/server-fn-transform.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,2BAA2B,GAAG;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAEF,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,GACT,2BAA2B,GAAG,IAAI,CAiCpC"}

package/dist/rsc/server-fn-transform.js

@@ -0,0 +1,152 @@
+const SERVER_FUNCTION_FACTORY_IMPORT_RE = /\bimport\s+(?:type\s+)?(?:[A-Za-z_$][\w$]*\s*,\s*)?(\{[^}]*\})\s+from\s*["']@farm.js\/core(?:\/(?:server-fn|server-query))?["']\s*;?/g;
+const EXPORT_SERVER_FUNCTION_FACTORY_RE = /\bexport\s+(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*([A-Za-z_$][\w$]*)\s*\(/g;
+const MODULE_EXT_RE = /\.[cm]?[jt]sx?$/;
+const DECLARATION_RE = /(^|\n)\s*["']([^"']+)["']\s*;?/g;
+export function transformFarmServerFns(code, id) {
+    if (!isTransformableModule(id) ||
+        (!code.includes("createServerFn") && !code.includes("createServerQuery"))) {
+        return null;
+    }
+    const factoryNames = findServerFunctionFactoryImportNames(code);
+    if (factoryNames.size === 0)
+        return null;
+    const replacements = findServerFnExportReplacements(code, factoryNames);
+    if (replacements.length === 0)
+        return null;
+    if (hasModuleDirective(code, "use client")) {
+        throw new Error("createServerFn and createServerQuery exports must live in a server module. Move them out of the 'use client' file.");
+    }
+    let output = code;
+    for (const replacement of [...replacements].sort((a, b) => b.start - a.start)) {
+        output = output.slice(0, replacement.start) + replacement.code + output.slice(replacement.end);
+    }
+    if (!hasModuleDirective(output, "use server")) {
+        output = `"use server";\n${output}`;
+    }
+    return {
+        code: output,
+        exports: replacements.map((replacement) => replacement.exportName),
+    };
+}
+function isTransformableModule(id) {
+    const cleanId = id.split("?", 1)[0];
+    return MODULE_EXT_RE.test(cleanId) && !/\.d\.[cm]?ts$/.test(cleanId);
+}
+function findServerFunctionFactoryImportNames(code) {
+    const names = new Map();
+    for (const match of code.matchAll(SERVER_FUNCTION_FACTORY_IMPORT_RE)) {
+        const importClause = match[1] ?? "";
+        const namedStart = importClause.indexOf("{");
+        const namedEnd = importClause.lastIndexOf("}");
+        if (namedStart === -1 || namedEnd === -1 || namedEnd <= namedStart)
+            continue;
+        const namedImports = importClause.slice(namedStart + 1, namedEnd).split(",");
+        for (const specifier of namedImports) {
+            const normalized = specifier.trim().replace(/^type\s+/, "");
+            const specifierMatch = normalized.match(/^(createServerFn|createServerQuery)(?:\s+as\s+([A-Za-z_$][\w$]*))?$/);
+            if (specifierMatch) {
+                const factory = specifierMatch[1];
+                names.set(specifierMatch[2] ?? factory, factory === "createServerFn" ? "fn" : "query");
+            }
+        }
+    }
+    return names;
+}
+function findServerFnExportReplacements(code, factoryNames) {
+    const replacements = [];
+    for (const match of code.matchAll(EXPORT_SERVER_FUNCTION_FACTORY_RE)) {
+        const exportName = match[1];
+        const calleeName = match[2];
+        const factory = calleeName ? factoryNames.get(calleeName) : undefined;
+        if (!exportName || !calleeName || !factory)
+            continue;
+        const openParenIndex = (match.index ?? 0) + match[0].length - 1;
+        const callEnd = findMatchingParen(code, openParenIndex);
+        if (callEnd === -1)
+            continue;
+        let declarationEnd = callEnd + 1;
+        while (/\s/.test(code[declarationEnd] ?? ""))
+            declarationEnd++;
+        if (code[declarationEnd] === ";")
+            declarationEnd++;
+        const calleeIndex = code.indexOf(calleeName, match.index);
+        const callExpression = code.slice(calleeIndex, callEnd + 1);
+        const privateName = `$$farm_server_${factory}_${exportName}`;
+        replacements.push({
+            start: match.index ?? 0,
+            end: declarationEnd,
+            exportName,
+            code: `const ${privateName} = ${callExpression};\nexport async function ${exportName}(input) {\n  return ${privateName}(input);\n}`,
+        });
+    }
+    return replacements;
+}
+function hasModuleDirective(code, directive) {
+    for (const match of code.matchAll(DECLARATION_RE)) {
+        const value = match[2];
+        if (value === directive)
+            return true;
+        if (value !== "use strict" && value !== "use client" && value !== "use server")
+            return false;
+    }
+    return false;
+}
+function findMatchingParen(code, openParenIndex) {
+    let depth = 0;
+    let quote = null;
+    let lineComment = false;
+    let blockComment = false;
+    let escaped = false;
+    for (let index = openParenIndex; index < code.length; index++) {
+        const char = code[index];
+        const next = code[index + 1];
+        if (lineComment) {
+            if (char === "\n" || char === "\r")
+                lineComment = false;
+            continue;
+        }
+        if (blockComment) {
+            if (char === "*" && next === "/") {
+                blockComment = false;
+                index++;
+            }
+            continue;
+        }
+        if (quote) {
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (char === "\\") {
+                escaped = true;
+                continue;
+            }
+            if (char === quote) {
+                quote = null;
+            }
+            continue;
+        }
+        if (char === "/" && next === "/") {
+            lineComment = true;
+            index++;
+            continue;
+        }
+        if (char === "/" && next === "*") {
+            blockComment = true;
+            index++;
+            continue;
+        }
+        if (char === "'" || char === '"' || char === "`") {
+            quote = char;
+            continue;
+        }
+        if (char === "(")
+            depth++;
+        if (char === ")") {
+            depth--;
+            if (depth === 0)
+                return index;
+        }
+    }
+    return -1;
+}