@warlock.js/core 5.30.0 → 5.32.0

package/esm/utils/clock.d.mts

@@ -0,0 +1,35 @@
+//#region ../../packages/core/src/utils/clock.d.ts
+/**
+ * The application clock.
+ *
+ * Read the current time through `clock` instead of `new Date()` / `Date.now()`
+ * where a test needs to control it: tokens that expire, "created 5 minutes
+ * ago", scheduled cut-offs. In the test environment the test kit swaps the
+ * source for a frozen one (`clockFake` from `@warlock.js/core/tests`); in
+ * every other environment it is the system clock.
+ *
+ * Only code that reads `clock` is affected — the global `Date` and timers are
+ * never patched, so a fake clock cannot stall `setTimeout` or a driver.
+ *
+ * @example
+ * import { clock } from "@warlock.js/core";
+ *
+ * const expiresAt = new Date(clock.timestamp() + 15 * 60_000);
+ */
+export type ClockSource = {
+  /** Milliseconds since the Unix epoch. */
+  now(): number;
+};
+export declare const clock: {
+  /** The current time as a `Date`. */
+  now(): Date;
+  /** The current time in milliseconds since the Unix epoch. */
+  timestamp(): number;
+};
+/**
+ * Replace the clock's source, or restore the system clock with `undefined`.
+ * The test kit's `clockFake` is built on this.
+ */
+export declare function setClockSource(next: ClockSource | undefined): void;
+//#endregion
+//# sourceMappingURL=clock.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"clock.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/utils/clock.ts"],"mappings":";;;;;;;;;;;;;;;;;;YAiBY;;EAEV;;qBAeW;;EAEX,OAAO;;EAKP;;;;;;wBASc,eAAe,MAAM"}

package/esm/utils/clock.mjs

@@ -0,0 +1,27 @@
+//#region ../../packages/core/src/utils/clock.ts
+const systemClock = { now: () => Date.now() };
+const SOURCE_KEY = Symbol.for("warlock.core.clockSource");
+function source() {
+	return globalThis[SOURCE_KEY] ?? systemClock;
+}
+const clock = {
+	/** The current time as a `Date`. */
+	now() {
+		return new Date(source().now());
+	},
+	/** The current time in milliseconds since the Unix epoch. */
+	timestamp() {
+		return source().now();
+	}
+};
+/**
+* Replace the clock's source, or restore the system clock with `undefined`.
+* The test kit's `clockFake` is built on this.
+*/
+function setClockSource(next) {
+	globalThis[SOURCE_KEY] = next;
+}
+
+//#endregion
+export { clock, setClockSource };
+//# sourceMappingURL=clock.mjs.map

package/esm/utils/clock.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"clock.mjs","names":[],"sources":["../../../../../../../../packages/core/src/utils/clock.ts"],"sourcesContent":["/**\n * The application clock.\n *\n * Read the current time through `clock` instead of `new Date()` / `Date.now()`\n * where a test needs to control it: tokens that expire, \"created 5 minutes\n * ago\", scheduled cut-offs. In the test environment the test kit swaps the\n * source for a frozen one (`clockFake` from `@warlock.js/core/tests`); in\n * every other environment it is the system clock.\n *\n * Only code that reads `clock` is affected — the global `Date` and timers are\n * never patched, so a fake clock cannot stall `setTimeout` or a driver.\n *\n * @example\n * import { clock } from \"@warlock.js/core\";\n *\n * const expiresAt = new Date(clock.timestamp() + 15 * 60_000);\n */\nexport type ClockSource = {\n  /** Milliseconds since the Unix epoch. */\n  now(): number;\n};\n\nconst systemClock: ClockSource = { now: () => Date.now() };\n\n// On `globalThis` so the framework loaded twice in one Vitest worker (native\n// and through vite-node) still reads one source.\nconst SOURCE_KEY = Symbol.for(\"warlock.core.clockSource\");\n\ntype SourceHolder = { [SOURCE_KEY]?: ClockSource };\n\nfunction source(): ClockSource {\n  return (globalThis as SourceHolder)[SOURCE_KEY] ?? systemClock;\n}\n\nexport const clock = {\n  /** The current time as a `Date`. */\n  now(): Date {\n    return new Date(source().now());\n  },\n\n  /** The current time in milliseconds since the Unix epoch. */\n  timestamp(): number {\n    return source().now();\n  },\n};\n\n/**\n * Replace the clock's source, or restore the system clock with `undefined`.\n * The test kit's `clockFake` is built on this.\n */\nexport function setClockSource(next: ClockSource | undefined): void {\n  (globalThis as SourceHolder)[SOURCE_KEY] = next;\n}\n"],"mappings":";AAsBA,MAAM,cAA2B,EAAE,WAAW,KAAK,IAAI,EAAE;AAIzD,MAAM,aAAa,OAAO,IAAI,0BAA0B;AAIxD,SAAS,SAAsB;CAC7B,OAAQ,WAA4B,eAAe;AACrD;AAEA,MAAa,QAAQ;;CAEnB,MAAY;EACV,OAAO,IAAI,KAAK,OAAO,CAAC,CAAC,IAAI,CAAC;CAChC;;CAGA,YAAoB;EAClB,OAAO,OAAO,CAAC,CAAC,IAAI;CACtB;AACF;;;;;AAMA,SAAgB,eAAe,MAAqC;CAClE,AAAC,WAA4B,cAAc;AAC7C"}

package/esm/utils/database-log.d.mts

@@ -1,15 +1,15 @@
 import { DatabaseLogModel } from "../database/models/database-log/database-log.mjs";
+import "../database/models/database-log/index.mjs";
 import { ChildModel, Model } from "@warlock.js/cascade";
 import { BasicLogConfigurations, LogChannel, LogContract, LoggingData } from "@warlock.js/logger";
-
 //#region ../../packages/core/src/utils/database-log.d.ts
-type DatabaseLogOptions = BasicLogConfigurations & {
+export type DatabaseLogOptions = BasicLogConfigurations & {
   /**
    * Model to use for logging
    */
   model?: typeof DatabaseLogModel;
 };
-declare class DatabaseLog extends LogChannel<DatabaseLogOptions> implements LogContract {
+export declare class DatabaseLog extends LogChannel<DatabaseLogOptions> implements LogContract {
   /**
    * {@inheritdoc}
    */
@@ -24,5 +24,4 @@ declare class DatabaseLog extends LogChannel<DatabaseLogOptions> implements LogC
   log(log: LoggingData): Promise<void>;
 }
 //#endregion
-export { DatabaseLog, DatabaseLogOptions };
 //# sourceMappingURL=database-log.d.mts.map

package/esm/utils/database-log.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"database-log.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/utils/database-log.ts"],"mappings":";;;;;KAKY,kBAAA,GAAqB,sBAAA;;AAAjC;;EAIE,KAAA,UAAe,gBAAgB;AAAA;AAAA,cAGpB,WAAA,SAAoB,UAAA,CAAW,kBAAA,aAA+B,WAAA;EAHzE;;;EAOO,IAAA;EAJI;;;EAAA,IASA,KAAA,IAAS,UAAA,CAAW,KAAA;EAAA;;;EAOlB,GAAA,CAAI,GAAA,EAAK,WAAA,GAAW,OAAA;AAAA"}
+{"version":3,"file":"database-log.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/utils/database-log.ts"],"mappings":";;;;;YAKY,qBAAqB;;;;EAI/B,eAAe;;qBAGJ,oBAAoB,WAAW,+BAA+B;;;;EAIlE;;;;MAKI,SAAS,WAAW;;;;EAOlB,IAAI,KAAK,cAAW"}

package/esm/utils/environment.d.mts

@@ -1,12 +1,11 @@
 //#region ../../packages/core/src/utils/environment.d.ts
-type Environment = "development" | "production" | "test";
+export type Environment = "development" | "production" | "test";
 /**
  * How the framework hosts your code — the dev server (watcher + HMR) or the
  * bundled production output. A separate axis from {@link Environment}.
  */
-type RuntimeStrategy = "production" | "development";
-declare function environment(): Environment;
-declare function setEnvironment(env: Environment): void;
+export type RuntimeStrategy = "production" | "development";
+export declare function environment(): Environment;
+export declare function setEnvironment(env: Environment): void;
 //#endregion
-export { Environment, RuntimeStrategy, environment, setEnvironment };
 //# sourceMappingURL=environment.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"environment.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/utils/environment.ts"],"mappings":";KAAY,WAAA;AAAZ;;;;AAAA,KAMY,eAAA;AAAA,iBAEI,WAAA,IAAe,WAAW;AAAA,iBAI1B,cAAA,CAAe,GAAgB,EAAX,WAAW"}
+{"version":3,"file":"environment.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/utils/environment.ts"],"mappings":";YAAY;;;;;YAMA;wBAEI,eAAe;wBAIf,eAAe,KAAK"}

package/esm/utils/framework-vesion.mjs

@@ -11,7 +11,7 @@ let cachedVersion = null;
 */
 async function getWarlockVersion() {
 	if (cachedVersion) return cachedVersion;
-	const version = (await getJsonFileAsync(path.join(import.meta.dirname, "./../../package.json"))).version.replace(/\^|\~/g, "");
+	const version = (await getJsonFileAsync(path.join(import.meta.dirname, "./../../package.json"))).version.replace(/\^|~/g, "");
 	cachedVersion = version;
 	return version;
 }

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

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

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

@@ -1,5 +1,5 @@
 //#region ../../packages/core/src/utils/get-localized.d.ts
-type LocalizedObject = {
+export type LocalizedObject = {
   localeCode: string;
   value: any;
 };
@@ -7,7 +7,6 @@ type LocalizedObject = {
  * Get localized value based on the given locale code
  * If the locale code is not given and the function is called within a request context, it will get the current locale code
  */
-declare function getLocalized(values: LocalizedObject[], localeCode?: string, key?: string): any;
+export declare function getLocalized(values: LocalizedObject[], localeCode?: string, key?: string): any;
 //#endregion
-export { LocalizedObject, getLocalized };
 //# sourceMappingURL=get-localized.d.mts.map

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

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

package/esm/utils/ids.d.mts

@@ -0,0 +1,35 @@
+//#region ../../packages/core/src/utils/ids.d.ts
+/**
+ * Identifier generation the test kit can make deterministic.
+ *
+ * Generate ids through `ids` instead of calling `crypto.randomUUID()` directly
+ * where a test needs to predict them (a snapshot, a file name, a link). In the
+ * test environment `idsFake` from `@warlock.js/core/tests` replaces the source
+ * with a numbered sequence; in every other environment the values come from
+ * `node:crypto`.
+ *
+ * @example
+ * import { ids } from "@warlock.js/core";
+ *
+ * const reference = ids.uuid();
+ * const resetToken = ids.token(48);
+ */
+export type IdsSource = {
+  /** A version 4 UUID. */
+  uuid(): string;
+  /** A URL-safe random string of exactly `length` characters. */
+  token(length: number): string;
+};
+export declare const ids: {
+  /** A version 4 UUID. */
+  uuid(): string;
+  /** A URL-safe random string, 32 characters unless `length` says otherwise. */
+  token(length?: number): string;
+};
+/**
+ * Replace the id source, or restore `node:crypto` with `undefined`.
+ * The test kit's `idsFake` is built on this.
+ */
+export declare function setIdsSource(next: IdsSource | undefined): void;
+//#endregion
+//# sourceMappingURL=ids.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ids.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/utils/ids.ts"],"mappings":";;;;;;;;;;;;;;;;YAiBY;;EAEV;;EAEA,MAAM;;qBAmBK;;EAEX;;EAKA,MAAK;;;;;;wBAaS,aAAa,MAAM"}

package/esm/utils/ids.mjs

@@ -0,0 +1,33 @@
+import { randomBytes, randomUUID } from "node:crypto";
+
+//#region ../../packages/core/src/utils/ids.ts
+const cryptoIds = {
+	uuid: () => randomUUID(),
+	token: (length) => randomBytes(Math.ceil(length * 3 / 4) + 1).toString("base64url").slice(0, length)
+};
+const SOURCE_KEY = Symbol.for("warlock.core.idsSource");
+function source() {
+	return globalThis[SOURCE_KEY] ?? cryptoIds;
+}
+const ids = {
+	/** A version 4 UUID. */
+	uuid() {
+		return source().uuid();
+	},
+	/** A URL-safe random string, 32 characters unless `length` says otherwise. */
+	token(length = 32) {
+		if (!Number.isInteger(length) || length < 1) throw new RangeError(`ids.token(length) needs a positive integer, got ${String(length)}.`);
+		return source().token(length);
+	}
+};
+/**
+* Replace the id source, or restore `node:crypto` with `undefined`.
+* The test kit's `idsFake` is built on this.
+*/
+function setIdsSource(next) {
+	globalThis[SOURCE_KEY] = next;
+}
+
+//#endregion
+export { ids, setIdsSource };
+//# sourceMappingURL=ids.mjs.map

package/esm/utils/ids.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ids.mjs","names":[],"sources":["../../../../../../../../packages/core/src/utils/ids.ts"],"sourcesContent":["import { randomBytes, randomUUID } from \"node:crypto\";\n\n/**\n * Identifier generation the test kit can make deterministic.\n *\n * Generate ids through `ids` instead of calling `crypto.randomUUID()` directly\n * where a test needs to predict them (a snapshot, a file name, a link). In the\n * test environment `idsFake` from `@warlock.js/core/tests` replaces the source\n * with a numbered sequence; in every other environment the values come from\n * `node:crypto`.\n *\n * @example\n * import { ids } from \"@warlock.js/core\";\n *\n * const reference = ids.uuid();\n * const resetToken = ids.token(48);\n */\nexport type IdsSource = {\n  /** A version 4 UUID. */\n  uuid(): string;\n  /** A URL-safe random string of exactly `length` characters. */\n  token(length: number): string;\n};\n\nconst cryptoIds: IdsSource = {\n  uuid: () => randomUUID(),\n  token: (length) =>\n    randomBytes(Math.ceil((length * 3) / 4) + 1)\n      .toString(\"base64url\")\n      .slice(0, length),\n};\n\nconst SOURCE_KEY = Symbol.for(\"warlock.core.idsSource\");\n\ntype SourceHolder = { [SOURCE_KEY]?: IdsSource };\n\nfunction source(): IdsSource {\n  return (globalThis as SourceHolder)[SOURCE_KEY] ?? cryptoIds;\n}\n\nexport const ids = {\n  /** A version 4 UUID. */\n  uuid(): string {\n    return source().uuid();\n  },\n\n  /** A URL-safe random string, 32 characters unless `length` says otherwise. */\n  token(length = 32): string {\n    if (!Number.isInteger(length) || length < 1) {\n      throw new RangeError(`ids.token(length) needs a positive integer, got ${String(length)}.`);\n    }\n\n    return source().token(length);\n  },\n};\n\n/**\n * Replace the id source, or restore `node:crypto` with `undefined`.\n * The test kit's `idsFake` is built on this.\n */\nexport function setIdsSource(next: IdsSource | undefined): void {\n  (globalThis as SourceHolder)[SOURCE_KEY] = next;\n}\n"],"mappings":";;;AAwBA,MAAM,YAAuB;CAC3B,YAAY,WAAW;CACvB,QAAQ,WACN,YAAY,KAAK,KAAM,SAAS,IAAK,CAAC,IAAI,CAAC,CAAC,CACzC,SAAS,WAAW,CAAC,CACrB,MAAM,GAAG,MAAM;AACtB;AAEA,MAAM,aAAa,OAAO,IAAI,wBAAwB;AAItD,SAAS,SAAoB;CAC3B,OAAQ,WAA4B,eAAe;AACrD;AAEA,MAAa,MAAM;;CAEjB,OAAe;EACb,OAAO,OAAO,CAAC,CAAC,KAAK;CACvB;;CAGA,MAAM,SAAS,IAAY;EACzB,IAAI,CAAC,OAAO,UAAU,MAAM,KAAK,SAAS,GACxC,MAAM,IAAI,WAAW,mDAAmD,OAAO,MAAM,EAAE,EAAE;EAG3F,OAAO,OAAO,CAAC,CAAC,MAAM,MAAM;CAC9B;AACF;;;;;AAMA,SAAgB,aAAa,MAAmC;CAC9D,AAAC,WAA4B,cAAc;AAC7C"}

package/esm/utils/index.d.mts

@@ -1,14 +1,18 @@
 import { LocalizedObject, getLocalized } from "./get-localized.mjs";
 import { Environment, RuntimeStrategy, environment, setEnvironment } from "./environment.mjs";
 import { appLog } from "./app-log.mjs";
+import { ClockSource, clock, setClockSource } from "./clock.mjs";
 import { DatabaseLog, DatabaseLogOptions } from "./database-log.mjs";
+import { IdsSource, ids, setIdsSource } from "./ids.mjs";
 import { Path } from "./normalized-path.mjs";
 import { fetchLatestVersion } from "./npm-registry.mjs";
 import { appPath, cachePath, configPath, logsPath, paths, publicPath, rootPath, sanitizePath, srcPath, storagePath, tempPath, uploadsPath, warlockPath } from "./paths.mjs";
 import { promiseAllObject } from "./promise-all-object.mjs";
 import { Queue } from "./queue.mjs";
+import { JavaScriptRuntime, JavaScriptRuntimeName, SUPPORTED_RUNTIMES_DOCS_URL, assertNodeOnlyCommand, describeJavaScriptRuntime, detectJavaScriptRuntime, nodeOnlyCommandError, unverifiedBuildRuntimeNotice } from "./runtime.mjs";
 import { sleep } from "./sleep.mjs";
 import { sluggable } from "./sluggable.mjs";
 import { toJson } from "./to-json.mjs";
 import { assetsUrl, publicUrl, setBaseUrl, uploadsUrl, url } from "./urls.mjs";
-import { isNewerVersion } from "./version-compare.mjs";
+import { isNewerVersion } from "./version-compare.mjs";
+export { ClockSource, DatabaseLog, DatabaseLogOptions, Environment, IdsSource, JavaScriptRuntime, JavaScriptRuntimeName, LocalizedObject, Path, Queue, RuntimeStrategy, SUPPORTED_RUNTIMES_DOCS_URL, appLog, appPath, assertNodeOnlyCommand, assetsUrl, cachePath, clock, configPath, describeJavaScriptRuntime, detectJavaScriptRuntime, environment, fetchLatestVersion, getLocalized, ids, isNewerVersion, logsPath, nodeOnlyCommandError, paths, promiseAllObject, publicPath, publicUrl, rootPath, sanitizePath, setBaseUrl, setClockSource, setEnvironment, setIdsSource, sleep, sluggable, srcPath, storagePath, tempPath, toJson, unverifiedBuildRuntimeNotice, uploadsPath, uploadsUrl, url, warlockPath };

package/esm/utils/index.mjs

@@ -1,16 +1,19 @@
 import { appLog } from "./app-log.mjs";
+import { clock, setClockSource } from "./clock.mjs";
 import { DatabaseLog } from "./database-log.mjs";
 import { environment, setEnvironment } from "./environment.mjs";
 import { getLocalized } from "./get-localized.mjs";
+import { ids, setIdsSource } from "./ids.mjs";
 import { Path } from "./normalized-path.mjs";
 import { fetchLatestVersion } from "./npm-registry.mjs";
 import { appPath, cachePath, configPath, logsPath, paths, publicPath, rootPath, sanitizePath, srcPath, storagePath, tempPath, uploadsPath, warlockPath } from "./paths.mjs";
 import { promiseAllObject } from "./promise-all-object.mjs";
 import { Queue } from "./queue.mjs";
+import { SUPPORTED_RUNTIMES_DOCS_URL, assertNodeOnlyCommand, describeJavaScriptRuntime, detectJavaScriptRuntime, nodeOnlyCommandError, unverifiedBuildRuntimeNotice } from "./runtime.mjs";
 import { sleep } from "./sleep.mjs";
 import { sluggable } from "./sluggable.mjs";
 import { toJson } from "./to-json.mjs";
 import { assetsUrl, publicUrl, setBaseUrl, uploadsUrl, url } from "./urls.mjs";
 import { isNewerVersion } from "./version-compare.mjs";
 
-export {  };
+export { DatabaseLog, Path, Queue, SUPPORTED_RUNTIMES_DOCS_URL, appLog, appPath, assertNodeOnlyCommand, assetsUrl, cachePath, clock, configPath, describeJavaScriptRuntime, detectJavaScriptRuntime, environment, fetchLatestVersion, getLocalized, ids, isNewerVersion, logsPath, nodeOnlyCommandError, paths, promiseAllObject, publicPath, publicUrl, rootPath, sanitizePath, setBaseUrl, setClockSource, setEnvironment, setIdsSource, sleep, sluggable, srcPath, storagePath, tempPath, toJson, unverifiedBuildRuntimeNotice, uploadsPath, uploadsUrl, url, warlockPath };

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

@@ -12,7 +12,7 @@
  * directory into the production module graph. The code was never dev-only —
  * only its location was.
  */
-declare class Path {
+export declare class Path {
   /**
    * Convert the given absolute path to a relative path
    */
@@ -53,5 +53,4 @@ declare class Path {
   static extname(filePath: string): string;
 }
 //#endregion
-export { Path };
 //# sourceMappingURL=normalized-path.d.mts.map

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

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

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

@@ -18,7 +18,6 @@
  * @param packageName Fully-qualified npm name, e.g. `@warlock.js/core`.
  * @param timeoutMs   Abort budget in milliseconds (defaults to 30_000 -> 30 seconds).
  */
-declare function fetchLatestVersion(packageName: string, timeoutMs?: number): Promise<string | undefined>;
+export declare function fetchLatestVersion(packageName: string, timeoutMs?: number): Promise<string | undefined>;
 //#endregion
-export { fetchLatestVersion };
 //# sourceMappingURL=npm-registry.d.mts.map

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

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

package/esm/utils/paths.d.mts

@@ -2,58 +2,58 @@
 /**
  * Get root path or join the given paths to the root path
  */
-declare function rootPath(...paths: string[]): string;
+export declare function rootPath(...paths: string[]): string;
 /**
  * Get src directory path or join the given paths to the src directory path
  */
-declare function srcPath(...paths: string[]): string;
+export declare function srcPath(...paths: string[]): string;
 /**
  * Get the absolute path to the storage folder to the given path
  *
  * If no path is given, it will return the absolute path to the storage folder
  */
-declare function storagePath(relativePath?: string): string;
+export declare function storagePath(relativePath?: string): string;
 /**
  * Get the absolute path to the uploads folder to the given path
  *
  * If no path is given, it will return the absolute path to the uploads folder
  */
-declare function uploadsPath(relativePath?: string): any;
+export declare function uploadsPath(relativePath?: string): any;
 /**
  * Get the absolute path to the public folder to the given path
  *
  * If no path is given, it will return the absolute path to the public folder
  */
-declare function publicPath(relativePath?: string): string;
+export declare function publicPath(relativePath?: string): string;
 /**
  * Get the absolute path to the cache folder to the given path
  *
  * If no path is given, it will return the absolute path to the cache folder
  */
-declare function cachePath(relativePath?: string): string;
+export declare function cachePath(relativePath?: string): string;
 /**
  * App path
  */
-declare function appPath(relativePath?: string): string;
+export declare function appPath(relativePath?: string): string;
 /**
  * Get logs directory path
  */
-declare function logsPath(relativePath?: string): string;
+export declare function logsPath(relativePath?: string): string;
 /**
  * Get a temp path
  */
-declare function tempPath(relativePath?: string): string;
-declare function sanitizePath(filePath: string): string;
+export declare function tempPath(relativePath?: string): string;
+export declare function sanitizePath(filePath: string): string;
 /**
  * Warlock path
  * PLEASE DO NOT add any files in this directory as it may be deleted
  */
-declare function warlockPath(...path: string[]): string;
+export declare function warlockPath(...path: string[]): string;
 /**
  * Get config directory path
  */
-declare function configPath(...path: string[]): string;
-declare const paths: {
+export declare function configPath(...path: string[]): string;
+export declare const paths: {
   root: typeof rootPath;
   src: typeof srcPath;
   storage: typeof storagePath;
@@ -68,5 +68,4 @@ declare const paths: {
   sanitize: typeof sanitizePath;
 };
 //#endregion
-export { appPath, cachePath, configPath, logsPath, paths, publicPath, rootPath, sanitizePath, srcPath, storagePath, tempPath, uploadsPath, warlockPath };
 //# sourceMappingURL=paths.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"paths.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/utils/paths.ts"],"mappings":";;AAMA;;iBAAgB,QAAA,IAAY,KAAK;;AAAA;AAOjC;iBAAgB,OAAA,IAAW,KAAK;;;AAAA;AAShC;;iBAAgB,WAAA,CAAY,YAAiB;;AAAA;AAS7C;;;iBAAgB,WAAA,CAAY,YAAiB;AAAA;AAgB7C;;;;AAhB6C,iBAgB7B,UAAA,CAAW,YAAiB;AAS5C;;;;AAA2C;AAA3C,iBAAgB,SAAA,CAAU,YAAiB;;;;iBAO3B,OAAA,CAAQ,YAAiB;AAOzC;;;AAAA,iBAAgB,QAAA,CAAS,YAAiB;AAAA;AAO1C;;AAP0C,iBAO1B,QAAA,CAAS,YAAiB;AAAA,iBAS1B,YAAA,CAAa,QAAgB;AATH;AAS1C;;;AAT0C,iBAiB1B,WAAA,IAAe,IAAI;AARU;AAQ7C;;AAR6C,iBAe7B,UAAA,IAAc,IAAI;AAAA,cAIrB,KAAA"}
+{"version":3,"file":"paths.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/utils/paths.ts"],"mappings":";;;;wBAMgB,YAAY;;;;wBAOZ,WAAW;;;;;;wBASX,YAAY;;;;;;wBASZ,YAAY;;;;;;wBAgBZ,WAAW;;;;;;wBASX,UAAU;;;;wBAOV,QAAQ;;;;wBAOR,SAAS;;;;wBAOT,SAAS;wBAST,aAAa;;;;;wBAQb,eAAe;;;;wBAOf,cAAc;qBAIjB;EACX,aAAI;EACJ,YAAG;EACH,gBAAO;EACP,aAAI;EACJ,gBAAO;EACP,eAAM;EACN,cAAK;EACL,YAAG;EACH,aAAI;EACJ,gBAAO;EACP,eAAM;EACN,iBAAQ"}

package/esm/utils/paths.mjs

@@ -1,4 +1,4 @@
-import config from "@mongez/config";
+import baseConfig from "@mongez/config";
 import path from "path";
 
 //#region ../../packages/core/src/utils/paths.ts
@@ -28,7 +28,7 @@ function storagePath(relativePath = "") {
 * If no path is given, it will return the absolute path to the uploads folder
 */
 function uploadsPath(relativePath = "") {
-	const configPath = config.get("uploads.root");
+	const configPath = baseConfig.get("uploads.root");
 	if (!configPath) return rootPath("storage", "uploads", relativePath);
 	return typeof configPath === "function" ? configPath(relativePath) : path.resolve(configPath, relativePath);
 }

package/esm/utils/paths.mjs.map

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

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

@@ -3,7 +3,6 @@
  * Resolve all of the given promises in the object and return the results as an object.
  * This is more convenient than using `Promise.all` and then mapping the results back to the keys.
  */
-declare function promiseAllObject<T extends Record<string, Promise<any>>>(promises: T): Promise<{ [K in keyof T]: T[K] extends Promise<infer U> ? U : never }>;
+export declare function promiseAllObject<T extends Record<string, Promise<any>>>(promises: T): Promise<{ [K in keyof T]: T[K] extends Promise<infer U> ? U : never; }>;
 //#endregion
-export { promiseAllObject };
 //# sourceMappingURL=promise-all-object.d.mts.map

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

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

package/esm/utils/queue.d.mts

@@ -4,7 +4,7 @@
  * Allows enqueuing values and executing a function when the queue reaches a certain size or after a specified interval.
  * Supports both parallel and sequential execution of the queued operations.
  */
-declare class Queue<T> {
+export declare class Queue<T> {
   /** The items currently in the queue. */
   private items;
   /** The maximum size of the queue before triggering execution. */
@@ -50,5 +50,4 @@ declare class Queue<T> {
   private execute;
 }
 //#endregion
-export { Queue };
 //# sourceMappingURL=queue.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"queue.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/utils/queue.ts"],"mappings":";;AAKA;;;;cAAa,KAAA;EA0DU;EAAA,QAxDb,KAAA;EAwDc;EAAA,iBArDL,OAAA;EAHT;EAAA,iBAMS,QAAA;EAAA;EAAA,iBAGA,SAAA;EAGT;EAAA,QAAA,KAAA;EAMS;EAAA,iBAHA,iBAAA;EAST;EAAA,iBANS,SAAA;EAiBI;EAAA,iBAdJ,OAAA;EAcY;EAAA,QAXrB,WAAA;EAYN;;;;;;;;cADA,SAAA,GAAY,KAAA,EAAO,CAAA,OAAQ,OAAA,QAC3B,iBAAA,YACA,YAAA,WACA,SAAA,WACA,OAAA,WACA,OAAA,IAAU,KAAA;EA8BJ;;;AAaa;;;EA3Bd,OAAA,CAAQ,IAAA,EAAM,CAAA;;;;UAcb,UAAA;;;;;UAaM,OAAA;AAAA"}
+{"version":3,"file":"queue.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/utils/queue.ts"],"mappings":";;;;;;qBAKa,MAAM;;UAET;;mBAGS;;mBAGA;;mBAGA;;UAGT;;mBAGS;;mBAGA;;mBAGA;;UAGT;;;;;;;;;EAUR,YACE,YAAY,OAAO,QAAQ,eAC3B,6BACA,uBACA,oBACA,kBACA,WAAU;;;;;;;EAgBL,QAAQ,MAAM;;;;UAcb;;;;;UAaM"}

package/esm/utils/runtime.d.mts

@@ -0,0 +1,60 @@
+//#region ../../packages/core/src/utils/runtime.d.ts
+/**
+ * Which JavaScript runtime is executing this process, and what that means for
+ * the CLI commands that only work on one of them.
+ *
+ * Bun and Deno both run Node programs through their Node compatibility layers,
+ * and both announce themselves the same way: they keep `process.versions.node`
+ * (the Node version they emulate) and add their own entry —
+ * `process.versions.bun` (Bun's documented check,
+ * https://bun.sh/guides/util/detect-bun) and `process.versions.deno`
+ * (observed on Deno 2.9.7, the version the runtime CI job pins). Reading those
+ * entries is therefore the one check that works from inside all three
+ * runtimes without touching a runtime-specific global.
+ */
+/** The runtimes Warlock knows how to name. */
+export type JavaScriptRuntimeName = "node" | "bun" | "deno";
+export type JavaScriptRuntime = {
+  /** Which runtime is executing this process. */
+  type: JavaScriptRuntimeName;
+  /** That runtime's own version (for Bun and Deno, not the Node version they emulate). */
+  version: string;
+};
+/** Where the supported-runtimes matrix is documented. */
+export declare const SUPPORTED_RUNTIMES_DOCS_URL = "https://warlock.js.org/v/latest/core/digging-deeper/supported-runtimes/";
+/**
+ * Detect the runtime executing this process.
+ *
+ * @param versions the `process.versions` to read; injectable for tests.
+ */
+export declare function detectJavaScriptRuntime(versions?: NodeJS.ProcessVersions): JavaScriptRuntime;
+/** `"Bun 1.4.3"`, `"Deno 2.9.7"`, `"Node.js 22.15.0"`. */
+export declare function describeJavaScriptRuntime(runtime: JavaScriptRuntime): string;
+/**
+ * The error a Node-only CLI command prints when it is started on Bun or Deno,
+ * or `undefined` when the runtime is Node and the command may run.
+ *
+ * Only `warlock dev` is Node-only today: it compiles TypeScript and reloads
+ * modules through Node's module customization hooks, which Bun does not
+ * provide and Deno provides only partially. The production build runs anywhere
+ * the compatibility layers reach, so the message points there.
+ */
+export declare function nodeOnlyCommandError(commandName: string, runtime?: JavaScriptRuntime): string | undefined;
+/**
+ * Stop a Node-only command before it does any work when it runs on Bun or Deno.
+ *
+ * Exits with code 1 after printing {@link nodeOnlyCommandError} on stderr; a
+ * no-op on Node.
+ */
+export declare function assertNodeOnlyCommand(commandName: string, runtime?: JavaScriptRuntime): void;
+/**
+ * The note `warlock build` prints when it runs on Bun or Deno, or `undefined`
+ * on Node.
+ *
+ * Not an error: the build is plain esbuild and Vite work that the
+ * compatibility layers handle, but only the Node build is verified in CI, so
+ * the user is told which part of the pipeline is supported where.
+ */
+export declare function unverifiedBuildRuntimeNotice(runtime?: JavaScriptRuntime): string | undefined;
+//#endregion
+//# sourceMappingURL=runtime.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/utils/runtime.ts"],"mappings":";;;;;;;;;;;;;;;YAeY;YAEA;;EAEV,MAAM;;EAEN;;;qBAIW;;;;;;wBAcG,wBACd,WAAU,OAAO,kBAChB;;wBAiBa,0BAA0B,SAAS;;;;;;;;;;wBAanC,qBACd,qBACA,UAAS;;;;;;;wBAsBK,sBACd,qBACA,UAAS;;;;;;;;;wBAoBK,6BACd,UAAS"}