@farm.js/core 0.1.60 → 0.1.61

package/dist/chunk-TUPKMMXT.mjs

@@ -1,173 +0,0 @@
-import {
-  writeFileIfChanged
-} from "./chunk-Q5B4LNON.mjs";
-
-// src/env-types.ts
-import * as fs from "fs";
-import * as path from "path";
-var DEFAULT_OUT_FILE = "farm-env.d.ts";
-var CONFIG_FILENAMES = [
-  "farm.config.ts",
-  "farm.config.tsx",
-  "farm.config.mts",
-  "farm.config.cts",
-  "farm.config.js",
-  "farm.config.jsx",
-  "farm.config.mjs",
-  "farm.config.cjs",
-  "config.ts",
-  "config.tsx",
-  "config.mts",
-  "config.cts",
-  "config.js",
-  "config.jsx",
-  "config.mjs",
-  "config.cjs"
-];
-async function generateEnvTypes(options) {
-  const root = path.resolve(options.root);
-  const srcDir = options.srcDir || "src";
-  const outFile = options.outFile || DEFAULT_OUT_FILE;
-  const outPath = path.isAbsolute(outFile) ? outFile : path.join(root, srcDir, outFile);
-  const content = createEnvTypeDeclarations(options, outPath);
-  fs.mkdirSync(path.dirname(outPath), { recursive: true });
-  writeFileIfChanged(outPath, content);
-  return outPath;
-}
-function createEnvTypeDeclarations(options, outPath) {
-  const root = path.resolve(options.root);
-  const configPath = findConfigPath(root, options.configPath);
-  const configPaths = [
-    ...(options.layerConfigPaths ?? []).filter((value) => fs.existsSync(value)),
-    ...configPath ? [configPath] : []
-  ];
-  const content = configPaths.length > 1 ? createLayeredConfigBackedEnvTypes(outPath, configPaths) : configPaths.length === 1 ? createConfigBackedEnvTypes(outPath, configPaths[0]) : createEmptyEnvTypes();
-  return content;
-}
-function createLayeredConfigBackedEnvTypes(outPath, configPaths) {
-  const imports = configPaths.map(
-    (configPath, index) => `import type FarmConfig${index} from ${JSON.stringify(toTypeImportPath(outPath, configPath))};`
-  ).join("\n");
-  const resolvedTypes = configPaths.map(
-    (_configPath, index) => `
-type FarmConfigEnv${index} = typeof FarmConfig${index} extends { env?: infer TEnv }
-  ? NonNullable<TEnv>
-  : never;
-type FarmResolvedEnv${index} = [FarmConfigEnv${index}] extends [never]
-  ? { server: {}; public: {} }
-  : InferEnv<FarmConfigEnv${index}>;`
-  ).join("\n");
-  const mergedTypes = configPaths.slice(1).map(
-    (_configPath, index) => `type FarmMergedEnv${index + 1} = MergeFarmEnv<${index === 0 ? "FarmResolvedEnv0" : `FarmMergedEnv${index}`}, FarmResolvedEnv${index + 1}>;`
-  ).join("\n");
-  const finalType = `FarmMergedEnv${configPaths.length - 1}`;
-  return `/**
- * Auto-generated env types from Farm layers and farm.config.
- * Regenerated on dev start, build, and farm generate.
- */
-${imports}
-import type { InferEnv } from "@farm.js/core/env";
-
-type MergeFarmEnv<TBase, TOverride> = {
-  server: Omit<TBase extends { server: infer T } ? T : {}, keyof (TOverride extends { server: infer T } ? T : {})> &
-    (TOverride extends { server: infer T } ? T : {});
-  public: Omit<TBase extends { public: infer T } ? T : {}, keyof (TOverride extends { public: infer T } ? T : {})> &
-    (TOverride extends { public: infer T } ? T : {});
-};
-${resolvedTypes}
-${mergedTypes}
-
-type FarmResolvedEnv = ${finalType};
-
-declare module "@farm.js/core/env" {
-  interface FarmEnvTypes {
-    server: FarmResolvedEnv["server"];
-    public: FarmResolvedEnv["public"];
-  }
-}
-
-declare module "@farm.js/core" {
-  interface FarmEnvTypes {
-    server: FarmResolvedEnv["server"];
-    public: FarmResolvedEnv["public"];
-  }
-}
-
-export {};
-`;
-}
-function findConfigPath(root, configPath) {
-  if (configPath) {
-    const resolvedPath = path.isAbsolute(configPath) ? configPath : path.join(root, configPath);
-    return fs.existsSync(resolvedPath) ? resolvedPath : null;
-  }
-  for (const filename of CONFIG_FILENAMES) {
-    const resolvedPath = path.join(root, filename);
-    if (fs.existsSync(resolvedPath)) {
-      return resolvedPath;
-    }
-  }
-  return null;
-}
-function createConfigBackedEnvTypes(outPath, configPath) {
-  const configImportPath = toTypeImportPath(outPath, configPath);
-  return `/**
- * Auto-generated env types from farm.config.
- * Regenerated on dev start, build, and farm generate.
- */
-import type FarmConfig from ${JSON.stringify(configImportPath)};
-import type { InferEnv } from "@farm.js/core/env";
-
-type FarmConfigEnv = typeof FarmConfig extends { env?: infer TEnv } ? NonNullable<TEnv> : never;
-type FarmResolvedEnv = [FarmConfigEnv] extends [never]
-  ? { server: {}; public: {} }
-  : InferEnv<FarmConfigEnv>;
-
-declare module "@farm.js/core/env" {
-  interface FarmEnvTypes {
-    server: FarmResolvedEnv["server"];
-    public: FarmResolvedEnv["public"];
-  }
-}
-
-declare module "@farm.js/core" {
-  interface FarmEnvTypes {
-    server: FarmResolvedEnv["server"];
-    public: FarmResolvedEnv["public"];
-  }
-}
-
-export {};
-`;
-}
-function createEmptyEnvTypes() {
-  return `/**
- * Auto-generated env types from farm.config.
- * Regenerated on dev start, build, and farm generate.
- */
-declare module "@farm.js/core/env" {
-  interface FarmEnvTypes {
-    server: {};
-    public: {};
-  }
-}
-
-declare module "@farm.js/core" {
-  interface FarmEnvTypes {
-    server: {};
-    public: {};
-  }
-}
-
-export {};
-`;
-}
-function toTypeImportPath(outPath, targetPath) {
-  const relativePath = path.relative(path.dirname(outPath), targetPath).replace(/\\/g, "/").replace(/\.(tsx?|jsx?|mjs|cjs|mts|cts)$/, "");
-  return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-}
-
-export {
-  generateEnvTypes,
-  createEnvTypeDeclarations
-};

package/dist/chunk-TVCFY3KK.cjs

@@ -1,217 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-
-
-
-
-
-
-var _chunkCQL5ZGFUcjs = require('./chunk-CQL5ZGFU.cjs');
-
-// src/client/island-codec.ts
-var TYPED_ARRAYS = {
-  Int8Array,
-  Uint8Array,
-  Uint8ClampedArray,
-  Int16Array,
-  Uint16Array,
-  Int32Array,
-  Uint32Array,
-  Float32Array,
-  Float64Array,
-  BigInt64Array,
-  BigUint64Array
-};
-function toBase64(bytes) {
-  let binary = "";
-  for (let index = 0; index < bytes.length; index += 32768) {
-    binary += String.fromCharCode(...bytes.subarray(index, index + 32768));
-  }
-  return btoa(binary);
-}
-function fromBase64(base64) {
-  const binary = atob(base64);
-  const bytes = new Uint8Array(binary.length);
-  for (let index = 0; index < binary.length; index++) bytes[index] = binary.charCodeAt(index);
-  return bytes;
-}
-function farmTagged(tag, value) {
-  return value === void 0 ? { [_chunkCQL5ZGFUcjs.FARM_TAG]: tag } : { [_chunkCQL5ZGFUcjs.FARM_TAG]: tag, [_chunkCQL5ZGFUcjs.FARM_TAG_VALUE]: value };
-}
-function needsFarmObjectTag(object) {
-  return Object.prototype.hasOwnProperty.call(object, _chunkCQL5ZGFUcjs.FARM_TAG);
-}
-function encodeFarmLeaf(value) {
-  switch (typeof value) {
-    case "undefined":
-      return farmTagged("u");
-    case "bigint":
-      return farmTagged("B", value.toString());
-    case "number":
-      if (Number.isNaN(value)) return farmTagged("n", "NaN");
-      if (value === Infinity) return farmTagged("n", "Infinity");
-      if (value === -Infinity) return farmTagged("n", "-Infinity");
-      if (Object.is(value, -0)) return farmTagged("n", "-0");
-      return void 0;
-    case "object":
-      break;
-    default:
-      return void 0;
-  }
-  if (value === null) return void 0;
-  if (value instanceof Date) {
-    return farmTagged("D", Number.isNaN(value.getTime()) ? null : value.toISOString());
-  }
-  if (typeof URL === "function" && value instanceof URL) return farmTagged("U", value.href);
-  if (value instanceof RegExp) return farmTagged("R", [value.source, value.flags]);
-  if (value instanceof ArrayBuffer) {
-    return farmTagged("Y", ["ArrayBuffer", toBase64(new Uint8Array(value))]);
-  }
-  if (ArrayBuffer.isView(value)) {
-    const name = value instanceof DataView ? "DataView" : value.constructor.name;
-    if (name !== "DataView" && !(name in TYPED_ARRAYS)) return void 0;
-    const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
-    return farmTagged("Y", [name, toBase64(bytes)]);
-  }
-  return void 0;
-}
-var NOT_A_FARM_MARKER = /* @__PURE__ */ Symbol.for("farm.codec.not-a-marker");
-function farmPlainObject(entries) {
-  const object = {};
-  for (const [key, value] of entries) {
-    Object.defineProperty(object, key, {
-      value,
-      enumerable: true,
-      writable: true,
-      configurable: true
-    });
-  }
-  return object;
-}
-function decodeFarmTagged(object, decodeChild) {
-  const tag = object[_chunkCQL5ZGFUcjs.FARM_TAG];
-  const data = object[_chunkCQL5ZGFUcjs.FARM_TAG_VALUE];
-  switch (tag) {
-    case _chunkCQL5ZGFUcjs.FARM_REFERENCE_TAG:
-    case _chunkCQL5ZGFUcjs.FARM_SLOT_TAG:
-    case _chunkCQL5ZGFUcjs.FARM_ACTION_TAG:
-      return NOT_A_FARM_MARKER;
-    case _chunkCQL5ZGFUcjs.FARM_OBJECT_TAG:
-      if (data && typeof data === "object" && !Array.isArray(data)) {
-        return farmPlainObject(
-          Object.entries(data).map(([key, value]) => [key, decodeChild(value)])
-        );
-      }
-      break;
-    case "u":
-      return void 0;
-    case "n":
-      if (data === "NaN") return Number.NaN;
-      if (data === "Infinity") return Infinity;
-      if (data === "-Infinity") return -Infinity;
-      if (data === "-0") return -0;
-      break;
-    case "B":
-      if (typeof data === "string" && /^-?\d+$/.test(data)) return BigInt(data);
-      break;
-    case "D":
-      if (data === null) return new Date(Number.NaN);
-      if (typeof data === "string") return new Date(data);
-      break;
-    case "U":
-      if (typeof data === "string") return new URL(data);
-      break;
-    case "R":
-      if (Array.isArray(data) && typeof data[0] === "string" && typeof data[1] === "string") {
-        return new RegExp(data[0], data[1]);
-      }
-      break;
-    case "Y": {
-      if (!Array.isArray(data) || typeof data[0] !== "string" || typeof data[1] !== "string") break;
-      const bytes = fromBase64(data[1]);
-      if (data[0] === "ArrayBuffer") return bytes.buffer;
-      if (data[0] === "DataView") return new DataView(bytes.buffer);
-      const TypedArray = Object.prototype.hasOwnProperty.call(TYPED_ARRAYS, data[0]) ? TYPED_ARRAYS[data[0]] : void 0;
-      if (!TypedArray || bytes.byteLength % TypedArray.BYTES_PER_ELEMENT !== 0) break;
-      return new TypedArray(
-        bytes.buffer,
-        0,
-        bytes.byteLength / TypedArray.BYTES_PER_ELEMENT
-      );
-    }
-    case "M":
-      if (Array.isArray(data) && data.every((entry) => Array.isArray(entry) && entry.length === 2)) {
-        return new Map(data.map(([key, value]) => [decodeChild(key), decodeChild(value)]));
-      }
-      break;
-    case "S":
-      if (Array.isArray(data)) return new Set(data.map(decodeChild));
-      break;
-    default:
-      throw new TypeError(`unknown ${JSON.stringify(tag)} tag`);
-  }
-  throw new TypeError(`malformed ${JSON.stringify(tag)} tag`);
-}
-function encodeFarmJson(value, seen = /* @__PURE__ */ new Set()) {
-  const leaf = encodeFarmLeaf(value);
-  if (leaf) return leaf;
-  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
-  if (typeof value === "number") return value;
-  if (typeof value !== "object") throw new TypeError(`${typeof value} values are not serializable`);
-  if (seen.has(value)) throw new TypeError("circular values are not serializable");
-  seen.add(value);
-  try {
-    if (Array.isArray(value)) return value.map((entry) => encodeFarmJson(entry, seen));
-    if (value instanceof Map) {
-      return farmTagged(
-        "M",
-        Array.from(value, ([key, entry]) => [
-          encodeFarmJson(key, seen),
-          encodeFarmJson(entry, seen)
-        ])
-      );
-    }
-    if (value instanceof Set) {
-      return farmTagged(
-        "S",
-        Array.from(value, (entry) => encodeFarmJson(entry, seen))
-      );
-    }
-    const prototype = Object.getPrototypeOf(value);
-    if (prototype !== Object.prototype && prototype !== null) {
-      throw new TypeError("class instances are not serializable");
-    }
-    const encoded = Object.fromEntries(
-      Object.entries(value).map(([key, entry]) => [key, encodeFarmJson(entry, seen)])
-    );
-    return needsFarmObjectTag(value) ? farmTagged(_chunkCQL5ZGFUcjs.FARM_OBJECT_TAG, encoded) : encoded;
-  } finally {
-    seen.delete(value);
-  }
-}
-function decodeFarmJson(value) {
-  if (Array.isArray(value)) return value.map(decodeFarmJson);
-  if (!value || typeof value !== "object") return value;
-  if (_chunkCQL5ZGFUcjs.getFarmTag.call(void 0, value) !== void 0) {
-    const decoded = decodeFarmTagged(value, decodeFarmJson);
-    if (decoded === NOT_A_FARM_MARKER) {
-      throw new TypeError(
-        `a ${JSON.stringify(value[_chunkCQL5ZGFUcjs.FARM_TAG])} reference is not allowed here`
-      );
-    }
-    return decoded;
-  }
-  if (needsFarmObjectTag(value)) throw new TypeError('malformed "$" tag');
-  return farmPlainObject(Object.entries(value).map(([key, entry]) => [key, decodeFarmJson(entry)]));
-}
-
-
-
-
-
-
-
-
-
-
-exports.farmTagged = farmTagged; exports.needsFarmObjectTag = needsFarmObjectTag; exports.encodeFarmLeaf = encodeFarmLeaf; exports.NOT_A_FARM_MARKER = NOT_A_FARM_MARKER; exports.farmPlainObject = farmPlainObject; exports.decodeFarmTagged = decodeFarmTagged; exports.encodeFarmJson = encodeFarmJson; exports.decodeFarmJson = decodeFarmJson;

package/dist/chunk-U4BJKNIR.cjs

@@ -1,224 +0,0 @@
-"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(); } }
-
-var _chunk5YPBFMBNcjs = require('./chunk-5YPBFMBN.cjs');
-
-
-var _chunkRD623KW4cjs = require('./chunk-RD623KW4.cjs');
-
-
-var _chunkZDAEHG2Ocjs = require('./chunk-ZDAEHG2O.cjs');
-
-
-var _chunkNWUHS6GVcjs = require('./chunk-NWUHS6GV.cjs');
-
-
-var _chunkQMNWKQL4cjs = require('./chunk-QMNWKQL4.cjs');
-
-// src/routing/generate-route-types.ts
-var _path = require('path'); var path = _interopRequireWildcard(_path);
-var _fs = require('fs'); var fs = _interopRequireWildcard(_fs);
-function routeSegmentsToTsTypeLiteral(segments) {
-  if (segments.length === 0) return '"/"';
-  const hasDynamic = segments.some((s) => s.startsWith("["));
-  if (!hasDynamic) return JSON.stringify("/" + segments.join("/"));
-  const parts = segments.map((s) => {
-    if (s.startsWith("[[...") || s.startsWith("[...")) return "${string}";
-    if (s.startsWith("[")) return "${string}";
-    return s;
-  });
-  return "`/" + parts.join("/") + "`";
-}
-function routePatternToTsTypeLiterals(pattern) {
-  if (pattern === "/") return ['"/"'];
-  let variants = [[]];
-  for (const segment of pattern.slice(1).split("/").filter(Boolean)) {
-    if (segment.startsWith("[[...") && segment.endsWith("]]")) {
-      variants = variants.flatMap((parts) => [parts, [...parts, segment]]);
-    } else {
-      variants = variants.map((parts) => [...parts, segment]);
-    }
-  }
-  return variants.map(routeSegmentsToTsTypeLiteral);
-}
-function routePatternToRouteLiteral(pattern) {
-  return JSON.stringify(pattern);
-}
-function renderTypeUnion(values) {
-  return values.length <= 1 ? values[0] || "never" : `
-  | ${values.join("\n  | ")}`;
-}
-function renderTypeAlias(name, value) {
-  return `export type ${name} =${value.startsWith("\n") ? "" : " "}${value};`;
-}
-function createRoutePattern(route) {
-  if (route.segments.length === 0) return "/";
-  return "/" + route.segments.map((seg) => {
-    if (!seg.isDynamic) return seg.segment;
-    if (seg.isCatchAll) return seg.isOptional ? `[[...${seg.segment}]]` : `[...${seg.segment}]`;
-    return `[${seg.segment}]`;
-  }).join("/");
-}
-var DEFAULT_OUT_FILE = "farm-routes.d.ts";
-async function generateRouteTypes(options) {
-  const root = path.resolve(options.root);
-  const srcDir = options.srcDir || "src";
-  const outFile = options.outFile || DEFAULT_OUT_FILE;
-  const outPath = path.isAbsolute(outFile) ? outFile : path.join(root, srcDir, outFile);
-  const content = await createRouteTypeDeclarations(options, outPath);
-  fs.mkdirSync(path.dirname(outPath), { recursive: true });
-  _chunk5YPBFMBNcjs.writeFileIfChanged.call(void 0, outPath, content);
-  return outPath;
-}
-async function createRouteTypeDeclarations(options, outPath) {
-  const { extraRoutes = [], suppressLintOnLink = false } = options;
-  const { pages: patterns, modules: routeModulePatterns } = await scanRoutePatterns(options);
-  for (const route of extraRoutes) {
-    if (route.startsWith("/")) {
-      patterns.add(route);
-      routeModulePatterns.add(route);
-    }
-  }
-  const sortedPatterns = Array.from(patterns).sort();
-  const typeLiterals = Array.from(new Set(sortedPatterns.flatMap(routePatternToTsTypeLiterals)));
-  const patternLiterals = sortedPatterns.map(routePatternToRouteLiteral);
-  const routeModulePatternLiterals = Array.from(routeModulePatterns).sort().map(routePatternToRouteLiteral);
-  const routePathType = suppressLintOnLink ? "string" : renderTypeUnion(typeLiterals);
-  const routePatternType = suppressLintOnLink ? "string" : renderTypeUnion(patternLiterals);
-  const routeModulePatternType = renderTypeUnion(routeModulePatternLiterals);
-  const routeTypesImportPath = `./${path.basename(outPath).replace(/\.d\.ts$/, "")}`;
-  const linkAugmentationBlock = suppressLintOnLink ? "" : `
-declare module "@farm.js/core/client" {
-  interface LinkDefaultRoute {
-    _: import(${JSON.stringify(routeTypesImportPath)}).RoutePath;
-    pattern: import(${JSON.stringify(routeTypesImportPath)}).RoutePattern;
-  }
-}
-
-declare module "@farm.js/core" {
-  interface LinkDefaultRoute {
-    _: import(${JSON.stringify(routeTypesImportPath)}).RoutePath;
-    pattern: import(${JSON.stringify(routeTypesImportPath)}).RoutePattern;
-  }
-  // Ensure root import ("@farm.js/core") uses the same typed Link signature as client entry.
-  const Link: typeof import("@farm.js/core/client").Link;
-}
-
-// Internal declaration path used by @farm.js/core root type re-exports.
-declare module "@farm.js/core/dist/client.js" {
-  interface LinkDefaultRoute {
-    _: import(${JSON.stringify(routeTypesImportPath)}).RoutePath;
-    pattern: import(${JSON.stringify(routeTypesImportPath)}).RoutePattern;
-  }
-}
-`;
-  const routeModuleAugmentationBlock = `
-declare global {
-  namespace FarmJS {
-    interface RouteRegistry {
-      pattern: import(${JSON.stringify(routeTypesImportPath)}).RouteModulePattern;
-    }
-  }
-}
-`;
-  const content = `/**
- * Auto-generated route types from src/app.
- * Link href and route component props are typed automatically from generated declarations.
- * Regenerated on dev start and when routes change.
- * Set suppressLintOnLink: true in farm.config.ts to accept any string on Link href.
- */
-${renderTypeAlias("RoutePath", routePathType)}
-${renderTypeAlias("RoutePattern", routePatternType)}
-${renderTypeAlias("RouteModulePattern", routeModulePatternType)}${linkAugmentationBlock}${routeModuleAugmentationBlock}
-`;
-  return content;
-}
-var PLATFORM_FILE = /^(?:(page|layout)\.(native|ios|android)\.(?:tsx|ts|jsx|js)|page\.(kt|swift))$/;
-async function scanRoutePatterns(options) {
-  const { root, srcDir = "src" } = options;
-  const sourceRoots = _nullishCoalesce(options.sourceRoots, () => ( [{ name: "project", root, srcDir, layer: false }]));
-  const componentExtensions = _chunkRD623KW4cjs.resolveFarmComponentExtensions.call(void 0, options.componentExtensions).map(
-    (extension) => extension.slice(1)
-  );
-  const pages = /* @__PURE__ */ new Set();
-  const modules = /* @__PURE__ */ new Set();
-  const pageFiles = /* @__PURE__ */ new Map();
-  const nativePages = /* @__PURE__ */ new Map();
-  const nativeLayouts = /* @__PURE__ */ new Map();
-  const { glob } = await import("tinyglobby");
-  for (const source of sourceRoots) {
-    const appDir = path.join(source.root, source.srcDir, "app");
-    if (fs.existsSync(appDir)) {
-      const routeModuleFiles = await glob(
-        `**/{page,layout,loading,error}.{${componentExtensions.join(",")},md,mdx}`,
-        { cwd: appDir, expandDirectories: false }
-      );
-      for (const file of routeModuleFiles) {
-        if (_chunkZDAEHG2Ocjs.parseRouteSlotFile.call(void 0, file)) continue;
-        const route = _chunkQMNWKQL4cjs.parseRoutePath.call(void 0, file);
-        const pattern = createRoutePattern(route);
-        modules.add(pattern);
-        if (route.type === "page") {
-          pages.add(pattern);
-          if (options.platformFiles) pageFiles.set(pattern, path.join(appDir, file));
-        }
-      }
-      if (options.platformFiles) {
-        scanPlatformRouteFiles(
-          appDir,
-          await glob(
-            ["**/{page,layout}.{native,ios,android}.{tsx,ts,jsx,js}", "**/page.{kt,swift}"],
-            { cwd: appDir, expandDirectories: false }
-          ),
-          nativePages,
-          nativeLayouts
-        );
-      }
-    }
-    for (const route of await _chunkNWUHS6GVcjs.discoverProgrammaticRoutePaths.call(void 0, source.root, source.srcDir)) {
-      pages.add(route);
-      modules.add(route);
-    }
-  }
-  if (!options.platformFiles) return { pages, modules };
-  for (const [pattern, files] of nativePages) {
-    if (!pages.has(pattern)) {
-      const file = path.relative(root, Object.values(files)[0]);
-      throw new Error(
-        `${file.replace(/\\/g, "/")} has no web page next to it. Add ${path.join(path.dirname(file), "page.tsx").replace(/\\/g, "/")}: it is the route's web screen and the fallback on every platform.`
-      );
-    }
-  }
-  return { pages, modules, pageFiles, nativePages, nativeLayouts };
-}
-function scanPlatformRouteFiles(appDir, files, nativePages, nativeLayouts) {
-  const seen = /* @__PURE__ */ new Map();
-  for (const file of [...files].sort()) {
-    const normalized = file.replace(/\\/g, "/");
-    const match = PLATFORM_FILE.exec(path.posix.basename(normalized));
-    if (!match) continue;
-    const kind = _nullishCoalesce(match[1], () => ( "page"));
-    const platform = _nullishCoalesce(match[2], () => ( match[3]));
-    const twin = path.posix.join(path.posix.dirname(normalized), `${kind}.tsx`);
-    if (kind === "page" && _chunkZDAEHG2Ocjs.parseRouteSlotFile.call(void 0, twin)) continue;
-    const dir = path.posix.dirname(normalized);
-    const pattern = kind === "page" ? createRoutePattern(_chunkQMNWKQL4cjs.parseRoutePath.call(void 0, twin)) : dir === "." ? "/" : `/${dir}`;
-    const key = `${kind}\0${pattern}\0${platform}`;
-    const previous = seen.get(key);
-    if (previous) {
-      throw new Error(
-        `Duplicate ${platform} ${kind} for "${pattern}": found ${previous} and ${normalized} in ${appDir}. Keep one.`
-      );
-    }
-    seen.set(key, normalized);
-    const target = kind === "page" ? nativePages : nativeLayouts;
-    const entry = { ...target.get(pattern) };
-    entry[platform] = path.join(appDir, normalized);
-    target.set(pattern, entry);
-  }
-}
-
-
-
-
-
-exports.generateRouteTypes = generateRouteTypes; exports.createRouteTypeDeclarations = createRouteTypeDeclarations; exports.scanRoutePatterns = scanRoutePatterns;