@warlock.js/core 5.2.0 → 5.2.2

package/esm/tests/vitest-setup.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"vitest-setup.mjs","names":[],"sources":["C:/Work/Warlock.js/core/src/tests/vitest-setup.ts"],"sourcesContent":["/**\r\n * Worker test lifecycle — `setupTest` / `teardownTest`.\r\n *\r\n * Implements `contracts/2026-08-12-test-worker-lifecycle.md`. The pair is\r\n * context-scoped, not \"once per worker\": Vitest runs `setupFiles` before EVERY\r\n * test file and rebuilds the module registry each time, so the harness that\r\n * calls `setupTest` owns pairing it with `teardownTest` in the same runtime\r\n * context.\r\n *\r\n * Ownership, stated once because teardown is wider than it looks:\r\n *\r\n * - the runtime assumes exclusive ownership of the process-local\r\n *   `connectorsManager` for its lifetime;\r\n * - it owns the framework bootstrap, the application shutdown hooks, and the\r\n *   connectors it starts — including the `connectors: false` case, where\r\n *   bootstrap still registers hooks;\r\n * - teardown is MANAGER-WIDE. `connectorsManager.shutdown()` has no selective\r\n *   ownership handle, so a lifecycle that started two connectors still closes\r\n *   every connector the manager holds. Mixing `setupTest` with manual connector\r\n *   startup in the same process is unsupported for exactly that reason.\r\n * - HTTP global setup stays separately owned by `startHttpTestServer` /\r\n *   `stopHttpTestServer`.\r\n */\r\nimport { Application } from \"../application/application\";\r\nimport { bootstrap } from \"../bootstrap\";\r\nimport { loadConfigFiles } from \"../config/load-config-files\";\r\nimport { connectorsManager } from \"../connectors\";\r\nimport { filesOrchestrator } from \"../dev-server/files-orchestrator\";\r\nimport { warlockConfigManager } from \"../warlock-config/warlock-config.manager\";\r\nimport {\r\n  describeConnectorsSelection,\r\n  isSameConnectorsSelection,\r\n  normalizeConnectorNames,\r\n  readRequestedConnectors,\r\n  resolveEffectiveConnectors,\r\n} from \"./test-connectors-selection\";\r\nimport type {\r\n  RequestedTestConnectors,\r\n  TestConnectorsSelection,\r\n} from \"./test-connectors-selection\";\r\nimport { getTestLifecycleRegistry } from \"./test-lifecycle-state\";\r\nimport type { TestLifecycleRegistry, TestSetupAttempt } from \"./test-lifecycle-state\";\r\nimport {\r\n  DEFAULT_TEST_SETUP_TIMEOUT,\r\n  describeExpiredSetup,\r\n  readConfiguredSetupTimeout,\r\n  scheduleRealTimeout,\r\n} from \"./test-setup-timeout\";\r\nimport type { TestTimeoutHandle } from \"./test-setup-timeout\";\r\n\r\nexport type { TestConnectorsSelection } from \"./test-connectors-selection\";\r\n\r\nexport type TestSetupOptions = {\r\n  /**\r\n   * Which connectors to start.\r\n   *\r\n   * Precedence is `explicit non-undefined option > tests.connectors config >\r\n   * true`. Omitting the property, or passing `undefined`, lets project config\r\n   * apply — so an optional variable that happens to be `undefined` cannot erase\r\n   * it.\r\n   */\r\n  connectors?: TestConnectorsSelection;\r\n};\r\n\r\n/**\r\n * Raised by the lifecycle itself, never by the runtime it manages — a conflict\r\n * between two calls, or a refusal to reuse a runtime that did not close.\r\n */\r\nexport class TestLifecycleError extends Error {\r\n  public constructor(message: string) {\r\n    super(message);\r\n\r\n    this.name = \"TestLifecycleError\";\r\n  }\r\n}\r\n\r\nconst POISONED_MESSAGE =\r\n  \"setupTest() refuses to start a test runtime: an earlier teardownTest() reported a shutdown failure, so the connectors, ports and pools it owned are not known to be closed. Restart the Vitest worker before setting up again, or call teardownTest() to retry the shutdown — the lifecycle only returns to idle on a fully successful retry.\";\r\n\r\n/**\r\n * Bootstrap the test runtime and start the selected connectors.\r\n *\r\n * ⚠ Runs once per TEST FILE, not once per worker: `setupFiles` is executed for\r\n * every file and its module registry is rebuilt with it, measured across both\r\n * pools with isolation on and off. The lifecycle state lives on the runtime\r\n * context rather than in this module precisely so that a rebuild cannot hide a\r\n * runtime that is still up.\r\n *\r\n * Repeated calls:\r\n *\r\n * - concurrent calls with the same effective selection share one startup;\r\n * - while ready, the same effective selection is a no-op;\r\n * - while starting or ready, a DIFFERENT effective selection rejects and leaves\r\n *   the live runtime untouched;\r\n * - a failed setup unwinds and returns to idle, so a clean retry is allowed;\r\n * - after a successful `teardownTest`, a later setup may use a different\r\n *   selection.\r\n *\r\n * @example\r\n * // let project config decide, falling back to the default set\r\n * await setupTest();\r\n *\r\n * @example\r\n * // bootstrap only — no connectors, whatever config says\r\n * await setupTest({ connectors: false });\r\n */\r\nexport async function setupTest(options?: TestSetupOptions): Promise<void> {\r\n  const registry = getTestLifecycleRegistry();\r\n  const requested = readRequestedConnectors(options?.connectors);\r\n\r\n  if (registry.state === \"poisoned\") {\r\n    throw new TestLifecycleError(POISONED_MESSAGE);\r\n  }\r\n\r\n  if (registry.state === \"stopping\" && registry.teardownAttempt) {\r\n    await settled(registry.teardownAttempt);\r\n\r\n    return setupTest(options);\r\n  }\r\n\r\n  if (registry.state === \"ready\") {\r\n    assertReadySelectionMatches(registry.activeSelection, requested);\r\n\r\n    return;\r\n  }\r\n\r\n  if (registry.state === \"starting\" && registry.setupAttempt) {\r\n    const attempt = registry.setupAttempt;\r\n\r\n    await assertPendingSetupMatches(attempt, requested);\r\n\r\n    return attempt.completion;\r\n  }\r\n\r\n  return startTestRuntime(requested);\r\n}\r\n\r\n/**\r\n * Shut the test runtime down and release the lifecycle.\r\n *\r\n * - idle is a no-op;\r\n * - concurrent calls share one attempt;\r\n * - a call made while setup is still running waits for that attempt to settle,\r\n *   then closes the runtime if it succeeded;\r\n * - the local \"ready\" state is always cleared, including when shutdown rejects;\r\n * - a shutdown rejection is surfaced, never swallowed, and poisons the\r\n *   lifecycle — a reported close failure is not proof that anything closed, so\r\n *   later `setupTest` calls refuse until the worker is restarted or a retry\r\n *   fully succeeds.\r\n *\r\n * ⚠ Individual connector shutdown failures are caught and logged inside\r\n * `connectorsManager.shutdown()`, so they never reach this function and never\r\n * poison anything. This lifecycle can only surface what that layer reports.\r\n */\r\nexport async function teardownTest(): Promise<void> {\r\n  const registry = getTestLifecycleRegistry();\r\n\r\n  if (registry.state === \"stopping\" && registry.teardownAttempt) {\r\n    return registry.teardownAttempt;\r\n  }\r\n\r\n  if (registry.state === \"starting\" && registry.setupAttempt) {\r\n    // A runtime that is still opening cannot be closed halfway. Wait for the\r\n    // attempt to settle: a failed one has already unwound itself and left the\r\n    // lifecycle idle, which the re-entry below then reads as \"nothing to do\".\r\n    await settled(registry.setupAttempt.completion);\r\n\r\n    return teardownTest();\r\n  }\r\n\r\n  if (registry.state === \"idle\") {\r\n    return;\r\n  }\r\n\r\n  registry.state = \"stopping\";\r\n\r\n  // Deferred by a microtask so the registry is fully published before the\r\n  // attempt's first line runs — a synchronous throw would otherwise reach the\r\n  // `finally` below, and reset the state, before this function had recorded\r\n  // that a teardown was in flight at all.\r\n  const attempt = Promise.resolve().then(() => runTestRuntimeShutdown());\r\n\r\n  registry.teardownAttempt = attempt;\r\n\r\n  return attempt;\r\n}\r\n\r\n/**\r\n * The setup attempt's hang guard, as the lifecycle consumes it.\r\n *\r\n * The bound's POLICY — the default, the config key, the message — lives in\r\n * `test-setup-timeout.ts`. What expiry MEANS lives here.\r\n *\r\n * @internal\r\n */\r\ntype SetupBound = {\r\n  /**\r\n   * Rejects with the expiry error. Never resolves: the attempt is the only side\r\n   * of the race that can succeed.\r\n   */\r\n  readonly expiry: Promise<never>;\r\n\r\n  /**\r\n   * Re-aim the bound at `next` ms measured from when the ATTEMPT STARTED, once\r\n   * config has made `tests.setupTimeout` readable.\r\n   */\r\n  rearm(next: number): void;\r\n\r\n  /** The race is over — cancel whatever timer is still pending. */\r\n  settle(): void;\r\n\r\n  /** Whether the bound, rather than the attempt, won the race. */\r\n  hasExpired(): boolean;\r\n};\r\n\r\n/**\r\n * Arm the hang guard for one setup attempt.\r\n *\r\n * Armed at the default BEFORE the attempt runs, because `tests.setupTimeout` is\r\n * not readable until the attempt has loaded config — and loading config is\r\n * itself one of the steps that can hang. `rearm` then narrows or widens it the\r\n * moment config arrives.\r\n */\r\nfunction armSetupBound(registry: TestLifecycleRegistry): SetupBound {\r\n  const schedule = registry.scheduleTimeout ?? scheduleRealTimeout;\r\n  const armedAt = Date.now();\r\n\r\n  let handle: TestTimeoutHandle | undefined;\r\n  let expired = false;\r\n  let closed = false;\r\n  let expire: (error: unknown) => void = () => undefined;\r\n\r\n  const expiry = new Promise<never>((_resolve, reject) => {\r\n    expire = reject;\r\n  });\r\n\r\n  // Only `awaitSetupWithinBound` observes this, and only until the attempt wins\r\n  // — after that nobody is listening, and an unobserved rejection surfaces as an\r\n  // unhandled rejection that fails an unrelated test file. Same reason as the\r\n  // `effectiveSelection` barrier below.\r\n  expiry.catch(() => undefined);\r\n\r\n  const expireNow = (bound: number): void => {\r\n    if (closed) {\r\n      return;\r\n    }\r\n\r\n    closed = true;\r\n    expired = true;\r\n\r\n    handle?.cancel();\r\n    handle = undefined;\r\n\r\n    expire(new TestLifecycleError(describeExpiredSetup(bound)));\r\n  };\r\n\r\n  const armFor = (bound: number, delay: number): void => {\r\n    if (closed) {\r\n      return;\r\n    }\r\n\r\n    handle?.cancel();\r\n\r\n    // Already overdue. A bound the attempt has ALREADY exceeded must fire now,\r\n    // not be rescheduled for time that was spent before it was known.\r\n    if (delay <= 0) {\r\n      expireNow(bound);\r\n\r\n      return;\r\n    }\r\n\r\n    handle = schedule(delay, () => expireNow(bound));\r\n  };\r\n\r\n  const initialBound = registry.setupTimeoutOverride ?? DEFAULT_TEST_SETUP_TIMEOUT;\r\n\r\n  armFor(initialBound, initialBound);\r\n\r\n  return {\r\n    expiry,\r\n\r\n    // Measured from `armedAt`, never from now: adding a configured bound to the\r\n    // time already spent would make the real bound default-plus-configured, and\r\n    // a project that lowered the key would get a LONGER guard than the default.\r\n    rearm: (next) => armFor(next, next - (Date.now() - armedAt)),\r\n\r\n    settle: () => {\r\n      closed = true;\r\n\r\n      handle?.cancel();\r\n      handle = undefined;\r\n    },\r\n\r\n    hasExpired: () => expired,\r\n  };\r\n}\r\n\r\n/**\r\n * Race one setup attempt against its bound.\r\n *\r\n * The losing attempt is NOT cancellable — nothing here can interrupt a bootstrap\r\n * stuck in a socket connect — so when the bound wins, the lifecycle is poisoned\r\n * and every later state write from that abandoned attempt is dropped. That\r\n * dropping happens in `runTestRuntimeStartup`, guarded on `hasExpired()`;\r\n * without it the still-running attempt would quietly overwrite `poisoned` with\r\n * `ready` or `idle` and hand the next caller a runtime nobody owns.\r\n */\r\nasync function awaitSetupWithinBound(\r\n  attempt: Promise<void>,\r\n  bound: SetupBound,\r\n  registry: TestLifecycleRegistry,\r\n): Promise<void> {\r\n  try {\r\n    await Promise.race([attempt, bound.expiry]);\r\n  } catch (error) {\r\n    if (bound.hasExpired()) {\r\n      registry.state = \"poisoned\";\r\n      registry.activeSelection = undefined;\r\n      registry.setupAttempt = undefined;\r\n    }\r\n\r\n    throw error;\r\n  } finally {\r\n    bound.settle();\r\n  }\r\n}\r\n\r\n/**\r\n * Open a new setup attempt and publish it before it runs.\r\n */\r\nfunction startTestRuntime(requested: RequestedTestConnectors): Promise<void> {\r\n  const registry = getTestLifecycleRegistry();\r\n\r\n  let publishEffectiveSelection: (selection: TestConnectorsSelection) => void = () => undefined;\r\n  let failEffectiveSelection: (error: unknown) => void = () => undefined;\r\n\r\n  const effectiveSelection = new Promise<TestConnectorsSelection>((resolve, reject) => {\r\n    publishEffectiveSelection = resolve;\r\n    failEffectiveSelection = reject;\r\n  });\r\n\r\n  // Only the mixed explicit/config comparison ever awaits this barrier, so its\r\n  // rejection is usually unobserved — and an unobserved rejection would surface\r\n  // as an unhandled rejection and fail an unrelated test file.\r\n  effectiveSelection.catch(() => undefined);\r\n\r\n  const bound = armSetupBound(registry);\r\n\r\n  const attempt = Promise.resolve().then(() =>\r\n    runTestRuntimeStartup(requested, publishEffectiveSelection, failEffectiveSelection, bound),\r\n  );\r\n\r\n  // The attempt outlives a bound that beat it, and by then `completion` has\r\n  // already rejected with the expiry error — so the attempt's own late rejection\r\n  // has no observer. Same unhandled-rejection hazard as above.\r\n  attempt.catch(() => undefined);\r\n\r\n  // `teardownTest` waits on this same promise, which is how a teardown requested\r\n  // during setup inherits the bound. There is deliberately no second timer and\r\n  // no separate teardown deadline.\r\n  const completion = awaitSetupWithinBound(attempt, bound, registry);\r\n\r\n  registry.state = \"starting\";\r\n  registry.setupAttempt = { requested, effectiveSelection, completion };\r\n\r\n  return completion;\r\n}\r\n\r\n/**\r\n * The startup attempt itself.\r\n *\r\n * On failure: best-effort unwind, reset bookkeeping, rethrow the ORIGINAL error\r\n * unchanged. A cleanup failure is a secondary diagnostic and never replaces the\r\n * cause the caller needs to read.\r\n */\r\nasync function runTestRuntimeStartup(\r\n  requested: RequestedTestConnectors,\r\n  publishEffectiveSelection: (selection: TestConnectorsSelection) => void,\r\n  failEffectiveSelection: (error: unknown) => void,\r\n  bound: SetupBound,\r\n): Promise<void> {\r\n  const registry = getTestLifecycleRegistry();\r\n\r\n  try {\r\n    Application.setEnvironment(\"test\");\r\n\r\n    await warlockConfigManager.load();\r\n    await bootstrap();\r\n\r\n    await filesOrchestrator.init();\r\n    await loadConfigFiles(true);\r\n\r\n    // The first point at which `tests.setupTimeout` is readable at all. An\r\n    // invalid value throws from here and takes the normal failure path — falling\r\n    // back to the default would silently erase what the project configured.\r\n    const configuredTimeout = readConfiguredSetupTimeout();\r\n\r\n    if (configuredTimeout !== undefined) {\r\n      bound.rearm(configuredTimeout);\r\n    }\r\n\r\n    // Resolved here and not at call time: the config layer is only readable once\r\n    // the four steps above have run.\r\n    const effectiveSelection = resolveEffectiveConnectors(requested);\r\n\r\n    // Every state write below is conditional on this attempt still being the one\r\n    // the lifecycle is waiting for. Once the bound has expired the lifecycle is\r\n    // poisoned and this attempt is abandoned — it may still be running, but it\r\n    // no longer speaks for the runtime.\r\n    if (!bound.hasExpired()) {\r\n      registry.activeSelection = effectiveSelection;\r\n    }\r\n\r\n    publishEffectiveSelection(effectiveSelection);\r\n\r\n    await startSelectedConnectors(effectiveSelection);\r\n\r\n    if (!bound.hasExpired()) {\r\n      registry.state = \"ready\";\r\n      registry.setupAttempt = undefined;\r\n    }\r\n  } catch (error) {\r\n    failEffectiveSelection(error);\r\n\r\n    await unwindPartialStartup();\r\n\r\n    if (!bound.hasExpired()) {\r\n      registry.state = \"idle\";\r\n      registry.activeSelection = undefined;\r\n      registry.setupAttempt = undefined;\r\n    }\r\n\r\n    console.error(\"[vitest-setup] Failed to setup test environment:\", error);\r\n\r\n    throw error;\r\n  }\r\n}\r\n\r\n/**\r\n * `false` means none at all. Everything else starts something: an array starts\r\n * exactly those, and `true` starts the default set — all but http, which is the\r\n * global setup's job and shared across every worker.\r\n */\r\nasync function startSelectedConnectors(selection: TestConnectorsSelection): Promise<void> {\r\n  if (selection === false) {\r\n    return;\r\n  }\r\n\r\n  if (Array.isArray(selection)) {\r\n    await connectorsManager.start(normalizeConnectorNames(selection));\r\n\r\n    return;\r\n  }\r\n\r\n  await connectorsManager.startWithout([\"http\"]);\r\n}\r\n\r\n/**\r\n * Best-effort teardown of whatever a failed startup managed to start.\r\n *\r\n * Runs while an error is already in flight, so no step here may throw and every\r\n * step is attempted independently.\r\n */\r\nasync function unwindPartialStartup(): Promise<void> {\r\n  // Two steps rather than one: `connectorsManager.shutdown()` runs the\r\n  // application hooks itself, but it runs them FIRST and does not isolate their\r\n  // rejection — so a hook that rejects would take the connector teardown down\r\n  // with it and leave every connector up. Both calls are idempotent, so running\r\n  // the hooks on their own first costs nothing and means neither failure can\r\n  // skip the other step.\r\n  await attemptCleanupStep(\"application shutdown hooks\", () => Application.runShutdownHooks());\r\n  await attemptCleanupStep(\"connectors shutdown\", () => connectorsManager.shutdown());\r\n}\r\n\r\n/**\r\n * Run one cleanup step, isolating its failure so the next step still runs.\r\n */\r\nasync function attemptCleanupStep(step: string, run: () => Promise<void>): Promise<void> {\r\n  try {\r\n    await run();\r\n  } catch (error) {\r\n    // Reported, not thrown — it is secondary to the startup error about to be\r\n    // rethrown, and losing that one to this would be the worse outcome.\r\n    console.error(`[vitest-setup] Cleanup after a failed setup did not complete (${step}):`, error);\r\n  }\r\n}\r\n\r\n/**\r\n * The teardown attempt itself.\r\n */\r\nasync function runTestRuntimeShutdown(): Promise<void> {\r\n  const registry = getTestLifecycleRegistry();\r\n  let shutdownSucceeded = false;\r\n\r\n  try {\r\n    // Manager-wide, and deliberately called whatever the selection was: with\r\n    // `connectors: false` nothing was started, but bootstrap still registered\r\n    // application shutdown hooks, and the manager runs those first (see\r\n    // `connectors-manager.ts` — `Application.runShutdownHooks()` is its first\r\n    // line). Skipping the call to \"match\" an empty selection would leak them.\r\n    await connectorsManager.shutdown();\r\n\r\n    shutdownSucceeded = true;\r\n  } finally {\r\n    // In a `finally`, not after the `await`: a rejected shutdown must not leave\r\n    // the lifecycle claiming a runtime it no longer owns. Poisoned rather than\r\n    // idle, because a cleared flag does not prove that ports, sockets, pools or\r\n    // timers closed.\r\n    registry.activeSelection = undefined;\r\n    registry.setupAttempt = undefined;\r\n    registry.teardownAttempt = undefined;\r\n    registry.state = shutdownSucceeded ? \"idle\" : \"poisoned\";\r\n  }\r\n}\r\n\r\n/**\r\n * Reject when a ready runtime was set up with a different selection.\r\n */\r\nfunction assertReadySelectionMatches(\r\n  activeSelection: TestConnectorsSelection | undefined,\r\n  requested: RequestedTestConnectors,\r\n): void {\r\n  if (activeSelection === undefined) {\r\n    return;\r\n  }\r\n\r\n  // Config is loaded by the time anything is ready, so the config-derived layer\r\n  // is resolvable right here.\r\n  const requestedSelection = resolveEffectiveConnectors(requested);\r\n\r\n  assertSelectionsMatch(activeSelection, requestedSelection);\r\n}\r\n\r\n/**\r\n * Reject when an in-flight setup attempt is starting a different selection.\r\n */\r\nasync function assertPendingSetupMatches(\r\n  attempt: TestSetupAttempt,\r\n  requested: RequestedTestConnectors,\r\n): Promise<void> {\r\n  const pending = attempt.requested;\r\n\r\n  // Two calls that both defer to project config resolve to the same thing by\r\n  // construction — knowable without waiting for config to load.\r\n  if (!pending.isExplicit && !requested.isExplicit) {\r\n    return;\r\n  }\r\n\r\n  if (pending.isExplicit && requested.isExplicit) {\r\n    assertSelectionsMatch(pending.selection, requested.selection);\r\n\r\n    return;\r\n  }\r\n\r\n  // Mixed: one side is config-derived and config is not readable until the\r\n  // running attempt has loaded it, so wait for that barrier first.\r\n  const activeSelection = await attempt.effectiveSelection;\r\n  const requestedSelection = resolveEffectiveConnectors(requested);\r\n\r\n  assertSelectionsMatch(activeSelection, requestedSelection);\r\n}\r\n\r\n/**\r\n * Name both selections: a caller looking at this message has to be able to tell\r\n * which call to change without reading the framework's source.\r\n */\r\nfunction assertSelectionsMatch(\r\n  activeSelection: TestConnectorsSelection,\r\n  requestedSelection: TestConnectorsSelection,\r\n): void {\r\n  if (isSameConnectorsSelection(activeSelection, requestedSelection)) {\r\n    return;\r\n  }\r\n\r\n  throw new TestLifecycleError(\r\n    `setupTest() is already using ${describeConnectorsSelection(activeSelection)}, and this call asked for ${describeConnectorsSelection(requestedSelection)}. One test runtime serves one connector selection — call teardownTest() before setting up a different one.`,\r\n  );\r\n}\r\n\r\n/**\r\n * Await an attempt for its state transition only, not its result.\r\n */\r\nfunction settled(attempt: Promise<void>): Promise<void> {\r\n  return attempt.catch(() => undefined);\r\n}\r\n"],"mappings":"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"}
+{"version":3,"file":"vitest-setup.mjs","names":[],"sources":["../../../../../../../core/src/tests/vitest-setup.ts"],"sourcesContent":["/**\r\n * Worker test lifecycle — `setupTest` / `teardownTest`.\r\n *\r\n * Implements `contracts/2026-08-12-test-worker-lifecycle.md`. The pair is\r\n * context-scoped, not \"once per worker\": Vitest runs `setupFiles` before EVERY\r\n * test file and rebuilds the module registry each time, so the harness that\r\n * calls `setupTest` owns pairing it with `teardownTest` in the same runtime\r\n * context.\r\n *\r\n * Ownership, stated once because teardown is wider than it looks:\r\n *\r\n * - the runtime assumes exclusive ownership of the process-local\r\n *   `connectorsManager` for its lifetime;\r\n * - it owns the framework bootstrap, the application shutdown hooks, and the\r\n *   connectors it starts — including the `connectors: false` case, where\r\n *   bootstrap still registers hooks;\r\n * - teardown is MANAGER-WIDE. `connectorsManager.shutdown()` has no selective\r\n *   ownership handle, so a lifecycle that started two connectors still closes\r\n *   every connector the manager holds. Mixing `setupTest` with manual connector\r\n *   startup in the same process is unsupported for exactly that reason.\r\n * - HTTP global setup stays separately owned by `startHttpTestServer` /\r\n *   `stopHttpTestServer`.\r\n */\r\nimport { Application } from \"../application/application\";\r\nimport { bootstrap } from \"../bootstrap\";\r\nimport { loadConfigFiles } from \"../config/load-config-files\";\r\nimport { connectorsManager } from \"../connectors\";\r\nimport { filesOrchestrator } from \"../dev-server/files-orchestrator\";\r\nimport { warlockConfigManager } from \"../warlock-config/warlock-config.manager\";\r\nimport {\r\n  describeConnectorsSelection,\r\n  isSameConnectorsSelection,\r\n  normalizeConnectorNames,\r\n  readRequestedConnectors,\r\n  resolveEffectiveConnectors,\r\n} from \"./test-connectors-selection\";\r\nimport type {\r\n  RequestedTestConnectors,\r\n  TestConnectorsSelection,\r\n} from \"./test-connectors-selection\";\r\nimport { getTestLifecycleRegistry } from \"./test-lifecycle-state\";\r\nimport type { TestLifecycleRegistry, TestSetupAttempt } from \"./test-lifecycle-state\";\r\nimport {\r\n  DEFAULT_TEST_SETUP_TIMEOUT,\r\n  describeExpiredSetup,\r\n  readConfiguredSetupTimeout,\r\n  scheduleRealTimeout,\r\n} from \"./test-setup-timeout\";\r\nimport type { TestTimeoutHandle } from \"./test-setup-timeout\";\r\n\r\nexport type { TestConnectorsSelection } from \"./test-connectors-selection\";\r\n\r\nexport type TestSetupOptions = {\r\n  /**\r\n   * Which connectors to start.\r\n   *\r\n   * Precedence is `explicit non-undefined option > tests.connectors config >\r\n   * true`. Omitting the property, or passing `undefined`, lets project config\r\n   * apply — so an optional variable that happens to be `undefined` cannot erase\r\n   * it.\r\n   */\r\n  connectors?: TestConnectorsSelection;\r\n};\r\n\r\n/**\r\n * Raised by the lifecycle itself, never by the runtime it manages — a conflict\r\n * between two calls, or a refusal to reuse a runtime that did not close.\r\n */\r\nexport class TestLifecycleError extends Error {\r\n  public constructor(message: string) {\r\n    super(message);\r\n\r\n    this.name = \"TestLifecycleError\";\r\n  }\r\n}\r\n\r\nconst POISONED_MESSAGE =\r\n  \"setupTest() refuses to start a test runtime: an earlier teardownTest() reported a shutdown failure, so the connectors, ports and pools it owned are not known to be closed. Restart the Vitest worker before setting up again, or call teardownTest() to retry the shutdown — the lifecycle only returns to idle on a fully successful retry.\";\r\n\r\n/**\r\n * Bootstrap the test runtime and start the selected connectors.\r\n *\r\n * ⚠ Runs once per TEST FILE, not once per worker: `setupFiles` is executed for\r\n * every file and its module registry is rebuilt with it, measured across both\r\n * pools with isolation on and off. The lifecycle state lives on the runtime\r\n * context rather than in this module precisely so that a rebuild cannot hide a\r\n * runtime that is still up.\r\n *\r\n * Repeated calls:\r\n *\r\n * - concurrent calls with the same effective selection share one startup;\r\n * - while ready, the same effective selection is a no-op;\r\n * - while starting or ready, a DIFFERENT effective selection rejects and leaves\r\n *   the live runtime untouched;\r\n * - a failed setup unwinds and returns to idle, so a clean retry is allowed;\r\n * - after a successful `teardownTest`, a later setup may use a different\r\n *   selection.\r\n *\r\n * @example\r\n * // let project config decide, falling back to the default set\r\n * await setupTest();\r\n *\r\n * @example\r\n * // bootstrap only — no connectors, whatever config says\r\n * await setupTest({ connectors: false });\r\n */\r\nexport async function setupTest(options?: TestSetupOptions): Promise<void> {\r\n  const registry = getTestLifecycleRegistry();\r\n  const requested = readRequestedConnectors(options?.connectors);\r\n\r\n  if (registry.state === \"poisoned\") {\r\n    throw new TestLifecycleError(POISONED_MESSAGE);\r\n  }\r\n\r\n  if (registry.state === \"stopping\" && registry.teardownAttempt) {\r\n    await settled(registry.teardownAttempt);\r\n\r\n    return setupTest(options);\r\n  }\r\n\r\n  if (registry.state === \"ready\") {\r\n    assertReadySelectionMatches(registry.activeSelection, requested);\r\n\r\n    return;\r\n  }\r\n\r\n  if (registry.state === \"starting\" && registry.setupAttempt) {\r\n    const attempt = registry.setupAttempt;\r\n\r\n    await assertPendingSetupMatches(attempt, requested);\r\n\r\n    return attempt.completion;\r\n  }\r\n\r\n  return startTestRuntime(requested);\r\n}\r\n\r\n/**\r\n * Shut the test runtime down and release the lifecycle.\r\n *\r\n * - idle is a no-op;\r\n * - concurrent calls share one attempt;\r\n * - a call made while setup is still running waits for that attempt to settle,\r\n *   then closes the runtime if it succeeded;\r\n * - the local \"ready\" state is always cleared, including when shutdown rejects;\r\n * - a shutdown rejection is surfaced, never swallowed, and poisons the\r\n *   lifecycle — a reported close failure is not proof that anything closed, so\r\n *   later `setupTest` calls refuse until the worker is restarted or a retry\r\n *   fully succeeds.\r\n *\r\n * ⚠ Individual connector shutdown failures are caught and logged inside\r\n * `connectorsManager.shutdown()`, so they never reach this function and never\r\n * poison anything. This lifecycle can only surface what that layer reports.\r\n */\r\nexport async function teardownTest(): Promise<void> {\r\n  const registry = getTestLifecycleRegistry();\r\n\r\n  if (registry.state === \"stopping\" && registry.teardownAttempt) {\r\n    return registry.teardownAttempt;\r\n  }\r\n\r\n  if (registry.state === \"starting\" && registry.setupAttempt) {\r\n    // A runtime that is still opening cannot be closed halfway. Wait for the\r\n    // attempt to settle: a failed one has already unwound itself and left the\r\n    // lifecycle idle, which the re-entry below then reads as \"nothing to do\".\r\n    await settled(registry.setupAttempt.completion);\r\n\r\n    return teardownTest();\r\n  }\r\n\r\n  if (registry.state === \"idle\") {\r\n    return;\r\n  }\r\n\r\n  registry.state = \"stopping\";\r\n\r\n  // Deferred by a microtask so the registry is fully published before the\r\n  // attempt's first line runs — a synchronous throw would otherwise reach the\r\n  // `finally` below, and reset the state, before this function had recorded\r\n  // that a teardown was in flight at all.\r\n  const attempt = Promise.resolve().then(() => runTestRuntimeShutdown());\r\n\r\n  registry.teardownAttempt = attempt;\r\n\r\n  return attempt;\r\n}\r\n\r\n/**\r\n * The setup attempt's hang guard, as the lifecycle consumes it.\r\n *\r\n * The bound's POLICY — the default, the config key, the message — lives in\r\n * `test-setup-timeout.ts`. What expiry MEANS lives here.\r\n *\r\n * @internal\r\n */\r\ntype SetupBound = {\r\n  /**\r\n   * Rejects with the expiry error. Never resolves: the attempt is the only side\r\n   * of the race that can succeed.\r\n   */\r\n  readonly expiry: Promise<never>;\r\n\r\n  /**\r\n   * Re-aim the bound at `next` ms measured from when the ATTEMPT STARTED, once\r\n   * config has made `tests.setupTimeout` readable.\r\n   */\r\n  rearm(next: number): void;\r\n\r\n  /** The race is over — cancel whatever timer is still pending. */\r\n  settle(): void;\r\n\r\n  /** Whether the bound, rather than the attempt, won the race. */\r\n  hasExpired(): boolean;\r\n};\r\n\r\n/**\r\n * Arm the hang guard for one setup attempt.\r\n *\r\n * Armed at the default BEFORE the attempt runs, because `tests.setupTimeout` is\r\n * not readable until the attempt has loaded config — and loading config is\r\n * itself one of the steps that can hang. `rearm` then narrows or widens it the\r\n * moment config arrives.\r\n */\r\nfunction armSetupBound(registry: TestLifecycleRegistry): SetupBound {\r\n  const schedule = registry.scheduleTimeout ?? scheduleRealTimeout;\r\n  const armedAt = Date.now();\r\n\r\n  let handle: TestTimeoutHandle | undefined;\r\n  let expired = false;\r\n  let closed = false;\r\n  let expire: (error: unknown) => void = () => undefined;\r\n\r\n  const expiry = new Promise<never>((_resolve, reject) => {\r\n    expire = reject;\r\n  });\r\n\r\n  // Only `awaitSetupWithinBound` observes this, and only until the attempt wins\r\n  // — after that nobody is listening, and an unobserved rejection surfaces as an\r\n  // unhandled rejection that fails an unrelated test file. Same reason as the\r\n  // `effectiveSelection` barrier below.\r\n  expiry.catch(() => undefined);\r\n\r\n  const expireNow = (bound: number): void => {\r\n    if (closed) {\r\n      return;\r\n    }\r\n\r\n    closed = true;\r\n    expired = true;\r\n\r\n    handle?.cancel();\r\n    handle = undefined;\r\n\r\n    expire(new TestLifecycleError(describeExpiredSetup(bound)));\r\n  };\r\n\r\n  const armFor = (bound: number, delay: number): void => {\r\n    if (closed) {\r\n      return;\r\n    }\r\n\r\n    handle?.cancel();\r\n\r\n    // Already overdue. A bound the attempt has ALREADY exceeded must fire now,\r\n    // not be rescheduled for time that was spent before it was known.\r\n    if (delay <= 0) {\r\n      expireNow(bound);\r\n\r\n      return;\r\n    }\r\n\r\n    handle = schedule(delay, () => expireNow(bound));\r\n  };\r\n\r\n  const initialBound = registry.setupTimeoutOverride ?? DEFAULT_TEST_SETUP_TIMEOUT;\r\n\r\n  armFor(initialBound, initialBound);\r\n\r\n  return {\r\n    expiry,\r\n\r\n    // Measured from `armedAt`, never from now: adding a configured bound to the\r\n    // time already spent would make the real bound default-plus-configured, and\r\n    // a project that lowered the key would get a LONGER guard than the default.\r\n    rearm: (next) => armFor(next, next - (Date.now() - armedAt)),\r\n\r\n    settle: () => {\r\n      closed = true;\r\n\r\n      handle?.cancel();\r\n      handle = undefined;\r\n    },\r\n\r\n    hasExpired: () => expired,\r\n  };\r\n}\r\n\r\n/**\r\n * Race one setup attempt against its bound.\r\n *\r\n * The losing attempt is NOT cancellable — nothing here can interrupt a bootstrap\r\n * stuck in a socket connect — so when the bound wins, the lifecycle is poisoned\r\n * and every later state write from that abandoned attempt is dropped. That\r\n * dropping happens in `runTestRuntimeStartup`, guarded on `hasExpired()`;\r\n * without it the still-running attempt would quietly overwrite `poisoned` with\r\n * `ready` or `idle` and hand the next caller a runtime nobody owns.\r\n */\r\nasync function awaitSetupWithinBound(\r\n  attempt: Promise<void>,\r\n  bound: SetupBound,\r\n  registry: TestLifecycleRegistry,\r\n): Promise<void> {\r\n  try {\r\n    await Promise.race([attempt, bound.expiry]);\r\n  } catch (error) {\r\n    if (bound.hasExpired()) {\r\n      registry.state = \"poisoned\";\r\n      registry.activeSelection = undefined;\r\n      registry.setupAttempt = undefined;\r\n    }\r\n\r\n    throw error;\r\n  } finally {\r\n    bound.settle();\r\n  }\r\n}\r\n\r\n/**\r\n * Open a new setup attempt and publish it before it runs.\r\n */\r\nfunction startTestRuntime(requested: RequestedTestConnectors): Promise<void> {\r\n  const registry = getTestLifecycleRegistry();\r\n\r\n  let publishEffectiveSelection: (selection: TestConnectorsSelection) => void = () => undefined;\r\n  let failEffectiveSelection: (error: unknown) => void = () => undefined;\r\n\r\n  const effectiveSelection = new Promise<TestConnectorsSelection>((resolve, reject) => {\r\n    publishEffectiveSelection = resolve;\r\n    failEffectiveSelection = reject;\r\n  });\r\n\r\n  // Only the mixed explicit/config comparison ever awaits this barrier, so its\r\n  // rejection is usually unobserved — and an unobserved rejection would surface\r\n  // as an unhandled rejection and fail an unrelated test file.\r\n  effectiveSelection.catch(() => undefined);\r\n\r\n  const bound = armSetupBound(registry);\r\n\r\n  const attempt = Promise.resolve().then(() =>\r\n    runTestRuntimeStartup(requested, publishEffectiveSelection, failEffectiveSelection, bound),\r\n  );\r\n\r\n  // The attempt outlives a bound that beat it, and by then `completion` has\r\n  // already rejected with the expiry error — so the attempt's own late rejection\r\n  // has no observer. Same unhandled-rejection hazard as above.\r\n  attempt.catch(() => undefined);\r\n\r\n  // `teardownTest` waits on this same promise, which is how a teardown requested\r\n  // during setup inherits the bound. There is deliberately no second timer and\r\n  // no separate teardown deadline.\r\n  const completion = awaitSetupWithinBound(attempt, bound, registry);\r\n\r\n  registry.state = \"starting\";\r\n  registry.setupAttempt = { requested, effectiveSelection, completion };\r\n\r\n  return completion;\r\n}\r\n\r\n/**\r\n * The startup attempt itself.\r\n *\r\n * On failure: best-effort unwind, reset bookkeeping, rethrow the ORIGINAL error\r\n * unchanged. A cleanup failure is a secondary diagnostic and never replaces the\r\n * cause the caller needs to read.\r\n */\r\nasync function runTestRuntimeStartup(\r\n  requested: RequestedTestConnectors,\r\n  publishEffectiveSelection: (selection: TestConnectorsSelection) => void,\r\n  failEffectiveSelection: (error: unknown) => void,\r\n  bound: SetupBound,\r\n): Promise<void> {\r\n  const registry = getTestLifecycleRegistry();\r\n\r\n  try {\r\n    Application.setEnvironment(\"test\");\r\n\r\n    await warlockConfigManager.load();\r\n    await bootstrap();\r\n\r\n    await filesOrchestrator.init();\r\n    await loadConfigFiles(true);\r\n\r\n    // The first point at which `tests.setupTimeout` is readable at all. An\r\n    // invalid value throws from here and takes the normal failure path — falling\r\n    // back to the default would silently erase what the project configured.\r\n    const configuredTimeout = readConfiguredSetupTimeout();\r\n\r\n    if (configuredTimeout !== undefined) {\r\n      bound.rearm(configuredTimeout);\r\n    }\r\n\r\n    // Resolved here and not at call time: the config layer is only readable once\r\n    // the four steps above have run.\r\n    const effectiveSelection = resolveEffectiveConnectors(requested);\r\n\r\n    // Every state write below is conditional on this attempt still being the one\r\n    // the lifecycle is waiting for. Once the bound has expired the lifecycle is\r\n    // poisoned and this attempt is abandoned — it may still be running, but it\r\n    // no longer speaks for the runtime.\r\n    if (!bound.hasExpired()) {\r\n      registry.activeSelection = effectiveSelection;\r\n    }\r\n\r\n    publishEffectiveSelection(effectiveSelection);\r\n\r\n    await startSelectedConnectors(effectiveSelection);\r\n\r\n    if (!bound.hasExpired()) {\r\n      registry.state = \"ready\";\r\n      registry.setupAttempt = undefined;\r\n    }\r\n  } catch (error) {\r\n    failEffectiveSelection(error);\r\n\r\n    await unwindPartialStartup();\r\n\r\n    if (!bound.hasExpired()) {\r\n      registry.state = \"idle\";\r\n      registry.activeSelection = undefined;\r\n      registry.setupAttempt = undefined;\r\n    }\r\n\r\n    console.error(\"[vitest-setup] Failed to setup test environment:\", error);\r\n\r\n    throw error;\r\n  }\r\n}\r\n\r\n/**\r\n * `false` means none at all. Everything else starts something: an array starts\r\n * exactly those, and `true` starts the default set — all but http, which is the\r\n * global setup's job and shared across every worker.\r\n */\r\nasync function startSelectedConnectors(selection: TestConnectorsSelection): Promise<void> {\r\n  if (selection === false) {\r\n    return;\r\n  }\r\n\r\n  if (Array.isArray(selection)) {\r\n    await connectorsManager.start(normalizeConnectorNames(selection));\r\n\r\n    return;\r\n  }\r\n\r\n  await connectorsManager.startWithout([\"http\"]);\r\n}\r\n\r\n/**\r\n * Best-effort teardown of whatever a failed startup managed to start.\r\n *\r\n * Runs while an error is already in flight, so no step here may throw and every\r\n * step is attempted independently.\r\n */\r\nasync function unwindPartialStartup(): Promise<void> {\r\n  // Two steps rather than one: `connectorsManager.shutdown()` runs the\r\n  // application hooks itself, but it runs them FIRST and does not isolate their\r\n  // rejection — so a hook that rejects would take the connector teardown down\r\n  // with it and leave every connector up. Both calls are idempotent, so running\r\n  // the hooks on their own first costs nothing and means neither failure can\r\n  // skip the other step.\r\n  await attemptCleanupStep(\"application shutdown hooks\", () => Application.runShutdownHooks());\r\n  await attemptCleanupStep(\"connectors shutdown\", () => connectorsManager.shutdown());\r\n}\r\n\r\n/**\r\n * Run one cleanup step, isolating its failure so the next step still runs.\r\n */\r\nasync function attemptCleanupStep(step: string, run: () => Promise<void>): Promise<void> {\r\n  try {\r\n    await run();\r\n  } catch (error) {\r\n    // Reported, not thrown — it is secondary to the startup error about to be\r\n    // rethrown, and losing that one to this would be the worse outcome.\r\n    console.error(`[vitest-setup] Cleanup after a failed setup did not complete (${step}):`, error);\r\n  }\r\n}\r\n\r\n/**\r\n * The teardown attempt itself.\r\n */\r\nasync function runTestRuntimeShutdown(): Promise<void> {\r\n  const registry = getTestLifecycleRegistry();\r\n  let shutdownSucceeded = false;\r\n\r\n  try {\r\n    // Manager-wide, and deliberately called whatever the selection was: with\r\n    // `connectors: false` nothing was started, but bootstrap still registered\r\n    // application shutdown hooks, and the manager runs those first (see\r\n    // `connectors-manager.ts` — `Application.runShutdownHooks()` is its first\r\n    // line). Skipping the call to \"match\" an empty selection would leak them.\r\n    await connectorsManager.shutdown();\r\n\r\n    shutdownSucceeded = true;\r\n  } finally {\r\n    // In a `finally`, not after the `await`: a rejected shutdown must not leave\r\n    // the lifecycle claiming a runtime it no longer owns. Poisoned rather than\r\n    // idle, because a cleared flag does not prove that ports, sockets, pools or\r\n    // timers closed.\r\n    registry.activeSelection = undefined;\r\n    registry.setupAttempt = undefined;\r\n    registry.teardownAttempt = undefined;\r\n    registry.state = shutdownSucceeded ? \"idle\" : \"poisoned\";\r\n  }\r\n}\r\n\r\n/**\r\n * Reject when a ready runtime was set up with a different selection.\r\n */\r\nfunction assertReadySelectionMatches(\r\n  activeSelection: TestConnectorsSelection | undefined,\r\n  requested: RequestedTestConnectors,\r\n): void {\r\n  if (activeSelection === undefined) {\r\n    return;\r\n  }\r\n\r\n  // Config is loaded by the time anything is ready, so the config-derived layer\r\n  // is resolvable right here.\r\n  const requestedSelection = resolveEffectiveConnectors(requested);\r\n\r\n  assertSelectionsMatch(activeSelection, requestedSelection);\r\n}\r\n\r\n/**\r\n * Reject when an in-flight setup attempt is starting a different selection.\r\n */\r\nasync function assertPendingSetupMatches(\r\n  attempt: TestSetupAttempt,\r\n  requested: RequestedTestConnectors,\r\n): Promise<void> {\r\n  const pending = attempt.requested;\r\n\r\n  // Two calls that both defer to project config resolve to the same thing by\r\n  // construction — knowable without waiting for config to load.\r\n  if (!pending.isExplicit && !requested.isExplicit) {\r\n    return;\r\n  }\r\n\r\n  if (pending.isExplicit && requested.isExplicit) {\r\n    assertSelectionsMatch(pending.selection, requested.selection);\r\n\r\n    return;\r\n  }\r\n\r\n  // Mixed: one side is config-derived and config is not readable until the\r\n  // running attempt has loaded it, so wait for that barrier first.\r\n  const activeSelection = await attempt.effectiveSelection;\r\n  const requestedSelection = resolveEffectiveConnectors(requested);\r\n\r\n  assertSelectionsMatch(activeSelection, requestedSelection);\r\n}\r\n\r\n/**\r\n * Name both selections: a caller looking at this message has to be able to tell\r\n * which call to change without reading the framework's source.\r\n */\r\nfunction assertSelectionsMatch(\r\n  activeSelection: TestConnectorsSelection,\r\n  requestedSelection: TestConnectorsSelection,\r\n): void {\r\n  if (isSameConnectorsSelection(activeSelection, requestedSelection)) {\r\n    return;\r\n  }\r\n\r\n  throw new TestLifecycleError(\r\n    `setupTest() is already using ${describeConnectorsSelection(activeSelection)}, and this call asked for ${describeConnectorsSelection(requestedSelection)}. One test runtime serves one connector selection — call teardownTest() before setting up a different one.`,\r\n  );\r\n}\r\n\r\n/**\r\n * Await an attempt for its state transition only, not its result.\r\n */\r\nfunction settled(attempt: Promise<void>): Promise<void> {\r\n  return attempt.catch(() => undefined);\r\n}\r\n"],"mappings":"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"}

package/esm/updater/package-manager.mjs

@@ -2,7 +2,7 @@ import { rootPath } from "../utils/paths.mjs";
 import "../utils/index.mjs";
 import { fileExistsAsync } from "@warlock.js/fs";
 
-//#region core/src/updater/package-manager.ts
+//#region ../core/src/updater/package-manager.ts
 /**
 * The lockfile that identifies each package manager, in detection order.
 * Bun is checked first because a Bun project may also carry a `yarn.lock`

package/esm/updater/package-manager.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"package-manager.mjs","names":[],"sources":["C:/Work/Warlock.js/core/src/updater/package-manager.ts"],"sourcesContent":["import { fileExistsAsync } from \"@warlock.js/fs\";\nimport { rootPath } from \"../utils\";\n\n/** Package managers the framework knows how to drive. */\nexport type PackageManager = \"npm\" | \"yarn\" | \"pnpm\" | \"bun\";\n\n/**\n * The lockfile that identifies each package manager, in detection order.\n * Bun is checked first because a Bun project may also carry a `yarn.lock`\n * (Bun writes one for tooling compatibility) — matching yarn there would run\n * the wrong installer against the wrong lockfile.\n */\nconst LOCKFILES: ReadonlyArray<{ file: string; packageManager: PackageManager }> = [\n  { file: \"bun.lock\", packageManager: \"bun\" },\n  { file: \"bun.lockb\", packageManager: \"bun\" },\n  { file: \"package-lock.json\", packageManager: \"npm\" },\n  { file: \"yarn.lock\", packageManager: \"yarn\" },\n  { file: \"pnpm-lock.yaml\", packageManager: \"pnpm\" },\n];\n\n/**\n * Detect the project's package manager from its lockfile, falling back to\n * npm when none is present. Shared by `warlock update` and `warlock add` so\n * both agree on a project that happens to carry more than one lockfile.\n */\nexport async function detectPackageManager(): Promise<PackageManager> {\n  for (const { file, packageManager } of LOCKFILES) {\n    if (await fileExistsAsync(rootPath(file))) {\n      return packageManager;\n    }\n  }\n\n  return \"npm\";\n}\n\n/**\n * The lockfile-syncing install command for the given manager. No package\n * arguments — `warlock update` rewrites the versions in package.json first,\n * then a plain install reconciles `node_modules` to match.\n */\nexport function getInstallCommand(packageManager: PackageManager): string {\n  switch (packageManager) {\n    case \"yarn\":\n      return \"yarn install\";\n\n    case \"pnpm\":\n      return \"pnpm install\";\n\n    case \"bun\":\n      return \"bun install\";\n\n    default:\n      return \"npm install\";\n  }\n}\n\n/**\n * The command that installs *specific* packages — what `warlock add` needs.\n * Distinct from {@link getInstallCommand}, which only reconciles what is\n * already written into package.json.\n */\nexport function getAddCommand(packageManager: PackageManager): string {\n  switch (packageManager) {\n    case \"yarn\":\n      return \"yarn add\";\n\n    case \"pnpm\":\n      return \"pnpm add\";\n\n    case \"bun\":\n      return \"bun add\";\n\n    default:\n      return \"npm install\";\n  }\n}\n"],"mappings":";;;;;;;;;;;AAYA,MAAM,YAA6E;CACjF;EAAE,MAAM;EAAY,gBAAgB;CAAM;CAC1C;EAAE,MAAM;EAAa,gBAAgB;CAAM;CAC3C;EAAE,MAAM;EAAqB,gBAAgB;CAAM;CACnD;EAAE,MAAM;EAAa,gBAAgB;CAAO;CAC5C;EAAE,MAAM;EAAkB,gBAAgB;CAAO;AACnD;;;;;;AAOA,eAAsB,uBAAgD;CACpE,KAAK,MAAM,EAAE,MAAM,oBAAoB,WACrC,IAAI,MAAM,gBAAgB,SAAS,IAAI,CAAC,GACtC,OAAO;CAIX,OAAO;AACT;;;;;;AAOA,SAAgB,kBAAkB,gBAAwC;CACxE,QAAQ,gBAAR;EACE,KAAK,QACH,OAAO;EAET,KAAK,QACH,OAAO;EAET,KAAK,OACH,OAAO;EAET,SACE,OAAO;CACX;AACF;;;;;;AAOA,SAAgB,cAAc,gBAAwC;CACpE,QAAQ,gBAAR;EACE,KAAK,QACH,OAAO;EAET,KAAK,QACH,OAAO;EAET,KAAK,OACH,OAAO;EAET,SACE,OAAO;CACX;AACF"}
+{"version":3,"file":"package-manager.mjs","names":[],"sources":["../../../../../../../core/src/updater/package-manager.ts"],"sourcesContent":["import { fileExistsAsync } from \"@warlock.js/fs\";\nimport { rootPath } from \"../utils\";\n\n/** Package managers the framework knows how to drive. */\nexport type PackageManager = \"npm\" | \"yarn\" | \"pnpm\" | \"bun\";\n\n/**\n * The lockfile that identifies each package manager, in detection order.\n * Bun is checked first because a Bun project may also carry a `yarn.lock`\n * (Bun writes one for tooling compatibility) — matching yarn there would run\n * the wrong installer against the wrong lockfile.\n */\nconst LOCKFILES: ReadonlyArray<{ file: string; packageManager: PackageManager }> = [\n  { file: \"bun.lock\", packageManager: \"bun\" },\n  { file: \"bun.lockb\", packageManager: \"bun\" },\n  { file: \"package-lock.json\", packageManager: \"npm\" },\n  { file: \"yarn.lock\", packageManager: \"yarn\" },\n  { file: \"pnpm-lock.yaml\", packageManager: \"pnpm\" },\n];\n\n/**\n * Detect the project's package manager from its lockfile, falling back to\n * npm when none is present. Shared by `warlock update` and `warlock add` so\n * both agree on a project that happens to carry more than one lockfile.\n */\nexport async function detectPackageManager(): Promise<PackageManager> {\n  for (const { file, packageManager } of LOCKFILES) {\n    if (await fileExistsAsync(rootPath(file))) {\n      return packageManager;\n    }\n  }\n\n  return \"npm\";\n}\n\n/**\n * The lockfile-syncing install command for the given manager. No package\n * arguments — `warlock update` rewrites the versions in package.json first,\n * then a plain install reconciles `node_modules` to match.\n */\nexport function getInstallCommand(packageManager: PackageManager): string {\n  switch (packageManager) {\n    case \"yarn\":\n      return \"yarn install\";\n\n    case \"pnpm\":\n      return \"pnpm install\";\n\n    case \"bun\":\n      return \"bun install\";\n\n    default:\n      return \"npm install\";\n  }\n}\n\n/**\n * The command that installs *specific* packages — what `warlock add` needs.\n * Distinct from {@link getInstallCommand}, which only reconciles what is\n * already written into package.json.\n */\nexport function getAddCommand(packageManager: PackageManager): string {\n  switch (packageManager) {\n    case \"yarn\":\n      return \"yarn add\";\n\n    case \"pnpm\":\n      return \"pnpm add\";\n\n    case \"bun\":\n      return \"bun add\";\n\n    default:\n      return \"npm install\";\n  }\n}\n"],"mappings":";;;;;;;;;;;AAYA,MAAM,YAA6E;CACjF;EAAE,MAAM;EAAY,gBAAgB;CAAM;CAC1C;EAAE,MAAM;EAAa,gBAAgB;CAAM;CAC3C;EAAE,MAAM;EAAqB,gBAAgB;CAAM;CACnD;EAAE,MAAM;EAAa,gBAAgB;CAAO;CAC5C;EAAE,MAAM;EAAkB,gBAAgB;CAAO;AACnD;;;;;;AAOA,eAAsB,uBAAgD;CACpE,KAAK,MAAM,EAAE,MAAM,oBAAoB,WACrC,IAAI,MAAM,gBAAgB,SAAS,IAAI,CAAC,GACtC,OAAO;CAIX,OAAO;AACT;;;;;;AAOA,SAAgB,kBAAkB,gBAAwC;CACxE,QAAQ,gBAAR;EACE,KAAK,QACH,OAAO;EAET,KAAK,QACH,OAAO;EAET,KAAK,OACH,OAAO;EAET,SACE,OAAO;CACX;AACF;;;;;;AAOA,SAAgB,cAAc,gBAAwC;CACpE,QAAQ,gBAAR;EACE,KAAK,QACH,OAAO;EAET,KAAK,QACH,OAAO;EAET,KAAK,OACH,OAAO;EAET,SACE,OAAO;CACX;AACF"}

package/esm/updater/update-warlock-packages.mjs

@@ -7,7 +7,7 @@ import { colors } from "@mongez/copper";
 import { fileExistsAsync, getJsonFileAsync, putJsonFileAsync } from "@warlock.js/fs";
 import { execSync } from "node:child_process";
 
-//#region core/src/updater/update-warlock-packages.ts
+//#region ../core/src/updater/update-warlock-packages.ts
 /** Scope prefix that identifies a Warlock framework package. */
 const WARLOCK_SCOPE = "@warlock.js/";
 /** The dependency maps in package.json we update, in display order. */

package/esm/updater/update-warlock-packages.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"update-warlock-packages.mjs","names":[],"sources":["C:/Work/Warlock.js/core/src/updater/update-warlock-packages.ts"],"sourcesContent":["import { colors } from \"@mongez/copper\";\nimport { fileExistsAsync, getJsonFileAsync, putJsonFileAsync } from \"@warlock.js/fs\";\nimport { execSync } from \"node:child_process\";\nimport { rootPath } from \"../utils\";\nimport { fetchLatestVersion } from \"../utils/npm-registry\";\nimport { isNewerVersion } from \"../utils/version-compare\";\nimport { detectPackageManager, getInstallCommand } from \"./package-manager\";\n\n/** Scope prefix that identifies a Warlock framework package. */\nconst WARLOCK_SCOPE = \"@warlock.js/\";\n\n/** The dependency maps in package.json we update, in display order. */\nconst DEPENDENCY_SECTIONS = [\"dependencies\", \"devDependencies\"] as const;\n\ntype DependencySection = (typeof DEPENDENCY_SECTIONS)[number];\n\ntype DependencyMap = Record<string, string>;\n\ntype PackageJson = Record<string, unknown> & {\n  dependencies?: DependencyMap;\n  devDependencies?: DependencyMap;\n};\n\n/** A `@warlock.js/*` dependency found in package.json. */\ntype WarlockDependency = {\n  name: string;\n  section: DependencySection;\n  /** The current spec exactly as written, e.g. `^4.2.0`. */\n  current: string;\n};\n\n/** A dependency whose latest version has been resolved from the registry. */\nexport type ResolvedDependency = WarlockDependency & {\n  /** Latest version from npm, or `undefined` when the lookup failed. */\n  latest: string | undefined;\n};\n\n/** A concrete version bump to write back into package.json. */\nexport type PackageUpdate = {\n  name: string;\n  section: DependencySection;\n  /** Existing spec, e.g. `^4.2.0`. */\n  from: string;\n  /** New spec with the original range operator preserved, e.g. `^4.3.0`. */\n  to: string;\n};\n\n/** Options accepted by {@link updateWarlockPackages}. */\nexport type UpdateWarlockPackagesOptions = {\n  /** Run the package manager install after rewriting versions (default true). */\n  install?: boolean;\n  /**\n   * Report what would change without touching package.json or node_modules.\n   * Resolves with the `outdated` outcome instead of `updated`.\n   */\n  dryRun?: boolean;\n};\n\n/**\n * How an update run ended. Callers branch on this instead of re-deriving the\n * situation from the printed output — the dev-server `u` shortcut needs to\n * know whether restarting is warranted, and whether it may offer a retry.\n */\nexport type UpdateOutcome =\n  /** No package.json at the project root — nothing to do. */\n  | \"no-package-json\"\n  /** package.json carries no `@warlock.js/*` dependency. */\n  | \"no-packages\"\n  /** Every registry lookup failed — offline, DNS down, or npm unreachable. */\n  | \"registry-unreachable\"\n  /** Every package is already at (or ahead of) its latest published version. */\n  | \"up-to-date\"\n  /** Newer versions exist, and a dry run left everything untouched. */\n  | \"outdated\"\n  /** Versions were rewritten (and installed, unless `install: false`). */\n  | \"updated\"\n  /** Versions were rewritten but the package manager install failed. */\n  | \"install-failed\";\n\n/** The result of an update run. */\nexport type UpdateWarlockPackagesResult = {\n  outcome: UpdateOutcome;\n  /** The bumps written to package.json — empty unless `outcome` wrote any. */\n  updates: PackageUpdate[];\n  /** The install failure, present only for `install-failed`. */\n  error?: Error;\n};\n\n/**\n * Update every `@warlock.js/*` package listed in the project's root\n * package.json to its latest published version, then reconcile `node_modules`\n * via the detected package manager.\n *\n * The original range operator on each dependency (`^`, `~`, or an exact pin)\n * is preserved; specs that aren't a plain semver — `workspace:*`, `*`,\n * `latest`, git/file URLs — are left untouched. Only genuine upgrades are\n * written, so re-running on an already-current project is a no-op.\n *\n * Resolves rather than throws on the two failures a caller is expected to\n * survive — an unreachable registry and a failed install — so the dev-server\n * shortcut can report them and keep serving.\n */\nexport async function updateWarlockPackages(\n  options: UpdateWarlockPackagesOptions = {},\n): Promise<UpdateWarlockPackagesResult> {\n  const runInstall = options.install ?? true;\n  const packageJsonPath = rootPath(\"package.json\");\n\n  if (!(await fileExistsAsync(packageJsonPath))) {\n    console.log(`${colors.red(\"✖\")} No package.json found at the project root.`);\n    return { outcome: \"no-package-json\", updates: [] };\n  }\n\n  const packageJson = (await getJsonFileAsync(packageJsonPath)) as PackageJson;\n  const dependencies = collectWarlockDependencies(packageJson);\n\n  if (dependencies.length === 0) {\n    console.log(`${colors.yellow(\"⚠\")} No @warlock.js packages found in package.json.`);\n    return { outcome: \"no-packages\", updates: [] };\n  }\n\n  console.log(\n    `${colors.cyan(\"›\")} Checking ${colors.bold(String(dependencies.length))} ` +\n      `@warlock.js package(s) for updates…`,\n  );\n\n  const resolved = await resolveLatestVersions(dependencies);\n\n  // Distinguish \"nothing newer\" from \"we never got an answer\". Without this,\n  // an offline run reports every package as up to date, which is a lie.\n  if (isRegistryUnreachable(resolved)) {\n    console.log(\n      `${colors.yellow(\"⚠\")} Could not reach the npm registry — ` +\n        `no versions were changed. Check your connection and try again.`,\n    );\n    return { outcome: \"registry-unreachable\", updates: [] };\n  }\n\n  const updates = resolvePackageUpdates(resolved);\n\n  if (updates.length === 0) {\n    console.log(`${colors.green(\"✓\")} All @warlock.js packages are already up to date.`);\n    return { outcome: \"up-to-date\", updates: [] };\n  }\n\n  if (options.dryRun) {\n    printUpdates(updates, { pending: true });\n    return { outcome: \"outdated\", updates };\n  }\n\n  applyUpdates(packageJson, updates);\n  await putJsonFileAsync(packageJsonPath, packageJson);\n\n  printUpdates(updates);\n\n  if (!runInstall) {\n    console.log(\n      colors.dim(\"Skipped install (--no-install). Run your package manager to apply the changes.\"),\n    );\n    return { outcome: \"updated\", updates };\n  }\n\n  try {\n    await installDependencies();\n  } catch (error) {\n    console.log(\n      `${colors.red(\"✖\")} The install failed. package.json is already updated — ` +\n        `re-run your package manager install to finish.`,\n    );\n    return { outcome: \"install-failed\", updates, error: error as Error };\n  }\n\n  return { outcome: \"updated\", updates };\n}\n\n/**\n * Whether *every* lookup came back empty, which in practice means the\n * registry was never reached. A single failed package (unpublished, renamed,\n * private) leaves the rest resolvable and is not treated as an outage.\n */\nexport function isRegistryUnreachable(resolved: ResolvedDependency[]): boolean {\n  return resolved.length > 0 && resolved.every((dependency) => !dependency.latest);\n}\n\n/** Collect every `@warlock.js/*` dependency across the relevant sections. */\nfunction collectWarlockDependencies(packageJson: PackageJson): WarlockDependency[] {\n  const dependencies: WarlockDependency[] = [];\n\n  for (const section of DEPENDENCY_SECTIONS) {\n    const map = packageJson[section];\n\n    if (!map) {\n      continue;\n    }\n\n    for (const [name, current] of Object.entries(map)) {\n      if (name.startsWith(WARLOCK_SCOPE)) {\n        dependencies.push({ name, section, current });\n      }\n    }\n  }\n\n  return dependencies;\n}\n\n/** Resolve each dependency's latest version from the registry in parallel. */\nasync function resolveLatestVersions(\n  dependencies: WarlockDependency[],\n): Promise<ResolvedDependency[]> {\n  return Promise.all(\n    dependencies.map(async (dependency) => ({\n      ...dependency,\n      latest: await fetchLatestVersion(dependency.name),\n    })),\n  );\n}\n\n/**\n * Turn resolved dependencies into the concrete set of version bumps to write.\n * Pure (no I/O) so it can be unit-tested directly: skips lookups that failed,\n * non-semver specs, and anything already at (or ahead of) the latest version,\n * and preserves the original range operator on everything it does rewrite.\n */\nexport function resolvePackageUpdates(resolved: ResolvedDependency[]): PackageUpdate[] {\n  const updates: PackageUpdate[] = [];\n\n  for (const dependency of resolved) {\n    if (!dependency.latest) {\n      continue;\n    }\n\n    const parsed = parseSpec(dependency.current);\n\n    if (!parsed) {\n      continue;\n    }\n\n    if (!isNewerVersion(dependency.latest, parsed.version)) {\n      continue;\n    }\n\n    updates.push({\n      name: dependency.name,\n      section: dependency.section,\n      from: dependency.current,\n      to: `${parsed.operator}${dependency.latest}`,\n    });\n  }\n\n  return updates;\n}\n\n/**\n * Split a dependency spec into its range operator and concrete version.\n * Returns `undefined` for specs we won't touch — `workspace:*`, `*`,\n * `latest`, multi-part ranges, or git/file URLs — leaving them exactly as\n * the author wrote them.\n */\nfunction parseSpec(spec: string): { operator: string; version: string } | undefined {\n  const match = spec.trim().match(/^(\\^|~)?(\\d+\\.\\d+\\.\\d+(?:-[0-9A-Za-z.-]+)?)$/);\n\n  if (!match) {\n    return undefined;\n  }\n\n  return { operator: match[1] ?? \"\", version: match[2] };\n}\n\n/** Write the resolved bumps back into the package.json object in place. */\nfunction applyUpdates(packageJson: PackageJson, updates: PackageUpdate[]): void {\n  for (const update of updates) {\n    const map = packageJson[update.section];\n\n    if (map) {\n      map[update.name] = update.to;\n    }\n  }\n}\n\n/** Print the version bumps — applied, or pending on a dry run. */\nfunction printUpdates(updates: PackageUpdate[], { pending = false } = {}): void {\n  const headline = pending\n    ? `${colors.yellow(\"↑\")} ${colors.bold(String(updates.length))} package(s) can be updated:`\n    : `${colors.green(\"✓\")} Updated ${colors.bold(String(updates.length))} package(s):`;\n\n  console.log(headline);\n\n  for (const update of updates) {\n    console.log(\n      `   ${colors.cyan(update.name)}  ` +\n        `${colors.dim(update.from)} ${colors.dim(\"→\")} ${colors.greenBright(update.to)}`,\n    );\n  }\n}\n\n/** Reconcile node_modules to the rewritten package.json via the project PM. */\nasync function installDependencies(): Promise<void> {\n  const packageManager = await detectPackageManager();\n  const installCommand = getInstallCommand(packageManager);\n\n  console.log(`${colors.cyan(\"›\")} Running ${colors.bold(installCommand)}…`);\n\n  execSync(installCommand, { cwd: process.cwd(), stdio: \"inherit\" });\n}\n"],"mappings":"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"}
+{"version":3,"file":"update-warlock-packages.mjs","names":[],"sources":["../../../../../../../core/src/updater/update-warlock-packages.ts"],"sourcesContent":["import { colors } from \"@mongez/copper\";\nimport { fileExistsAsync, getJsonFileAsync, putJsonFileAsync } from \"@warlock.js/fs\";\nimport { execSync } from \"node:child_process\";\nimport { rootPath } from \"../utils\";\nimport { fetchLatestVersion } from \"../utils/npm-registry\";\nimport { isNewerVersion } from \"../utils/version-compare\";\nimport { detectPackageManager, getInstallCommand } from \"./package-manager\";\n\n/** Scope prefix that identifies a Warlock framework package. */\nconst WARLOCK_SCOPE = \"@warlock.js/\";\n\n/** The dependency maps in package.json we update, in display order. */\nconst DEPENDENCY_SECTIONS = [\"dependencies\", \"devDependencies\"] as const;\n\ntype DependencySection = (typeof DEPENDENCY_SECTIONS)[number];\n\ntype DependencyMap = Record<string, string>;\n\ntype PackageJson = Record<string, unknown> & {\n  dependencies?: DependencyMap;\n  devDependencies?: DependencyMap;\n};\n\n/** A `@warlock.js/*` dependency found in package.json. */\ntype WarlockDependency = {\n  name: string;\n  section: DependencySection;\n  /** The current spec exactly as written, e.g. `^4.2.0`. */\n  current: string;\n};\n\n/** A dependency whose latest version has been resolved from the registry. */\nexport type ResolvedDependency = WarlockDependency & {\n  /** Latest version from npm, or `undefined` when the lookup failed. */\n  latest: string | undefined;\n};\n\n/** A concrete version bump to write back into package.json. */\nexport type PackageUpdate = {\n  name: string;\n  section: DependencySection;\n  /** Existing spec, e.g. `^4.2.0`. */\n  from: string;\n  /** New spec with the original range operator preserved, e.g. `^4.3.0`. */\n  to: string;\n};\n\n/** Options accepted by {@link updateWarlockPackages}. */\nexport type UpdateWarlockPackagesOptions = {\n  /** Run the package manager install after rewriting versions (default true). */\n  install?: boolean;\n  /**\n   * Report what would change without touching package.json or node_modules.\n   * Resolves with the `outdated` outcome instead of `updated`.\n   */\n  dryRun?: boolean;\n};\n\n/**\n * How an update run ended. Callers branch on this instead of re-deriving the\n * situation from the printed output — the dev-server `u` shortcut needs to\n * know whether restarting is warranted, and whether it may offer a retry.\n */\nexport type UpdateOutcome =\n  /** No package.json at the project root — nothing to do. */\n  | \"no-package-json\"\n  /** package.json carries no `@warlock.js/*` dependency. */\n  | \"no-packages\"\n  /** Every registry lookup failed — offline, DNS down, or npm unreachable. */\n  | \"registry-unreachable\"\n  /** Every package is already at (or ahead of) its latest published version. */\n  | \"up-to-date\"\n  /** Newer versions exist, and a dry run left everything untouched. */\n  | \"outdated\"\n  /** Versions were rewritten (and installed, unless `install: false`). */\n  | \"updated\"\n  /** Versions were rewritten but the package manager install failed. */\n  | \"install-failed\";\n\n/** The result of an update run. */\nexport type UpdateWarlockPackagesResult = {\n  outcome: UpdateOutcome;\n  /** The bumps written to package.json — empty unless `outcome` wrote any. */\n  updates: PackageUpdate[];\n  /** The install failure, present only for `install-failed`. */\n  error?: Error;\n};\n\n/**\n * Update every `@warlock.js/*` package listed in the project's root\n * package.json to its latest published version, then reconcile `node_modules`\n * via the detected package manager.\n *\n * The original range operator on each dependency (`^`, `~`, or an exact pin)\n * is preserved; specs that aren't a plain semver — `workspace:*`, `*`,\n * `latest`, git/file URLs — are left untouched. Only genuine upgrades are\n * written, so re-running on an already-current project is a no-op.\n *\n * Resolves rather than throws on the two failures a caller is expected to\n * survive — an unreachable registry and a failed install — so the dev-server\n * shortcut can report them and keep serving.\n */\nexport async function updateWarlockPackages(\n  options: UpdateWarlockPackagesOptions = {},\n): Promise<UpdateWarlockPackagesResult> {\n  const runInstall = options.install ?? true;\n  const packageJsonPath = rootPath(\"package.json\");\n\n  if (!(await fileExistsAsync(packageJsonPath))) {\n    console.log(`${colors.red(\"✖\")} No package.json found at the project root.`);\n    return { outcome: \"no-package-json\", updates: [] };\n  }\n\n  const packageJson = (await getJsonFileAsync(packageJsonPath)) as PackageJson;\n  const dependencies = collectWarlockDependencies(packageJson);\n\n  if (dependencies.length === 0) {\n    console.log(`${colors.yellow(\"⚠\")} No @warlock.js packages found in package.json.`);\n    return { outcome: \"no-packages\", updates: [] };\n  }\n\n  console.log(\n    `${colors.cyan(\"›\")} Checking ${colors.bold(String(dependencies.length))} ` +\n      `@warlock.js package(s) for updates…`,\n  );\n\n  const resolved = await resolveLatestVersions(dependencies);\n\n  // Distinguish \"nothing newer\" from \"we never got an answer\". Without this,\n  // an offline run reports every package as up to date, which is a lie.\n  if (isRegistryUnreachable(resolved)) {\n    console.log(\n      `${colors.yellow(\"⚠\")} Could not reach the npm registry — ` +\n        `no versions were changed. Check your connection and try again.`,\n    );\n    return { outcome: \"registry-unreachable\", updates: [] };\n  }\n\n  const updates = resolvePackageUpdates(resolved);\n\n  if (updates.length === 0) {\n    console.log(`${colors.green(\"✓\")} All @warlock.js packages are already up to date.`);\n    return { outcome: \"up-to-date\", updates: [] };\n  }\n\n  if (options.dryRun) {\n    printUpdates(updates, { pending: true });\n    return { outcome: \"outdated\", updates };\n  }\n\n  applyUpdates(packageJson, updates);\n  await putJsonFileAsync(packageJsonPath, packageJson);\n\n  printUpdates(updates);\n\n  if (!runInstall) {\n    console.log(\n      colors.dim(\"Skipped install (--no-install). Run your package manager to apply the changes.\"),\n    );\n    return { outcome: \"updated\", updates };\n  }\n\n  try {\n    await installDependencies();\n  } catch (error) {\n    console.log(\n      `${colors.red(\"✖\")} The install failed. package.json is already updated — ` +\n        `re-run your package manager install to finish.`,\n    );\n    return { outcome: \"install-failed\", updates, error: error as Error };\n  }\n\n  return { outcome: \"updated\", updates };\n}\n\n/**\n * Whether *every* lookup came back empty, which in practice means the\n * registry was never reached. A single failed package (unpublished, renamed,\n * private) leaves the rest resolvable and is not treated as an outage.\n */\nexport function isRegistryUnreachable(resolved: ResolvedDependency[]): boolean {\n  return resolved.length > 0 && resolved.every((dependency) => !dependency.latest);\n}\n\n/** Collect every `@warlock.js/*` dependency across the relevant sections. */\nfunction collectWarlockDependencies(packageJson: PackageJson): WarlockDependency[] {\n  const dependencies: WarlockDependency[] = [];\n\n  for (const section of DEPENDENCY_SECTIONS) {\n    const map = packageJson[section];\n\n    if (!map) {\n      continue;\n    }\n\n    for (const [name, current] of Object.entries(map)) {\n      if (name.startsWith(WARLOCK_SCOPE)) {\n        dependencies.push({ name, section, current });\n      }\n    }\n  }\n\n  return dependencies;\n}\n\n/** Resolve each dependency's latest version from the registry in parallel. */\nasync function resolveLatestVersions(\n  dependencies: WarlockDependency[],\n): Promise<ResolvedDependency[]> {\n  return Promise.all(\n    dependencies.map(async (dependency) => ({\n      ...dependency,\n      latest: await fetchLatestVersion(dependency.name),\n    })),\n  );\n}\n\n/**\n * Turn resolved dependencies into the concrete set of version bumps to write.\n * Pure (no I/O) so it can be unit-tested directly: skips lookups that failed,\n * non-semver specs, and anything already at (or ahead of) the latest version,\n * and preserves the original range operator on everything it does rewrite.\n */\nexport function resolvePackageUpdates(resolved: ResolvedDependency[]): PackageUpdate[] {\n  const updates: PackageUpdate[] = [];\n\n  for (const dependency of resolved) {\n    if (!dependency.latest) {\n      continue;\n    }\n\n    const parsed = parseSpec(dependency.current);\n\n    if (!parsed) {\n      continue;\n    }\n\n    if (!isNewerVersion(dependency.latest, parsed.version)) {\n      continue;\n    }\n\n    updates.push({\n      name: dependency.name,\n      section: dependency.section,\n      from: dependency.current,\n      to: `${parsed.operator}${dependency.latest}`,\n    });\n  }\n\n  return updates;\n}\n\n/**\n * Split a dependency spec into its range operator and concrete version.\n * Returns `undefined` for specs we won't touch — `workspace:*`, `*`,\n * `latest`, multi-part ranges, or git/file URLs — leaving them exactly as\n * the author wrote them.\n */\nfunction parseSpec(spec: string): { operator: string; version: string } | undefined {\n  const match = spec.trim().match(/^(\\^|~)?(\\d+\\.\\d+\\.\\d+(?:-[0-9A-Za-z.-]+)?)$/);\n\n  if (!match) {\n    return undefined;\n  }\n\n  return { operator: match[1] ?? \"\", version: match[2] };\n}\n\n/** Write the resolved bumps back into the package.json object in place. */\nfunction applyUpdates(packageJson: PackageJson, updates: PackageUpdate[]): void {\n  for (const update of updates) {\n    const map = packageJson[update.section];\n\n    if (map) {\n      map[update.name] = update.to;\n    }\n  }\n}\n\n/** Print the version bumps — applied, or pending on a dry run. */\nfunction printUpdates(updates: PackageUpdate[], { pending = false } = {}): void {\n  const headline = pending\n    ? `${colors.yellow(\"↑\")} ${colors.bold(String(updates.length))} package(s) can be updated:`\n    : `${colors.green(\"✓\")} Updated ${colors.bold(String(updates.length))} package(s):`;\n\n  console.log(headline);\n\n  for (const update of updates) {\n    console.log(\n      `   ${colors.cyan(update.name)}  ` +\n        `${colors.dim(update.from)} ${colors.dim(\"→\")} ${colors.greenBright(update.to)}`,\n    );\n  }\n}\n\n/** Reconcile node_modules to the rewritten package.json via the project PM. */\nasync function installDependencies(): Promise<void> {\n  const packageManager = await detectPackageManager();\n  const installCommand = getInstallCommand(packageManager);\n\n  console.log(`${colors.cyan(\"›\")} Running ${colors.bold(installCommand)}…`);\n\n  execSync(installCommand, { cwd: process.cwd(), stdio: \"inherit\" });\n}\n"],"mappings":";;;;;;;;;;;AASA,MAAM,gBAAgB;;AAGtB,MAAM,sBAAsB,CAAC,gBAAgB,iBAAiB;;;;;;;;;;;;;;;AA0F9D,eAAsB,sBACpB,UAAwC,CAAC,GACH;CACtC,MAAM,aAAa,QAAQ,WAAW;CACtC,MAAM,kBAAkB,SAAS,cAAc;CAE/C,IAAI,CAAE,MAAM,gBAAgB,eAAe,GAAI;EAC7C,QAAQ,IAAI,GAAG,OAAO,IAAI,GAAG,EAAE,4CAA4C;EAC3E,OAAO;GAAE,SAAS;GAAmB,SAAS,CAAC;EAAE;CACnD;CAEA,MAAM,cAAe,MAAM,iBAAiB,eAAe;CAC3D,MAAM,eAAe,2BAA2B,WAAW;CAE3D,IAAI,aAAa,WAAW,GAAG;EAC7B,QAAQ,IAAI,GAAG,OAAO,OAAO,GAAG,EAAE,gDAAgD;EAClF,OAAO;GAAE,SAAS;GAAe,SAAS,CAAC;EAAE;CAC/C;CAEA,QAAQ,IACN,GAAG,OAAO,KAAK,GAAG,EAAE,YAAY,OAAO,KAAK,OAAO,aAAa,MAAM,CAAC,EAAE,qCAE3E;CAEA,MAAM,WAAW,MAAM,sBAAsB,YAAY;CAIzD,IAAI,sBAAsB,QAAQ,GAAG;EACnC,QAAQ,IACN,GAAG,OAAO,OAAO,GAAG,EAAE,mGAExB;EACA,OAAO;GAAE,SAAS;GAAwB,SAAS,CAAC;EAAE;CACxD;CAEA,MAAM,UAAU,sBAAsB,QAAQ;CAE9C,IAAI,QAAQ,WAAW,GAAG;EACxB,QAAQ,IAAI,GAAG,OAAO,MAAM,GAAG,EAAE,kDAAkD;EACnF,OAAO;GAAE,SAAS;GAAc,SAAS,CAAC;EAAE;CAC9C;CAEA,IAAI,QAAQ,QAAQ;EAClB,aAAa,SAAS,EAAE,SAAS,KAAK,CAAC;EACvC,OAAO;GAAE,SAAS;GAAY;EAAQ;CACxC;CAEA,aAAa,aAAa,OAAO;CACjC,MAAM,iBAAiB,iBAAiB,WAAW;CAEnD,aAAa,OAAO;CAEpB,IAAI,CAAC,YAAY;EACf,QAAQ,IACN,OAAO,IAAI,gFAAgF,CAC7F;EACA,OAAO;GAAE,SAAS;GAAW;EAAQ;CACvC;CAEA,IAAI;EACF,MAAM,oBAAoB;CAC5B,SAAS,OAAO;EACd,QAAQ,IACN,GAAG,OAAO,IAAI,GAAG,EAAE,sGAErB;EACA,OAAO;GAAE,SAAS;GAAkB;GAAgB;EAAe;CACrE;CAEA,OAAO;EAAE,SAAS;EAAW;CAAQ;AACvC;;;;;;AAOA,SAAgB,sBAAsB,UAAyC;CAC7E,OAAO,SAAS,SAAS,KAAK,SAAS,OAAO,eAAe,CAAC,WAAW,MAAM;AACjF;;AAGA,SAAS,2BAA2B,aAA+C;CACjF,MAAM,eAAoC,CAAC;CAE3C,KAAK,MAAM,WAAW,qBAAqB;EACzC,MAAM,MAAM,YAAY;EAExB,IAAI,CAAC,KACH;EAGF,KAAK,MAAM,CAAC,MAAM,YAAY,OAAO,QAAQ,GAAG,GAC9C,IAAI,KAAK,WAAW,aAAa,GAC/B,aAAa,KAAK;GAAE;GAAM;GAAS;EAAQ,CAAC;CAGlD;CAEA,OAAO;AACT;;AAGA,eAAe,sBACb,cAC+B;CAC/B,OAAO,QAAQ,IACb,aAAa,IAAI,OAAO,gBAAgB;EACtC,GAAG;EACH,QAAQ,MAAM,mBAAmB,WAAW,IAAI;CAClD,EAAE,CACJ;AACF;;;;;;;AAQA,SAAgB,sBAAsB,UAAiD;CACrF,MAAM,UAA2B,CAAC;CAElC,KAAK,MAAM,cAAc,UAAU;EACjC,IAAI,CAAC,WAAW,QACd;EAGF,MAAM,SAAS,UAAU,WAAW,OAAO;EAE3C,IAAI,CAAC,QACH;EAGF,IAAI,CAAC,eAAe,WAAW,QAAQ,OAAO,OAAO,GACnD;EAGF,QAAQ,KAAK;GACX,MAAM,WAAW;GACjB,SAAS,WAAW;GACpB,MAAM,WAAW;GACjB,IAAI,GAAG,OAAO,WAAW,WAAW;EACtC,CAAC;CACH;CAEA,OAAO;AACT;;;;;;;AAQA,SAAS,UAAU,MAAiE;CAClF,MAAM,QAAQ,KAAK,KAAK,EAAE,MAAM,8CAA8C;CAE9E,IAAI,CAAC,OACH;CAGF,OAAO;EAAE,UAAU,MAAM,MAAM;EAAI,SAAS,MAAM;CAAG;AACvD;;AAGA,SAAS,aAAa,aAA0B,SAAgC;CAC9E,KAAK,MAAM,UAAU,SAAS;EAC5B,MAAM,MAAM,YAAY,OAAO;EAE/B,IAAI,KACF,IAAI,OAAO,QAAQ,OAAO;CAE9B;AACF;;AAGA,SAAS,aAAa,SAA0B,EAAE,UAAU,UAAU,CAAC,GAAS;CAC9E,MAAM,WAAW,UACb,GAAG,OAAO,OAAO,GAAG,EAAE,GAAG,OAAO,KAAK,OAAO,QAAQ,MAAM,CAAC,EAAE,+BAC7D,GAAG,OAAO,MAAM,GAAG,EAAE,WAAW,OAAO,KAAK,OAAO,QAAQ,MAAM,CAAC,EAAE;CAExE,QAAQ,IAAI,QAAQ;CAEpB,KAAK,MAAM,UAAU,SACnB,QAAQ,IACN,MAAM,OAAO,KAAK,OAAO,IAAI,EAAE,IAC1B,OAAO,IAAI,OAAO,IAAI,EAAE,GAAG,OAAO,IAAI,GAAG,EAAE,GAAG,OAAO,YAAY,OAAO,EAAE,GACjF;AAEJ;;AAGA,eAAe,sBAAqC;CAElD,MAAM,iBAAiB,kBAAkB,MADZ,qBAAqB,CACK;CAEvD,QAAQ,IAAI,GAAG,OAAO,KAAK,GAAG,EAAE,WAAW,OAAO,KAAK,cAAc,EAAE,EAAE;CAEzE,SAAS,gBAAgB;EAAE,KAAK,QAAQ,IAAI;EAAG,OAAO;CAAU,CAAC;AACnE"}

package/esm/use-cases/types.d.mts

@@ -2,7 +2,7 @@ import { BenchmarkOptions } from "../benchmark/types.mjs";
 import { Infer, ObjectValidator } from "@warlock.js/seal";
 import { RetryOptions } from "@mongez/reinforcements";
 
-//#region core/src/use-cases/types.d.ts
+//#region ../core/src/use-cases/types.d.ts
 /**
  * Shared context object passed through the entire use case pipeline.
  * Contains the optional schema and can be enriched by guards/middleware

package/esm/use-cases/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["C:/Work/Warlock.js/core/src/use-cases/types.ts"],"mappings":"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"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../../core/src/use-cases/types.ts"],"mappings":"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"}

package/esm/use-cases/use-case-broadcast.d.mts

@@ -1,6 +1,6 @@
 import { UseCaseBroadcastOption, UseCaseConfigurations, UseCaseResult } from "./types.mjs";
 
-//#region core/src/use-cases/use-case-broadcast.d.ts
+//#region ../core/src/use-cases/use-case-broadcast.d.ts
 /**
  * Broadcast a successful use-case result through the globally-configured channels.
  *

package/esm/use-cases/use-case-broadcast.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"use-case-broadcast.d.mts","names":[],"sources":["C:/Work/Warlock.js/core/src/use-cases/use-case-broadcast.ts"],"mappings":";;;;;AAkBA;;;;;;;;iBAAsB,sBAAA,QAAA,CAA+B,MAAA;EACnD,IAAA;EACA,EAAA;EACA,MAAA,EAAQ,MAAA;EACR,MAAA,EAAQ,aAAA,CAAc,MAAA;EACtB,SAAA,GAAY,sBAAA,CAAuB,MAAA;EACnC,MAAA,GAAS,qBAAA;AAAA,IACP,OAAA"}
+{"version":3,"file":"use-case-broadcast.d.mts","names":[],"sources":["../../../../../../../core/src/use-cases/use-case-broadcast.ts"],"mappings":";;;;;AAkBA;;;;;;;;iBAAsB,sBAAA,QAAA,CAA+B,MAAA;EACnD,IAAA;EACA,EAAA;EACA,MAAA,EAAQ,MAAA;EACR,MAAA,EAAQ,aAAA,CAAc,MAAA;EACtB,SAAA,GAAY,sBAAA,CAAuB,MAAA;EACnC,MAAA,GAAS,qBAAA;AAAA,IACP,OAAA"}

package/esm/use-cases/use-case-broadcast.mjs

@@ -1,6 +1,6 @@
 import { log } from "@warlock.js/logger";
 
-//#region core/src/use-cases/use-case-broadcast.ts
+//#region ../core/src/use-cases/use-case-broadcast.ts
 /**
 * Broadcast a successful use-case result through the globally-configured channels.
 *

package/esm/use-cases/use-case-broadcast.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-case-broadcast.mjs","names":[],"sources":["C:/Work/Warlock.js/core/src/use-cases/use-case-broadcast.ts"],"sourcesContent":["import { log } from \"@warlock.js/logger\";\nimport type {\n  UseCaseBroadcastEvent,\n  UseCaseBroadcastOption,\n  UseCaseConfigurations,\n  UseCaseResult,\n} from \"./types\";\n\n/**\n * Broadcast a successful use-case result through the globally-configured channels.\n *\n * Fires only when the use case opted in (`broadcast`) and the global transport is\n * enabled with at least one channel. Fan-out is isolated via `Promise.allSettled` —\n * a failing channel is logged and never affects the use case or sibling channels.\n *\n * @example\n * await broadcastUseCaseResult({ name, id, output, result, broadcast, config });\n */\nexport async function broadcastUseCaseResult<Output>(params: {\n  name: string;\n  id: string;\n  output: Output;\n  result: UseCaseResult<Output>;\n  broadcast?: UseCaseBroadcastOption<Output>;\n  config?: UseCaseConfigurations[\"broadcast\"];\n}): Promise<void> {\n  const { name, id, output, result, broadcast, config } = params;\n\n  if (!broadcast) {\n    return;\n  }\n\n  if (config?.enabled === false) {\n    return;\n  }\n\n  const channels = config?.channels;\n\n  if (!channels || channels.length === 0) {\n    return;\n  }\n\n  const projector = typeof broadcast === \"object\" ? broadcast.output : undefined;\n  const event = typeof broadcast === \"object\" && broadcast.event ? broadcast.event : name;\n  const payload = projector ? projector(output, result) : output;\n\n  const broadcastEvent: UseCaseBroadcastEvent = {\n    useCase: name,\n    event,\n    id,\n    at: new Date(),\n    payload,\n  };\n\n  const outcomes = await Promise.allSettled(\n    channels.map((channel) => channel.broadcast(broadcastEvent)),\n  );\n\n  for (const outcome of outcomes) {\n    if (outcome.status === \"rejected\") {\n      log.error(\"use-cases\", name, \"broadcast channel failed\", { error: outcome.reason });\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAkBA,eAAsB,uBAA+B,QAOnC;CAChB,MAAM,EAAE,MAAM,IAAI,QAAQ,QAAQ,WAAW,WAAW;CAExD,IAAI,CAAC,WACH;CAGF,IAAI,QAAQ,YAAY,OACtB;CAGF,MAAM,WAAW,QAAQ;CAEzB,IAAI,CAAC,YAAY,SAAS,WAAW,GACnC;CAGF,MAAM,YAAY,OAAO,cAAc,WAAW,UAAU,SAAS;CACrE,MAAM,QAAQ,OAAO,cAAc,YAAY,UAAU,QAAQ,UAAU,QAAQ;CACnF,MAAM,UAAU,YAAY,UAAU,QAAQ,MAAM,IAAI;CAExD,MAAM,iBAAwC;EAC5C,SAAS;EACT;EACA;EACA,oBAAI,IAAI,KAAK;EACb;CACF;CAEA,MAAM,WAAW,MAAM,QAAQ,WAC7B,SAAS,KAAK,YAAY,QAAQ,UAAU,cAAc,CAAC,CAC7D;CAEA,KAAK,MAAM,WAAW,UACpB,IAAI,QAAQ,WAAW,YACrB,IAAI,MAAM,aAAa,MAAM,4BAA4B,EAAE,OAAO,QAAQ,OAAO,CAAC;AAGxF"}
+{"version":3,"file":"use-case-broadcast.mjs","names":[],"sources":["../../../../../../../core/src/use-cases/use-case-broadcast.ts"],"sourcesContent":["import { log } from \"@warlock.js/logger\";\nimport type {\n  UseCaseBroadcastEvent,\n  UseCaseBroadcastOption,\n  UseCaseConfigurations,\n  UseCaseResult,\n} from \"./types\";\n\n/**\n * Broadcast a successful use-case result through the globally-configured channels.\n *\n * Fires only when the use case opted in (`broadcast`) and the global transport is\n * enabled with at least one channel. Fan-out is isolated via `Promise.allSettled` —\n * a failing channel is logged and never affects the use case or sibling channels.\n *\n * @example\n * await broadcastUseCaseResult({ name, id, output, result, broadcast, config });\n */\nexport async function broadcastUseCaseResult<Output>(params: {\n  name: string;\n  id: string;\n  output: Output;\n  result: UseCaseResult<Output>;\n  broadcast?: UseCaseBroadcastOption<Output>;\n  config?: UseCaseConfigurations[\"broadcast\"];\n}): Promise<void> {\n  const { name, id, output, result, broadcast, config } = params;\n\n  if (!broadcast) {\n    return;\n  }\n\n  if (config?.enabled === false) {\n    return;\n  }\n\n  const channels = config?.channels;\n\n  if (!channels || channels.length === 0) {\n    return;\n  }\n\n  const projector = typeof broadcast === \"object\" ? broadcast.output : undefined;\n  const event = typeof broadcast === \"object\" && broadcast.event ? broadcast.event : name;\n  const payload = projector ? projector(output, result) : output;\n\n  const broadcastEvent: UseCaseBroadcastEvent = {\n    useCase: name,\n    event,\n    id,\n    at: new Date(),\n    payload,\n  };\n\n  const outcomes = await Promise.allSettled(\n    channels.map((channel) => channel.broadcast(broadcastEvent)),\n  );\n\n  for (const outcome of outcomes) {\n    if (outcome.status === \"rejected\") {\n      log.error(\"use-cases\", name, \"broadcast channel failed\", { error: outcome.reason });\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAkBA,eAAsB,uBAA+B,QAOnC;CAChB,MAAM,EAAE,MAAM,IAAI,QAAQ,QAAQ,WAAW,WAAW;CAExD,IAAI,CAAC,WACH;CAGF,IAAI,QAAQ,YAAY,OACtB;CAGF,MAAM,WAAW,QAAQ;CAEzB,IAAI,CAAC,YAAY,SAAS,WAAW,GACnC;CAGF,MAAM,YAAY,OAAO,cAAc,WAAW,UAAU,SAAS;CACrE,MAAM,QAAQ,OAAO,cAAc,YAAY,UAAU,QAAQ,UAAU,QAAQ;CACnF,MAAM,UAAU,YAAY,UAAU,QAAQ,MAAM,IAAI;CAExD,MAAM,iBAAwC;EAC5C,SAAS;EACT;EACA;EACA,oBAAI,IAAI,KAAK;EACb;CACF;CAEA,MAAM,WAAW,MAAM,QAAQ,WAC7B,SAAS,KAAK,YAAY,QAAQ,UAAU,cAAc,CAAC,CAC7D;CAEA,KAAK,MAAM,WAAW,UACpB,IAAI,QAAQ,WAAW,YACrB,IAAI,MAAM,aAAa,MAAM,4BAA4B,EAAE,OAAO,QAAQ,OAAO,CAAC;AAGxF"}

package/esm/use-cases/use-case-events.d.mts

@@ -1,6 +1,6 @@
 import { UseCaseErrorResult, UseCaseEventsCallbacksMap, UseCaseOnExecutingContext, UseCaseResult } from "./types.mjs";
 
-//#region core/src/use-cases/use-case-events.d.ts
+//#region ../core/src/use-cases/use-case-events.d.ts
 /**
  * Global event callbacks — shared across all use case instances.
  */

package/esm/use-cases/use-case-events.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"use-case-events.d.mts","names":[],"sources":["C:/Work/Warlock.js/core/src/use-cases/use-case-events.ts"],"mappings":";;;;;AAWA;cAAa,wBAAA,EAA0B,yBAItC;;;AAAA;AASD;;;;cAAa,oBAAA;yBACY,GAAA,EAAK,yBAAA;;;sBASV,QAAA,GAAa,MAAA,EAAQ,aAAA,CAAc,MAAA;;;qBASlC,GAAA,EAAK,kBAAA;;;;;;;;;;;iBAkBJ,kBAAA,UAAA,CACpB,GAAA,EAAK,QAAA,EACL,SAAA;EACE,UAAA,KAAe,GAAA,EAAK,QAAA,YAAoB,OAAA;EACxC,OAAA,KAAY,GAAA,EAAK,QAAA,YAAoB,OAAA;EACrC,MAAA,KAAW,GAAA,EAAK,QAAA,YAAoB,OAAA;AAAA,IACrC,OAAA"}
+{"version":3,"file":"use-case-events.d.mts","names":[],"sources":["../../../../../../../core/src/use-cases/use-case-events.ts"],"mappings":";;;;;AAWA;cAAa,wBAAA,EAA0B,yBAItC;;;AAAA;AASD;;;;cAAa,oBAAA;yBACY,GAAA,EAAK,yBAAA;;;sBASV,QAAA,GAAa,MAAA,EAAQ,aAAA,CAAc,MAAA;;;qBASlC,GAAA,EAAK,kBAAA;;;;;;;;;;;iBAkBJ,kBAAA,UAAA,CACpB,GAAA,EAAK,QAAA,EACL,SAAA;EACE,UAAA,KAAe,GAAA,EAAK,QAAA,YAAoB,OAAA;EACxC,OAAA,KAAY,GAAA,EAAK,QAAA,YAAoB,OAAA;EACrC,MAAA,KAAW,GAAA,EAAK,QAAA,YAAoB,OAAA;AAAA,IACrC,OAAA"}

package/esm/use-cases/use-case-events.mjs

@@ -1,6 +1,6 @@
 import { log } from "@warlock.js/logger";
 
-//#region core/src/use-cases/use-case-events.ts
+//#region ../core/src/use-cases/use-case-events.ts
 /**
 * Global event callbacks — shared across all use case instances.
 */

package/esm/use-cases/use-case-events.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-case-events.mjs","names":[],"sources":["C:/Work/Warlock.js/core/src/use-cases/use-case-events.ts"],"sourcesContent":["import { log } from \"@warlock.js/logger\";\r\nimport type {\r\n  UseCaseErrorResult,\r\n  UseCaseEventsCallbacksMap,\r\n  UseCaseOnExecutingContext,\r\n  UseCaseResult,\r\n} from \"./types\";\r\n\r\n/**\r\n * Global event callbacks — shared across all use case instances.\r\n */\r\nexport const globalEventsCallbacksMap: UseCaseEventsCallbacksMap = {\r\n  onExecuting: [],\r\n  onCompleted: [],\r\n  onError: [],\r\n};\r\n\r\n/**\r\n * Subscribe to lifecycle events fired by any use case.\r\n *\r\n * @example\r\n * globalUseCasesEvents.onCompleted((result) => metrics.track(result.name, result.benchmarkResult));\r\n * globalUseCasesEvents.onError((ctx) => logger.error(ctx.name, ctx.error));\r\n */\r\nexport const globalUseCasesEvents = {\r\n  onExecuting(callback: (ctx: UseCaseOnExecutingContext) => void) {\r\n    globalEventsCallbacksMap.onExecuting.push(callback);\r\n    return {\r\n      unsubscribe: () => {\r\n        const idx = globalEventsCallbacksMap.onExecuting.indexOf(callback);\r\n        if (idx !== -1) globalEventsCallbacksMap.onExecuting.splice(idx, 1);\r\n      },\r\n    };\r\n  },\r\n  onCompleted<Output>(callback: (result: UseCaseResult<Output>) => void) {\r\n    globalEventsCallbacksMap.onCompleted.push(callback);\r\n    return {\r\n      unsubscribe: () => {\r\n        const idx = globalEventsCallbacksMap.onCompleted.indexOf(callback);\r\n        if (idx !== -1) globalEventsCallbacksMap.onCompleted.splice(idx, 1);\r\n      },\r\n    };\r\n  },\r\n  onError(callback: (ctx: UseCaseErrorResult) => void) {\r\n    globalEventsCallbacksMap.onError.push(callback);\r\n    return {\r\n      unsubscribe: () => {\r\n        const idx = globalEventsCallbacksMap.onError.indexOf(callback);\r\n        if (idx !== -1) globalEventsCallbacksMap.onError.splice(idx, 1);\r\n      },\r\n    };\r\n  },\r\n};\r\n\r\n/**\r\n * Dispatches a lifecycle event to invocation → use-case → global observers, in that order.\r\n *\r\n * Each observer is awaited sequentially and isolated in its own try/catch — a slow\r\n * observer can't stall the others, and a throwing one can't break the pipeline (e.g.\r\n * a successful use case must not fail because a metrics/broadcast observer threw).\r\n */\r\nexport async function fireLifecycleEvent<EventCtx>(\r\n  ctx: EventCtx,\r\n  observers: {\r\n    invocation?: ((ctx: EventCtx) => void | Promise<void>)[];\r\n    useCase?: ((ctx: EventCtx) => void | Promise<void>)[];\r\n    global?: ((ctx: EventCtx) => void | Promise<void>)[];\r\n  },\r\n) {\r\n  const tiers = [observers.invocation, observers.useCase, observers.global];\r\n\r\n  for (const tier of tiers) {\r\n    if (!tier) {\r\n      continue;\r\n    }\r\n\r\n    for (const observer of tier) {\r\n      try {\r\n        await observer(ctx);\r\n      } catch (observerError) {\r\n        log.error(\"use-cases\", \"lifecycle\", \"observer failed\", { error: observerError });\r\n      }\r\n    }\r\n  }\r\n}\r\n"],"mappings":";;;;;;AAWA,MAAa,2BAAsD;CACjE,aAAa,CAAC;CACd,aAAa,CAAC;CACd,SAAS,CAAC;AACZ;;;;;;;;AASA,MAAa,uBAAuB;CAClC,YAAY,UAAoD;EAC9D,yBAAyB,YAAY,KAAK,QAAQ;EAClD,OAAO,EACL,mBAAmB;GACjB,MAAM,MAAM,yBAAyB,YAAY,QAAQ,QAAQ;GACjE,IAAI,QAAQ,IAAI,yBAAyB,YAAY,OAAO,KAAK,CAAC;EACpE,EACF;CACF;CACA,YAAoB,UAAmD;EACrE,yBAAyB,YAAY,KAAK,QAAQ;EAClD,OAAO,EACL,mBAAmB;GACjB,MAAM,MAAM,yBAAyB,YAAY,QAAQ,QAAQ;GACjE,IAAI,QAAQ,IAAI,yBAAyB,YAAY,OAAO,KAAK,CAAC;EACpE,EACF;CACF;CACA,QAAQ,UAA6C;EACnD,yBAAyB,QAAQ,KAAK,QAAQ;EAC9C,OAAO,EACL,mBAAmB;GACjB,MAAM,MAAM,yBAAyB,QAAQ,QAAQ,QAAQ;GAC7D,IAAI,QAAQ,IAAI,yBAAyB,QAAQ,OAAO,KAAK,CAAC;EAChE,EACF;CACF;AACF;;;;;;;;AASA,eAAsB,mBACpB,KACA,WAKA;CACA,MAAM,QAAQ;EAAC,UAAU;EAAY,UAAU;EAAS,UAAU;CAAM;CAExE,KAAK,MAAM,QAAQ,OAAO;EACxB,IAAI,CAAC,MACH;EAGF,KAAK,MAAM,YAAY,MACrB,IAAI;GACF,MAAM,SAAS,GAAG;EACpB,SAAS,eAAe;GACtB,IAAI,MAAM,aAAa,aAAa,mBAAmB,EAAE,OAAO,cAAc,CAAC;EACjF;CAEJ;AACF"}
+{"version":3,"file":"use-case-events.mjs","names":[],"sources":["../../../../../../../core/src/use-cases/use-case-events.ts"],"sourcesContent":["import { log } from \"@warlock.js/logger\";\r\nimport type {\r\n  UseCaseErrorResult,\r\n  UseCaseEventsCallbacksMap,\r\n  UseCaseOnExecutingContext,\r\n  UseCaseResult,\r\n} from \"./types\";\r\n\r\n/**\r\n * Global event callbacks — shared across all use case instances.\r\n */\r\nexport const globalEventsCallbacksMap: UseCaseEventsCallbacksMap = {\r\n  onExecuting: [],\r\n  onCompleted: [],\r\n  onError: [],\r\n};\r\n\r\n/**\r\n * Subscribe to lifecycle events fired by any use case.\r\n *\r\n * @example\r\n * globalUseCasesEvents.onCompleted((result) => metrics.track(result.name, result.benchmarkResult));\r\n * globalUseCasesEvents.onError((ctx) => logger.error(ctx.name, ctx.error));\r\n */\r\nexport const globalUseCasesEvents = {\r\n  onExecuting(callback: (ctx: UseCaseOnExecutingContext) => void) {\r\n    globalEventsCallbacksMap.onExecuting.push(callback);\r\n    return {\r\n      unsubscribe: () => {\r\n        const idx = globalEventsCallbacksMap.onExecuting.indexOf(callback);\r\n        if (idx !== -1) globalEventsCallbacksMap.onExecuting.splice(idx, 1);\r\n      },\r\n    };\r\n  },\r\n  onCompleted<Output>(callback: (result: UseCaseResult<Output>) => void) {\r\n    globalEventsCallbacksMap.onCompleted.push(callback);\r\n    return {\r\n      unsubscribe: () => {\r\n        const idx = globalEventsCallbacksMap.onCompleted.indexOf(callback);\r\n        if (idx !== -1) globalEventsCallbacksMap.onCompleted.splice(idx, 1);\r\n      },\r\n    };\r\n  },\r\n  onError(callback: (ctx: UseCaseErrorResult) => void) {\r\n    globalEventsCallbacksMap.onError.push(callback);\r\n    return {\r\n      unsubscribe: () => {\r\n        const idx = globalEventsCallbacksMap.onError.indexOf(callback);\r\n        if (idx !== -1) globalEventsCallbacksMap.onError.splice(idx, 1);\r\n      },\r\n    };\r\n  },\r\n};\r\n\r\n/**\r\n * Dispatches a lifecycle event to invocation → use-case → global observers, in that order.\r\n *\r\n * Each observer is awaited sequentially and isolated in its own try/catch — a slow\r\n * observer can't stall the others, and a throwing one can't break the pipeline (e.g.\r\n * a successful use case must not fail because a metrics/broadcast observer threw).\r\n */\r\nexport async function fireLifecycleEvent<EventCtx>(\r\n  ctx: EventCtx,\r\n  observers: {\r\n    invocation?: ((ctx: EventCtx) => void | Promise<void>)[];\r\n    useCase?: ((ctx: EventCtx) => void | Promise<void>)[];\r\n    global?: ((ctx: EventCtx) => void | Promise<void>)[];\r\n  },\r\n) {\r\n  const tiers = [observers.invocation, observers.useCase, observers.global];\r\n\r\n  for (const tier of tiers) {\r\n    if (!tier) {\r\n      continue;\r\n    }\r\n\r\n    for (const observer of tier) {\r\n      try {\r\n        await observer(ctx);\r\n      } catch (observerError) {\r\n        log.error(\"use-cases\", \"lifecycle\", \"observer failed\", { error: observerError });\r\n      }\r\n    }\r\n  }\r\n}\r\n"],"mappings":";;;;;;AAWA,MAAa,2BAAsD;CACjE,aAAa,CAAC;CACd,aAAa,CAAC;CACd,SAAS,CAAC;AACZ;;;;;;;;AASA,MAAa,uBAAuB;CAClC,YAAY,UAAoD;EAC9D,yBAAyB,YAAY,KAAK,QAAQ;EAClD,OAAO,EACL,mBAAmB;GACjB,MAAM,MAAM,yBAAyB,YAAY,QAAQ,QAAQ;GACjE,IAAI,QAAQ,IAAI,yBAAyB,YAAY,OAAO,KAAK,CAAC;EACpE,EACF;CACF;CACA,YAAoB,UAAmD;EACrE,yBAAyB,YAAY,KAAK,QAAQ;EAClD,OAAO,EACL,mBAAmB;GACjB,MAAM,MAAM,yBAAyB,YAAY,QAAQ,QAAQ;GACjE,IAAI,QAAQ,IAAI,yBAAyB,YAAY,OAAO,KAAK,CAAC;EACpE,EACF;CACF;CACA,QAAQ,UAA6C;EACnD,yBAAyB,QAAQ,KAAK,QAAQ;EAC9C,OAAO,EACL,mBAAmB;GACjB,MAAM,MAAM,yBAAyB,QAAQ,QAAQ,QAAQ;GAC7D,IAAI,QAAQ,IAAI,yBAAyB,QAAQ,OAAO,KAAK,CAAC;EAChE,EACF;CACF;AACF;;;;;;;;AASA,eAAsB,mBACpB,KACA,WAKA;CACA,MAAM,QAAQ;EAAC,UAAU;EAAY,UAAU;EAAS,UAAU;CAAM;CAExE,KAAK,MAAM,QAAQ,OAAO;EACxB,IAAI,CAAC,MACH;EAGF,KAAK,MAAM,YAAY,MACrB,IAAI;GACF,MAAM,SAAS,GAAG;EACpB,SAAS,eAAe;GACtB,IAAI,MAAM,aAAa,aAAa,mBAAmB,EAAE,OAAO,cAAc,CAAC;EACjF;CAEJ;AACF"}

package/esm/use-cases/use-case-pipeline.d.mts

@@ -1,7 +1,7 @@
 import { UseCaseBeforeMiddleware, UseCaseContext, UseCaseGuard, UseCaseOnExecutingContext } from "./types.mjs";
 import { ObjectValidator } from "@warlock.js/seal";
 
-//#region core/src/use-cases/use-case-pipeline.d.ts
+//#region ../core/src/use-cases/use-case-pipeline.d.ts
 type PipelineOptions<Input> = {
   name: string;
   id: string;

package/esm/use-cases/use-case-pipeline.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"use-case-pipeline.d.mts","names":[],"sources":["C:/Work/Warlock.js/core/src/use-cases/use-case-pipeline.ts"],"mappings":";;;;KAWY,eAAA;EACV,IAAA;EACA,EAAA;EACA,IAAA,EAAM,KAAA;EACN,GAAA,EAAK,cAAA;EACL,SAAA,EAAW,IAAA;EACX,MAAA,GAAS,eAAA;EACT,MAAA,GAAS,YAAA,CAAa,KAAA;EACtB,MAAA,GAAS,uBAAA,CAAwB,KAAA,KADX;EAGtB,WAAA,IAAe,GAAA,EAAK,yBAAA,WAFa;EAIjC,aAAA,IAAiB,GAAA,EAAK,yBAAA;AAAA;;;;;;;;;;;;;;iBAgBF,WAAA,OAAA,CAAmB,IAAA,EAAM,eAAA,CAAgB,KAAA,IAAS,OAAA,CAAQ,KAAA"}
+{"version":3,"file":"use-case-pipeline.d.mts","names":[],"sources":["../../../../../../../core/src/use-cases/use-case-pipeline.ts"],"mappings":";;;;KAWY,eAAA;EACV,IAAA;EACA,EAAA;EACA,IAAA,EAAM,KAAA;EACN,GAAA,EAAK,cAAA;EACL,SAAA,EAAW,IAAA;EACX,MAAA,GAAS,eAAA;EACT,MAAA,GAAS,YAAA,CAAa,KAAA;EACtB,MAAA,GAAS,uBAAA,CAAwB,KAAA,KADX;EAGtB,WAAA,IAAe,GAAA,EAAK,yBAAA,WAFa;EAIjC,aAAA,IAAiB,GAAA,EAAK,yBAAA;AAAA;;;;;;;;;;;;;;iBAgBF,WAAA,OAAA,CAAmB,IAAA,EAAM,eAAA,CAAgB,KAAA,IAAS,OAAA,CAAQ,KAAA"}

package/esm/use-cases/use-case-pipeline.mjs

@@ -2,7 +2,7 @@ import { fireLifecycleEvent, globalEventsCallbacksMap } from "./use-case-events.
 import { BadSchemaUseCaseError } from "./use-case.errors.mjs";
 import { v } from "@warlock.js/seal";
 
-//#region core/src/use-cases/use-case-pipeline.ts
+//#region ../core/src/use-cases/use-case-pipeline.ts
 /**
 * Runs the pre-handler pipeline in order:
 * onExecuting event → guards → validation → before middleware.

package/esm/use-cases/use-case-pipeline.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-case-pipeline.mjs","names":[],"sources":["C:/Work/Warlock.js/core/src/use-cases/use-case-pipeline.ts"],"sourcesContent":["import type { ObjectValidator } from \"@warlock.js/seal\";\nimport { v } from \"@warlock.js/seal\";\nimport type {\n  UseCaseBeforeMiddleware,\n  UseCaseContext,\n  UseCaseGuard,\n  UseCaseOnExecutingContext,\n} from \"./types\";\nimport { fireLifecycleEvent, globalEventsCallbacksMap } from \"./use-case-events\";\nimport { BadSchemaUseCaseError } from \"./use-case.errors\";\n\nexport type PipelineOptions<Input> = {\n  name: string;\n  id: string;\n  data: Input;\n  ctx: UseCaseContext;\n  startedAt: Date;\n  schema?: ObjectValidator;\n  guards?: UseCaseGuard<Input>[];\n  before?: UseCaseBeforeMiddleware<Input>[];\n  /** Invocation-level onExecuting override */\n  onExecuting?: (ctx: UseCaseOnExecutingContext) => void;\n  /** Use-case-level onExecuting */\n  ucOnExecuting?: (ctx: UseCaseOnExecutingContext) => void;\n};\n\n/**\n * Runs the pre-handler pipeline in order:\n * onExecuting event → guards → validation → before middleware.\n *\n * Returns the validated, transformed data ready for the handler. The handler is\n * invoked by the caller so retry/benchmark can wrap it in isolation — keeping\n * guards, validation, and onExecuting from re-running on each retry attempt.\n *\n * Throws on guard failure or validation failure.\n *\n * @example\n * const data = await runPipeline({ name, id, data, ctx, startedAt, schema, guards, before });\n */\nexport async function runPipeline<Input>(opts: PipelineOptions<Input>): Promise<Input> {\n  const { name, id, ctx, startedAt, schema, guards, before, onExecuting, ucOnExecuting } = opts;\n  let data = opts.data;\n\n  await fireLifecycleEvent<UseCaseOnExecutingContext>(\n    { name, id, data, schema, ctx, startedAt },\n    {\n      invocation: onExecuting ? [onExecuting] : undefined,\n      useCase: ucOnExecuting ? [ucOnExecuting] : undefined,\n      global: globalEventsCallbacksMap.onExecuting.length\n        ? globalEventsCallbacksMap.onExecuting\n        : undefined,\n    },\n  );\n\n  if (guards) {\n    // Guards get a frozen SHALLOW CLONE so a guard can't mutate the input, while\n    // the original `data` (and the reference that reaches before-middleware and the\n    // handler) stays writable. Freezing `data` in place would leak the frozen ref\n    // downstream and make a handler mutating its input throw under strict mode.\n    // The guard contract is read-only by design; the clone is shallow (deep-freeze\n    // is optional and intentionally not done here).\n    const frozenData = Object.freeze(\n      Array.isArray(data) ? [...data] : { ...(data as object) },\n    ) as Readonly<Input>;\n\n    for (const guard of guards) {\n      await guard(frozenData, ctx);\n    }\n  }\n\n  if (schema) {\n    const result = await v.validate(schema, data);\n\n    if (!result.isValid) {\n      throw new BadSchemaUseCaseError(result);\n    }\n\n    data = result.data;\n  }\n\n  let transformed = data;\n\n  if (before) {\n    for (const middleware of before) {\n      transformed = await middleware(transformed, ctx);\n    }\n  }\n\n  return transformed;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAuCA,eAAsB,YAAmB,MAA8C;CACrF,MAAM,EAAE,MAAM,IAAI,KAAK,WAAW,QAAQ,QAAQ,QAAQ,aAAa,kBAAkB;CACzF,IAAI,OAAO,KAAK;CAEhB,MAAM,mBACJ;EAAE;EAAM;EAAI;EAAM;EAAQ;EAAK;CAAU,GACzC;EACE,YAAY,cAAc,CAAC,WAAW,IAAI;EAC1C,SAAS,gBAAgB,CAAC,aAAa,IAAI;EAC3C,QAAQ,yBAAyB,YAAY,SACzC,yBAAyB,cACzB;CACN,CACF;CAEA,IAAI,QAAQ;EAOV,MAAM,aAAa,OAAO,OACxB,MAAM,QAAQ,IAAI,IAAI,CAAC,GAAG,IAAI,IAAI,EAAE,GAAI,KAAgB,CAC1D;EAEA,KAAK,MAAM,SAAS,QAClB,MAAM,MAAM,YAAY,GAAG;CAE/B;CAEA,IAAI,QAAQ;EACV,MAAM,SAAS,MAAM,EAAE,SAAS,QAAQ,IAAI;EAE5C,IAAI,CAAC,OAAO,SACV,MAAM,IAAI,sBAAsB,MAAM;EAGxC,OAAO,OAAO;CAChB;CAEA,IAAI,cAAc;CAElB,IAAI,QACF,KAAK,MAAM,cAAc,QACvB,cAAc,MAAM,WAAW,aAAa,GAAG;CAInD,OAAO;AACT"}
+{"version":3,"file":"use-case-pipeline.mjs","names":[],"sources":["../../../../../../../core/src/use-cases/use-case-pipeline.ts"],"sourcesContent":["import type { ObjectValidator } from \"@warlock.js/seal\";\nimport { v } from \"@warlock.js/seal\";\nimport type {\n  UseCaseBeforeMiddleware,\n  UseCaseContext,\n  UseCaseGuard,\n  UseCaseOnExecutingContext,\n} from \"./types\";\nimport { fireLifecycleEvent, globalEventsCallbacksMap } from \"./use-case-events\";\nimport { BadSchemaUseCaseError } from \"./use-case.errors\";\n\nexport type PipelineOptions<Input> = {\n  name: string;\n  id: string;\n  data: Input;\n  ctx: UseCaseContext;\n  startedAt: Date;\n  schema?: ObjectValidator;\n  guards?: UseCaseGuard<Input>[];\n  before?: UseCaseBeforeMiddleware<Input>[];\n  /** Invocation-level onExecuting override */\n  onExecuting?: (ctx: UseCaseOnExecutingContext) => void;\n  /** Use-case-level onExecuting */\n  ucOnExecuting?: (ctx: UseCaseOnExecutingContext) => void;\n};\n\n/**\n * Runs the pre-handler pipeline in order:\n * onExecuting event → guards → validation → before middleware.\n *\n * Returns the validated, transformed data ready for the handler. The handler is\n * invoked by the caller so retry/benchmark can wrap it in isolation — keeping\n * guards, validation, and onExecuting from re-running on each retry attempt.\n *\n * Throws on guard failure or validation failure.\n *\n * @example\n * const data = await runPipeline({ name, id, data, ctx, startedAt, schema, guards, before });\n */\nexport async function runPipeline<Input>(opts: PipelineOptions<Input>): Promise<Input> {\n  const { name, id, ctx, startedAt, schema, guards, before, onExecuting, ucOnExecuting } = opts;\n  let data = opts.data;\n\n  await fireLifecycleEvent<UseCaseOnExecutingContext>(\n    { name, id, data, schema, ctx, startedAt },\n    {\n      invocation: onExecuting ? [onExecuting] : undefined,\n      useCase: ucOnExecuting ? [ucOnExecuting] : undefined,\n      global: globalEventsCallbacksMap.onExecuting.length\n        ? globalEventsCallbacksMap.onExecuting\n        : undefined,\n    },\n  );\n\n  if (guards) {\n    // Guards get a frozen SHALLOW CLONE so a guard can't mutate the input, while\n    // the original `data` (and the reference that reaches before-middleware and the\n    // handler) stays writable. Freezing `data` in place would leak the frozen ref\n    // downstream and make a handler mutating its input throw under strict mode.\n    // The guard contract is read-only by design; the clone is shallow (deep-freeze\n    // is optional and intentionally not done here).\n    const frozenData = Object.freeze(\n      Array.isArray(data) ? [...data] : { ...(data as object) },\n    ) as Readonly<Input>;\n\n    for (const guard of guards) {\n      await guard(frozenData, ctx);\n    }\n  }\n\n  if (schema) {\n    const result = await v.validate(schema, data);\n\n    if (!result.isValid) {\n      throw new BadSchemaUseCaseError(result);\n    }\n\n    data = result.data;\n  }\n\n  let transformed = data;\n\n  if (before) {\n    for (const middleware of before) {\n      transformed = await middleware(transformed, ctx);\n    }\n  }\n\n  return transformed;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAuCA,eAAsB,YAAmB,MAA8C;CACrF,MAAM,EAAE,MAAM,IAAI,KAAK,WAAW,QAAQ,QAAQ,QAAQ,aAAa,kBAAkB;CACzF,IAAI,OAAO,KAAK;CAEhB,MAAM,mBACJ;EAAE;EAAM;EAAI;EAAM;EAAQ;EAAK;CAAU,GACzC;EACE,YAAY,cAAc,CAAC,WAAW,IAAI;EAC1C,SAAS,gBAAgB,CAAC,aAAa,IAAI;EAC3C,QAAQ,yBAAyB,YAAY,SACzC,yBAAyB,cACzB;CACN,CACF;CAEA,IAAI,QAAQ;EAOV,MAAM,aAAa,OAAO,OACxB,MAAM,QAAQ,IAAI,IAAI,CAAC,GAAG,IAAI,IAAI,EAAE,GAAI,KAAgB,CAC1D;EAEA,KAAK,MAAM,SAAS,QAClB,MAAM,MAAM,YAAY,GAAG;CAE/B;CAEA,IAAI,QAAQ;EACV,MAAM,SAAS,MAAM,EAAE,SAAS,QAAQ,IAAI;EAE5C,IAAI,CAAC,OAAO,SACV,MAAM,IAAI,sBAAsB,MAAM;EAGxC,OAAO,OAAO;CAChB;CAEA,IAAI,cAAc;CAElB,IAAI,QACF,KAAK,MAAM,cAAc,QACvB,cAAc,MAAM,WAAW,aAAa,GAAG;CAInD,OAAO;AACT"}

package/esm/use-cases/use-case.d.mts

@@ -1,7 +1,7 @@
 import { UseCase, UseCaseContext, UseCaseHandler, UseCaseWithSchema } from "./types.mjs";
 import { Infer, ObjectValidator } from "@warlock.js/seal";
 
-//#region core/src/use-cases/use-case.d.ts
+//#region ../core/src/use-cases/use-case.d.ts
 /**
  * Defines and registers a use case.
  *

package/esm/use-cases/use-case.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"use-case.d.mts","names":[],"sources":["C:/Work/Warlock.js/core/src/use-cases/use-case.ts"],"mappings":";;;;;;AAwDA;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,OAAA,wBAEC,eAAA,cACH,cAAA,GAAiB,cAAA,CAAA,CAC7B,OAAA,EAAS,iBAAA,CAAkB,MAAA,EAAQ,MAAA,EAAQ,GAAA,IAAO,cAAA,CAAe,MAAA,EAAQ,KAAA,CAAM,MAAA;AAAA,iBACjE,OAAA,wCAA+C,cAAA,GAAiB,cAAA,CAAA,CAC9E,OAAA,EAAS,OAAA,CAAQ,MAAA,EAAQ,KAAA,EAAO,GAAA,IAC/B,cAAA,CAAe,MAAA,EAAQ,KAAA"}
+{"version":3,"file":"use-case.d.mts","names":[],"sources":["../../../../../../../core/src/use-cases/use-case.ts"],"mappings":";;;;;;AAwDA;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,OAAA,wBAEC,eAAA,cACH,cAAA,GAAiB,cAAA,CAAA,CAC7B,OAAA,EAAS,iBAAA,CAAkB,MAAA,EAAQ,MAAA,EAAQ,GAAA,IAAO,cAAA,CAAe,MAAA,EAAQ,KAAA,CAAM,MAAA;AAAA,iBACjE,OAAA,wCAA+C,cAAA,GAAiB,cAAA,CAAA,CAC9E,OAAA,EAAS,OAAA,CAAQ,MAAA,EAAQ,KAAA,EAAO,GAAA,IAC/B,cAAA,CAAe,MAAA,EAAQ,KAAA"}

package/esm/use-cases/use-case.errors.d.mts

@@ -1,7 +1,7 @@
 import { HttpError } from "../http/errors/errors.mjs";
 import { ValidationResult } from "@warlock.js/seal";
 
-//#region core/src/use-cases/use-case.errors.d.ts
+//#region ../core/src/use-cases/use-case.errors.d.ts
 declare class BadSchemaUseCaseError extends HttpError {
   constructor(result: ValidationResult);
 }

package/esm/use-cases/use-case.errors.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"use-case.errors.d.mts","names":[],"sources":["C:/Work/Warlock.js/core/src/use-cases/use-case.errors.ts"],"mappings":";;;;cAGa,qBAAA,SAA8B,SAAS;cAC/B,MAAA,EAAQ,gBAAA;AAAA"}
+{"version":3,"file":"use-case.errors.d.mts","names":[],"sources":["../../../../../../../core/src/use-cases/use-case.errors.ts"],"mappings":";;;;cAGa,qBAAA,SAA8B,SAAS;cAC/B,MAAA,EAAQ,gBAAA;AAAA"}

package/esm/use-cases/use-case.errors.mjs

@@ -1,6 +1,6 @@
 import { HttpError } from "../http/errors/errors.mjs";
 
-//#region core/src/use-cases/use-case.errors.ts
+//#region ../core/src/use-cases/use-case.errors.ts
 var BadSchemaUseCaseError = class extends HttpError {
 	constructor(result) {
 		super(400, `Invalid input data`, {

package/esm/use-cases/use-case.errors.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-case.errors.mjs","names":[],"sources":["C:/Work/Warlock.js/core/src/use-cases/use-case.errors.ts"],"sourcesContent":["import type { ValidationResult } from \"@warlock.js/seal\";\nimport { HttpError } from \"../http/errors/errors\";\n\nexport class BadSchemaUseCaseError extends HttpError {\n  public constructor(result: ValidationResult) {\n    super(400, `Invalid input data`, {\n      code: \"BAD_SCHEMA_USE_CASE\",\n      errors: result.errors,\n    });\n  }\n}\n"],"mappings":";;;AAGA,IAAa,wBAAb,cAA2C,UAAU;CACnD,AAAO,YAAY,QAA0B;EAC3C,MAAM,KAAK,sBAAsB;GAC/B,MAAM;GACN,QAAQ,OAAO;EACjB,CAAC;CACH;AACF"}
+{"version":3,"file":"use-case.errors.mjs","names":[],"sources":["../../../../../../../core/src/use-cases/use-case.errors.ts"],"sourcesContent":["import type { ValidationResult } from \"@warlock.js/seal\";\nimport { HttpError } from \"../http/errors/errors\";\n\nexport class BadSchemaUseCaseError extends HttpError {\n  public constructor(result: ValidationResult) {\n    super(400, `Invalid input data`, {\n      code: \"BAD_SCHEMA_USE_CASE\",\n      errors: result.errors,\n    });\n  }\n}\n"],"mappings":";;;AAGA,IAAa,wBAAb,cAA2C,UAAU;CACnD,AAAO,YAAY,QAA0B;EAC3C,MAAM,KAAK,sBAAsB;GAC/B,MAAM;GACN,QAAQ,OAAO;EACjB,CAAC;CACH;AACF"}

package/esm/use-cases/use-case.mjs

@@ -9,7 +9,7 @@ import { $registerUseCase, $unregisterUseCase, addUseCaseHistory, increaseUseCas
 import { log } from "@warlock.js/logger";
 import { Random, except, retry } from "@mongez/reinforcements";
 
-//#region core/src/use-cases/use-case.ts
+//#region ../core/src/use-cases/use-case.ts
 const defaultUseCaseOptions = { benchmark: true };
 function useCase(options) {
 	const { name, handler, schema, guards, before, after, onExecuting, onCompleted, onError } = options;

package/esm/use-cases/use-case.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-case.mjs","names":["runWithRetry"],"sources":["C:/Work/Warlock.js/core/src/use-cases/use-case.ts"],"sourcesContent":["import { except, Random, retry as runWithRetry } from \"@mongez/reinforcements\";\nimport { log } from \"@warlock.js/logger\";\nimport type { Infer, ObjectValidator } from \"@warlock.js/seal\";\nimport { measure } from \"../benchmark\";\nimport { config } from \"../config\";\nimport type {\n  UseCase,\n  UseCaseConfigurations,\n  UseCaseContext,\n  UseCaseErrorResult,\n  UseCaseHandler,\n  UseCaseResult,\n  UseCaseRuntimeOptions,\n  UseCaseWithSchema,\n} from \"./types\";\nimport { broadcastUseCaseResult } from \"./use-case-broadcast\";\nimport { fireLifecycleEvent, globalEventsCallbacksMap } from \"./use-case-events\";\nimport { runPipeline } from \"./use-case-pipeline\";\nimport {\n  $registerUseCase,\n  $unregisterUseCase,\n  addUseCaseHistory,\n  increaseUseCaseFailedCalls,\n  increaseUseCaseSuccessCalls,\n} from \"./use-cases-registry\";\n\nconst defaultUseCaseOptions: UseCaseConfigurations = {\n  benchmark: true,\n};\n\n/**\n * Defines and registers a use case.\n *\n * A use case is a named, observable, optionally benchmarked unit of business logic.\n * The returned handler is a typed async function you call with the input data.\n *\n * Execution order: onExecuting → guards → validation → before → handler → after →\n * onCompleted → broadcast. Retry and benchmark wrap the **handler** only.\n *\n * When a `schema` is provided, the handler's input is inferred from it — no manual\n * `Input` generic needed.\n *\n * @example\n * export const createOrderUseCase = useCase({\n *   name: \"create_order\",\n *   schema: createOrderSchema,           // handler `data` is inferred from this\n *   guards: [authGuard],\n *   handler: async (data, ctx) => orderService.create(data),\n *   after: [sendConfirmationEmail],\n *   retry: { attempts: 3, delay: 500, backoff: \"exponential\" },\n *   broadcast: true,\n * });\n *\n * // In a controller:\n * const output = await createOrderUseCase({ ...validated, user_id: req.user.id });\n */\nexport function useCase<\n  Output,\n  Schema extends ObjectValidator,\n  Ctx extends UseCaseContext = UseCaseContext,\n>(options: UseCaseWithSchema<Output, Schema, Ctx>): UseCaseHandler<Output, Infer<Schema>>;\nexport function useCase<Output = any, Input = any, Ctx extends UseCaseContext = UseCaseContext>(\n  options: UseCase<Output, Input, Ctx>,\n): UseCaseHandler<Output, Input>;\nexport function useCase<Output = any, Input = any>(\n  options: UseCase<Output, Input>,\n): UseCaseHandler<Output, Input> {\n  const { name, handler, schema, guards, before, after, onExecuting, onCompleted, onError } =\n    options;\n\n  // Merge per-use-case options with global config defaults\n  const useCaseConfig = config.get<UseCaseConfigurations>(\"use-cases\", defaultUseCaseOptions);\n  const benchmark = options.benchmark ?? useCaseConfig?.benchmark ?? true;\n  const retryConfig = options.retry ?? useCaseConfig?.retry;\n  const broadcast = options.broadcast;\n  const broadcastConfig = useCaseConfig?.broadcast;\n  const logEnabled = useCaseConfig?.log === true;\n\n  $registerUseCase(name, {\n    ...options,\n    calls: { success: 0, failed: 0, total: 0 },\n  });\n\n  const useCaseHandler = async (\n    data: Input,\n    {\n      ctx = {},\n      id = `uc-${name}-` + Random.string(),\n      onExecuting: invocationOnExecuting,\n      onCompleted: invocationOnCompleted,\n      onError: invocationOnError,\n    }: UseCaseRuntimeOptions = {},\n  ): Promise<Output> => {\n    ctx.schema = schema;\n    ctx.id = id;\n\n    const startedAt = new Date();\n    let output: Output | undefined;\n    let error: Error | undefined;\n    let benchmarkResult: { latency: number; state: \"excellent\" | \"good\" | \"poor\" } | undefined;\n    // 1-based count of failed attempts (reinforcements' `attempt` arg). Translated\n    // into \"retries performed\" at snapshot time — see the `currentRetry` derivation.\n    let failedAttempts = 0;\n\n    if (logEnabled) {\n      log.debug(\"use-cases\", name, \"executing\", { id });\n    }\n\n    try {\n      const transformed = await runPipeline<Input>({\n        name,\n        id,\n        data,\n        ctx,\n        startedAt,\n        schema,\n        guards,\n        before,\n        onExecuting: invocationOnExecuting,\n        ucOnExecuting: onExecuting,\n      });\n\n      // Benchmark wraps ONLY the handler (per attempt) so latency reflects business\n      // logic — not the guard/validation prelude, and not the retry backoff delays.\n      const runHandler = async (): Promise<Output> => {\n        if (!benchmark) {\n          return handler(transformed, ctx);\n        }\n\n        const measured = await measure(\n          name,\n          () => handler(transformed, ctx),\n          benchmark === true ? undefined : benchmark,\n        );\n\n        benchmarkResult = { latency: measured.latency, state: measured.state };\n\n        // measure() never throws — it returns an error result. Re-throw so retry\n        // and the outer catch handle failures uniformly.\n        if (!measured.success) {\n          throw measured.error;\n        }\n\n        return measured.value;\n      };\n\n      output = retryConfig\n        ? await runWithRetry(runHandler, {\n            ...retryConfig,\n            onError: (retryError, attempt) => {\n              failedAttempts = attempt;\n              retryConfig.onError?.(retryError, attempt);\n            },\n          })\n        : await runHandler();\n    } catch (err) {\n      error = err as Error;\n    }\n\n    const endedAt = new Date();\n\n    // After middleware — fire-and-forget side effects, only on success.\n    // Keyed off the error flag alone so void handlers (which return undefined)\n    // still run their after middleware.\n    if (!error && after) {\n      for (const middleware of after) {\n        try {\n          // On the success path `output` holds the handler's return value; for a\n          // void handler that's undefined, which the middleware receives as-is.\n          await middleware(output as Output, ctx);\n        } catch (afterError) {\n          log.error(\"use-cases\", name, \"after middleware failed\", { error: afterError });\n        }\n      }\n    }\n\n    // Retries actually performed (0 = succeeded on the first try). On success every\n    // failed attempt was followed by a retry; on failure the final failed attempt\n    // was NOT retried, so it doesn't count as a retry performed.\n    const currentRetry = error ? Math.max(failedAttempts - 1, 0) : failedAttempts;\n\n    const snapshot: UseCaseResult<Output> = {\n      output,\n      ctx,\n      startedAt,\n      endedAt,\n      id,\n      name,\n      retries: retryConfig\n        ? { attempts: retryConfig.attempts ?? 3, delay: retryConfig.delay, currentRetry }\n        : undefined,\n      benchmarkResult,\n      // Set per-branch below so the counter reflects the actual outcome —\n      // a failure must never increment the success tally.\n      calls: 0,\n    };\n\n    if (error) {\n      snapshot.calls = increaseUseCaseFailedCalls(name);\n\n      if (logEnabled) {\n        log.error(\"use-cases\", name, \"failed\", { id, error });\n      }\n\n      await fireLifecycleEvent<UseCaseErrorResult>(\n        { ...except(snapshot, [\"output\"]), error },\n        {\n          invocation: invocationOnError ? [invocationOnError] : undefined,\n          useCase: onError ? [onError] : undefined,\n          global: globalEventsCallbacksMap.onError.length\n            ? globalEventsCallbacksMap.onError\n            : undefined,\n        },\n      );\n\n      throw error;\n    }\n\n    snapshot.calls = increaseUseCaseSuccessCalls(name);\n\n    if (logEnabled) {\n      log.debug(\"use-cases\", name, \"completed\", { id, latency: benchmarkResult?.latency });\n    }\n\n    // History is best-effort — a cache rejection must not turn a successful run\n    // into a thrown error or skip onCompleted/broadcast.\n    try {\n      await addUseCaseHistory(name, snapshot);\n    } catch (historyError) {\n      log.error(\"use-cases\", name, \"history persistence failed\", { id, error: historyError });\n    }\n\n    await fireLifecycleEvent<UseCaseResult<Output>>(snapshot, {\n      invocation: invocationOnCompleted ? [invocationOnCompleted] : undefined,\n      useCase: onCompleted ? [onCompleted] : undefined,\n      global: globalEventsCallbacksMap.onCompleted.length\n        ? globalEventsCallbacksMap.onCompleted\n        : undefined,\n    });\n\n    await broadcastUseCaseResult({\n      name,\n      id,\n      // A void handler resolves to undefined — broadcast it as-is rather than\n      // asserting a non-null value that would fabricate a bogus payload.\n      output: output as Output,\n      result: snapshot,\n      broadcast,\n      config: broadcastConfig,\n    });\n\n    return output as Output;\n  };\n\n  useCaseHandler.$cleanup = () => {\n    $unregisterUseCase(name);\n  };\n\n  return useCaseHandler;\n}\n"],"mappings":"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"}
+{"version":3,"file":"use-case.mjs","names":["runWithRetry"],"sources":["../../../../../../../core/src/use-cases/use-case.ts"],"sourcesContent":["import { except, Random, retry as runWithRetry } from \"@mongez/reinforcements\";\nimport { log } from \"@warlock.js/logger\";\nimport type { Infer, ObjectValidator } from \"@warlock.js/seal\";\nimport { measure } from \"../benchmark\";\nimport { config } from \"../config\";\nimport type {\n  UseCase,\n  UseCaseConfigurations,\n  UseCaseContext,\n  UseCaseErrorResult,\n  UseCaseHandler,\n  UseCaseResult,\n  UseCaseRuntimeOptions,\n  UseCaseWithSchema,\n} from \"./types\";\nimport { broadcastUseCaseResult } from \"./use-case-broadcast\";\nimport { fireLifecycleEvent, globalEventsCallbacksMap } from \"./use-case-events\";\nimport { runPipeline } from \"./use-case-pipeline\";\nimport {\n  $registerUseCase,\n  $unregisterUseCase,\n  addUseCaseHistory,\n  increaseUseCaseFailedCalls,\n  increaseUseCaseSuccessCalls,\n} from \"./use-cases-registry\";\n\nconst defaultUseCaseOptions: UseCaseConfigurations = {\n  benchmark: true,\n};\n\n/**\n * Defines and registers a use case.\n *\n * A use case is a named, observable, optionally benchmarked unit of business logic.\n * The returned handler is a typed async function you call with the input data.\n *\n * Execution order: onExecuting → guards → validation → before → handler → after →\n * onCompleted → broadcast. Retry and benchmark wrap the **handler** only.\n *\n * When a `schema` is provided, the handler's input is inferred from it — no manual\n * `Input` generic needed.\n *\n * @example\n * export const createOrderUseCase = useCase({\n *   name: \"create_order\",\n *   schema: createOrderSchema,           // handler `data` is inferred from this\n *   guards: [authGuard],\n *   handler: async (data, ctx) => orderService.create(data),\n *   after: [sendConfirmationEmail],\n *   retry: { attempts: 3, delay: 500, backoff: \"exponential\" },\n *   broadcast: true,\n * });\n *\n * // In a controller:\n * const output = await createOrderUseCase({ ...validated, user_id: req.user.id });\n */\nexport function useCase<\n  Output,\n  Schema extends ObjectValidator,\n  Ctx extends UseCaseContext = UseCaseContext,\n>(options: UseCaseWithSchema<Output, Schema, Ctx>): UseCaseHandler<Output, Infer<Schema>>;\nexport function useCase<Output = any, Input = any, Ctx extends UseCaseContext = UseCaseContext>(\n  options: UseCase<Output, Input, Ctx>,\n): UseCaseHandler<Output, Input>;\nexport function useCase<Output = any, Input = any>(\n  options: UseCase<Output, Input>,\n): UseCaseHandler<Output, Input> {\n  const { name, handler, schema, guards, before, after, onExecuting, onCompleted, onError } =\n    options;\n\n  // Merge per-use-case options with global config defaults\n  const useCaseConfig = config.get<UseCaseConfigurations>(\"use-cases\", defaultUseCaseOptions);\n  const benchmark = options.benchmark ?? useCaseConfig?.benchmark ?? true;\n  const retryConfig = options.retry ?? useCaseConfig?.retry;\n  const broadcast = options.broadcast;\n  const broadcastConfig = useCaseConfig?.broadcast;\n  const logEnabled = useCaseConfig?.log === true;\n\n  $registerUseCase(name, {\n    ...options,\n    calls: { success: 0, failed: 0, total: 0 },\n  });\n\n  const useCaseHandler = async (\n    data: Input,\n    {\n      ctx = {},\n      id = `uc-${name}-` + Random.string(),\n      onExecuting: invocationOnExecuting,\n      onCompleted: invocationOnCompleted,\n      onError: invocationOnError,\n    }: UseCaseRuntimeOptions = {},\n  ): Promise<Output> => {\n    ctx.schema = schema;\n    ctx.id = id;\n\n    const startedAt = new Date();\n    let output: Output | undefined;\n    let error: Error | undefined;\n    let benchmarkResult: { latency: number; state: \"excellent\" | \"good\" | \"poor\" } | undefined;\n    // 1-based count of failed attempts (reinforcements' `attempt` arg). Translated\n    // into \"retries performed\" at snapshot time — see the `currentRetry` derivation.\n    let failedAttempts = 0;\n\n    if (logEnabled) {\n      log.debug(\"use-cases\", name, \"executing\", { id });\n    }\n\n    try {\n      const transformed = await runPipeline<Input>({\n        name,\n        id,\n        data,\n        ctx,\n        startedAt,\n        schema,\n        guards,\n        before,\n        onExecuting: invocationOnExecuting,\n        ucOnExecuting: onExecuting,\n      });\n\n      // Benchmark wraps ONLY the handler (per attempt) so latency reflects business\n      // logic — not the guard/validation prelude, and not the retry backoff delays.\n      const runHandler = async (): Promise<Output> => {\n        if (!benchmark) {\n          return handler(transformed, ctx);\n        }\n\n        const measured = await measure(\n          name,\n          () => handler(transformed, ctx),\n          benchmark === true ? undefined : benchmark,\n        );\n\n        benchmarkResult = { latency: measured.latency, state: measured.state };\n\n        // measure() never throws — it returns an error result. Re-throw so retry\n        // and the outer catch handle failures uniformly.\n        if (!measured.success) {\n          throw measured.error;\n        }\n\n        return measured.value;\n      };\n\n      output = retryConfig\n        ? await runWithRetry(runHandler, {\n            ...retryConfig,\n            onError: (retryError, attempt) => {\n              failedAttempts = attempt;\n              retryConfig.onError?.(retryError, attempt);\n            },\n          })\n        : await runHandler();\n    } catch (err) {\n      error = err as Error;\n    }\n\n    const endedAt = new Date();\n\n    // After middleware — fire-and-forget side effects, only on success.\n    // Keyed off the error flag alone so void handlers (which return undefined)\n    // still run their after middleware.\n    if (!error && after) {\n      for (const middleware of after) {\n        try {\n          // On the success path `output` holds the handler's return value; for a\n          // void handler that's undefined, which the middleware receives as-is.\n          await middleware(output as Output, ctx);\n        } catch (afterError) {\n          log.error(\"use-cases\", name, \"after middleware failed\", { error: afterError });\n        }\n      }\n    }\n\n    // Retries actually performed (0 = succeeded on the first try). On success every\n    // failed attempt was followed by a retry; on failure the final failed attempt\n    // was NOT retried, so it doesn't count as a retry performed.\n    const currentRetry = error ? Math.max(failedAttempts - 1, 0) : failedAttempts;\n\n    const snapshot: UseCaseResult<Output> = {\n      output,\n      ctx,\n      startedAt,\n      endedAt,\n      id,\n      name,\n      retries: retryConfig\n        ? { attempts: retryConfig.attempts ?? 3, delay: retryConfig.delay, currentRetry }\n        : undefined,\n      benchmarkResult,\n      // Set per-branch below so the counter reflects the actual outcome —\n      // a failure must never increment the success tally.\n      calls: 0,\n    };\n\n    if (error) {\n      snapshot.calls = increaseUseCaseFailedCalls(name);\n\n      if (logEnabled) {\n        log.error(\"use-cases\", name, \"failed\", { id, error });\n      }\n\n      await fireLifecycleEvent<UseCaseErrorResult>(\n        { ...except(snapshot, [\"output\"]), error },\n        {\n          invocation: invocationOnError ? [invocationOnError] : undefined,\n          useCase: onError ? [onError] : undefined,\n          global: globalEventsCallbacksMap.onError.length\n            ? globalEventsCallbacksMap.onError\n            : undefined,\n        },\n      );\n\n      throw error;\n    }\n\n    snapshot.calls = increaseUseCaseSuccessCalls(name);\n\n    if (logEnabled) {\n      log.debug(\"use-cases\", name, \"completed\", { id, latency: benchmarkResult?.latency });\n    }\n\n    // History is best-effort — a cache rejection must not turn a successful run\n    // into a thrown error or skip onCompleted/broadcast.\n    try {\n      await addUseCaseHistory(name, snapshot);\n    } catch (historyError) {\n      log.error(\"use-cases\", name, \"history persistence failed\", { id, error: historyError });\n    }\n\n    await fireLifecycleEvent<UseCaseResult<Output>>(snapshot, {\n      invocation: invocationOnCompleted ? [invocationOnCompleted] : undefined,\n      useCase: onCompleted ? [onCompleted] : undefined,\n      global: globalEventsCallbacksMap.onCompleted.length\n        ? globalEventsCallbacksMap.onCompleted\n        : undefined,\n    });\n\n    await broadcastUseCaseResult({\n      name,\n      id,\n      // A void handler resolves to undefined — broadcast it as-is rather than\n      // asserting a non-null value that would fabricate a bogus payload.\n      output: output as Output,\n      result: snapshot,\n      broadcast,\n      config: broadcastConfig,\n    });\n\n    return output as Output;\n  };\n\n  useCaseHandler.$cleanup = () => {\n    $unregisterUseCase(name);\n  };\n\n  return useCaseHandler;\n}\n"],"mappings":"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"}

package/esm/use-cases/use-cases-registry.d.mts

@@ -1,6 +1,6 @@
 import { RegisteredUseCase, UseCaseResult } from "./types.mjs";
 
-//#region core/src/use-cases/use-cases-registry.d.ts
+//#region ../core/src/use-cases/use-cases-registry.d.ts
 /**
  * Register a use case
  */

package/esm/use-cases/use-cases-registry.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"use-cases-registry.d.mts","names":[],"sources":["C:/Work/Warlock.js/core/src/use-cases/use-cases-registry.ts"],"mappings":";;;;;AAaA;iBAAgB,gBAAA,eAAA,CACd,IAAA,UACA,OAAA,EAAS,iBAAA,CAAkB,MAAA,EAAQ,KAAA;;;;;;;;iBAoBrB,kBAAA,CAAmB,IAAY;;;;;;;AApBJ;iBAmC3B,UAAA,eAAA,CAA0B,IAAA,WACJ,iBAAA,CAAkB,MAAA,EAAQ,KAAA;;;;iBAMhD,WAAA,CAAA,GAAW,GAAA,SAAA,iBAAA;AAP3B;;;AAAA,iBAcgB,2BAAA,CAA4B,IAAY;;;;iBAexC,0BAAA,CAA2B,IAAY;;;;;;iBA2BjC,iBAAA,CAAkB,IAAA,WAAe,OAAO,CAAC,aAAA;;AAvDM;AAMrE;;iBA+EsB,iBAAA,CAAkB,IAAA,UAAc,MAAA,EAAQ,aAAA,QAAkB,OAAA"}
+{"version":3,"file":"use-cases-registry.d.mts","names":[],"sources":["../../../../../../../core/src/use-cases/use-cases-registry.ts"],"mappings":";;;;;AAaA;iBAAgB,gBAAA,eAAA,CACd,IAAA,UACA,OAAA,EAAS,iBAAA,CAAkB,MAAA,EAAQ,KAAA;;;;;;;;iBAoBrB,kBAAA,CAAmB,IAAY;;;;;;;AApBJ;iBAmC3B,UAAA,eAAA,CAA0B,IAAA,WACJ,iBAAA,CAAkB,MAAA,EAAQ,KAAA;;;;iBAMhD,WAAA,CAAA,GAAW,GAAA,SAAA,iBAAA;AAP3B;;;AAAA,iBAcgB,2BAAA,CAA4B,IAAY;;;;iBAexC,0BAAA,CAA2B,IAAY;;;;;;iBA2BjC,iBAAA,CAAkB,IAAA,WAAe,OAAO,CAAC,aAAA;;AAvDM;AAMrE;;iBA+EsB,iBAAA,CAAkB,IAAA,UAAc,MAAA,EAAQ,aAAA,QAAkB,OAAA"}

package/esm/use-cases/use-cases-registry.mjs

@@ -3,7 +3,7 @@ import "../config/index.mjs";
 import { log } from "@warlock.js/logger";
 import { cache } from "@warlock.js/cache";
 
-//#region core/src/use-cases/use-cases-registry.ts
+//#region ../core/src/use-cases/use-cases-registry.ts
 /**
 * Store registered use cases
 */