@warlock.js/core 5.29.0 → 5.30.0

package/esm/utils/framework-vesion.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"framework-vesion.mjs","names":[],"sources":["../../../../../../../core/src/utils/framework-vesion.ts"],"sourcesContent":["import { getJsonFileAsync } from \"@warlock.js/fs\";\nimport path from \"node:path\";\n\n/**\n * Cached version string\n */\nlet cachedVersion: string | null = null;\n\n/**\n * Get the framework version from package.json (cached)\n */\nexport async function getWarlockVersion(): Promise<string> {\n  if (cachedVersion) return cachedVersion;\n\n  const frameworkPackageJson = (await getJsonFileAsync(\n    path.join(import.meta.dirname, \"./../../package.json\"),\n  )) as { version: string };\n\n  const version = frameworkPackageJson.version.replace(/\\^|\\~/g, \"\");\n  cachedVersion = version;\n  return version;\n}\n\nexport function getFrameworkVersion(): string | null {\n  return cachedVersion;\n}\n"],"mappings":";;;;;;;AAMA,IAAI,gBAA+B;;;;AAKnC,eAAsB,oBAAqC;CACzD,IAAI,eAAe,OAAO;CAM1B,MAAM,WAAU,MAJoB,iBAClC,KAAK,KAAK,OAAO,KAAK,SAAS,sBAAsB,CACvD,EAEoC,CAAC,QAAQ,QAAQ,UAAU,EAAE;CACjE,gBAAgB;CAChB,OAAO;AACT;AAEA,SAAgB,sBAAqC;CACnD,OAAO;AACT"}
+{"version":3,"file":"framework-vesion.mjs","names":[],"sources":["../../../../../../../../packages/core/src/utils/framework-vesion.ts"],"sourcesContent":["import { getJsonFileAsync } from \"@warlock.js/fs\";\nimport path from \"node:path\";\n\n/**\n * Cached version string\n */\nlet cachedVersion: string | null = null;\n\n/**\n * Get the framework version from package.json (cached)\n */\nexport async function getWarlockVersion(): Promise<string> {\n  if (cachedVersion) return cachedVersion;\n\n  const frameworkPackageJson = (await getJsonFileAsync(\n    path.join(import.meta.dirname, \"./../../package.json\"),\n  )) as { version: string };\n\n  const version = frameworkPackageJson.version.replace(/\\^|\\~/g, \"\");\n  cachedVersion = version;\n  return version;\n}\n\nexport function getFrameworkVersion(): string | null {\n  return cachedVersion;\n}\n"],"mappings":";;;;;;;AAMA,IAAI,gBAA+B;;;;AAKnC,eAAsB,oBAAqC;CACzD,IAAI,eAAe,OAAO;CAM1B,MAAM,WAAU,MAJoB,iBAClC,KAAK,KAAK,OAAO,KAAK,SAAS,sBAAsB,CACvD,EAEoC,CAAC,QAAQ,QAAQ,UAAU,EAAE;CACjE,gBAAgB;CAChB,OAAO;AACT;AAEA,SAAgB,sBAAqC;CACnD,OAAO;AACT"}

package/esm/utils/get-localized.d.mts

@@ -1,4 +1,4 @@
-//#region ../core/src/utils/get-localized.d.ts
+//#region ../../packages/core/src/utils/get-localized.d.ts
 type LocalizedObject = {
   localeCode: string;
   value: any;

package/esm/utils/get-localized.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"get-localized.d.mts","names":[],"sources":["../../../../../../../core/src/utils/get-localized.ts"],"mappings":";KAEY,eAAA;EACV,UAAA;EACA,KAAK;AAAA;;AAAA;AAOP;;iBAAgB,YAAA,CAAa,MAAA,EAAQ,eAAe,IAAI,UAAA,WAAqB,GAAA"}
+{"version":3,"file":"get-localized.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/utils/get-localized.ts"],"mappings":";KAEY,eAAA;EACV,UAAA;EACA,KAAK;AAAA;;AAAA;AAOP;;iBAAgB,YAAA,CAAa,MAAA,EAAQ,eAAe,IAAI,UAAA,WAAqB,GAAA"}

package/esm/utils/get-localized.mjs

@@ -1,6 +1,6 @@
 import { useRequestStore } from "../http/context/request-context.mjs";
 
-//#region ../core/src/utils/get-localized.ts
+//#region ../../packages/core/src/utils/get-localized.ts
 /**
 * Get localized value based on the given locale code
 * If the locale code is not given and the function is called within a request context, it will get the current locale code

package/esm/utils/get-localized.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"get-localized.mjs","names":[],"sources":["../../../../../../../core/src/utils/get-localized.ts"],"sourcesContent":["import { useRequestStore } from \"../http/context/request-context\";\n\nexport type LocalizedObject = {\n  localeCode: string;\n  value: any;\n};\n\n/**\n * Get localized value based on the given locale code\n * If the locale code is not given and the function is called within a request context, it will get the current locale code\n */\nexport function getLocalized(values: LocalizedObject[], localeCode?: string, key = \"value\") {\n  if (!values) return values;\n\n  if (!localeCode) {\n    localeCode = useRequestStore().request?.getLocaleCode();\n  }\n\n  if (Array.isArray(values)) {\n    return values.find((value) => value.localeCode === localeCode)?.[key as keyof LocalizedObject];\n  }\n\n  return values;\n}\n"],"mappings":";;;;;;;AAWA,SAAgB,aAAa,QAA2B,YAAqB,MAAM,SAAS;CAC1F,IAAI,CAAC,QAAQ,OAAO;CAEpB,IAAI,CAAC,YACH,aAAa,gBAAgB,CAAC,CAAC,SAAS,cAAc;CAGxD,IAAI,MAAM,QAAQ,MAAM,GACtB,OAAO,OAAO,MAAM,UAAU,MAAM,eAAe,UAAU,CAAC,GAAG;CAGnE,OAAO;AACT"}
+{"version":3,"file":"get-localized.mjs","names":[],"sources":["../../../../../../../../packages/core/src/utils/get-localized.ts"],"sourcesContent":["import { useRequestStore } from \"../http/context/request-context\";\n\nexport type LocalizedObject = {\n  localeCode: string;\n  value: any;\n};\n\n/**\n * Get localized value based on the given locale code\n * If the locale code is not given and the function is called within a request context, it will get the current locale code\n */\nexport function getLocalized(values: LocalizedObject[], localeCode?: string, key = \"value\") {\n  if (!values) return values;\n\n  if (!localeCode) {\n    localeCode = useRequestStore().request?.getLocaleCode();\n  }\n\n  if (Array.isArray(values)) {\n    return values.find((value) => value.localeCode === localeCode)?.[key as keyof LocalizedObject];\n  }\n\n  return values;\n}\n"],"mappings":";;;;;;;AAWA,SAAgB,aAAa,QAA2B,YAAqB,MAAM,SAAS;CAC1F,IAAI,CAAC,QAAQ,OAAO;CAEpB,IAAI,CAAC,YACH,aAAa,gBAAgB,CAAC,CAAC,SAAS,cAAc;CAGxD,IAAI,MAAM,QAAQ,MAAM,GACtB,OAAO,OAAO,MAAM,UAAU,MAAM,eAAe,UAAU,CAAC,GAAG;CAGnE,OAAO;AACT"}

package/esm/utils/is-test-file.mjs

@@ -1,4 +1,4 @@
-//#region ../core/src/utils/is-test-file.ts
+//#region ../../packages/core/src/utils/is-test-file.ts
 /** `foo.spec.ts`, `foo.test.tsx`, `foo.spec.mjs` … — a file only a test runner can load. */
 const TEST_FILE = /\.(spec|test)\.[cm]?[jt]sx?$/;
 /**

package/esm/utils/is-test-file.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-test-file.mjs","names":[],"sources":["../../../../../../../core/src/utils/is-test-file.ts"],"sourcesContent":["/** `foo.spec.ts`, `foo.test.tsx`, `foo.spec.mjs` … — a file only a test runner can load. */\nconst TEST_FILE = /\\.(spec|test)\\.[cm]?[jt]sx?$/;\n\n/**\n * Whether a path names a test file. Folder-scanning commands (`warlock seed`,\n * `warlock migrate`) skip these: a spec that sits beside the seeder it tests\n * calls `vi.mock()` at import time, which throws outside Vitest.\n */\nexport function isTestFile(filePath: string): boolean {\n  return TEST_FILE.test(filePath);\n}\n"],"mappings":";;AACA,MAAM,YAAY;;;;;;AAOlB,SAAgB,WAAW,UAA2B;CACpD,OAAO,UAAU,KAAK,QAAQ;AAChC"}
+{"version":3,"file":"is-test-file.mjs","names":[],"sources":["../../../../../../../../packages/core/src/utils/is-test-file.ts"],"sourcesContent":["/** `foo.spec.ts`, `foo.test.tsx`, `foo.spec.mjs` … — a file only a test runner can load. */\nconst TEST_FILE = /\\.(spec|test)\\.[cm]?[jt]sx?$/;\n\n/**\n * Whether a path names a test file. Folder-scanning commands (`warlock seed`,\n * `warlock migrate`) skip these: a spec that sits beside the seeder it tests\n * calls `vi.mock()` at import time, which throws outside Vitest.\n */\nexport function isTestFile(filePath: string): boolean {\n  return TEST_FILE.test(filePath);\n}\n"],"mappings":";;AACA,MAAM,YAAY;;;;;;AAOlB,SAAgB,WAAW,UAA2B;CACpD,OAAO,UAAU,KAAK,QAAQ;AAChC"}

package/esm/utils/load-environment.mjs

@@ -5,7 +5,7 @@ import { loadEnv } from "@mongez/dotenv";
 import path from "node:path";
 import { existsSync } from "node:fs";
 
-//#region ../core/src/utils/load-environment.ts
+//#region ../../packages/core/src/utils/load-environment.ts
 /**
 * Core's env precedence policy, in one place because two callers load env:
 * this module at boot, and the dev server when an `.env` file changes.

package/esm/utils/load-environment.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"load-environment.mjs","names":[],"sources":["../../../../../../../core/src/utils/load-environment.ts"],"sourcesContent":["import { loadEnv, type EnvLoaderOptions } from \"@mongez/dotenv\";\nimport { existsSync } from \"node:fs\";\nimport path from \"node:path\";\nimport { detectEnvironmentOverrides } from \"./detect-environment-overrides\";\nimport { recordEnvironmentOverrides } from \"./recorded-environment-overrides\";\nimport { reportEnvironmentOverrides } from \"./report-environment-overrides\";\n\n/**\n * Core's env precedence policy, in one place because two callers load env:\n * this module at boot, and the dev server when an `.env` file changes.\n *\n * `@mongez/dotenv` defaults to `precedence: \"file-wins\"`, which is backwards.\n * The `.env` file is a checked-in DEFAULT; a variable already exported into\n * `process.env` is the deliberate, situational override — a second instance on\n * another port, CI pointed at another database, a container's configuration.\n * Under the default, `PORT=6060 warlock dev` produced a server on the `.env`\n * file's 3000 and said nothing. A default that silently beats an explicit\n * instruction is the wrong way round, so core opts into `process-wins`:\n * the file supplies only the keys the environment does not already carry.\n *\n * EMPTY STRING — `FOO=` in the environment counts as SET, and wins, so the\n * file's value is discarded and `env(\"FOO\")` returns `\"\"`. Chosen over\n * \"empty means absent\" because the loader cannot tell a deliberate blanking\n * from an accident, and only one of the two readings is expressible: an\n * operator who wants the file's value can unset the variable, whereas under\n * \"empty means absent\" an operator who wants a blank value has no way to ask\n * for one. It also matches POSIX (an exported empty variable is set), dotenv,\n * dotenv-flow and Vite. Note the consequence: a blank export beats the second\n * argument too, so `env(\"FOO\", \"fallback\")` yields `\"\"`, not the fallback.\n *\n * Keys this loader itself wrote are tracked by the library and are NOT treated\n * as process-provided, so editing `.env` during a dev session still takes\n * effect on reload rather than being pinned by the previous load's own writes.\n */\nexport const environmentLoaderOptions: EnvLoaderOptions = {\n  precedence: \"process-wins\",\n};\n\n/**\n * The files `loadEnv()` will look for, in the order it considers them.\n *\n * Mirrors `@mongez/dotenv`'s own resolution — `.env.shared` first, then\n * `.env.<NODE_ENV>` if it exists, else plain `.env` — because the presence\n * check has to ask the same question the loader is about to ask.\n */\nfunction candidateEnvFiles(directory: string): string[] {\n  const files = [path.join(directory, \".env\"), path.join(directory, \".env.shared\")];\n\n  if (process.env.NODE_ENV) {\n    files.push(path.join(directory, `.env.${process.env.NODE_ENV}`));\n  }\n\n  return files;\n}\n\n/**\n * The files `loadEnv()` will actually read, in its own read order.\n *\n * Differs from {@link candidateEnvFiles}, which lists every candidate to\n * answer \"is there anything to load at all\". `loadEnv()` itself only ever\n * reads `.env.shared` (if present) plus ONE of `.env.<NODE_ENV>` /\n * `.env` — the NODE_ENV-specific file when it exists, `.env` otherwise —\n * never both. Override detection has to mirror that exactly, or a key\n * declared only in a file `loadEnv()` would not have touched could be\n * reported as having \"lost\" a comparison it was never actually part of.\n */\nfunction resolveLoadedEnvFiles(directory: string): string[] {\n  const files: string[] = [];\n  const sharedFile = path.join(directory, \".env.shared\");\n\n  if (existsSync(sharedFile)) {\n    files.push(sharedFile);\n  }\n\n  const nodeEnvFile = process.env.NODE_ENV\n    ? path.join(directory, `.env.${process.env.NODE_ENV}`)\n    : undefined;\n  const derivedFile =\n    nodeEnvFile && existsSync(nodeEnvFile) ? nodeEnvFile : path.join(directory, \".env\");\n\n  if (existsSync(derivedFile)) {\n    files.push(derivedFile);\n  }\n\n  return files;\n}\n\n/**\n * Whether this process has already loaded its env files.\n *\n * Two callers reach here on a bootstrapping command — the CLI preload phase and\n * `bootstrap()` — and `loadEnv()` defaults to `override: true`, so a second pass\n * re-parses the same files and re-writes `process.env`. Anything set in between\n * (a `warlock.config.ts` module body, a config file, an orchestrator) would be\n * silently clobbered by the later load. Same shape as the defect where a\n * caller's test-server port was overwritten by a re-read of `.env`.\n *\n * A deliberate reload is still possible and still used: the dev server calls\n * `loadEnv()` directly when an `.env` file changes on disk, which is a reload\n * the user asked for rather than an accidental second pass.\n */\nlet environmentLoaded = false;\n\n/**\n * Load `.env` files when there are any, and do nothing when there are not.\n *\n * Loads at most **once per process** — see {@link environmentLoaded}.\n *\n * `@mongez/dotenv`'s `loadEnvFile` **throws** when the file is absent. That was\n * survivable while only `dev` loaded env; now that every command loads it —\n * because `warlock.config.ts` calls `env()` in its module body and had been\n * evaluated against an empty store under every command — an unguarded call\n * would turn \"this project has no .env\" from a non-event into a hard failure\n * of `warlock build`. A project without a `.env` is legitimate: config files\n * carry defaults, and containers inject their own variables.\n *\n * The guard lives here rather than waiting on a fix in `@mongez/dotenv`: core\n * decides its own env policy and must not depend on another package's release\n * schedule to avoid crashing a working build.\n */\nexport async function loadEnvironmentFiles(directory: string = process.cwd()): Promise<void> {\n  if (environmentLoaded) {\n    return;\n  }\n\n  const hasEnvFile = candidateEnvFiles(directory).some((file) => existsSync(file));\n\n  if (!hasEnvFile) {\n    // Not latched: a project may create its `.env` between a command's preload\n    // and its bootstrap, and there is nothing to protect from a second override\n    // when the first pass loaded nothing.\n    return;\n  }\n\n  environmentLoaded = true;\n\n  // Snapshot BEFORE `loadEnv()` runs: the loader writes into `process.env` for\n  // every key its files supply, so a snapshot taken afterwards could no\n  // longer distinguish an ambient override from a value the loader itself\n  // just wrote — see `detectEnvironmentOverrides`.\n  const processEnvironmentSnapshot = { ...process.env };\n\n  // The precedence itself is correct (see `environmentLoaderOptions` above);\n  // the defect this guards against is the SILENCE — `.env` losing to an\n  // ambient value with no diagnostic at all.\n  const overrides = detectEnvironmentOverrides(\n    resolveLoadedEnvFiles(directory),\n    processEnvironmentSnapshot,\n  );\n\n  // Print the overrides here AND retain them: a later point in the boot (the\n  // port-collision reporter) needs to know an ambient `HTTP_PORT` beat `.env`\n  // to avoid advising a rebuild that the env var would just override again —\n  // see `recorded-environment-overrides.ts` (finding 8782b840).\n  recordEnvironmentOverrides(overrides);\n  reportEnvironmentOverrides(overrides);\n\n  // `dir` has to be forwarded: `loadEnv()` defaults it to `process.cwd()`, so\n  // without this the existence check above asks about `directory` while the\n  // load itself reads somewhere else entirely. Identical in production, where\n  // `directory` IS `process.cwd()`.\n  await loadEnv(undefined, { ...environmentLoaderOptions, dir: directory });\n}\n\n/**\n * Forget that env has been loaded, so the next call loads again.\n *\n * @internal For tests, which run many boots inside one process.\n */\nexport function resetLoadedEnvironment(): void {\n  environmentLoaded = false;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,MAAa,2BAA6C,EACxD,YAAY,eACd;;;;;;;;AASA,SAAS,kBAAkB,WAA6B;CACtD,MAAM,QAAQ,CAAC,KAAK,KAAK,WAAW,MAAM,GAAG,KAAK,KAAK,WAAW,aAAa,CAAC;CAEhF,IAAI,QAAQ,IAAI,UACd,MAAM,KAAK,KAAK,KAAK,WAAW,QAAQ,QAAQ,IAAI,UAAU,CAAC;CAGjE,OAAO;AACT;;;;;;;;;;;;AAaA,SAAS,sBAAsB,WAA6B;CAC1D,MAAM,QAAkB,CAAC;CACzB,MAAM,aAAa,KAAK,KAAK,WAAW,aAAa;CAErD,IAAI,WAAW,UAAU,GACvB,MAAM,KAAK,UAAU;CAGvB,MAAM,cAAc,QAAQ,IAAI,WAC5B,KAAK,KAAK,WAAW,QAAQ,QAAQ,IAAI,UAAU,IACnD;CACJ,MAAM,cACJ,eAAe,WAAW,WAAW,IAAI,cAAc,KAAK,KAAK,WAAW,MAAM;CAEpF,IAAI,WAAW,WAAW,GACxB,MAAM,KAAK,WAAW;CAGxB,OAAO;AACT;;;;;;;;;;;;;;;AAgBA,IAAI,oBAAoB;;;;;;;;;;;;;;;;;;AAmBxB,eAAsB,qBAAqB,YAAoB,QAAQ,IAAI,GAAkB;CAC3F,IAAI,mBACF;CAKF,IAAI,CAFe,kBAAkB,SAAS,CAAC,CAAC,MAAM,SAAS,WAAW,IAAI,CAEhE,GAIZ;CAGF,oBAAoB;CAMpB,MAAM,6BAA6B,EAAE,GAAG,QAAQ,IAAI;CAKpD,MAAM,YAAY,2BAChB,sBAAsB,SAAS,GAC/B,0BACF;CAMA,2BAA2B,SAAS;CACpC,2BAA2B,SAAS;CAMpC,MAAM,QAAQ,QAAW;EAAE,GAAG;EAA0B,KAAK;CAAU,CAAC;AAC1E"}
+{"version":3,"file":"load-environment.mjs","names":[],"sources":["../../../../../../../../packages/core/src/utils/load-environment.ts"],"sourcesContent":["import { loadEnv, type EnvLoaderOptions } from \"@mongez/dotenv\";\nimport { existsSync } from \"node:fs\";\nimport path from \"node:path\";\nimport { detectEnvironmentOverrides } from \"./detect-environment-overrides\";\nimport { recordEnvironmentOverrides } from \"./recorded-environment-overrides\";\nimport { reportEnvironmentOverrides } from \"./report-environment-overrides\";\n\n/**\n * Core's env precedence policy, in one place because two callers load env:\n * this module at boot, and the dev server when an `.env` file changes.\n *\n * `@mongez/dotenv` defaults to `precedence: \"file-wins\"`, which is backwards.\n * The `.env` file is a checked-in DEFAULT; a variable already exported into\n * `process.env` is the deliberate, situational override — a second instance on\n * another port, CI pointed at another database, a container's configuration.\n * Under the default, `PORT=6060 warlock dev` produced a server on the `.env`\n * file's 3000 and said nothing. A default that silently beats an explicit\n * instruction is the wrong way round, so core opts into `process-wins`:\n * the file supplies only the keys the environment does not already carry.\n *\n * EMPTY STRING — `FOO=` in the environment counts as SET, and wins, so the\n * file's value is discarded and `env(\"FOO\")` returns `\"\"`. Chosen over\n * \"empty means absent\" because the loader cannot tell a deliberate blanking\n * from an accident, and only one of the two readings is expressible: an\n * operator who wants the file's value can unset the variable, whereas under\n * \"empty means absent\" an operator who wants a blank value has no way to ask\n * for one. It also matches POSIX (an exported empty variable is set), dotenv,\n * dotenv-flow and Vite. Note the consequence: a blank export beats the second\n * argument too, so `env(\"FOO\", \"fallback\")` yields `\"\"`, not the fallback.\n *\n * Keys this loader itself wrote are tracked by the library and are NOT treated\n * as process-provided, so editing `.env` during a dev session still takes\n * effect on reload rather than being pinned by the previous load's own writes.\n */\nexport const environmentLoaderOptions: EnvLoaderOptions = {\n  precedence: \"process-wins\",\n};\n\n/**\n * The files `loadEnv()` will look for, in the order it considers them.\n *\n * Mirrors `@mongez/dotenv`'s own resolution — `.env.shared` first, then\n * `.env.<NODE_ENV>` if it exists, else plain `.env` — because the presence\n * check has to ask the same question the loader is about to ask.\n */\nfunction candidateEnvFiles(directory: string): string[] {\n  const files = [path.join(directory, \".env\"), path.join(directory, \".env.shared\")];\n\n  if (process.env.NODE_ENV) {\n    files.push(path.join(directory, `.env.${process.env.NODE_ENV}`));\n  }\n\n  return files;\n}\n\n/**\n * The files `loadEnv()` will actually read, in its own read order.\n *\n * Differs from {@link candidateEnvFiles}, which lists every candidate to\n * answer \"is there anything to load at all\". `loadEnv()` itself only ever\n * reads `.env.shared` (if present) plus ONE of `.env.<NODE_ENV>` /\n * `.env` — the NODE_ENV-specific file when it exists, `.env` otherwise —\n * never both. Override detection has to mirror that exactly, or a key\n * declared only in a file `loadEnv()` would not have touched could be\n * reported as having \"lost\" a comparison it was never actually part of.\n */\nfunction resolveLoadedEnvFiles(directory: string): string[] {\n  const files: string[] = [];\n  const sharedFile = path.join(directory, \".env.shared\");\n\n  if (existsSync(sharedFile)) {\n    files.push(sharedFile);\n  }\n\n  const nodeEnvFile = process.env.NODE_ENV\n    ? path.join(directory, `.env.${process.env.NODE_ENV}`)\n    : undefined;\n  const derivedFile =\n    nodeEnvFile && existsSync(nodeEnvFile) ? nodeEnvFile : path.join(directory, \".env\");\n\n  if (existsSync(derivedFile)) {\n    files.push(derivedFile);\n  }\n\n  return files;\n}\n\n/**\n * Whether this process has already loaded its env files.\n *\n * Two callers reach here on a bootstrapping command — the CLI preload phase and\n * `bootstrap()` — and `loadEnv()` defaults to `override: true`, so a second pass\n * re-parses the same files and re-writes `process.env`. Anything set in between\n * (a `warlock.config.ts` module body, a config file, an orchestrator) would be\n * silently clobbered by the later load. Same shape as the defect where a\n * caller's test-server port was overwritten by a re-read of `.env`.\n *\n * A deliberate reload is still possible and still used: the dev server calls\n * `loadEnv()` directly when an `.env` file changes on disk, which is a reload\n * the user asked for rather than an accidental second pass.\n */\nlet environmentLoaded = false;\n\n/**\n * Load `.env` files when there are any, and do nothing when there are not.\n *\n * Loads at most **once per process** — see {@link environmentLoaded}.\n *\n * `@mongez/dotenv`'s `loadEnvFile` **throws** when the file is absent. That was\n * survivable while only `dev` loaded env; now that every command loads it —\n * because `warlock.config.ts` calls `env()` in its module body and had been\n * evaluated against an empty store under every command — an unguarded call\n * would turn \"this project has no .env\" from a non-event into a hard failure\n * of `warlock build`. A project without a `.env` is legitimate: config files\n * carry defaults, and containers inject their own variables.\n *\n * The guard lives here rather than waiting on a fix in `@mongez/dotenv`: core\n * decides its own env policy and must not depend on another package's release\n * schedule to avoid crashing a working build.\n */\nexport async function loadEnvironmentFiles(directory: string = process.cwd()): Promise<void> {\n  if (environmentLoaded) {\n    return;\n  }\n\n  const hasEnvFile = candidateEnvFiles(directory).some((file) => existsSync(file));\n\n  if (!hasEnvFile) {\n    // Not latched: a project may create its `.env` between a command's preload\n    // and its bootstrap, and there is nothing to protect from a second override\n    // when the first pass loaded nothing.\n    return;\n  }\n\n  environmentLoaded = true;\n\n  // Snapshot BEFORE `loadEnv()` runs: the loader writes into `process.env` for\n  // every key its files supply, so a snapshot taken afterwards could no\n  // longer distinguish an ambient override from a value the loader itself\n  // just wrote — see `detectEnvironmentOverrides`.\n  const processEnvironmentSnapshot = { ...process.env };\n\n  // The precedence itself is correct (see `environmentLoaderOptions` above);\n  // the defect this guards against is the SILENCE — `.env` losing to an\n  // ambient value with no diagnostic at all.\n  const overrides = detectEnvironmentOverrides(\n    resolveLoadedEnvFiles(directory),\n    processEnvironmentSnapshot,\n  );\n\n  // Print the overrides here AND retain them: a later point in the boot (the\n  // port-collision reporter) needs to know an ambient `HTTP_PORT` beat `.env`\n  // to avoid advising a rebuild that the env var would just override again —\n  // see `recorded-environment-overrides.ts` (finding 8782b840).\n  recordEnvironmentOverrides(overrides);\n  reportEnvironmentOverrides(overrides);\n\n  // `dir` has to be forwarded: `loadEnv()` defaults it to `process.cwd()`, so\n  // without this the existence check above asks about `directory` while the\n  // load itself reads somewhere else entirely. Identical in production, where\n  // `directory` IS `process.cwd()`.\n  await loadEnv(undefined, { ...environmentLoaderOptions, dir: directory });\n}\n\n/**\n * Forget that env has been loaded, so the next call loads again.\n *\n * @internal For tests, which run many boots inside one process.\n */\nexport function resetLoadedEnvironment(): void {\n  environmentLoaded = false;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,MAAa,2BAA6C,EACxD,YAAY,eACd;;;;;;;;AASA,SAAS,kBAAkB,WAA6B;CACtD,MAAM,QAAQ,CAAC,KAAK,KAAK,WAAW,MAAM,GAAG,KAAK,KAAK,WAAW,aAAa,CAAC;CAEhF,IAAI,QAAQ,IAAI,UACd,MAAM,KAAK,KAAK,KAAK,WAAW,QAAQ,QAAQ,IAAI,UAAU,CAAC;CAGjE,OAAO;AACT;;;;;;;;;;;;AAaA,SAAS,sBAAsB,WAA6B;CAC1D,MAAM,QAAkB,CAAC;CACzB,MAAM,aAAa,KAAK,KAAK,WAAW,aAAa;CAErD,IAAI,WAAW,UAAU,GACvB,MAAM,KAAK,UAAU;CAGvB,MAAM,cAAc,QAAQ,IAAI,WAC5B,KAAK,KAAK,WAAW,QAAQ,QAAQ,IAAI,UAAU,IACnD;CACJ,MAAM,cACJ,eAAe,WAAW,WAAW,IAAI,cAAc,KAAK,KAAK,WAAW,MAAM;CAEpF,IAAI,WAAW,WAAW,GACxB,MAAM,KAAK,WAAW;CAGxB,OAAO;AACT;;;;;;;;;;;;;;;AAgBA,IAAI,oBAAoB;;;;;;;;;;;;;;;;;;AAmBxB,eAAsB,qBAAqB,YAAoB,QAAQ,IAAI,GAAkB;CAC3F,IAAI,mBACF;CAKF,IAAI,CAFe,kBAAkB,SAAS,CAAC,CAAC,MAAM,SAAS,WAAW,IAAI,CAEhE,GAIZ;CAGF,oBAAoB;CAMpB,MAAM,6BAA6B,EAAE,GAAG,QAAQ,IAAI;CAKpD,MAAM,YAAY,2BAChB,sBAAsB,SAAS,GAC/B,0BACF;CAMA,2BAA2B,SAAS;CACpC,2BAA2B,SAAS;CAMpC,MAAM,QAAQ,QAAW;EAAE,GAAG;EAA0B,KAAK;CAAU,CAAC;AAC1E"}

package/esm/utils/normalized-path.d.mts

@@ -1,4 +1,4 @@
-//#region ../core/src/utils/normalized-path.d.ts
+//#region ../../packages/core/src/utils/normalized-path.d.ts
 /**
  * Path helpers that always hand back forward slashes.
  *

package/esm/utils/normalized-path.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"normalized-path.d.mts","names":[],"sources":["../../../../../../../core/src/utils/normalized-path.ts"],"mappings":";;AAeA;;;;;;;;;;;;cAAa,IAAA;EAgCa;;;EAAA,OA5BV,UAAA,CAAW,YAAA;EA4CH;;;EAAA,OArCR,QAAA,CAAS,YAAA;EAmDT;;;EAAA,OA5CA,oBAAA,CAAqB,YAAA;;;;SAOrB,UAAA,CAAW,YAAA;;;;SAOX,SAAA,CAAU,QAAA;;;;SAOV,IAAA,IAAQ,KAAA;;;;;;SASR,OAAA,CAAQ,QAAA;;;;SAOR,QAAA,CAAS,QAAA,UAAkB,GAAA;;;;SAO3B,OAAA,CAAQ,QAAA;AAAA"}
+{"version":3,"file":"normalized-path.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/utils/normalized-path.ts"],"mappings":";;AAeA;;;;;;;;;;;;cAAa,IAAA;EAgCa;;;EAAA,OA5BV,UAAA,CAAW,YAAA;EA4CH;;;EAAA,OArCR,QAAA,CAAS,YAAA;EAmDT;;;EAAA,OA5CA,oBAAA,CAAqB,YAAA;;;;SAOrB,UAAA,CAAW,YAAA;;;;SAOX,SAAA,CAAU,QAAA;;;;SAOV,IAAA,IAAQ,KAAA;;;;;;SASR,OAAA,CAAQ,QAAA;;;;SAOR,QAAA,CAAS,QAAA,UAAkB,GAAA;;;;SAO3B,OAAA,CAAQ,QAAA;AAAA"}

package/esm/utils/normalized-path.mjs

@@ -1,6 +1,6 @@
 import path from "node:path";
 
-//#region ../core/src/utils/normalized-path.ts
+//#region ../../packages/core/src/utils/normalized-path.ts
 /**
 * Path helpers that always hand back forward slashes.
 *

package/esm/utils/normalized-path.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"normalized-path.mjs","names":[],"sources":["../../../../../../../core/src/utils/normalized-path.ts"],"sourcesContent":["import path from \"node:path\";\n\n/**\n * Path helpers that always hand back forward slashes.\n *\n * Node's `path` returns `\\` on Windows, and these values are compared against\n * module specifiers, glob results and map keys — all of which use `/`. A raw\n * `path.relative()` therefore produces a string that looks right in a log and\n * fails every lookup it is used for.\n *\n * This lived under `dev-server/` and was imported from there by production\n * modules (`connectors`, `database`, `config`), which put the whole dev-server\n * directory into the production module graph. The code was never dev-only —\n * only its location was.\n */\nexport class Path {\n  /**\n   * Convert the given absolute path to a relative path\n   */\n  public static toRelative(absolutePath: string) {\n    return this.normalize(path.relative(process.cwd(), absolutePath));\n  }\n\n  /**\n   * Get relative path of the given path\n   */\n  public static relative(relativePath: string) {\n    return this.normalize(path.relative(process.cwd(), relativePath));\n  }\n\n  /**\n   * Get normalized absolute path of the given path\n   */\n  public static toNormalizedAbsolute(relativePath: string) {\n    return this.normalize(path.resolve(process.cwd(), relativePath));\n  }\n\n  /**\n   * Get absolute path of the given path\n   */\n  public static toAbsolute(relativePath: string) {\n    return this.normalize(path.resolve(process.cwd(), relativePath));\n  }\n\n  /**\n   * Normalize the given path (convert backslashes to forward slashes)\n   */\n  public static normalize(filePath: string) {\n    return filePath.replace(/\\\\/g, \"/\");\n  }\n\n  /**\n   * Join paths and normalize\n   */\n  public static join(...paths: string[]) {\n    return this.normalize(path.join(...paths));\n  }\n\n  /**\n   * Get directory name of a path. The input is normalized first: on POSIX a\n   * backslash is a filename character, so `a\\b\\c.ts` would otherwise have no\n   * directory at all.\n   */\n  public static dirname(filePath: string) {\n    return this.normalize(path.dirname(this.normalize(filePath)));\n  }\n\n  /**\n   * Get base name of a path\n   */\n  public static basename(filePath: string, ext?: string) {\n    return path.basename(filePath, ext);\n  }\n\n  /**\n   * Get extension of a path\n   */\n  public static extname(filePath: string) {\n    return path.extname(filePath);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAeA,IAAa,OAAb,MAAkB;;;;CAIhB,OAAc,WAAW,cAAsB;EAC7C,OAAO,KAAK,UAAU,KAAK,SAAS,QAAQ,IAAI,GAAG,YAAY,CAAC;CAClE;;;;CAKA,OAAc,SAAS,cAAsB;EAC3C,OAAO,KAAK,UAAU,KAAK,SAAS,QAAQ,IAAI,GAAG,YAAY,CAAC;CAClE;;;;CAKA,OAAc,qBAAqB,cAAsB;EACvD,OAAO,KAAK,UAAU,KAAK,QAAQ,QAAQ,IAAI,GAAG,YAAY,CAAC;CACjE;;;;CAKA,OAAc,WAAW,cAAsB;EAC7C,OAAO,KAAK,UAAU,KAAK,QAAQ,QAAQ,IAAI,GAAG,YAAY,CAAC;CACjE;;;;CAKA,OAAc,UAAU,UAAkB;EACxC,OAAO,SAAS,QAAQ,OAAO,GAAG;CACpC;;;;CAKA,OAAc,KAAK,GAAG,OAAiB;EACrC,OAAO,KAAK,UAAU,KAAK,KAAK,GAAG,KAAK,CAAC;CAC3C;;;;;;CAOA,OAAc,QAAQ,UAAkB;EACtC,OAAO,KAAK,UAAU,KAAK,QAAQ,KAAK,UAAU,QAAQ,CAAC,CAAC;CAC9D;;;;CAKA,OAAc,SAAS,UAAkB,KAAc;EACrD,OAAO,KAAK,SAAS,UAAU,GAAG;CACpC;;;;CAKA,OAAc,QAAQ,UAAkB;EACtC,OAAO,KAAK,QAAQ,QAAQ;CAC9B;AACF"}
+{"version":3,"file":"normalized-path.mjs","names":[],"sources":["../../../../../../../../packages/core/src/utils/normalized-path.ts"],"sourcesContent":["import path from \"node:path\";\n\n/**\n * Path helpers that always hand back forward slashes.\n *\n * Node's `path` returns `\\` on Windows, and these values are compared against\n * module specifiers, glob results and map keys — all of which use `/`. A raw\n * `path.relative()` therefore produces a string that looks right in a log and\n * fails every lookup it is used for.\n *\n * This lived under `dev-server/` and was imported from there by production\n * modules (`connectors`, `database`, `config`), which put the whole dev-server\n * directory into the production module graph. The code was never dev-only —\n * only its location was.\n */\nexport class Path {\n  /**\n   * Convert the given absolute path to a relative path\n   */\n  public static toRelative(absolutePath: string) {\n    return this.normalize(path.relative(process.cwd(), absolutePath));\n  }\n\n  /**\n   * Get relative path of the given path\n   */\n  public static relative(relativePath: string) {\n    return this.normalize(path.relative(process.cwd(), relativePath));\n  }\n\n  /**\n   * Get normalized absolute path of the given path\n   */\n  public static toNormalizedAbsolute(relativePath: string) {\n    return this.normalize(path.resolve(process.cwd(), relativePath));\n  }\n\n  /**\n   * Get absolute path of the given path\n   */\n  public static toAbsolute(relativePath: string) {\n    return this.normalize(path.resolve(process.cwd(), relativePath));\n  }\n\n  /**\n   * Normalize the given path (convert backslashes to forward slashes)\n   */\n  public static normalize(filePath: string) {\n    return filePath.replace(/\\\\/g, \"/\");\n  }\n\n  /**\n   * Join paths and normalize\n   */\n  public static join(...paths: string[]) {\n    return this.normalize(path.join(...paths));\n  }\n\n  /**\n   * Get directory name of a path. The input is normalized first: on POSIX a\n   * backslash is a filename character, so `a\\b\\c.ts` would otherwise have no\n   * directory at all.\n   */\n  public static dirname(filePath: string) {\n    return this.normalize(path.dirname(this.normalize(filePath)));\n  }\n\n  /**\n   * Get base name of a path\n   */\n  public static basename(filePath: string, ext?: string) {\n    return path.basename(filePath, ext);\n  }\n\n  /**\n   * Get extension of a path\n   */\n  public static extname(filePath: string) {\n    return path.extname(filePath);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAeA,IAAa,OAAb,MAAkB;;;;CAIhB,OAAc,WAAW,cAAsB;EAC7C,OAAO,KAAK,UAAU,KAAK,SAAS,QAAQ,IAAI,GAAG,YAAY,CAAC;CAClE;;;;CAKA,OAAc,SAAS,cAAsB;EAC3C,OAAO,KAAK,UAAU,KAAK,SAAS,QAAQ,IAAI,GAAG,YAAY,CAAC;CAClE;;;;CAKA,OAAc,qBAAqB,cAAsB;EACvD,OAAO,KAAK,UAAU,KAAK,QAAQ,QAAQ,IAAI,GAAG,YAAY,CAAC;CACjE;;;;CAKA,OAAc,WAAW,cAAsB;EAC7C,OAAO,KAAK,UAAU,KAAK,QAAQ,QAAQ,IAAI,GAAG,YAAY,CAAC;CACjE;;;;CAKA,OAAc,UAAU,UAAkB;EACxC,OAAO,SAAS,QAAQ,OAAO,GAAG;CACpC;;;;CAKA,OAAc,KAAK,GAAG,OAAiB;EACrC,OAAO,KAAK,UAAU,KAAK,KAAK,GAAG,KAAK,CAAC;CAC3C;;;;;;CAOA,OAAc,QAAQ,UAAkB;EACtC,OAAO,KAAK,UAAU,KAAK,QAAQ,KAAK,UAAU,QAAQ,CAAC,CAAC;CAC9D;;;;CAKA,OAAc,SAAS,UAAkB,KAAc;EACrD,OAAO,KAAK,SAAS,UAAU,GAAG;CACpC;;;;CAKA,OAAc,QAAQ,UAAkB;EACtC,OAAO,KAAK,QAAQ,QAAQ;CAC9B;AACF"}

package/esm/utils/npm-registry.d.mts

@@ -1,4 +1,4 @@
-//#region ../core/src/utils/npm-registry.d.ts
+//#region ../../packages/core/src/utils/npm-registry.d.ts
 /**
  * Minimal npm-registry access for the framework's self-update tooling
  * (the dev-server update notice + the `warlock update` command).

package/esm/utils/npm-registry.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"npm-registry.d.mts","names":[],"sources":["../../../../../../../core/src/utils/npm-registry.ts"],"mappings":";;AAwBA;;;;;;;;AAGU;;;;;;;;;;iBAHY,kBAAA,CACpB,WAAA,UACA,SAAA,YACC,OAAO"}
+{"version":3,"file":"npm-registry.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/utils/npm-registry.ts"],"mappings":";;AAwBA;;;;;;;;AAGU;;;;;;;;;;iBAHY,kBAAA,CACpB,WAAA,UACA,SAAA,YACC,OAAO"}

package/esm/utils/npm-registry.mjs

@@ -1,4 +1,4 @@
-//#region ../core/src/utils/npm-registry.ts
+//#region ../../packages/core/src/utils/npm-registry.ts
 /**
 * Minimal npm-registry access for the framework's self-update tooling
 * (the dev-server update notice + the `warlock update` command).

package/esm/utils/npm-registry.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"npm-registry.mjs","names":[],"sources":["../../../../../../../core/src/utils/npm-registry.ts"],"sourcesContent":["/**\n * Minimal npm-registry access for the framework's self-update tooling\n * (the dev-server update notice + the `warlock update` command).\n *\n * No SDK and no caching layer — just the public registry over `fetch`.\n * Every lookup is best-effort: any failure resolves to `undefined` so a\n * registry hiccup can never break the dev server or the CLI.\n */\n\nconst REGISTRY_BASE_URL = \"https://registry.npmjs.org\";\n\nconst DEFAULT_TIMEOUT_MS = 30_000;\n\n/**\n * Fetch the latest published version of a package from the npm registry.\n *\n * Hits the abbreviated `/<package>/latest` endpoint, which returns only the\n * latest dist-tag manifest (not the full packument). Resolves to `undefined`\n * on any failure — offline, timeout, non-200 response, or malformed payload —\n * and never throws, so callers can stay fail-silent.\n *\n * @param packageName Fully-qualified npm name, e.g. `@warlock.js/core`.\n * @param timeoutMs   Abort budget in milliseconds (defaults to 30_000 -> 30 seconds).\n */\nexport async function fetchLatestVersion(\n  packageName: string,\n  timeoutMs: number = DEFAULT_TIMEOUT_MS,\n): Promise<string | undefined> {\n  const controller = new AbortController();\n  const timer = setTimeout(() => controller.abort(), timeoutMs);\n\n  try {\n    const response = await fetch(`${REGISTRY_BASE_URL}/${packageName}/latest`, {\n      signal: controller.signal,\n      headers: { accept: \"application/json\" },\n    });\n\n    if (!response.ok) {\n      return undefined;\n    }\n\n    const data = (await response.json()) as { version?: unknown };\n\n    return typeof data.version === \"string\" ? data.version : undefined;\n  } catch {\n    // Best-effort: offline, DNS failure, abort/timeout, or bad JSON — all \"unknown\".\n    return undefined;\n  } finally {\n    clearTimeout(timer);\n  }\n}\n"],"mappings":";;;;;;;;;AASA,MAAM,oBAAoB;AAE1B,MAAM,qBAAqB;;;;;;;;;;;;AAa3B,eAAsB,mBACpB,aACA,YAAoB,oBACS;CAC7B,MAAM,aAAa,IAAI,gBAAgB;CACvC,MAAM,QAAQ,iBAAiB,WAAW,MAAM,GAAG,SAAS;CAE5D,IAAI;EACF,MAAM,WAAW,MAAM,MAAM,GAAG,kBAAkB,GAAG,YAAY,UAAU;GACzE,QAAQ,WAAW;GACnB,SAAS,EAAE,QAAQ,mBAAmB;EACxC,CAAC;EAED,IAAI,CAAC,SAAS,IACZ;EAGF,MAAM,OAAQ,MAAM,SAAS,KAAK;EAElC,OAAO,OAAO,KAAK,YAAY,WAAW,KAAK,UAAU;CAC3D,QAAQ;EAEN;CACF,UAAU;EACR,aAAa,KAAK;CACpB;AACF"}
+{"version":3,"file":"npm-registry.mjs","names":[],"sources":["../../../../../../../../packages/core/src/utils/npm-registry.ts"],"sourcesContent":["/**\n * Minimal npm-registry access for the framework's self-update tooling\n * (the dev-server update notice + the `warlock update` command).\n *\n * No SDK and no caching layer — just the public registry over `fetch`.\n * Every lookup is best-effort: any failure resolves to `undefined` so a\n * registry hiccup can never break the dev server or the CLI.\n */\n\nconst REGISTRY_BASE_URL = \"https://registry.npmjs.org\";\n\nconst DEFAULT_TIMEOUT_MS = 30_000;\n\n/**\n * Fetch the latest published version of a package from the npm registry.\n *\n * Hits the abbreviated `/<package>/latest` endpoint, which returns only the\n * latest dist-tag manifest (not the full packument). Resolves to `undefined`\n * on any failure — offline, timeout, non-200 response, or malformed payload —\n * and never throws, so callers can stay fail-silent.\n *\n * @param packageName Fully-qualified npm name, e.g. `@warlock.js/core`.\n * @param timeoutMs   Abort budget in milliseconds (defaults to 30_000 -> 30 seconds).\n */\nexport async function fetchLatestVersion(\n  packageName: string,\n  timeoutMs: number = DEFAULT_TIMEOUT_MS,\n): Promise<string | undefined> {\n  const controller = new AbortController();\n  const timer = setTimeout(() => controller.abort(), timeoutMs);\n\n  try {\n    const response = await fetch(`${REGISTRY_BASE_URL}/${packageName}/latest`, {\n      signal: controller.signal,\n      headers: { accept: \"application/json\" },\n    });\n\n    if (!response.ok) {\n      return undefined;\n    }\n\n    const data = (await response.json()) as { version?: unknown };\n\n    return typeof data.version === \"string\" ? data.version : undefined;\n  } catch {\n    // Best-effort: offline, DNS failure, abort/timeout, or bad JSON — all \"unknown\".\n    return undefined;\n  } finally {\n    clearTimeout(timer);\n  }\n}\n"],"mappings":";;;;;;;;;AASA,MAAM,oBAAoB;AAE1B,MAAM,qBAAqB;;;;;;;;;;;;AAa3B,eAAsB,mBACpB,aACA,YAAoB,oBACS;CAC7B,MAAM,aAAa,IAAI,gBAAgB;CACvC,MAAM,QAAQ,iBAAiB,WAAW,MAAM,GAAG,SAAS;CAE5D,IAAI;EACF,MAAM,WAAW,MAAM,MAAM,GAAG,kBAAkB,GAAG,YAAY,UAAU;GACzE,QAAQ,WAAW;GACnB,SAAS,EAAE,QAAQ,mBAAmB;EACxC,CAAC;EAED,IAAI,CAAC,SAAS,IACZ;EAGF,MAAM,OAAQ,MAAM,SAAS,KAAK;EAElC,OAAO,OAAO,KAAK,YAAY,WAAW,KAAK,UAAU;CAC3D,QAAQ;EAEN;CACF,UAAU;EACR,aAAa,KAAK;CACpB;AACF"}

package/esm/utils/paths.d.mts

@@ -1,4 +1,4 @@
-//#region ../core/src/utils/paths.d.ts
+//#region ../../packages/core/src/utils/paths.d.ts
 /**
  * Get root path or join the given paths to the root path
  */

package/esm/utils/paths.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"paths.d.mts","names":[],"sources":["../../../../../../../core/src/utils/paths.ts"],"mappings":";;AAMA;;iBAAgB,QAAA,IAAY,KAAK;;AAAA;AAOjC;iBAAgB,OAAA,IAAW,KAAK;;;AAAA;AAShC;;iBAAgB,WAAA,CAAY,YAAiB;;AAAA;AAS7C;;;iBAAgB,WAAA,CAAY,YAAiB;AAAA;AAgB7C;;;;AAhB6C,iBAgB7B,UAAA,CAAW,YAAiB;AAS5C;;;;AAA2C;AAA3C,iBAAgB,SAAA,CAAU,YAAiB;;;;iBAO3B,OAAA,CAAQ,YAAiB;AAOzC;;;AAAA,iBAAgB,QAAA,CAAS,YAAiB;AAAA;AAO1C;;AAP0C,iBAO1B,QAAA,CAAS,YAAiB;AAAA,iBAS1B,YAAA,CAAa,QAAgB;AATH;AAS1C;;;AAT0C,iBAiB1B,WAAA,IAAe,IAAI;AARU;AAQ7C;;AAR6C,iBAe7B,UAAA,IAAc,IAAI;AAAA,cAIrB,KAAA"}
+{"version":3,"file":"paths.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/utils/paths.ts"],"mappings":";;AAMA;;iBAAgB,QAAA,IAAY,KAAK;;AAAA;AAOjC;iBAAgB,OAAA,IAAW,KAAK;;;AAAA;AAShC;;iBAAgB,WAAA,CAAY,YAAiB;;AAAA;AAS7C;;;iBAAgB,WAAA,CAAY,YAAiB;AAAA;AAgB7C;;;;AAhB6C,iBAgB7B,UAAA,CAAW,YAAiB;AAS5C;;;;AAA2C;AAA3C,iBAAgB,SAAA,CAAU,YAAiB;;;;iBAO3B,OAAA,CAAQ,YAAiB;AAOzC;;;AAAA,iBAAgB,QAAA,CAAS,YAAiB;AAAA;AAO1C;;AAP0C,iBAO1B,QAAA,CAAS,YAAiB;AAAA,iBAS1B,YAAA,CAAa,QAAgB;AATH;AAS1C;;;AAT0C,iBAiB1B,WAAA,IAAe,IAAI;AARU;AAQ7C;;AAR6C,iBAe7B,UAAA,IAAc,IAAI;AAAA,cAIrB,KAAA"}

package/esm/utils/paths.mjs

@@ -1,7 +1,7 @@
 import config from "@mongez/config";
 import path from "path";
 
-//#region ../core/src/utils/paths.ts
+//#region ../../packages/core/src/utils/paths.ts
 /**
 * Get root path or join the given paths to the root path
 */

package/esm/utils/paths.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"paths.mjs","names":[],"sources":["../../../../../../../core/src/utils/paths.ts"],"sourcesContent":["import config from \"@mongez/config\";\nimport path from \"path\";\n\n/**\n * Get root path or join the given paths to the root path\n */\nexport function rootPath(...paths: string[]) {\n  return path.resolve(process.cwd(), ...paths);\n}\n\n/**\n * Get src directory path or join the given paths to the src directory path\n */\nexport function srcPath(...paths: string[]) {\n  return rootPath(\"src\", ...paths);\n}\n\n/**\n * Get the absolute path to the storage folder to the given path\n *\n * If no path is given, it will return the absolute path to the storage folder\n */\nexport function storagePath(relativePath = \"\") {\n  return rootPath(\"storage\", relativePath);\n}\n\n/**\n * Get the absolute path to the uploads folder to the given path\n *\n * If no path is given, it will return the absolute path to the uploads folder\n */\nexport function uploadsPath(relativePath = \"\") {\n  const configPath = config.get(\"uploads.root\");\n  if (!configPath) {\n    return rootPath(\"storage\", \"uploads\", relativePath);\n  }\n\n  return typeof configPath === \"function\"\n    ? configPath(relativePath)\n    : path.resolve(configPath, relativePath);\n}\n\n/**\n * Get the absolute path to the public folder to the given path\n *\n * If no path is given, it will return the absolute path to the public folder\n */\nexport function publicPath(relativePath = \"\") {\n  return rootPath(\"public\", relativePath);\n}\n\n/**\n * Get the absolute path to the cache folder to the given path\n *\n * If no path is given, it will return the absolute path to the cache folder\n */\nexport function cachePath(relativePath = \"\") {\n  return rootPath(\"storage\", \"cache\", relativePath);\n}\n\n/**\n * App path\n */\nexport function appPath(relativePath = \"\") {\n  return rootPath(\"src/app\", relativePath);\n}\n\n/**\n * Get logs directory path\n */\nexport function logsPath(relativePath = \"\") {\n  return rootPath(\"storage/logs\", relativePath);\n}\n\n/**\n * Get a temp path\n */\nexport function tempPath(relativePath = \"\") {\n  return rootPath(\"storage/tmp\", relativePath);\n}\n\n/**\n * Remove any invalid characters from the file path using regex\n * It should accept any language character, numbers, and the following characters: _ - .\n */\nconst invalidCharsRegex = /[<>:\"/\\\\|?*]/g; // Regex to match invalid characters\nexport function sanitizePath(filePath: string) {\n  return filePath.replace(invalidCharsRegex, \"\"); // Replace invalid characters with an empty string\n}\n\n/**\n * Warlock path\n * PLEASE DO NOT add any files in this directory as it may be deleted\n */\nexport function warlockPath(...path: string[]) {\n  return rootPath(\".warlock\", ...path);\n}\n\n/**\n * Get config directory path\n */\nexport function configPath(...path: string[]) {\n  return rootPath(\"src/config\", ...path);\n}\n\nexport const paths = {\n  root: rootPath,\n  src: srcPath,\n  storage: storagePath,\n  logs: logsPath,\n  uploads: uploadsPath,\n  public: publicPath,\n  cache: cachePath,\n  app: appPath,\n  temp: tempPath,\n  warlock: warlockPath,\n  config: configPath,\n  sanitize: sanitizePath,\n};\n"],"mappings":";;;;;;;AAMA,SAAgB,SAAS,GAAG,OAAiB;CAC3C,OAAO,KAAK,QAAQ,QAAQ,IAAI,GAAG,GAAG,KAAK;AAC7C;;;;AAKA,SAAgB,QAAQ,GAAG,OAAiB;CAC1C,OAAO,SAAS,OAAO,GAAG,KAAK;AACjC;;;;;;AAOA,SAAgB,YAAY,eAAe,IAAI;CAC7C,OAAO,SAAS,WAAW,YAAY;AACzC;;;;;;AAOA,SAAgB,YAAY,eAAe,IAAI;CAC7C,MAAM,aAAa,OAAO,IAAI,cAAc;CAC5C,IAAI,CAAC,YACH,OAAO,SAAS,WAAW,WAAW,YAAY;CAGpD,OAAO,OAAO,eAAe,aACzB,WAAW,YAAY,IACvB,KAAK,QAAQ,YAAY,YAAY;AAC3C;;;;;;AAOA,SAAgB,WAAW,eAAe,IAAI;CAC5C,OAAO,SAAS,UAAU,YAAY;AACxC;;;;;;AAOA,SAAgB,UAAU,eAAe,IAAI;CAC3C,OAAO,SAAS,WAAW,SAAS,YAAY;AAClD;;;;AAKA,SAAgB,QAAQ,eAAe,IAAI;CACzC,OAAO,SAAS,WAAW,YAAY;AACzC;;;;AAKA,SAAgB,SAAS,eAAe,IAAI;CAC1C,OAAO,SAAS,gBAAgB,YAAY;AAC9C;;;;AAKA,SAAgB,SAAS,eAAe,IAAI;CAC1C,OAAO,SAAS,eAAe,YAAY;AAC7C;;;;;AAMA,MAAM,oBAAoB;AAC1B,SAAgB,aAAa,UAAkB;CAC7C,OAAO,SAAS,QAAQ,mBAAmB,EAAE;AAC/C;;;;;AAMA,SAAgB,YAAY,GAAG,MAAgB;CAC7C,OAAO,SAAS,YAAY,GAAG,IAAI;AACrC;;;;AAKA,SAAgB,WAAW,GAAG,MAAgB;CAC5C,OAAO,SAAS,cAAc,GAAG,IAAI;AACvC;AAEA,MAAa,QAAQ;CACnB,MAAM;CACN,KAAK;CACL,SAAS;CACT,MAAM;CACN,SAAS;CACT,QAAQ;CACR,OAAO;CACP,KAAK;CACL,MAAM;CACN,SAAS;CACT,QAAQ;CACR,UAAU;AACZ"}
+{"version":3,"file":"paths.mjs","names":[],"sources":["../../../../../../../../packages/core/src/utils/paths.ts"],"sourcesContent":["import config from \"@mongez/config\";\nimport path from \"path\";\n\n/**\n * Get root path or join the given paths to the root path\n */\nexport function rootPath(...paths: string[]) {\n  return path.resolve(process.cwd(), ...paths);\n}\n\n/**\n * Get src directory path or join the given paths to the src directory path\n */\nexport function srcPath(...paths: string[]) {\n  return rootPath(\"src\", ...paths);\n}\n\n/**\n * Get the absolute path to the storage folder to the given path\n *\n * If no path is given, it will return the absolute path to the storage folder\n */\nexport function storagePath(relativePath = \"\") {\n  return rootPath(\"storage\", relativePath);\n}\n\n/**\n * Get the absolute path to the uploads folder to the given path\n *\n * If no path is given, it will return the absolute path to the uploads folder\n */\nexport function uploadsPath(relativePath = \"\") {\n  const configPath = config.get(\"uploads.root\");\n  if (!configPath) {\n    return rootPath(\"storage\", \"uploads\", relativePath);\n  }\n\n  return typeof configPath === \"function\"\n    ? configPath(relativePath)\n    : path.resolve(configPath, relativePath);\n}\n\n/**\n * Get the absolute path to the public folder to the given path\n *\n * If no path is given, it will return the absolute path to the public folder\n */\nexport function publicPath(relativePath = \"\") {\n  return rootPath(\"public\", relativePath);\n}\n\n/**\n * Get the absolute path to the cache folder to the given path\n *\n * If no path is given, it will return the absolute path to the cache folder\n */\nexport function cachePath(relativePath = \"\") {\n  return rootPath(\"storage\", \"cache\", relativePath);\n}\n\n/**\n * App path\n */\nexport function appPath(relativePath = \"\") {\n  return rootPath(\"src/app\", relativePath);\n}\n\n/**\n * Get logs directory path\n */\nexport function logsPath(relativePath = \"\") {\n  return rootPath(\"storage/logs\", relativePath);\n}\n\n/**\n * Get a temp path\n */\nexport function tempPath(relativePath = \"\") {\n  return rootPath(\"storage/tmp\", relativePath);\n}\n\n/**\n * Remove any invalid characters from the file path using regex\n * It should accept any language character, numbers, and the following characters: _ - .\n */\nconst invalidCharsRegex = /[<>:\"/\\\\|?*]/g; // Regex to match invalid characters\nexport function sanitizePath(filePath: string) {\n  return filePath.replace(invalidCharsRegex, \"\"); // Replace invalid characters with an empty string\n}\n\n/**\n * Warlock path\n * PLEASE DO NOT add any files in this directory as it may be deleted\n */\nexport function warlockPath(...path: string[]) {\n  return rootPath(\".warlock\", ...path);\n}\n\n/**\n * Get config directory path\n */\nexport function configPath(...path: string[]) {\n  return rootPath(\"src/config\", ...path);\n}\n\nexport const paths = {\n  root: rootPath,\n  src: srcPath,\n  storage: storagePath,\n  logs: logsPath,\n  uploads: uploadsPath,\n  public: publicPath,\n  cache: cachePath,\n  app: appPath,\n  temp: tempPath,\n  warlock: warlockPath,\n  config: configPath,\n  sanitize: sanitizePath,\n};\n"],"mappings":";;;;;;;AAMA,SAAgB,SAAS,GAAG,OAAiB;CAC3C,OAAO,KAAK,QAAQ,QAAQ,IAAI,GAAG,GAAG,KAAK;AAC7C;;;;AAKA,SAAgB,QAAQ,GAAG,OAAiB;CAC1C,OAAO,SAAS,OAAO,GAAG,KAAK;AACjC;;;;;;AAOA,SAAgB,YAAY,eAAe,IAAI;CAC7C,OAAO,SAAS,WAAW,YAAY;AACzC;;;;;;AAOA,SAAgB,YAAY,eAAe,IAAI;CAC7C,MAAM,aAAa,OAAO,IAAI,cAAc;CAC5C,IAAI,CAAC,YACH,OAAO,SAAS,WAAW,WAAW,YAAY;CAGpD,OAAO,OAAO,eAAe,aACzB,WAAW,YAAY,IACvB,KAAK,QAAQ,YAAY,YAAY;AAC3C;;;;;;AAOA,SAAgB,WAAW,eAAe,IAAI;CAC5C,OAAO,SAAS,UAAU,YAAY;AACxC;;;;;;AAOA,SAAgB,UAAU,eAAe,IAAI;CAC3C,OAAO,SAAS,WAAW,SAAS,YAAY;AAClD;;;;AAKA,SAAgB,QAAQ,eAAe,IAAI;CACzC,OAAO,SAAS,WAAW,YAAY;AACzC;;;;AAKA,SAAgB,SAAS,eAAe,IAAI;CAC1C,OAAO,SAAS,gBAAgB,YAAY;AAC9C;;;;AAKA,SAAgB,SAAS,eAAe,IAAI;CAC1C,OAAO,SAAS,eAAe,YAAY;AAC7C;;;;;AAMA,MAAM,oBAAoB;AAC1B,SAAgB,aAAa,UAAkB;CAC7C,OAAO,SAAS,QAAQ,mBAAmB,EAAE;AAC/C;;;;;AAMA,SAAgB,YAAY,GAAG,MAAgB;CAC7C,OAAO,SAAS,YAAY,GAAG,IAAI;AACrC;;;;AAKA,SAAgB,WAAW,GAAG,MAAgB;CAC5C,OAAO,SAAS,cAAc,GAAG,IAAI;AACvC;AAEA,MAAa,QAAQ;CACnB,MAAM;CACN,KAAK;CACL,SAAS;CACT,MAAM;CACN,SAAS;CACT,QAAQ;CACR,OAAO;CACP,KAAK;CACL,MAAM;CACN,SAAS;CACT,QAAQ;CACR,UAAU;AACZ"}

package/esm/utils/promise-all-object.d.mts

@@ -1,4 +1,4 @@
-//#region ../core/src/utils/promise-all-object.d.ts
+//#region ../../packages/core/src/utils/promise-all-object.d.ts
 /**
  * Resolve all of the given promises in the object and return the results as an object.
  * This is more convenient than using `Promise.all` and then mapping the results back to the keys.

package/esm/utils/promise-all-object.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"promise-all-object.d.mts","names":[],"sources":["../../../../../../../core/src/utils/promise-all-object.ts"],"mappings":";;AAIA;;;iBAAsB,gBAAA,WAA2B,MAAA,SAAe,OAAA,QAC9D,QAAA,EAAU,CAAA,GACT,OAAA,eAAsB,CAAA,GAAI,CAAA,CAAE,CAAA,UAAW,OAAA,YAAmB,CAAA"}
+{"version":3,"file":"promise-all-object.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/utils/promise-all-object.ts"],"mappings":";;AAIA;;;iBAAsB,gBAAA,WAA2B,MAAA,SAAe,OAAA,QAC9D,QAAA,EAAU,CAAA,GACT,OAAA,eAAsB,CAAA,GAAI,CAAA,CAAE,CAAA,UAAW,OAAA,YAAmB,CAAA"}

package/esm/utils/promise-all-object.mjs

@@ -1,4 +1,4 @@
-//#region ../core/src/utils/promise-all-object.ts
+//#region ../../packages/core/src/utils/promise-all-object.ts
 /**
 * Resolve all of the given promises in the object and return the results as an object.
 * This is more convenient than using `Promise.all` and then mapping the results back to the keys.

package/esm/utils/promise-all-object.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"promise-all-object.mjs","names":[],"sources":["../../../../../../../core/src/utils/promise-all-object.ts"],"sourcesContent":["/**\n * Resolve all of the given promises in the object and return the results as an object.\n * This is more convenient than using `Promise.all` and then mapping the results back to the keys.\n */\nexport async function promiseAllObject<T extends Record<string, Promise<any>>>(\n  promises: T,\n): Promise<{ [K in keyof T]: T[K] extends Promise<infer U> ? U : never }> {\n  const results = await Promise.all(Object.values(promises));\n  const keys = Object.keys(promises);\n\n  return keys.reduce(\n    (result, key, index) => {\n      (result as any)[key] = results[index];\n      return result;\n    },\n    {} as { [K in keyof T]: T[K] extends Promise<infer U> ? U : never },\n  );\n}\n"],"mappings":";;;;;AAIA,eAAsB,iBACpB,UACwE;CACxE,MAAM,UAAU,MAAM,QAAQ,IAAI,OAAO,OAAO,QAAQ,CAAC;CAGzD,OAFa,OAAO,KAAK,QAEf,CAAC,CAAC,QACT,QAAQ,KAAK,UAAU;EACtB,AAAC,OAAe,OAAO,QAAQ;EAC/B,OAAO;CACT,GACA,CAAC,CACH;AACF"}
+{"version":3,"file":"promise-all-object.mjs","names":[],"sources":["../../../../../../../../packages/core/src/utils/promise-all-object.ts"],"sourcesContent":["/**\n * Resolve all of the given promises in the object and return the results as an object.\n * This is more convenient than using `Promise.all` and then mapping the results back to the keys.\n */\nexport async function promiseAllObject<T extends Record<string, Promise<any>>>(\n  promises: T,\n): Promise<{ [K in keyof T]: T[K] extends Promise<infer U> ? U : never }> {\n  const results = await Promise.all(Object.values(promises));\n  const keys = Object.keys(promises);\n\n  return keys.reduce(\n    (result, key, index) => {\n      (result as any)[key] = results[index];\n      return result;\n    },\n    {} as { [K in keyof T]: T[K] extends Promise<infer U> ? U : never },\n  );\n}\n"],"mappings":";;;;;AAIA,eAAsB,iBACpB,UACwE;CACxE,MAAM,UAAU,MAAM,QAAQ,IAAI,OAAO,OAAO,QAAQ,CAAC;CAGzD,OAFa,OAAO,KAAK,QAEf,CAAC,CAAC,QACT,QAAQ,KAAK,UAAU;EACtB,AAAC,OAAe,OAAO,QAAQ;EAC/B,OAAO;CACT,GACA,CAAC,CACH;AACF"}

package/esm/utils/queue.d.mts

@@ -1,4 +1,4 @@
-//#region ../core/src/utils/queue.d.ts
+//#region ../../packages/core/src/utils/queue.d.ts
 /**
  * A utility class for managing a queue of operations.
  * Allows enqueuing values and executing a function when the queue reaches a certain size or after a specified interval.

package/esm/utils/queue.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"queue.d.mts","names":[],"sources":["../../../../../../../core/src/utils/queue.ts"],"mappings":";;AAKA;;;;cAAa,KAAA;EA0DU;EAAA,QAxDb,KAAA;EAwDc;EAAA,iBArDL,OAAA;EAHT;EAAA,iBAMS,QAAA;EAAA;EAAA,iBAGA,SAAA;EAGT;EAAA,QAAA,KAAA;EAMS;EAAA,iBAHA,iBAAA;EAST;EAAA,iBANS,SAAA;EAiBI;EAAA,iBAdJ,OAAA;EAcY;EAAA,QAXrB,WAAA;EAYN;;;;;;;;cADA,SAAA,GAAY,KAAA,EAAO,CAAA,OAAQ,OAAA,QAC3B,iBAAA,YACA,YAAA,WACA,SAAA,WACA,OAAA,WACA,OAAA,IAAU,KAAA;EA8BJ;;;AAaa;;;EA3Bd,OAAA,CAAQ,IAAA,EAAM,CAAA;;;;UAcb,UAAA;;;;;UAaM,OAAA;AAAA"}
+{"version":3,"file":"queue.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/utils/queue.ts"],"mappings":";;AAKA;;;;cAAa,KAAA;EA0DU;EAAA,QAxDb,KAAA;EAwDc;EAAA,iBArDL,OAAA;EAHT;EAAA,iBAMS,QAAA;EAAA;EAAA,iBAGA,SAAA;EAGT;EAAA,QAAA,KAAA;EAMS;EAAA,iBAHA,iBAAA;EAST;EAAA,iBANS,SAAA;EAiBI;EAAA,iBAdJ,OAAA;EAcY;EAAA,QAXrB,WAAA;EAYN;;;;;;;;cADA,SAAA,GAAY,KAAA,EAAO,CAAA,OAAQ,OAAA,QAC3B,iBAAA,YACA,YAAA,WACA,SAAA,WACA,OAAA,WACA,OAAA,IAAU,KAAA;EA8BJ;;;AAaa;;;EA3Bd,OAAA,CAAQ,IAAA,EAAM,CAAA;;;;UAcb,UAAA;;;;;UAaM,OAAA;AAAA"}

package/esm/utils/queue.mjs

@@ -1,4 +1,4 @@
-//#region ../core/src/utils/queue.ts
+//#region ../../packages/core/src/utils/queue.ts
 /**
 * A utility class for managing a queue of operations.
 * Allows enqueuing values and executing a function when the queue reaches a certain size or after a specified interval.

package/esm/utils/queue.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"queue.mjs","names":[],"sources":["../../../../../../../core/src/utils/queue.ts"],"sourcesContent":["/**\n * A utility class for managing a queue of operations.\n * Allows enqueuing values and executing a function when the queue reaches a certain size or after a specified interval.\n * Supports both parallel and sequential execution of the queued operations.\n */\nexport class Queue<T> {\n  /** The items currently in the queue. */\n  private items: T[] = [];\n\n  /** The maximum size of the queue before triggering execution. */\n  private readonly maxSize?: number;\n\n  /** The interval in milliseconds after which the queue will be executed if not already triggered by size. */\n  private readonly interval: number;\n\n  /** The function to execute with the items in the queue. */\n  private readonly executeFn: (items: T[]) => Promise<void>;\n\n  /** Timer for managing the interval-based execution. */\n  private timer: NodeJS.Timeout | null = null;\n\n  /** Flag to determine if execution should be parallel or sequential. */\n  private readonly executeInParallel: boolean;\n\n  /** The batch size for processing items. */\n  private readonly batchSize?: number;\n\n  /** Called when the execute function rejects. */\n  private readonly onError: (error: unknown) => void;\n\n  /** Whether the current queue is busy executing */\n  private isExecuting = false;\n\n  /**\n   * Constructs a new Queue instance.\n   * @param executeFn - The function to execute with the items in the queue.\n   * @param maxSize - The maximum number of items before the queue is executed.\n   * @param executeEvery - The time in milliseconds after which the queue is executed if not already triggered.\n   * @param executeInParallel - Whether to execute the function in parallel or sequentially.\n   * @param batchSize - The number of items to process in each batch.\n   */\n  public constructor(\n    executeFn: (items: T[]) => Promise<void>,\n    executeInParallel: boolean = true,\n    executeEvery: number = 5000,\n    batchSize?: number,\n    maxSize?: number,\n    onError: (error: unknown) => void = (error) => console.error(\"Queue execution failed\", error),\n  ) {\n    this.onError = onError;\n    this.executeFn = executeFn;\n    this.maxSize = maxSize;\n    this.interval = executeEvery;\n    this.executeInParallel = executeInParallel;\n    this.batchSize = batchSize;\n  }\n\n  /**\n   * Adds an item to the queue.\n   * Triggers execution if the queue reaches the maximum size.\n   * Starts a timer if not already running.\n   * @param item - The item to add to the queue.\n   */\n  public enqueue(item: T): void {\n    this.items.push(item);\n    if (this.maxSize && this.items.length >= this.maxSize) {\n      void this.execute();\n    }\n\n    if (!this.timer && !this.isExecuting) {\n      this.startTimer();\n    }\n  }\n\n  /**\n   * Starts a timer to execute the queue after the specified interval.\n   */\n  private startTimer(): void {\n    this.timer = setInterval(() => {\n      if (this.items.length > 0) {\n        void this.execute();\n      }\n    }, this.interval);\n    this.timer.unref?.();\n  }\n\n  /**\n   * Executes the function with the queued items until the queue is drained.\n   * Rejections from the execute function are passed to `onError`.\n   */\n  private async execute(): Promise<void> {\n    if (this.timer) {\n      clearInterval(this.timer);\n      this.timer = null;\n    }\n\n    // the running drain loop will pick up newly enqueued items\n    if (this.isExecuting) return;\n\n    this.isExecuting = true;\n\n    try {\n      while (this.items.length > 0) {\n        // Without a batch size, all items go in a single call\n        const batch = this.items.splice(0, this.batchSize || this.items.length);\n\n        try {\n          if (!this.batchSize) {\n            await this.executeFn(batch);\n          } else if (this.executeInParallel) {\n            await Promise.all(batch.map((item) => this.executeFn([item])));\n          } else {\n            for (const item of batch) {\n              await this.executeFn([item]);\n            }\n          }\n        } catch (error) {\n          this.onError(error);\n        }\n      }\n    } finally {\n      this.isExecuting = false;\n    }\n  }\n}\n"],"mappings":";;;;;;AAKA,IAAa,QAAb,MAAsB;;;;;;;;;CAoCpB,AAAO,YACL,WACA,oBAA6B,MAC7B,eAAuB,KACvB,WACA,SACA,WAAqC,UAAU,QAAQ,MAAM,0BAA0B,KAAK,GAC5F;eAzCmB,CAAC;eAYiB;qBAYjB;EAkBpB,KAAK,UAAU;EACf,KAAK,YAAY;EACjB,KAAK,UAAU;EACf,KAAK,WAAW;EAChB,KAAK,oBAAoB;EACzB,KAAK,YAAY;CACnB;;;;;;;CAQA,AAAO,QAAQ,MAAe;EAC5B,KAAK,MAAM,KAAK,IAAI;EACpB,IAAI,KAAK,WAAW,KAAK,MAAM,UAAU,KAAK,SAC5C,AAAK,KAAK,QAAQ;EAGpB,IAAI,CAAC,KAAK,SAAS,CAAC,KAAK,aACvB,KAAK,WAAW;CAEpB;;;;CAKA,AAAQ,aAAmB;EACzB,KAAK,QAAQ,kBAAkB;GAC7B,IAAI,KAAK,MAAM,SAAS,GACtB,AAAK,KAAK,QAAQ;EAEtB,GAAG,KAAK,QAAQ;EAChB,KAAK,MAAM,QAAQ;CACrB;;;;;CAMA,MAAc,UAAyB;EACrC,IAAI,KAAK,OAAO;GACd,cAAc,KAAK,KAAK;GACxB,KAAK,QAAQ;EACf;EAGA,IAAI,KAAK,aAAa;EAEtB,KAAK,cAAc;EAEnB,IAAI;GACF,OAAO,KAAK,MAAM,SAAS,GAAG;IAE5B,MAAM,QAAQ,KAAK,MAAM,OAAO,GAAG,KAAK,aAAa,KAAK,MAAM,MAAM;IAEtE,IAAI;KACF,IAAI,CAAC,KAAK,WACR,MAAM,KAAK,UAAU,KAAK;UACrB,IAAI,KAAK,mBACd,MAAM,QAAQ,IAAI,MAAM,KAAK,SAAS,KAAK,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC;UAE7D,KAAK,MAAM,QAAQ,OACjB,MAAM,KAAK,UAAU,CAAC,IAAI,CAAC;IAGjC,SAAS,OAAO;KACd,KAAK,QAAQ,KAAK;IACpB;GACF;EACF,UAAU;GACR,KAAK,cAAc;EACrB;CACF;AACF"}
+{"version":3,"file":"queue.mjs","names":[],"sources":["../../../../../../../../packages/core/src/utils/queue.ts"],"sourcesContent":["/**\n * A utility class for managing a queue of operations.\n * Allows enqueuing values and executing a function when the queue reaches a certain size or after a specified interval.\n * Supports both parallel and sequential execution of the queued operations.\n */\nexport class Queue<T> {\n  /** The items currently in the queue. */\n  private items: T[] = [];\n\n  /** The maximum size of the queue before triggering execution. */\n  private readonly maxSize?: number;\n\n  /** The interval in milliseconds after which the queue will be executed if not already triggered by size. */\n  private readonly interval: number;\n\n  /** The function to execute with the items in the queue. */\n  private readonly executeFn: (items: T[]) => Promise<void>;\n\n  /** Timer for managing the interval-based execution. */\n  private timer: NodeJS.Timeout | null = null;\n\n  /** Flag to determine if execution should be parallel or sequential. */\n  private readonly executeInParallel: boolean;\n\n  /** The batch size for processing items. */\n  private readonly batchSize?: number;\n\n  /** Called when the execute function rejects. */\n  private readonly onError: (error: unknown) => void;\n\n  /** Whether the current queue is busy executing */\n  private isExecuting = false;\n\n  /**\n   * Constructs a new Queue instance.\n   * @param executeFn - The function to execute with the items in the queue.\n   * @param maxSize - The maximum number of items before the queue is executed.\n   * @param executeEvery - The time in milliseconds after which the queue is executed if not already triggered.\n   * @param executeInParallel - Whether to execute the function in parallel or sequentially.\n   * @param batchSize - The number of items to process in each batch.\n   */\n  public constructor(\n    executeFn: (items: T[]) => Promise<void>,\n    executeInParallel: boolean = true,\n    executeEvery: number = 5000,\n    batchSize?: number,\n    maxSize?: number,\n    onError: (error: unknown) => void = (error) => console.error(\"Queue execution failed\", error),\n  ) {\n    this.onError = onError;\n    this.executeFn = executeFn;\n    this.maxSize = maxSize;\n    this.interval = executeEvery;\n    this.executeInParallel = executeInParallel;\n    this.batchSize = batchSize;\n  }\n\n  /**\n   * Adds an item to the queue.\n   * Triggers execution if the queue reaches the maximum size.\n   * Starts a timer if not already running.\n   * @param item - The item to add to the queue.\n   */\n  public enqueue(item: T): void {\n    this.items.push(item);\n    if (this.maxSize && this.items.length >= this.maxSize) {\n      void this.execute();\n    }\n\n    if (!this.timer && !this.isExecuting) {\n      this.startTimer();\n    }\n  }\n\n  /**\n   * Starts a timer to execute the queue after the specified interval.\n   */\n  private startTimer(): void {\n    this.timer = setInterval(() => {\n      if (this.items.length > 0) {\n        void this.execute();\n      }\n    }, this.interval);\n    this.timer.unref?.();\n  }\n\n  /**\n   * Executes the function with the queued items until the queue is drained.\n   * Rejections from the execute function are passed to `onError`.\n   */\n  private async execute(): Promise<void> {\n    if (this.timer) {\n      clearInterval(this.timer);\n      this.timer = null;\n    }\n\n    // the running drain loop will pick up newly enqueued items\n    if (this.isExecuting) return;\n\n    this.isExecuting = true;\n\n    try {\n      while (this.items.length > 0) {\n        // Without a batch size, all items go in a single call\n        const batch = this.items.splice(0, this.batchSize || this.items.length);\n\n        try {\n          if (!this.batchSize) {\n            await this.executeFn(batch);\n          } else if (this.executeInParallel) {\n            await Promise.all(batch.map((item) => this.executeFn([item])));\n          } else {\n            for (const item of batch) {\n              await this.executeFn([item]);\n            }\n          }\n        } catch (error) {\n          this.onError(error);\n        }\n      }\n    } finally {\n      this.isExecuting = false;\n    }\n  }\n}\n"],"mappings":";;;;;;AAKA,IAAa,QAAb,MAAsB;;;;;;;;;CAoCpB,AAAO,YACL,WACA,oBAA6B,MAC7B,eAAuB,KACvB,WACA,SACA,WAAqC,UAAU,QAAQ,MAAM,0BAA0B,KAAK,GAC5F;eAzCmB,CAAC;eAYiB;qBAYjB;EAkBpB,KAAK,UAAU;EACf,KAAK,YAAY;EACjB,KAAK,UAAU;EACf,KAAK,WAAW;EAChB,KAAK,oBAAoB;EACzB,KAAK,YAAY;CACnB;;;;;;;CAQA,AAAO,QAAQ,MAAe;EAC5B,KAAK,MAAM,KAAK,IAAI;EACpB,IAAI,KAAK,WAAW,KAAK,MAAM,UAAU,KAAK,SAC5C,AAAK,KAAK,QAAQ;EAGpB,IAAI,CAAC,KAAK,SAAS,CAAC,KAAK,aACvB,KAAK,WAAW;CAEpB;;;;CAKA,AAAQ,aAAmB;EACzB,KAAK,QAAQ,kBAAkB;GAC7B,IAAI,KAAK,MAAM,SAAS,GACtB,AAAK,KAAK,QAAQ;EAEtB,GAAG,KAAK,QAAQ;EAChB,KAAK,MAAM,QAAQ;CACrB;;;;;CAMA,MAAc,UAAyB;EACrC,IAAI,KAAK,OAAO;GACd,cAAc,KAAK,KAAK;GACxB,KAAK,QAAQ;EACf;EAGA,IAAI,KAAK,aAAa;EAEtB,KAAK,cAAc;EAEnB,IAAI;GACF,OAAO,KAAK,MAAM,SAAS,GAAG;IAE5B,MAAM,QAAQ,KAAK,MAAM,OAAO,GAAG,KAAK,aAAa,KAAK,MAAM,MAAM;IAEtE,IAAI;KACF,IAAI,CAAC,KAAK,WACR,MAAM,KAAK,UAAU,KAAK;UACrB,IAAI,KAAK,mBACd,MAAM,QAAQ,IAAI,MAAM,KAAK,SAAS,KAAK,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC;UAE7D,KAAK,MAAM,QAAQ,OACjB,MAAM,KAAK,UAAU,CAAC,IAAI,CAAC;IAGjC,SAAS,OAAO;KACd,KAAK,QAAQ,KAAK;IACpB;GACF;EACF,UAAU;GACR,KAAK,cAAc;EACrB;CACF;AACF"}

package/esm/utils/recorded-environment-overrides.mjs

@@ -1,4 +1,4 @@
-//#region ../core/src/utils/recorded-environment-overrides.ts
+//#region ../../packages/core/src/utils/recorded-environment-overrides.ts
 /**
 * The environment overrides {@link detectEnvironmentOverrides} found on this
 * boot, kept so a LATER point in the boot can ask which `.env` keys the ambient

package/esm/utils/recorded-environment-overrides.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"recorded-environment-overrides.mjs","names":[],"sources":["../../../../../../../core/src/utils/recorded-environment-overrides.ts"],"sourcesContent":["import type { EnvironmentOverride } from \"./detect-environment-overrides\";\n\n/**\n * The environment overrides {@link detectEnvironmentOverrides} found on this\n * boot, kept so a LATER point in the boot can ask which `.env` keys the ambient\n * process environment beat — WITHOUT re-reading `.env` or `process.env` a second\n * time, and without re-deriving the comparison.\n *\n * Why this exists: `reportPortInUse` (`src/http/boot-port-preflight.ts`) runs\n * far downstream of `loadEnvironmentFiles()` and needs to know whether the\n * colliding `http.port` came from an ambient `HTTP_PORT` (in which case\n * \"edit src/config/http.ts and rebuild\" is ACTIVELY WRONG — the env var wins,\n * so the rebuild changes nothing) or from config (where that advice is right).\n * The detector already knows this at env-load time; the provenance has to\n * travel to the point of use rather than be recomputed there (finding\n * 8782b840, requirement 3).\n *\n * Keyed by env var name, last-write-wins — a single boot loads env at most once\n * (`loadEnvironmentFiles` latches), and a deliberate dev-server reload re-records\n * the current truth.\n */\nlet recorded = new Map<string, EnvironmentOverride>();\n\n/**\n * Record the overrides detected on this boot. Replaces any prior record, so a\n * re-load reflects the current environment rather than accumulating stale keys.\n */\nexport function recordEnvironmentOverrides(overrides: EnvironmentOverride[]): void {\n  recorded = new Map(overrides.map((override) => [override.key, override]));\n}\n\n/**\n * The recorded override for `key`, or `undefined` if the ambient environment\n * did not beat a `.env` value for it on this boot. The returned object is the\n * detector's own finding (effective value + the `.env` value it overrode), so a\n * caller can name both without recomputing either.\n */\nexport function getRecordedEnvironmentOverride(key: string): EnvironmentOverride | undefined {\n  return recorded.get(key);\n}\n\n/**\n * Forget every recorded override.\n *\n * @internal For tests, which run many boots inside one process.\n */\nexport function clearRecordedEnvironmentOverrides(): void {\n  recorded = new Map();\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAqBA,IAAI,2BAAW,IAAI,IAAiC;;;;;AAMpD,SAAgB,2BAA2B,WAAwC;CACjF,WAAW,IAAI,IAAI,UAAU,KAAK,aAAa,CAAC,SAAS,KAAK,QAAQ,CAAC,CAAC;AAC1E;;;;;;;AAQA,SAAgB,+BAA+B,KAA8C;CAC3F,OAAO,SAAS,IAAI,GAAG;AACzB"}
+{"version":3,"file":"recorded-environment-overrides.mjs","names":[],"sources":["../../../../../../../../packages/core/src/utils/recorded-environment-overrides.ts"],"sourcesContent":["import type { EnvironmentOverride } from \"./detect-environment-overrides\";\n\n/**\n * The environment overrides {@link detectEnvironmentOverrides} found on this\n * boot, kept so a LATER point in the boot can ask which `.env` keys the ambient\n * process environment beat — WITHOUT re-reading `.env` or `process.env` a second\n * time, and without re-deriving the comparison.\n *\n * Why this exists: `reportPortInUse` (`src/http/boot-port-preflight.ts`) runs\n * far downstream of `loadEnvironmentFiles()` and needs to know whether the\n * colliding `http.port` came from an ambient `HTTP_PORT` (in which case\n * \"edit src/config/http.ts and rebuild\" is ACTIVELY WRONG — the env var wins,\n * so the rebuild changes nothing) or from config (where that advice is right).\n * The detector already knows this at env-load time; the provenance has to\n * travel to the point of use rather than be recomputed there (finding\n * 8782b840, requirement 3).\n *\n * Keyed by env var name, last-write-wins — a single boot loads env at most once\n * (`loadEnvironmentFiles` latches), and a deliberate dev-server reload re-records\n * the current truth.\n */\nlet recorded = new Map<string, EnvironmentOverride>();\n\n/**\n * Record the overrides detected on this boot. Replaces any prior record, so a\n * re-load reflects the current environment rather than accumulating stale keys.\n */\nexport function recordEnvironmentOverrides(overrides: EnvironmentOverride[]): void {\n  recorded = new Map(overrides.map((override) => [override.key, override]));\n}\n\n/**\n * The recorded override for `key`, or `undefined` if the ambient environment\n * did not beat a `.env` value for it on this boot. The returned object is the\n * detector's own finding (effective value + the `.env` value it overrode), so a\n * caller can name both without recomputing either.\n */\nexport function getRecordedEnvironmentOverride(key: string): EnvironmentOverride | undefined {\n  return recorded.get(key);\n}\n\n/**\n * Forget every recorded override.\n *\n * @internal For tests, which run many boots inside one process.\n */\nexport function clearRecordedEnvironmentOverrides(): void {\n  recorded = new Map();\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAqBA,IAAI,2BAAW,IAAI,IAAiC;;;;;AAMpD,SAAgB,2BAA2B,WAAwC;CACjF,WAAW,IAAI,IAAI,UAAU,KAAK,aAAa,CAAC,SAAS,KAAK,QAAQ,CAAC,CAAC;AAC1E;;;;;;;AAQA,SAAgB,+BAA+B,KAA8C;CAC3F,OAAO,SAAS,IAAI,GAAG;AACzB"}

package/esm/utils/report-environment-overrides.mjs

@@ -1,4 +1,4 @@
-//#region ../core/src/utils/report-environment-overrides.ts
+//#region ../../packages/core/src/utils/report-environment-overrides.ts
 /**
 * Key names shaped like a secret. Matched values are redacted in the printed
 * line even though the key itself is still named — knowing WHICH secret was

package/esm/utils/report-environment-overrides.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"report-environment-overrides.mjs","names":[],"sources":["../../../../../../../core/src/utils/report-environment-overrides.ts"],"sourcesContent":["import type { EnvironmentOverride } from \"./detect-environment-overrides\";\n\n/**\n * Key names shaped like a secret. Matched values are redacted in the printed\n * line even though the key itself is still named — knowing WHICH secret was\n * overridden is useful, the value never is.\n */\nconst SECRET_KEY_PATTERN = /(PASSWORD|SECRET|TOKEN|KEY|CREDENTIAL|DSN|CONNECTION_STRING)/i;\n\nconst REDACTED_PLACEHOLDER = \"<redacted>\";\n\n/**\n * Tell the developer, one line per key, which `.env` values the ambient\n * process environment silently beat.\n *\n * Uses `console.warn` (stderr) rather than the `log` singleton on purpose:\n * this runs from `loadEnvironmentFiles()`, ahead of the logger connector in\n * the boot sequence, so any channel configured through `log.*` has nowhere to\n * deliver to yet. Same reasoning as `console.error` in\n * `src/http/boot-port-preflight.ts`.\n */\nexport function reportEnvironmentOverrides(overrides: EnvironmentOverride[]): void {\n  for (const override of overrides) {\n    const isSecretShaped = SECRET_KEY_PATTERN.test(override.key);\n    const effectiveValue = isSecretShaped ? REDACTED_PLACEHOLDER : override.effectiveValue;\n    const fileValue = isSecretShaped ? REDACTED_PLACEHOLDER : override.fileValue;\n\n    console.warn(\n      `[env] ${override.key}=${effectiveValue} is in effect from the process environment, overriding .env's ${override.key}=${fileValue}`,\n    );\n  }\n}\n"],"mappings":";;;;;;AAOA,MAAM,qBAAqB;AAE3B,MAAM,uBAAuB;;;;;;;;;;;AAY7B,SAAgB,2BAA2B,WAAwC;CACjF,KAAK,MAAM,YAAY,WAAW;EAChC,MAAM,iBAAiB,mBAAmB,KAAK,SAAS,GAAG;EAC3D,MAAM,iBAAiB,iBAAiB,uBAAuB,SAAS;EACxE,MAAM,YAAY,iBAAiB,uBAAuB,SAAS;EAEnE,QAAQ,KACN,SAAS,SAAS,IAAI,GAAG,eAAe,gEAAgE,SAAS,IAAI,GAAG,WAC1H;CACF;AACF"}
+{"version":3,"file":"report-environment-overrides.mjs","names":[],"sources":["../../../../../../../../packages/core/src/utils/report-environment-overrides.ts"],"sourcesContent":["import type { EnvironmentOverride } from \"./detect-environment-overrides\";\n\n/**\n * Key names shaped like a secret. Matched values are redacted in the printed\n * line even though the key itself is still named — knowing WHICH secret was\n * overridden is useful, the value never is.\n */\nconst SECRET_KEY_PATTERN = /(PASSWORD|SECRET|TOKEN|KEY|CREDENTIAL|DSN|CONNECTION_STRING)/i;\n\nconst REDACTED_PLACEHOLDER = \"<redacted>\";\n\n/**\n * Tell the developer, one line per key, which `.env` values the ambient\n * process environment silently beat.\n *\n * Uses `console.warn` (stderr) rather than the `log` singleton on purpose:\n * this runs from `loadEnvironmentFiles()`, ahead of the logger connector in\n * the boot sequence, so any channel configured through `log.*` has nowhere to\n * deliver to yet. Same reasoning as `console.error` in\n * `src/http/boot-port-preflight.ts`.\n */\nexport function reportEnvironmentOverrides(overrides: EnvironmentOverride[]): void {\n  for (const override of overrides) {\n    const isSecretShaped = SECRET_KEY_PATTERN.test(override.key);\n    const effectiveValue = isSecretShaped ? REDACTED_PLACEHOLDER : override.effectiveValue;\n    const fileValue = isSecretShaped ? REDACTED_PLACEHOLDER : override.fileValue;\n\n    console.warn(\n      `[env] ${override.key}=${effectiveValue} is in effect from the process environment, overriding .env's ${override.key}=${fileValue}`,\n    );\n  }\n}\n"],"mappings":";;;;;;AAOA,MAAM,qBAAqB;AAE3B,MAAM,uBAAuB;;;;;;;;;;;AAY7B,SAAgB,2BAA2B,WAAwC;CACjF,KAAK,MAAM,YAAY,WAAW;EAChC,MAAM,iBAAiB,mBAAmB,KAAK,SAAS,GAAG;EAC3D,MAAM,iBAAiB,iBAAiB,uBAAuB,SAAS;EACxE,MAAM,YAAY,iBAAiB,uBAAuB,SAAS;EAEnE,QAAQ,KACN,SAAS,SAAS,IAAI,GAAG,eAAe,gEAAgE,SAAS,IAAI,GAAG,WAC1H;CACF;AACF"}

package/esm/utils/sleep.d.mts

@@ -1,4 +1,4 @@
-//#region ../core/src/utils/sleep.d.ts
+//#region ../../packages/core/src/utils/sleep.d.ts
 declare function sleep(ms: number): Promise<unknown>;
 //#endregion
 export { sleep };

package/esm/utils/sleep.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"sleep.d.mts","names":[],"sources":["../../../../../../../core/src/utils/sleep.ts"],"mappings":";iBAAgB,KAAA,CAAM,EAAA,WAAU,OAAA"}
+{"version":3,"file":"sleep.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/utils/sleep.ts"],"mappings":";iBAAgB,KAAA,CAAM,EAAA,WAAU,OAAA"}

package/esm/utils/sleep.mjs

@@ -1,4 +1,4 @@
-//#region ../core/src/utils/sleep.ts
+//#region ../../packages/core/src/utils/sleep.ts
 function sleep(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/esm/utils/sleep.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"sleep.mjs","names":[],"sources":["../../../../../../../core/src/utils/sleep.ts"],"sourcesContent":["export function sleep(ms: number) {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n"],"mappings":";AAAA,SAAgB,MAAM,IAAY;CAChC,OAAO,IAAI,SAAS,YAAY,WAAW,SAAS,EAAE,CAAC;AACzD"}
+{"version":3,"file":"sleep.mjs","names":[],"sources":["../../../../../../../../packages/core/src/utils/sleep.ts"],"sourcesContent":["export function sleep(ms: number) {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n"],"mappings":";AAAA,SAAgB,MAAM,IAAY;CAChC,OAAO,IAAI,SAAS,YAAY,WAAW,SAAS,EAAE,CAAC;AACzD"}

package/esm/utils/sluggable.d.mts

@@ -1,6 +1,6 @@
 import { Model } from "@warlock.js/cascade";
 
-//#region ../core/src/utils/sluggable.d.ts
+//#region ../../packages/core/src/utils/sluggable.d.ts
 /**
  * Used for model castings
  */

package/esm/utils/sluggable.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"sluggable.d.mts","names":[],"sources":["../../../../../../../core/src/utils/sluggable.ts"],"mappings":";;;;;AAMA;iBAAgB,SAAA,CAAU,YAAA,UAAsB,cAAA,aACtC,KAAA,EAAO,KAAK"}
+{"version":3,"file":"sluggable.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/utils/sluggable.ts"],"mappings":";;;;;AAMA;iBAAgB,SAAA,CAAU,YAAA,UAAsB,cAAA,aACtC,KAAA,EAAO,KAAK"}

package/esm/utils/sluggable.mjs

@@ -1,6 +1,6 @@
 import slug from "@mongez/slug";
 
-//#region ../core/src/utils/sluggable.ts
+//#region ../../packages/core/src/utils/sluggable.ts
 /**
 * Used for model castings
 */

package/esm/utils/sluggable.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"sluggable.mjs","names":[],"sources":["../../../../../../../core/src/utils/sluggable.ts"],"sourcesContent":["import slug from \"@mongez/slug\";\nimport type { Model } from \"@warlock.js/cascade\";\n\n/**\n * Used for model castings\n */\nexport function sluggable(generateFrom: string, slugLocaleCode = \"en\") {\n  return (model: Model) => {\n    let value = model.get(generateFrom);\n\n    if (!value) return \"\";\n\n    if (Array.isArray(value)) {\n      value = (value as any[]).find((value) => value.localeCode === slugLocaleCode)?.value;\n    }\n\n    const slugFunction = (slug as any).default || slug;\n\n    return slugFunction(String(value));\n  };\n}\n"],"mappings":";;;;;;AAMA,SAAgB,UAAU,cAAsB,iBAAiB,MAAM;CACrE,QAAQ,UAAiB;EACvB,IAAI,QAAQ,MAAM,IAAI,YAAY;EAElC,IAAI,CAAC,OAAO,OAAO;EAEnB,IAAI,MAAM,QAAQ,KAAK,GACrB,QAAS,MAAgB,MAAM,UAAU,MAAM,eAAe,cAAc,CAAC,EAAE;EAKjF,QAFsB,KAAa,WAAW,KAE3B,CAAC,OAAO,KAAK,CAAC;CACnC;AACF"}
+{"version":3,"file":"sluggable.mjs","names":[],"sources":["../../../../../../../../packages/core/src/utils/sluggable.ts"],"sourcesContent":["import slug from \"@mongez/slug\";\nimport type { Model } from \"@warlock.js/cascade\";\n\n/**\n * Used for model castings\n */\nexport function sluggable(generateFrom: string, slugLocaleCode = \"en\") {\n  return (model: Model) => {\n    let value = model.get(generateFrom);\n\n    if (!value) return \"\";\n\n    if (Array.isArray(value)) {\n      value = (value as any[]).find((value) => value.localeCode === slugLocaleCode)?.value;\n    }\n\n    const slugFunction = (slug as any).default || slug;\n\n    return slugFunction(String(value));\n  };\n}\n"],"mappings":";;;;;;AAMA,SAAgB,UAAU,cAAsB,iBAAiB,MAAM;CACrE,QAAQ,UAAiB;EACvB,IAAI,QAAQ,MAAM,IAAI,YAAY;EAElC,IAAI,CAAC,OAAO,OAAO;EAEnB,IAAI,MAAM,QAAQ,KAAK,GACrB,QAAS,MAAgB,MAAM,UAAU,MAAM,eAAe,cAAc,CAAC,EAAE;EAKjF,QAFsB,KAAa,WAAW,KAE3B,CAAC,OAAO,KAAK,CAAC;CACnC;AACF"}

package/esm/utils/to-json.d.mts

@@ -1,4 +1,4 @@
-//#region ../core/src/utils/to-json.d.ts
+//#region ../../packages/core/src/utils/to-json.d.ts
 declare function toJson(value: any): Promise<any>;
 //#endregion
 export { toJson };

package/esm/utils/to-json.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"to-json.d.mts","names":[],"sources":["../../../../../../../core/src/utils/to-json.ts"],"mappings":";iBAEsB,MAAA,CAAO,KAAA,QAAa,OAAO"}
+{"version":3,"file":"to-json.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/utils/to-json.ts"],"mappings":";iBAEsB,MAAA,CAAO,KAAA,QAAa,OAAO"}

package/esm/utils/to-json.mjs

@@ -1,6 +1,6 @@
 import { isIterable, isPlainObject, isScalar } from "@mongez/supportive-is";
 
-//#region ../core/src/utils/to-json.ts
+//#region ../../packages/core/src/utils/to-json.ts
 async function toJson(value) {
 	if (!value || isScalar(value)) return value;
 	if (value.toJSON) return await value.toJSON();

package/esm/utils/to-json.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"to-json.mjs","names":[],"sources":["../../../../../../../core/src/utils/to-json.ts"],"sourcesContent":["import { isIterable, isPlainObject, isScalar } from \"@mongez/supportive-is\";\n\nexport async function toJson(value: any): Promise<any> {\n  // if it is a falsy value, return it\n  if (!value || isScalar(value)) return value;\n\n  // if it has a `toJSON` method, call it and await the result then return it\n  if (value.toJSON) {\n    return await value.toJSON();\n  }\n\n  // if it is iterable, an array or array-like object then parse each item\n  if (isIterable(value)) {\n    const values = Array.from(value);\n\n    return Promise.all(\n      values.map(async (item: any) => {\n        return await toJson(item);\n      }),\n    );\n  }\n\n  // if not plain object, then return it\n  if (!isPlainObject(value)) {\n    return value;\n  }\n\n  // loop over the object and check if the value and call `parse` on it\n  for (const key in value) {\n    const subValue = value[key];\n\n    value[key] = await toJson(subValue);\n  }\n\n  return value;\n}\n"],"mappings":";;;AAEA,eAAsB,OAAO,OAA0B;CAErD,IAAI,CAAC,SAAS,SAAS,KAAK,GAAG,OAAO;CAGtC,IAAI,MAAM,QACR,OAAO,MAAM,MAAM,OAAO;CAI5B,IAAI,WAAW,KAAK,GAAG;EACrB,MAAM,SAAS,MAAM,KAAK,KAAK;EAE/B,OAAO,QAAQ,IACb,OAAO,IAAI,OAAO,SAAc;GAC9B,OAAO,MAAM,OAAO,IAAI;EAC1B,CAAC,CACH;CACF;CAGA,IAAI,CAAC,cAAc,KAAK,GACtB,OAAO;CAIT,KAAK,MAAM,OAAO,OAAO;EACvB,MAAM,WAAW,MAAM;EAEvB,MAAM,OAAO,MAAM,OAAO,QAAQ;CACpC;CAEA,OAAO;AACT"}
+{"version":3,"file":"to-json.mjs","names":[],"sources":["../../../../../../../../packages/core/src/utils/to-json.ts"],"sourcesContent":["import { isIterable, isPlainObject, isScalar } from \"@mongez/supportive-is\";\n\nexport async function toJson(value: any): Promise<any> {\n  // if it is a falsy value, return it\n  if (!value || isScalar(value)) return value;\n\n  // if it has a `toJSON` method, call it and await the result then return it\n  if (value.toJSON) {\n    return await value.toJSON();\n  }\n\n  // if it is iterable, an array or array-like object then parse each item\n  if (isIterable(value)) {\n    const values = Array.from(value);\n\n    return Promise.all(\n      values.map(async (item: any) => {\n        return await toJson(item);\n      }),\n    );\n  }\n\n  // if not plain object, then return it\n  if (!isPlainObject(value)) {\n    return value;\n  }\n\n  // loop over the object and check if the value and call `parse` on it\n  for (const key in value) {\n    const subValue = value[key];\n\n    value[key] = await toJson(subValue);\n  }\n\n  return value;\n}\n"],"mappings":";;;AAEA,eAAsB,OAAO,OAA0B;CAErD,IAAI,CAAC,SAAS,SAAS,KAAK,GAAG,OAAO;CAGtC,IAAI,MAAM,QACR,OAAO,MAAM,MAAM,OAAO;CAI5B,IAAI,WAAW,KAAK,GAAG;EACrB,MAAM,SAAS,MAAM,KAAK,KAAK;EAE/B,OAAO,QAAQ,IACb,OAAO,IAAI,OAAO,SAAc;GAC9B,OAAO,MAAM,OAAO,IAAI;EAC1B,CAAC,CACH;CACF;CAGA,IAAI,CAAC,cAAc,KAAK,GACtB,OAAO;CAIT,KAAK,MAAM,OAAO,OAAO;EACvB,MAAM,WAAW,MAAM;EAEvB,MAAM,OAAO,MAAM,OAAO,QAAQ;CACpC;CAEA,OAAO;AACT"}

package/esm/utils/types.d.mts

@@ -1,4 +1,4 @@
-//#region ../core/src/utils/types.d.ts
+//#region ../../packages/core/src/utils/types.d.ts
 type AppConfigurations = {
   /**
    * Set default timezone

package/esm/utils/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../../core/src/utils/types.ts"],"mappings":";KAAY,iBAAA;EAAA;;;EAIV,QAAA;EAAA;;;EAIA,OAAA;EAcA;;AAAO;;;EARP,UAAA;;;;EAIA,WAAA;;;;EAIA,OAAA;AAAA"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/utils/types.ts"],"mappings":";KAAY,iBAAA;EAAA;;;EAIV,QAAA;EAAA;;;EAIA,OAAA;EAcA;;AAAO;;;EARP,UAAA;;;;EAIA,WAAA;;;;EAIA,OAAA;AAAA"}

package/esm/utils/urls.d.mts

@@ -1,4 +1,4 @@
-//#region ../core/src/utils/urls.d.ts
+//#region ../../packages/core/src/utils/urls.d.ts
 /**
  * Set base url
  */

package/esm/utils/urls.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"urls.d.mts","names":[],"sources":["../../../../../../../core/src/utils/urls.ts"],"mappings":";;AAOA;;iBAAgB,UAAA,CAAW,GAAW;;AAAA;AAOtC;iBAAgB,GAAA,CAAI,IAAS;;;AAAA;iBAOb,UAAA,CAAW,IAAS;;;;iBAOpB,SAAA,CAAU,IAAS;AAAnC;;;AAAA,iBAOgB,SAAA,CAAU,IAAS"}
+{"version":3,"file":"urls.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/utils/urls.ts"],"mappings":";;AAOA;;iBAAgB,UAAA,CAAW,GAAW;;AAAA;AAOtC;iBAAgB,GAAA,CAAI,IAAS;;;AAAA;iBAOb,UAAA,CAAW,IAAS;;;;iBAOpB,SAAA,CAAU,IAAS;AAAnC;;;AAAA,iBAOgB,SAAA,CAAU,IAAS"}

package/esm/utils/urls.mjs

@@ -1,6 +1,6 @@
 import { ltrim, rtrim } from "@mongez/reinforcements";
 
-//#region ../core/src/utils/urls.ts
+//#region ../../packages/core/src/utils/urls.ts
 let baseUrl = "";
 /**
 * Set base url

package/esm/utils/urls.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"urls.mjs","names":[],"sources":["../../../../../../../core/src/utils/urls.ts"],"sourcesContent":["import { ltrim, rtrim } from \"@mongez/reinforcements\";\n\nlet baseUrl = \"\";\n\n/**\n * Set base url\n */\nexport function setBaseUrl(url: string) {\n  baseUrl = url;\n}\n\n/**\n * Get full path for the given path\n */\nexport function url(path = \"\") {\n  return rtrim(baseUrl, \"/\") + \"/\" + ltrim(path, \"/\");\n}\n\n/**\n * Get uploads url\n */\nexport function uploadsUrl(path = \"\") {\n  return url(\"/uploads/\" + ltrim(path, \"/\"));\n}\n\n/**\n * Get full path for the given path related to public route\n */\nexport function publicUrl(path = \"\") {\n  return url(\"/public/\" + ltrim(path, \"/\"));\n}\n\n/**\n * Assets url\n */\nexport function assetsUrl(path = \"\") {\n  return publicUrl(\"/assets/\" + ltrim(path, \"/\"));\n}\n"],"mappings":";;;AAEA,IAAI,UAAU;;;;AAKd,SAAgB,WAAW,KAAa;CACtC,UAAU;AACZ;;;;AAKA,SAAgB,IAAI,OAAO,IAAI;CAC7B,OAAO,MAAM,SAAS,GAAG,IAAI,MAAM,MAAM,MAAM,GAAG;AACpD;;;;AAKA,SAAgB,WAAW,OAAO,IAAI;CACpC,OAAO,IAAI,cAAc,MAAM,MAAM,GAAG,CAAC;AAC3C;;;;AAKA,SAAgB,UAAU,OAAO,IAAI;CACnC,OAAO,IAAI,aAAa,MAAM,MAAM,GAAG,CAAC;AAC1C;;;;AAKA,SAAgB,UAAU,OAAO,IAAI;CACnC,OAAO,UAAU,aAAa,MAAM,MAAM,GAAG,CAAC;AAChD"}
+{"version":3,"file":"urls.mjs","names":[],"sources":["../../../../../../../../packages/core/src/utils/urls.ts"],"sourcesContent":["import { ltrim, rtrim } from \"@mongez/reinforcements\";\n\nlet baseUrl = \"\";\n\n/**\n * Set base url\n */\nexport function setBaseUrl(url: string) {\n  baseUrl = url;\n}\n\n/**\n * Get full path for the given path\n */\nexport function url(path = \"\") {\n  return rtrim(baseUrl, \"/\") + \"/\" + ltrim(path, \"/\");\n}\n\n/**\n * Get uploads url\n */\nexport function uploadsUrl(path = \"\") {\n  return url(\"/uploads/\" + ltrim(path, \"/\"));\n}\n\n/**\n * Get full path for the given path related to public route\n */\nexport function publicUrl(path = \"\") {\n  return url(\"/public/\" + ltrim(path, \"/\"));\n}\n\n/**\n * Assets url\n */\nexport function assetsUrl(path = \"\") {\n  return publicUrl(\"/assets/\" + ltrim(path, \"/\"));\n}\n"],"mappings":";;;AAEA,IAAI,UAAU;;;;AAKd,SAAgB,WAAW,KAAa;CACtC,UAAU;AACZ;;;;AAKA,SAAgB,IAAI,OAAO,IAAI;CAC7B,OAAO,MAAM,SAAS,GAAG,IAAI,MAAM,MAAM,MAAM,GAAG;AACpD;;;;AAKA,SAAgB,WAAW,OAAO,IAAI;CACpC,OAAO,IAAI,cAAc,MAAM,MAAM,GAAG,CAAC;AAC3C;;;;AAKA,SAAgB,UAAU,OAAO,IAAI;CACnC,OAAO,IAAI,aAAa,MAAM,MAAM,GAAG,CAAC;AAC1C;;;;AAKA,SAAgB,UAAU,OAAO,IAAI;CACnC,OAAO,UAAU,aAAa,MAAM,MAAM,GAAG,CAAC;AAChD"}

package/esm/utils/version-compare.d.mts

@@ -1,4 +1,4 @@
-//#region ../core/src/utils/version-compare.d.ts
+//#region ../../packages/core/src/utils/version-compare.d.ts
 /**
  * Zero-dependency semver comparison — just enough for the framework's
  * self-update tooling (the dev-server update notice + the `warlock update`

package/esm/utils/version-compare.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"version-compare.d.mts","names":[],"sources":["../../../../../../../core/src/utils/version-compare.ts"],"mappings":";;AAiHA;;;;AAA8D;;;;;;;;;;iBAA9C,cAAA,CAAe,MAAA,UAAgB,OAAe"}
+{"version":3,"file":"version-compare.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/utils/version-compare.ts"],"mappings":";;AAiHA;;;;AAA8D;;;;;;;;;;iBAA9C,cAAA,CAAe,MAAA,UAAgB,OAAe"}

package/esm/utils/version-compare.mjs

@@ -1,4 +1,4 @@
-//#region ../core/src/utils/version-compare.ts
+//#region ../../packages/core/src/utils/version-compare.ts
 /**
 * Parse a semver string into its numeric core + prerelease identifiers.
 * Tolerates a leading `v` and ignores build metadata (`+…`). Returns

package/esm/utils/version-compare.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"version-compare.mjs","names":[],"sources":["../../../../../../../core/src/utils/version-compare.ts"],"sourcesContent":["/**\n * Zero-dependency semver comparison — just enough for the framework's\n * self-update tooling (the dev-server update notice + the `warlock update`\n * command).\n *\n * We deliberately avoid pulling in a semver library: the only question these\n * callers ask is \"is the published version newer than what's installed?\".\n */\n\ntype ParsedVersion = {\n  /** Numeric core as `[major, minor, patch]`. */\n  core: [number, number, number];\n  /** Dot-separated prerelease identifiers; empty for a stable release. */\n  prerelease: string[];\n};\n\n/**\n * Parse a semver string into its numeric core + prerelease identifiers.\n * Tolerates a leading `v` and ignores build metadata (`+…`). Returns\n * `undefined` when the core isn't exactly three non-negative integers.\n */\nfunction parseVersion(version: string): ParsedVersion | undefined {\n  const cleaned = version.trim().replace(/^v/i, \"\");\n  const [coreAndPrerelease] = cleaned.split(\"+\"); // drop build metadata\n\n  if (!coreAndPrerelease) {\n    return undefined;\n  }\n\n  const [core, ...prereleaseParts] = coreAndPrerelease.split(\"-\");\n\n  if (!core) {\n    return undefined;\n  }\n  const segments = core.split(\".\");\n\n  if (segments.length !== 3) {\n    return undefined;\n  }\n\n  const numbers = segments.map((segment) => Number(segment));\n\n  if (numbers.some((value) => !Number.isInteger(value) || value < 0)) {\n    return undefined;\n  }\n\n  const prerelease = prereleaseParts.length > 0 ? prereleaseParts.join(\"-\").split(\".\") : [];\n\n  const [major, minor, patch] = numbers;\n\n  if (major === undefined || minor === undefined || patch === undefined) {\n    return undefined;\n  }\n\n  return {\n    core: [major, minor, patch],\n    prerelease,\n  };\n}\n\n/**\n * Compare two prerelease identifier lists per semver rules: numeric\n * identifiers compare numerically, alphanumeric ones lexically, a numeric\n * identifier ranks below an alphanumeric one, and a longer list wins when\n * otherwise equal. Returns a negative / zero / positive number.\n */\nfunction comparePrerelease(left: string[], right: string[]): number {\n  const length = Math.max(left.length, right.length);\n\n  for (let index = 0; index < length; index++) {\n    const a = left[index];\n    const b = right[index];\n\n    if (a === undefined) {\n      return -1;\n    }\n\n    if (b === undefined) {\n      return 1;\n    }\n\n    const aIsNumeric = /^\\d+$/.test(a);\n    const bIsNumeric = /^\\d+$/.test(b);\n\n    if (aIsNumeric && bIsNumeric) {\n      const diff = Number(a) - Number(b);\n\n      if (diff !== 0) {\n        return diff;\n      }\n\n      continue;\n    }\n\n    if (aIsNumeric !== bIsNumeric) {\n      return aIsNumeric ? -1 : 1;\n    }\n\n    if (a !== b) {\n      return a < b ? -1 : 1;\n    }\n  }\n\n  return 0;\n}\n\n/**\n * Return `true` when `latest` is a strictly newer semantic version than\n * `current`. Compares the numeric `major.minor.patch` first, then treats a\n * stable release as newer than a prerelease of the same core\n * (`1.2.0` > `1.2.0-beta`). Unparseable input yields `false` — we never nag\n * on a version string we can't understand.\n */\nexport function isNewerVersion(latest: string, current: string): boolean {\n  const latestParsed = parseVersion(latest);\n  const currentParsed = parseVersion(current);\n\n  if (!latestParsed || !currentParsed) {\n    return false;\n  }\n\n  for (let index = 0; index < 3; index++) {\n    const latestPart = latestParsed.core[index];\n    const currentPart = currentParsed.core[index];\n\n    // A parsed semver core is always three numbers, so both reads hold. Treating\n    // a missing part as 0 rather than asserting: this decides whether to tell\n    // the user a NEWER VERSION EXISTS, and `undefined > undefined` is `false` —\n    // so an assertion would silently answer \"not newer\" and suppress the\n    // notice, which is the failure nobody would ever notice happening.\n    if (latestPart !== currentPart) {\n      return (latestPart ?? 0) > (currentPart ?? 0);\n    }\n  }\n\n  // Equal numeric core — order by prerelease (a stable release beats a prerelease).\n  const latestIsStable = latestParsed.prerelease.length === 0;\n  const currentIsStable = currentParsed.prerelease.length === 0;\n\n  if (latestIsStable && currentIsStable) {\n    return false;\n  }\n\n  if (latestIsStable !== currentIsStable) {\n    return latestIsStable;\n  }\n\n  return comparePrerelease(latestParsed.prerelease, currentParsed.prerelease) > 0;\n}\n"],"mappings":";;;;;;AAqBA,SAAS,aAAa,SAA4C;CAEhE,MAAM,CAAC,qBADS,QAAQ,KAAK,CAAC,CAAC,QAAQ,OAAO,EACZ,CAAC,CAAC,MAAM,GAAG;CAE7C,IAAI,CAAC,mBACH;CAGF,MAAM,CAAC,MAAM,GAAG,mBAAmB,kBAAkB,MAAM,GAAG;CAE9D,IAAI,CAAC,MACH;CAEF,MAAM,WAAW,KAAK,MAAM,GAAG;CAE/B,IAAI,SAAS,WAAW,GACtB;CAGF,MAAM,UAAU,SAAS,KAAK,YAAY,OAAO,OAAO,CAAC;CAEzD,IAAI,QAAQ,MAAM,UAAU,CAAC,OAAO,UAAU,KAAK,KAAK,QAAQ,CAAC,GAC/D;CAGF,MAAM,aAAa,gBAAgB,SAAS,IAAI,gBAAgB,KAAK,GAAG,CAAC,CAAC,MAAM,GAAG,IAAI,CAAC;CAExF,MAAM,CAAC,OAAO,OAAO,SAAS;CAE9B,IAAI,UAAU,UAAa,UAAU,UAAa,UAAU,QAC1D;CAGF,OAAO;EACL,MAAM;GAAC;GAAO;GAAO;EAAK;EAC1B;CACF;AACF;;;;;;;AAQA,SAAS,kBAAkB,MAAgB,OAAyB;CAClE,MAAM,SAAS,KAAK,IAAI,KAAK,QAAQ,MAAM,MAAM;CAEjD,KAAK,IAAI,QAAQ,GAAG,QAAQ,QAAQ,SAAS;EAC3C,MAAM,IAAI,KAAK;EACf,MAAM,IAAI,MAAM;EAEhB,IAAI,MAAM,QACR,OAAO;EAGT,IAAI,MAAM,QACR,OAAO;EAGT,MAAM,aAAa,QAAQ,KAAK,CAAC;EACjC,MAAM,aAAa,QAAQ,KAAK,CAAC;EAEjC,IAAI,cAAc,YAAY;GAC5B,MAAM,OAAO,OAAO,CAAC,IAAI,OAAO,CAAC;GAEjC,IAAI,SAAS,GACX,OAAO;GAGT;EACF;EAEA,IAAI,eAAe,YACjB,OAAO,aAAa,KAAK;EAG3B,IAAI,MAAM,GACR,OAAO,IAAI,IAAI,KAAK;CAExB;CAEA,OAAO;AACT;;;;;;;;AASA,SAAgB,eAAe,QAAgB,SAA0B;CACvE,MAAM,eAAe,aAAa,MAAM;CACxC,MAAM,gBAAgB,aAAa,OAAO;CAE1C,IAAI,CAAC,gBAAgB,CAAC,eACpB,OAAO;CAGT,KAAK,IAAI,QAAQ,GAAG,QAAQ,GAAG,SAAS;EACtC,MAAM,aAAa,aAAa,KAAK;EACrC,MAAM,cAAc,cAAc,KAAK;EAOvC,IAAI,eAAe,aACjB,QAAQ,cAAc,MAAM,eAAe;CAE/C;CAGA,MAAM,iBAAiB,aAAa,WAAW,WAAW;CAC1D,MAAM,kBAAkB,cAAc,WAAW,WAAW;CAE5D,IAAI,kBAAkB,iBACpB,OAAO;CAGT,IAAI,mBAAmB,iBACrB,OAAO;CAGT,OAAO,kBAAkB,aAAa,YAAY,cAAc,UAAU,IAAI;AAChF"}
+{"version":3,"file":"version-compare.mjs","names":[],"sources":["../../../../../../../../packages/core/src/utils/version-compare.ts"],"sourcesContent":["/**\n * Zero-dependency semver comparison — just enough for the framework's\n * self-update tooling (the dev-server update notice + the `warlock update`\n * command).\n *\n * We deliberately avoid pulling in a semver library: the only question these\n * callers ask is \"is the published version newer than what's installed?\".\n */\n\ntype ParsedVersion = {\n  /** Numeric core as `[major, minor, patch]`. */\n  core: [number, number, number];\n  /** Dot-separated prerelease identifiers; empty for a stable release. */\n  prerelease: string[];\n};\n\n/**\n * Parse a semver string into its numeric core + prerelease identifiers.\n * Tolerates a leading `v` and ignores build metadata (`+…`). Returns\n * `undefined` when the core isn't exactly three non-negative integers.\n */\nfunction parseVersion(version: string): ParsedVersion | undefined {\n  const cleaned = version.trim().replace(/^v/i, \"\");\n  const [coreAndPrerelease] = cleaned.split(\"+\"); // drop build metadata\n\n  if (!coreAndPrerelease) {\n    return undefined;\n  }\n\n  const [core, ...prereleaseParts] = coreAndPrerelease.split(\"-\");\n\n  if (!core) {\n    return undefined;\n  }\n  const segments = core.split(\".\");\n\n  if (segments.length !== 3) {\n    return undefined;\n  }\n\n  const numbers = segments.map((segment) => Number(segment));\n\n  if (numbers.some((value) => !Number.isInteger(value) || value < 0)) {\n    return undefined;\n  }\n\n  const prerelease = prereleaseParts.length > 0 ? prereleaseParts.join(\"-\").split(\".\") : [];\n\n  const [major, minor, patch] = numbers;\n\n  if (major === undefined || minor === undefined || patch === undefined) {\n    return undefined;\n  }\n\n  return {\n    core: [major, minor, patch],\n    prerelease,\n  };\n}\n\n/**\n * Compare two prerelease identifier lists per semver rules: numeric\n * identifiers compare numerically, alphanumeric ones lexically, a numeric\n * identifier ranks below an alphanumeric one, and a longer list wins when\n * otherwise equal. Returns a negative / zero / positive number.\n */\nfunction comparePrerelease(left: string[], right: string[]): number {\n  const length = Math.max(left.length, right.length);\n\n  for (let index = 0; index < length; index++) {\n    const a = left[index];\n    const b = right[index];\n\n    if (a === undefined) {\n      return -1;\n    }\n\n    if (b === undefined) {\n      return 1;\n    }\n\n    const aIsNumeric = /^\\d+$/.test(a);\n    const bIsNumeric = /^\\d+$/.test(b);\n\n    if (aIsNumeric && bIsNumeric) {\n      const diff = Number(a) - Number(b);\n\n      if (diff !== 0) {\n        return diff;\n      }\n\n      continue;\n    }\n\n    if (aIsNumeric !== bIsNumeric) {\n      return aIsNumeric ? -1 : 1;\n    }\n\n    if (a !== b) {\n      return a < b ? -1 : 1;\n    }\n  }\n\n  return 0;\n}\n\n/**\n * Return `true` when `latest` is a strictly newer semantic version than\n * `current`. Compares the numeric `major.minor.patch` first, then treats a\n * stable release as newer than a prerelease of the same core\n * (`1.2.0` > `1.2.0-beta`). Unparseable input yields `false` — we never nag\n * on a version string we can't understand.\n */\nexport function isNewerVersion(latest: string, current: string): boolean {\n  const latestParsed = parseVersion(latest);\n  const currentParsed = parseVersion(current);\n\n  if (!latestParsed || !currentParsed) {\n    return false;\n  }\n\n  for (let index = 0; index < 3; index++) {\n    const latestPart = latestParsed.core[index];\n    const currentPart = currentParsed.core[index];\n\n    // A parsed semver core is always three numbers, so both reads hold. Treating\n    // a missing part as 0 rather than asserting: this decides whether to tell\n    // the user a NEWER VERSION EXISTS, and `undefined > undefined` is `false` —\n    // so an assertion would silently answer \"not newer\" and suppress the\n    // notice, which is the failure nobody would ever notice happening.\n    if (latestPart !== currentPart) {\n      return (latestPart ?? 0) > (currentPart ?? 0);\n    }\n  }\n\n  // Equal numeric core — order by prerelease (a stable release beats a prerelease).\n  const latestIsStable = latestParsed.prerelease.length === 0;\n  const currentIsStable = currentParsed.prerelease.length === 0;\n\n  if (latestIsStable && currentIsStable) {\n    return false;\n  }\n\n  if (latestIsStable !== currentIsStable) {\n    return latestIsStable;\n  }\n\n  return comparePrerelease(latestParsed.prerelease, currentParsed.prerelease) > 0;\n}\n"],"mappings":";;;;;;AAqBA,SAAS,aAAa,SAA4C;CAEhE,MAAM,CAAC,qBADS,QAAQ,KAAK,CAAC,CAAC,QAAQ,OAAO,EACZ,CAAC,CAAC,MAAM,GAAG;CAE7C,IAAI,CAAC,mBACH;CAGF,MAAM,CAAC,MAAM,GAAG,mBAAmB,kBAAkB,MAAM,GAAG;CAE9D,IAAI,CAAC,MACH;CAEF,MAAM,WAAW,KAAK,MAAM,GAAG;CAE/B,IAAI,SAAS,WAAW,GACtB;CAGF,MAAM,UAAU,SAAS,KAAK,YAAY,OAAO,OAAO,CAAC;CAEzD,IAAI,QAAQ,MAAM,UAAU,CAAC,OAAO,UAAU,KAAK,KAAK,QAAQ,CAAC,GAC/D;CAGF,MAAM,aAAa,gBAAgB,SAAS,IAAI,gBAAgB,KAAK,GAAG,CAAC,CAAC,MAAM,GAAG,IAAI,CAAC;CAExF,MAAM,CAAC,OAAO,OAAO,SAAS;CAE9B,IAAI,UAAU,UAAa,UAAU,UAAa,UAAU,QAC1D;CAGF,OAAO;EACL,MAAM;GAAC;GAAO;GAAO;EAAK;EAC1B;CACF;AACF;;;;;;;AAQA,SAAS,kBAAkB,MAAgB,OAAyB;CAClE,MAAM,SAAS,KAAK,IAAI,KAAK,QAAQ,MAAM,MAAM;CAEjD,KAAK,IAAI,QAAQ,GAAG,QAAQ,QAAQ,SAAS;EAC3C,MAAM,IAAI,KAAK;EACf,MAAM,IAAI,MAAM;EAEhB,IAAI,MAAM,QACR,OAAO;EAGT,IAAI,MAAM,QACR,OAAO;EAGT,MAAM,aAAa,QAAQ,KAAK,CAAC;EACjC,MAAM,aAAa,QAAQ,KAAK,CAAC;EAEjC,IAAI,cAAc,YAAY;GAC5B,MAAM,OAAO,OAAO,CAAC,IAAI,OAAO,CAAC;GAEjC,IAAI,SAAS,GACX,OAAO;GAGT;EACF;EAEA,IAAI,eAAe,YACjB,OAAO,aAAa,KAAK;EAG3B,IAAI,MAAM,GACR,OAAO,IAAI,IAAI,KAAK;CAExB;CAEA,OAAO;AACT;;;;;;;;AASA,SAAgB,eAAe,QAAgB,SAA0B;CACvE,MAAM,eAAe,aAAa,MAAM;CACxC,MAAM,gBAAgB,aAAa,OAAO;CAE1C,IAAI,CAAC,gBAAgB,CAAC,eACpB,OAAO;CAGT,KAAK,IAAI,QAAQ,GAAG,QAAQ,GAAG,SAAS;EACtC,MAAM,aAAa,aAAa,KAAK;EACrC,MAAM,cAAc,cAAc,KAAK;EAOvC,IAAI,eAAe,aACjB,QAAQ,cAAc,MAAM,eAAe;CAE/C;CAGA,MAAM,iBAAiB,aAAa,WAAW,WAAW;CAC1D,MAAM,kBAAkB,cAAc,WAAW,WAAW;CAE5D,IAAI,kBAAkB,iBACpB,OAAO;CAGT,IAAI,mBAAmB,iBACrB,OAAO;CAGT,OAAO,kBAAkB,aAAa,YAAY,cAAc,UAAU,IAAI;AAChF"}

package/esm/validation/database/exists-except-current-id.d.mts

@@ -1,7 +1,7 @@
 import { ExistsExceptCurrentIdRuleOptions } from "./types.mjs";
 import { SchemaRule } from "@warlock.js/seal";
 
-//#region ../core/src/validation/database/exists-except-current-id.d.ts
+//#region ../../packages/core/src/validation/database/exists-except-current-id.d.ts
 /**
  * Exists except current ID rule
  */

package/esm/validation/database/exists-except-current-id.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"exists-except-current-id.d.mts","names":[],"sources":["../../../../../../../../core/src/validation/database/exists-except-current-id.ts"],"mappings":";;;;;;;cAQa,yBAAA,EAA2B,UAAU,CAAC,gCAAA"}
+{"version":3,"file":"exists-except-current-id.d.mts","names":[],"sources":["../../../../../../../../../packages/core/src/validation/database/exists-except-current-id.ts"],"mappings":";;;;;;;cAQa,yBAAA,EAA2B,UAAU,CAAC,gCAAA"}