@farm.js/core 0.1.46 → 0.1.48

package/dist/chunk-4OOBRCJX.mjs

@@ -1,300 +0,0 @@
-import {
-  readFarmEnvironmentValue
-} from "./chunk-ONUEYC6N.mjs";
-import {
-  __name
-} from "./chunk-LPEX4YW6.mjs";
-
-// src/env.ts
-var FARM_ENV_SYMBOL = /* @__PURE__ */ Symbol.for("farm.env");
-var FARM_ENV_RUNTIME_SYMBOL = /* @__PURE__ */ Symbol.for("farm.env.runtime");
-var farmEnvGlobal = globalThis;
-var currentEnv = getInitialEnv();
-function resolveEnv(config, source = getProcessEnv()) {
-  const resolved = {
-    server: resolveEnvScope(config?.server, source, "server"),
-    public: resolveEnvScope(config?.public, source, "public")
-  };
-  return resolved;
-}
-__name(resolveEnv, "resolveEnv");
-function createBundledEnv(env2, source = getProcessEnv()) {
-  const resolved = normalizeResolvedEnv(env2 ?? {});
-  const server = {};
-  const runtime = {};
-  for (const [key, value] of Object.entries(resolved.server)) {
-    const raw = source[key];
-    const type = getRuntimeEnvType(value);
-    if (raw !== void 0 && isSameEnvValue(coerceRuntimeEnvValue(raw, type), value)) {
-      runtime[key] = type;
-    } else {
-      server[key] = value;
-    }
-  }
-  return {
-    server,
-    public: resolved.public,
-    ...Object.keys(runtime).length > 0 ? { runtime: { server: runtime } } : {}
-  };
-}
-__name(createBundledEnv, "createBundledEnv");
-function setEnv(env2) {
-  currentEnv = prepareEnv(env2);
-  if (typeof window === "undefined") {
-    farmEnvGlobal[FARM_ENV_SYMBOL] = currentEnv;
-  }
-}
-__name(setEnv, "setEnv");
-function getResolvedEnv() {
-  const env2 = getCurrentEnv();
-  if (typeof window === "undefined") readRuntimeServerEnv(env2);
-  return env2;
-}
-__name(getResolvedEnv, "getResolvedEnv");
-function getEnv(key) {
-  const server = getEnvScope("server");
-  if (key === void 0) {
-    return server;
-  }
-  return readServerEnvKey(server, key);
-}
-__name(getEnv, "getEnv");
-function getPublicEnv(key) {
-  if (key === void 0) {
-    return getCurrentEnv().public;
-  }
-  return getCurrentEnv().public[key];
-}
-__name(getPublicEnv, "getPublicEnv");
-var env = createEnvProxy("server");
-var serverEnv = env;
-var publicEnv = createEnvProxy("public");
-function resolveEnvScope(shape, source, scope) {
-  if (!shape) {
-    return {};
-  }
-  const resolved = {};
-  for (const [key, parser] of Object.entries(shape)) {
-    try {
-      resolved[key] = parseEnvValue(parser, source[key], key, scope);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      throw new Error(`Invalid ${scope} env "${key}": ${message}`);
-    }
-  }
-  return resolved;
-}
-__name(resolveEnvScope, "resolveEnvScope");
-function parseEnvValue(parser, value, key, scope) {
-  if (typeof parser === "function") {
-    return parser(value, { key, scope });
-  }
-  if (parser && typeof parser.parse === "function") {
-    return parser.parse(value);
-  }
-  throw new Error("expected a parser function or schema with parse()");
-}
-__name(parseEnvValue, "parseEnvValue");
-function createEnvProxy(scope) {
-  return new Proxy(
-    {},
-    {
-      get(_target, property) {
-        if (typeof property === "symbol") {
-          return void 0;
-        }
-        const env2 = getEnvScope(scope);
-        return scope === "server" ? readServerEnvKey(env2, property) : env2[property];
-      },
-      ownKeys() {
-        return Reflect.ownKeys(getEnvScope(scope));
-      },
-      getOwnPropertyDescriptor(_target, property) {
-        const env2 = getEnvScope(scope);
-        if (!(property in env2)) {
-          return void 0;
-        }
-        return {
-          enumerable: true,
-          configurable: true,
-          value: env2[property]
-        };
-      },
-      has(_target, property) {
-        return property in getEnvScope(scope);
-      }
-    }
-  );
-}
-__name(createEnvProxy, "createEnvProxy");
-function getEnvScope(scope) {
-  const env2 = getCurrentEnv();
-  if (scope === "server") {
-    assertServerEnvAccess();
-    readRuntimeServerEnv(env2);
-  }
-  return env2[scope] || {};
-}
-__name(getEnvScope, "getEnvScope");
-function readServerEnvKey(server, key) {
-  const value = server[key];
-  if (value === void 0) {
-    const state = getCurrentEnv()[FARM_ENV_RUNTIME_SYMBOL];
-    if (state && key in state.pending && !state.warned.has(key)) {
-      state.warned.add(key);
-      console.warn(
-        `[Farm] Server env "${key}" was set when this app was built but is not set where the server runs, so it reads as undefined. Farm reads server env at runtime and does not store it in the build output; set "${key}" in the server's environment.`
-      );
-    }
-  }
-  return value;
-}
-__name(readServerEnvKey, "readServerEnvKey");
-function readRuntimeServerEnv(env2) {
-  const state = env2[FARM_ENV_RUNTIME_SYMBOL];
-  if (!state) return;
-  for (const [key, type] of Object.entries(state.pending)) {
-    const raw = readFarmEnvironmentValue(key);
-    if (raw === void 0) continue;
-    env2.server[key] = coerceRuntimeEnvValue(raw, type);
-    delete state.pending[key];
-  }
-}
-__name(readRuntimeServerEnv, "readRuntimeServerEnv");
-function getRuntimeEnvType(value) {
-  if (typeof value === "number") return "number";
-  if (typeof value === "boolean") return "boolean";
-  if (value !== null && typeof value === "object" && !(value instanceof Date)) return "json";
-  return "string";
-}
-__name(getRuntimeEnvType, "getRuntimeEnvType");
-function coerceRuntimeEnvValue(raw, type) {
-  if (type === "number") {
-    const value = Number(raw);
-    return raw.trim() !== "" && Number.isFinite(value) ? value : raw;
-  }
-  if (type === "boolean") {
-    if (/^(true|1)$/i.test(raw.trim())) return true;
-    if (/^(false|0|)$/i.test(raw.trim())) return false;
-    return raw;
-  }
-  if (type === "json") {
-    try {
-      return JSON.parse(raw);
-    } catch {
-      return raw;
-    }
-  }
-  return raw;
-}
-__name(coerceRuntimeEnvValue, "coerceRuntimeEnvValue");
-function isSameEnvValue(left, right) {
-  if (Object.is(left, right)) return true;
-  if (Array.isArray(left) || Array.isArray(right)) {
-    return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((item, index) => isSameEnvValue(item, right[index]));
-  }
-  if (!isPlainObject(left) || !isPlainObject(right)) return false;
-  const keys = Object.keys(left);
-  return keys.length === Object.keys(right).length && keys.every(
-    (key) => Object.prototype.hasOwnProperty.call(right, key) && isSameEnvValue(left[key], right[key])
-  );
-}
-__name(isSameEnvValue, "isSameEnvValue");
-function isPlainObject(value) {
-  if (!value || typeof value !== "object") return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-__name(isPlainObject, "isPlainObject");
-function prepareEnv(env2) {
-  const normalized = normalizeResolvedEnv(env2);
-  const runtime = env2.runtime?.server;
-  if (!isRecord(runtime) || Object.keys(runtime).length === 0) return normalized;
-  const prepared = { server: { ...normalized.server }, public: normalized.public };
-  Object.defineProperty(prepared, FARM_ENV_RUNTIME_SYMBOL, {
-    value: {
-      pending: { ...runtime },
-      warned: /* @__PURE__ */ new Set()
-    },
-    enumerable: false
-  });
-  return prepared;
-}
-__name(prepareEnv, "prepareEnv");
-function assertServerEnvAccess() {
-  if (typeof window !== "undefined") {
-    throw new Error("Farm server env is not available in the browser. Use publicEnv.");
-  }
-}
-__name(assertServerEnvAccess, "assertServerEnvAccess");
-function getInitialEnv() {
-  const injectedEnv = getInjectedEnv();
-  if (injectedEnv) {
-    return injectedEnv;
-  }
-  if (typeof window === "undefined" && farmEnvGlobal[FARM_ENV_SYMBOL]) {
-    return normalizeResolvedEnv(farmEnvGlobal[FARM_ENV_SYMBOL]);
-  }
-  return {
-    server: {},
-    public: getInjectedPublicEnv()
-  };
-}
-__name(getInitialEnv, "getInitialEnv");
-function getCurrentEnv() {
-  if (typeof window === "undefined" && farmEnvGlobal[FARM_ENV_SYMBOL]) {
-    return farmEnvGlobal[FARM_ENV_SYMBOL];
-  }
-  return currentEnv;
-}
-__name(getCurrentEnv, "getCurrentEnv");
-function getInjectedEnv() {
-  try {
-    if (typeof __FARM_ENV__ !== "undefined" && __FARM_ENV__) {
-      return prepareEnv(__FARM_ENV__);
-    }
-  } catch {
-  }
-  return null;
-}
-__name(getInjectedEnv, "getInjectedEnv");
-function getInjectedPublicEnv() {
-  try {
-    if (typeof __FARM_PUBLIC_ENV__ !== "undefined" && __FARM_PUBLIC_ENV__) {
-      return __FARM_PUBLIC_ENV__;
-    }
-  } catch {
-  }
-  return {};
-}
-__name(getInjectedPublicEnv, "getInjectedPublicEnv");
-function normalizeResolvedEnv(env2) {
-  return {
-    server: isRecord(env2.server) ? env2.server : {},
-    public: isRecord(env2.public) ? env2.public : {}
-  };
-}
-__name(normalizeResolvedEnv, "normalizeResolvedEnv");
-function isRecord(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-__name(isRecord, "isRecord");
-function getProcessEnv() {
-  if (typeof process !== "undefined" && process.env) {
-    return process.env;
-  }
-  return {};
-}
-__name(getProcessEnv, "getProcessEnv");
-
-export {
-  resolveEnv,
-  createBundledEnv,
-  setEnv,
-  getResolvedEnv,
-  getEnv,
-  getPublicEnv,
-  env,
-  serverEnv,
-  publicEnv
-};

package/dist/chunk-4PPEPOZZ.cjs

@@ -1,21 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
-
-var _chunk72ADZ6GQcjs = require('./chunk-72ADZ6GQ.cjs');
-
-
-var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
-
-// src/api/server-context.ts
-var _async_hooks = require('async_hooks');
-var API_RUNTIME_STORAGE = /* @__PURE__ */ Symbol.for("@farm.js/core/api-request-storage");
-var runtimeGlobal = globalThis;
-var storage = _nullishCoalesce(runtimeGlobal[API_RUNTIME_STORAGE], () => ( (runtimeGlobal[API_RUNTIME_STORAGE] = new (0, _async_hooks.AsyncLocalStorage)())));
-_chunk72ADZ6GQcjs.setAPIRequestRuntimeResolver.call(void 0, () => storage.getStore());
-function _runWithAPIRequestRuntime(runtime, run) {
-  return storage.run(runtime, run);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, _runWithAPIRequestRuntime, "_runWithAPIRequestRuntime");
-
-
-
-exports._runWithAPIRequestRuntime = _runWithAPIRequestRuntime;

package/dist/chunk-4RB44K6Z.mjs

@@ -1,94 +0,0 @@
-import {
-  __name
-} from "./chunk-LPEX4YW6.mjs";
-
-// src/base-path.ts
-var FARM_BASE_PATH = /* @__PURE__ */ Symbol.for("farm.basePath");
-function getFarmGlobalState() {
-  return globalThis;
-}
-__name(getFarmGlobalState, "getFarmGlobalState");
-function setFarmBasePath(basePath) {
-  getFarmGlobalState()[FARM_BASE_PATH] = normalizeFarmBasePath(basePath);
-}
-__name(setFarmBasePath, "setFarmBasePath");
-function getFarmBasePath() {
-  return getFarmGlobalState()[FARM_BASE_PATH] ?? "";
-}
-__name(getFarmBasePath, "getFarmBasePath");
-function applyFarmBasePath(href, basePath = getFarmBasePath()) {
-  const normalizedBasePath = normalizeFarmBasePath(basePath);
-  if (!normalizedBasePath || !href.startsWith("/") || href.startsWith("//")) return href;
-  const canonicalHref = canonicalizeAppRelativeHref(href);
-  if (canonicalHref === normalizedBasePath || canonicalHref.startsWith(`${normalizedBasePath}/`) || canonicalHref.startsWith(`${normalizedBasePath}?`) || canonicalHref.startsWith(`${normalizedBasePath}#`)) {
-    return canonicalHref;
-  }
-  return `${normalizedBasePath}${canonicalHref}`;
-}
-__name(applyFarmBasePath, "applyFarmBasePath");
-function canonicalizeAppRelativeHref(href) {
-  const origin = "http://farm.local";
-  const resolved = new URL(href, origin);
-  if (resolved.origin !== origin) {
-    throw new Error("Farm app-relative href cannot change the URL origin.");
-  }
-  return `${resolved.pathname}${resolved.search}${resolved.hash}`;
-}
-__name(canonicalizeAppRelativeHref, "canonicalizeAppRelativeHref");
-function stripFarmBasePath(pathname, basePath = getFarmBasePath()) {
-  const normalizedBasePath = normalizeFarmBasePath(basePath);
-  if (!normalizedBasePath) return pathname || "/";
-  if (pathname === normalizedBasePath) return "/";
-  if (!pathname.startsWith(`${normalizedBasePath}/`)) return pathname || "/";
-  return pathname.slice(normalizedBasePath.length) || "/";
-}
-__name(stripFarmBasePath, "stripFarmBasePath");
-function normalizeFarmBasePath(basePath) {
-  if (!basePath || basePath === "/") return "";
-  const hasUnstableCharacters = /* @__PURE__ */ __name((candidate) => candidate.includes("\\") || Array.from(candidate).some((character) => {
-    const code = character.charCodeAt(0);
-    return code <= 31 || code >= 127 && code <= 159;
-  }), "hasUnstableCharacters");
-  if (hasUnstableCharacters(basePath)) {
-    throw new Error("Farm basePath cannot contain backslashes or control characters.");
-  }
-  const pathname = basePath.trim();
-  if (!pathname || pathname === "/") return "";
-  if (pathname.includes("?") || pathname.includes("#")) {
-    throw new Error("Farm basePath cannot contain a query string or hash.");
-  }
-  if (pathname.startsWith("//") || /^[a-z][a-z\d+.-]*:\/\//i.test(pathname)) {
-    throw new Error('Farm basePath must be a pathname such as "/docs", not a URL.');
-  }
-  for (const segment of pathname.split("/")) {
-    let decoded = segment;
-    try {
-      decoded = decodeURIComponent(segment);
-    } catch {
-    }
-    if (hasUnstableCharacters(decoded)) {
-      throw new Error("Farm basePath cannot contain backslashes or control characters.");
-    }
-    if (decoded.includes("/")) {
-      throw new Error("Farm basePath cannot contain percent-encoded path separators.");
-    }
-    if (decoded === "." || decoded === "..") {
-      throw new Error('Farm basePath cannot contain "." or ".." path segments.');
-    }
-  }
-  return `/${pathname}`.replace(/\/{2,}/g, "/").replace(/\/+$/, "");
-}
-__name(normalizeFarmBasePath, "normalizeFarmBasePath");
-function normalizeFarmConfigBasePath(basePath) {
-  return normalizeFarmBasePath(basePath) || "/";
-}
-__name(normalizeFarmConfigBasePath, "normalizeFarmConfigBasePath");
-
-export {
-  setFarmBasePath,
-  getFarmBasePath,
-  applyFarmBasePath,
-  stripFarmBasePath,
-  normalizeFarmBasePath,
-  normalizeFarmConfigBasePath
-};

package/dist/chunk-4SIYUGRY.mjs

@@ -1,93 +0,0 @@
-import {
-  __name
-} from "./chunk-LPEX4YW6.mjs";
-
-// src/cache-invalidation.ts
-var FARM_CACHE_INVALIDATION_HEADER = "x-farm-cache-invalidations";
-var FARM_CACHE_INVALIDATION_STATE = /* @__PURE__ */ Symbol.for("farm.cacheInvalidationState");
-var globalState = globalThis;
-function getFarmCacheInvalidationState() {
-  return globalState[FARM_CACHE_INVALIDATION_STATE] ?? (globalState[FARM_CACHE_INVALIDATION_STATE] = {
-    listeners: /* @__PURE__ */ new Set(),
-    taskListeners: /* @__PURE__ */ new Set()
-  });
-}
-__name(getFarmCacheInvalidationState, "getFarmCacheInvalidationState");
-function warnFarmCacheListenerError(scope, error) {
-  const detail = error instanceof Error ? error.stack ?? error.message : String(error);
-  console.warn(`[farm:cache] ${scope} listener failed: ${detail}`);
-}
-__name(warnFarmCacheListenerError, "warnFarmCacheListenerError");
-function notifyFarmCacheInvalidation(key, source = "local") {
-  if (typeof key !== "string" || key.length === 0) return;
-  for (const listener of getFarmCacheInvalidationState().listeners) {
-    try {
-      listener(key, source);
-    } catch (error) {
-      warnFarmCacheListenerError("invalidation", error);
-    }
-  }
-}
-__name(notifyFarmCacheInvalidation, "notifyFarmCacheInvalidation");
-function notifyFarmCacheTask(task) {
-  for (const listener of getFarmCacheInvalidationState().taskListeners) {
-    try {
-      listener(task);
-    } catch (error) {
-      warnFarmCacheListenerError("task", error);
-    }
-  }
-}
-__name(notifyFarmCacheTask, "notifyFarmCacheTask");
-function applyFarmCacheInvalidations(keys, source = "local") {
-  if (!Array.isArray(keys)) return;
-  for (const key of keys) {
-    if (typeof key === "string") {
-      notifyFarmCacheInvalidation(key, source);
-    }
-  }
-}
-__name(applyFarmCacheInvalidations, "applyFarmCacheInvalidations");
-function encodeFarmCacheInvalidations(keys) {
-  const normalized = Array.from(
-    new Set(keys.filter((key) => typeof key === "string" && key.length > 0))
-  );
-  if (normalized.length === 0) return null;
-  return encodeURIComponent(JSON.stringify(normalized));
-}
-__name(encodeFarmCacheInvalidations, "encodeFarmCacheInvalidations");
-function decodeFarmCacheInvalidations(value) {
-  if (!value) return [];
-  try {
-    const parsed = JSON.parse(decodeURIComponent(value));
-    return Array.isArray(parsed) ? Array.from(
-      new Set(parsed.filter((key) => typeof key === "string" && key.length > 0))
-    ) : [];
-  } catch {
-    return [];
-  }
-}
-__name(decodeFarmCacheInvalidations, "decodeFarmCacheInvalidations");
-function subscribeFarmCacheInvalidation(listener) {
-  const state = getFarmCacheInvalidationState();
-  state.listeners.add(listener);
-  return () => state.listeners.delete(listener);
-}
-__name(subscribeFarmCacheInvalidation, "subscribeFarmCacheInvalidation");
-function subscribeFarmCacheTask(listener) {
-  const state = getFarmCacheInvalidationState();
-  state.taskListeners.add(listener);
-  return () => state.taskListeners.delete(listener);
-}
-__name(subscribeFarmCacheTask, "subscribeFarmCacheTask");
-
-export {
-  FARM_CACHE_INVALIDATION_HEADER,
-  notifyFarmCacheInvalidation,
-  notifyFarmCacheTask,
-  applyFarmCacheInvalidations,
-  encodeFarmCacheInvalidations,
-  decodeFarmCacheInvalidations,
-  subscribeFarmCacheInvalidation,
-  subscribeFarmCacheTask
-};

package/dist/chunk-4TLUFAIP.cjs

@@ -1,92 +0,0 @@
-"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 _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
-
-// src/request-context.ts
-var REQUEST_CONTEXT_STORE_KEY = /* @__PURE__ */ Symbol.for("farm.requestContextStore");
-function getRequestContextStore() {
-  const globalState = globalThis;
-  if (!globalState[REQUEST_CONTEXT_STORE_KEY]) {
-    globalState[REQUEST_CONTEXT_STORE_KEY] = /* @__PURE__ */ new WeakMap();
-  }
-  return globalState[REQUEST_CONTEXT_STORE_KEY];
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, getRequestContextStore, "getRequestContextStore");
-function getBucket(target) {
-  const requestContextStore = getRequestContextStore();
-  let bucket = requestContextStore.get(target);
-  if (!bucket) {
-    bucket = {
-      privateData: /* @__PURE__ */ new Map(),
-      exposedData: /* @__PURE__ */ new Map()
-    };
-    requestContextStore.set(target, bucket);
-  }
-  return bucket;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, getBucket, "getBucket");
-function setRequestContext(target, key, value, options = {}) {
-  const bucket = getBucket(target);
-  bucket.privateData.set(key, value);
-  if (options.exposeToPage) {
-    bucket.exposedData.set(key, value);
-  }
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, setRequestContext, "setRequestContext");
-function getRequestContext(target, key) {
-  const requestContextStore = getRequestContextStore();
-  const bucket = requestContextStore.get(target);
-  return _optionalChain([bucket, 'optionalAccess', _ => _.privateData, 'access', _2 => _2.get, 'call', _3 => _3(key)]);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, getRequestContext, "getRequestContext");
-function hasRequestContext(target, key) {
-  const requestContextStore = getRequestContextStore();
-  const bucket = requestContextStore.get(target);
-  return _nullishCoalesce(_optionalChain([bucket, 'optionalAccess', _4 => _4.privateData, 'access', _5 => _5.has, 'call', _6 => _6(key)]), () => ( false));
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, hasRequestContext, "hasRequestContext");
-function deleteRequestContext(target, key) {
-  const requestContextStore = getRequestContextStore();
-  const bucket = requestContextStore.get(target);
-  if (!bucket) return false;
-  const removedPrivate = bucket.privateData.delete(key);
-  bucket.exposedData.delete(key);
-  return removedPrivate;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, deleteRequestContext, "deleteRequestContext");
-function clearRequestContext(target) {
-  const requestContextStore = getRequestContextStore();
-  const bucket = requestContextStore.get(target);
-  if (!bucket) return;
-  bucket.privateData.clear();
-  bucket.exposedData.clear();
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, clearRequestContext, "clearRequestContext");
-function getRequestContextSnapshot(target, options = {}) {
-  const requestContextStore = getRequestContextStore();
-  const bucket = requestContextStore.get(target);
-  if (!bucket) return /* @__PURE__ */ new Map();
-  if (options.exposedOnly) {
-    return new Map(bucket.exposedData);
-  }
-  return new Map(bucket.privateData);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, getRequestContextSnapshot, "getRequestContextSnapshot");
-function copyRequestContext(source, target) {
-  const bucket = getRequestContextStore().get(source);
-  if (!bucket || source === target) return;
-  for (const [key, value] of bucket.privateData) {
-    setRequestContext(target, key, value, { exposeToPage: bucket.exposedData.has(key) });
-  }
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, copyRequestContext, "copyRequestContext");
-
-
-
-
-
-
-
-
-
-exports.setRequestContext = setRequestContext; exports.getRequestContext = getRequestContext; exports.hasRequestContext = hasRequestContext; exports.deleteRequestContext = deleteRequestContext; exports.clearRequestContext = clearRequestContext; exports.getRequestContextSnapshot = getRequestContextSnapshot; exports.copyRequestContext = copyRequestContext;

package/dist/chunk-4U5XZDLG.cjs

@@ -1,80 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
-
-var _chunk6D24SDKOcjs = require('./chunk-6D24SDKO.cjs');
-
-
-var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
-
-// src/schema-extend.ts
-function collectSchemaExtensions(owner, schema, models) {
-  if (!schema.extend) return [];
-  const resolved = _chunk6D24SDKOcjs.resolveSchemaModels.call(void 0, owner, schema);
-  const extensions = [];
-  for (const [modelKey, extension] of Object.entries(schema.extend)) {
-    const model = resolved[modelKey];
-    if (!model || !model.external && (!models || models.includes(modelKey))) continue;
-    const fields = Object.keys(_nullishCoalesce(extension.fields, () => ( {}))).map((fieldKey) => {
-      const field = model.fields[fieldKey];
-      assertAddableColumn(owner, modelKey, fieldKey, field);
-      return { fieldKey, field };
-    });
-    if (fields.length > 0) {
-      extensions.push({ owner, modelKey, table: model.name, fields });
-    }
-  }
-  return extensions;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, collectSchemaExtensions, "collectSchemaExtensions");
-function assertAddableColumn(owner, modelKey, fieldKey, field) {
-  const where = `${owner} adds "${modelKey}.${fieldKey}" to a table it does not own`;
-  if (field.primaryKey || field.unique || field.index || field.list) {
-    const what = field.primaryKey ? "a primary key" : field.unique ? "unique" : field.index ? "indexed" : "a list";
-    throw new Error(`${where}, which cannot be ${what}. Remove it from the extension.`);
-  }
-  if (field.nullable !== true && field.required !== false && field.default === void 0) {
-    throw new Error(
-      `${where}. The table may already have rows, so the column needs a \`default\` or \`nullable: true\`.`
-    );
-  }
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, assertAddableColumn, "assertAddableColumn");
-function isSchemaExtensionAllowed(allowExtend, extension) {
-  if (!allowExtend || !Object.prototype.hasOwnProperty.call(allowExtend, extension.owner)) {
-    return false;
-  }
-  const allowed = _nullishCoalesce(allowExtend[extension.owner], () => ( []));
-  return allowed.includes(extension.modelKey) || allowed.includes(extension.table);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, isSchemaExtensionAllowed, "isSchemaExtensionAllowed");
-function describeSchemaExtensionApproval(extension) {
-  return `schema: { allowExtend: { ${JSON.stringify(extension.owner)}: [${JSON.stringify(extension.modelKey)}] } }`;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, describeSchemaExtensionApproval, "describeSchemaExtensionApproval");
-
-// src/schema-owner.ts
-var FARM_SCHEMA_TABLES = /* @__PURE__ */ Symbol.for("farm.schema-tables");
-function declareSchemaTables(target, declaration) {
-  Object.defineProperty(target, FARM_SCHEMA_TABLES, {
-    value: declaration,
-    enumerable: false,
-    configurable: true
-  });
-  return target;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, declareSchemaTables, "declareSchemaTables");
-function readSchemaTables(candidate) {
-  if (!candidate || typeof candidate !== "object" && typeof candidate !== "function") {
-    return void 0;
-  }
-  return candidate[FARM_SCHEMA_TABLES];
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, readSchemaTables, "readSchemaTables");
-
-
-
-
-
-
-
-
-exports.collectSchemaExtensions = collectSchemaExtensions; exports.isSchemaExtensionAllowed = isSchemaExtensionAllowed; exports.describeSchemaExtensionApproval = describeSchemaExtensionApproval; exports.FARM_SCHEMA_TABLES = FARM_SCHEMA_TABLES; exports.declareSchemaTables = declareSchemaTables; exports.readSchemaTables = readSchemaTables;