@warlock.js/core 4.3.0 → 4.5.0

package/esm/ai/src/workflow/step.mjs

@@ -0,0 +1,37 @@
+import { WorkflowError } from "../errors/workflow-error.mjs";
+import "../errors/index.mjs";
+
+//#region ../@warlock.js/ai/src/workflow/step.ts
+/**
+* `ai.step(def)` — pass-through factory used for authoring. Returns
+* the definition object verbatim so the workflow engine can read it
+* during execution; the factory exists for API symmetry with
+* `ai.workflow()` and to leave room for future validation or
+* metadata annotation.
+*
+* Generics flow from the enclosing `ai.workflow<...>()` call when the
+* step is declared inline inside `steps: [...]`. To author a step
+* outside that context with full typing, pass them explicitly:
+* `ai.step<MyInput, MyState, MyContext>({ ... })`.
+*/
+function step(definition) {
+	validate(definition);
+	return definition;
+}
+function validate(def) {
+	if (!def.name || typeof def.name !== "string") throw new WorkflowError("ai.step: `name` is required");
+	const hasRun = typeof def.run === "function";
+	const hasAgent = def.agent !== void 0;
+	const modes = [
+		hasRun,
+		hasAgent,
+		Array.isArray(def.parallel) && def.parallel.length > 0
+	].filter(Boolean).length;
+	if (modes === 0) throw new WorkflowError(`ai.step("${def.name}"): must define exactly one of run | agent | parallel`);
+	if (modes > 1) throw new WorkflowError(`ai.step("${def.name}"): define only one of run | agent | parallel`);
+	if (hasAgent && typeof def.input !== "function") throw new WorkflowError(`ai.step("${def.name}"): \`input(ctx)\` is required when \`agent\` is set`);
+}
+
+//#endregion
+export { step };
+//# sourceMappingURL=step.mjs.map

package/esm/ai/src/workflow/step.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"step.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/workflow/step.ts"],"sourcesContent":["import type { StepDefinition } from \"../contracts/workflow/step.contract\";\nimport { WorkflowError } from \"../errors\";\n\n/**\n * `ai.step(def)` — pass-through factory used for authoring. Returns\n * the definition object verbatim so the workflow engine can read it\n * during execution; the factory exists for API symmetry with\n * `ai.workflow()` and to leave room for future validation or\n * metadata annotation.\n *\n * Generics flow from the enclosing `ai.workflow<...>()` call when the\n * step is declared inline inside `steps: [...]`. To author a step\n * outside that context with full typing, pass them explicitly:\n * `ai.step<MyInput, MyState, MyContext>({ ... })`.\n */\nexport function step<\n  TInput = unknown,\n  TState = Record<string, unknown>,\n  TContext = unknown,\n>(\n  definition: StepDefinition<TInput, TState, TContext>,\n): StepDefinition<TInput, TState, TContext> {\n  validate(definition);\n  return definition;\n}\n\nfunction validate<TInput, TState, TContext>(\n  def: StepDefinition<TInput, TState, TContext>,\n): void {\n  if (!def.name || typeof def.name !== \"string\") {\n    throw new WorkflowError(\"ai.step: `name` is required\");\n  }\n\n  const hasRun = typeof def.run === \"function\";\n  const hasAgent = def.agent !== undefined;\n  const hasParallel = Array.isArray(def.parallel) && def.parallel.length > 0;\n\n  const modes = [hasRun, hasAgent, hasParallel].filter(Boolean).length;\n\n  if (modes === 0) {\n    throw new WorkflowError(\n      `ai.step(\"${def.name}\"): must define exactly one of run | agent | parallel`,\n    );\n  }\n\n  if (modes > 1) {\n    throw new WorkflowError(\n      `ai.step(\"${def.name}\"): define only one of run | agent | parallel`,\n    );\n  }\n\n  if (hasAgent && typeof def.input !== \"function\") {\n    throw new WorkflowError(\n      `ai.step(\"${def.name}\"): \\`input(ctx)\\` is required when \\`agent\\` is set`,\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAeA,SAAgB,KAKd,YAC0C;CAC1C,SAAS,UAAU;CACnB,OAAO;AACT;AAEA,SAAS,SACP,KACM;CACN,IAAI,CAAC,IAAI,QAAQ,OAAO,IAAI,SAAS,UACnC,MAAM,IAAI,cAAc,6BAA6B;CAGvD,MAAM,SAAS,OAAO,IAAI,QAAQ;CAClC,MAAM,WAAW,IAAI,UAAU;CAG/B,MAAM,QAAQ;EAAC;EAAQ;EAFH,MAAM,QAAQ,IAAI,QAAQ,KAAK,IAAI,SAAS,SAAS;CAE7B,CAAC,CAAC,OAAO,OAAO,CAAC,CAAC;CAE9D,IAAI,UAAU,GACZ,MAAM,IAAI,cACR,YAAY,IAAI,KAAK,sDACvB;CAGF,IAAI,QAAQ,GACV,MAAM,IAAI,cACR,YAAY,IAAI,KAAK,8CACvB;CAGF,IAAI,YAAY,OAAO,IAAI,UAAU,YACnC,MAAM,IAAI,cACR,YAAY,IAAI,KAAK,qDACvB;AAEJ"}

package/esm/ai/src/workflow/workflow.mjs

@@ -0,0 +1,122 @@
+import { WorkflowError } from "../errors/workflow-error.mjs";
+import "../errors/index.mjs";
+import { notifyObservers } from "../observe/resolve-observers.mjs";
+import { asTool } from "./as-tool.mjs";
+import { WorkflowEmitter } from "./emitter.mjs";
+import { loadSnapshotForResume } from "./snapshot.mjs";
+import { runWorkflow } from "./engine.mjs";
+import { computeSignature } from "./signature.mjs";
+
+//#region ../@warlock.js/ai/src/workflow/workflow.ts
+/**
+* `ai.workflow(def)` — construct a `WorkflowInstance`. Validates the
+* definition, computes a stable structural signature, and wires up the
+* three-tier event subscription model.
+*/
+function workflow(definition) {
+	validate(definition);
+	const signature = computeSignature(definition);
+	const emitter = new WorkflowEmitter(definition.on);
+	async function execute(inputOrOptions, maybeOptions) {
+		const { input, options } = normalizeExecuteArgs(inputOrOptions, maybeOptions);
+		const runId = options?.runId ?? generateRunId();
+		const result = await runWorkflow({
+			definition,
+			signature,
+			emitter,
+			input,
+			context: options?.context,
+			runId,
+			signal: options?.signal,
+			executionHandlers: options?.on,
+			sessionId: options?.sessionId
+		});
+		await notifyObservers(definition.observe, result.report);
+		return result;
+	}
+	async function resume(runId, options) {
+		const snapshot = await loadSnapshotForResume({
+			definition,
+			signature,
+			runId,
+			options
+		});
+		const result = await runWorkflow({
+			definition,
+			signature,
+			emitter,
+			input: snapshot.input,
+			context: options?.context,
+			runId,
+			signal: options?.signal,
+			executionHandlers: options?.on,
+			sessionId: options?.sessionId,
+			resumeFrom: snapshot
+		});
+		await notifyObservers(definition.observe, result.report);
+		return result;
+	}
+	const instance = {
+		name: definition.name,
+		description: definition.description,
+		inputSchema: definition.inputSchema,
+		signature,
+		version: definition.version,
+		execute,
+		resume,
+		on(event, handler) {
+			return emitter.on(event, handler);
+		},
+		off(event, handler) {
+			emitter.off(event, handler);
+		},
+		asTool(options) {
+			return asTool(instance, options);
+		}
+	};
+	return instance;
+}
+/**
+* Resolve the overloaded `execute()` call shape. If the caller passed
+* a single plain object with an `input` field, treat it as the
+* combined `WorkflowExecuteOptions`. Otherwise the first arg is the
+* raw workflow input and the second is the run options.
+*
+* Ambiguity note: if your real workflow `input` is itself an object
+* with a top-level `input` key, prefer `execute(rawInput, options)`
+* explicitly — the single-arg detection heuristic would mis-classify
+* it.
+*/
+function normalizeExecuteArgs(inputOrOptions, maybeOptions) {
+	if (maybeOptions === void 0 && inputOrOptions !== null && typeof inputOrOptions === "object" && "input" in inputOrOptions) {
+		const { input, ...options } = inputOrOptions;
+		return {
+			input,
+			options
+		};
+	}
+	return {
+		input: inputOrOptions,
+		options: maybeOptions
+	};
+}
+function validate(definition) {
+	if (!definition.name || typeof definition.name !== "string") throw new WorkflowError("ai.workflow: `name` is required");
+	if (!Array.isArray(definition.steps) || definition.steps.length === 0) throw new WorkflowError(`ai.workflow("${definition.name}"): at least one step is required`);
+	const seen = /* @__PURE__ */ new Set();
+	const walk = (name) => {
+		if (seen.has(name)) throw new WorkflowError(`ai.workflow("${definition.name}"): duplicate step name "${name}"`);
+		seen.add(name);
+	};
+	for (const step of definition.steps) {
+		walk(step.name);
+		if (step.parallel) for (const child of step.parallel) walk(child.name);
+	}
+}
+function generateRunId() {
+	return `wf_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+}
+
+//#endregion
+export { workflow };
+//# sourceMappingURL=workflow.mjs.map

package/esm/ai/src/workflow/workflow.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.mjs","names":["combined"],"sources":["../../../../../../../../../@warlock.js/ai/src/workflow/workflow.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport type { WorkflowEventMap } from \"../contracts/events/event-map.type\";\nimport type { ExecutionReport } from \"../contracts/result/execution-report.type\";\nimport type { WorkflowResult } from \"../contracts/result/workflow-result.type\";\nimport type {\n  WorkflowDefinition,\n  WorkflowEventHandler,\n  WorkflowExecuteOptions,\n  WorkflowInstance,\n  WorkflowResumeOptions,\n  WorkflowRunOptions,\n} from \"../contracts/workflow/workflow.contract\";\nimport { WorkflowError } from \"../errors\";\nimport { notifyObservers } from \"../observe/resolve-observers\";\nimport type { ToolContract } from \"../tool/tool\";\nimport { asTool } from \"./as-tool\";\nimport { WorkflowEmitter } from \"./emitter\";\nimport { loadSnapshotForResume, runWorkflow } from \"./engine\";\nimport { computeSignature } from \"./signature\";\n\n/**\n * `ai.workflow(def)` — construct a `WorkflowInstance`. Validates the\n * definition, computes a stable structural signature, and wires up the\n * three-tier event subscription model.\n */\nexport function workflow<\n  TInput = unknown,\n  TOutput = unknown,\n  TState = Record<string, unknown>,\n  TContext = unknown,\n>(\n  definition: WorkflowDefinition<TInput, TOutput, TState, TContext>,\n): WorkflowInstance<TInput, TOutput, TState, TContext> {\n  validate(definition);\n  const signature = computeSignature(definition);\n  const emitter = new WorkflowEmitter(definition.on);\n\n  async function execute(\n    inputOrOptions: TInput | WorkflowExecuteOptions<TInput, TContext>,\n    maybeOptions?: WorkflowRunOptions<TContext>,\n  ): Promise<WorkflowResult<TOutput>> {\n    const { input, options } = normalizeExecuteArgs<TInput, TContext>(\n      inputOrOptions,\n      maybeOptions,\n    );\n    const runId = options?.runId ?? generateRunId();\n    const result = await runWorkflow<TOutput>({\n      definition,\n      signature,\n      emitter,\n      input,\n      context: options?.context,\n      runId,\n      signal: options?.signal,\n      executionHandlers: options?.on,\n      sessionId: options?.sessionId,\n    });\n\n    // Route the finished report to any resolved observers (F1/F3).\n    // Gated by `definition.observe` + the global observe-all flag;\n    // observer errors are swallowed inside `notifyObservers`. Bridge the\n    // pre-existing `WorkflowReport = Omit<BaseReport, \"type\">` drift (the\n    // report carries `type: \"workflow\"` at runtime — engine sets it) so\n    // this call site adds no new type error beyond the documented baseline.\n    await notifyObservers(definition.observe, result.report as unknown as ExecutionReport);\n\n    return result;\n  }\n\n  async function resume(\n    runId: string,\n    options?: WorkflowResumeOptions<TContext>,\n  ): Promise<WorkflowResult<TOutput>> {\n    const snapshot = await loadSnapshotForResume({\n      definition,\n      signature,\n      runId,\n      options,\n    });\n\n    const result = await runWorkflow<TOutput>({\n      definition,\n      signature,\n      emitter,\n      input: snapshot.input,\n      context: options?.context,\n      runId,\n      signal: options?.signal,\n      executionHandlers: options?.on,\n      sessionId: options?.sessionId,\n      resumeFrom: snapshot,\n    });\n\n    await notifyObservers(definition.observe, result.report as unknown as ExecutionReport);\n\n    return result;\n  }\n\n  const instance: WorkflowInstance<TInput, TOutput, TState, TContext> = {\n    name: definition.name,\n    description: definition.description,\n    inputSchema: definition.inputSchema,\n    signature,\n    version: definition.version,\n    execute,\n    resume,\n    on<K extends keyof WorkflowEventMap>(event: K, handler: WorkflowEventHandler<K>) {\n      return emitter.on(event, handler);\n    },\n    off<K extends keyof WorkflowEventMap>(event: K, handler: WorkflowEventHandler<K>) {\n      emitter.off(event, handler);\n    },\n    asTool<TToolInput = TInput>(options: {\n      description?: string;\n      inputSchema: StandardSchemaV1<TToolInput>;\n    }): ToolContract<TToolInput, TOutput> {\n      return asTool<TInput, TOutput, TToolInput>(instance, options);\n    },\n  };\n\n  return instance;\n}\n\n/**\n * Resolve the overloaded `execute()` call shape. If the caller passed\n * a single plain object with an `input` field, treat it as the\n * combined `WorkflowExecuteOptions`. Otherwise the first arg is the\n * raw workflow input and the second is the run options.\n *\n * Ambiguity note: if your real workflow `input` is itself an object\n * with a top-level `input` key, prefer `execute(rawInput, options)`\n * explicitly — the single-arg detection heuristic would mis-classify\n * it.\n */\nfunction normalizeExecuteArgs<TInput, TContext>(\n  inputOrOptions: TInput | WorkflowExecuteOptions<TInput, TContext>,\n  maybeOptions: WorkflowRunOptions<TContext> | undefined,\n): { input: TInput; options?: WorkflowRunOptions<TContext> } {\n  if (\n    maybeOptions === undefined &&\n    inputOrOptions !== null &&\n    typeof inputOrOptions === \"object\" &&\n    \"input\" in (inputOrOptions as object)\n  ) {\n    const combined = inputOrOptions as WorkflowExecuteOptions<TInput, TContext>;\n    const { input, ...options } = combined;\n    return { input, options };\n  }\n\n  return { input: inputOrOptions as TInput, options: maybeOptions };\n}\n\nfunction validate<TInput, TOutput, TState, TContext>(\n  definition: WorkflowDefinition<TInput, TOutput, TState, TContext>,\n): void {\n  if (!definition.name || typeof definition.name !== \"string\") {\n    throw new WorkflowError(\"ai.workflow: `name` is required\");\n  }\n\n  if (!Array.isArray(definition.steps) || definition.steps.length === 0) {\n    throw new WorkflowError(`ai.workflow(\"${definition.name}\"): at least one step is required`);\n  }\n\n  const seen = new Set<string>();\n  const walk = (name: string) => {\n    if (seen.has(name)) {\n      throw new WorkflowError(`ai.workflow(\"${definition.name}\"): duplicate step name \"${name}\"`);\n    }\n    seen.add(name);\n  };\n\n  for (const step of definition.steps) {\n    walk(step.name);\n\n    if (step.parallel) {\n      for (const child of step.parallel) {\n        walk(child.name);\n      }\n    }\n  }\n}\n\nfunction generateRunId(): string {\n  // Non-crypto random — adequate for ephemeral workflow runs.\n  return `wf_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;\n}\n"],"mappings":";;;;;;;;;;;;;;;AAyBA,SAAgB,SAMd,YACqD;CACrD,SAAS,UAAU;CACnB,MAAM,YAAY,iBAAiB,UAAU;CAC7C,MAAM,UAAU,IAAI,gBAAgB,WAAW,EAAE;CAEjD,eAAe,QACb,gBACA,cACkC;EAClC,MAAM,EAAE,OAAO,YAAY,qBACzB,gBACA,YACF;EACA,MAAM,QAAQ,SAAS,SAAS,cAAc;EAC9C,MAAM,SAAS,MAAM,YAAqB;GACxC;GACA;GACA;GACA;GACA,SAAS,SAAS;GAClB;GACA,QAAQ,SAAS;GACjB,mBAAmB,SAAS;GAC5B,WAAW,SAAS;EACtB,CAAC;EAQD,MAAM,gBAAgB,WAAW,SAAS,OAAO,MAAoC;EAErF,OAAO;CACT;CAEA,eAAe,OACb,OACA,SACkC;EAClC,MAAM,WAAW,MAAM,sBAAsB;GAC3C;GACA;GACA;GACA;EACF,CAAC;EAED,MAAM,SAAS,MAAM,YAAqB;GACxC;GACA;GACA;GACA,OAAO,SAAS;GAChB,SAAS,SAAS;GAClB;GACA,QAAQ,SAAS;GACjB,mBAAmB,SAAS;GAC5B,WAAW,SAAS;GACpB,YAAY;EACd,CAAC;EAED,MAAM,gBAAgB,WAAW,SAAS,OAAO,MAAoC;EAErF,OAAO;CACT;CAEA,MAAM,WAAgE;EACpE,MAAM,WAAW;EACjB,aAAa,WAAW;EACxB,aAAa,WAAW;EACxB;EACA,SAAS,WAAW;EACpB;EACA;EACA,GAAqC,OAAU,SAAkC;GAC/E,OAAO,QAAQ,GAAG,OAAO,OAAO;EAClC;EACA,IAAsC,OAAU,SAAkC;GAChF,QAAQ,IAAI,OAAO,OAAO;EAC5B;EACA,OAA4B,SAGU;GACpC,OAAO,OAAoC,UAAU,OAAO;EAC9D;CACF;CAEA,OAAO;AACT;;;;;;;;;;;;AAaA,SAAS,qBACP,gBACA,cAC2D;CAC3D,IACE,iBAAiB,UACjB,mBAAmB,QACnB,OAAO,mBAAmB,YAC1B,WAAY,gBACZ;EAEA,MAAM,EAAE,OAAO,GAAG,YAAYA;EAC9B,OAAO;GAAE;GAAO;EAAQ;CAC1B;CAEA,OAAO;EAAE,OAAO;EAA0B,SAAS;CAAa;AAClE;AAEA,SAAS,SACP,YACM;CACN,IAAI,CAAC,WAAW,QAAQ,OAAO,WAAW,SAAS,UACjD,MAAM,IAAI,cAAc,iCAAiC;CAG3D,IAAI,CAAC,MAAM,QAAQ,WAAW,KAAK,KAAK,WAAW,MAAM,WAAW,GAClE,MAAM,IAAI,cAAc,gBAAgB,WAAW,KAAK,kCAAkC;CAG5F,MAAM,uBAAO,IAAI,IAAY;CAC7B,MAAM,QAAQ,SAAiB;EAC7B,IAAI,KAAK,IAAI,IAAI,GACf,MAAM,IAAI,cAAc,gBAAgB,WAAW,KAAK,2BAA2B,KAAK,EAAE;EAE5F,KAAK,IAAI,IAAI;CACf;CAEA,KAAK,MAAM,QAAQ,WAAW,OAAO;EACnC,KAAK,KAAK,IAAI;EAEd,IAAI,KAAK,UACP,KAAK,MAAM,SAAS,KAAK,UACvB,KAAK,MAAM,IAAI;CAGrB;AACF;AAEA,SAAS,gBAAwB;CAE/B,OAAO,MAAM,KAAK,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,GAAG,KAAK,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,MAAM,GAAG,EAAE;AAChF"}

package/esm/ai-openai/src/embedder.mjs

@@ -0,0 +1,4 @@
+import "./utils/index.mjs";
+import { log } from "@warlock.js/logger";
+
+export {  };

package/esm/ai-openai/src/index.mjs

@@ -0,0 +1,4 @@
+import "./embedder.mjs";
+import "./sdk.mjs";
+
+export {  };

package/esm/ai-openai/src/model.mjs

@@ -0,0 +1,5 @@
+import "../../ai/src/index.mjs";
+import "./utils/index.mjs";
+import { log } from "@warlock.js/logger";
+
+export {  };

package/esm/ai-openai/src/sdk.mjs

@@ -0,0 +1,6 @@
+import "../../node_modules/openai/index.mjs";
+import "../../ai/src/index.mjs";
+import "./embedder.mjs";
+import "./model.mjs";
+
+export {  };

package/esm/ai-openai/src/utils/index.mjs

@@ -0,0 +1,4 @@
+import "./to-openai-tools.mjs";
+import "./wrap-openai-error.mjs";
+
+export {  };

package/esm/ai-openai/src/utils/to-openai-tools.mjs

@@ -0,0 +1,3 @@
+import "../../../ai/src/index.mjs";
+
+export {  };

package/esm/ai-openai/src/utils/wrap-openai-error.mjs

@@ -0,0 +1,4 @@
+import "../../../node_modules/openai/index.mjs";
+import "../../../ai/src/index.mjs";
+
+export {  };

package/esm/application/application.d.mts

@@ -1,6 +1,33 @@
-import { Environment } from "../utils/environment.mjs";
+import { Environment, RuntimeStrategy } from "../utils/environment.mjs";
 
 //#region ../@warlock.js/core/src/application/application.d.ts
+/**
+ * Snapshot of the global facts known the moment the application finished
+ * booting: every connector (early + late) is active and all app files
+ * (locales, events, main, routes) are loaded. Passed to every
+ * `Application.onceBooted` listener and resolved from `Application.whenBooted`.
+ */
+type BootContext = {
+  environment: Environment;
+  runtimeStrategy: RuntimeStrategy;
+  /**
+   * Wall-clock milliseconds the boot took. The dev server measures it; the
+   * production entry omits it.
+   */
+  bootDurationMs?: number;
+};
+/**
+ * A callback registered through `Application.onceBooted`. May be async — its
+ * rejection is caught and logged so a single listener can never break boot or
+ * the other listeners.
+ */
+type BootListener = (context: BootContext) => void | Promise<void>;
+/**
+ * A callback registered through `Application.onShutdown`. Runs once, while the
+ * connectors (db, cache, http) are still up, so it can release app-owned
+ * resources cleanly. May be async — its rejection is caught and logged.
+ */
+type ShutdownListener = () => void | Promise<void>;
 declare class Application {
   /**
    * Project start time regarding the process start time
@@ -9,7 +36,29 @@ declare class Application {
   /**
    * Runtime strategy
    */
-  static runtimeStrategy: "production" | "development";
+  static runtimeStrategy: RuntimeStrategy;
+  /**
+   * Whether the application has finished booting. Flipped once by `markBooted`.
+   */
+  private static booted;
+  /**
+   * The boot context, set once booted so it can be replayed to late subscribers.
+   */
+  private static bootContext;
+  /**
+   * Listeners queued before boot completed, drained in registration order by
+   * `markBooted`.
+   */
+  private static bootListeners;
+  /**
+   * Whether the application has begun (or finished) shutting down. Flipped once
+   * by `runShutdownHooks`.
+   */
+  private static shuttingDown;
+  /**
+   * Teardown callbacks, run once when shutdown begins.
+   */
+  private static shutdownListeners;
   /**
    * Get framework version
    */
@@ -17,7 +66,80 @@ declare class Application {
   /**
    * Set the runtime strategy
    */
-  static setRuntimeStrategy(strategy: "production" | "development"): void;
+  static setRuntimeStrategy(strategy: RuntimeStrategy): void;
+  /**
+   * Whether the application has finished booting — every connector in both
+   * the early and late phases is active and all app files (locales, events,
+   * main, routes) have been loaded.
+   */
+  static get isBooted(): boolean;
+  /**
+   * Run a callback once the application is fully booted.
+   *
+   * App files (`main` / `events` / `routes` / locales) are imported BEFORE the
+   * late-phase connectors (http, socket) start, so a listener registered at
+   * import time waits for the whole sequence to finish before it runs. If the
+   * application is already booted, the callback runs on the next microtask —
+   * so a late subscriber never silently misses the event.
+   *
+   * @example
+   * Application.onceBooted(({ environment }) => {
+   *   log.info("app", "booted", `ready in ${environment}`);
+   * });
+   */
+  static onceBooted(listener: BootListener): void;
+  /**
+   * Promise form of {@link onceBooted} — resolves with the boot context once
+   * the application is booted, or immediately if it already is.
+   */
+  static whenBooted(): Promise<BootContext>;
+  /**
+   * Flip the boot latch and drain every queued listener. The dev server and
+   * the production entry call this once, right after the late phase starts. It
+   * is idempotent — a second call is a no-op, so a double-invoke can never
+   * double-fire listeners.
+   *
+   * @internal Framework entry points call this; application code must not.
+   */
+  static markBooted(context: BootContext): void;
+  /**
+   * Invoke a single boot listener, isolating its failure so neither boot nor
+   * the remaining listeners are affected.
+   */
+  private static runBootListener;
+  /**
+   * Whether the application has begun shutting down. Once true, readiness
+   * checks report not-ready so a load balancer drains this instance before the
+   * HTTP server stops accepting requests.
+   */
+  static get isShuttingDown(): boolean;
+  /**
+   * Register a teardown callback, run once when the application shuts down —
+   * before the connectors (db, cache, http) are torn down, so it can still use
+   * them. The natural place to close an app-owned resource opened in
+   * `onceBooted`. If shutdown has already begun, the callback runs immediately.
+   *
+   * @example
+   * Application.onShutdown(async () => {
+   *   await myQueueConsumer.stop();
+   * });
+   */
+  static onShutdown(listener: ShutdownListener): void;
+  /**
+   * Flip the shutdown latch and run every teardown callback. The connectors
+   * manager calls this at the start of shutdown — before any connector is torn
+   * down. Idempotent and error-isolated: each callback is awaited, a thrown one
+   * is logged and does not stop the rest. Listeners run LIFO (reverse of
+   * registration), mirroring resource-unwind order.
+   *
+   * @internal Framework entry points call this; application code must not.
+   */
+  static runShutdownHooks(): Promise<void>;
+  /**
+   * Invoke a single teardown callback, isolating its failure so the rest still
+   * run and shutdown is never blocked by one bad hook.
+   */
+  private static runShutdownListener;
   /**
    * Get project uptime in milliseconds
    */
@@ -68,5 +190,5 @@ declare class Application {
   static get publicPath(): string;
 }
 //#endregion
-export { Application };
+export { Application, BootContext, BootListener, ShutdownListener };
 //# sourceMappingURL=application.d.mts.map

package/esm/application/application.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"application.d.mts","names":[],"sources":["../../../../../../../@warlock.js/core/src/application/application.ts"],"mappings":";;;cAIa,WAAA;;AAAb;;kBAIyB,SAAA,EAAS,IAAA;EAAA;;;EAAA,OAKlB,eAAA;EAiC+B;;;EAAA,WA5B3B,OAAA;EAAA;;;EAAA,OAOJ,kBAAA,CAAmB,QAAA;EAcf;;;EAAA,WAPA,MAAA;EAcW;;;EAAA,WAPX,WAAA,IAAe,WAAA;EAmCf;;;EAAA,OA5BJ,cAAA,CAAe,GAAA,EAAK,WAAA;EAwDhB;;;EAAA,WAjDA,YAAA;;;;aAOA,aAAA;;;;aAOA,MAAA;;;;aAOA,QAAA;;;;aAOA,OAAA;;;;aAOA,OAAA;;;;aAOA,WAAA;;;;aAOA,WAAA;;;;aAOA,UAAA;AAAA"}
+{"version":3,"file":"application.d.mts","names":[],"sources":["../../../../../../../@warlock.js/core/src/application/application.ts"],"mappings":";;;;;AAgBA;;;;KAAY,WAAA;EACV,WAAA,EAAa,WAAA;EACb,eAAA,EAAiB,eAAe;EAAf;;;AAKH;EAAd,cAAA;AAAA;;;;;;KAQU,YAAA,IAAgB,OAAA,EAAS,WAAA,YAAuB,OAAO;AAAA;AAOnE;;;;AAPmE,KAOvD,gBAAA,gBAAgC,OAAO;AAAA,cAEtC,WAAA;EAAW;;;EAAA,gBAIC,SAAA,EAAS,IAAA;EA4CW;;;EAAA,OAvC7B,eAAA,EAAiB,eAAA;EAmGG;;;EAAA,eA9FnB,MAAA;EAgNmB;;;EAAA,eA3MnB,WAAA;EAfiB;;;;EAAA,eAqBjB,aAAA;EAAA;;;;EAAA,eAMA,YAAA;EAiB4B;;;EAAA,eAZ5B,iBAAA;EAuCoB;;;EAAA,WAlCjB,OAAA;EAiDkB;;;EAAA,OA1CtB,kBAAA,CAAmB,QAAA,EAAU,eAAA;EAgFtB;;;;;EAAA,WAvEH,QAAA;EAyHsB;;;;;;;;;;;;;;EAAA,OAvG1B,UAAA,CAAW,QAAA,EAAU,YAAA;EA2MjB;;;AAOU;EAPV,OA5LJ,UAAA,IAAc,OAAA,CAAQ,WAAA;;;;;;;;;SAkBtB,UAAA,CAAW,OAAA,EAAS,WAAA;;;;;iBAoBb,eAAA;;;;;;aAgBH,cAAA;;;;;;;;;;;;SAeJ,UAAA,CAAW,QAAA,EAAU,gBAAA;;;;;;;;;;SAmBf,gBAAA,IAAoB,OAAA;;;;;iBAmBnB,mBAAA;;;;aAWH,MAAA;;;;aAOA,WAAA,IAAe,WAAA;;;;SAOnB,cAAA,CAAe,GAAA,EAAK,WAAA;;;;aAOhB,YAAA;;;;aAOA,aAAA;;;;aAOA,MAAA;;;;aAOA,QAAA;;;;aAOA,OAAA;;;;aAOA,OAAA;;;;aAOA,WAAA;;;;aAOA,WAAA;;;;aAOA,UAAA;AAAA"}

package/esm/application/application.mjs

@@ -1,12 +1,25 @@
 import { environment, setEnvironment } from "../utils/environment.mjs";
 import { appPath, publicPath, rootPath, srcPath, storagePath, uploadsPath } from "../utils/paths.mjs";
 import { getFrameworkVersion } from "../utils/framework-vesion.mjs";
+import { log } from "@warlock.js/logger";
 
 //#region ../@warlock.js/core/src/application/application.ts
 var Application = class {
 	static {
 		this.startedAt = /* @__PURE__ */ new Date(Date.now() - process.uptime() * 1e3);
 	}
+	static {
+		this.booted = false;
+	}
+	static {
+		this.bootListeners = [];
+	}
+	static {
+		this.shuttingDown = false;
+	}
+	static {
+		this.shutdownListeners = [];
+	}
 	/**
 	* Get framework version
 	*/
@@ -20,6 +33,126 @@ var Application = class {
 		this.runtimeStrategy = strategy;
 	}
 	/**
+	* Whether the application has finished booting — every connector in both
+	* the early and late phases is active and all app files (locales, events,
+	* main, routes) have been loaded.
+	*/
+	static get isBooted() {
+		return this.booted;
+	}
+	/**
+	* Run a callback once the application is fully booted.
+	*
+	* App files (`main` / `events` / `routes` / locales) are imported BEFORE the
+	* late-phase connectors (http, socket) start, so a listener registered at
+	* import time waits for the whole sequence to finish before it runs. If the
+	* application is already booted, the callback runs on the next microtask —
+	* so a late subscriber never silently misses the event.
+	*
+	* @example
+	* Application.onceBooted(({ environment }) => {
+	*   log.info("app", "booted", `ready in ${environment}`);
+	* });
+	*/
+	static onceBooted(listener) {
+		if (this.booted && this.bootContext) {
+			const context = this.bootContext;
+			this.runBootListener(listener, context);
+			return;
+		}
+		this.bootListeners.push(listener);
+	}
+	/**
+	* Promise form of {@link onceBooted} — resolves with the boot context once
+	* the application is booted, or immediately if it already is.
+	*/
+	static whenBooted() {
+		if (this.booted && this.bootContext) return Promise.resolve(this.bootContext);
+		return new Promise((resolve) => {
+			this.onceBooted((context) => resolve(context));
+		});
+	}
+	/**
+	* Flip the boot latch and drain every queued listener. The dev server and
+	* the production entry call this once, right after the late phase starts. It
+	* is idempotent — a second call is a no-op, so a double-invoke can never
+	* double-fire listeners.
+	*
+	* @internal Framework entry points call this; application code must not.
+	*/
+	static markBooted(context) {
+		if (this.booted) return;
+		this.booted = true;
+		this.bootContext = context;
+		const listeners = this.bootListeners;
+		this.bootListeners = [];
+		for (const listener of listeners) this.runBootListener(listener, context);
+	}
+	/**
+	* Invoke a single boot listener, isolating its failure so neither boot nor
+	* the remaining listeners are affected.
+	*/
+	static async runBootListener(listener, context) {
+		try {
+			await listener(context);
+		} catch (error) {
+			log.error("application", "booted-listener", error);
+		}
+	}
+	/**
+	* Whether the application has begun shutting down. Once true, readiness
+	* checks report not-ready so a load balancer drains this instance before the
+	* HTTP server stops accepting requests.
+	*/
+	static get isShuttingDown() {
+		return this.shuttingDown;
+	}
+	/**
+	* Register a teardown callback, run once when the application shuts down —
+	* before the connectors (db, cache, http) are torn down, so it can still use
+	* them. The natural place to close an app-owned resource opened in
+	* `onceBooted`. If shutdown has already begun, the callback runs immediately.
+	*
+	* @example
+	* Application.onShutdown(async () => {
+	*   await myQueueConsumer.stop();
+	* });
+	*/
+	static onShutdown(listener) {
+		if (this.shuttingDown) {
+			this.runShutdownListener(listener);
+			return;
+		}
+		this.shutdownListeners.push(listener);
+	}
+	/**
+	* Flip the shutdown latch and run every teardown callback. The connectors
+	* manager calls this at the start of shutdown — before any connector is torn
+	* down. Idempotent and error-isolated: each callback is awaited, a thrown one
+	* is logged and does not stop the rest. Listeners run LIFO (reverse of
+	* registration), mirroring resource-unwind order.
+	*
+	* @internal Framework entry points call this; application code must not.
+	*/
+	static async runShutdownHooks() {
+		if (this.shuttingDown) return;
+		this.shuttingDown = true;
+		const listeners = this.shutdownListeners.reverse();
+		this.shutdownListeners = [];
+		for (const listener of listeners) await this.runShutdownListener(listener);
+	}
+	/**
+	* Invoke a single teardown callback, isolating its failure so the rest still
+	* run and shutdown is never blocked by one bad hook.
+	*/
+	static async runShutdownListener(listener) {
+		try {
+			await listener();
+		} catch (error) {
+			log.error("application", "shutdown-listener", error);
+		}
+	}
+	/**
 	* Get project uptime in milliseconds
 	*/
 	static get uptime() {

package/esm/application/application.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"application.mjs","names":[],"sources":["../../../../../../../@warlock.js/core/src/application/application.ts"],"sourcesContent":["import { environment, setEnvironment, type Environment } from \"../utils/environment\";\nimport { getFrameworkVersion } from \"../utils/framework-vesion\";\nimport { appPath, publicPath, rootPath, srcPath, storagePath, uploadsPath } from \"../utils/paths\";\n\nexport class Application {\n  /**\n   * Project start time regarding the process start time\n   */\n  public static readonly startedAt = new Date(Date.now() - process.uptime() * 1000);\n\n  /**\n   * Runtime strategy\n   */\n  public static runtimeStrategy: \"production\" | \"development\";\n\n  /**\n   * Get framework version\n   */\n  public static get version() {\n    return getFrameworkVersion();\n  }\n\n  /**\n   * Set the runtime strategy\n   */\n  public static setRuntimeStrategy(strategy: \"production\" | \"development\") {\n    this.runtimeStrategy = strategy;\n  }\n\n  /**\n   * Get project uptime in milliseconds\n   */\n  public static get uptime(): number {\n    return process.uptime() * 1000;\n  }\n\n  /**\n   * Get the current environment\n   */\n  public static get environment(): Environment {\n    return environment();\n  }\n\n  /**\n   * Set the current environment\n   */\n  public static setEnvironment(env: Environment) {\n    setEnvironment(env);\n  }\n\n  /**\n   * Check if the application is running in production environment\n   */\n  public static get isProduction(): boolean {\n    return this.environment === \"production\";\n  }\n\n  /**\n   * Check if the application is running in development environment\n   */\n  public static get isDevelopment(): boolean {\n    return this.environment === \"development\";\n  }\n\n  /**\n   * Check if the application is running in test environment\n   */\n  public static get isTest(): boolean {\n    return this.environment === \"test\";\n  }\n\n  /**\n   * Get the root path\n   */\n  public static get rootPath(): string {\n    return rootPath();\n  }\n\n  /**\n   * Get the src path\n   */\n  public static get srcPath(): string {\n    return srcPath();\n  }\n\n  /**\n   * Get the app path\n   */\n  public static get appPath(): string {\n    return appPath();\n  }\n\n  /**\n   * Get the storage path\n   */\n  public static get storagePath(): string {\n    return storagePath();\n  }\n\n  /**\n   * Get the uploads path\n   */\n  public static get uploadsPath(): string {\n    return uploadsPath();\n  }\n\n  /**\n   * Get the public path\n   */\n  public static get publicPath(): string {\n    return publicPath();\n  }\n}\n"],"mappings":";;;;;AAIA,IAAa,cAAb,MAAyB;;mCAIY,IAAI,KAAK,KAAK,IAAI,IAAI,QAAQ,OAAO,IAAI,GAAI;;;;;CAUhF,WAAkB,UAAU;EAC1B,OAAO,oBAAoB;CAC7B;;;;CAKA,OAAc,mBAAmB,UAAwC;EACvE,KAAK,kBAAkB;CACzB;;;;CAKA,WAAkB,SAAiB;EACjC,OAAO,QAAQ,OAAO,IAAI;CAC5B;;;;CAKA,WAAkB,cAA2B;EAC3C,OAAO,YAAY;CACrB;;;;CAKA,OAAc,eAAe,KAAkB;EAC7C,eAAe,GAAG;CACpB;;;;CAKA,WAAkB,eAAwB;EACxC,OAAO,KAAK,gBAAgB;CAC9B;;;;CAKA,WAAkB,gBAAyB;EACzC,OAAO,KAAK,gBAAgB;CAC9B;;;;CAKA,WAAkB,SAAkB;EAClC,OAAO,KAAK,gBAAgB;CAC9B;;;;CAKA,WAAkB,WAAmB;EACnC,OAAO,SAAS;CAClB;;;;CAKA,WAAkB,UAAkB;EAClC,OAAO,QAAQ;CACjB;;;;CAKA,WAAkB,UAAkB;EAClC,OAAO,QAAQ;CACjB;;;;CAKA,WAAkB,cAAsB;EACtC,OAAO,YAAY;CACrB;;;;CAKA,WAAkB,cAAsB;EACtC,OAAO,YAAY;CACrB;;;;CAKA,WAAkB,aAAqB;EACrC,OAAO,WAAW;CACpB;AACF"}
+{"version":3,"file":"application.mjs","names":[],"sources":["../../../../../../../@warlock.js/core/src/application/application.ts"],"sourcesContent":["import { log } from \"@warlock.js/logger\";\nimport {\n  environment,\n  setEnvironment,\n  type Environment,\n  type RuntimeStrategy,\n} from \"../utils/environment\";\nimport { getFrameworkVersion } from \"../utils/framework-vesion\";\nimport { appPath, publicPath, rootPath, srcPath, storagePath, uploadsPath } from \"../utils/paths\";\n\n/**\n * Snapshot of the global facts known the moment the application finished\n * booting: every connector (early + late) is active and all app files\n * (locales, events, main, routes) are loaded. Passed to every\n * `Application.onceBooted` listener and resolved from `Application.whenBooted`.\n */\nexport type BootContext = {\n  environment: Environment;\n  runtimeStrategy: RuntimeStrategy;\n  /**\n   * Wall-clock milliseconds the boot took. The dev server measures it; the\n   * production entry omits it.\n   */\n  bootDurationMs?: number;\n};\n\n/**\n * A callback registered through `Application.onceBooted`. May be async — its\n * rejection is caught and logged so a single listener can never break boot or\n * the other listeners.\n */\nexport type BootListener = (context: BootContext) => void | Promise<void>;\n\n/**\n * A callback registered through `Application.onShutdown`. Runs once, while the\n * connectors (db, cache, http) are still up, so it can release app-owned\n * resources cleanly. May be async — its rejection is caught and logged.\n */\nexport type ShutdownListener = () => void | Promise<void>;\n\nexport class Application {\n  /**\n   * Project start time regarding the process start time\n   */\n  public static readonly startedAt = new Date(Date.now() - process.uptime() * 1000);\n\n  /**\n   * Runtime strategy\n   */\n  public static runtimeStrategy: RuntimeStrategy;\n\n  /**\n   * Whether the application has finished booting. Flipped once by `markBooted`.\n   */\n  private static booted = false;\n\n  /**\n   * The boot context, set once booted so it can be replayed to late subscribers.\n   */\n  private static bootContext: BootContext | undefined;\n\n  /**\n   * Listeners queued before boot completed, drained in registration order by\n   * `markBooted`.\n   */\n  private static bootListeners: BootListener[] = [];\n\n  /**\n   * Whether the application has begun (or finished) shutting down. Flipped once\n   * by `runShutdownHooks`.\n   */\n  private static shuttingDown = false;\n\n  /**\n   * Teardown callbacks, run once when shutdown begins.\n   */\n  private static shutdownListeners: ShutdownListener[] = [];\n\n  /**\n   * Get framework version\n   */\n  public static get version() {\n    return getFrameworkVersion();\n  }\n\n  /**\n   * Set the runtime strategy\n   */\n  public static setRuntimeStrategy(strategy: RuntimeStrategy) {\n    this.runtimeStrategy = strategy;\n  }\n\n  /**\n   * Whether the application has finished booting — every connector in both\n   * the early and late phases is active and all app files (locales, events,\n   * main, routes) have been loaded.\n   */\n  public static get isBooted(): boolean {\n    return this.booted;\n  }\n\n  /**\n   * Run a callback once the application is fully booted.\n   *\n   * App files (`main` / `events` / `routes` / locales) are imported BEFORE the\n   * late-phase connectors (http, socket) start, so a listener registered at\n   * import time waits for the whole sequence to finish before it runs. If the\n   * application is already booted, the callback runs on the next microtask —\n   * so a late subscriber never silently misses the event.\n   *\n   * @example\n   * Application.onceBooted(({ environment }) => {\n   *   log.info(\"app\", \"booted\", `ready in ${environment}`);\n   * });\n   */\n  public static onceBooted(listener: BootListener): void {\n    if (this.booted && this.bootContext) {\n      const context = this.bootContext;\n      void this.runBootListener(listener, context);\n\n      return;\n    }\n\n    this.bootListeners.push(listener);\n  }\n\n  /**\n   * Promise form of {@link onceBooted} — resolves with the boot context once\n   * the application is booted, or immediately if it already is.\n   */\n  public static whenBooted(): Promise<BootContext> {\n    if (this.booted && this.bootContext) {\n      return Promise.resolve(this.bootContext);\n    }\n\n    return new Promise<BootContext>((resolve) => {\n      this.onceBooted((context) => resolve(context));\n    });\n  }\n\n  /**\n   * Flip the boot latch and drain every queued listener. The dev server and\n   * the production entry call this once, right after the late phase starts. It\n   * is idempotent — a second call is a no-op, so a double-invoke can never\n   * double-fire listeners.\n   *\n   * @internal Framework entry points call this; application code must not.\n   */\n  public static markBooted(context: BootContext): void {\n    if (this.booted) {\n      return;\n    }\n\n    this.booted = true;\n    this.bootContext = context;\n\n    const listeners = this.bootListeners;\n    this.bootListeners = [];\n\n    for (const listener of listeners) {\n      void this.runBootListener(listener, context);\n    }\n  }\n\n  /**\n   * Invoke a single boot listener, isolating its failure so neither boot nor\n   * the remaining listeners are affected.\n   */\n  private static async runBootListener(\n    listener: BootListener,\n    context: BootContext,\n  ): Promise<void> {\n    try {\n      await listener(context);\n    } catch (error) {\n      log.error(\"application\", \"booted-listener\", error as Error);\n    }\n  }\n\n  /**\n   * Whether the application has begun shutting down. Once true, readiness\n   * checks report not-ready so a load balancer drains this instance before the\n   * HTTP server stops accepting requests.\n   */\n  public static get isShuttingDown(): boolean {\n    return this.shuttingDown;\n  }\n\n  /**\n   * Register a teardown callback, run once when the application shuts down —\n   * before the connectors (db, cache, http) are torn down, so it can still use\n   * them. The natural place to close an app-owned resource opened in\n   * `onceBooted`. If shutdown has already begun, the callback runs immediately.\n   *\n   * @example\n   * Application.onShutdown(async () => {\n   *   await myQueueConsumer.stop();\n   * });\n   */\n  public static onShutdown(listener: ShutdownListener): void {\n    if (this.shuttingDown) {\n      void this.runShutdownListener(listener);\n\n      return;\n    }\n\n    this.shutdownListeners.push(listener);\n  }\n\n  /**\n   * Flip the shutdown latch and run every teardown callback. The connectors\n   * manager calls this at the start of shutdown — before any connector is torn\n   * down. Idempotent and error-isolated: each callback is awaited, a thrown one\n   * is logged and does not stop the rest. Listeners run LIFO (reverse of\n   * registration), mirroring resource-unwind order.\n   *\n   * @internal Framework entry points call this; application code must not.\n   */\n  public static async runShutdownHooks(): Promise<void> {\n    if (this.shuttingDown) {\n      return;\n    }\n\n    this.shuttingDown = true;\n\n    const listeners = this.shutdownListeners.reverse();\n    this.shutdownListeners = [];\n\n    for (const listener of listeners) {\n      await this.runShutdownListener(listener);\n    }\n  }\n\n  /**\n   * Invoke a single teardown callback, isolating its failure so the rest still\n   * run and shutdown is never blocked by one bad hook.\n   */\n  private static async runShutdownListener(listener: ShutdownListener): Promise<void> {\n    try {\n      await listener();\n    } catch (error) {\n      log.error(\"application\", \"shutdown-listener\", error as Error);\n    }\n  }\n\n  /**\n   * Get project uptime in milliseconds\n   */\n  public static get uptime(): number {\n    return process.uptime() * 1000;\n  }\n\n  /**\n   * Get the current environment\n   */\n  public static get environment(): Environment {\n    return environment();\n  }\n\n  /**\n   * Set the current environment\n   */\n  public static setEnvironment(env: Environment) {\n    setEnvironment(env);\n  }\n\n  /**\n   * Check if the application is running in production environment\n   */\n  public static get isProduction(): boolean {\n    return this.environment === \"production\";\n  }\n\n  /**\n   * Check if the application is running in development environment\n   */\n  public static get isDevelopment(): boolean {\n    return this.environment === \"development\";\n  }\n\n  /**\n   * Check if the application is running in test environment\n   */\n  public static get isTest(): boolean {\n    return this.environment === \"test\";\n  }\n\n  /**\n   * Get the root path\n   */\n  public static get rootPath(): string {\n    return rootPath();\n  }\n\n  /**\n   * Get the src path\n   */\n  public static get srcPath(): string {\n    return srcPath();\n  }\n\n  /**\n   * Get the app path\n   */\n  public static get appPath(): string {\n    return appPath();\n  }\n\n  /**\n   * Get the storage path\n   */\n  public static get storagePath(): string {\n    return storagePath();\n  }\n\n  /**\n   * Get the uploads path\n   */\n  public static get uploadsPath(): string {\n    return uploadsPath();\n  }\n\n  /**\n   * Get the public path\n   */\n  public static get publicPath(): string {\n    return publicPath();\n  }\n}\n"],"mappings":";;;;;;AAwCA,IAAa,cAAb,MAAyB;;mCAIY,IAAI,KAAK,KAAK,IAAI,IAAI,QAAQ,OAAO,IAAI,GAAI;;;gBAUxD;;;uBAWuB,CAAC;;;sBAMlB;;;2BAKyB,CAAC;;;;;CAKxD,WAAkB,UAAU;EAC1B,OAAO,oBAAoB;CAC7B;;;;CAKA,OAAc,mBAAmB,UAA2B;EAC1D,KAAK,kBAAkB;CACzB;;;;;;CAOA,WAAkB,WAAoB;EACpC,OAAO,KAAK;CACd;;;;;;;;;;;;;;;CAgBA,OAAc,WAAW,UAA8B;EACrD,IAAI,KAAK,UAAU,KAAK,aAAa;GACnC,MAAM,UAAU,KAAK;GACrB,AAAK,KAAK,gBAAgB,UAAU,OAAO;GAE3C;EACF;EAEA,KAAK,cAAc,KAAK,QAAQ;CAClC;;;;;CAMA,OAAc,aAAmC;EAC/C,IAAI,KAAK,UAAU,KAAK,aACtB,OAAO,QAAQ,QAAQ,KAAK,WAAW;EAGzC,OAAO,IAAI,SAAsB,YAAY;GAC3C,KAAK,YAAY,YAAY,QAAQ,OAAO,CAAC;EAC/C,CAAC;CACH;;;;;;;;;CAUA,OAAc,WAAW,SAA4B;EACnD,IAAI,KAAK,QACP;EAGF,KAAK,SAAS;EACd,KAAK,cAAc;EAEnB,MAAM,YAAY,KAAK;EACvB,KAAK,gBAAgB,CAAC;EAEtB,KAAK,MAAM,YAAY,WACrB,AAAK,KAAK,gBAAgB,UAAU,OAAO;CAE/C;;;;;CAMA,aAAqB,gBACnB,UACA,SACe;EACf,IAAI;GACF,MAAM,SAAS,OAAO;EACxB,SAAS,OAAO;GACd,IAAI,MAAM,eAAe,mBAAmB,KAAc;EAC5D;CACF;;;;;;CAOA,WAAkB,iBAA0B;EAC1C,OAAO,KAAK;CACd;;;;;;;;;;;;CAaA,OAAc,WAAW,UAAkC;EACzD,IAAI,KAAK,cAAc;GACrB,AAAK,KAAK,oBAAoB,QAAQ;GAEtC;EACF;EAEA,KAAK,kBAAkB,KAAK,QAAQ;CACtC;;;;;;;;;;CAWA,aAAoB,mBAAkC;EACpD,IAAI,KAAK,cACP;EAGF,KAAK,eAAe;EAEpB,MAAM,YAAY,KAAK,kBAAkB,QAAQ;EACjD,KAAK,oBAAoB,CAAC;EAE1B,KAAK,MAAM,YAAY,WACrB,MAAM,KAAK,oBAAoB,QAAQ;CAE3C;;;;;CAMA,aAAqB,oBAAoB,UAA2C;EAClF,IAAI;GACF,MAAM,SAAS;EACjB,SAAS,OAAO;GACd,IAAI,MAAM,eAAe,qBAAqB,KAAc;EAC9D;CACF;;;;CAKA,WAAkB,SAAiB;EACjC,OAAO,QAAQ,OAAO,IAAI;CAC5B;;;;CAKA,WAAkB,cAA2B;EAC3C,OAAO,YAAY;CACrB;;;;CAKA,OAAc,eAAe,KAAkB;EAC7C,eAAe,GAAG;CACpB;;;;CAKA,WAAkB,eAAwB;EACxC,OAAO,KAAK,gBAAgB;CAC9B;;;;CAKA,WAAkB,gBAAyB;EACzC,OAAO,KAAK,gBAAgB;CAC9B;;;;CAKA,WAAkB,SAAkB;EAClC,OAAO,KAAK,gBAAgB;CAC9B;;;;CAKA,WAAkB,WAAmB;EACnC,OAAO,SAAS;CAClB;;;;CAKA,WAAkB,UAAkB;EAClC,OAAO,QAAQ;CACjB;;;;CAKA,WAAkB,UAAkB;EAClC,OAAO,QAAQ;CACjB;;;;CAKA,WAAkB,cAAsB;EACtC,OAAO,YAAY;CACrB;;;;CAKA,WAAkB,cAAsB;EACtC,OAAO,YAAY;CACrB;;;;CAKA,WAAkB,aAAqB;EACrC,OAAO,WAAW;CACpB;AACF"}

package/esm/application/index.d.mts

@@ -1,3 +1,3 @@
 import { app } from "./app.mjs";
-import { Application } from "./application.mjs";
+import { Application, BootContext, BootListener, ShutdownListener } from "./application.mjs";
 import { AppConfigurations } from "./application-config-types.mjs";

package/esm/cli/commands/dev-server.command.mjs

@@ -19,7 +19,7 @@ const devServerCommand = command({
 		await displayStartupBanner({ environment: "development" });
 	},
 	action: async (data) => {
-		await startDevelopmentServer({
+		startDevelopmentServer({
 			fresh: Boolean(data.options.fresh),
 			generateTypings: data.options.skipTypings ? false : void 0,
 			healthCheckers: data.options.skipHealth ? false : void 0

package/esm/cli/commands/dev-server.command.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"dev-server.command.mjs","names":[],"sources":["../../../../../../../../@warlock.js/core/src/cli/commands/dev-server.command.ts"],"sourcesContent":["import { checkForFrameworkUpdate } from \"../../dev-server/check-for-updates\";\r\nimport { startDevelopmentServer } from \"../../dev-server/start-development-server\";\r\nimport { command } from \"../cli-command\";\r\nimport { displayStartupBanner } from \"../cli-commands.utils\";\r\n\r\nexport const devServerCommand = command({\r\n  name: \"dev\",\r\n  description: \"Start development server (HMR, type-gen, health checks)\",\r\n  persistent: true,\r\n  preload: {\r\n    runtimeStrategy: \"development\",\r\n    config: true, // load all config\r\n    bootstrap: true,\r\n    prestart: true, // load prestart file (if exists)\r\n    // Only the Early lifecycle phase starts here; the Late phase\r\n    // (http, socket) starts after app modules load — see\r\n    // development-server.ts STEP 8.5.\r\n    connectors: true,\r\n  },\r\n  preAction: async () => {\r\n    await displayStartupBanner({ environment: \"development\" });\r\n  },\r\n  action: async (data) => {\r\n    await startDevelopmentServer({\r\n      fresh: Boolean(data.options.fresh),\r\n      // Pass `false` only when the CLI flag is explicitly set; `undefined`\r\n      // lets `warlock.config.ts > devServer.*` defaults apply.\r\n      generateTypings: data.options.skipTypings ? false : undefined,\r\n      healthCheckers: data.options.skipHealth ? false : undefined,\r\n    });\r\n\r\n    // Fire-and-forget: once the server is ready, surface a one-line notice if\r\n    // a newer @warlock.js/core has been published. Fully self-guarded — it\r\n    // never blocks startup nor breaks dev if the registry is unreachable.\r\n    void checkForFrameworkUpdate();\r\n  },\r\n  options: [\r\n    {\r\n      text: \"--fresh, -f\",\r\n      description: \"Delete .warlock/manifest.json before start (force full re-parse from disk)\",\r\n      type: \"boolean\",\r\n    },\r\n    {\r\n      text: \"--skip-typings, -st\",\r\n      description: \"Skip background type generation for this run\",\r\n      type: \"boolean\",\r\n    },\r\n    {\r\n      text: \"--skip-health, -sh\",\r\n      description: \"Skip file health checkers for this run\",\r\n      type: \"boolean\",\r\n    },\r\n  ],\r\n});\r\n"],"mappings":";;;;;;AAKA,MAAa,mBAAmB,QAAQ;CACtC,MAAM;CACN,aAAa;CACb,YAAY;CACZ,SAAS;EACP,iBAAiB;EACjB,QAAQ;EACR,WAAW;EACX,UAAU;EAIV,YAAY;CACd;CACA,WAAW,YAAY;EACrB,MAAM,qBAAqB,EAAE,aAAa,cAAc,CAAC;CAC3D;CACA,QAAQ,OAAO,SAAS;EACtB,MAAM,uBAAuB;GAC3B,OAAO,QAAQ,KAAK,QAAQ,KAAK;GAGjC,iBAAiB,KAAK,QAAQ,cAAc,QAAQ;GACpD,gBAAgB,KAAK,QAAQ,aAAa,QAAQ;EACpD,CAAC;EAKD,AAAK,wBAAwB;CAC/B;CACA,SAAS;EACP;GACE,MAAM;GACN,aAAa;GACb,MAAM;EACR;EACA;GACE,MAAM;GACN,aAAa;GACb,MAAM;EACR;EACA;GACE,MAAM;GACN,aAAa;GACb,MAAM;EACR;CACF;AACF,CAAC"}
+{"version":3,"file":"dev-server.command.mjs","names":[],"sources":["../../../../../../../../@warlock.js/core/src/cli/commands/dev-server.command.ts"],"sourcesContent":["import { checkForFrameworkUpdate } from \"../../dev-server/check-for-updates\";\r\nimport { startDevelopmentServer } from \"../../dev-server/start-development-server\";\r\nimport { command } from \"../cli-command\";\r\nimport { displayStartupBanner } from \"../cli-commands.utils\";\r\n\r\nexport const devServerCommand = command({\r\n  name: \"dev\",\r\n  description: \"Start development server (HMR, type-gen, health checks)\",\r\n  persistent: true,\r\n  preload: {\r\n    runtimeStrategy: \"development\",\r\n    config: true, // load all config\r\n    bootstrap: true,\r\n    prestart: true, // load prestart file (if exists)\r\n    // Only the Early lifecycle phase starts here; the Late phase\r\n    // (http, socket) starts after app modules load — see\r\n    // development-server.ts STEP 8.5.\r\n    connectors: true,\r\n  },\r\n  preAction: async () => {\r\n    await displayStartupBanner({ environment: \"development\" });\r\n  },\r\n  action: async (data) => {\r\n    startDevelopmentServer({\r\n      fresh: Boolean(data.options.fresh),\r\n      // Pass `false` only when the CLI flag is explicitly set; `undefined`\r\n      // lets `warlock.config.ts > devServer.*` defaults apply.\r\n      generateTypings: data.options.skipTypings ? false : undefined,\r\n      healthCheckers: data.options.skipHealth ? false : undefined,\r\n    });\r\n\r\n    // Fire-and-forget: once the server is ready, surface a one-line notice if\r\n    // a newer @warlock.js/core has been published. Fully self-guarded — it\r\n    // never blocks startup nor breaks dev if the registry is unreachable.\r\n    void checkForFrameworkUpdate();\r\n  },\r\n  options: [\r\n    {\r\n      text: \"--fresh, -f\",\r\n      description: \"Delete .warlock/manifest.json before start (force full re-parse from disk)\",\r\n      type: \"boolean\",\r\n    },\r\n    {\r\n      text: \"--skip-typings, -st\",\r\n      description: \"Skip background type generation for this run\",\r\n      type: \"boolean\",\r\n    },\r\n    {\r\n      text: \"--skip-health, -sh\",\r\n      description: \"Skip file health checkers for this run\",\r\n      type: \"boolean\",\r\n    },\r\n  ],\r\n});\r\n"],"mappings":";;;;;;AAKA,MAAa,mBAAmB,QAAQ;CACtC,MAAM;CACN,aAAa;CACb,YAAY;CACZ,SAAS;EACP,iBAAiB;EACjB,QAAQ;EACR,WAAW;EACX,UAAU;EAIV,YAAY;CACd;CACA,WAAW,YAAY;EACrB,MAAM,qBAAqB,EAAE,aAAa,cAAc,CAAC;CAC3D;CACA,QAAQ,OAAO,SAAS;EACtB,uBAAuB;GACrB,OAAO,QAAQ,KAAK,QAAQ,KAAK;GAGjC,iBAAiB,KAAK,QAAQ,cAAc,QAAQ;GACpD,gBAAgB,KAAK,QAAQ,aAAa,QAAQ;EACpD,CAAC;EAKD,AAAK,wBAAwB;CAC/B;CACA,SAAS;EACP;GACE,MAAM;GACN,aAAa;GACb,MAAM;EACR;EACA;GACE,MAAM;GACN,aAAa;GACb,MAAM;EACR;EACA;GACE,MAAM;GACN,aAAa;GACb,MAAM;EACR;CACF;AACF,CAAC"}

package/esm/cli/commands/generate/templates/stubs.mjs

@@ -174,7 +174,7 @@ function crudModelStub(moduleName) {
 	const singular = moduleName.singular;
 	const plural = moduleName.plural;
 	return `import { Model, RegisterModel } from "@warlock.js/cascade";
-import { type Infer, v } from "@warlock.js/core";
+import { type Infer, v } from "@warlock.js/seal";
 import { ${singular.pascal}Resource } from "app/${plural.kebab}/resources/${singular.kebab}.resource";
 
 export const ${singular.camel}Schema = v.object({
@@ -442,9 +442,8 @@ export type ${name.pascal}Schema = Infer<typeof ${name.camel}Schema>;
 */
 function modelStub(name, options = {}) {
 	const { tableName = `${name.plural.snake}`, withResource } = options;
-	return `import { Model } from "@warlock.js/core";
-import type { StrictMode } from "@warlock.js/cascade";
-import { v, type Infer } from "@warlock.js/core";
+	return `import { Model, type StrictMode } from "@warlock.js/cascade";
+import { v, type Infer } from "@warlock.js/seal";
 ${withResource ? `import { ${name.singular.pascal}Resource } from "../../resources/${name.singular.kebab}.resource";` : ""}
 
 const ${name.singular.camel}Schema = v.object({