@farm.js/core 0.1.61 → 0.1.62

package/dist/chunk-F3N52U7S.mjs

@@ -0,0 +1,138 @@
+// src/schema-primary-key.ts
+var SUPPORTED_PRIMARY_KEY_TYPES = /* @__PURE__ */ new Set(["id", "uuid", "string", "integer"]);
+function assertSupportedPrimaryKeyField(location, field) {
+  if (!field.primaryKey || SUPPORTED_PRIMARY_KEY_TYPES.has(field.type)) {
+    return;
+  }
+  throw new Error(
+    `Schema primary-key field "${location}" uses unsupported type "${field.type}". Supported types are id, uuid, string, and integer.`
+  );
+}
+
+// src/schema-resolve.ts
+function resolveSchemaModels(ownerKey, schema) {
+  const models = Object.fromEntries(
+    Object.entries(schema.models).map(([modelKey, model]) => [modelKey, cloneSchemaModel(model)])
+  );
+  for (const [modelKey, extension] of Object.entries(schema.extend || {})) {
+    const existing = models[modelKey];
+    models[modelKey] = {
+      ...existing || { fields: {} },
+      ...extension.name ? { name: extension.name } : {},
+      ...extension.description ? { description: extension.description } : {},
+      fields: {
+        ...existing?.fields,
+        ...extension.fields
+      },
+      constraints: [...existing?.constraints || [], ...extension.constraints || []],
+      meta: {
+        ...existing?.meta,
+        ...extension.meta
+      }
+    };
+  }
+  for (const [modelKey, override] of Object.entries(schema.override || {})) {
+    const existing = models[modelKey];
+    if (!existing) {
+      throw new Error(
+        `Schema override for "${ownerKey}.${modelKey}" is invalid because that model does not exist.`
+      );
+    }
+    const fields = {
+      ...existing.fields
+    };
+    for (const [fieldKey, fieldOverride] of Object.entries(override.fields || {})) {
+      const existingField = fields[fieldKey];
+      if (!existingField && !fieldOverride.type) {
+        throw new Error(
+          `Schema override for "${ownerKey}.${modelKey}.${fieldKey}" is missing a field type.`
+        );
+      }
+      fields[fieldKey] = {
+        ...existingField,
+        ...fieldOverride
+      };
+    }
+    models[modelKey] = {
+      ...existing,
+      ...override.name ? { name: override.name } : {},
+      ...override.description ? { description: override.description } : {},
+      fields,
+      constraints: override.constraints || existing.constraints,
+      meta: {
+        ...existing.meta,
+        ...override.meta
+      }
+    };
+  }
+  const resolvedModels = {};
+  for (const [modelKey, model] of Object.entries(models)) {
+    const modelName = model.name || modelKey;
+    const fieldNames = /* @__PURE__ */ new Set();
+    const resolvedFields = {};
+    for (const [fieldKey, field] of Object.entries(model.fields)) {
+      const fieldName = field.name || fieldKey;
+      assertSupportedPrimaryKeyField(`${ownerKey}.${modelKey}.${fieldKey}`, field);
+      if (fieldNames.has(fieldName)) {
+        throw new Error(
+          `Schema model "${ownerKey}.${modelKey}" contains duplicate field name "${fieldName}".`
+        );
+      }
+      fieldNames.add(fieldName);
+      resolvedFields[fieldKey] = {
+        ...field,
+        name: fieldName
+      };
+    }
+    const primaryKeyFields = Object.entries(resolvedFields).filter(([, field]) => field.primaryKey).map(([fieldKey]) => fieldKey);
+    if (primaryKeyFields.length > 1) {
+      throw new Error(
+        `Schema model "${ownerKey}.${modelKey}" defines multiple primary-key fields: ${primaryKeyFields.map((fieldKey) => `"${fieldKey}"`).join(", ")}. Composite primary keys are not supported.`
+      );
+    }
+    for (const constraint of model.constraints || []) {
+      for (const fieldKey of constraint.fields) {
+        if (!Object.prototype.hasOwnProperty.call(resolvedFields, fieldKey)) {
+          throw new Error(
+            `Schema ${constraint.type} constraint on "${ownerKey}.${modelKey}" references missing field "${fieldKey}".`
+          );
+        }
+      }
+    }
+    resolvedModels[modelKey] = {
+      ...model,
+      name: modelName,
+      fields: resolvedFields
+    };
+  }
+  for (const [modelKey, model] of Object.entries(resolvedModels)) {
+    for (const [fieldKey, field] of Object.entries(model.fields)) {
+      const reference = field.reference;
+      if (!reference || !Object.prototype.hasOwnProperty.call(resolvedModels, reference.model)) {
+        continue;
+      }
+      const referencedModel = resolvedModels[reference.model];
+      if (!Object.prototype.hasOwnProperty.call(referencedModel.fields, reference.field)) {
+        throw new Error(
+          `Schema reference "${ownerKey}.${modelKey}.${fieldKey}" targets missing field "${ownerKey}.${reference.model}.${reference.field}".`
+        );
+      }
+    }
+  }
+  return resolvedModels;
+}
+function cloneSchemaModel(model) {
+  return {
+    ...model,
+    fields: Object.fromEntries(
+      Object.entries(model.fields).map(([fieldKey, field]) => [fieldKey, { ...field }])
+    ),
+    constraints: model.constraints ? [...model.constraints] : void 0,
+    meta: model.meta ? { ...model.meta } : void 0
+  };
+}
+
+export {
+  assertSupportedPrimaryKeyField,
+  resolveSchemaModels
+};

package/dist/chunk-FBEBSAVI.cjs

@@ -0,0 +1,225 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkHXNLKCWHcjs = require('./chunk-HXNLKCWH.cjs');
+
+
+
+
+
+var _chunk6XQSPIN6cjs = require('./chunk-6XQSPIN6.cjs');
+
+
+var _chunk7JUIK547cjs = require('./chunk-7JUIK547.cjs');
+
+
+var _chunkHNAISJFDcjs = require('./chunk-HNAISJFD.cjs');
+
+// src/plugins/redirects.ts
+function createRedirectsPlugin(redirects, {
+  beforeRequest: overrideBeforeRequest,
+  afterResponse: overrideAfterResponse,
+  i18n
+} = {}) {
+  for (const redirect of redirects) {
+    if (redirect.statusCode !== void 0 && !_chunk7JUIK547cjs.isFarmRedirectStatus.call(void 0, redirect.statusCode)) {
+      throw new RangeError(
+        `Redirect "${redirect.source}" statusCode must be one of 301, 302, 303, 307, or 308.`
+      );
+    }
+  }
+  const compiledRedirects = redirects.map((redirect) => ({
+    redirect,
+    pattern: _chunk6XQSPIN6cjs.compileConfigRoutePattern.call(void 0, redirect.source)
+  }));
+  return {
+    name: "farm:redirects",
+    enforce: "pre",
+    async beforeRequest(req, res, context) {
+      if (overrideBeforeRequest) {
+        await overrideBeforeRequest(req, res, context);
+      }
+      const url = _chunkHNAISJFDcjs.resolveFarmRequestURL.call(void 0, req);
+      const routePath = _chunk6XQSPIN6cjs.resolveConfigRoutePathname.call(void 0, url.pathname, i18n);
+      const pathname = routePath.pathname;
+      for (const { redirect, pattern } of compiledRedirects) {
+        const match = pathname.match(pattern.regex);
+        if (match) {
+          const localizedDestination = _chunk6XQSPIN6cjs.localizeConfigRouteDestination.call(void 0, 
+            _chunk6XQSPIN6cjs.interpolateConfigRouteDestination.call(void 0, redirect.destination, match, pattern.tokens),
+            routePath.locale,
+            i18n
+          );
+          const destination = _chunkHXNLKCWHcjs.appendFarmRedirectQuery.call(void 0, localizedDestination, url.search);
+          const statusCode = _nullishCoalesce(redirect.statusCode, () => ( (redirect.permanent ? 308 : 307)));
+          res.writeHead(statusCode, {
+            Location: destination
+          });
+          res.end();
+          return;
+        }
+      }
+    },
+    async afterResponse(req, res, context) {
+      if (overrideAfterResponse) {
+        await overrideAfterResponse(req, res, context);
+      }
+    }
+  };
+}
+
+// src/plugins/headers.ts
+var FARM_CONFIG_HEADERS_FINALIZER = /* @__PURE__ */ Symbol.for("farm.configHeadersFinalizer");
+function appendConfiguredLinkHeader(res, value) {
+  const current = res.getHeader("Link");
+  if (current === void 0) {
+    res.setHeader("Link", value);
+    return;
+  }
+  const currentValue = Array.isArray(current) ? current.join(", ") : String(current);
+  if (currentValue !== value && !currentValue.endsWith(`, ${value}`)) {
+    res.setHeader("Link", `${currentValue}, ${value}`);
+  }
+}
+function appendConfiguredSetCookieHeader(res, value) {
+  const current = res.getHeader("Set-Cookie");
+  if (current === void 0) {
+    res.setHeader("Set-Cookie", value);
+    return;
+  }
+  const values = (Array.isArray(current) ? current : [current]).map(String);
+  if (!values.includes(value)) {
+    res.setHeader("Set-Cookie", [...values, value]);
+  }
+}
+function applyResponseHeaders(res, matchedHeaders) {
+  for (const headers of matchedHeaders) {
+    for (const header of headers) {
+      const key = header.key.toLowerCase();
+      if (key === "link") {
+        appendConfiguredLinkHeader(res, header.value);
+      } else if (key === "set-cookie") {
+        appendConfiguredSetCookieHeader(res, header.value);
+      } else {
+        res.setHeader(header.key, header.value);
+      }
+    }
+  }
+}
+function applyWriteHeadHeaders(res, headers) {
+  if (Array.isArray(headers)) {
+    let setCookieWritten = false;
+    for (let index = 0; index + 1 < headers.length; index += 2) {
+      const key = String(headers[index]);
+      const value = headers[index + 1];
+      if (key.toLowerCase() === "set-cookie" && setCookieWritten) {
+        const current = res.getHeader("Set-Cookie");
+        const values = (Array.isArray(current) ? current : [current]).filter(
+          (entry) => entry !== void 0
+        );
+        res.setHeader("Set-Cookie", [...values, ...Array.isArray(value) ? value : [value]]);
+      } else {
+        res.setHeader(key, value);
+        if (key.toLowerCase() === "set-cookie") setCookieWritten = true;
+      }
+    }
+    return;
+  }
+  if (!headers || typeof headers !== "object") return;
+  for (const [key, value] of Object.entries(headers)) {
+    if (value !== void 0) res.setHeader(key, value);
+  }
+}
+function createHeadersPlugin(headers, {
+  beforeRequest: overrideBeforeRequest,
+  afterResponse: overrideAfterResponse,
+  i18n
+} = {}) {
+  const compiledHeaders = headers.map((config) => ({
+    config,
+    pattern: _chunk6XQSPIN6cjs.compileConfigRoutePattern.call(void 0, config.source)
+  }));
+  return {
+    name: "farm:headers",
+    enforce: "pre",
+    async beforeRequest(req, res, context) {
+      if (overrideBeforeRequest) {
+        await overrideBeforeRequest(req, res, context);
+      }
+      const url = _chunkHNAISJFDcjs.resolveFarmRequestURL.call(void 0, req);
+      const pathname = _chunk6XQSPIN6cjs.resolveConfigRoutePathname.call(void 0, url.pathname, i18n).pathname;
+      const matchedHeaders = compiledHeaders.filter(({ pattern }) => pattern.regex.test(pathname)).map(({ config }) => config.headers);
+      applyResponseHeaders(res, matchedHeaders);
+      const responseWithFinalizer = res;
+      if (matchedHeaders.length === 0 || responseWithFinalizer[FARM_CONFIG_HEADERS_FINALIZER]) {
+        return;
+      }
+      responseWithFinalizer[FARM_CONFIG_HEADERS_FINALIZER] = true;
+      const writeHead = res.writeHead;
+      res.writeHead = ((statusCode, ...args) => {
+        const statusMessage = typeof args[0] === "string" ? args.shift() : void 0;
+        applyWriteHeadHeaders(res, args[0]);
+        applyResponseHeaders(res, matchedHeaders);
+        return statusMessage === void 0 ? writeHead.call(res, statusCode) : writeHead.call(res, statusCode, statusMessage);
+      });
+    },
+    async afterResponse(req, res, context) {
+      if (overrideAfterResponse) {
+        await overrideAfterResponse(req, res, context);
+      }
+    }
+  };
+}
+
+// src/plugins/env.ts
+function createEnvPlugin(env, {
+  beforeRequest: overrideBeforeRequest,
+  afterResponse: overrideAfterResponse
+} = {}) {
+  return {
+    name: "farm:env",
+    configResolved(config, context) {
+      for (const [key, value] of Object.entries(env)) {
+        process.env[key] = value;
+      }
+    },
+    async beforeRequest(req, res, context) {
+      if (overrideBeforeRequest) {
+        await overrideBeforeRequest(req, res, context);
+      }
+    },
+    async afterResponse(req, res, context) {
+      if (overrideAfterResponse) {
+        await overrideAfterResponse(req, res, context);
+      }
+    }
+  };
+}
+
+// src/plugins/logger.ts
+function createLoggerPlugin({
+  beforeRequest,
+  afterResponse
+} = {}) {
+  const plugin = {
+    name: "farm:logger",
+    enforce: "post"
+  };
+  if (beforeRequest) {
+    plugin.beforeRequest = async (req, res, context) => {
+      await beforeRequest(req, res, context);
+    };
+  }
+  if (afterResponse) {
+    plugin.afterResponse = async (req, res, context) => {
+      await afterResponse(req, res, context);
+    };
+  }
+  return plugin;
+}
+
+
+
+
+
+
+exports.createRedirectsPlugin = createRedirectsPlugin; exports.createHeadersPlugin = createHeadersPlugin; exports.createEnvPlugin = createEnvPlugin; exports.createLoggerPlugin = createLoggerPlugin;

package/dist/chunk-FEFCISOX.cjs

@@ -0,0 +1,102 @@
+"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/request-origin.ts
+function getRequestSourceOrigin(request) {
+  const origin = _optionalChain([request, 'access', _ => _.headers, 'access', _2 => _2.get, 'call', _3 => _3("origin"), 'optionalAccess', _4 => _4.trim, 'call', _5 => _5()]);
+  if (origin) {
+    return parseSourceOrigin(origin);
+  }
+  const referer = _optionalChain([request, 'access', _6 => _6.headers, 'access', _7 => _7.get, 'call', _8 => _8("referer"), 'optionalAccess', _9 => _9.trim, 'call', _10 => _10()]);
+  if (referer) {
+    return parseSourceOrigin(referer);
+  }
+  return { ok: true, origin: null };
+}
+function parseSourceOrigin(value) {
+  if (value === "null") {
+    return { ok: false, reason: "opaque-origin" };
+  }
+  try {
+    const parsed = new URL(value);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      return { ok: false, reason: "invalid-origin" };
+    }
+    return { ok: true, origin: parsed.origin };
+  } catch (e) {
+    return { ok: false, reason: "invalid-origin" };
+  }
+}
+function matchesHostHeader(sourceOrigin, request) {
+  const host = _optionalChain([request, 'access', _11 => _11.headers, 'access', _12 => _12.get, 'call', _13 => _13("host"), 'optionalAccess', _14 => _14.trim, 'call', _15 => _15(), 'access', _16 => _16.toLowerCase, 'call', _17 => _17()]);
+  if (!host) return false;
+  try {
+    const source = new URL(sourceOrigin);
+    const target = new URL(request.url);
+    return source.protocol === target.protocol && source.host.toLowerCase() === host;
+  } catch (e2) {
+    return false;
+  }
+}
+function matchesAllowedOrigin(sourceOrigin, pattern) {
+  const source = new URL(sourceOrigin);
+  if (!pattern.includes("*")) {
+    return pattern.includes("://") ? source.origin === pattern : source.host === pattern;
+  }
+  const schemeEnd = pattern.indexOf("://");
+  const scheme = schemeEnd === -1 ? null : pattern.slice(0, schemeEnd + 1);
+  const hostPattern = pattern.slice(schemeEnd === -1 ? 0 : schemeEnd + 3);
+  const [wildcardHost, port] = splitHostAndPort(hostPattern);
+  const baseHost = wildcardHost.slice(2);
+  if (scheme && source.protocol !== scheme) return false;
+  if (port && getEffectivePort(source) !== port) return false;
+  if (!port && source.port) return false;
+  return source.hostname.endsWith(`.${baseHost}`) && source.hostname !== baseHost;
+}
+function normalizeAllowedOriginPattern(value, label) {
+  const pattern = value.trim().toLowerCase();
+  if (!pattern) {
+    throw new TypeError(`${label} cannot contain empty values`);
+  }
+  if (pattern.includes("*")) {
+    if (!/^(?:https?:\/\/)?\*\.[a-z0-9.-]+(?::\d+)?$/.test(pattern)) {
+      throw new TypeError(`Invalid ${label} pattern: ${JSON.stringify(value)}`);
+    }
+    return pattern;
+  }
+  if (pattern.includes("://")) {
+    let parsed;
+    try {
+      parsed = new URL(pattern);
+    } catch (e3) {
+      throw new TypeError(`Invalid ${label} value: ${JSON.stringify(value)}`);
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:" || parsed.username || parsed.password || parsed.pathname !== "/" || parsed.search || parsed.hash) {
+      throw new TypeError(`${label} must contain origins without paths: ${JSON.stringify(value)}`);
+    }
+    return parsed.origin;
+  }
+  if (/[/@?#]/.test(pattern)) {
+    throw new TypeError(`${label} must contain origins or hosts: ${JSON.stringify(value)}`);
+  }
+  try {
+    return new URL(`http://${pattern}`).host;
+  } catch (e4) {
+    throw new TypeError(`Invalid ${label} value: ${JSON.stringify(value)}`);
+  }
+}
+function splitHostAndPort(value) {
+  const separator = value.lastIndexOf(":");
+  if (separator === -1) return [value, null];
+  return [value.slice(0, separator), value.slice(separator + 1)];
+}
+function getEffectivePort(url) {
+  if (url.port) return url.port;
+  if (url.protocol === "https:") return "443";
+  if (url.protocol === "http:") return "80";
+  return "";
+}
+
+
+
+
+
+
+exports.getRequestSourceOrigin = getRequestSourceOrigin; exports.matchesHostHeader = matchesHostHeader; exports.matchesAllowedOrigin = matchesAllowedOrigin; exports.normalizeAllowedOriginPattern = normalizeAllowedOriginPattern;

package/dist/chunk-FHURJABM.mjs

@@ -0,0 +1,45 @@
+// src/client/action-reference.ts
+var ACTION_IDS_KEY = /* @__PURE__ */ Symbol.for("farm.form-actions.ids");
+function getFarmActionId(value) {
+  if (typeof value !== "function") return void 0;
+  const scope = globalThis;
+  return scope[ACTION_IDS_KEY]?.get(value);
+}
+
+// src/client/client-reference.ts
+var CLIENT_REFERENCE = /* @__PURE__ */ Symbol.for("farm.isolated-hydration.client-reference");
+function markFarmClientReference(boundary, reference) {
+  Object.defineProperty(boundary, CLIENT_REFERENCE, { value: reference });
+}
+function getFarmClientReference(type) {
+  if (!type || typeof type !== "function" && typeof type !== "object") return void 0;
+  return type[CLIENT_REFERENCE];
+}
+var SERVER_TREE_UPDATES = /* @__PURE__ */ Symbol.for("farm.isolated-hydration.server-tree-updates");
+function getListeners() {
+  const shared = globalThis;
+  return shared[SERVER_TREE_UPDATES] ?? (shared[SERVER_TREE_UPDATES] = /* @__PURE__ */ new Set());
+}
+function subscribeFarmServerTreeUpdates(listener) {
+  const listeners = getListeners();
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+function updateFarmServerTreeModule(reference, module) {
+  const listeners = globalThis[SERVER_TREE_UPDATES];
+  let updated = 0;
+  if (listeners) {
+    for (const listener of listeners) if (listener(reference, module)) updated++;
+  }
+  return updated;
+}
+
+export {
+  getFarmActionId,
+  markFarmClientReference,
+  getFarmClientReference,
+  subscribeFarmServerTreeUpdates,
+  updateFarmServerTreeModule
+};

package/dist/chunk-FN5UEC7I.mjs

@@ -0,0 +1,55 @@
+import {
+  logger
+} from "./chunk-JSDV2NUN.mjs";
+
+// src/server/dev-loopback.ts
+import net from "net";
+var OTHER_LOOPBACK = { "::1": "127.0.0.1", "127.0.0.1": "::1" };
+function createFarmDevLoopbackPlugin() {
+  return {
+    name: "farm:dev-loopback",
+    configureServer(server) {
+      const listen = server.listen.bind(server);
+      server.listen = async (...args) => {
+        const result = await listen(...args);
+        await listenOnOtherLoopback(server);
+        return result;
+      };
+    }
+  };
+}
+async function listenOnOtherLoopback(server) {
+  const host = server.config.server.host;
+  if (host !== void 0 && host !== false && host !== "localhost") return;
+  const httpServer = server.httpServer;
+  const address = httpServer?.address();
+  if (!httpServer || !address || typeof address !== "object") return;
+  const other = OTHER_LOOPBACK[address.address];
+  if (!other) return;
+  const loopback = net.createServer((socket) => httpServer.emit("connection", socket));
+  const listening = await new Promise((resolve) => {
+    const onError = (error) => {
+      if (error.code === "EADDRINUSE") {
+        logger.warn(
+          `Another process is listening on ${formatHost(other)}:${address.port}; the dev server answers on ${formatHost(address.address)}:${address.port} only.`
+        );
+      }
+      resolve(false);
+    };
+    loopback.once("error", onError);
+    loopback.listen({ port: address.port, host: other, ipv6Only: other === "::1" }, () => {
+      loopback.off("error", onError);
+      resolve(true);
+    });
+  });
+  if (!listening) return;
+  loopback.on("error", (error) => logger.warn(`Dev loopback listener failed: ${String(error)}`));
+  httpServer.once("close", () => loopback.close());
+}
+function formatHost(address) {
+  return address.includes(":") ? `[${address}]` : address;
+}
+
+export {
+  createFarmDevLoopbackPlugin
+};

package/dist/chunk-FSXSQQTV.mjs

@@ -0,0 +1,79 @@
+import {
+  PROGRAMMATIC_ROUTE_FILE_NAMES,
+  scanProgrammaticPagePaths
+} from "./chunk-6YFC3ZFX.mjs";
+
+// src/routes.server.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+async function loadProgrammaticRouteManifests(options) {
+  const manifests = [];
+  const routeFiles = findProgrammaticRouteFiles(options.root, options.srcDir);
+  if (routeFiles.length === 0) return manifests;
+  const { getProgrammaticRouteManifest } = await import("./routes.mjs");
+  for (const filePath of routeFiles) {
+    const mod = await options.loadModule(filePath);
+    const manifest = getProgrammaticRouteManifest(mod);
+    if (manifest) {
+      manifests.push({ filePath, manifest });
+    }
+  }
+  return manifests;
+}
+function findProgrammaticRouteFiles(root, srcDir = "src") {
+  return findProgrammaticRouteFilesInDir(join(root, srcDir));
+}
+function findProgrammaticRouteFilesInDir(srcRoot) {
+  const files = [];
+  for (const fileName of PROGRAMMATIC_ROUTE_FILE_NAMES) {
+    const filePath = join(srcRoot, fileName);
+    if (existsSync(filePath)) {
+      files.push(filePath);
+    }
+  }
+  return files;
+}
+async function discoverProgrammaticRoutePaths(root, srcDir = "src") {
+  const paths = /* @__PURE__ */ new Set();
+  const files = /* @__PURE__ */ new Set([
+    ...findProgrammaticRouteFiles(root, srcDir),
+    ...await findProgrammaticRouteSourceFiles(join(root, srcDir))
+  ]);
+  for (const filePath of files) {
+    const source = readFileSync(filePath, "utf8");
+    for (const routePath of scanProgrammaticPagePaths(source)) {
+      paths.add(routePath);
+    }
+  }
+  return Array.from(paths).sort();
+}
+async function findProgrammaticRouteSourceFiles(srcRoot) {
+  if (!existsSync(srcRoot)) {
+    return [];
+  }
+  try {
+    const { glob } = await import("tinyglobby");
+    return await glob("**/*.{ts,tsx,js,jsx}", {
+      cwd: srcRoot,
+      absolute: true,
+      expandDirectories: false,
+      ignore: [
+        "**/*.d.ts",
+        "**/node_modules/**",
+        "**/.*/**",
+        "farm-routes.d.ts",
+        "farm-env.d.ts",
+        "lib/api.generated.ts"
+      ]
+    });
+  } catch {
+    return [];
+  }
+}
+
+export {
+  loadProgrammaticRouteManifests,
+  findProgrammaticRouteFiles,
+  findProgrammaticRouteFilesInDir,
+  discoverProgrammaticRoutePaths
+};