@farm.js/core 0.1.47 → 0.1.48

package/dist/chunk-ONG4RDW3.mjs

@@ -0,0 +1,155 @@
+import {
+  canonicalizeRequestPathname
+} from "./chunk-OHWM2VI4.mjs";
+import {
+  localizeFarmHref,
+  resolveFarmLocalePath
+} from "./chunk-7S7AAK2D.mjs";
+import {
+  assertBrowserStableRoutePath
+} from "./chunk-AYP2YFVN.mjs";
+
+// src/plugins/route-pattern.ts
+function validateConfigRouteSource(source, field = "Config route source") {
+  if (typeof source !== "string" || source.length === 0) {
+    throw new TypeError(`${field} must be a non-empty pathname pattern.`);
+  }
+  if (source.trim() !== source) {
+    throw new Error(`${field} cannot contain leading or trailing whitespace.`);
+  }
+  if (!source.startsWith("/")) {
+    throw new Error(`${field} must start with "/".`);
+  }
+  if (source.includes("?") || source.includes("#")) {
+    throw new Error(`${field} must be a pathname without a query string or hash.`);
+  }
+  if (source.includes("\\") || Array.from(source).some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code >= 127 && code <= 159;
+  })) {
+    throw new Error(`${field} cannot contain backslashes or control characters.`);
+  }
+  assertBrowserStableRoutePath(source);
+  return source;
+}
+function resolveConfigRoutePathname(pathname, i18n) {
+  const localizedPathname = i18n?.enabled ? resolveFarmLocalePath(pathname, i18n) : { pathname };
+  return {
+    pathname: normalizeConfigRoutePathname(canonicalizeRequestPathname(localizedPathname.pathname)),
+    ...i18n?.enabled && "locale" in localizedPathname ? { locale: localizedPathname.locale } : {}
+  };
+}
+function normalizeConfigRoutePathname(pathname) {
+  if (!pathname || pathname === "/") return "/";
+  return pathname.endsWith("/") ? pathname.replace(/\/+$/, "") || "/" : pathname;
+}
+function localizeConfigRouteDestination(destination, locale, i18n) {
+  return locale && i18n?.enabled ? localizeFarmHref(destination, locale, i18n) : destination;
+}
+function appendCatchAll(pattern) {
+  return pattern.endsWith("/") ? `${pattern.slice(0, -1)}(?:/(.*))?` : `${pattern}(.*)`;
+}
+function escapeRegexCharacter(character) {
+  return /[\\^$.*+?()[\]{}|]/.test(character) ? `\\${character}` : character;
+}
+function compileConfigRoutePattern(source) {
+  validateConfigRouteSource(source);
+  const tokens = [];
+  let pattern = "";
+  let captureIndex = 1;
+  for (let index = 0; index < source.length; ) {
+    const rest = source.slice(index);
+    const parameter = rest.match(/^:([A-Za-z0-9_]+)(\*)?/);
+    if (parameter) {
+      tokens.push({
+        kind: "param",
+        name: parameter[1],
+        captureIndex,
+        catchAll: parameter[2] === "*"
+      });
+      pattern = parameter[2] ? appendCatchAll(pattern) : `${pattern}([^/]+)`;
+      captureIndex += 1;
+      index += parameter[0].length;
+      continue;
+    }
+    if (source[index] === "*") {
+      tokens.push({ kind: "wildcard", captureIndex });
+      pattern = appendCatchAll(pattern);
+      captureIndex += 1;
+      index += 1;
+      continue;
+    }
+    pattern += escapeRegexCharacter(source[index]);
+    index += 1;
+  }
+  return { regex: new RegExp(`^${pattern}$`), tokens };
+}
+function interpolateConfigRouteDestination(destination, match, tokens) {
+  const namedCaptures = /* @__PURE__ */ new Map();
+  const wildcardCaptures = [];
+  const captures = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    const value = normalizeConfigRouteCapture(
+      match[token.captureIndex] || "",
+      token.kind === "wildcard" || token.catchAll
+    );
+    captures.set(token.captureIndex, value);
+    if (token.kind === "param") {
+      namedCaptures.set(token.name, value);
+    } else {
+      wildcardCaptures.push(value);
+    }
+  }
+  let result = "";
+  let wildcardIndex = 0;
+  for (let index = 0; index < destination.length; ) {
+    const rest = destination.slice(index);
+    const parameter = rest.match(/^:([A-Za-z0-9_]+)(\*)?/);
+    if (parameter) {
+      const value = namedCaptures.get(parameter[1]);
+      result += value === void 0 ? parameter[0] : value;
+      index += parameter[0].length;
+      continue;
+    }
+    const capture = rest.match(/^\$(\d+)/);
+    if (capture) {
+      result += captures.get(Number(capture[1])) ?? "";
+      index += capture[0].length;
+      continue;
+    }
+    if (destination[index] === "*") {
+      result += wildcardCaptures[wildcardIndex] || "";
+      wildcardIndex += 1;
+      index += 1;
+      continue;
+    }
+    result += destination[index];
+    index += 1;
+  }
+  return result;
+}
+function normalizeConfigRouteCapture(value, catchAll) {
+  const segments = catchAll ? value.split("/").filter(Boolean) : [value];
+  return segments.map((segment) => encodeConfigRouteSegment(decodeConfigRouteSegment(segment))).join("/");
+}
+function decodeConfigRouteSegment(segment) {
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return segment;
+  }
+}
+function encodeConfigRouteSegment(segment) {
+  return encodeURIComponent(segment).replace(
+    /[!'()*]/g,
+    (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`
+  );
+}
+
+export {
+  validateConfigRouteSource,
+  resolveConfigRoutePathname,
+  localizeConfigRouteDestination,
+  compileConfigRoutePattern,
+  interpolateConfigRouteDestination
+};

package/dist/chunk-OOJBBHYW.cjs

@@ -0,0 +1,38 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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/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 = _optionalChain([nextTitle, 'optionalAccess', _ => _.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)));
+}
+
+
+
+
+exports.FARM_NAVIGATION_HEAD_SELECTOR = FARM_NAVIGATION_HEAD_SELECTOR; exports.reconcileFarmDocumentHead = reconcileFarmDocumentHead;

package/dist/chunk-OOZEU5KK.cjs

@@ -0,0 +1,18 @@
+"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/bridge.ts
+var FALLBACK_SERVER_SNAPSHOT = Object.freeze({
+  theme: "system",
+  resolvedTheme: void 0,
+  mounted: false
+});
+var FARM_THEME_SERVER_SNAPSHOT_RESOLVER = /* @__PURE__ */ Symbol.for("farm.js.theme.server-snapshot-resolver");
+function _setFarmThemeServerSnapshotResolver(resolver) {
+  globalThis[FARM_THEME_SERVER_SNAPSHOT_RESOLVER] = resolver;
+}
+function getFarmThemeServerSnapshot() {
+  return _nullishCoalesce(_optionalChain([globalThis, 'access', _ => _[FARM_THEME_SERVER_SNAPSHOT_RESOLVER], 'optionalCall', _2 => _2()]), () => ( FALLBACK_SERVER_SNAPSHOT));
+}
+
+
+
+
+exports._setFarmThemeServerSnapshotResolver = _setFarmThemeServerSnapshotResolver; exports.getFarmThemeServerSnapshot = getFarmThemeServerSnapshot;

package/dist/chunk-OWQV6MLM.cjs

@@ -0,0 +1,82 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunkD22BUQKWcjs = require('./chunk-D22BUQKW.cjs');
+
+// src/i18n/routing.ts
+var RTL_LANGUAGES = /* @__PURE__ */ new Set([
+  "ar",
+  "arc",
+  "ckb",
+  "dv",
+  "fa",
+  "he",
+  "ku",
+  "nqo",
+  "ps",
+  "sd",
+  "syr",
+  "ug",
+  "ur",
+  "yi"
+]);
+function resolveFarmLocalePath(pathname, config) {
+  const normalized = normalizePathname(_chunkD22BUQKWcjs.stripFarmBasePath.call(void 0, pathname, config.basePath));
+  if (config.routing === "none") {
+    return { pathname: normalized, explicit: false };
+  }
+  const segments = normalized.split("/").filter(Boolean);
+  const firstSegment = segments[0];
+  const locale = config.locales.find(
+    (candidate) => candidate.toLowerCase() === _optionalChain([firstSegment, 'optionalAccess', _ => _.toLowerCase, 'call', _2 => _2()])
+  );
+  if (!locale) {
+    return { pathname: normalized, explicit: false };
+  }
+  const remaining = segments.slice(1);
+  return {
+    locale,
+    pathname: remaining.length > 0 ? `/${remaining.join("/")}` : "/",
+    explicit: true
+  };
+}
+function stripFarmLocaleFromPathname(pathname, config) {
+  return resolveFarmLocalePath(pathname, config).pathname;
+}
+function localizeFarmPathname(pathname, locale, config) {
+  const internalPathname = resolveFarmLocalePath(pathname, config).pathname;
+  let localizedPathname = internalPathname;
+  if (config.routing === "none") {
+    return _chunkD22BUQKWcjs.applyFarmBasePath.call(void 0, localizedPathname, config.basePath);
+  }
+  if (config.routing === "prefix-except-default" && locale === config.defaultLocale) {
+    return _chunkD22BUQKWcjs.applyFarmBasePath.call(void 0, localizedPathname, config.basePath);
+  }
+  localizedPathname = internalPathname === "/" ? `/${locale}` : `/${locale}${internalPathname}`;
+  return _chunkD22BUQKWcjs.applyFarmBasePath.call(void 0, localizedPathname, config.basePath);
+}
+function localizeFarmHref(href, locale, config) {
+  if (!href.startsWith("/") || href.startsWith("//")) return href;
+  const url = new URL(href, "http://farm.local");
+  url.pathname = localizeFarmPathname(url.pathname, locale, config);
+  return `${url.pathname}${url.search}${url.hash}`;
+}
+function getFarmLocaleDirection(locale, direction) {
+  const configured = _optionalChain([direction, 'optionalAccess', _3 => _3[locale]]);
+  if (configured) return configured;
+  const language = _optionalChain([locale, 'access', _4 => _4.split, 'call', _5 => _5("-"), 'access', _6 => _6[0], 'optionalAccess', _7 => _7.toLowerCase, 'call', _8 => _8()]) || locale.toLowerCase();
+  return RTL_LANGUAGES.has(language) ? "rtl" : "ltr";
+}
+function normalizePathname(pathname) {
+  const withLeadingSlash = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  if (withLeadingSlash === "/") return "/";
+  return withLeadingSlash.replace(/\/{2,}/g, "/").replace(/\/$/, "") || "/";
+}
+
+
+
+
+
+
+
+exports.resolveFarmLocalePath = resolveFarmLocalePath; exports.stripFarmLocaleFromPathname = stripFarmLocaleFromPathname; exports.localizeFarmPathname = localizeFarmPathname; exports.localizeFarmHref = localizeFarmHref; exports.getFarmLocaleDirection = getFarmLocaleDirection;

package/dist/chunk-OYZXVBZP.cjs

@@ -0,0 +1,133 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/route-runtime.ts
+function normalizeFarmRouteRuntimeConfig(value, source = "Route configuration") {
+  if (!value) return {};
+  const normalized = {};
+  if (value.runtime !== void 0) {
+    const runtime = value.runtime === "nodejs" ? "node" : value.runtime;
+    if (runtime !== "auto" && runtime !== "node" && runtime !== "edge") {
+      throw new TypeError(`${source} runtime must be "auto", "node", or "edge"`);
+    }
+    normalized.runtime = runtime;
+  }
+  if (value.regions !== void 0) {
+    if (value.regions === "auto") {
+      normalized.regions = "auto";
+    } else {
+      if (!Array.isArray(value.regions) || value.regions.length === 0) {
+        throw new TypeError(`${source} regions must be "auto" or a non-empty string array`);
+      }
+      const regions = Array.from(
+        new Set(
+          value.regions.map((region) => {
+            if (typeof region !== "string" || !region.trim() || /[\u0000-\u001f\u007f]/.test(region)) {
+              throw new TypeError(`${source} regions must contain non-empty region identifiers`);
+            }
+            return region.trim();
+          })
+        )
+      );
+      normalized.regions = regions;
+    }
+  }
+  if (value.maxDuration !== void 0) {
+    if (value.maxDuration === "auto") {
+      normalized.maxDuration = "auto";
+    } else if (typeof value.maxDuration !== "number" || !Number.isInteger(value.maxDuration) || value.maxDuration <= 0) {
+      throw new TypeError(`${source} maxDuration must be "auto" or a positive integer in seconds`);
+    } else {
+      normalized.maxDuration = value.maxDuration;
+    }
+  }
+  return normalized;
+}
+function mergeFarmRouteRuntimeConfigs(...configs) {
+  const merged = {};
+  for (const config of configs) {
+    if (!config) continue;
+    if (config.runtime !== void 0) merged.runtime = config.runtime;
+    if (config.regions !== void 0) merged.regions = config.regions;
+    if (config.maxDuration !== void 0) merged.maxDuration = config.maxDuration;
+  }
+  return merged;
+}
+function resolveFarmRouteRuntimeConfig(config, source) {
+  const normalized = normalizeFarmRouteRuntimeConfig(config, source);
+  return {
+    runtime: _nullishCoalesce(normalized.runtime, () => ( "auto")),
+    ...normalized.regions && normalized.regions !== "auto" ? { regions: [...normalized.regions] } : {},
+    ...typeof normalized.maxDuration === "number" ? { maxDuration: normalized.maxDuration } : {}
+  };
+}
+function hasFarmRouteRuntimeControls(config) {
+  return Boolean(
+    config && (config.runtime !== void 0 || config.regions !== void 0 || config.maxDuration !== void 0)
+  );
+}
+function getFarmRouteRuntimeConfig(value) {
+  if (!value || typeof value !== "object") return {};
+  const route = value;
+  return {
+    ...route.runtime !== void 0 ? { runtime: route.runtime } : {},
+    ...route.regions !== void 0 ? { regions: route.regions } : {},
+    ...route.maxDuration !== void 0 ? { maxDuration: route.maxDuration } : {}
+  };
+}
+function createFarmRouteRuntimeKey(config) {
+  return JSON.stringify({
+    runtime: config.runtime,
+    regions: config.regions || null,
+    maxDuration: config.maxDuration || null
+  });
+}
+function resolveFarmRouteRuleRuntimeConfig(pathname, routeRules) {
+  if (!routeRules) return {};
+  const matches = Object.entries(routeRules).filter(
+    ([pattern, rule]) => hasFarmRouteRuntimeControls(rule) && farmRouteRuleMatches(pattern, pathname)
+  ).sort(([left], [right]) => compareFarmRouteRuleSpecificity(left, right));
+  return mergeFarmRouteRuntimeConfigs(...matches.map(([, rule]) => rule));
+}
+function farmRouteRuleMatches(pattern, pathname) {
+  const normalizedPattern = normalizeRoutePattern(pattern);
+  const normalizedPathname = normalizeRoutePattern(pathname);
+  if (normalizedPattern === normalizedPathname) return true;
+  const expression = normalizedPattern.split("/").filter(Boolean).map((segment) => {
+    if (segment === "**") return ".*";
+    if (segment === "*") return "[^/]+";
+    if (/^\[\[\.\.\..+\]\]$/.test(segment)) return ".*";
+    if (/^\[\.\.\..+\]$/.test(segment)) return ".+";
+    if (/^\[.+\]$/.test(segment) || /^:.+$/.test(segment)) return "[^/]+";
+    return escapeRegExp(segment);
+  }).join("/");
+  return new RegExp(`^/${expression}/?$`).test(normalizedPathname);
+}
+function compareFarmRouteRuleSpecificity(left, right) {
+  const leftScore = getFarmRouteRuleSpecificity(left);
+  const rightScore = getFarmRouteRuleSpecificity(right);
+  return leftScore - rightScore || left.localeCompare(right);
+}
+function getFarmRouteRuleSpecificity(pattern) {
+  return normalizeRoutePattern(pattern).split("/").filter(Boolean).reduce((score, segment) => {
+    if (segment === "**" || segment.startsWith("[[...")) return score + 1;
+    if (segment === "*" || segment.startsWith("[...")) return score + 10;
+    if (/^\[.+\]$/.test(segment) || /^:.+$/.test(segment)) return score + 50;
+    return score + 100;
+  }, 0);
+}
+function normalizeRoutePattern(value) {
+  const withSlash = value.trim().startsWith("/") ? value.trim() : `/${value.trim()}`;
+  return withSlash.length > 1 ? withSlash.replace(/\/+$/, "") : withSlash;
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+
+
+
+
+
+
+
+
+
+exports.normalizeFarmRouteRuntimeConfig = normalizeFarmRouteRuntimeConfig; exports.mergeFarmRouteRuntimeConfigs = mergeFarmRouteRuntimeConfigs; exports.resolveFarmRouteRuntimeConfig = resolveFarmRouteRuntimeConfig; exports.hasFarmRouteRuntimeControls = hasFarmRouteRuntimeControls; exports.getFarmRouteRuntimeConfig = getFarmRouteRuntimeConfig; exports.createFarmRouteRuntimeKey = createFarmRouteRuntimeKey; exports.resolveFarmRouteRuleRuntimeConfig = resolveFarmRouteRuleRuntimeConfig; exports.farmRouteRuleMatches = farmRouteRuleMatches;

package/dist/chunk-OZC2JPW6.cjs

@@ -0,0 +1,10 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/config-entry.ts
+function defineConfig(config) {
+  return config;
+}
+var defineFarmConfig = defineConfig;
+
+
+
+
+exports.defineConfig = defineConfig; exports.defineFarmConfig = defineFarmConfig;

package/dist/chunk-P2355C6E.cjs

@@ -0,0 +1,186 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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/after.ts
+var _async_hooks = require('async_hooks');
+var AFTER_STORAGE = /* @__PURE__ */ Symbol.for("@farm.js/core/after-storage");
+function getAfterStorage() {
+  const runtime = globalThis;
+  const existing = runtime[AFTER_STORAGE];
+  if (existing instanceof _async_hooks.AsyncLocalStorage) {
+    return existing;
+  }
+  const storage = new (0, _async_hooks.AsyncLocalStorage)();
+  runtime[AFTER_STORAGE] = storage;
+  return storage;
+}
+var afterStorage = getAfterStorage();
+function defaultAfterErrorReporter(error) {
+  console.error("[Farm.js] after() callback failed:", error);
+}
+function reportAfterError(state, error) {
+  try {
+    state.reportError(error);
+  } catch (e) {
+  }
+}
+function createAfterRequestState(reportError = defaultAfterErrorReporter) {
+  let resolveResponseFinished;
+  let responseFinished = false;
+  const responseFinishedPromise = new Promise((resolve) => {
+    resolveResponseFinished = resolve;
+  });
+  const state = {
+    completion: Promise.resolve(),
+    finishResponse: () => {
+      if (responseFinished) return;
+      responseFinished = true;
+      resolveResponseFinished();
+    },
+    phase: "open",
+    reportError,
+    tasks: []
+  };
+  state.completion = responseFinishedPromise.then(
+    () => afterStorage.run(state, async () => {
+      state.phase = "running";
+      for (let index = 0; index < state.tasks.length; index++) {
+        const task = state.tasks[index];
+        task.start();
+        try {
+          await task.result;
+        } catch (error) {
+          reportAfterError(state, error);
+        }
+      }
+      state.phase = "closed";
+    })
+  );
+  return state;
+}
+function registerPlatformLifetime(state, context) {
+  if (!_optionalChain([context, 'optionalAccess', _ => _.waitUntil])) return;
+  try {
+    context.waitUntil(state.completion);
+  } catch (error) {
+    reportAfterError(state, error);
+  }
+}
+function registerResponseFinishedHook(state, context) {
+  if (!_optionalChain([context, 'optionalAccess', _2 => _2.onResponseFinished])) return false;
+  try {
+    context.onResponseFinished(state.finishResponse);
+    return true;
+  } catch (error) {
+    reportAfterError(state, error);
+    return false;
+  }
+}
+function finishSoon(state) {
+  setTimeout(state.finishResponse, 0);
+}
+function wrapResponseBody(response, request, state) {
+  if (request.method === "HEAD" || response.status < 200 || response.status > 599 || !response.body || response.bodyUsed || response.body.locked) {
+    finishSoon(state);
+    return response;
+  }
+  const reader = response.body.getReader();
+  let released = false;
+  const releaseReader = () => {
+    if (released) return;
+    released = true;
+    reader.releaseLock();
+  };
+  const body = new ReadableStream({
+    async pull(controller) {
+      try {
+        const chunk = await reader.read();
+        if (chunk.done) {
+          releaseReader();
+          controller.close();
+          finishSoon(state);
+          return;
+        }
+        controller.enqueue(chunk.value);
+      } catch (error) {
+        releaseReader();
+        controller.error(error);
+        finishSoon(state);
+      }
+    },
+    cancel(reason) {
+      try {
+        return reader.cancel(reason);
+      } finally {
+        releaseReader();
+        finishSoon(state);
+      }
+    }
+  });
+  return new Response(body, {
+    headers: response.headers,
+    status: response.status,
+    statusText: response.statusText
+  });
+}
+function after(callback) {
+  if (typeof callback !== "function") {
+    throw new TypeError("after() expects a callback function.");
+  }
+  const state = afterStorage.getStore();
+  if (!state) {
+    throw new Error("after() can only be used while Farm is handling a server request.");
+  }
+  if (state.phase === "closed") {
+    throw new Error("after() cannot schedule work after the request lifecycle has completed.");
+  }
+  let start;
+  const ready = new Promise((resolve) => {
+    start = resolve;
+  });
+  const result = ready.then(callback);
+  state.tasks.push({ result, start });
+}
+async function _runWithAfterRequest(request, handler, context) {
+  if (afterStorage.getStore()) {
+    return await handler();
+  }
+  const state = createAfterRequestState();
+  registerPlatformLifetime(state, context);
+  const hasResponseHook = registerResponseFinishedHook(state, context);
+  try {
+    const response = await afterStorage.run(state, handler);
+    return hasResponseHook ? response : wrapResponseBody(response, request, state);
+  } catch (error) {
+    finishSoon(state);
+    throw error;
+  }
+}
+async function _runWithAfterNodeResponse(response, handler, context) {
+  if (afterStorage.getStore()) {
+    return await handler();
+  }
+  const state = createAfterRequestState();
+  let finished = false;
+  const finish = () => {
+    if (finished) return;
+    finished = true;
+    response.off("finish", finish);
+    response.off("close", finish);
+    state.finishResponse();
+  };
+  response.once("finish", finish);
+  response.once("close", finish);
+  if (response.writableEnded || response.destroyed) setTimeout(finish, 0);
+  registerPlatformLifetime(state, context);
+  return await afterStorage.run(state, handler);
+}
+function _withAfterNodeMiddleware(handler) {
+  return async (request, response, next) => {
+    await _runWithAfterNodeResponse(response, () => handler(request, response, next));
+  };
+}
+
+
+
+
+
+
+exports.after = after; exports._runWithAfterRequest = _runWithAfterRequest; exports._runWithAfterNodeResponse = _runWithAfterNodeResponse; exports._withAfterNodeMiddleware = _withAfterNodeMiddleware;