@warlock.js/core 4.1.15 → 4.2.0

package/esm/dev-server/loader/own-resolver.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"own-resolver.mjs","names":[],"sources":["../../../../../../../@warlock.js/core/src/dev-server/loader/own-resolver.ts"],"sourcesContent":["import { fileURLToPath, pathToFileURL, URL } from \"node:url\";\n\n/**\n * The framework's own ESM `resolve()` core — the Phase B replacement for\n * delegating resolution to tsx.\n *\n * Scope by design: it owns exactly what Node's default resolver cannot do\n * (TypeScript extension/`index` probing and tsconfig `paths` aliases). For\n * anything else — bare npm packages, `node:` builtins, `file:`/`data:`\n * specifiers — it returns `null`, meaning \"not mine, fall through to the\n * next resolver\" (Node default, which already honours `node_modules` and\n * package `exports`). That keeps the risky surface minimal: we only have\n * to reproduce tsx's TS-path behaviour, not re-implement npm resolution.\n *\n * Pure and dependency-injected (`pathsMatcher`, `fileExists`) so the whole\n * thing is unit-testable and verifiable against the captured tsx-4.21\n * golden fixture without booting.\n */\n\nexport type PathsMatcher = (specifier: string) => string[];\nexport type FileExists = (absolutePath: string) => boolean;\n\n/**\n * Extension/`index` probing for one candidate base path, mirroring tsx's\n * TypeScript-aware order:\n *\n * 1. exact (if it already has a real extension that exists)\n * 2. `.js`/`.jsx`/`.mjs`/`.cjs` specifier → the TS source it compiles from\n *    (`.ts`/`.tsx`) — the standard \"import the .js, ship the .ts\" ESM style\n * 3. append `.ts`, `.tsx`, `.js`, `.jsx`, `.json`\n * 4. directory index: `<dir>/index.{ts,tsx,js,jsx}`\n *\n * Returns the resolved absolute path, or `null` if nothing exists.\n */\nexport function probeFile(basePath: string, fileExists: FileExists): string | null {\n  // 2. `.js` → `.ts`/`.tsx` rewrite (checked before the literal .js so a\n  //    co-located source wins, matching tsx).\n  const jsRewrite = basePath.match(/\\.(js|jsx|mjs|cjs)$/);\n  if (jsRewrite) {\n    const stem = basePath.slice(0, -jsRewrite[0].length);\n    for (const ext of [\".ts\", \".tsx\"]) {\n      if (fileExists(stem + ext)) return stem + ext;\n    }\n  }\n\n  // 1. exact (real extension already present and on disk)\n  if (/\\.[a-z]+$/i.test(basePath) && fileExists(basePath)) {\n    return basePath;\n  }\n\n  // 3. append source/asset extensions\n  for (const ext of [\".ts\", \".tsx\", \".js\", \".jsx\", \".json\"]) {\n    if (fileExists(basePath + ext)) return basePath + ext;\n  }\n\n  // 4. directory index\n  for (const ext of [\".ts\", \".tsx\", \".js\", \".jsx\"]) {\n    const candidate = `${basePath}/index${ext}`;\n    if (fileExists(candidate)) return candidate;\n  }\n\n  return null;\n}\n\nfunction isRelative(specifier: string): boolean {\n  return specifier.startsWith(\"./\") || specifier.startsWith(\"../\");\n}\n\n/**\n * Resolve `specifier` to a `file://` URL we own, or `null` to fall through\n * to the next resolver.\n *\n * @param specifier  - The import specifier.\n * @param parentURL  - Importing module's URL (already `?v=N`-stripped).\n * @param pathsMatcher - `get-tsconfig` paths matcher (alias → candidates).\n * @param fileExists - Existence probe (injected for testing).\n */\nexport function ownResolve(\n  specifier: string,\n  parentURL: string | undefined,\n  pathsMatcher: PathsMatcher | null,\n  fileExists: FileExists,\n): string | null {\n  // Not ours: builtins and already-formed URLs (config-loader imports by\n  // file: URL). Node default handles these.\n  if (\n    specifier.startsWith(\"node:\") ||\n    specifier.startsWith(\"file:\") ||\n    specifier.startsWith(\"data:\")\n  ) {\n    return null;\n  }\n\n  // Relative / absolute path imports → probe against the parent's dir.\n  if (isRelative(specifier) || specifier.startsWith(\"/\") || /^[a-zA-Z]:[\\\\/]/.test(specifier)) {\n    if (!parentURL) return null;\n    const base = fileURLToPath(new URL(specifier, parentURL));\n    const hit = probeFile(base.replace(/\\\\/g, \"/\"), fileExists);\n    return hit ? pathToFileURL(hit).href : null;\n  }\n\n  // Bare / aliased: try tsconfig `paths`. Each candidate is probed; the\n  // first that exists on disk wins. If none do (e.g. a real npm package\n  // whose name happened to match a baseUrl guess), return null so Node\n  // default resolves it from node_modules with full `exports` support.\n  if (pathsMatcher) {\n    for (const candidate of pathsMatcher(specifier)) {\n      const hit = probeFile(candidate.replace(/\\\\/g, \"/\"), fileExists);\n      if (hit) return pathToFileURL(hit).href;\n    }\n  }\n\n  return null;\n}\n"],"mappings":";;;;;;;;;;;;;;;AAkCA,SAAgB,UAAU,UAAkB,YAAuC;CAGjF,MAAM,YAAY,SAAS,MAAM,qBAAqB;CACtD,IAAI,WAAW;EACb,MAAM,OAAO,SAAS,MAAM,GAAG,CAAC,UAAU,GAAG,MAAM;EACnD,KAAK,MAAM,OAAO,CAAC,OAAO,MAAM,GAC9B,IAAI,WAAW,OAAO,GAAG,GAAG,OAAO,OAAO;CAE9C;CAGA,IAAI,aAAa,KAAK,QAAQ,KAAK,WAAW,QAAQ,GACpD,OAAO;CAIT,KAAK,MAAM,OAAO;EAAC;EAAO;EAAQ;EAAO;EAAQ;CAAO,GACtD,IAAI,WAAW,WAAW,GAAG,GAAG,OAAO,WAAW;CAIpD,KAAK,MAAM,OAAO;EAAC;EAAO;EAAQ;EAAO;CAAM,GAAG;EAChD,MAAM,YAAY,GAAG,SAAS,QAAQ;EACtC,IAAI,WAAW,SAAS,GAAG,OAAO;CACpC;CAEA,OAAO;AACT;AAEA,SAAS,WAAW,WAA4B;CAC9C,OAAO,UAAU,WAAW,IAAI,KAAK,UAAU,WAAW,KAAK;AACjE;;;;;;;;;;AAWA,SAAgB,WACd,WACA,WACA,cACA,YACe;CAGf,IACE,UAAU,WAAW,OAAO,KAC5B,UAAU,WAAW,OAAO,KAC5B,UAAU,WAAW,OAAO,GAE5B,OAAO;CAIT,IAAI,WAAW,SAAS,KAAK,UAAU,WAAW,GAAG,KAAK,kBAAkB,KAAK,SAAS,GAAG;EAC3F,IAAI,CAAC,WAAW,OAAO;EAEvB,MAAM,MAAM,UADC,cAAc,IAAI,IAAI,WAAW,SAAS,CAC9B,EAAE,QAAQ,OAAO,GAAG,GAAG,UAAU;EAC1D,OAAO,MAAM,cAAc,GAAG,EAAE,OAAO;CACzC;CAMA,IAAI,cACF,KAAK,MAAM,aAAa,aAAa,SAAS,GAAG;EAC/C,MAAM,MAAM,UAAU,UAAU,QAAQ,OAAO,GAAG,GAAG,UAAU;EAC/D,IAAI,KAAK,OAAO,cAAc,GAAG,EAAE;CACrC;CAGF,OAAO;AACT"}

package/esm/dev-server/loader/resolve-capture.mjs

@@ -1,43 +0,0 @@
-import { appendFileSync } from "node:fs";
-
-//#region ../../@warlock.js/core/src/dev-server/loader/resolve-capture.ts
-/**
-* Golden-fixture recorder for the Phase B resolver work.
-*
-* When `WARLOCK_RESOLVE_CAPTURE` points at a file path, every resolution
-* the *current* (tsx-backed) hook performs is appended there as one JSON
-* object per line: `{ specifier, parentURL, url, format }`, all with the
-* `?v=N` HMR token stripped so the record is stable across runs.
-*
-* A full `yarn start` boot then yields the real import graph's resolutions
-* — tsconfig paths, workspace `@warlock.js/*`, relative/extensionless,
-* package `exports`, bare npm, `node:` builtins — as the ground truth the
-* replacement resolver must reproduce exactly.
-*
-* Disabled (the default) it is a single env-var read and an immediate
-* return: no measurable cost on the resolve hot path.
-*/
-const VERSION_QUERY = /\?v=\d+$/;
-let resolvedPath;
-function targetFile() {
-	if (resolvedPath !== void 0) return resolvedPath;
-	resolvedPath = process.env.WARLOCK_RESOLVE_CAPTURE || null;
-	return resolvedPath;
-}
-function captureResolution(record) {
-	const file = targetFile();
-	if (!file) return;
-	const line = JSON.stringify({
-		specifier: record.specifier,
-		parentURL: record.parentURL?.replace(VERSION_QUERY, ""),
-		url: record.url.replace(VERSION_QUERY, ""),
-		format: record.format
-	}) + "\n";
-	try {
-		appendFileSync(file, line);
-	} catch {}
-}
-
-//#endregion
-export { captureResolution };
-//# sourceMappingURL=resolve-capture.mjs.map

package/esm/dev-server/loader/resolve-capture.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolve-capture.mjs","names":[],"sources":["../../../../../../../@warlock.js/core/src/dev-server/loader/resolve-capture.ts"],"sourcesContent":["import { appendFileSync } from \"node:fs\";\n\n/**\n * Golden-fixture recorder for the Phase B resolver work.\n *\n * When `WARLOCK_RESOLVE_CAPTURE` points at a file path, every resolution\n * the *current* (tsx-backed) hook performs is appended there as one JSON\n * object per line: `{ specifier, parentURL, url, format }`, all with the\n * `?v=N` HMR token stripped so the record is stable across runs.\n *\n * A full `yarn start` boot then yields the real import graph's resolutions\n * — tsconfig paths, workspace `@warlock.js/*`, relative/extensionless,\n * package `exports`, bare npm, `node:` builtins — as the ground truth the\n * replacement resolver must reproduce exactly.\n *\n * Disabled (the default) it is a single env-var read and an immediate\n * return: no measurable cost on the resolve hot path.\n */\n\nconst VERSION_QUERY = /\\?v=\\d+$/;\n\nlet resolvedPath: string | null | undefined;\n\nfunction targetFile(): string | null {\n  if (resolvedPath !== undefined) return resolvedPath;\n  resolvedPath = process.env.WARLOCK_RESOLVE_CAPTURE || null;\n  return resolvedPath;\n}\n\nexport type ResolutionRecord = {\n  specifier: string;\n  parentURL: string | undefined;\n  url: string;\n  format: string | undefined;\n};\n\nexport function captureResolution(record: ResolutionRecord): void {\n  const file = targetFile();\n  if (!file) return;\n\n  const line =\n    JSON.stringify({\n      specifier: record.specifier,\n      parentURL: record.parentURL?.replace(VERSION_QUERY, \"\"),\n      url: record.url.replace(VERSION_QUERY, \"\"),\n      format: record.format,\n    }) + \"\\n\";\n\n  try {\n    appendFileSync(file, line);\n  } catch {\n    // Capture is a diagnostic aid — never let it break resolution.\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAmBA,MAAM,gBAAgB;AAEtB,IAAI;AAEJ,SAAS,aAA4B;CACnC,IAAI,iBAAiB,QAAW,OAAO;CACvC,eAAe,QAAQ,IAAI,2BAA2B;CACtD,OAAO;AACT;AASA,SAAgB,kBAAkB,QAAgC;CAChE,MAAM,OAAO,WAAW;CACxB,IAAI,CAAC,MAAM;CAEX,MAAM,OACJ,KAAK,UAAU;EACb,WAAW,OAAO;EAClB,WAAW,OAAO,WAAW,QAAQ,eAAe,EAAE;EACtD,KAAK,OAAO,IAAI,QAAQ,eAAe,EAAE;EACzC,QAAQ,OAAO;CACjB,CAAC,IAAI;CAEP,IAAI;EACF,eAAe,MAAM,IAAI;CAC3B,QAAQ,CAER;AACF"}

package/esm/dev-server/loader/resolve-hook.d.mts

@@ -1,41 +0,0 @@
-//#region ../../@warlock.js/core/src/dev-server/loader/resolve-hook.d.ts
-type ResolveContext = {
-  parentURL?: string;
-  conditions?: string[];
-  importAttributes?: Record<string, string>;
-};
-type ResolveResult = {
-  url: string;
-  format?: string;
-  shortCircuit?: boolean;
-};
-type NextResolve = (specifier: string, context?: ResolveContext) => Promise<ResolveResult>;
-/**
- * ESM loader `resolve()` hook.
- *
- * The framework's own resolver (`ownResolve`) handles tsconfig `paths`,
- * aliases, and TS extension/`index` probing. Specifiers it doesn't own
- * (bare npm, `node:`, `file:`) fall through to `nextResolve` (Node
- * default). After resolution, stamps a `?v=<N>` version token onto any
- * `.ts` / `.tsx` file that lives under the configured `src/` root.
- *
- * The version token is the cache-bust mechanism: when a file changes the main
- * thread bumps its counter, the next `import()` produces a new URL, Node sees
- * a cache miss, and loads fresh content — native ESM cycles are preserved
- * because static imports remain static throughout.
- *
- * **parentURL cleaning**: the resolved URL carries `?v=N` as a suffix. If a
- * module loaded this way statically imports a relative sibling, Node uses that
- * `?v=N` URL as the `parentURL` for the next `resolve()` call. Passing it
- * unmodified to `nextResolve()` causes tsx to produce paths like
- * `some-sibling.ts?v=0` (the query leaks into URL joining). We strip `?v=N`
- * from `parentURL` before forwarding to prevent this.
- *
- * @example
- * // First import of user.model.ts → ?v=0
- * // File watcher bumps → next import → ?v=1 → fresh module
- */
-declare function resolve(specifier: string, context: ResolveContext, nextResolve: NextResolve): Promise<ResolveResult>;
-//#endregion
-export { resolve };
-//# sourceMappingURL=resolve-hook.d.mts.map

package/esm/dev-server/loader/resolve-hook.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolve-hook.d.mts","names":[],"sources":["../../../../../../../@warlock.js/core/src/dev-server/loader/resolve-hook.ts"],"mappings":";KAqCK,cAAA;EACH,SAAA;EACA,UAAA;EACA,gBAAA,GAAmB,MAAM;AAAA;AAAA,KAGtB,aAAA;EACH,GAAA;EACA,MAAA;EACA,YAAA;AAAA;AAAA,KAGG,WAAA,IAAe,SAAA,UAAmB,OAAA,GAAU,cAAA,KAAmB,OAAA,CAAQ,aAAA;;AAH9D;AAAA;;;;;;;;;;;;;;AAG2E;AA2BzF;;;;;;;;iBAAsB,OAAA,CACpB,SAAA,UACA,OAAA,EAAS,cAAA,EACT,WAAA,EAAa,WAAA,GACZ,OAAA,CAAQ,aAAA"}

package/esm/dev-server/loader/resolve-hook.mjs

@@ -1,87 +0,0 @@
-import { ownResolve } from "./own-resolver.mjs";
-import { captureResolution } from "./resolve-capture.mjs";
-import { getVersion } from "./version-registry.mjs";
-import { existsSync } from "node:fs";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { getTsconfig, resolvePathAlias } from "get-tsconfig";
-
-//#region ../../@warlock.js/core/src/dev-server/loader/resolve-hook.ts
-/**
-* The `file://` URL prefix for the project's `src/` root, set once during
-* `initialize()`. Used to identify which resolved URLs belong to user code.
-*/
-let srcRootUrl = "";
-/**
-* Configure the source root used by the resolve hook.
-* Must be called from `initialize()` before any imports are resolved.
-*
-* @param srcRoot - Absolute filesystem path to the project `src/` directory.
-*/
-function setSrcRoot(srcRoot) {
-	srcRootUrl = pathToFileURL(srcRoot).href + "/";
-}
-/** Lazily-built tsconfig `paths` matcher (worker has no startup hook). */
-let pathsMatcher = null;
-let pathsMatcherBuilt = false;
-function getPathsMatcher() {
-	if (pathsMatcherBuilt) return pathsMatcher;
-	pathsMatcherBuilt = true;
-	const tsconfig = getTsconfig(process.cwd());
-	pathsMatcher = tsconfig ? (specifier) => resolvePathAlias(tsconfig, specifier) : null;
-	return pathsMatcher;
-}
-/**
-* ESM loader `resolve()` hook.
-*
-* The framework's own resolver (`ownResolve`) handles tsconfig `paths`,
-* aliases, and TS extension/`index` probing. Specifiers it doesn't own
-* (bare npm, `node:`, `file:`) fall through to `nextResolve` (Node
-* default). After resolution, stamps a `?v=<N>` version token onto any
-* `.ts` / `.tsx` file that lives under the configured `src/` root.
-*
-* The version token is the cache-bust mechanism: when a file changes the main
-* thread bumps its counter, the next `import()` produces a new URL, Node sees
-* a cache miss, and loads fresh content — native ESM cycles are preserved
-* because static imports remain static throughout.
-*
-* **parentURL cleaning**: the resolved URL carries `?v=N` as a suffix. If a
-* module loaded this way statically imports a relative sibling, Node uses that
-* `?v=N` URL as the `parentURL` for the next `resolve()` call. Passing it
-* unmodified to `nextResolve()` causes tsx to produce paths like
-* `some-sibling.ts?v=0` (the query leaks into URL joining). We strip `?v=N`
-* from `parentURL` before forwarding to prevent this.
-*
-* @example
-* // First import of user.model.ts → ?v=0
-* // File watcher bumps → next import → ?v=1 → fresh module
-*/
-async function resolve(specifier, context, nextResolve) {
-	const cleanContext = context.parentURL?.includes("?v=") ? {
-		...context,
-		parentURL: context.parentURL.replace(/\?v=\d+$/, "")
-	} : context;
-	const owned = ownResolve(specifier, cleanContext.parentURL, getPathsMatcher(), existsSync);
-	const result = owned ? {
-		url: owned,
-		shortCircuit: true
-	} : await nextResolve(specifier, cleanContext);
-	const { url } = result;
-	captureResolution({
-		specifier,
-		parentURL: cleanContext.parentURL,
-		url,
-		format: result.format
-	});
-	const cleanUrl = url.replace(/\?v=\d+$/, "");
-	if (!cleanUrl.startsWith(srcRootUrl) || !cleanUrl.endsWith(".ts") && !cleanUrl.endsWith(".tsx")) return result;
-	const version = getVersion(fileURLToPath(cleanUrl));
-	return {
-		...result,
-		url: `${cleanUrl}?v=${version}`,
-		shortCircuit: true
-	};
-}
-
-//#endregion
-export { resolve, setSrcRoot };
-//# sourceMappingURL=resolve-hook.mjs.map

package/esm/dev-server/loader/resolve-hook.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolve-hook.mjs","names":[],"sources":["../../../../../../../@warlock.js/core/src/dev-server/loader/resolve-hook.ts"],"sourcesContent":["import { getTsconfig, resolvePathAlias } from \"get-tsconfig\";\nimport { existsSync } from \"node:fs\";\nimport { fileURLToPath, pathToFileURL } from \"node:url\";\nimport { ownResolve, type PathsMatcher } from \"./own-resolver.js\";\nimport { captureResolution } from \"./resolve-capture.js\";\nimport { getVersion } from \"./version-registry.js\";\n\n/**\n * The `file://` URL prefix for the project's `src/` root, set once during\n * `initialize()`. Used to identify which resolved URLs belong to user code.\n */\nlet srcRootUrl = \"\";\n\n/**\n * Configure the source root used by the resolve hook.\n * Must be called from `initialize()` before any imports are resolved.\n *\n * @param srcRoot - Absolute filesystem path to the project `src/` directory.\n */\nexport function setSrcRoot(srcRoot: string): void {\n  srcRootUrl = pathToFileURL(srcRoot).href + \"/\";\n}\n\n/** Lazily-built tsconfig `paths` matcher (worker has no startup hook). */\nlet pathsMatcher: PathsMatcher | null = null;\nlet pathsMatcherBuilt = false;\n\nfunction getPathsMatcher(): PathsMatcher | null {\n  if (pathsMatcherBuilt) return pathsMatcher;\n  pathsMatcherBuilt = true;\n  const tsconfig = getTsconfig(process.cwd());\n  // get-tsconfig v5 renamed the curried `createPathsMatcher(t)(spec)` to a direct\n  // `resolvePathAlias(t, spec)`. Wrap it to keep the PathsMatcher closure shape.\n  pathsMatcher = tsconfig ? (specifier: string) => resolvePathAlias(tsconfig, specifier) : null;\n  return pathsMatcher;\n}\n\ntype ResolveContext = {\n  parentURL?: string;\n  conditions?: string[];\n  importAttributes?: Record<string, string>;\n};\n\ntype ResolveResult = {\n  url: string;\n  format?: string;\n  shortCircuit?: boolean;\n};\n\ntype NextResolve = (specifier: string, context?: ResolveContext) => Promise<ResolveResult>;\n\n/**\n * ESM loader `resolve()` hook.\n *\n * The framework's own resolver (`ownResolve`) handles tsconfig `paths`,\n * aliases, and TS extension/`index` probing. Specifiers it doesn't own\n * (bare npm, `node:`, `file:`) fall through to `nextResolve` (Node\n * default). After resolution, stamps a `?v=<N>` version token onto any\n * `.ts` / `.tsx` file that lives under the configured `src/` root.\n *\n * The version token is the cache-bust mechanism: when a file changes the main\n * thread bumps its counter, the next `import()` produces a new URL, Node sees\n * a cache miss, and loads fresh content — native ESM cycles are preserved\n * because static imports remain static throughout.\n *\n * **parentURL cleaning**: the resolved URL carries `?v=N` as a suffix. If a\n * module loaded this way statically imports a relative sibling, Node uses that\n * `?v=N` URL as the `parentURL` for the next `resolve()` call. Passing it\n * unmodified to `nextResolve()` causes tsx to produce paths like\n * `some-sibling.ts?v=0` (the query leaks into URL joining). We strip `?v=N`\n * from `parentURL` before forwarding to prevent this.\n *\n * @example\n * // First import of user.model.ts → ?v=0\n * // File watcher bumps → next import → ?v=1 → fresh module\n */\nexport async function resolve(\n  specifier: string,\n  context: ResolveContext,\n  nextResolve: NextResolve,\n): Promise<ResolveResult> {\n  const cleanContext =\n    context.parentURL?.includes(\"?v=\")\n      ? { ...context, parentURL: context.parentURL.replace(/\\?v=\\d+$/, \"\") }\n      : context;\n\n  // The framework's own resolver owns tsconfig `paths` + TS\n  // extension/index probing. Anything it returns `null` for (bare npm,\n  // `node:`, `file:`) falls through to Node default via `nextResolve`.\n  const owned = ownResolve(\n    specifier,\n    cleanContext.parentURL,\n    getPathsMatcher(),\n    existsSync,\n  );\n  // When we produced the URL ourselves we did NOT call nextResolve, so the\n  // result must short-circuit the loader chain or Node throws\n  // ERR_LOADER_CHAIN_INCOMPLETE (e.g. for @warlock.js/* .ts that resolve\n  // outside the project src root and hit the early return below).\n  const result: ResolveResult = owned\n    ? { url: owned, shortCircuit: true }\n    : await nextResolve(specifier, cleanContext);\n\n  const { url } = result;\n\n  // Ground-truth recorder (no-op unless WARLOCK_RESOLVE_CAPTURE is set):\n  // logs the answer for this (specifier, parentURL) so the Phase B\n  // resolver can be proven to reproduce tsx exactly.\n  captureResolution({\n    specifier,\n    parentURL: cleanContext.parentURL,\n    url,\n    format: result.format,\n  });\n\n  const cleanUrl = url.replace(/\\?v=\\d+$/, \"\");\n\n  if (\n    !cleanUrl.startsWith(srcRootUrl) ||\n    (!cleanUrl.endsWith(\".ts\") && !cleanUrl.endsWith(\".tsx\"))\n  ) {\n    return result;\n  }\n\n  const absolutePath = fileURLToPath(cleanUrl);\n  const version = getVersion(absolutePath);\n\n  // Spread the full result from nextResolve (preserves `format` and any other\n  // fields tsx sets) and only override `url`. Dropping `format` would cause\n  // tsx's load hook to see an undefined format and fall through to Node's\n  // default loader, which rejects unknown extensions like .tsx.\n  return { ...result, url: `${cleanUrl}?v=${version}`, shortCircuit: true };\n}\n"],"mappings":";;;;;;;;;;;;AAWA,IAAI,aAAa;;;;;;;AAQjB,SAAgB,WAAW,SAAuB;CAChD,aAAa,cAAc,OAAO,EAAE,OAAO;AAC7C;;AAGA,IAAI,eAAoC;AACxC,IAAI,oBAAoB;AAExB,SAAS,kBAAuC;CAC9C,IAAI,mBAAmB,OAAO;CAC9B,oBAAoB;CACpB,MAAM,WAAW,YAAY,QAAQ,IAAI,CAAC;CAG1C,eAAe,YAAY,cAAsB,iBAAiB,UAAU,SAAS,IAAI;CACzF,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,eAAsB,QACpB,WACA,SACA,aACwB;CACxB,MAAM,eACJ,QAAQ,WAAW,SAAS,KAAK,IAC7B;EAAE,GAAG;EAAS,WAAW,QAAQ,UAAU,QAAQ,YAAY,EAAE;CAAE,IACnE;CAKN,MAAM,QAAQ,WACZ,WACA,aAAa,WACb,gBAAgB,GAChB,UACF;CAKA,MAAM,SAAwB,QAC1B;EAAE,KAAK;EAAO,cAAc;CAAK,IACjC,MAAM,YAAY,WAAW,YAAY;CAE7C,MAAM,EAAE,QAAQ;CAKhB,kBAAkB;EAChB;EACA,WAAW,aAAa;EACxB;EACA,QAAQ,OAAO;CACjB,CAAC;CAED,MAAM,WAAW,IAAI,QAAQ,YAAY,EAAE;CAE3C,IACE,CAAC,SAAS,WAAW,UAAU,KAC9B,CAAC,SAAS,SAAS,KAAK,KAAK,CAAC,SAAS,SAAS,MAAM,GAEvD,OAAO;CAIT,MAAM,UAAU,WADK,cAAc,QACG,CAAC;CAMvC,OAAO;EAAE,GAAG;EAAQ,KAAK,GAAG,SAAS,KAAK;EAAW,cAAc;CAAK;AAC1E"}

package/esm/dev-server/loader/source-slug.mjs

@@ -1,22 +0,0 @@
-//#region ../../@warlock.js/core/src/dev-server/loader/source-slug.ts
-/**
-* Human-readable label for a cached transpile file, derived from the last
-* three path segments of the source file.
-*
-* Purely cosmetic: it rides in front of the content hash in the cache
-* filename so `ls .warlock/transpile/<shard>/` is browsable when debugging.
-* It is **never** used as a cache key, module URL, or source-map
-* `sourcefile` — correctness still rests entirely on the content hash, so
-* the slug is allowed to be lossy (sanitised, capped).
-*
-* @example
-*   sourceSlug("D:/proj/src/app/vectors/utils/locales.ts")
-*   // → "vectors-utils-locales"
-*/
-function sourceSlug(absolutePath) {
-	return absolutePath.replace(/\\/g, "/").replace(/\.[cm]?[jt]sx?$/, "").split("/").filter(Boolean).slice(-3).join("-").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60) || "src";
-}
-
-//#endregion
-export { sourceSlug };
-//# sourceMappingURL=source-slug.mjs.map

package/esm/dev-server/loader/source-slug.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"source-slug.mjs","names":[],"sources":["../../../../../../../@warlock.js/core/src/dev-server/loader/source-slug.ts"],"sourcesContent":["/**\n * Human-readable label for a cached transpile file, derived from the last\n * three path segments of the source file.\n *\n * Purely cosmetic: it rides in front of the content hash in the cache\n * filename so `ls .warlock/transpile/<shard>/` is browsable when debugging.\n * It is **never** used as a cache key, module URL, or source-map\n * `sourcefile` — correctness still rests entirely on the content hash, so\n * the slug is allowed to be lossy (sanitised, capped).\n *\n * @example\n *   sourceSlug(\"D:/proj/src/app/vectors/utils/locales.ts\")\n *   // → \"vectors-utils-locales\"\n */\nexport function sourceSlug(absolutePath: string): string {\n  const noExt = absolutePath.replace(/\\\\/g, \"/\").replace(/\\.[cm]?[jt]sx?$/, \"\");\n\n  const slug = noExt\n    .split(\"/\")\n    .filter(Boolean)\n    .slice(-3)\n    .join(\"-\")\n    .toLowerCase()\n    .replace(/[^a-z0-9]+/g, \"-\")\n    .replace(/^-+|-+$/g, \"\");\n\n  // The hash guarantees uniqueness; the slug is just a label, so capping it\n  // is safe and keeps total path length sane on deep trees / Windows.\n  return slug.slice(0, 60) || \"src\";\n}\n"],"mappings":";;;;;;;;;;;;;;;AAcA,SAAgB,WAAW,cAA8B;CAcvD,OAbc,aAAa,QAAQ,OAAO,GAAG,EAAE,QAAQ,mBAAmB,EAEzD,EACd,MAAM,GAAG,EACT,OAAO,OAAO,EACd,MAAM,EAAE,EACR,KAAK,GAAG,EACR,YAAY,EACZ,QAAQ,eAAe,GAAG,EAC1B,QAAQ,YAAY,EAIb,EAAE,MAAM,GAAG,EAAE,KAAK;AAC9B"}

package/esm/dev-server/loader/version-registry.mjs

@@ -1,45 +0,0 @@
-//#region ../../@warlock.js/core/src/dev-server/loader/version-registry.ts
-/**
-* Version registry for the ESM loader hook.
-*
-* Lives in the hook worker thread. The main thread sends bump messages via
-* MessageChannel; each bump increments the monotonic counter for that path,
-* which causes `resolve()` to produce a new URL — Node sees a fresh module.
-*
-* Monotonic integers are used instead of timestamps so there is no clock-drift
-* risk and the version is trivial to reason about during debugging.
-*
-* @example
-* // Hook worker receives a bump from the file watcher:
-* bumpVersion("/abs/path/to/user.model.ts");
-* // → getVersion returns 1, resolve() appends ?v=1 to the URL
-*/
-const versionMap = /* @__PURE__ */ new Map();
-/**
-* Normalize a filesystem path to a single canonical form so the main thread
-* (which often holds forward-slash paths from posix-style joins) and the
-* hook worker (which gets backslash paths from `fileURLToPath` on Windows)
-* agree on map keys.
-*/
-function normalizeKey(absolutePath) {
-	return absolutePath.replace(/\\/g, "/").toLowerCase();
-}
-/**
-* Increment the version counter for the given absolute path.
-* Called when the file watcher detects a change.
-*/
-function bumpVersion(absolutePath) {
-	const key = normalizeKey(absolutePath);
-	versionMap.set(key, (versionMap.get(key) ?? 0) + 1);
-}
-/**
-* Return the current version counter for the given absolute path.
-* Returns 0 for paths not yet seen (first import).
-*/
-function getVersion(absolutePath) {
-	return versionMap.get(normalizeKey(absolutePath)) ?? 0;
-}
-
-//#endregion
-export { bumpVersion, getVersion };
-//# sourceMappingURL=version-registry.mjs.map

package/esm/dev-server/loader/version-registry.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"version-registry.mjs","names":[],"sources":["../../../../../../../@warlock.js/core/src/dev-server/loader/version-registry.ts"],"sourcesContent":["/**\n * Version registry for the ESM loader hook.\n *\n * Lives in the hook worker thread. The main thread sends bump messages via\n * MessageChannel; each bump increments the monotonic counter for that path,\n * which causes `resolve()` to produce a new URL — Node sees a fresh module.\n *\n * Monotonic integers are used instead of timestamps so there is no clock-drift\n * risk and the version is trivial to reason about during debugging.\n *\n * @example\n * // Hook worker receives a bump from the file watcher:\n * bumpVersion(\"/abs/path/to/user.model.ts\");\n * // → getVersion returns 1, resolve() appends ?v=1 to the URL\n */\n\nconst versionMap = new Map<string, number>();\n\n/**\n * Normalize a filesystem path to a single canonical form so the main thread\n * (which often holds forward-slash paths from posix-style joins) and the\n * hook worker (which gets backslash paths from `fileURLToPath` on Windows)\n * agree on map keys.\n */\nfunction normalizeKey(absolutePath: string): string {\n  return absolutePath.replace(/\\\\/g, \"/\").toLowerCase();\n}\n\n/**\n * Increment the version counter for the given absolute path.\n * Called when the file watcher detects a change.\n */\nexport function bumpVersion(absolutePath: string): void {\n  const key = normalizeKey(absolutePath);\n  versionMap.set(key, (versionMap.get(key) ?? 0) + 1);\n}\n\n/**\n * Return the current version counter for the given absolute path.\n * Returns 0 for paths not yet seen (first import).\n */\nexport function getVersion(absolutePath: string): number {\n  return versionMap.get(normalizeKey(absolutePath)) ?? 0;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAgBA,MAAM,6BAAa,IAAI,IAAoB;;;;;;;AAQ3C,SAAS,aAAa,cAA8B;CAClD,OAAO,aAAa,QAAQ,OAAO,GAAG,EAAE,YAAY;AACtD;;;;;AAMA,SAAgB,YAAY,cAA4B;CACtD,MAAM,MAAM,aAAa,YAAY;CACrC,WAAW,IAAI,MAAM,WAAW,IAAI,GAAG,KAAK,KAAK,CAAC;AACpD;;;;;AAMA,SAAgB,WAAW,cAA8B;CACvD,OAAO,WAAW,IAAI,aAAa,YAAY,CAAC,KAAK;AACvD"}

package/esm/dev-server/start-development-server.mjs

@@ -1,63 +0,0 @@
-import { devLogError, devServeLog } from "./dev-logger.mjs";
-import { DevelopmentServer } from "./development-server.mjs";
-import { colors } from "@mongez/copper";
-
-//#region ../../@warlock.js/core/src/dev-server/start-development-server.ts
-let handlersRegistered = false;
-/**
-* Start the development server.
-*
-* Boots the file orchestrator, loads app modules, starts late-phase
-* connectors, then wires graceful shutdown for SIGINT/SIGTERM (plus
-* SIGHUP on Windows where Ctrl+C in spawned children lands as SIGHUP).
-*
-* If startup throws, shuts down cleanly and exits 1 — dev should die
-* loudly rather than hang with a half-initialized state.
-*/
-async function startDevelopmentServer(options = {}) {
-	process.setSourceMapsEnabled(true);
-	const devServer = new DevelopmentServer(options);
-	registerShutdownHandlers(devServer);
-	try {
-		await devServer.start();
-	} catch (error) {
-		devLogError(`Failed to start Development Server: ${error.message}`);
-		await safeShutdown(devServer);
-		process.exit(1);
-	}
-	return devServer;
-}
-/**
-* Register signal handlers once per process. Guards against handler
-* accumulation if `startDevelopmentServer` is invoked more than once
-* (tests, programmatic restart).
-*/
-function registerShutdownHandlers(devServer) {
-	if (handlersRegistered) return;
-	handlersRegistered = true;
-	const onSignal = (signal) => async () => {
-		devServeLog(colors.yellow(`📡 Received ${signal}`));
-		const ok = await safeShutdown(devServer);
-		process.exit(ok ? 0 : 1);
-	};
-	process.on("SIGINT", onSignal("SIGINT"));
-	process.on("SIGTERM", onSignal("SIGTERM"));
-	if (process.platform === "win32") process.on("SIGHUP", onSignal("SIGHUP"));
-}
-/**
-* Shut down the dev server without swallowing async errors. Returns
-* whether shutdown completed cleanly so the caller picks the exit code.
-*/
-async function safeShutdown(devServer) {
-	try {
-		await devServer.shutdown();
-		return true;
-	} catch (error) {
-		devLogError(`Shutdown failed: ${error.message}`);
-		return false;
-	}
-}
-
-//#endregion
-export { startDevelopmentServer };
-//# sourceMappingURL=start-development-server.mjs.map

package/esm/dev-server/start-development-server.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"start-development-server.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/dev-server/start-development-server.ts"],"sourcesContent":["import { colors } from \"@mongez/copper\";\r\nimport { devLogError, devServeLog } from \"./dev-logger\";\r\nimport { DevelopmentServer } from \"./development-server\";\r\n\r\nlet handlersRegistered = false;\r\n\r\n/**\r\n * Options accepted by `startDevelopmentServer`. CLI flags translate to\r\n * these; programmatic callers (tests, scripts) can pass them directly.\r\n *\r\n * `undefined` for any field means \"fall through to `warlock.config.ts >\r\n * devServer.*` defaults.\" Pass an explicit value only to override.\r\n */\r\nexport type StartDevServerOptions = {\r\n  /**\r\n   * Delete `.warlock/manifest.json` before starting — forces every file\r\n   * to be re-parsed from disk instead of restored from the cached graph.\r\n   */\r\n  fresh?: boolean;\r\n  /** Run background type generation. Default from devServer config (true). */\r\n  generateTypings?: boolean;\r\n  /** Run file health checkers. Default from devServer config (true). */\r\n  healthCheckers?: boolean;\r\n};\r\n\r\n/**\r\n * Start the development server.\r\n *\r\n * Boots the file orchestrator, loads app modules, starts late-phase\r\n * connectors, then wires graceful shutdown for SIGINT/SIGTERM (plus\r\n * SIGHUP on Windows where Ctrl+C in spawned children lands as SIGHUP).\r\n *\r\n * If startup throws, shuts down cleanly and exits 1 — dev should die\r\n * loudly rather than hang with a half-initialized state.\r\n */\r\nexport async function startDevelopmentServer(\r\n  options: StartDevServerOptions = {},\r\n): Promise<DevelopmentServer> {\r\n  // V8 honours inline source maps embedded by the transpile cache (and\r\n  // tsx's own maps in passthrough mode), so thrown-error stack frames point\r\n  // at the original `src/**.ts` line/column instead of transpiled output.\r\n  process.setSourceMapsEnabled(true);\r\n\r\n  const devServer = new DevelopmentServer(options);\r\n\r\n  registerShutdownHandlers(devServer);\r\n\r\n  try {\r\n    await devServer.start();\r\n  } catch (error) {\r\n    devLogError(`Failed to start Development Server: ${(error as Error).message}`);\r\n    await safeShutdown(devServer);\r\n    process.exit(1);\r\n  }\r\n\r\n  return devServer;\r\n}\r\n\r\n/**\r\n * Register signal handlers once per process. Guards against handler\r\n * accumulation if `startDevelopmentServer` is invoked more than once\r\n * (tests, programmatic restart).\r\n */\r\nfunction registerShutdownHandlers(devServer: DevelopmentServer): void {\r\n  if (handlersRegistered) return;\r\n  handlersRegistered = true;\r\n\r\n  const onSignal = (signal: NodeJS.Signals) => async () => {\r\n    devServeLog(colors.yellow(`📡 Received ${signal}`));\r\n    const ok = await safeShutdown(devServer);\r\n    process.exit(ok ? 0 : 1);\r\n  };\r\n\r\n  process.on(\"SIGINT\", onSignal(\"SIGINT\"));\r\n  process.on(\"SIGTERM\", onSignal(\"SIGTERM\"));\r\n  // Ctrl+C in spawned Windows children lands as SIGHUP, not SIGINT.\r\n  if (process.platform === \"win32\") {\r\n    process.on(\"SIGHUP\", onSignal(\"SIGHUP\"));\r\n  }\r\n}\r\n\r\n/**\r\n * Shut down the dev server without swallowing async errors. Returns\r\n * whether shutdown completed cleanly so the caller picks the exit code.\r\n */\r\nasync function safeShutdown(devServer: DevelopmentServer): Promise<boolean> {\r\n  try {\r\n    await devServer.shutdown();\r\n    return true;\r\n  } catch (error) {\r\n    devLogError(`Shutdown failed: ${(error as Error).message}`);\r\n    return false;\r\n  }\r\n}\r\n"],"mappings":";;;;;AAIA,IAAI,qBAAqB;;;;;;;;;;;AA+BzB,eAAsB,uBACpB,UAAiC,CAAC,GACN;CAI5B,QAAQ,qBAAqB,IAAI;CAEjC,MAAM,YAAY,IAAI,kBAAkB,OAAO;CAE/C,yBAAyB,SAAS;CAElC,IAAI;EACF,MAAM,UAAU,MAAM;CACxB,SAAS,OAAO;EACd,YAAY,uCAAwC,MAAgB,SAAS;EAC7E,MAAM,aAAa,SAAS;EAC5B,QAAQ,KAAK,CAAC;CAChB;CAEA,OAAO;AACT;;;;;;AAOA,SAAS,yBAAyB,WAAoC;CACpE,IAAI,oBAAoB;CACxB,qBAAqB;CAErB,MAAM,YAAY,WAA2B,YAAY;EACvD,YAAY,OAAO,OAAO,eAAe,QAAQ,CAAC;EAClD,MAAM,KAAK,MAAM,aAAa,SAAS;EACvC,QAAQ,KAAK,KAAK,IAAI,CAAC;CACzB;CAEA,QAAQ,GAAG,UAAU,SAAS,QAAQ,CAAC;CACvC,QAAQ,GAAG,WAAW,SAAS,SAAS,CAAC;CAEzC,IAAI,QAAQ,aAAa,SACvB,QAAQ,GAAG,UAAU,SAAS,QAAQ,CAAC;AAE3C;;;;;AAMA,eAAe,aAAa,WAAgD;CAC1E,IAAI;EACF,MAAM,UAAU,SAAS;EACzB,OAAO;CACT,SAAS,OAAO;EACd,YAAY,oBAAqB,MAAgB,SAAS;EAC1D,OAAO;CACT;AACF"}