@farm.js/core 0.1.16 → 0.1.18

package/dist/chunk-T5CERMEH.cjs

@@ -0,0 +1,417 @@
+"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 _chunkSVRTJOUFcjs = require('./chunk-SVRTJOUF.cjs');
+
+
+var _chunkEM6SBQKMcjs = require('./chunk-EM6SBQKM.cjs');
+
+
+
+var _chunkZEG3OPIBcjs = require('./chunk-ZEG3OPIB.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/server-action-security.ts
+var _async_hooks = require('async_hooks');
+
+// src/server-fn-error.ts
+var FARM_SERVER_FN_FAILURE_SYMBOL = /* @__PURE__ */ Symbol.for("farm.server-fn.failure");
+var _ServerFnFailure = class _ServerFnFailure extends Error {
+  constructor(code, data, options) {
+    super(options.message);
+    this.name = "ServerFnFailure";
+    this.code = code;
+    this.data = data;
+    this.status = options.status;
+    Object.defineProperty(this, FARM_SERVER_FN_FAILURE_SYMBOL, {
+      value: true,
+      enumerable: false
+    });
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _ServerFnFailure, "ServerFnFailure");
+var ServerFnFailure = _ServerFnFailure;
+var _ServerActionError = class _ServerActionError extends Error {
+  constructor(message = "Server function failed") {
+    super(message);
+    this.name = "ServerActionError";
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _ServerActionError, "ServerActionError");
+var ServerActionError = _ServerActionError;
+function isServerFnFailure(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return candidate[FARM_SERVER_FN_FAILURE_SYMBOL] === true && candidate.name === "ServerFnFailure" && typeof candidate.code === "string" && Number.isInteger(candidate.status) && (_nullishCoalesce(candidate.status, () => ( 0))) >= 400 && (_nullishCoalesce(candidate.status, () => ( 0))) <= 599;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isServerFnFailure, "isServerFnFailure");
+function serializeServerFnFailure(value) {
+  if (!isServerFnFailure(value)) return null;
+  return {
+    name: "ServerFnFailure",
+    message: value.message,
+    code: value.code,
+    status: value.status,
+    data: value.data
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, serializeServerFnFailure, "serializeServerFnFailure");
+function createServerFnTransportError(value) {
+  if (isSerializedServerFnFailure(value)) {
+    return new ServerFnFailure(value.code, value.data, {
+      status: value.status,
+      message: value.message
+    });
+  }
+  const message = value && typeof value === "object" && "message" in value && typeof value.message === "string" ? value.message : "Server function failed";
+  return new ServerActionError(message);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createServerFnTransportError, "createServerFnTransportError");
+function isSerializedServerFnFailure(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return candidate.name === "ServerFnFailure" && typeof candidate.message === "string" && typeof candidate.code === "string" && Number.isInteger(candidate.status) && (_nullishCoalesce(candidate.status, () => ( 0))) >= 400 && (_nullishCoalesce(candidate.status, () => ( 0))) <= 599 && "data" in candidate;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isSerializedServerFnFailure, "isSerializedServerFnFailure");
+
+// src/server-action-security.ts
+var SERVER_ACTION_ALLOWED_ORIGINS_LABEL = "serverActions.allowedOrigins";
+var DEFAULT_SERVER_ACTION_BODY_SIZE_LIMIT = 1e6;
+var _ServerActionRequestError = class _ServerActionRequestError extends Error {
+  constructor(code, status, message) {
+    super(message);
+    this.name = "ServerActionRequestError";
+    this.code = code;
+    this.status = status;
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _ServerActionRequestError, "ServerActionRequestError");
+var ServerActionRequestError = _ServerActionRequestError;
+var SERVER_ACTION_STORAGE_KEY = /* @__PURE__ */ Symbol.for("farm.serverActionStorage");
+var FALLBACK_ABORT_CONTROLLER_KEY = /* @__PURE__ */ Symbol.for("farm.serverActionFallbackAbortController");
+var FORM_ACTION_CONTENT_TYPES = /* @__PURE__ */ new Set([
+  "application/x-www-form-urlencoded",
+  "multipart/form-data"
+]);
+var JAVASCRIPT_ACTION_CONTENT_TYPES = /* @__PURE__ */ new Set([
+  "application/octet-stream",
+  "application/x-www-form-urlencoded",
+  "multipart/form-data",
+  "text/plain"
+]);
+function resolveServerActionsConfig(config) {
+  const allowedOrigins = (_nullishCoalesce(_optionalChain([config, 'optionalAccess', _ => _.allowedOrigins]), () => ( []))).map(
+    (value) => _chunkSVRTJOUFcjs.normalizeAllowedOriginPattern.call(void 0, value, SERVER_ACTION_ALLOWED_ORIGINS_LABEL)
+  );
+  const bodySizeLimit = _chunkEM6SBQKMcjs.parseBodySizeLimit.call(void 0, 
+    _nullishCoalesce(_optionalChain([config, 'optionalAccess', _2 => _2.bodySizeLimit]), () => ( DEFAULT_SERVER_ACTION_BODY_SIZE_LIMIT)),
+    "serverActions.bodySizeLimit"
+  );
+  return Object.freeze({
+    allowedOrigins: Object.freeze(allowedOrigins),
+    bodySizeLimit
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveServerActionsConfig, "resolveServerActionsConfig");
+function validateServerActionRequest(request, config) {
+  if (request.method.toUpperCase() !== "POST") {
+    throw new ServerActionRequestError(
+      "INVALID_METHOD",
+      405,
+      "Server actions only accept POST requests"
+    );
+  }
+  const requestUrl = new URL(request.url);
+  const sourceOrigin = resolveSourceOrigin(request);
+  const fetchSite = _optionalChain([request, 'access', _3 => _3.headers, 'access', _4 => _4.get, 'call', _5 => _5("sec-fetch-site"), 'optionalAccess', _6 => _6.trim, 'call', _7 => _7(), 'access', _8 => _8.toLowerCase, 'call', _9 => _9()]);
+  if (!sourceOrigin) {
+    if (fetchSite !== "same-origin") {
+      throw new ServerActionRequestError(
+        "MISSING_ORIGIN",
+        403,
+        "Server action request is missing same-origin metadata"
+      );
+    }
+    return;
+  }
+  const matchesRequest = sourceOrigin === requestUrl.origin || _chunkSVRTJOUFcjs.matchesHostHeader.call(void 0, sourceOrigin, request);
+  const matchesConfiguredOrigin = config.allowedOrigins.some(
+    (pattern) => _chunkSVRTJOUFcjs.matchesAllowedOrigin.call(void 0, sourceOrigin, pattern)
+  );
+  if (!matchesRequest && !matchesConfiguredOrigin) {
+    throw new ServerActionRequestError(
+      "INVALID_ORIGIN",
+      403,
+      "Server action origin does not match the request origin"
+    );
+  }
+  if (fetchSite === "cross-site" && !matchesConfiguredOrigin) {
+    throw new ServerActionRequestError(
+      "INVALID_ORIGIN",
+      403,
+      "Cross-site server action request was rejected"
+    );
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, validateServerActionRequest, "validateServerActionRequest");
+async function prepareServerActionRequest(request, config, kind, actionId) {
+  validateServerActionRequest(request, config);
+  if (kind === "javascript") {
+    validateActionId(actionId);
+  }
+  const contentType = getSupportedContentType(request, kind);
+  const bytes = await readBodyWithLimit(request, config.bodySizeLimit);
+  if (kind === "form" || contentType === "multipart/form-data") {
+    return {
+      body: await parseFormData(request, bytes),
+      contentType
+    };
+  }
+  return {
+    body: new TextDecoder().decode(bytes),
+    contentType
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, prepareServerActionRequest, "prepareServerActionRequest");
+function createServerActionRequestErrorResponse(error) {
+  if (!(error instanceof ServerActionRequestError)) {
+    return null;
+  }
+  const headers = new Headers({
+    "cache-control": "no-store",
+    "content-type": "text/plain; charset=utf-8",
+    "x-content-type-options": "nosniff"
+  });
+  if (error.status === 405) {
+    headers.set("allow", "POST");
+  }
+  return new Response(getPublicErrorMessage(error.status), {
+    status: error.status,
+    headers
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createServerActionRequestErrorResponse, "createServerActionRequestErrorResponse");
+function sanitizeServerActionError(error) {
+  const declaredFailure = serializeServerFnFailure(error);
+  if (declaredFailure) return declaredFailure;
+  return {
+    name: "ServerActionError",
+    message: "Server function failed"
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, sanitizeServerActionError, "sanitizeServerActionError");
+async function runWithServerActionRequest(request, callback) {
+  throwIfAborted(request.signal);
+  const context = {
+    request,
+    signal: request.signal,
+    invalidations: /* @__PURE__ */ new Set(),
+    cacheTasks: /* @__PURE__ */ new Set()
+  };
+  return getServerActionStorage().run(context, async () => {
+    try {
+      const result = await callback();
+      await Promise.all(context.cacheTasks);
+      return result;
+    } catch (error) {
+      await Promise.allSettled(context.cacheTasks);
+      throw error;
+    }
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, runWithServerActionRequest, "runWithServerActionRequest");
+function getServerActionExecutionContext() {
+  return getServerActionStorage().getStore();
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getServerActionExecutionContext, "getServerActionExecutionContext");
+function getServerActionSignal() {
+  return _nullishCoalesce(_optionalChain([getServerActionExecutionContext, 'call', _10 => _10(), 'optionalAccess', _11 => _11.signal]), () => ( getFallbackAbortController().signal));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getServerActionSignal, "getServerActionSignal");
+function getServerActionInvalidations() {
+  return Array.from(_nullishCoalesce(_optionalChain([getServerActionExecutionContext, 'call', _12 => _12(), 'optionalAccess', _13 => _13.invalidations]), () => ( [])));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getServerActionInvalidations, "getServerActionInvalidations");
+_chunkZEG3OPIBcjs.subscribeFarmCacheInvalidation.call(void 0, (key) => {
+  _optionalChain([getServerActionExecutionContext, 'call', _14 => _14(), 'optionalAccess', _15 => _15.invalidations, 'access', _16 => _16.add, 'call', _17 => _17(key)]);
+});
+_chunkZEG3OPIBcjs.subscribeFarmCacheTask.call(void 0, (task) => {
+  _optionalChain([getServerActionExecutionContext, 'call', _18 => _18(), 'optionalAccess', _19 => _19.cacheTasks, 'access', _20 => _20.add, 'call', _21 => _21(task)]);
+});
+function getServerActionStorage() {
+  const globalState = globalThis;
+  if (!globalState[SERVER_ACTION_STORAGE_KEY]) {
+    globalState[SERVER_ACTION_STORAGE_KEY] = new (0, _async_hooks.AsyncLocalStorage)();
+  }
+  return globalState[SERVER_ACTION_STORAGE_KEY];
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getServerActionStorage, "getServerActionStorage");
+function getFallbackAbortController() {
+  const globalState = globalThis;
+  if (!globalState[FALLBACK_ABORT_CONTROLLER_KEY]) {
+    globalState[FALLBACK_ABORT_CONTROLLER_KEY] = new AbortController();
+  }
+  return globalState[FALLBACK_ABORT_CONTROLLER_KEY];
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFallbackAbortController, "getFallbackAbortController");
+function resolveSourceOrigin(request) {
+  const result = _chunkSVRTJOUFcjs.getRequestSourceOrigin.call(void 0, request);
+  if (!result.ok) {
+    throw new ServerActionRequestError(
+      "INVALID_ORIGIN",
+      403,
+      result.reason === "opaque-origin" ? "Opaque origins are not allowed" : "Invalid request origin"
+    );
+  }
+  return result.origin;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveSourceOrigin, "resolveSourceOrigin");
+function validateActionId(actionId) {
+  if (!actionId || actionId.length > 4096 || hasControlCharacters(actionId)) {
+    throw new ServerActionRequestError("INVALID_ACTION_ID", 400, "Invalid server action id");
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, validateActionId, "validateActionId");
+function hasControlCharacters(value) {
+  for (let index = 0; index < value.length; index++) {
+    const code = value.charCodeAt(index);
+    if (code <= 31 || code === 127) return true;
+  }
+  return false;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, hasControlCharacters, "hasControlCharacters");
+function getSupportedContentType(request, kind) {
+  const header = _optionalChain([request, 'access', _22 => _22.headers, 'access', _23 => _23.get, 'call', _24 => _24("content-type"), 'optionalAccess', _25 => _25.trim, 'call', _26 => _26(), 'access', _27 => _27.toLowerCase, 'call', _28 => _28()]);
+  const contentType = _nullishCoalesce(_optionalChain([header, 'optionalAccess', _29 => _29.split, 'call', _30 => _30(";", 1), 'access', _31 => _31[0], 'optionalAccess', _32 => _32.trim, 'call', _33 => _33()]), () => ( ""));
+  const supported = kind === "form" ? FORM_ACTION_CONTENT_TYPES : JAVASCRIPT_ACTION_CONTENT_TYPES;
+  if (!supported.has(contentType)) {
+    throw new ServerActionRequestError(
+      "UNSUPPORTED_CONTENT_TYPE",
+      415,
+      "Unsupported server action content type"
+    );
+  }
+  return contentType;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getSupportedContentType, "getSupportedContentType");
+async function readBodyWithLimit(request, limit) {
+  const contentLength = _optionalChain([request, 'access', _34 => _34.headers, 'access', _35 => _35.get, 'call', _36 => _36("content-length"), 'optionalAccess', _37 => _37.trim, 'call', _38 => _38()]);
+  if (contentLength) {
+    if (!/^\d+$/.test(contentLength)) {
+      throw new ServerActionRequestError(
+        "INVALID_CONTENT_LENGTH",
+        400,
+        "Invalid content-length header"
+      );
+    }
+    if (Number(contentLength) > limit) {
+      throw new ServerActionRequestError("BODY_TOO_LARGE", 413, "Server action body is too large");
+    }
+  }
+  throwIfAborted(request.signal);
+  if (!request.body) return new Uint8Array();
+  const reader = request.body.getReader();
+  const chunks = [];
+  let total = 0;
+  const cancelBodyRead = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
+    void reader.cancel(request.signal.reason).catch(() => {
+    });
+  }, "cancelBodyRead");
+  request.signal.addEventListener("abort", cancelBodyRead, { once: true });
+  try {
+    while (true) {
+      throwIfAborted(request.signal);
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!value) continue;
+      total += value.byteLength;
+      if (total > limit) {
+        const error = new ServerActionRequestError(
+          "BODY_TOO_LARGE",
+          413,
+          "Server action body is too large"
+        );
+        void reader.cancel(error).catch(() => {
+        });
+        throw error;
+      }
+      chunks.push(value);
+    }
+  } catch (error) {
+    if (request.signal.aborted) throwIfAborted(request.signal);
+    throw error;
+  } finally {
+    request.signal.removeEventListener("abort", cancelBodyRead);
+    reader.releaseLock();
+  }
+  throwIfAborted(request.signal);
+  const body = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return body;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, readBodyWithLimit, "readBodyWithLimit");
+async function parseFormData(request, bytes) {
+  const body = new ArrayBuffer(bytes.byteLength);
+  new Uint8Array(body).set(bytes);
+  const copy = new Request(request.url, {
+    method: "POST",
+    headers: request.headers,
+    body
+  });
+  try {
+    return await copy.formData();
+  } catch (e) {
+    throw new ServerActionRequestError("INVALID_BODY", 400, "Invalid server action form body");
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, parseFormData, "parseFormData");
+function getPublicErrorMessage(status) {
+  switch (status) {
+    case 400:
+      return "Bad Request";
+    case 403:
+      return "Forbidden";
+    case 405:
+      return "Method Not Allowed";
+    case 413:
+      return "Payload Too Large";
+    case 415:
+      return "Unsupported Media Type";
+    default:
+      return "Server Action Request Failed";
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getPublicErrorMessage, "getPublicErrorMessage");
+function throwIfAborted(signal) {
+  if (!signal.aborted) return;
+  if (signal.reason !== void 0) throw signal.reason;
+  throw new DOMException("The operation was aborted", "AbortError");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, throwIfAborted, "throwIfAborted");
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.FARM_SERVER_FN_FAILURE_SYMBOL = FARM_SERVER_FN_FAILURE_SYMBOL; exports.ServerFnFailure = ServerFnFailure; exports.ServerActionError = ServerActionError; exports.isServerFnFailure = isServerFnFailure; exports.createServerFnTransportError = createServerFnTransportError; exports.DEFAULT_SERVER_ACTION_BODY_SIZE_LIMIT = DEFAULT_SERVER_ACTION_BODY_SIZE_LIMIT; exports.ServerActionRequestError = ServerActionRequestError; exports.resolveServerActionsConfig = resolveServerActionsConfig; exports.validateServerActionRequest = validateServerActionRequest; exports.prepareServerActionRequest = prepareServerActionRequest; exports.createServerActionRequestErrorResponse = createServerActionRequestErrorResponse; exports.sanitizeServerActionError = sanitizeServerActionError; exports.runWithServerActionRequest = runWithServerActionRequest; exports.getServerActionExecutionContext = getServerActionExecutionContext; exports.getServerActionSignal = getServerActionSignal; exports.getServerActionInvalidations = getServerActionInvalidations;

package/dist/chunk-TFAXUHWX.cjs

@@ -0,0 +1,206 @@
+"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(); } } 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 _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/renderer.ts
+var _module = require('module');
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _url = require('url');
+var DEFAULT_RENDERER_CAPABILITIES = Object.freeze({
+  streaming: Object.freeze({ node: false, web: false }),
+  // Conservative default: assume a re-render rebuilds until a renderer states
+  // otherwise, so callers do not silently rely on reconciliation.
+  reconcilesRerenders: false,
+  functionComponents: false
+});
+function getFarmRendererCapabilities(renderer) {
+  const defaultStreaming = {
+    node: _nullishCoalesce(_optionalChain([renderer, 'optionalAccess', _ => _.capabilities, 'optionalAccess', _2 => _2.streaming, 'optionalAccess', _3 => _3.node]), () => ( DEFAULT_RENDERER_CAPABILITIES.streaming.node)),
+    web: _nullishCoalesce(_optionalChain([renderer, 'optionalAccess', _4 => _4.capabilities, 'optionalAccess', _5 => _5.streaming, 'optionalAccess', _6 => _6.web]), () => ( DEFAULT_RENDERER_CAPABILITIES.streaming.web))
+  };
+  const runtimes = Object.fromEntries(
+    ["node", "edge"].flatMap((runtime) => {
+      const override = _optionalChain([renderer, 'optionalAccess', _7 => _7.capabilities, 'optionalAccess', _8 => _8.streaming, 'optionalAccess', _9 => _9.runtimes, 'optionalAccess', _10 => _10[runtime]]);
+      if (!override) return [];
+      return [
+        [
+          runtime,
+          {
+            node: _nullishCoalesce(override.node, () => ( defaultStreaming.node)),
+            web: _nullishCoalesce(override.web, () => ( defaultStreaming.web))
+          }
+        ]
+      ];
+    })
+  );
+  return {
+    streaming: {
+      ...defaultStreaming,
+      ...Object.keys(runtimes).length > 0 ? { runtimes } : {}
+    },
+    reconcilesRerenders: _nullishCoalesce(_optionalChain([renderer, 'optionalAccess', _11 => _11.capabilities, 'optionalAccess', _12 => _12.reconcilesRerenders]), () => ( DEFAULT_RENDERER_CAPABILITIES.reconcilesRerenders)),
+    functionComponents: _nullishCoalesce(_optionalChain([renderer, 'optionalAccess', _13 => _13.capabilities, 'optionalAccess', _14 => _14.functionComponents]), () => ( DEFAULT_RENDERER_CAPABILITIES.functionComponents))
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmRendererCapabilities, "getFarmRendererCapabilities");
+function getFarmRendererStreamingCapabilitiesForRuntime(renderer, runtime) {
+  const streaming = getFarmRendererCapabilities(renderer).streaming;
+  if (runtime === "unknown") return { node: streaming.node, web: streaming.web };
+  return _nullishCoalesce(_optionalChain([streaming, 'access', _15 => _15.runtimes, 'optionalAccess', _16 => _16[runtime]]), () => ( { node: streaming.node, web: streaming.web }));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmRendererStreamingCapabilitiesForRuntime, "getFarmRendererStreamingCapabilitiesForRuntime");
+function assertFarmRendererStreamingRuntime(name, renderer, runtimeModule, runtime) {
+  const declared = getFarmRendererStreamingCapabilitiesForRuntime(renderer, runtime);
+  const runtimeDeclaration = _optionalChain([runtimeModule, 'access', _17 => _17.capabilities, 'optionalAccess', _18 => _18.streaming]);
+  if (runtimeDeclaration) {
+    const advertised = getFarmRendererStreamingCapabilitiesForRuntime(
+      { capabilities: { streaming: runtimeDeclaration } },
+      runtime
+    );
+    if (declared.node && !advertised.node || declared.web && !advertised.web) {
+      throw new Error(
+        `Renderer \`${name}\` server module advertises ${JSON.stringify(advertised)} streaming for the ${runtime} runtime, which does not satisfy its descriptor ${JSON.stringify(declared)}.`
+      );
+    }
+  }
+  if (declared.node && typeof runtimeModule.renderToPipeableStream !== "function") {
+    throw new Error(
+      `Renderer \`${name}\` advertises Node streaming for the ${runtime} runtime but its server module does not export renderToPipeableStream().`
+    );
+  }
+  if (declared.web && typeof runtimeModule.renderToReadableStream !== "function") {
+    throw new Error(
+      `Renderer \`${name}\` advertises Web streaming for the ${runtime} runtime but its server module does not export renderToReadableStream().`
+    );
+  }
+  return declared;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, assertFarmRendererStreamingRuntime, "assertFarmRendererStreamingRuntime");
+var FARM_COMPONENT_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"];
+function resolveFarmComponentExtensions(extensions = []) {
+  return Array.from(
+    new Set(
+      [...FARM_COMPONENT_EXTENSIONS, ...extensions].map((extension) => {
+        const normalized = extension.trim().toLowerCase();
+        return normalized.startsWith(".") ? normalized : `.${normalized}`;
+      })
+    )
+  ).filter((extension) => extension.length > 1);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmComponentExtensions, "resolveFarmComponentExtensions");
+function getFarmRendererComponentExtensions(renderer) {
+  return resolveFarmComponentExtensions(_optionalChain([renderer, 'optionalAccess', _19 => _19.componentExtensions]));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmRendererComponentExtensions, "getFarmRendererComponentExtensions");
+var REACT_RENDERER = Object.freeze({
+  name: "react",
+  vite: "@farm.js/core/renderer/react/vite",
+  server: "@farm.js/core/renderer/react/server",
+  client: "@farm.js/core/renderer/react/client",
+  jsxImportSource: "react",
+  dedupe: ["react", "react-dom", "react/jsx-runtime", "react/jsx-dev-runtime"],
+  optimizeDeps: [
+    "react",
+    "react-dom",
+    "react-dom/client",
+    "react/jsx-runtime",
+    "react/jsx-dev-runtime"
+  ],
+  capabilities: {
+    streaming: {
+      node: true,
+      web: false,
+      runtimes: { edge: { node: false, web: true } }
+    },
+    reconcilesRerenders: true,
+    functionComponents: true
+  }
+});
+function defineRenderer(renderer) {
+  return renderer;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, defineRenderer, "defineRenderer");
+function resolveFarmRenderer(renderer) {
+  const resolved = renderer || REACT_RENDERER;
+  const fields = ["name", "vite", "server", "client"];
+  for (const field of fields) {
+    if (typeof resolved[field] !== "string" || resolved[field].trim().length === 0) {
+      throw new TypeError(`Farm renderer \`${field}\` must be a non-empty string.`);
+    }
+  }
+  return {
+    ...resolved,
+    componentExtensions: [...resolved.componentExtensions || []],
+    dedupe: [...resolved.dedupe || []],
+    optimizeDeps: [...resolved.optimizeDeps || []],
+    buildConcurrency: resolved.buildConcurrency || "parallel",
+    capabilities: getFarmRendererCapabilities(resolved),
+    options: resolved.options ? { ...resolved.options } : void 0
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmRenderer, "resolveFarmRenderer");
+async function readFarmRendererWebStream(stream) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let html = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    html += typeof value === "string" ? value : decoder.decode(value, { stream: true });
+  }
+  return html + decoder.decode();
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, readFarmRendererWebStream, "readFarmRendererWebStream");
+function isReactRenderer(renderer) {
+  return !renderer || renderer.name === "react";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isReactRenderer, "isReactRenderer");
+function resolveFarmRendererModule(root, specifier) {
+  const requireFromApp = _module.createRequire.call(void 0, _path2.default.join(_path2.default.resolve(root), "package.json"));
+  return requireFromApp.resolve(specifier);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmRendererModule, "resolveFarmRendererModule");
+function createFarmReactJsxPlugin() {
+  return {
+    name: "farm:react-jsx",
+    config(config) {
+      if (this && _optionalChain([this, 'access', _20 => _20.meta, 'optionalAccess', _21 => _21.rolldownVersion])) return;
+      if (config.esbuild === false || _optionalChain([config, 'access', _22 => _22.esbuild, 'optionalAccess', _23 => _23.jsx]) !== void 0) return;
+      return { esbuild: { jsx: "automatic" } };
+    }
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmReactJsxPlugin, "createFarmReactJsxPlugin");
+async function loadFarmRendererVitePlugins(renderer, root, options = {}) {
+  if (renderer.vite === REACT_RENDERER.vite) return [createFarmReactJsxPlugin()];
+  const modulePath = resolveFarmRendererModule(root, renderer.vite);
+  const rendererModule = await import(_url.pathToFileURL.call(void 0, modulePath).href);
+  if (typeof rendererModule.createFarmRendererPlugin !== "function") {
+    throw new Error(
+      `Renderer \`${renderer.name}\` module ${renderer.vite} must export createFarmRendererPlugin().`
+    );
+  }
+  const created = await rendererModule.createFarmRendererPlugin({
+    ...options,
+    rendererOptions: renderer.options
+  });
+  if (!created) return [];
+  return Array.isArray(created) ? [...created] : [created];
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, loadFarmRendererVitePlugins, "loadFarmRendererVitePlugins");
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.getFarmRendererCapabilities = getFarmRendererCapabilities; exports.getFarmRendererStreamingCapabilitiesForRuntime = getFarmRendererStreamingCapabilitiesForRuntime; exports.assertFarmRendererStreamingRuntime = assertFarmRendererStreamingRuntime; exports.FARM_COMPONENT_EXTENSIONS = FARM_COMPONENT_EXTENSIONS; exports.resolveFarmComponentExtensions = resolveFarmComponentExtensions; exports.getFarmRendererComponentExtensions = getFarmRendererComponentExtensions; exports.REACT_RENDERER = REACT_RENDERER; exports.defineRenderer = defineRenderer; exports.resolveFarmRenderer = resolveFarmRenderer; exports.readFarmRendererWebStream = readFarmRendererWebStream; exports.isReactRenderer = isReactRenderer; exports.resolveFarmRendererModule = resolveFarmRendererModule; exports.loadFarmRendererVitePlugins = loadFarmRendererVitePlugins;

package/dist/chunk-TIWHTW3Q.cjs

@@ -0,0 +1,24 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/write-file-if-changed.ts
+var _fs = require('fs');
+function writeFileIfChanged(filePath, content) {
+  try {
+    if (_fs.readFileSync.call(void 0, filePath, "utf8") === content) {
+      return false;
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  _fs.writeFileSync.call(void 0, filePath, content, "utf8");
+  return true;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, writeFileIfChanged, "writeFileIfChanged");
+
+
+
+exports.writeFileIfChanged = writeFileIfChanged;

package/dist/chunk-TKJZFIML.cjs

@@ -0,0 +1,20 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/response-body.ts
+function omitFarmResponseBody(response) {
+  if (response.body) {
+    void response.body.cancel().catch(() => void 0);
+  }
+  return new Response(null, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, omitFarmResponseBody, "omitFarmResponseBody");
+
+
+
+exports.omitFarmResponseBody = omitFarmResponseBody;