@farm.js/core 0.1.46 → 0.1.48

package/dist/chunk-C7425KDG.cjs

@@ -0,0 +1,406 @@
+"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 _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 _chunk2KMIJDY6cjs = require('./chunk-2KMIJDY6.cjs');
+
+
+var _chunkSHIWRBFIcjs = require('./chunk-SHIWRBFI.cjs');
+
+
+var _chunkXN2MB4QZcjs = require('./chunk-XN2MB4QZ.cjs');
+
+// src/cron.ts
+var DEFAULT_FARM_CRON_SECRET_ENV = "CRON_SECRET";
+var FARM_CRON_MANIFEST = "cron-manifest.json";
+var CRON_FIELD_RANGES = [
+  [0, 59, "minute"],
+  [0, 23, "hour"],
+  [1, 31, "day of month"],
+  [1, 12, "month"],
+  [0, 6, "day of week"]
+];
+function resolveCronConfig(cron) {
+  if (isResolvedCronConfig(cron)) return cron;
+  if (!cron) {
+    return {
+      enabled: false,
+      secretEnv: DEFAULT_FARM_CRON_SECRET_ENV,
+      jobs: []
+    };
+  }
+  const jobs = [];
+  for (const [name, job] of Object.entries(cron)) {
+    if (!job || typeof job !== "object" || Array.isArray(job)) {
+      throw new TypeError(`Farm cron ${JSON.stringify(name)} must be a configuration object.`);
+    }
+    if (job.enabled === false) continue;
+    jobs.push(normalizeCronJob(name, job));
+  }
+  return {
+    enabled: jobs.length > 0,
+    secretEnv: DEFAULT_FARM_CRON_SECRET_ENV,
+    jobs
+  };
+}
+async function prepareFarmCronForNitro(config) {
+  const cron = isResolvedCronConfig(config.cron) ? config.cron : resolveCronConfig(config.cron);
+  const root = config.root || process.cwd();
+  const distDir = config.distDir || ".farm";
+  const fs = await import("fs/promises");
+  const path = await import("path");
+  const manifestPath = path.join(root, distDir, FARM_CRON_MANIFEST);
+  const generatedDir = path.join(root, distDir, ".nitro", "farm-cron");
+  if (!cron.enabled) {
+    await Promise.all([
+      fs.rm(manifestPath, { force: true }),
+      fs.rm(generatedDir, { recursive: true, force: true })
+    ]);
+    return {
+      jobs: [],
+      tasks: {},
+      scheduledTasks: {}
+    };
+  }
+  await fs.rm(generatedDir, { recursive: true, force: true });
+  await fs.mkdir(generatedDir, { recursive: true });
+  const tasks = {};
+  const wrapperNames = resolveCronWrapperFileNames(cron.jobs.map((job) => job.name));
+  for (const job of cron.jobs) {
+    const taskName = getFarmCronTaskName(job.name);
+    const wrapperPath = _chunkXN2MB4QZcjs.toPosixPath.call(void 0, path.join(generatedDir, `${wrapperNames.get(job.name)}.mjs`));
+    await fs.writeFile(wrapperPath, createNitroCronTaskWrapper(job, cron.secretEnv), "utf8");
+    tasks[taskName] = {
+      handler: wrapperPath,
+      description: job.description || `Farm cron ${job.name}`
+    };
+  }
+  const manifest = createFarmCronManifest(cron);
+  await fs.mkdir(path.dirname(manifestPath), { recursive: true });
+  await fs.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+  return {
+    jobs: cron.jobs,
+    tasks,
+    scheduledTasks: createCronScheduledTasks(cron.jobs),
+    manifestPath
+  };
+}
+function createFarmCronManifest(cron) {
+  return {
+    schemaVersion: 1,
+    secretEnv: cron.secretEnv,
+    jobs: cron.jobs.map((job) => ({
+      name: job.name,
+      schedule: job.schedule,
+      path: job.path,
+      description: job.description || null
+    }))
+  };
+}
+function createFarmCronVercelCrons(jobs) {
+  return jobs.flatMap(
+    (job) => job.schedule.map((schedule) => ({
+      path: job.path,
+      schedule
+    }))
+  );
+}
+function applyFarmCronVercelCrons(vercelConfig, jobs) {
+  const existingCrons = Array.isArray(vercelConfig.crons) ? vercelConfig.crons : [];
+  const seen = new Set(existingCrons.map((cron) => `${cron.path}:${cron.schedule}`));
+  const crons = [...existingCrons];
+  for (const cron of createFarmCronVercelCrons(jobs)) {
+    const key = `${cron.path}:${cron.schedule}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    crons.push(cron);
+  }
+  return crons.length > 0 ? { ...vercelConfig, crons } : vercelConfig;
+}
+function createFarmCronCloudflareTriggers(jobs) {
+  return [...new Set(jobs.flatMap((job) => job.schedule))];
+}
+function createFarmCronCloudflareConfig(jobs) {
+  const crons = createFarmCronCloudflareTriggers(jobs);
+  if (crons.length === 0) return void 0;
+  return {
+    deployConfig: true,
+    wrangler: {
+      triggers: { crons }
+    }
+  };
+}
+function mergeScheduledTasks(...maps) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const map of maps) {
+    for (const [schedule, taskNames] of Object.entries(map || {})) {
+      const current = merged.get(schedule) || [];
+      for (const taskName of Array.isArray(taskNames) ? taskNames : [taskNames]) {
+        if (!current.includes(taskName)) current.push(taskName);
+      }
+      merged.set(schedule, current);
+    }
+  }
+  return Object.fromEntries(
+    [...merged].map(([schedule, taskNames]) => [
+      schedule,
+      taskNames.length === 1 ? taskNames[0] : taskNames
+    ])
+  );
+}
+function isExplicitDevelopmentEnv() {
+  const nodeEnv = _chunk2KMIJDY6cjs.readFarmEnvironmentValue.call(void 0, "NODE_ENV");
+  return nodeEnv === "development" || nodeEnv === "test";
+}
+function isCronRequestAuthorized(request, options = {}) {
+  const secretEnv = options.secretEnv || DEFAULT_FARM_CRON_SECRET_ENV;
+  const secret = options.secret || _chunk2KMIJDY6cjs.readFarmEnvironmentValue.call(void 0, secretEnv);
+  if (!secret) {
+    return options.allowUnsecured === true || !_chunk2KMIJDY6cjs.getFarmRuntimeBindings.call(void 0, ) && isExplicitDevelopmentEnv();
+  }
+  const authorization = request.headers.get("authorization") || "";
+  const bearer = _optionalChain([/^Bearer (.*)$/i, 'access', _ => _.exec, 'call', _2 => _2(authorization), 'optionalAccess', _3 => _3[1]]) || "";
+  const headerSecret = request.headers.get("x-farm-cron-secret") || "";
+  return _chunkSHIWRBFIcjs.farmSecretsMatch.call(void 0, bearer, secret) || _chunkSHIWRBFIcjs.farmSecretsMatch.call(void 0, headerSecret, secret);
+}
+function cronRoute(handler, options = {}) {
+  return (request, ...args) => {
+    if (!isCronRequestAuthorized(request, options)) {
+      return Promise.resolve(
+        Response.json({ error: "Unauthorized cron request." }, { status: 401 })
+      );
+    }
+    return handler(request, ...args);
+  };
+}
+function normalizeCronJob(name, job) {
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(name)) {
+    throw new TypeError(
+      `Farm cron name ${JSON.stringify(name)} must start with a letter or number and contain only letters, numbers, dots, underscores, or hyphens.`
+    );
+  }
+  if (!job || typeof job !== "object" || Array.isArray(job)) {
+    throw new TypeError(`Farm cron ${JSON.stringify(name)} must be a configuration object.`);
+  }
+  const path = normalizeCronPath(name, job.path);
+  const rawSchedule = Array.isArray(job.schedule) ? job.schedule : [job.schedule];
+  const schedule = [...new Set(rawSchedule.map((value) => normalizeCronExpression(name, value)))];
+  if (schedule.length === 0) {
+    throw new TypeError(`Farm cron ${JSON.stringify(name)} must define at least one schedule.`);
+  }
+  return {
+    name,
+    schedule,
+    path,
+    description: _optionalChain([job, 'access', _4 => _4.description, 'optionalAccess', _5 => _5.trim, 'call', _6 => _6()]) || void 0
+  };
+}
+function normalizeCronPath(name, value) {
+  if (typeof value !== "string" || !value.trim().startsWith("/")) {
+    throw new TypeError(`Farm cron ${JSON.stringify(name)} path must start with "/".`);
+  }
+  const hasUnstableCharacters = (candidate) => candidate.includes("\\") || Array.from(candidate).some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code >= 127 && code <= 159;
+  });
+  if (hasUnstableCharacters(value)) {
+    throw new TypeError(
+      `Farm cron ${JSON.stringify(name)} path cannot contain backslashes or control characters.`
+    );
+  }
+  const path = value.trim();
+  if (path.startsWith("//") || path.includes("?") || path.includes("#")) {
+    throw new TypeError(
+      `Farm cron ${JSON.stringify(name)} path must be an application pathname without a host, query, or hash.`
+    );
+  }
+  for (const segment of path.split("/")) {
+    let decoded = segment;
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch (e) {
+    }
+    if (hasUnstableCharacters(decoded)) {
+      throw new TypeError(
+        `Farm cron ${JSON.stringify(name)} path cannot contain backslashes or control characters.`
+      );
+    }
+    if (decoded.includes("/")) {
+      throw new TypeError(
+        `Farm cron ${JSON.stringify(name)} path cannot contain percent-encoded path separators.`
+      );
+    }
+    if (decoded === "." || decoded === "..") {
+      throw new TypeError(
+        `Farm cron ${JSON.stringify(name)} path cannot contain "." or ".." path segments.`
+      );
+    }
+  }
+  return path.length > 1 ? path.replace(/\/+$/, "") : path;
+}
+function normalizeCronExpression(name, value) {
+  if (typeof value !== "string") {
+    throw new TypeError(`Farm cron ${JSON.stringify(name)} schedule must be a string.`);
+  }
+  const expression = value.trim().replace(/\s+/g, " ");
+  const fields = expression.split(" ");
+  if (fields.length !== CRON_FIELD_RANGES.length) {
+    throw new TypeError(
+      `Farm cron ${JSON.stringify(name)} schedule ${JSON.stringify(expression)} must use five fields: minute hour day-of-month month day-of-week.`
+    );
+  }
+  fields.forEach((field, index) => {
+    const [minimum, maximum, label] = CRON_FIELD_RANGES[index];
+    validateCronField(name, expression, field, minimum, maximum, label);
+  });
+  if (fields[2] !== "*" && fields[4] !== "*") {
+    throw new TypeError(
+      `Farm cron ${JSON.stringify(name)} schedule ${JSON.stringify(expression)} cannot constrain both day-of-month and day-of-week.`
+    );
+  }
+  return expression;
+}
+function validateCronField(name, expression, field, minimum, maximum, label) {
+  for (const segment of field.split(",")) {
+    const [range, stepText, ...extra] = segment.split("/");
+    if (!range || extra.length > 0 || stepText !== void 0 && !isIntegerInRange(stepText, 1)) {
+      throwInvalidCronField(name, expression, label);
+    }
+    if (range === "*") continue;
+    const bounds = range.split("-");
+    if (bounds.length > 2 || !bounds.every((value) => isIntegerInRange(value, minimum, maximum))) {
+      throwInvalidCronField(name, expression, label);
+    }
+    if (bounds.length === 2 && Number(bounds[0]) > Number(bounds[1])) {
+      throwInvalidCronField(name, expression, label);
+    }
+  }
+}
+function isIntegerInRange(value, minimum, maximum = Number.MAX_SAFE_INTEGER) {
+  if (!/^\d+$/.test(value)) return false;
+  const parsed = Number(value);
+  return parsed >= minimum && parsed <= maximum;
+}
+function throwInvalidCronField(name, expression, label) {
+  throw new TypeError(
+    `Farm cron ${JSON.stringify(name)} schedule ${JSON.stringify(expression)} has an invalid ${label} field.`
+  );
+}
+function isResolvedCronConfig(value) {
+  return !!value && typeof value === "object" && "enabled" in value && typeof value.enabled === "boolean" && "jobs" in value && Array.isArray(value.jobs) && "secretEnv" in value;
+}
+function createCronScheduledTasks(jobs) {
+  const scheduledTasks = {};
+  for (const job of jobs) {
+    const taskName = getFarmCronTaskName(job.name);
+    for (const schedule of job.schedule) {
+      scheduledTasks[schedule] = mergeTaskNames(scheduledTasks[schedule], taskName);
+    }
+  }
+  return scheduledTasks;
+}
+function mergeTaskNames(current, taskName) {
+  if (!current) return taskName;
+  const names = Array.isArray(current) ? current : [current];
+  return names.includes(taskName) ? names : [...names, taskName];
+}
+function getFarmCronTaskName(name) {
+  return `farm:cron:${name}`;
+}
+function createNitroCronTaskWrapper(job, secretEnv) {
+  return `
+import { useNitroApp } from "nitro/app";
+import { defineTask } from "nitro/task";
+
+const name = ${JSON.stringify(job.name)};
+const path = ${JSON.stringify(job.path)};
+const secretEnv = ${JSON.stringify(secretEnv)};
+
+function readSecret(event) {
+  const runtimeEnv = event?.context?.cloudflare?.env || event?.context?.env || {};
+  return runtimeEnv[secretEnv] || (typeof process !== "undefined" ? process.env?.[secretEnv] : "") || "";
+}
+
+export default defineTask({
+  meta: {
+    name: ${JSON.stringify(getFarmCronTaskName(job.name))},
+    description: ${JSON.stringify(job.description || `Farm cron ${job.name}`)}
+  },
+  async run(event) {
+    const headers = new Headers({
+      "x-farm-cron-name": name,
+      "x-farm-cron-scheduled-at": String(event?.payload?.scheduledTime || Date.now())
+    });
+    const secret = readSecret(event);
+    if (secret) headers.set("authorization", "Bearer " + secret);
+
+    const response = await useNitroApp().fetch(path, { method: "GET", headers });
+    const contentType = response.headers.get("content-type") || "";
+    const body = response.status === 204
+      ? null
+      : contentType.includes("application/json")
+        ? await response.json().catch(() => null)
+        : await response.text();
+
+    if (!response.ok) {
+      const detail = typeof body === "string" ? body : JSON.stringify(body);
+      throw new Error(
+        "Farm cron " + JSON.stringify(name) + " received " + response.status +
+        " from " + path + (detail ? ": " + detail : "")
+      );
+    }
+
+    return { result: body };
+  }
+});
+`.trim();
+}
+function resolveCronWrapperFileNames(names) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const name of names) {
+    const key = safeFileName(name).toLowerCase();
+    groups.set(key, (_nullishCoalesce(groups.get(key), () => ( 0))) + 1);
+  }
+  const resolved = /* @__PURE__ */ new Map();
+  const claimed = /* @__PURE__ */ new Map();
+  for (const name of names) {
+    const base = safeFileName(name);
+    const key = base.toLowerCase();
+    const fileName = (_nullishCoalesce(groups.get(key), () => ( 0))) > 1 ? `${key}-${cronNameFingerprint(name)}` : base;
+    const claimedBy = claimed.get(fileName.toLowerCase());
+    if (claimedBy !== void 0) {
+      throw new Error(
+        `Farm cron jobs ${JSON.stringify(claimedBy)} and ${JSON.stringify(name)} generate the same wrapper file ${JSON.stringify(`${fileName}.mjs`)}. Rename one of them.`
+      );
+    }
+    claimed.set(fileName.toLowerCase(), name);
+    resolved.set(name, fileName);
+  }
+  return resolved;
+}
+function cronNameFingerprint(value) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function safeFileName(value) {
+  return value.replace(/[^a-zA-Z0-9._-]+/g, "-") || "cron";
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.DEFAULT_FARM_CRON_SECRET_ENV = DEFAULT_FARM_CRON_SECRET_ENV; exports.FARM_CRON_MANIFEST = FARM_CRON_MANIFEST; exports.resolveCronConfig = resolveCronConfig; exports.prepareFarmCronForNitro = prepareFarmCronForNitro; exports.createFarmCronManifest = createFarmCronManifest; exports.createFarmCronVercelCrons = createFarmCronVercelCrons; exports.applyFarmCronVercelCrons = applyFarmCronVercelCrons; exports.createFarmCronCloudflareTriggers = createFarmCronCloudflareTriggers; exports.createFarmCronCloudflareConfig = createFarmCronCloudflareConfig; exports.mergeScheduledTasks = mergeScheduledTasks; exports.isCronRequestAuthorized = isCronRequestAuthorized; exports.cronRoute = cronRoute;

package/dist/chunk-C7LCTVJ2.cjs

@@ -0,0 +1,30 @@
+"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 _chunkWEGAVN37cjs = require('./chunk-WEGAVN37.cjs');
+
+
+var _chunkOOZEU5KKcjs = require('./chunk-OOZEU5KK.cjs');
+
+// src/theme/client.tsx
+var _react = require('react');
+function getHydrationSnapshot() {
+  if (typeof window !== "undefined" && _optionalChain([window, 'access', _ => _.__FARM_THEME__, 'optionalAccess', _2 => _2.serverSnapshot])) {
+    return window.__FARM_THEME__.serverSnapshot;
+  }
+  return _chunkOOZEU5KKcjs.getFarmThemeServerSnapshot.call(void 0, );
+}
+function useTheme() {
+  const snapshot = _react.useSyncExternalStore.call(void 0, _chunkWEGAVN37cjs.subscribeTheme, _chunkWEGAVN37cjs.getTheme, getHydrationSnapshot);
+  return {
+    ...snapshot,
+    setTheme: _chunkWEGAVN37cjs.setTheme,
+    toggleTheme: _chunkWEGAVN37cjs.toggleTheme
+  };
+}
+
+
+
+exports.useTheme = useTheme;

package/dist/chunk-CA7DNRHO.cjs

@@ -0,0 +1,164 @@
+"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 _chunkYTVSWXEZcjs = require('./chunk-YTVSWXEZ.cjs');
+
+// src/api/route-pattern.ts
+var compiledEntries = /* @__PURE__ */ new WeakMap();
+function createStaticAPIRouteMatcher(routes) {
+  const table = new Map(routes.map((route) => [route.path, Object.freeze({ ...route })]));
+  const root = { children: /* @__PURE__ */ new Map(), candidates: [] };
+  let order = 0;
+  for (const route of table.values()) {
+    const compiled = compileRouteEntry(route.path);
+    let node = root;
+    for (const segment of compiled.segments) {
+      if (segment.dynamic) break;
+      let child = node.children.get(segment.value);
+      if (!child) {
+        child = { children: /* @__PURE__ */ new Map(), candidates: [] };
+        node.children.set(segment.value, child);
+      }
+      node = child;
+    }
+    node.candidates.push({ route, compiled, order: order++ });
+  }
+  return (pathname) => {
+    const exactRoute = table.get(pathname);
+    if (exactRoute) return { route: exactRoute, params: {} };
+    const normalizedPathname = normalizePathname(pathname);
+    if (normalizedPathname !== pathname) {
+      const normalizedRoute = table.get(normalizedPathname);
+      if (normalizedRoute) return { route: normalizedRoute, params: {} };
+    }
+    const segments = getPathSegments(normalizedPathname).map(decodePathSegment);
+    let best;
+    let bestMatch = null;
+    let node = root;
+    let depth = 0;
+    while (node) {
+      for (const candidate of node.candidates) {
+        const params = matchRouteEntry(candidate.compiled, segments);
+        if (!params) continue;
+        const comparison = best ? _chunkYTVSWXEZcjs.compareRouteSpecificity.call(void 0, candidate.compiled.specificity, best.compiled.specificity) : -1;
+        if (comparison < 0 || comparison === 0 && candidate.order < best.order) {
+          best = candidate;
+          bestMatch = { route: candidate.route, params };
+        }
+      }
+      node = depth < segments.length ? node.children.get(segments[depth++]) : void 0;
+    }
+    return bestMatch;
+  };
+}
+function matchAPIRoute(routes, pathname) {
+  const exactRoute = routes.get(pathname);
+  if (exactRoute) return { route: exactRoute, params: {} };
+  const normalizedPathname = normalizePathname(pathname);
+  if (normalizedPathname !== pathname) {
+    const normalizedRoute = routes.get(normalizedPathname);
+    if (normalizedRoute) return { route: normalizedRoute, params: {} };
+  }
+  const pathnameSegments = getPathSegments(normalizedPathname).map(decodePathSegment);
+  let bestMatch = null;
+  let bestSpecificity = null;
+  for (const route of routes.values()) {
+    const routePath = route.path;
+    let entry = compiledEntries.get(route);
+    if (!entry || entry.path !== routePath) {
+      entry = compileRouteEntry(routePath);
+      compiledEntries.set(route, entry);
+    }
+    const params = matchRouteEntry(entry, pathnameSegments);
+    if (!params) continue;
+    if (bestSpecificity === null || _chunkYTVSWXEZcjs.compareRouteSpecificity.call(void 0, entry.specificity, bestSpecificity) < 0) {
+      bestMatch = { route, params };
+      bestSpecificity = entry.specificity;
+    }
+  }
+  return bestMatch;
+}
+function compileRouteEntry(path) {
+  const segments = getPathSegments(path).map((segment) => {
+    const dynamic = parseDynamicSegment(segment);
+    return dynamic ? { dynamic } : { value: decodePathSegment(segment) };
+  });
+  return {
+    path,
+    segments,
+    specificity: segments.map((segment) => {
+      const dynamic = segment.dynamic;
+      if (!dynamic) return "static";
+      if (!dynamic.catchAll) return "dynamic";
+      return dynamic.optional ? "optional-catch-all" : "catch-all";
+    })
+  };
+}
+function matchRouteEntry(entry, pathnameSegments) {
+  const params = {};
+  let pathIndex = 0;
+  for (const routeSegment of entry.segments) {
+    const dynamicSegment = routeSegment.dynamic;
+    if (_optionalChain([dynamicSegment, 'optionalAccess', _ => _.catchAll])) {
+      const remainingSegments = pathnameSegments.slice(pathIndex);
+      if (remainingSegments.length === 0 && !dynamicSegment.optional) {
+        return null;
+      }
+      if (remainingSegments.length > 0) {
+        params[dynamicSegment.name] = remainingSegments;
+      }
+      pathIndex = pathnameSegments.length;
+      continue;
+    }
+    const pathnameSegment = pathnameSegments[pathIndex];
+    if (pathnameSegment === void 0) {
+      return null;
+    }
+    if (dynamicSegment) {
+      params[dynamicSegment.name] = pathnameSegment;
+      pathIndex++;
+      continue;
+    }
+    if (routeSegment.value !== pathnameSegment) {
+      return null;
+    }
+    pathIndex++;
+  }
+  return pathIndex === pathnameSegments.length ? params : null;
+}
+function getPathSegments(pathname) {
+  return normalizePathname(pathname).split("/").filter((segment) => segment.length > 0);
+}
+function normalizePathname(pathname) {
+  if (pathname.length > 1 && pathname.endsWith("/")) {
+    return pathname.replace(/\/+$/, "");
+  }
+  return pathname;
+}
+function parseDynamicSegment(segment) {
+  const optionalCatchAll = segment.match(/^\[\[\.\.\.(.+)\]\]$/);
+  if (_optionalChain([optionalCatchAll, 'optionalAccess', _2 => _2[1]])) {
+    return { name: optionalCatchAll[1], catchAll: true, optional: true };
+  }
+  const catchAll = segment.match(/^\[\.\.\.(.+)\]$/);
+  if (_optionalChain([catchAll, 'optionalAccess', _3 => _3[1]])) {
+    return { name: catchAll[1], catchAll: true, optional: false };
+  }
+  const dynamic = segment.match(/^\[(.+)\]$/);
+  if (_optionalChain([dynamic, 'optionalAccess', _4 => _4[1]])) {
+    return { name: dynamic[1], catchAll: false, optional: false };
+  }
+  return null;
+}
+function decodePathSegment(segment) {
+  try {
+    return decodeURIComponent(segment);
+  } catch (e) {
+    return segment;
+  }
+}
+
+
+
+
+
+exports.createStaticAPIRouteMatcher = createStaticAPIRouteMatcher; exports.matchAPIRoute = matchAPIRoute; exports.parseDynamicSegment = parseDynamicSegment;

package/dist/chunk-CBJKDB6F.mjs

@@ -0,0 +1,80 @@
+import {
+  parseRoutePath
+} from "./chunk-2SVJGOAX.mjs";
+
+// src/routing/route-slots.ts
+var SLOT_SEGMENT = /^@([A-Za-z][A-Za-z0-9_-]*)$/;
+function isRouteSlotSegment(segment) {
+  return SLOT_SEGMENT.test(segment);
+}
+function parseRouteSlotFile(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const parts = normalized.split("/").filter(Boolean);
+  const fileName = parts.at(-1) ?? "";
+  const baseName = fileName.replace(/\.(tsx?|jsx?|vue|svelte)$/, "");
+  if (baseName !== "page" && baseName !== "default") return null;
+  const slotIndex = parts.findIndex((part) => SLOT_SEGMENT.test(part));
+  if (slotIndex < 0) return null;
+  if (parts.slice(slotIndex + 1, -1).some((part) => SLOT_SEGMENT.test(part))) {
+    throw new Error(`Nested route slots are not supported in "${filePath}"`);
+  }
+  const slotMatch = parts[slotIndex].match(SLOT_SEGMENT);
+  const name = slotMatch?.[1];
+  if (!name) return null;
+  const ownerParts = parts.slice(0, slotIndex);
+  const contentParts = parts.slice(slotIndex + 1, -1);
+  const marker = parseInterceptionMarker(contentParts[0]);
+  let targetBase = ownerParts;
+  let targetParts = contentParts;
+  if (marker) {
+    targetBase = marker.root === true ? [] : ownerParts.slice(0, Math.max(0, ownerParts.length - marker.up));
+    targetParts = [...marker.remainder ? [marker.remainder] : [], ...contentParts.slice(1)];
+  }
+  const ownerFile = [...ownerParts, "layout.tsx"].join("/");
+  const routeFile = [
+    ...baseName === "default" ? ownerParts : targetBase,
+    ...baseName === "default" ? [] : targetParts,
+    "page.tsx"
+  ].join("/");
+  return {
+    name,
+    ownerRoute: parseRoutePath(ownerFile || "layout.tsx"),
+    route: parseRoutePath(routeFile || "page.tsx"),
+    interception: marker !== null,
+    fallback: baseName === "default"
+  };
+}
+function createRouteSlotContainerId(name, ownerPattern) {
+  const owner = ownerPattern === "/" ? "root" : ownerPattern.replace(/^\//, "").replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "");
+  return `__farm_slot_${name}_${owner || "root"}__`;
+}
+function parseInterceptionMarker(segment) {
+  if (!segment) return null;
+  if (segment.startsWith("(...)")) {
+    return {
+      up: 0,
+      root: true,
+      remainder: segment.slice(5)
+    };
+  }
+  if (segment.startsWith("(.)")) {
+    return {
+      up: 0,
+      remainder: segment.slice(3)
+    };
+  }
+  let remainder = segment;
+  let up = 0;
+  while (remainder.startsWith("(..)")) {
+    up += 1;
+    remainder = remainder.slice(4);
+  }
+  return up > 0 ? { up, remainder } : null;
+}
+
+export {
+  isRouteSlotSegment,
+  parseRouteSlotFile,
+  createRouteSlotContainerId,
+  parseInterceptionMarker
+};