@farm.js/core 0.1.46 → 0.1.48

package/dist/chunk-WNDAISB7.mjs

@@ -0,0 +1,51 @@
+// src/instrumentation-runtime.ts
+function createFarmInstrumentationLifecycle(module, context) {
+  let startPromise;
+  let shutdownPromise;
+  let cleanup;
+  return {
+    start() {
+      if (!startPromise) {
+        startPromise = Promise.resolve(module?.register?.(context)).then((result) => {
+          cleanup = result || void 0;
+        });
+      }
+      return startPromise;
+    },
+    shutdown() {
+      if (!shutdownPromise) {
+        shutdownPromise = (async () => {
+          try {
+            await startPromise;
+          } catch {
+          }
+          try {
+            if (typeof cleanup === "function") {
+              await cleanup();
+            } else if (cleanup?.shutdown) {
+              await cleanup.shutdown();
+            }
+          } finally {
+            if (module?.shutdown) {
+              await module.shutdown();
+            }
+          }
+        })();
+      }
+      return shutdownPromise;
+    }
+  };
+}
+function resolveFarmInstrumentationRuntime(preset) {
+  const normalized = preset?.toLowerCase() ?? "";
+  if (normalized.includes("cloudflare") || normalized.includes("worker") || normalized.includes("edge")) {
+    return "edge";
+  }
+  if (normalized.includes("bun")) return "bun";
+  return "nodejs";
+}
+
+export {
+  createFarmInstrumentationLifecycle,
+  resolveFarmInstrumentationRuntime
+};

package/dist/chunk-WNLPQW7W.mjs

@@ -0,0 +1,19 @@
+// src/schema-capabilities.ts
+function assertNoSchemaListField(field, fieldPath, target) {
+  if (!field.list) {
+    return;
+  }
+  throw new Error(
+    `Schema field "${fieldPath}" declares list: true, but ${target} does not support list fields. Use type: "json" for an array value or model the values in a related table.`
+  );
+}
+
+// src/schema-reference.ts
+function isDatabaseEnforcedReference(reference) {
+  return reference.enforced === void 0 || reference.enforced === "db";
+}
+
+export {
+  assertNoSchemaListField,
+  isDatabaseEnforcedReference
+};

package/dist/chunk-WQGRD5BJ.cjs

@@ -0,0 +1,239 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _chunkI2BYNELAcjs = require('./chunk-I2BYNELA.cjs');
+
+
+var _chunkMPU5DOXXcjs = require('./chunk-MPU5DOXX.cjs');
+
+
+var _chunkDXUXQP2Tcjs = require('./chunk-DXUXQP2T.cjs');
+
+// src/client-revalidation.ts
+function attachRevalidationListeners(refresh, options = {}) {
+  if (typeof window === "undefined") return () => {
+  };
+  const onFocus = options.refetchOnWindowFocus === false ? void 0 : refresh;
+  const onOnline = options.refetchOnReconnect === false ? void 0 : refresh;
+  if (onFocus) window.addEventListener("focus", onFocus);
+  if (onOnline) window.addEventListener("online", onOnline);
+  return () => {
+    if (onFocus) window.removeEventListener("focus", onFocus);
+    if (onOnline) window.removeEventListener("online", onOnline);
+  };
+}
+
+// src/server-query-runtime.ts
+var FARM_SERVER_QUERY_CLIENT_STATE = /* @__PURE__ */ Symbol.for("farm.serverQueryClientState");
+var serverQueryClientGlobal = globalThis;
+var serverQueryClientState = _nullishCoalesce(serverQueryClientGlobal[FARM_SERVER_QUERY_CLIENT_STATE], () => ( (serverQueryClientGlobal[FARM_SERVER_QUERY_CLIENT_STATE] = {
+  functionIds: /* @__PURE__ */ new WeakMap(),
+  nextFunctionId: 0,
+  active: [],
+  latestOwners: /* @__PURE__ */ new Map(),
+  owners: /* @__PURE__ */ new Set()
+})));
+_nullishCoalesce(serverQueryClientState.latestOwners, () => ( (serverQueryClientState.latestOwners = /* @__PURE__ */ new Map())));
+_nullishCoalesce(serverQueryClientState.owners, () => ( (serverQueryClientState.owners = /* @__PURE__ */ new Set())));
+function isServerQueryOwnerSuperseded(owner, key) {
+  const cache = _chunkI2BYNELAcjs.getFarmClientDataCache.call(void 0, );
+  const resolved = cache.resolveKey(key);
+  for (const superseded of _nullishCoalesce(owner.supersededKeys, () => ( []))) {
+    if (cache.resolveKey(superseded) === resolved) return true;
+  }
+  return false;
+}
+function claimServerQueryKey(owner, key) {
+  if (isServerQueryOwnerSuperseded(owner, key)) return false;
+  const resolved = _chunkI2BYNELAcjs.getFarmClientDataCache.call(void 0, ).resolveKey(key);
+  for (const older of serverQueryClientState.owners) {
+    if (older === owner) break;
+    older.supersededKeys.add(resolved);
+  }
+  return true;
+}
+var RAW_SERVER_QUERY_SYMBOL = /* @__PURE__ */ Symbol.for("farm.server-query");
+function isFarmServerQueryBrowserRuntime() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function assertNotRawServerQueryInBrowser(query) {
+  if (!isFarmServerQueryBrowserRuntime()) return;
+  if (!_optionalChain([query, 'optionalAccess', _ => _[RAW_SERVER_QUERY_SYMBOL]])) return;
+  throw new Error(
+    [
+      "useServerQuery received a raw server query implementation in the browser.",
+      "Server query handlers run only on the server. Enable the server-function transform (add @farm.js/plugin/rsc and set experimental.serverActions: true in farm.config.ts) so client imports become server references,",
+      "or call the query from server code / an API route (createAPIClient) instead."
+    ].join("\n")
+  );
+}
+function beginFarmServerQueryAction(actionId, args) {
+  const active = serverQueryClientState.active.at(-1);
+  return {
+    actionId,
+    args,
+    provisionalKey: _optionalChain([active, 'optionalAccess', _2 => _2.provisionalKey]),
+    owner: _optionalChain([active, 'optionalAccess', _3 => _3.owner])
+  };
+}
+function completeFarmServerQueryAction(invocation, value) {
+  if (!_chunkMPU5DOXXcjs.isFarmServerQueryResult.call(void 0, value)) return value;
+  const cache = _chunkI2BYNELAcjs.getFarmClientDataCache.call(void 0, );
+  const metadata = value.__farmServerQuery;
+  if (!shouldApplyFarmServerQueryActionResult(invocation)) {
+    return value.data;
+  }
+  if (invocation.provisionalKey) {
+    cache.alias(invocation.provisionalKey, metadata.key);
+  }
+  const owner = invocation.owner;
+  if (owner && serverQueryClientState.owners.has(owner) && !claimServerQueryKey(owner, metadata.key)) {
+    return value.data;
+  }
+  const invalidated = _optionalChain([invocation, 'access', _4 => _4.owner, 'optionalAccess', _5 => _5.invalidations, 'optionalAccess', _6 => _6.has, 'call', _7 => _7(
+    metadata.key
+  )]);
+  cache.set(metadata.key, {
+    data: value.data,
+    updatedAt: metadata.updatedAt,
+    staleAt: invalidated ? 0 : metadata.staleTime === false ? Number.POSITIVE_INFINITY : metadata.updatedAt + metadata.staleTime,
+    status: "success",
+    error: null,
+    fetching: false,
+    persist: metadata.persist === true ? true : void 0
+  });
+  return value.data;
+}
+function shouldApplyFarmServerQueryActionResult(invocation) {
+  if (!invocation.provisionalKey || !invocation.owner) return true;
+  return isCurrentServerQueryOwner(invocation.provisionalKey, invocation.owner);
+}
+function isCurrentServerQueryOwner(provisionalKey, owner) {
+  return serverQueryClientState.latestOwners.get(provisionalKey) === owner && !isServerQueryOwnerSuperseded(owner, provisionalKey);
+}
+function createServerQueryCallKey(query, input) {
+  let id = serverQueryClientState.functionIds.get(query);
+  if (!id) {
+    id = ++serverQueryClientState.nextFunctionId;
+    serverQueryClientState.functionIds.set(query, id);
+  }
+  return _chunkDXUXQP2Tcjs.createFarmCacheKey.call(void 0, ["server-query-call", id, input]);
+}
+async function fetchServerQuery(query, input, options = {}) {
+  if (!isFarmServerQueryBrowserRuntime()) return query(input);
+  const cache = _chunkI2BYNELAcjs.getFarmClientDataCache.call(void 0, );
+  const provisionalKey = createServerQueryCallKey(query, input);
+  const entry = cache.get(provisionalKey);
+  const stale = cache.isStale(provisionalKey);
+  const inflight = cache.getInflight(provisionalKey);
+  if (!options.force && entry && stale && (entry.status !== "pending" || entry.updatedAt !== 0) && entry.status !== "error" && (_nullishCoalesce(options.swr, () => ( true)))) {
+    if (!inflight) {
+      void executeServerQuery(query, input, provisionalKey, options).catch(() => void 0);
+    }
+    return entry.data;
+  }
+  if (inflight && !options.force) return inflight;
+  if (!options.force && entry && !stale && entry.status !== "error") return entry.data;
+  return executeServerQuery(query, input, provisionalKey, options);
+}
+function prefetchServerQuery(query, input, options = {}) {
+  return fetchServerQuery(query, input, options);
+}
+async function executeServerQuery(query, input, provisionalKey, options) {
+  assertNotRawServerQueryInBrowser(query);
+  const cache = _chunkI2BYNELAcjs.getFarmClientDataCache.call(void 0, );
+  const inflight = cache.getInflight(provisionalKey);
+  if (inflight && !options.force) return inflight;
+  const owner = {
+    invalidations: _chunkI2BYNELAcjs.trackFarmClientCacheInvalidations.call(void 0, cache),
+    supersededKeys: /* @__PURE__ */ new Set()
+  };
+  serverQueryClientState.latestOwners.set(provisionalKey, owner);
+  serverQueryClientState.owners.add(owner);
+  claimServerQueryKey(owner, provisionalKey);
+  const previous = cache.get(provisionalKey);
+  cache.set(provisionalKey, {
+    data: _optionalChain([previous, 'optionalAccess', _8 => _8.data]),
+    updatedAt: _nullishCoalesce(_optionalChain([previous, 'optionalAccess', _9 => _9.updatedAt]), () => ( 0)),
+    staleAt: _nullishCoalesce(_optionalChain([previous, 'optionalAccess', _10 => _10.staleAt]), () => ( 0)),
+    gcAt: _optionalChain([previous, 'optionalAccess', _11 => _11.gcAt]),
+    invalidatedAt: _optionalChain([previous, 'optionalAccess', _12 => _12.invalidatedAt]),
+    status: "pending",
+    error: null,
+    fetching: true
+  });
+  let promise;
+  promise = (async () => {
+    await Promise.resolve();
+    try {
+      serverQueryClientState.active.push({ provisionalKey, owner });
+      let pending;
+      try {
+        pending = query(input);
+      } finally {
+        serverQueryClientState.active.pop();
+      }
+      const data = await pending;
+      const transported = cache.get(provisionalKey);
+      if (isCurrentServerQueryOwner(provisionalKey, owner) && (!transported || transported.fetching)) {
+        const updatedAt = Date.now();
+        cache.set(provisionalKey, {
+          data,
+          updatedAt,
+          staleAt: owner.invalidations.has(provisionalKey) ? 0 : options.staleTime === false ? Number.POSITIVE_INFINITY : updatedAt + (_nullishCoalesce(options.staleTime, () => ( 0))),
+          status: "success",
+          error: null,
+          fetching: false
+        });
+      }
+      return data;
+    } catch (cause) {
+      const error = normalizeServerQueryError(cause);
+      if (isCurrentServerQueryOwner(provisionalKey, owner)) {
+        const current = cache.get(provisionalKey);
+        cache.set(provisionalKey, {
+          data: _optionalChain([current, 'optionalAccess', _13 => _13.data]),
+          updatedAt: _nullishCoalesce(_optionalChain([current, 'optionalAccess', _14 => _14.updatedAt]), () => ( 0)),
+          staleAt: _nullishCoalesce(_optionalChain([current, 'optionalAccess', _15 => _15.staleAt]), () => ( 0)),
+          gcAt: _optionalChain([current, 'optionalAccess', _16 => _16.gcAt]),
+          invalidatedAt: _optionalChain([current, 'optionalAccess', _17 => _17.invalidatedAt]),
+          status: "error",
+          error,
+          fetching: false
+        });
+      }
+      throw error;
+    } finally {
+      const invalidated = isCurrentServerQueryOwner(provisionalKey, owner) && owner.invalidations.has(provisionalKey);
+      owner.invalidations.dispose();
+      serverQueryClientState.owners.delete(owner);
+      owner.supersededKeys.clear();
+      if (cache.getInflight(provisionalKey) === promise) {
+        cache.deleteInflight(provisionalKey);
+      }
+      if (serverQueryClientState.latestOwners.get(provisionalKey) === owner) {
+        serverQueryClientState.latestOwners.delete(provisionalKey);
+      }
+      if (invalidated) cache.invalidate(provisionalKey);
+    }
+  })();
+  cache.setInflight(provisionalKey, promise);
+  return promise;
+}
+function normalizeServerQueryError(cause) {
+  if (cause instanceof Error) return cause;
+  const error = new Error(typeof cause === "string" ? cause : "Server query failed");
+  error.cause = cause;
+  return error;
+}
+
+
+
+
+
+
+
+
+
+
+exports.attachRevalidationListeners = attachRevalidationListeners; exports.isFarmServerQueryBrowserRuntime = isFarmServerQueryBrowserRuntime; exports.beginFarmServerQueryAction = beginFarmServerQueryAction; exports.completeFarmServerQueryAction = completeFarmServerQueryAction; exports.shouldApplyFarmServerQueryActionResult = shouldApplyFarmServerQueryActionResult; exports.createServerQueryCallKey = createServerQueryCallKey; exports.fetchServerQuery = fetchServerQuery; exports.prefetchServerQuery = prefetchServerQuery;

package/dist/chunk-WT6RAN2I.cjs

@@ -0,0 +1,41 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/theme/config.ts
+var DEFAULT_FARM_THEME_STORAGE_KEY = "farm-theme";
+var STORAGE_KEY_PATTERN = /^[A-Za-z0-9._-]+$/;
+function resolveFarmThemeConfig(config, basePath = "/") {
+  if (config && "enabled" in config) {
+    return config;
+  }
+  if (!config) {
+    return {
+      enabled: false,
+      default: "system",
+      storageKey: DEFAULT_FARM_THEME_STORAGE_KEY,
+      cookiePath: normalizeCookiePath(basePath)
+    };
+  }
+  const storageKey = _optionalChain([config, 'access', _ => _.storageKey, 'optionalAccess', _2 => _2.trim, 'call', _3 => _3()]) || DEFAULT_FARM_THEME_STORAGE_KEY;
+  if (!STORAGE_KEY_PATTERN.test(storageKey)) {
+    throw new Error(
+      "theme.storageKey may only contain letters, numbers, dots, underscores, and hyphens."
+    );
+  }
+  const defaultTheme = _nullishCoalesce(config.default, () => ( "system"));
+  if (defaultTheme !== "light" && defaultTheme !== "dark" && defaultTheme !== "system") {
+    throw new Error('theme.default must be "light", "dark", or "system".');
+  }
+  return {
+    enabled: true,
+    default: defaultTheme,
+    storageKey,
+    cookiePath: normalizeCookiePath(basePath)
+  };
+}
+function normalizeCookiePath(basePath) {
+  const normalized = `/${basePath}`.replace(/\/{2,}/g, "/");
+  if (normalized === "/") return normalized;
+  return normalized.replace(/\/$/, "");
+}
+
+
+
+exports.resolveFarmThemeConfig = resolveFarmThemeConfig;

package/dist/chunk-WUEDTW6E.cjs

@@ -0,0 +1,135 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } async function _asyncOptionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _chunkETF5C6HRcjs = require('./chunk-ETF5C6HR.cjs');
+
+
+var _chunkKZT2VHRQcjs = require('./chunk-KZT2VHRQ.cjs');
+
+
+var _chunk4S7M63WXcjs = require('./chunk-4S7M63WX.cjs');
+
+
+var _chunkIXSMFKZ2cjs = require('./chunk-IXSMFKZ2.cjs');
+
+// src/rsc-pipeline.ts
+var _fs = require('fs');
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _url = require('url');
+var FARM_RSC_ENTRIES = {
+  rsc: "./.farm/rsc-entries/entry.rsc.tsx",
+  ssr: "./.farm/rsc-entries/entry.ssr.tsx",
+  client: "./.farm/rsc-entries/entry.browser.tsx"
+};
+var FARM_RSC_CONFIG_KEYS = [
+  "srcDir",
+  "extends",
+  "basePath",
+  "api",
+  "server",
+  "middleware",
+  "images",
+  "serverActions",
+  "deploymentId",
+  "generateBuildId",
+  "md",
+  "agent",
+  "mcp"
+];
+var FARM_RSC_PASSTHROUGH_KEYS = ["i18n", "cache"];
+function pickImportTarget(entry) {
+  if (typeof entry === "string") return entry;
+  if (!entry || typeof entry !== "object") return void 0;
+  for (const condition of ["import", "node", "default"]) {
+    const target = pickImportTarget(entry[condition]);
+    if (target) return target;
+  }
+  return void 0;
+}
+async function importFromApp(root, packageName, subpath = ".") {
+  const packageDir = _chunkETF5C6HRcjs.findFarmAppPackageDir.call(void 0, root, packageName);
+  if (!packageDir) return void 0;
+  const manifest = JSON.parse(_fs.readFileSync.call(void 0, _path2.default.join(packageDir, "package.json"), "utf8"));
+  const exportsMap = manifest.exports;
+  const entry = exportsMap && typeof exportsMap === "object" && !Array.isArray(exportsMap) && subpath in exportsMap ? exportsMap[subpath] : subpath === "." ? _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(exportsMap, () => ( manifest.module)), () => ( manifest.main)), () => ( "index.js")) : void 0;
+  const target = pickImportTarget(entry);
+  if (!target) return void 0;
+  return import(_url.pathToFileURL.call(void 0, _path2.default.join(packageDir, target)).href);
+}
+function hasPluginNamed(plugins, prefix) {
+  if (Array.isArray(plugins)) return plugins.some((plugin) => hasPluginNamed(plugin, prefix));
+  const name = _optionalChain([plugins, 'optionalAccess', _ => _.name]);
+  return typeof name === "string" && name.startsWith(prefix);
+}
+async function createFarmRscViteConfig(userConfig, options) {
+  const root = _path2.default.resolve(options.root);
+  const renderer = userConfig.renderer;
+  if (renderer && typeof renderer === "object" && renderer.name && renderer.name !== "react") {
+    throw new Error(
+      `[Farm.js] experimental.serverComponents needs the React renderer; this app uses "${renderer.name}".`
+    );
+  }
+  const [pluginRsc, viteRsc, viteReact] = await Promise.all([
+    importFromApp(root, "@farm.js/plugin", "./rsc"),
+    importFromApp(root, "@vitejs/plugin-rsc"),
+    importFromApp(root, "@vitejs/plugin-react")
+  ]);
+  if (!pluginRsc || !viteRsc || !_chunkETF5C6HRcjs.findFarmAppPackageDir.call(void 0, root, "react-server-dom-webpack")) {
+    throw new Error(
+      `[Farm.js] experimental.serverComponents runs on @farm.js/plugin and the official @vitejs/plugin-rsc. Install them: ${_chunkETF5C6HRcjs.FARM_RSC_INSTALL_HINT}`
+    );
+  }
+  const { plugins: vitePlugins = [], ...viteOptions } = _nullishCoalesce(userConfig.vite, () => ( {}));
+  const rscConfig = {};
+  for (const key of FARM_RSC_CONFIG_KEYS) {
+    if (userConfig[key] !== void 0) rscConfig[key] = userConfig[key];
+  }
+  const createReactPlugin = hasPluginNamed(vitePlugins, "vite:react") ? void 0 : await _asyncNullishCoalesce(await _asyncOptionalChain([viteReact, 'optionalAccess', async _2 => _2.default]), async () => ( (options.command === "serve" ? (await _chunk4S7M63WXcjs.loadFarmReactPlugin.call(void 0, )).default : void 0)));
+  const tailwind = hasPluginNamed(vitePlugins, "@tailwindcss/vite") ? void 0 : await _chunkIXSMFKZ2cjs.loadTailwindVitePlugin.call(void 0, );
+  const farmConfig = pluginRsc.defineConfig({
+    ...rscConfig,
+    experimental: { ...userConfig.experimental, serverComponents: true },
+    port: _nullishCoalesce(options.port, () => ( _optionalChain([userConfig, 'access', _3 => _3.server, 'optionalAccess', _4 => _4.port]))),
+    plugins: [
+      ...tailwind ? [tailwind] : [],
+      ...vitePlugins,
+      viteRsc.default({ serverHandler: false, entries: FARM_RSC_ENTRIES }),
+      ...typeof createReactPlugin === "function" ? [createReactPlugin()] : [],
+      pluginRsc.nitro({
+        server: { environmentName: "rsc" },
+        config: {
+          preset: options.preset,
+          outputDir: options.outputDir && _chunkKZT2VHRQcjs.resolveDeployOutputPath.call(void 0, root, options.outputDir)
+        }
+      })
+    ]
+  });
+  for (const key of FARM_RSC_PASSTHROUGH_KEYS) {
+    if (userConfig[key] !== void 0) farmConfig[key] = userConfig[key];
+  }
+  const { mergeConfig } = await import("vite");
+  return {
+    ...mergeConfig(farmConfig, viteOptions),
+    root,
+    // The Farm config is the app's config; a stray vite.config must not add a second pipeline.
+    configFile: false,
+    mode: options.command === "build" ? "production" : "development"
+  };
+}
+async function createFarmRscDevServer(userConfig, options) {
+  const { createServer } = await import("vite");
+  return createServer(await createFarmRscViteConfig(userConfig, { ...options, command: "serve" }));
+}
+async function buildFarmRsc(userConfig, options) {
+  const { createBuilder } = await import("vite");
+  const builder = await createBuilder(
+    await createFarmRscViteConfig(userConfig, { ...options, command: "build" })
+  );
+  await builder.buildApp();
+}
+
+
+
+
+
+exports.createFarmRscViteConfig = createFarmRscViteConfig; exports.createFarmRscDevServer = createFarmRscDevServer; exports.buildFarmRsc = buildFarmRsc;

package/dist/chunk-WXFY5JIY.mjs

@@ -0,0 +1,20 @@
+// src/utils/runtime-env.ts
+function getFarmRuntimeBindings() {
+  const runtimeBindings = globalThis.__env__;
+  return runtimeBindings && typeof runtimeBindings === "object" ? runtimeBindings : void 0;
+}
+function readFarmEnvironmentValue(name) {
+  const runtimeValue = getFarmRuntimeBindings()?.[name];
+  if (typeof runtimeValue === "string") return runtimeValue;
+  return typeof process !== "undefined" ? process.env?.[name] : void 0;
+}
+function isFarmDeployedRuntime() {
+  if (getFarmRuntimeBindings()) return true;
+  return readFarmEnvironmentValue("NODE_ENV") === "production";
+}
+
+export {
+  getFarmRuntimeBindings,
+  readFarmEnvironmentValue,
+  isFarmDeployedRuntime
+};

package/dist/chunk-WYL4ODZ4.mjs

@@ -0,0 +1,38 @@
+// src/client/document-head.ts
+var FARM_NAVIGATION_HEAD_SELECTOR = [
+  "meta[name]",
+  "meta[property]",
+  "meta[http-equiv]",
+  "meta[charset]",
+  "meta[itemprop]",
+  'link[rel~="author"]',
+  'link[rel~="canonical"]',
+  'link[rel~="alternate"]',
+  'link[rel~="icon"]',
+  'link[rel~="apple-touch-icon"]',
+  'link[rel~="manifest"]',
+  'link[rel~="search"]',
+  'link[rel~="next"]',
+  'link[rel~="prev"]',
+  'link[rel~="publisher"]',
+  'link[rel~="license"]',
+  'link[rel~="help"]',
+  'link[rel~="me"]',
+  'link[rel~="pingback"]',
+  'link[rel~="privacy-policy"]',
+  'link[rel~="terms-of-service"]',
+  // Page and layout `metadata.jsonLd` (FARM_METADATA_ATTRIBUTE). The site-level
+  // agent JSON-LD and app-authored scripts carry no marker and stay in place.
+  'script[type="application/ld+json"][data-farm-metadata]'
+].join(",");
+function reconcileFarmDocumentHead(nextDocument) {
+  const nextTitle = nextDocument.querySelector("title");
+  document.title = nextTitle?.textContent || "";
+  document.head.querySelectorAll(FARM_NAVIGATION_HEAD_SELECTOR).forEach((node) => node.remove());
+  nextDocument.head.querySelectorAll(FARM_NAVIGATION_HEAD_SELECTOR).forEach((node) => document.head.appendChild(document.importNode(node, true)));
+}
+
+export {
+  FARM_NAVIGATION_HEAD_SELECTOR,
+  reconcileFarmDocumentHead
+};

package/dist/chunk-X333W5KV.cjs

@@ -0,0 +1,31 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/route-context.ts
+var FARM_ROUTE_CONTEXT_SYMBOL = /* @__PURE__ */ Symbol.for("farm.routeContext");
+async function resolveFarmRouteContext(config, input) {
+  if (typeof config.context !== "function") {
+    return void 0;
+  }
+  return config.context(input);
+}
+function withFarmRouteContext(props, context) {
+  if (context === void 0) {
+    return props;
+  }
+  Object.defineProperty(props, FARM_ROUTE_CONTEXT_SYMBOL, {
+    value: context,
+    enumerable: false,
+    configurable: true
+  });
+  return props;
+}
+function getFarmRouteContext(props) {
+  if (!props || typeof props !== "object") {
+    return void 0;
+  }
+  return props[FARM_ROUTE_CONTEXT_SYMBOL];
+}
+
+
+
+
+
+exports.resolveFarmRouteContext = resolveFarmRouteContext; exports.withFarmRouteContext = withFarmRouteContext; exports.getFarmRouteContext = getFarmRouteContext;