@farm.js/core 0.1.46 → 0.1.48

package/dist/chunk-WBKEZXWE.cjs

@@ -1,449 +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 _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await 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 _chunkUYIHRDE4cjs = require('./chunk-UYIHRDE4.cjs');
-
-
-var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
-
-// src/layers.ts
-var _fs = require('fs');
-var _promises = require('fs/promises');
-var _module = require('module');
-var _path = require('path'); var _path2 = _interopRequireDefault(_path);
-var _url = require('url');
-var FARM_CORE_PACKAGE = "@farm.js/core";
-var FARM_CONFIG_ENTRY = "@farm.js/core/config";
-var FARM_CORE_REFERENCE_RE = /(["'])@farm.js\/core\1/g;
-var FARM_CONFIG_HELPER_IMPORT_RE = /(?:^|\n)[\t ]*import[\t ]*\{([^{}]*)\}[\t ]*from[\t ]*(["'])@farm.js\/core\2[\t ]*;?[\t ]*(?:\n|$)/g;
-var FARM_CONFIG_HELPER_SPECIFIER_RE = /^(?:defineConfig|defineFarmConfig)(?:\s+as\s+[$A-Z_a-z][$\w]*)?$/;
-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"
-];
-var LAYER_LOCAL_CONFIG_KEYS = /* @__PURE__ */ new Set([
-  "root",
-  "srcDir",
-  "outDir",
-  "distDir",
-  "deploy",
-  "output",
-  "preset",
-  "publicDir",
-  "generateBuildId"
-]);
-async function resolveFarmLayers(projectConfig, options) {
-  const projectRoot = _path2.default.resolve(options.root);
-  const entries = normalizeLayerEntries(projectConfig.extends, "project config");
-  if (entries.length === 0) {
-    return {
-      config: {
-        ...projectConfig,
-        layers: []
-      },
-      layers: []
-    };
-  }
-  const loadedLayers = [];
-  const visited = /* @__PURE__ */ new Set();
-  const aliases = /* @__PURE__ */ new Map();
-  const visit = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async (source, ownerRoot, stack) => {
-    const resolvedSource = resolveLayerSource(source, ownerRoot);
-    const cycleIndex = stack.findIndex((entry) => entry.root === resolvedSource.root);
-    if (cycleIndex !== -1) {
-      const cycle = [...stack.slice(cycleIndex).map((entry) => entry.source), source];
-      throw new Error(`Farm layer cycle detected: ${cycle.join(" -> ")}`);
-    }
-    if (visited.has(resolvedSource.root)) return;
-    const configFile = findFarmConfigFile(resolvedSource.root, resolvedSource.configFile);
-    const config = configFile ? await loadFarmConfigFile(configFile, {
-      cacheRoot: projectRoot,
-      root: resolvedSource.root
-    }) : {};
-    const nestedEntries = normalizeLayerEntries(config.extends, `layer ${JSON.stringify(source)}`);
-    const nextStack = [...stack, { root: resolvedSource.root, source }];
-    for (const nestedSource of nestedEntries) {
-      await visit(nestedSource, resolvedSource.root, nextStack);
-    }
-    if (visited.has(resolvedSource.root)) return;
-    const name = getLayerName(source, resolvedSource.root);
-    const conflictingRoot = aliases.get(name);
-    if (conflictingRoot && conflictingRoot !== resolvedSource.root) {
-      throw new Error(
-        `Farm layer alias "#layers/${name}" is ambiguous between ${conflictingRoot} and ${resolvedSource.root}`
-      );
-    }
-    aliases.set(name, resolvedSource.root);
-    visited.add(resolvedSource.root);
-    loadedLayers.push({
-      source,
-      name,
-      root: resolvedSource.root,
-      srcDir: normalizeLayerSrcDir(config.srcDir),
-      configFile,
-      config
-    });
-  }, "visit");
-  for (const source of entries) {
-    await visit(source, projectRoot, []);
-  }
-  let mergedConfig = {};
-  for (const layer of loadedLayers) {
-    mergedConfig = mergeFarmLayerConfig(mergedConfig, getLayerDefaults(layer.config));
-  }
-  mergedConfig = mergeFarmLayerConfig(mergedConfig, projectConfig);
-  const layers = loadedLayers.map(({ config: _config, ...layer }) => layer);
-  return {
-    config: {
-      ...mergedConfig,
-      root: projectConfig.root,
-      srcDir: projectConfig.srcDir,
-      extends: projectConfig.extends,
-      layers
-    },
-    layers
-  };
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmLayers, "resolveFarmLayers");
-function getFarmSourceRoots(config) {
-  const roots = (_nullishCoalesce(config.layers, () => ( []))).map((layer) => ({
-    name: layer.name,
-    root: layer.root,
-    srcDir: layer.srcDir,
-    layer: true
-  }));
-  roots.push({
-    name: "project",
-    root: _path2.default.resolve(config.root || process.cwd()),
-    srcDir: config.srcDir || "src",
-    layer: false
-  });
-  return roots;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmSourceRoots, "getFarmSourceRoots");
-function getFarmAppDirectories(config) {
-  return getFarmSourceRoots(config).map((source) => _path2.default.join(source.root, source.srcDir, "app"));
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmAppDirectories, "getFarmAppDirectories");
-function getFarmLayerAliases(layers) {
-  return Object.fromEntries(
-    (_nullishCoalesce(layers, () => ( []))).map((layer) => [`#layers/${layer.name}`, _path2.default.join(layer.root, layer.srcDir)])
-  );
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmLayerAliases, "getFarmLayerAliases");
-var WINDOWS_ABSOLUTE_PATH_RE = /^(?:[A-Za-z]:[\\/]|\\\\)/;
-function toExternalSpecifier(resolvedPath) {
-  return _path2.default.isAbsolute(resolvedPath) ? _url.pathToFileURL.call(void 0, resolvedPath).href : resolvedPath;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, toExternalSpecifier, "toExternalSpecifier");
-var BARE_SPECIFIER_RE = /^[^./]/;
-function createFarmConfigResolutionPlugin(options) {
-  const configEntryChecks = /* @__PURE__ */ new Map();
-  return {
-    name: "farm-config-package-resolution",
-    async resolveId(source, importer, extraOptions) {
-      if (!importer || extraOptions.isEntry || !BARE_SPECIFIER_RE.test(source) || source.startsWith("\0") || _module.isBuiltin.call(void 0, source) || _path2.default.isAbsolute(source) || WINDOWS_ABSOLUTE_PATH_RE.test(source)) {
-        return null;
-      }
-      const resolveRuntimePath = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async (specifier) => {
-        const resolved = await this.resolve(specifier, importer, {
-          kind: extraOptions.kind,
-          skipSelf: true
-        });
-        if (!_optionalChain([resolved, 'optionalAccess', _ => _.id]) || !_chunkUYIHRDE4cjs.isDeclarationFile.call(void 0, resolved.id)) return _optionalChain([resolved, 'optionalAccess', _2 => _2.id]);
-        return await _asyncNullishCoalesce(await _chunkUYIHRDE4cjs.resolvePackageWithoutTsconfig.call(void 0, specifier, importer, extraOptions.kind), async () => ( void 0));
-      }, "resolveRuntimePath");
-      if (source === FARM_CORE_PACKAGE && extraOptions.kind === "import-statement") {
-        let configEntryCheck = configEntryChecks.get(importer);
-        if (!configEntryCheck) {
-          configEntryCheck = onlyImportsFarmConfigHelpers(importer, options.transform);
-          configEntryChecks.set(importer, configEntryCheck);
-        }
-        if (await configEntryCheck) {
-          const configEntry = await resolveRuntimePath(FARM_CONFIG_ENTRY);
-          if (configEntry) {
-            return { id: toExternalSpecifier(configEntry), external: true };
-          }
-        }
-      }
-      const resolvedId = await resolveRuntimePath(source);
-      if (!resolvedId) {
-        return { id: source, external: true };
-      }
-      return { id: toExternalSpecifier(resolvedId), external: true };
-    }
-  };
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmConfigResolutionPlugin, "createFarmConfigResolutionPlugin");
-var FARM_CONFIG_ROOT = /* @__PURE__ */ Symbol.for("farm.configRoot");
-async function loadFarmConfigFile(configPath, options) {
-  const { transform } = await import("rolldown/utils");
-  const cacheRoot = _path2.default.resolve(options.cacheRoot || options.root);
-  const configCacheDir = _path2.default.join(cacheRoot, ".farm", ".config-loader");
-  await _promises.mkdir.call(void 0, configCacheDir, { recursive: true });
-  const modulePath = _path2.default.join(
-    configCacheDir,
-    `farm-config-${Date.now()}-${Math.random().toString(36).slice(2)}.mjs`
-  );
-  await _chunkUYIHRDE4cjs.bundleNodeModule.call(void 0, {
-    root: _path2.default.resolve(options.root),
-    entry: _path2.default.resolve(configPath),
-    outfile: modulePath,
-    target: `node${process.versions.node.split(".")[0]}`,
-    plugins: [createFarmConfigResolutionPlugin({ transform })]
-  });
-  const moduleUrl = `${_url.pathToFileURL.call(void 0, modulePath).href}?t=${Date.now()}`;
-  const configRootState = globalThis;
-  const previousConfigRoot = configRootState[FARM_CONFIG_ROOT];
-  configRootState[FARM_CONFIG_ROOT] = cacheRoot;
-  try {
-    const loaded = await import(
-      /* @vite-ignore */
-      moduleUrl
-    );
-    const config = loaded.default || loaded;
-    if (!config || typeof config !== "object" || Array.isArray(config)) {
-      throw new TypeError(`Farm config ${configPath} must export an object`);
-    }
-    return config;
-  } finally {
-    configRootState[FARM_CONFIG_ROOT] = previousConfigRoot;
-    await _promises.unlink.call(void 0, modulePath).catch(() => void 0);
-  }
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, loadFarmConfigFile, "loadFarmConfigFile");
-async function onlyImportsFarmConfigHelpers(importer, transform) {
-  try {
-    const source = _fs.readFileSync.call(void 0, importer, "utf8");
-    if (!source.includes(FARM_CORE_PACKAGE)) return false;
-    const transformed = await transform(importer, source, {
-      lang: getSourceLang(importer),
-      sourceType: "module",
-      jsx: { runtime: "automatic" }
-    });
-    if (transformed.errors.length > 0) return false;
-    const references = [...transformed.code.matchAll(FARM_CORE_REFERENCE_RE)];
-    if (references.length === 0) return false;
-    const safeImportRanges = [];
-    for (const match of transformed.code.matchAll(FARM_CONFIG_HELPER_IMPORT_RE)) {
-      const specifiers = match[1].split(",").map((specifier) => specifier.trim()).filter(Boolean);
-      if (specifiers.length === 0 || !specifiers.every((specifier) => FARM_CONFIG_HELPER_SPECIFIER_RE.test(specifier))) {
-        continue;
-      }
-      const start = _nullishCoalesce(match.index, () => ( 0));
-      safeImportRanges.push({ start, end: start + match[0].length });
-    }
-    return references.every((reference) => {
-      const index = _nullishCoalesce(reference.index, () => ( -1));
-      return safeImportRanges.some((range) => index >= range.start && index < range.end);
-    });
-  } catch (e) {
-    return false;
-  }
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, onlyImportsFarmConfigHelpers, "onlyImportsFarmConfigHelpers");
-function getSourceLang(file) {
-  switch (_path2.default.extname(file)) {
-    case ".ts":
-    case ".mts":
-    case ".cts":
-      return "ts";
-    case ".tsx":
-      return "tsx";
-    case ".jsx":
-      return "jsx";
-    default:
-      return "js";
-  }
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, getSourceLang, "getSourceLang");
-function normalizeLayerEntries(value, owner) {
-  if (value === void 0) return [];
-  if (!Array.isArray(value)) {
-    throw new TypeError(`${owner} "extends" must be an array of layer paths or package names`);
-  }
-  return value.map((entry, index) => {
-    if (typeof entry !== "string" || entry.trim() === "") {
-      throw new TypeError(`${owner} "extends" entry ${index} must be a non-empty string`);
-    }
-    return entry.trim();
-  });
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeLayerEntries, "normalizeLayerEntries");
-function resolveLayerSource(source, ownerRoot) {
-  if (isPathLayerSource(source)) {
-    const target = source.startsWith("file:") ? _path2.default.resolve(ownerRoot, source.slice("file:".length)) : _path2.default.resolve(ownerRoot, source);
-    if (!_fs.existsSync.call(void 0, target)) {
-      throw new Error(`Cannot resolve Farm layer ${JSON.stringify(source)} from ${ownerRoot}`);
-    }
-    const stats = _fs.statSync.call(void 0, target);
-    const root = stats.isDirectory() ? target : _path2.default.dirname(target);
-    return {
-      root: normalizeRealPath(root),
-      configFile: stats.isFile() ? normalizeRealPath(target) : void 0
-    };
-  }
-  const requireFromOwner = _module.createRequire.call(void 0, _path2.default.join(ownerRoot, "package.json"));
-  let packageJsonPath;
-  try {
-    packageJsonPath = requireFromOwner.resolve(`${source}/package.json`);
-  } catch (e2) {
-  }
-  if (packageJsonPath) {
-    return { root: normalizeRealPath(_path2.default.dirname(packageJsonPath)) };
-  }
-  try {
-    const entryPath = requireFromOwner.resolve(source);
-    const packageRoot = findNearestPackageRoot(entryPath);
-    if (packageRoot) return { root: normalizeRealPath(packageRoot) };
-  } catch (e3) {
-  }
-  throw new Error(`Cannot resolve Farm layer package ${JSON.stringify(source)} from ${ownerRoot}`);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, resolveLayerSource, "resolveLayerSource");
-function findNearestPackageRoot(entryPath) {
-  let current = _fs.statSync.call(void 0, entryPath).isDirectory() ? entryPath : _path2.default.dirname(entryPath);
-  while (true) {
-    if (_fs.existsSync.call(void 0, _path2.default.join(current, "package.json"))) return current;
-    const parent = _path2.default.dirname(current);
-    if (parent === current) return null;
-    current = parent;
-  }
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, findNearestPackageRoot, "findNearestPackageRoot");
-function findFarmConfigFile(root, explicitPath) {
-  if (explicitPath) return explicitPath;
-  for (const fileName of CONFIG_FILENAMES) {
-    const candidate = _path2.default.join(root, fileName);
-    if (_fs.existsSync.call(void 0, candidate)) return candidate;
-  }
-  return void 0;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, findFarmConfigFile, "findFarmConfigFile");
-function getLayerName(source, root) {
-  if (!isPathLayerSource(source)) {
-    const packageName = source.split("/").filter(Boolean).pop();
-    if (packageName) return sanitizeLayerName(packageName);
-  }
-  try {
-    const packageJson = JSON.parse(_fs.readFileSync.call(void 0, _path2.default.join(root, "package.json"), "utf8"));
-    if (typeof packageJson.name === "string") {
-      return sanitizeLayerName(packageJson.name.split("/").pop() || packageJson.name);
-    }
-  } catch (e4) {
-  }
-  return sanitizeLayerName(_path2.default.basename(root));
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, getLayerName, "getLayerName");
-function sanitizeLayerName(value) {
-  const name = value.trim().replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "");
-  if (!name) throw new Error(`Cannot derive a name for Farm layer ${JSON.stringify(value)}`);
-  return name;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, sanitizeLayerName, "sanitizeLayerName");
-function normalizeLayerSrcDir(value) {
-  if (value === void 0) return "src";
-  if (typeof value !== "string" || value.trim() === "" || _path2.default.isAbsolute(value)) {
-    throw new TypeError("A Farm layer srcDir must be a non-empty relative path");
-  }
-  const normalized = _path2.default.normalize(value.trim());
-  if (normalized === ".." || normalized.startsWith(`..${_path2.default.sep}`)) {
-    throw new TypeError("A Farm layer srcDir cannot leave the layer root");
-  }
-  return normalized;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeLayerSrcDir, "normalizeLayerSrcDir");
-function getLayerDefaults(config) {
-  return Object.fromEntries(
-    Object.entries(config).filter(
-      ([key, value]) => key !== "extends" && value !== void 0 && !LAYER_LOCAL_CONFIG_KEYS.has(key)
-    )
-  );
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, getLayerDefaults, "getLayerDefaults");
-function mergeFarmLayerConfig(base, override) {
-  const output = { ...base };
-  for (const [key, value] of Object.entries(override)) {
-    if (value === void 0 || key === "layers") continue;
-    if (key === "plugins") {
-      output[key] = [...toArray(output[key]), ...toArray(value)];
-      continue;
-    }
-    if (key === "middleware" && output[key] !== void 0) {
-      output[key] = [...toArray(output[key]), ...toArray(value)];
-      continue;
-    }
-    if ((key === "redirects" || key === "rewrites" || key === "headers") && output[key]) {
-      output[key] = mergeConfigListResolvers(output[key], value);
-      continue;
-    }
-    if (isPlainObject(output[key]) && isPlainObject(value)) {
-      output[key] = mergePlainObjects(output[key], value);
-      continue;
-    }
-    output[key] = value;
-  }
-  return output;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, mergeFarmLayerConfig, "mergeFarmLayerConfig");
-function mergePlainObjects(base, override) {
-  const output = { ...base };
-  for (const [key, value] of Object.entries(override)) {
-    if (value === void 0) continue;
-    output[key] = isPlainObject(output[key]) && isPlainObject(value) ? mergePlainObjects(output[key], value) : value;
-  }
-  return output;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, mergePlainObjects, "mergePlainObjects");
-function mergeConfigListResolvers(base, override) {
-  return async () => [...await resolveConfigList(base), ...await resolveConfigList(override)];
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, mergeConfigListResolvers, "mergeConfigListResolvers");
-async function resolveConfigList(value) {
-  const resolved = typeof value === "function" ? await value() : value;
-  return toArray(resolved);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, resolveConfigList, "resolveConfigList");
-function toArray(value) {
-  if (value === void 0 || value === null) return [];
-  return Array.isArray(value) ? value : [value];
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, toArray, "toArray");
-function isPlainObject(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, isPlainObject, "isPlainObject");
-function isPathLayerSource(source) {
-  return source.startsWith(".") || source.startsWith("/") || source.startsWith("file:") || /^[a-zA-Z]:[\\/]/.test(source);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, isPathLayerSource, "isPathLayerSource");
-function normalizeRealPath(value) {
-  return _path2.default.resolve(_fs.realpathSync.call(void 0, value));
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeRealPath, "normalizeRealPath");
-
-
-
-
-
-
-
-
-exports.resolveFarmLayers = resolveFarmLayers; exports.getFarmSourceRoots = getFarmSourceRoots; exports.getFarmAppDirectories = getFarmAppDirectories; exports.getFarmLayerAliases = getFarmLayerAliases; exports.createFarmConfigResolutionPlugin = createFarmConfigResolutionPlugin; exports.loadFarmConfigFile = loadFarmConfigFile;

package/dist/chunk-WDMIW6Q6.mjs

@@ -1,145 +0,0 @@
-import {
-  __name
-} from "./chunk-LPEX4YW6.mjs";
-
-// 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.`
-  );
-}
-__name(assertSupportedPrimaryKeyField, "assertSupportedPrimaryKeyField");
-
-// 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;
-}
-__name(resolveSchemaModels, "resolveSchemaModels");
-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
-  };
-}
-__name(cloneSchemaModel, "cloneSchemaModel");
-
-export {
-  assertSupportedPrimaryKeyField,
-  resolveSchemaModels
-};