@carbonenginejs/runtime-resource 0.9.2 → 0.11.0

package/NOTICE

@@ -3,8 +3,9 @@ carbonenginejs/runtime-resource
 
 Copyright (c) 2026 CarbonEngineJS contributors.
 
-This package owns CarbonEngineJS resource lifecycle, format selection, and the
-non-shader format implementations listed under `format-notices/`.
+This package owns CarbonEngineJS resource lifecycle, format selection,
+canonical GPU-free shader/reflection models, and the non-shader format
+implementations listed under `format-notices/`.
 
 CarbonEngine source material, format names, class names, and schema semantics
 remain copyright their original CarbonEngine authors. Fenris Creations

package/README.md

@@ -4,10 +4,11 @@ CarbonEngineJS resource lifecycle, cache, format selection, source, and object
 loading contracts — the GPU-free resource layer.
 
 Use this package when you need Carbon-shaped resource loading (`res:/` paths,
-requirement/emit selection, `Ready()`/`GetObject()`) or one of the non-shader
-format readers, without choosing a GPU backend. It sits between source
-adapters and the engine packages that realize prepared resources. It does not
-own WebGL/WebGPU realization, device budgets, or shader formats.
+requirement/emit selection, `Ready()`/`GetObject()`), canonical GPU-free shader
+reflection, or one of the bundled format readers without choosing a GPU
+backend. It sits between format/resource providers and the engines that
+realize prepared resources. It owns neither WebGL/WebGPU realization nor the
+standalone shader parser/compiler packages.
 
 ## Install
 
@@ -21,11 +22,17 @@ Concrete formats are explicit tree-shakeable subpaths, never imported by the
 package root:
 
 ```js
-import { CjsResMan } from "@carbonenginejs/runtime-resource";
+import {
+  CjsResMan,
+  CjsResManFetchProvider
+} from "@carbonenginejs/runtime-resource";
 import { CjsMp4Format } from "@carbonenginejs/runtime-resource/formats/mp4";
 
 const resMan = new CjsResMan().Register({
-  source,
+  paths: {
+    res: "https://cdn.example.invalid/resources/"
+  },
+  source: new CjsResManFetchProvider(),
   formats: [ CjsMp4Format ]
 });
 
@@ -33,11 +40,45 @@ const resource = resMan.GetResource("res:/video/intro.mp4");
 const video = await resource.Ready();
 ```
 
+Browser consumers use worker-backed fetch and declared worker-safe format
+readers by default, with deterministic main-thread fallback; see
+[browser worker execution](docs/reference/workers.md).
+
+Raw audio resource ownership is available from an explicit subpath:
+
+```js
+import {
+  CjsAudioBufferRes,
+  CjsAudioRes
+} from "@carbonenginejs/runtime-resource/resource/audio";
+```
+
+`CjsAudioRes` always represents one addressable audio file. Its backing may be
+a complete loose file, an individually served response, or a window within a
+shared `CjsAudioBufferRes` bank payload.
+
+Canonical effect-resource and shader reflection classes are available from:
+
+```js
+import {
+  Tr2EffectRes,
+  Tr2Shader
+} from "@carbonenginejs/runtime-resource/resource/shader";
+```
+
+`Tr2EffectRes` fail-closed validates complete permutation topology and portable
+reflection, selects a package permutation, and hydrates it into a cached,
+device-free `Tr2Shader`. Engines add programs, layouts, bindings, and other GPU
+state.
+
 ## Documentation
 
 - [Package documentation](docs/README.md)
 - [Architecture and boundaries](docs/architecture.md)
 - [Resource lifecycle concepts](docs/concepts/resource-lifecycle.md)
+- [Browser worker execution](docs/reference/workers.md)
+- [Audio resource classes](docs/reference/classes/audio.md)
+- [Resource and shader-reflection classes](docs/reference/classes/resources.md)
 - [Format subpaths](docs/formats/README.md)
 - [Format ownership and fork provenance](docs/formats/provenance.md)
 

package/dist/CjsMotherLode.js

@@ -1,4 +1,4 @@
-import { normalizeResourcePath } from './resourcePath.js';
+import { normalizeResourcePath } from '@carbonenginejs/runtime-utils/path';
 
 // Source: blue/include/IMotherLode.h
 // Source: blue/src/MotherLode.h
@@ -150,7 +150,7 @@ class CjsMotherLode {
   #cacheSize = DEFAULT_CACHE_SIZE;
   #entries = new Map();
   #nextCacheSequence = 1;
-  #now = DefaultNow;
+  #now = defaultNow;
 
   /**
    * Create an active deterministic resource registry.
@@ -230,14 +230,14 @@ class CjsMotherLode {
    */
   Insert(keyOrResource, resourceOrPath, optionsOrVariant = {}) {
     if (!this.#active) {
-      throw MotherLodeInactiveError();
+      throw motherLodeInactiveError();
     }
     const {
       key,
       resource,
       options
-    } = NormalizeInsertArguments(keyOrResource, resourceOrPath, optionsOrVariant);
-    AssertResource(resource);
+    } = normalizeInsertArguments(keyOrResource, resourceOrPath, optionsOrVariant);
+    assertResource(resource);
     const existing = this.#entries.get(key) || null;
     if (existing && existing.resource === resource) {
       const updated = {
@@ -247,17 +247,17 @@ class CjsMotherLode {
       this.#AssertRecordedBytesTotal(updated, existing);
       this.#TouchRecord(updated, options);
       Object.assign(existing, updated);
-      return FreezeInsertResult(key, resource, false, false, null);
+      return freezeInsertResult(key, resource, false, false, null);
     }
     if (existing && options.replace === false) {
-      return FreezeInsertResult(key, existing.resource, false, false, null);
+      return freezeInsertResult(key, existing.resource, false, false, null);
     }
     const record = this.#CreateRecord(key, resource, options, existing);
     if (existing) {
       this.#CleanupRecord(existing, options, "replace", true);
     }
     this.#entries.set(key, record);
-    return FreezeInsertResult(key, resource, true, Boolean(existing), existing?.resource || null);
+    return freezeInsertResult(key, resource, true, Boolean(existing), existing?.resource || null);
   }
 
   /**
@@ -286,15 +286,15 @@ class CjsMotherLode {
    */
   ReplaceExpected(key, expected, resource, options = {}) {
     if (!this.#active) {
-      throw MotherLodeInactiveError();
+      throw motherLodeInactiveError();
     }
-    const resolvedKey = NormalizeResolvedKey(key);
-    const policy = NormalizeOptions(options, "conditional replace");
+    const resolvedKey = normalizeResolvedKey(key);
+    const policy = normalizeOptions(options, "conditional replace");
     if (policy.commitGuard !== undefined && typeof policy.commitGuard !== "function") {
       throw new TypeError("CjsMotherLode conditional replace commitGuard must be a function.");
     }
-    AssertResource(expected);
-    AssertResource(resource);
+    assertResource(expected);
+    assertResource(resource);
     if (resource === expected) {
       const error = new Error("CjsMotherLode conditional replacement requires a distinct resource.");
       error.code = "CJS_MOTHERLODE_REPLACE_ALIAS";
@@ -302,7 +302,7 @@ class CjsMotherLode {
     }
     const existing = this.#entries.get(resolvedKey) || null;
     if (!existing || existing.resource !== expected) {
-      return FreezeConditionalReplaceResult(resolvedKey, false, existing?.resource || null, null);
+      return freezeConditionalReplaceResult(resolvedKey, false, existing?.resource || null, null);
     }
     const recordOptions = {
       ...policy,
@@ -315,10 +315,10 @@ class CjsMotherLode {
     // Re-check after clock/metadata validation, then publish with no user code
     // between the exact-record comparison and Map mutation.
     if (policy.commitGuard && !policy.commitGuard() || this.#entries.get(resolvedKey) !== existing) {
-      return FreezeConditionalReplaceResult(resolvedKey, false, this.#entries.get(resolvedKey)?.resource || null, null);
+      return freezeConditionalReplaceResult(resolvedKey, false, this.#entries.get(resolvedKey)?.resource || null, null);
     }
     this.#entries.set(resolvedKey, record);
-    const result = FreezeConditionalReplaceResult(resolvedKey, true, resource, expected);
+    const result = freezeConditionalReplaceResult(resolvedKey, true, resource, expected);
     try {
       this.#CleanupRecord(existing, policy, "conditional replace");
     } catch (cause) {
@@ -340,7 +340,7 @@ class CjsMotherLode {
    * @throws {TypeError} If the identity cannot be normalized.
    */
   HasKey(key, variant = undefined) {
-    return this.#entries.has(NormalizeLookupKey(key, variant));
+    return this.#entries.has(normalizeLookupKey(key, variant));
   }
 
   /**
@@ -353,7 +353,7 @@ class CjsMotherLode {
    * @throws {TypeError} If the identity cannot be normalized.
    */
   Lookup(key, variant = undefined) {
-    return this.#entries.get(NormalizeLookupKey(key, variant))?.resource || null;
+    return this.#entries.get(normalizeLookupKey(key, variant))?.resource || null;
   }
 
   /**
@@ -372,7 +372,7 @@ class CjsMotherLode {
     const {
       resolvedKey,
       options
-    } = NormalizeDeleteArguments(key, variantOrOptions, maybeOptions);
+    } = normalizeDeleteArguments(key, variantOrOptions, maybeOptions);
     const record = this.#entries.get(resolvedKey);
     if (!record) return false;
     this.#entries.delete(resolvedKey);
@@ -391,7 +391,7 @@ class CjsMotherLode {
    * @throws {AggregateError} If cleanup fails for one or more removed resources.
    */
   DeleteAllVariants(path, options = {}) {
-    const normalizedPath = NormalizePath(path);
+    const normalizedPath = normalizePath(path);
     const prefix = `${normalizedPath}\u0000`;
     const records = [];
     for (const [key, record] of this.#entries) {
@@ -456,7 +456,7 @@ class CjsMotherLode {
     const {
       resolvedKey,
       options
-    } = NormalizeActivityArguments(key, variantOrOptions, maybeOptions);
+    } = normalizeActivityArguments(key, variantOrOptions, maybeOptions);
     const record = this.#entries.get(resolvedKey);
     if (!record) return null;
     record.cached = false;
@@ -480,7 +480,7 @@ class CjsMotherLode {
     const {
       resolvedKey,
       options
-    } = NormalizeActivityArguments(key, variantOrOptions, maybeOptions);
+    } = normalizeActivityArguments(key, variantOrOptions, maybeOptions);
     const record = this.#entries.get(resolvedKey);
     if (!record) return null;
     record.cached = false;
@@ -501,7 +501,7 @@ class CjsMotherLode {
    * @throws {TypeError} If the identity cannot be normalized.
    */
   Lock(key, variant = undefined) {
-    const record = this.#entries.get(NormalizeLookupKey(key, variant));
+    const record = this.#entries.get(normalizeLookupKey(key, variant));
     if (!record) return 0;
     record.lockCount += 1;
     record.cached = false;
@@ -520,7 +520,7 @@ class CjsMotherLode {
    * @throws {TypeError} If the identity cannot be normalized.
    */
   Unlock(key, variant = undefined) {
-    const record = this.#entries.get(NormalizeLookupKey(key, variant));
+    const record = this.#entries.get(normalizeLookupKey(key, variant));
     if (!record) return 0;
     if (record.lockCount > 0) record.lockCount -= 1;
     return record.lockCount;
@@ -545,7 +545,7 @@ class CjsMotherLode {
    * @throws {AggregateError} If one or more cleanup, payload-release, or purge-state operations fail.
    */
   PurgeInactive(options = {}) {
-    const policy = NormalizePurgeOptions(options, this.#activityFrame, this.#now);
+    const policy = normalizePurgeOptions(options, this.#activityFrame, this.#now);
     this.#activityFrame = Math.max(this.#activityFrame, policy.frame);
     const purgedKeys = [];
     const payloadKeys = [];
@@ -556,7 +556,7 @@ class CjsMotherLode {
         locked += 1;
         continue;
       }
-      if (IsInactive(record.lastUsedFrame, record.lastUsedTime, policy.frame, policy.time, policy.maxIdleFrames, policy.maxIdleMilliseconds)) {
+      if (isInactive(record.lastUsedFrame, record.lastUsedTime, policy.frame, policy.time, policy.maxIdleFrames, policy.maxIdleMilliseconds)) {
         try {
           this.#CleanupRecord(record, policy, "purge inactive", true);
         } catch (error) {
@@ -568,20 +568,20 @@ class CjsMotherLode {
         try {
           record.resource?.MarkPurged?.();
         } catch (cause) {
-          errors.push(MotherLodeCleanupError("mark purged", key, record.resource, cause));
+          errors.push(motherLodeCleanupError("mark purged", key, record.resource, cause));
         }
         continue;
       }
-      if (policy.releasePayload !== false && HasOwnedPayload(record.resource) && IsInactive(record.payloadLastUsedFrame, record.payloadLastUsedTime, policy.frame, policy.time, policy.payloadMaxIdleFrames, policy.payloadMaxIdleMilliseconds)) {
+      if (policy.releasePayload !== false && hasOwnedPayload(record.resource) && isInactive(record.payloadLastUsedFrame, record.payloadLastUsedTime, policy.frame, policy.time, policy.payloadMaxIdleFrames, policy.payloadMaxIdleMilliseconds)) {
         try {
           record.resource.ReleasePayload();
           payloadKeys.push(key);
         } catch (cause) {
-          errors.push(MotherLodeCleanupError("release inactive payload", key, record.resource, cause));
+          errors.push(motherLodeCleanupError("release inactive payload", key, record.resource, cause));
         }
       }
     }
-    const result = FreezePurgeResult(policy.frame, policy.time, purgedKeys, payloadKeys, locked);
+    const result = freezePurgeResult(policy.frame, policy.time, purgedKeys, payloadKeys, locked);
     if (errors.length) {
       const error = new AggregateError(errors, "CjsMotherLode inactivity purge failed.");
       error.code = "CJS_MOTHERLODE_PURGE_FAILED";
@@ -613,7 +613,7 @@ class CjsMotherLode {
    * @throws {AggregateError} If cleanup or purge-state publication fails for one or more candidates.
    */
   TrimCache(options = {}) {
-    const policy = NormalizeOptions(options, "cache trim");
+    const policy = normalizeOptions(options, "cache trim");
     const beforeBytes = this.#GetCacheBytes();
     const evictedKeys = [];
     const failedKeys = [];
@@ -641,13 +641,13 @@ class CjsMotherLode {
         try {
           record.resource?.MarkPurged?.();
         } catch (cause) {
-          errors.push(MotherLodeCleanupError("mark cache eviction purged", record.key, record.resource, cause));
+          errors.push(motherLodeCleanupError("mark cache eviction purged", record.key, record.resource, cause));
           failedKeys.push(record.key);
         }
       }
     }
     const afterBytes = this.#GetCacheBytes();
-    const result = FreezeCacheTrimResult(this.#cacheSize, beforeBytes, afterBytes, evictedBytes, evictedKeys, failedKeys);
+    const result = freezeCacheTrimResult(this.#cacheSize, beforeBytes, afterBytes, evictedBytes, evictedKeys, failedKeys);
     if (errors.length) {
       const error = new AggregateError(errors, "CjsMotherLode cache trim failed.");
       error.code = "CJS_MOTHERLODE_CACHE_TRIM_FAILED";
@@ -669,8 +669,8 @@ class CjsMotherLode {
    * @throws {AggregateError} If enforcing the new budget cannot clean one or more cached entries.
    */
   SetCacheSize(bytes, options = {}) {
-    AssertNonNegativeSafeInteger(bytes, "CjsMotherLode cache size");
-    const policy = NormalizeOptions(options, "set cache size");
+    assertNonNegativeSafeInteger(bytes, "CjsMotherLode cache size");
+    const policy = normalizeOptions(options, "set cache size");
     this.#cacheSize = bytes;
     this.TrimCache(policy);
     return this;
@@ -734,8 +734,8 @@ class CjsMotherLode {
         cacheBytes += record.bytes;
       }
       if (record.lockCount > 0) locked += 1;
-      if (HasOwnedPayload(record.resource)) payloads += 1;
-      const path = record.resource?.GetPath?.() || record.resource?.path || GetKeyPath(record.key);
+      if (hasOwnedPayload(record.resource)) payloads += 1;
+      const path = record.resource?.GetPath?.() || record.resource?.path || getKeyPath(record.key);
       if (path) paths.add(path);
       const state = typeof record.resource?.state === "string" ? record.resource.state : "unknown";
       states[state] = (states[state] || 0) + 1;
@@ -840,7 +840,7 @@ class CjsMotherLode {
    */
   #UpdateRecord(record, options) {
     if (options.bytes !== undefined) {
-      AssertNonNegativeSafeInteger(options.bytes, "CjsMotherLode entry bytes");
+      assertNonNegativeSafeInteger(options.bytes, "CjsMotherLode entry bytes");
       record.bytes = options.bytes;
     }
     if (options.cacheable !== undefined) record.cacheable = Boolean(options.cacheable);
@@ -900,7 +900,7 @@ class CjsMotherLode {
    */
   #TouchRecord(record, options) {
     const frame = options.frame === undefined ? this.#activityFrame + 1 : options.frame;
-    AssertNonNegativeSafeInteger(frame, "CjsMotherLode activity frame");
+    assertNonNegativeSafeInteger(frame, "CjsMotherLode activity frame");
     this.#activityFrame = Math.max(this.#activityFrame, frame);
     record.lastUsedFrame = frame;
     const time = options.time === undefined ? this.#now() : options.time;
@@ -924,18 +924,18 @@ class CjsMotherLode {
   #CleanupRecord(record, options, operation, preserveOnFailure = false) {
     let cleanupComplete = false;
     try {
-      CleanupOwnedResource(record.resource, options);
+      cleanupOwnedResource(record.resource, options);
       cleanupComplete = true;
-      DetachResourceLifecycle(record.resource);
+      detachResourceLifecycle(record.resource);
     } catch (cause) {
       if (!preserveOnFailure && !cleanupComplete) {
         try {
-          DetachResourceLifecycle(record.resource);
+          detachResourceLifecycle(record.resource);
         } catch (detachCause) {
           cause = new AggregateError([cause, detachCause], "Resource cleanup and detach failed.");
         }
       }
-      throw MotherLodeCleanupError(operation, record.key, record.resource, cause);
+      throw motherLodeCleanupError(operation, record.key, record.resource, cause);
     }
   }
 
@@ -952,14 +952,14 @@ class CjsMotherLode {
     const errors = [];
     for (const record of records) {
       try {
-        CleanupOwnedResource(record.resource, options);
+        cleanupOwnedResource(record.resource, options);
       } catch (cause) {
-        errors.push(MotherLodeCleanupError(operation, record.key, record.resource, cause));
+        errors.push(motherLodeCleanupError(operation, record.key, record.resource, cause));
       }
       try {
-        DetachResourceLifecycle(record.resource);
+        detachResourceLifecycle(record.resource);
       } catch (cause) {
-        errors.push(MotherLodeCleanupError(`${operation} detach`, record.key, record.resource, cause));
+        errors.push(motherLodeCleanupError(`${operation} detach`, record.key, record.resource, cause));
       }
     }
     if (errors.length) {
@@ -979,7 +979,7 @@ class CjsMotherLode {
  * @throws {TypeError} If the path is empty/invalid or the variant contains a null byte.
  */
 function getMotherLodeKey(path, variant = "") {
-  const normalizedPath = NormalizePath(path);
+  const normalizedPath = normalizePath(path);
   if (variant === null || variant === undefined || variant === "") return normalizedPath;
   const normalizedVariant = String(variant);
   if (normalizedVariant.includes("\u0000")) {
@@ -987,18 +987,18 @@ function getMotherLodeKey(path, variant = "") {
   }
   return `${normalizedPath}\u0000${normalizedVariant}`;
 }
-function NormalizeInsertArguments(keyOrResource, resourceOrPath, optionsOrVariant) {
+function normalizeInsertArguments(keyOrResource, resourceOrPath, optionsOrVariant) {
   if (typeof keyOrResource === "string") {
     return {
-      key: NormalizeResolvedKey(keyOrResource),
+      key: normalizeResolvedKey(keyOrResource),
       resource: resourceOrPath,
-      options: NormalizeOptions(optionsOrVariant, "insert")
+      options: normalizeOptions(optionsOrVariant, "insert")
     };
   }
   const resource = keyOrResource;
   const path = resourceOrPath ?? resource?.GetPath?.() ?? resource?.path;
   const isOptions = optionsOrVariant && typeof optionsOrVariant === "object" && !Array.isArray(optionsOrVariant);
-  const options = isOptions ? NormalizeOptions(optionsOrVariant, "insert") : {};
+  const options = isOptions ? normalizeOptions(optionsOrVariant, "insert") : {};
   const variant = isOptions ? options.variant || "" : optionsOrVariant;
   return {
     key: getMotherLodeKey(path, variant),
@@ -1006,46 +1006,46 @@ function NormalizeInsertArguments(keyOrResource, resourceOrPath, optionsOrVarian
     options
   };
 }
-function NormalizeDeleteArguments(key, variantOrOptions, maybeOptions) {
+function normalizeDeleteArguments(key, variantOrOptions, maybeOptions) {
   if (variantOrOptions && typeof variantOrOptions === "object" && !Array.isArray(variantOrOptions)) {
     return {
-      resolvedKey: NormalizeResolvedKey(key),
-      options: NormalizeOptions(variantOrOptions, "delete")
+      resolvedKey: normalizeResolvedKey(key),
+      options: normalizeOptions(variantOrOptions, "delete")
     };
   }
   return {
-    resolvedKey: NormalizeLookupKey(key, variantOrOptions),
-    options: NormalizeOptions(maybeOptions || {}, "delete")
+    resolvedKey: normalizeLookupKey(key, variantOrOptions),
+    options: normalizeOptions(maybeOptions || {}, "delete")
   };
 }
-function NormalizeActivityArguments(key, variantOrOptions, maybeOptions) {
+function normalizeActivityArguments(key, variantOrOptions, maybeOptions) {
   if (variantOrOptions && typeof variantOrOptions === "object" && !Array.isArray(variantOrOptions)) {
     return {
-      resolvedKey: NormalizeResolvedKey(key),
-      options: NormalizeOptions(variantOrOptions, "activity")
+      resolvedKey: normalizeResolvedKey(key),
+      options: normalizeOptions(variantOrOptions, "activity")
     };
   }
   return {
-    resolvedKey: NormalizeLookupKey(key, variantOrOptions),
-    options: NormalizeOptions(maybeOptions || {}, "activity")
+    resolvedKey: normalizeLookupKey(key, variantOrOptions),
+    options: normalizeOptions(maybeOptions || {}, "activity")
   };
 }
-function NormalizeLookupKey(key, variant) {
-  return variant === undefined ? NormalizeResolvedKey(key) : getMotherLodeKey(key, variant);
+function normalizeLookupKey(key, variant) {
+  return variant === undefined ? normalizeResolvedKey(key) : getMotherLodeKey(key, variant);
 }
-function NormalizeResolvedKey(key) {
+function normalizeResolvedKey(key) {
   if (typeof key !== "string" || !key) {
     throw new TypeError("CjsMotherLode requires a canonical string key.");
   }
   const separator = key.indexOf("\u0000");
   return separator === -1 ? getMotherLodeKey(key) : getMotherLodeKey(key.slice(0, separator), key.slice(separator + 1));
 }
-function NormalizePath(path) {
+function normalizePath(path) {
   const normalizedPath = normalizeResourcePath(path);
   if (!normalizedPath) throw new TypeError("CjsMotherLode requires a resource path.");
   return normalizedPath;
 }
-function NormalizeOptions(options, operation) {
+function normalizeOptions(options, operation) {
   if (options === null || options === undefined) return {};
   if (!options || typeof options !== "object" || Array.isArray(options)) {
     throw new TypeError(`CjsMotherLode ${operation} options must be an object.`);
@@ -1061,20 +1061,20 @@ function NormalizeOptions(options, operation) {
  * @param {() => number} now Registry clock.
  * @returns {CjsMotherLodePurgeOptions & {frame: number, time: number}} Validated sweep policy.
  */
-function NormalizePurgeOptions(options, activityFrame, now) {
-  const policy = NormalizeOptions(options, "purge");
+function normalizePurgeOptions(options, activityFrame, now) {
+  const policy = normalizeOptions(options, "purge");
   const frame = policy.frame === undefined ? activityFrame + 1 : policy.frame;
-  AssertNonNegativeSafeInteger(frame, "CjsMotherLode purge frame");
+  assertNonNegativeSafeInteger(frame, "CjsMotherLode purge frame");
   const time = policy.time === undefined ? now() : policy.time;
-  AssertNonNegativeFiniteNumber(time, "CjsMotherLode purge time");
+  assertNonNegativeFiniteNumber(time, "CjsMotherLode purge time");
   for (const name of ["maxIdleFrames", "payloadMaxIdleFrames"]) {
     if (policy[name] !== undefined) {
-      AssertNonNegativeSafeInteger(policy[name], `CjsMotherLode ${name}`);
+      assertNonNegativeSafeInteger(policy[name], `CjsMotherLode ${name}`);
     }
   }
   for (const name of ["maxIdleMilliseconds", "payloadMaxIdleMilliseconds"]) {
     if (policy[name] !== undefined) {
-      AssertNonNegativeFiniteNumber(policy[name], `CjsMotherLode ${name}`);
+      assertNonNegativeFiniteNumber(policy[name], `CjsMotherLode ${name}`);
     }
   }
   return {
@@ -1095,7 +1095,7 @@ function NormalizePurgeOptions(options, activityFrame, now) {
  * @param {number|undefined} maxMilliseconds Optional millisecond limit.
  * @returns {boolean} Whether at least one configured limit has elapsed.
  */
-function IsInactive(lastFrame, lastTime, frame, time, maxFrames, maxMilliseconds) {
+function isInactive(lastFrame, lastTime, frame, time, maxFrames, maxMilliseconds) {
   const frameExpired = maxFrames !== undefined && frame >= lastFrame && frame - lastFrame >= maxFrames;
   const timeExpired = maxMilliseconds !== undefined && time >= lastTime && time - lastTime >= maxMilliseconds;
   return frameExpired || timeExpired;
@@ -1107,7 +1107,7 @@ function IsInactive(lastFrame, lastTime, frame, time, maxFrames, maxMilliseconds
  * @param {object|Function} resource Candidate resource.
  * @returns {boolean} Whether `ReleasePayload()` can remove an attached payload.
  */
-function HasOwnedPayload(resource) {
+function hasOwnedPayload(resource) {
   return typeof resource?.HasPayload === "function" && typeof resource?.ReleasePayload === "function" && Boolean(resource.HasPayload());
 }
 
@@ -1117,10 +1117,10 @@ function HasOwnedPayload(resource) {
  * @param {object|Function} resource Removed resource.
  * @returns {void}
  */
-function DetachResourceLifecycle(resource) {
+function detachResourceLifecycle(resource) {
   resource?.SetLifecycleController?.(null);
 }
-function CleanupOwnedResource(resource, options) {
+function cleanupOwnedResource(resource, options) {
   if (options.cleanup === false) return;
   if (typeof options.cleanup === "function") {
     options.cleanup(resource);
@@ -1147,12 +1147,12 @@ function CleanupOwnedResource(resource, options) {
     throw errors.length === 1 ? errors[0] : new AggregateError(errors, "Resource cleanup failed.");
   }
 }
-function AssertResource(resource) {
+function assertResource(resource) {
   if (typeof resource !== "object" && typeof resource !== "function" || resource === null) {
     throw new TypeError("CjsMotherLode requires a resource object.");
   }
 }
-function AssertNonNegativeSafeInteger(value, label) {
+function assertNonNegativeSafeInteger(value, label) {
   if (!Number.isSafeInteger(value) || value < 0) {
     throw new TypeError(`${label} must be a non-negative safe integer.`);
   }
@@ -1165,12 +1165,12 @@ function AssertNonNegativeSafeInteger(value, label) {
  * @param {string} label Error-message field name.
  * @returns {void}
  */
-function AssertNonNegativeFiniteNumber(value, label) {
+function assertNonNegativeFiniteNumber(value, label) {
   if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
     throw new TypeError(`${label} must be a non-negative finite number.`);
   }
 }
-function FreezeInsertResult(key, resource, inserted, replaced, displaced) {
+function freezeInsertResult(key, resource, inserted, replaced, displaced) {
   return Object.freeze({
     key,
     resource,
@@ -1189,7 +1189,7 @@ function FreezeInsertResult(key, resource, inserted, replaced, displaced) {
  * @param {object|Function|null} displaced Former owner when committed.
  * @returns {CjsMotherLodeConditionalReplaceResult} Immutable replacement result.
  */
-function FreezeConditionalReplaceResult(key, committed, resource, displaced) {
+function freezeConditionalReplaceResult(key, committed, resource, displaced) {
   return Object.freeze({
     key,
     committed,
@@ -1208,7 +1208,7 @@ function FreezeConditionalReplaceResult(key, committed, resource, displaced) {
  * @param {number} locked Number of locked entries skipped.
  * @returns {CjsMotherLodePurgeResult} Immutable sweep result.
  */
-function FreezePurgeResult(frame, time, purgedKeys, payloadKeys, locked) {
+function freezePurgeResult(frame, time, purgedKeys, payloadKeys, locked) {
   return Object.freeze({
     frame,
     time,
@@ -1231,7 +1231,7 @@ function FreezePurgeResult(frame, time, purgedKeys, payloadKeys, locked) {
  * @param {string[]} failedKeys Candidate identities that reported failure.
  * @returns {CjsMotherLodeCacheTrimResult} Immutable cache-housekeeping result.
  */
-function FreezeCacheTrimResult(cacheSize, beforeBytes, afterBytes, evictedBytes, evictedKeys, failedKeys) {
+function freezeCacheTrimResult(cacheSize, beforeBytes, afterBytes, evictedBytes, evictedKeys, failedKeys) {
   return Object.freeze({
     cacheSize,
     beforeBytes,
@@ -1244,12 +1244,12 @@ function FreezeCacheTrimResult(cacheSize, beforeBytes, afterBytes, evictedBytes,
     failedKeys: Object.freeze(failedKeys)
   });
 }
-function MotherLodeInactiveError() {
+function motherLodeInactiveError() {
   const error = new Error("CjsMotherLode is shut down. Call Startup() before inserting resources.");
   error.code = "CJS_MOTHERLODE_INACTIVE";
   return error;
 }
-function MotherLodeCleanupError(operation, key, resource, cause) {
+function motherLodeCleanupError(operation, key, resource, cause) {
   const error = new Error(`CjsMotherLode ${operation} cleanup failed for ${key}.`, {
     cause
   });
@@ -1259,11 +1259,11 @@ function MotherLodeCleanupError(operation, key, resource, cause) {
   error.resource = resource;
   return error;
 }
-function GetKeyPath(key) {
+function getKeyPath(key) {
   const separator = key.indexOf("\u0000");
   return separator === -1 ? key : key.slice(0, separator);
 }
-function DefaultNow() {
+function defaultNow() {
   return Date.now();
 }