@carbonenginejs/runtime-resource 0.19.2 → 0.22.0

package/dist/CjsResMan.js

@@ -24,136 +24,136 @@ const RESOURCE_PROVENANCE_OPTION_KEYS = Object.freeze(["source", "sourceRevision
 const LOCAL_VALUE_IDENTITIES = new WeakMap();
 let nextLocalValueIdentity = 1;
 
-/**
- * Immutable source provenance used by one read/format operation chain.
- *
- * `sourceRevision` is caller/source-provided opaque content identity. It scopes
- * read caches only and never becomes part of MotherLode resource identity.
- *
- * @typedef {object} CjsResourceReadContext
- * @property {CjsResMan} resMan Owning manager.
- * @property {object|Function} source Selected source implementation.
- * @property {string} path Normalized Carbon-style source path.
- * @property {string} resFilePath Normalized lowercase Carbon-style source path.
- * @property {string} ext Normalized lowercase resource extension.
- * @property {string} fileName Normalized lowercase final path component.
- * @property {string|null} url Exact URL passed to a URL-backed source, otherwise `null`.
- * @property {string} sourcePath Resource path or URL passed to the selected source.
- * @property {string|number|undefined} sourceRevision Caller content token.
- * @property {string} revisionKey Type-stable internal form of the content token.
+/**
+ * Immutable source provenance used by one read/format operation chain.
+ *
+ * `sourceRevision` is caller/source-provided opaque content identity. It scopes
+ * read caches only and never becomes part of MotherLode resource identity.
+ *
+ * @typedef {object} CjsResourceReadContext
+ * @property {CjsResMan} resMan Owning manager.
+ * @property {object|Function} source Selected source implementation.
+ * @property {string} path Normalized Carbon-style source path.
+ * @property {string} resFilePath Normalized lowercase Carbon-style source path.
+ * @property {string} ext Normalized lowercase resource extension.
+ * @property {string} fileName Normalized lowercase final path component.
+ * @property {string|null} url Exact URL passed to a URL-backed source, otherwise `null`.
+ * @property {string} sourcePath Resource path or URL passed to the selected source.
+ * @property {string|number|undefined} sourceRevision Caller content token.
+ * @property {string} revisionKey Type-stable internal form of the content token.
  */
 
-/**
- * Mutable record retained in a source or format operation ledger.
- *
- * @typedef {object} CjsResourceReadOperationRecord
- * @property {Promise<*>} promise Shared operation promise.
- * @property {string} path Normalized source path used for explicit invalidation.
- * @property {string} revisionKey Type-stable source revision key.
- * @property {boolean} retain Whether any joined caller requested settled retention.
+/**
+ * Mutable record retained in a source or format operation ledger.
+ *
+ * @typedef {object} CjsResourceReadOperationRecord
+ * @property {Promise<*>} promise Shared operation promise.
+ * @property {string} path Normalized source path used for explicit invalidation.
+ * @property {string} revisionKey Type-stable source revision key.
+ * @property {boolean} retain Whether any joined caller requested settled retention.
  */
 
-/**
- * Source provenance and tri-state read-cache controls.
- *
- * Omitted cache flags share in-flight or explicitly retained work but do not
- * retain a newly completed operation. `true` retains success, while `false`
- * bypasses sharing and retention. Failures are never retained.
- *
- * @typedef {object} CjsResManReadCacheOptions
- * @property {object|Function} [source] Source override providing `Read(path, options)`.
- * @property {string|number} [sourceRevision] Opaque caller/source content token; finite numbers only.
- * @property {boolean} [reload=false] Invalidate this source/path and begin fresh work once.
- * @property {boolean} [cacheSource] Source operation sharing/retention policy.
- * @property {boolean} [cacheFormat] Parsed-format operation sharing/retention policy.
+/**
+ * Source provenance and tri-state read-cache controls.
+ *
+ * Omitted cache flags share in-flight or explicitly retained work but do not
+ * retain a newly completed operation. `true` retains success, while `false`
+ * bypasses sharing and retention. Failures are never retained.
+ *
+ * @typedef {object} CjsResManReadCacheOptions
+ * @property {object|Function} [source] Source override providing `Read(path, options)`.
+ * @property {string|number} [sourceRevision] Opaque caller/source content token; finite numbers only.
+ * @property {boolean} [reload=false] Invalidate this source/path and begin fresh work once.
+ * @property {boolean} [cacheSource] Source operation sharing/retention policy.
+ * @property {boolean} [cacheFormat] Parsed-format operation sharing/retention policy.
  */
 
-/**
- * Opt-in time-based inactivity policy run by {@link CjsResMan#Update}.
- *
- * Automatic policy deliberately uses elapsed milliseconds rather than
- * MotherLode activity frames: the latter count explicit activity observations
- * and are not guaranteed to match renderer frames. At least one identity or
- * payload limit is required. The policy is disabled by default.
- *
- * @typedef {object} CjsResManAutoPurgePolicy
- * @property {number} [intervalMilliseconds=1000] Minimum elapsed milliseconds between automatic sweeps; `0` permits every update.
- * @property {number} [maxIdleMilliseconds] Elapsed milliseconds after which an unlocked canonical identity is removed and cleaned.
- * @property {number} [payloadMaxIdleMilliseconds] Elapsed milliseconds after which an unlocked CPU payload is released.
- * @property {boolean} [destroyAdapters=true] Whether identity cleanup destroys adapter allocations.
- * @property {boolean} [releasePayload=true] Whether sweeps may release CPU payloads.
- * @property {false|Function} [cleanup] `false` retains owned state; a function replaces default identity cleanup.
- * @property {() => number} [now=Date.now] Cadence clock. Use the MotherLode activity clock when supplying a custom clock.
+/**
+ * Opt-in time-based inactivity policy run by {@link CjsResMan#Update}.
+ *
+ * Automatic policy deliberately uses elapsed milliseconds rather than
+ * MotherLode activity frames: the latter count explicit activity observations
+ * and are not guaranteed to match renderer frames. At least one identity or
+ * payload limit is required. The policy is disabled by default.
+ *
+ * @typedef {object} CjsResManAutoPurgePolicy
+ * @property {number} [intervalMilliseconds=1000] Minimum elapsed milliseconds between automatic sweeps; `0` permits every update.
+ * @property {number} [maxIdleMilliseconds] Elapsed milliseconds after which an unlocked canonical identity is removed and cleaned.
+ * @property {number} [payloadMaxIdleMilliseconds] Elapsed milliseconds after which an unlocked CPU payload is released.
+ * @property {boolean} [destroyAdapters=true] Whether identity cleanup destroys adapter allocations.
+ * @property {boolean} [releasePayload=true] Whether sweeps may release CPU payloads.
+ * @property {false|Function} [cleanup] `false` retains owned state; a function replaces default identity cleanup.
+ * @property {() => number} [now=Date.now] Cadence clock. Use the MotherLode activity clock when supplying a custom clock.
  */
 
-/**
- * Per-call controls for {@link CjsResMan#PumpAutoPurge}.
- *
- * @typedef {object} CjsResManAutoPurgePumpOptions
- * @property {number} [time] Explicit non-negative timestamp in milliseconds for deterministic pumping and sweeping.
+/**
+ * Per-call controls for {@link CjsResMan#PumpAutoPurge}.
+ *
+ * @typedef {object} CjsResManAutoPurgePumpOptions
+ * @property {number} [time] Explicit non-negative timestamp in milliseconds for deterministic pumping and sweeping.
  */
 
-/**
- * Queue and automatic-purge controls accepted by {@link CjsResMan#Update}.
- * Top-level queue options remain a compatibility form for the prepare pump.
- *
- * @typedef {object} CjsResManUpdateOptions
- * @property {object} [background] Background queue pump options.
- * @property {object} [prepare] Main-thread prepare queue pump options.
- * @property {false|object} [cache] `false` skips recorded-byte housekeeping; otherwise supplies cache-cleanup policy.
- * @property {false|CjsResManAutoPurgePumpOptions} [purge] `false` skips this update's automatic sweep; otherwise supplies its timestamp.
+/**
+ * Queue and automatic-purge controls accepted by {@link CjsResMan#Update}.
+ * Top-level queue options remain a compatibility form for the prepare pump.
+ *
+ * @typedef {object} CjsResManUpdateOptions
+ * @property {object} [background] Background queue pump options.
+ * @property {object} [prepare] Main-thread prepare queue pump options.
+ * @property {false|object} [cache] `false` skips recorded-byte housekeeping; otherwise supplies cache-cleanup policy.
+ * @property {false|CjsResManAutoPurgePumpOptions} [purge] `false` skips this update's automatic sweep; otherwise supplies its timestamp.
  */
 
-/**
- * Snapshot-fence controls accepted by {@link CjsResMan#Wait}.
- *
- * The default pump uses the manager's ordinary queue budgets and honors queue
- * pause state. `pump: false` leaves all progress to an external driver. The
- * yield callback is used only while this call is pumping and may return either
- * a promise or an immediate value.
- *
- * @typedef {object} CjsResManWaitOptions
- * @property {boolean} [pump=true] Whether this call pumps the two queues while awaiting its snapshot.
- * @property {object} [background] Options forwarded to `PumpBackgroundQueue`.
- * @property {object} [prepare] Options forwarded to `PumpMainThreadQueue`.
- * @property {() => (*|Promise<*>)} [yield] Cooperative wait between pump attempts.
+/**
+ * Snapshot-fence controls accepted by {@link CjsResMan#Wait}.
+ *
+ * The default pump uses the manager's ordinary queue budgets and honors queue
+ * pause state. `pump: false` leaves all progress to an external driver. The
+ * yield callback is used only while this call is pumping and may return either
+ * a promise or an immediate value.
+ *
+ * @typedef {object} CjsResManWaitOptions
+ * @property {boolean} [pump=true] Whether this call pumps the two queues while awaiting its snapshot.
+ * @property {object} [background] Options forwarded to `PumpBackgroundQueue`.
+ * @property {object} [prepare] Options forwarded to `PumpMainThreadQueue`.
+ * @property {() => (*|Promise<*>)} [yield] Cooperative wait between pump attempts.
  */
 
-/**
- * Immutable authority captured by asynchronous work that may mutate a
- * canonical resource. A generation changes whenever ResMan removes and later
- * rebinds the same JavaScript handle, even when owner and key are reused.
- *
- * @typedef {object} CjsResourceOwnership
- * @property {number} generation Manager-local ownership generation.
- * @property {CjsMotherLode} owner Exact registry that owns the resource.
- * @property {string} key Exact canonical registry identity.
- * @property {object|Function} resource Canonical resource handle.
+/**
+ * Immutable authority captured by asynchronous work that may mutate a
+ * canonical resource. A generation changes whenever ResMan removes and later
+ * rebinds the same JavaScript handle, even when owner and key are reused.
+ *
+ * @typedef {object} CjsResourceOwnership
+ * @property {number} generation Manager-local ownership generation.
+ * @property {CjsMotherLode} owner Exact registry that owns the resource.
+ * @property {string} key Exact canonical registry identity.
+ * @property {object|Function} resource Canonical resource handle.
  */
 
-/**
- * Immutable authority for one off-registry reload candidate.
- *
- * The newest generation for a canonical key is the only candidate permitted
- * to commit. `expectedOwnership` keeps the former canonical handle protected
- * by the same exact-owner generation checks used by ordinary asynchronous
- * resource work.
- *
- * @typedef {object} CjsResourceReloadCandidate
- * @property {true} reloadCandidate Distinguishes staged authority from canonical ownership.
- * @property {number} generation Manager-local reload request generation.
- * @property {CjsMotherLode} owner Exact registry expected to receive the candidate.
- * @property {string} key Exact canonical registry identity.
- * @property {object|Function} expected Former canonical resource preserved until commit.
- * @property {CjsResourceOwnership} expectedOwnership Captured authority of the former owner.
- * @property {object|Function} resource Off-registry candidate resource.
- * @property {Readonly<object>} loaderOptions Durable identity/source options restored after commit.
+/**
+ * Immutable authority for one off-registry reload candidate.
+ *
+ * The newest generation for a canonical key is the only candidate permitted
+ * to commit. `expectedOwnership` keeps the former canonical handle protected
+ * by the same exact-owner generation checks used by ordinary asynchronous
+ * resource work.
+ *
+ * @typedef {object} CjsResourceReloadCandidate
+ * @property {true} reloadCandidate Distinguishes staged authority from canonical ownership.
+ * @property {number} generation Manager-local reload request generation.
+ * @property {CjsMotherLode} owner Exact registry expected to receive the candidate.
+ * @property {string} key Exact canonical registry identity.
+ * @property {object|Function} expected Former canonical resource preserved until commit.
+ * @property {CjsResourceOwnership} expectedOwnership Captured authority of the former owner.
+ * @property {object|Function} resource Off-registry candidate resource.
+ * @property {Readonly<object>} loaderOptions Durable identity/source options restored after commit.
  */
 
-/**
- * Hidden authority accepted by guarded CPU read/publication helpers.
- *
- * @typedef {CjsResourceOwnership|CjsResourceReloadCandidate} CjsResourceMutationAuthority
+/**
+ * Hidden authority accepted by guarded CPU read/publication helpers.
+ *
+ * @typedef {CjsResourceOwnership|CjsResourceReloadCandidate} CjsResourceMutationAuthority
  */
 
 class CjsResMan extends CjsEventEmitter {
@@ -173,12 +173,13 @@ class CjsResMan extends CjsEventEmitter {
   #extensionRoutes = new Map();
   #resourceExtensionRoutes = new WeakMap();
   #resourceHandlerModes = new WeakMap();
+  #resourceTypeCandidates = new Map();
 
-  /**
-   * Create a GPU-free resource manager and apply its initial registration.
-   *
-   * @param {object} [options={}] Configuration forwarded to {@link CjsResMan#Register}.
-   * @throws {TypeError} If registration, queue, source, or format options are invalid.
+  /**
+   * Create a GPU-free resource manager and apply its initial registration.
+   *
+   * @param {object} [options={}] Configuration forwarded to {@link CjsResMan#Register}.
+   * @throws {TypeError} If registration, queue, source, or format options are invalid.
    */
   constructor(options = {}) {
     super();
@@ -217,30 +218,30 @@ class CjsResMan extends CjsEventEmitter {
     this.Register(options);
   }
 
-  /**
-   * Add or replace resource-manager configuration.
-   *
-   * The same options object can be forwarded unchanged by CjsLibrary. Format
-   * classes continue to own their input extensions; resource types are keyed
-   * by semantic requirements such as "texture", "image", or "geometry".
-   * Replacing MotherLode shuts down and cleans the former owner before the new
-   * registry is activated. Replacement is rejected while queued or direct
-   * resource mutations are active so a synchronous configuration call cannot
-   * detach ownership underneath asynchronous publication. Normal `Wait()`
-   * drains queued roots only; direct callers must await their own promises.
-   *
-   * @param {object} [options={}] Additive source, registry, queue, format, and resource-type settings.
-   * @param {number} [options.cacheSize] Recorded-byte budget immediately installed on the active MotherLode.
-   * @param {object} [options.cacheCleanup] Cleanup policy used if a smaller configured budget evicts cached identities.
-   * @param {object} [options.mainThreadLoader] Direct execution strategy.
-   * @param {object|Map<string,string>} [options.paths] Resource-prefix URL bases.
-   * @param {object|Map|object[]} [options.extensions] Extension route registrations.
-   * @param {Function|null} [options.pathResolver] Optional complete resource-path-to-URL resolver.
-   * @param {object} [options.workerLoader] Worker loader instance or construction options.
-   * @param {boolean} [options.useWorkerLoading=true] Whether worker-backed execution is selected.
-   * @returns {CjsResMan} This resource manager.
-   * @throws {TypeError} If options or any configured component are invalid.
-   * @throws {Error|AggregateError} If resource mutations are active or replacing MotherLode cannot clean its resources.
+  /**
+   * Add or replace resource-manager configuration.
+   *
+   * The same options object can be forwarded unchanged by CjsLibrary. Format
+   * classes continue to own their input extensions; resource types are keyed
+   * by semantic requirements such as "texture", "image", or "geometry".
+   * Replacing MotherLode shuts down and cleans the former owner before the new
+   * registry is activated. Replacement is rejected while queued or direct
+   * resource mutations are active so a synchronous configuration call cannot
+   * detach ownership underneath asynchronous publication. Normal `Wait()`
+   * drains queued roots only; direct callers must await their own promises.
+   *
+   * @param {object} [options={}] Additive source, registry, queue, format, and resource-type settings.
+   * @param {number} [options.cacheSize] Recorded-byte budget immediately installed on the active MotherLode.
+   * @param {object} [options.cacheCleanup] Cleanup policy used if a smaller configured budget evicts cached identities.
+   * @param {object} [options.mainThreadLoader] Direct execution strategy.
+   * @param {object|Map<string,string>} [options.paths] Resource-prefix URL bases.
+   * @param {object|Map|object[]} [options.extensions] Extension route registrations.
+   * @param {Function|null} [options.pathResolver] Optional complete resource-path-to-URL resolver.
+   * @param {object} [options.workerLoader] Worker loader instance or construction options.
+   * @param {boolean} [options.useWorkerLoading=true] Whether worker-backed execution is selected.
+   * @returns {CjsResMan} This resource manager.
+   * @throws {TypeError} If options or any configured component are invalid.
+   * @throws {Error|AggregateError} If resource mutations are active or replacing MotherLode cannot clean its resources.
    */
   Register(options = {}) {
     if (!options || typeof options !== "object" || Array.isArray(options)) {
@@ -315,25 +316,25 @@ class CjsResMan extends CjsEventEmitter {
     return this;
   }
 
-  /**
-   * Replace the default source selected by later resource requests.
-   * Existing handles retain the effective source captured when they were
-   * created, so payload reconstruction does not silently move to this source.
-   *
-   * @param {object|Function|null} source Source exposing `Read(path, options)`, or a falsey value to clear the default.
-   * @returns {CjsResMan} This resource manager.
+  /**
+   * Replace the default source selected by later resource requests.
+   * Existing handles retain the effective source captured when they were
+   * created, so payload reconstruction does not silently move to this source.
+   *
+   * @param {object|Function|null} source Source exposing `Read(path, options)`, or a falsey value to clear the default.
+   * @returns {CjsResMan} This resource manager.
    */
   SetSource(source) {
     this.source = source || null;
     return this;
   }
 
-  /**
-   * Add or replace one resource-prefix URL base.
-   *
-   * @param {string} prefix Resource scheme without `:/`.
-   * @param {string} urlBase URL base ending at the scheme root.
-   * @returns {CjsResMan} This resource manager.
+  /**
+   * Add or replace one resource-prefix URL base.
+   *
+   * @param {string} prefix Resource scheme without `:/`.
+   * @param {string} urlBase URL base ending at the scheme root.
+   * @returns {CjsResMan} This resource manager.
    */
   SetPath(prefix, urlBase) {
     const key = normalizePathPrefix(prefix);
@@ -342,11 +343,11 @@ class CjsResMan extends CjsEventEmitter {
     return this;
   }
 
-  /**
-   * Add or replace resource-prefix URL bases from an object or Map.
-   *
-   * @param {object|Map<string,string>} paths Prefix/base entries.
-   * @returns {CjsResMan} This resource manager.
+  /**
+   * Add or replace resource-prefix URL bases from an object or Map.
+   *
+   * @param {object|Map<string,string>} paths Prefix/base entries.
+   * @returns {CjsResMan} This resource manager.
    */
   SetPaths(paths) {
     if (!paths || typeof paths !== "object" && !(paths instanceof Map) || Array.isArray(paths)) {
@@ -359,31 +360,31 @@ class CjsResMan extends CjsEventEmitter {
     return this;
   }
 
-  /**
-   * Reports whether a resource-prefix URL base is registered.
-   *
-   * @param {string} prefix Resource scheme without `:/`.
-   * @returns {boolean}
+  /**
+   * Reports whether a resource-prefix URL base is registered.
+   *
+   * @param {string} prefix Resource scheme without `:/`.
+   * @returns {boolean}
    */
   HasPath(prefix) {
     return this.paths.has(normalizePathPrefix(prefix));
   }
 
-  /**
-   * Returns one registered resource-prefix URL base.
-   *
-   * @param {string} prefix Resource scheme without `:/`.
-   * @returns {string|null}
+  /**
+   * Returns one registered resource-prefix URL base.
+   *
+   * @param {string} prefix Resource scheme without `:/`.
+   * @returns {string|null}
    */
   GetPath(prefix) {
     return this.paths.get(normalizePathPrefix(prefix)) || null;
   }
 
-  /**
-   * Replaces the complete resource-path-to-URL resolver.
-   *
-   * @param {Function|null} resolver Resolver called as `(resourcePath, resMan)`.
-   * @returns {CjsResMan} This resource manager.
+  /**
+   * Replaces the complete resource-path-to-URL resolver.
+   *
+   * @param {Function|null} resolver Resolver called as `(resourcePath, resMan)`.
+   * @returns {CjsResMan} This resource manager.
    */
   SetPathResolver(resolver) {
     if (resolver !== null && resolver !== undefined && typeof resolver !== "function") {
@@ -393,12 +394,12 @@ class CjsResMan extends CjsEventEmitter {
     return this;
   }
 
-  /**
-   * Builds the URL used by URL-backed providers while preserving the resource
-   * path as the canonical resource identity.
-   *
-   * @param {string} path Resource path or direct HTTP(S) URL.
-   * @returns {string} Resolved URL.
+  /**
+   * Builds the URL used by URL-backed providers while preserving the resource
+   * path as the canonical resource identity.
+   *
+   * @param {string} path Resource path or direct HTTP(S) URL.
+   * @returns {string} Resolved URL.
    */
   BuildUrl(path) {
     const normalized = normalizeResourcePath(path);
@@ -427,12 +428,12 @@ class CjsResMan extends CjsEventEmitter {
     return `${urlBase}${normalized.slice(prefixIndex + 2)}`;
   }
 
-  /**
-   * Replace the direct execution strategy used by unsupported worker
-   * operations and whenever worker loading is not selected.
-   *
-   * @param {object} loader Loader exposing `Read` and `ReadFormat`.
-   * @returns {CjsResMan} This resource manager.
+  /**
+   * Replace the direct execution strategy used by unsupported worker
+   * operations and whenever worker loading is not selected.
+   *
+   * @param {object} loader Loader exposing `Read` and `ReadFormat`.
+   * @returns {CjsResMan} This resource manager.
    */
   SetMainThreadLoader(loader) {
     assertResourceLoader(loader, "mainThreadLoader");
@@ -443,14 +444,14 @@ class CjsResMan extends CjsEventEmitter {
     return this;
   }
 
-  /**
-   * Install a worker loader instance or construct one from options.
-   *
-   * Installation does not select worker execution; call
-   * `UseWorkerLoading(true)` or pass `useWorkerLoading: true`.
-   *
-   * @param {object|null} loader Worker loader or CjsResManWorkerLoader options.
-   * @returns {CjsResMan} This resource manager.
+  /**
+   * Install a worker loader instance or construct one from options.
+   *
+   * Installation does not select worker execution; call
+   * `UseWorkerLoading(true)` or pass `useWorkerLoading: true`.
+   *
+   * @param {object|null} loader Worker loader or CjsResManWorkerLoader options.
+   * @returns {CjsResMan} This resource manager.
    */
   SetWorkerLoader(loader) {
     const wasSelected = this.resourceLoader === this.workerLoader;
@@ -469,13 +470,13 @@ class CjsResMan extends CjsEventEmitter {
     return this;
   }
 
-  /**
-   * Select worker-backed execution, lazily creating the default module worker
-   * loader when required. Unsupported sources and formats still use the
-   * configured main-thread loader.
-   *
-   * @param {boolean} [value=true] Whether worker execution is selected.
-   * @returns {CjsResMan} This resource manager.
+  /**
+   * Select worker-backed execution, lazily creating the default module worker
+   * loader when required. Unsupported sources and formats still use the
+   * configured main-thread loader.
+   *
+   * @param {boolean} [value=true] Whether worker execution is selected.
+   * @returns {CjsResMan} This resource manager.
    */
   UseWorkerLoading(value = true) {
     if (!value) {
@@ -488,27 +489,27 @@ class CjsResMan extends CjsEventEmitter {
     return this;
   }
 
-  /**
-   * Report whether worker-backed execution is the selected strategy.
-   *
-   * @returns {boolean}
+  /**
+   * Report whether worker-backed execution is the selected strategy.
+   *
+   * @returns {boolean}
    */
   IsWorkerLoading() {
     return Boolean(this.workerLoader && this.resourceLoader === this.workerLoader);
   }
 
-  /**
-   * Return unresolved requests owned by the selected/installed worker loader.
-   *
-   * @returns {number}
+  /**
+   * Return unresolved requests owned by the selected/installed worker loader.
+   *
+   * @returns {number}
    */
   GetPendingWorkers() {
     return this.workerLoader?.GetPendingCount?.() || 0;
   }
 
-  /**
-   * Enqueues a resource task on the selected execution lane for the resource
-   * manager.
+  /**
+   * Enqueues a resource task on the selected execution lane for the resource
+   * manager.
    */
   AddToQueue(queue, callback, context = null, flags = 0) {
     const task = this.QueueTask(queue, callback, context, {
@@ -525,17 +526,17 @@ class CjsResMan extends CjsEventEmitter {
     return this.GetWorkQueue(queue).Cancel(id, reason);
   }
 
-  /**
-   * Allocates the next task identifier for a selected queue for the resource
-   * manager.
+  /**
+   * Allocates the next task identifier for a selected queue for the resource
+   * manager.
    */
   GetNextIdForQueue(queue) {
     return this.GetWorkQueue(queue).GetNextId();
   }
 
-  /**
-   * Starts pending preparation work within the main-thread concurrency limit for
-   * the resource manager.
+  /**
+   * Starts pending preparation work within the main-thread concurrency limit for
+   * the resource manager.
    */
   PumpMainThreadQueue(options = {}) {
     const urgent = options.urgent === true || this.urgentResourceLoads;
@@ -548,9 +549,9 @@ class CjsResMan extends CjsEventEmitter {
     return result.processed > 0;
   }
 
-  /**
-   * Starts pending load work within the background concurrency limit for the
-   * resource manager.
+  /**
+   * Starts pending load work within the background concurrency limit for the
+   * resource manager.
    */
   PumpBackgroundQueue(options = {}) {
     const result = this._loadQueue.Pump({
@@ -561,18 +562,18 @@ class CjsResMan extends CjsEventEmitter {
     return result.processed > 0;
   }
 
-  /**
-   * Prevents the selected queue from starting additional work for the resource
-   * manager.
+  /**
+   * Prevents the selected queue from starting additional work for the resource
+   * manager.
    */
   PauseQueue(queue) {
     this.GetWorkQueue(queue).Pause();
     return this;
   }
 
-  /**
-   * Allows the selected queue to start pending work again for the resource
-   * manager.
+  /**
+   * Allows the selected queue to start pending work again for the resource
+   * manager.
    */
   ResumeQueue(queue) {
     const name = CjsResManWorkQueue.normalizeName(queue);
@@ -581,25 +582,25 @@ class CjsResMan extends CjsEventEmitter {
     return this;
   }
 
-  /**
-   * Returns the number of load tasks waiting or running for the resource
-   * manager.
+  /**
+   * Returns the number of load tasks waiting or running for the resource
+   * manager.
    */
   GetPendingLoads() {
     return this._loadQueue.GetPendingCount();
   }
 
-  /**
-   * Returns the number of preparation tasks waiting or running for the resource
-   * manager.
+  /**
+   * Returns the number of preparation tasks waiting or running for the resource
+   * manager.
    */
   GetPendingPrepares() {
     return this._prepareQueue.GetPendingCount();
   }
 
-  /**
-   * Returns queue counts and concurrency state for diagnostics for the resource
-   * manager.
+  /**
+   * Returns queue counts and concurrency state for diagnostics for the resource
+   * manager.
    */
   GetQueueStats(queue = null) {
     if (queue !== null && queue !== undefined) return this.GetWorkQueue(queue).GetStats();
@@ -609,42 +610,42 @@ class CjsResMan extends CjsEventEmitter {
     });
   }
 
-  /**
-   * Switches resource loading between normal and urgent concurrency policy for
-   * the resource manager.
+  /**
+   * Switches resource loading between normal and urgent concurrency policy for
+   * the resource manager.
    */
   SetUrgentResourceLoads(value) {
     this.urgentResourceLoads = Boolean(value);
     return this;
   }
 
-  /**
-   * Reports whether urgent resource-load scheduling is active for the resource
-   * manager.
+  /**
+   * Reports whether urgent resource-load scheduling is active for the resource
+   * manager.
    */
   IsUrgentResourceLoads() {
     return this.urgentResourceLoads;
   }
 
-  /**
-   * Reports whether any resource load or preparation remains pending for the
-   * resource manager.
+  /**
+   * Reports whether any resource load or preparation remains pending for the
+   * resource manager.
    */
   IsLoading() {
     return this.GetPendingLoads() + this.GetPendingPrepares() + this.GetPendingWorkers() > 0;
   }
 
-  /**
-   * Pump background and main-thread work, enforce the recorded-byte cache
-   * budget, then run a due automatic inactivity sweep when one has been
-   * explicitly configured. Queue work is processed before housekeeping, and
-   * manager-owned active loads/prepares hold eviction locks. No housekeeping
-   * operation fetches, prepares, or reloads source data.
-   *
-   * @param {CjsResManUpdateOptions} [options={}] Queue budgets and optional automatic-purge controls.
-   * @returns {boolean} Whether queue work ran or housekeeping released owned state.
-   * @throws {TypeError} If queue, cache, purge timing, or MotherLode policy options are invalid.
-   * @throws {AggregateError} If cache or inactivity housekeeping cannot clean one or more resources.
+  /**
+   * Pump background and main-thread work, enforce the recorded-byte cache
+   * budget, then run a due automatic inactivity sweep when one has been
+   * explicitly configured. Queue work is processed before housekeeping, and
+   * manager-owned active loads/prepares hold eviction locks. No housekeeping
+   * operation fetches, prepares, or reloads source data.
+   *
+   * @param {CjsResManUpdateOptions} [options={}] Queue budgets and optional automatic-purge controls.
+   * @returns {boolean} Whether queue work ran or housekeeping released owned state.
+   * @throws {TypeError} If queue, cache, purge timing, or MotherLode policy options are invalid.
+   * @throws {AggregateError} If cache or inactivity housekeeping cannot clean one or more resources.
    */
   Update(options = {}) {
     const loaded = this.PumpBackgroundQueue(options.background || {});
@@ -658,45 +659,45 @@ class CjsResMan extends CjsEventEmitter {
     return loaded || prepared || trimmed || purged;
   }
 
-  /**
-   * Compatibility alias for {@link CjsResMan#Update}. It uses the same queue
-   * budgets, byte-cache housekeeping, opt-in purge cadence, return value, and
-   * error behavior.
-   *
-   * @param {CjsResManUpdateOptions} [options={}] Queue budgets and optional automatic-purge controls.
-   * @returns {boolean} Whether queue work ran or housekeeping released owned state.
-   * @throws {TypeError|AggregateError} If update options or a due purge fail.
+  /**
+   * Compatibility alias for {@link CjsResMan#Update}. It uses the same queue
+   * budgets, byte-cache housekeeping, opt-in purge cadence, return value, and
+   * error behavior.
+   *
+   * @param {CjsResManUpdateOptions} [options={}] Queue budgets and optional automatic-purge controls.
+   * @returns {boolean} Whether queue work ran or housekeeping released owned state.
+   * @throws {TypeError|AggregateError} If update options or a due purge fail.
    */
   Tick(options = {}) {
     return this.Update(options);
   }
 
-  /**
-   * Wait for the manager work that exists when this method is called.
-   * The snapshot contains active queued resource load roots and direct queue
-   * tasks. A captured resource root includes every CPU-work descendant it
-   * enqueues later, while unrelated roots/tasks submitted after the call do
-   * not postpone this fence. Shared-source joins do not merge distinct roots.
-   *
-   * Failure and queued cancellation count as terminal settlement: callers
-   * observe those errors through the original operation promises, while this
-   * method resolves after every captured promise settles. By default it pumps
-   * background and main queues directly, so waiting never triggers automatic
-   * retention sweeps. Paused queues remain paused. With `pump: false`, an
-   * external driver must resume/pump queues or the returned promise may remain
-   * pending.
-   *
-   * A standalone canonical `PrepareResourceObjectQueued()` call opens a
-   * resource root. Direct `LoadResourceObject()`, direct
-   * `PrepareResourceObject()`, standalone `ReadResource()`, and standalone
-   * `ReadFormatOnce()` calls bypass the two queues and are not resource roots
-   * unless they also own a captured queue task. `WaitUrgent()` remains absent
-   * until per-item priority and urgent membership exist.
-   *
-   * @param {CjsResManWaitOptions} [options={}] Snapshot pumping and cooperative-yield controls.
-   * @returns {Promise<CjsResMan>} This manager after all captured work settles.
-   * @throws {TypeError} If options, `pump`, or `yield` are invalid.
-   * @throws {Error} If a queue pump or custom yield callback itself fails.
+  /**
+   * Wait for the manager work that exists when this method is called.
+   * The snapshot contains active queued resource load roots and direct queue
+   * tasks. A captured resource root includes every CPU-work descendant it
+   * enqueues later, while unrelated roots/tasks submitted after the call do
+   * not postpone this fence. Shared-source joins do not merge distinct roots.
+   *
+   * Failure and queued cancellation count as terminal settlement: callers
+   * observe those errors through the original operation promises, while this
+   * method resolves after every captured promise settles. By default it pumps
+   * background and main queues directly, so waiting never triggers automatic
+   * retention sweeps. Paused queues remain paused. With `pump: false`, an
+   * external driver must resume/pump queues or the returned promise may remain
+   * pending.
+   *
+   * A standalone canonical `PrepareResourceObjectQueued()` call opens a
+   * resource root. Direct `LoadResourceObject()`, direct
+   * `PrepareResourceObject()`, standalone `ReadResource()`, and standalone
+   * `ReadFormatOnce()` calls bypass the two queues and are not resource roots
+   * unless they also own a captured queue task. `WaitUrgent()` remains absent
+   * until per-item priority and urgent membership exist.
+   *
+   * @param {CjsResManWaitOptions} [options={}] Snapshot pumping and cooperative-yield controls.
+   * @returns {Promise<CjsResMan>} This manager after all captured work settles.
+   * @throws {TypeError} If options, `pump`, or `yield` are invalid.
+   * @throws {Error} If a queue pump or custom yield callback itself fails.
    */
   async Wait(options = {}) {
     if (!options || typeof options !== "object" || Array.isArray(options)) {
@@ -729,27 +730,27 @@ class CjsResMan extends CjsEventEmitter {
     return this;
   }
 
-  /**
-   * Returns the execution queue selected by its public lane name for the
-   * resource manager.
+  /**
+   * Returns the execution queue selected by its public lane name for the
+   * resource manager.
    */
   GetWorkQueue(queue) {
     return CjsResManWorkQueue.normalizeName(queue) === CjsResManQueue.MAIN ? this._prepareQueue : this._loadQueue;
   }
 
-  /**
-   * Add one low-level task to a manager queue and retain its promise only while
-   * pending so a contemporaneous {@link CjsResMan#Wait} snapshot can include
-   * it. This does not assign resource lineage to tasks the callback may submit
-   * later; callers should return/await such work or use a manager resource
-   * operation.
-   *
-   * @param {string} queue Queue name or compatibility alias.
-   * @param {Function} callback Queue callback receiving immutable task metadata.
-   * @param {*} [context=null] `this` value used to invoke the callback.
-   * @param {object|null} [metadata=null] Opaque diagnostics retained on the task.
-   * @returns {object} Queue task record containing id, queue, state, metadata, and promise.
-   * @throws {TypeError} If the queue or callback is invalid.
+  /**
+   * Add one low-level task to a manager queue and retain its promise only while
+   * pending so a contemporaneous {@link CjsResMan#Wait} snapshot can include
+   * it. This does not assign resource lineage to tasks the callback may submit
+   * later; callers should return/await such work or use a manager resource
+   * operation.
+   *
+   * @param {string} queue Queue name or compatibility alias.
+   * @param {Function} callback Queue callback receiving immutable task metadata.
+   * @param {*} [context=null] `this` value used to invoke the callback.
+   * @param {object|null} [metadata=null] Opaque diagnostics retained on the task.
+   * @returns {object} Queue task record containing id, queue, state, metadata, and promise.
+   * @throws {TypeError} If the queue or callback is invalid.
    */
   QueueTask(queue, callback, context = null, metadata = null) {
     return this.#TrackQueueTask(this.GetWorkQueue(queue).Add(callback, context, metadata));
@@ -766,9 +767,9 @@ class CjsResMan extends CjsEventEmitter {
     return this;
   }
 
-  /**
-   * Requests a later main-thread preparation scheduling pass for the resource
-   * manager.
+  /**
+   * Requests a later main-thread preparation scheduling pass for the resource
+   * manager.
    */
   ScheduleMainThreadQueue() {
     if (!this.autoPumpMainThreadQueue || this._mainThreadPumpScheduled || this._prepareQueue.IsPaused()) return this;
@@ -785,20 +786,23 @@ class CjsResMan extends CjsEventEmitter {
     return this;
   }
 
-  /**
-   * Register a resource constructor or factory for one semantic outcome.
-   * The constructor is selected by `requirement`/`payload`, never by file
-   * extension. It does not enter resource identity: re-registration affects a
-   * path/output only after its existing handle is explicitly deleted/cleared.
-   *
-   * @param {string|Function} requirement Semantic outcome key, or a constructor declaring its own `payload`.
-   * @param {Function|object|null} [Constructor=null] Resource constructor/factory, or options when the first argument is the constructor.
-   * @param {object} [options={}] Registration aliases and optional requirement/payload override.
+  /**
+   * Register a resource constructor or factory for one semantic outcome.
+   * An explicit keyed registration replaces the semantic default. Constructor
+   * shorthand is additive: when several classes declare one requirement, a
+   * matching extension handler selects the concrete class and an un-routed
+   * request fails as ambiguous. Registration does not enter resource identity:
+   * changes affect a path/output only after its existing handle is deleted.
+   *
+   * @param {string|Function} requirement Semantic outcome key, or a constructor declaring its own `payload`.
+   * @param {Function|object|null} [Constructor=null] Resource constructor/factory, or options when the first argument is the constructor.
+   * @param {object} [options={}] Registration aliases and optional requirement/payload override.
    * @param {readonly string[]} [options.aliases=[]] Additional semantic keys mapped to the same constructor.
-   * @returns {CjsResMan} This resource manager.
-   * @throws {TypeError} If the semantic key or constructor/factory is invalid.
+   * @returns {CjsResMan} This resource manager.
+   * @throws {TypeError} If the semantic key or constructor/factory is invalid.
    */
   RegisterResourceType(requirement, Constructor = null, options = {}) {
+    const inferredRequirement = typeof requirement === "function";
     if (typeof requirement === "function") {
       options = Constructor && typeof Constructor === "object" ? Constructor : {};
       Constructor = requirement;
@@ -809,25 +813,31 @@ class CjsResMan extends CjsEventEmitter {
     if (typeof Constructor !== "function") {
       throw new TypeError("CjsResMan.RegisterResourceType requires a constructor or factory.");
     }
+    const candidates = inferredRequirement ? this.#resourceTypeCandidates.get(key) || new Set() : new Set();
+    candidates.add(Constructor);
+    this.#resourceTypeCandidates.set(key, candidates);
     this.resourceTypes.set(key, Constructor);
     for (const alias of options.aliases || []) {
       const aliasKey = normalizeRequirement(alias);
-      if (aliasKey) this.resourceTypes.set(aliasKey, Constructor);
+      if (aliasKey) {
+        this.#resourceTypeCandidates.set(aliasKey, new Set([Constructor]));
+        this.resourceTypes.set(aliasKey, Constructor);
+      }
     }
     return this;
   }
 
-  /**
-   * Register the direct byte-to-object reader for one input extension.
-   * Direct loaders take precedence over registered format facades and are
-   * resolved from current setup-time configuration whenever source is read.
-   * A direct loader represents only the extension's unforced default result;
-   * multiple named outputs belong on a registered format facade.
-   *
-   * @param {string} ext Input extension with or without a leading dot.
-   * @param {Function} loader Reader receiving source bytes and an immutable preparation context.
-   * @returns {CjsResMan} This resource manager.
-   * @throws {TypeError} If the extension or loader is invalid.
+  /**
+   * Register the direct byte-to-object reader for one input extension.
+   * Direct loaders take precedence over registered format facades and are
+   * resolved from current setup-time configuration whenever source is read.
+   * A direct loader represents only the extension's unforced default result;
+   * multiple named outputs belong on a registered format facade.
+   *
+   * @param {string} ext Input extension with or without a leading dot.
+   * @param {Function} loader Reader receiving source bytes and an immutable preparation context.
+   * @returns {CjsResMan} This resource manager.
+   * @throws {TypeError} If the extension or loader is invalid.
    */
   RegisterObjectLoader(ext, loader) {
     const key = normalizeResourceExtension(ext);
@@ -837,28 +847,28 @@ class CjsResMan extends CjsEventEmitter {
     return this;
   }
 
-  /**
-   * Register a reusable format facade for each accepted input extension.
-   * Multiple candidates may share an extension and are resolved by requested
-   * output/media type or by their support probes. Defaults are copied into a
-   * deeply frozen plain-object/array snapshot so later caller mutation cannot
-   * rewrite the registered configuration. Format methods are read from the
-   * currently registered facade when an operation runs.
-   *
-   * @param {Function} Format Format facade declaring at least one `inputTypes` extension.
-   * @param {object} [defaults={}] Plain reader-option defaults to snapshot for this registration.
-   * @returns {CjsResMan} This resource manager.
-   * @throws {TypeError} If the format declaration or immutable defaults snapshot is invalid.
+  /**
+   * Register a reusable format facade for each accepted input extension.
+   * Multiple candidates may share an extension and are resolved by requested
+   * output/media type or by their support probes. Defaults are copied into a
+   * deeply frozen plain-object/array snapshot so later caller mutation cannot
+   * rewrite the registered configuration. Format methods are read from the
+   * currently registered facade when an operation runs.
+   *
+   * @param {Function} Format Format facade declaring at least one extension.
+   * @param {object} [defaults={}] Plain reader-option defaults to snapshot for this registration.
+   * @returns {CjsResMan} This resource manager.
+   * @throws {TypeError} If the format declaration or immutable defaults snapshot is invalid.
    */
   RegisterFormat(Format, defaults = {}) {
     if (typeof Format !== "function") {
       throw new TypeError("CjsResMan.RegisterFormat requires a format class.");
     }
-    if (!Array.isArray(Format.inputTypes) || Format.inputTypes.length === 0) {
-      throw new TypeError(`${Format.name || "Format"} must declare non-empty inputTypes.`);
+    if (!Array.isArray(Format.extensions) || Format.extensions.length === 0) {
+      throw new TypeError(`${Format.name || "Format"} must declare non-empty extensions.`);
     }
     const descriptor = createFormatDescriptor(Format, defaults);
-    for (const inputType of Format.inputTypes) {
+    for (const inputType of Format.extensions) {
       const key = normalizeResourceExtension(inputType);
       if (!key) continue;
       const candidates = this.formats.get(key) || [];
@@ -869,19 +879,19 @@ class CjsResMan extends CjsEventEmitter {
     return this;
   }
 
-  /**
-   * Register one extension-selected resource or object handler and its reader
-   * route. A format constructor and an ordered format array are short forms
-   * for `{ Format }` and `{ Formats }` respectively.
-   *
-   * Re-registration replaces the complete route for future uncached handles.
-   * Existing handles retain the route snapshot captured at construction.
-   *
-   * @param {string} extension Input extension with or without a leading dot.
-   * @param {Function} Handler CjsResource-compatible handler constructor.
-   * @param {Function|Function[]|object} [formatOrFormatsOrOptions={}] Reader and optional target configuration.
-   * @returns {CjsResMan} This resource manager.
-   * @throws {TypeError} If the extension, handler, formats, or target policy is invalid.
+  /**
+   * Register one extension-selected resource or object handler and its reader
+   * route. A format constructor and an ordered format array are short forms
+   * for `{ Format }` and `{ Formats }` respectively.
+   *
+   * Re-registration replaces the complete route for future uncached handles.
+   * Existing handles retain the route snapshot captured at construction.
+   *
+   * @param {string} extension Input extension with or without a leading dot.
+   * @param {Function} Handler CjsResource-compatible handler constructor.
+   * @param {Function|Function[]|object} [formatOrFormatsOrOptions={}] Reader and optional target configuration.
+   * @returns {CjsResMan} This resource manager.
+   * @throws {TypeError} If the extension, handler, formats, or target policy is invalid.
    */
   RegisterExtension(extension, Handler, formatOrFormatsOrOptions = {}) {
     const ext = normalizeResourceExtension(extension);
@@ -936,52 +946,52 @@ class CjsResMan extends CjsEventEmitter {
     return this;
   }
 
-  /**
-   * Return the current immutable explicit route for one extension.
-   *
-   * @param {string} extension Input extension with or without a leading dot.
-   * @returns {object|null} Captured route descriptor, or `null`.
+  /**
+   * Return the current immutable explicit route for one extension.
+   *
+   * @param {string} extension Input extension with or without a leading dot.
+   * @returns {object|null} Captured route descriptor, or `null`.
    */
   GetExtensionRoute(extension) {
     return this.#extensionRoutes.get(normalizeResourceExtension(extension)) || null;
   }
 
-  /**
-   * Return registered format facades for one normalized input extension.
-   *
-   * @param {string} inputType Input extension with or without a leading dot.
-   * @returns {Function[]} Detached format-class list in registration order.
+  /**
+   * Return registered format facades for one normalized input extension.
+   *
+   * @param {string} inputType Input extension with or without a leading dot.
+   * @returns {Function[]} Detached format-class list in registration order.
    */
   GetFormats(inputType) {
     return this.GetFormatDescriptors(inputType).map(descriptor => descriptor.Format);
   }
 
-  /**
-   * Select one registered format facade for an input and requested outcome.
-   *
-   * @param {string} inputType Input extension with or without a leading dot.
-   * @param {object} [options={}] Optional format, output, media type, and source-byte selectors.
-   * @returns {Function} Unambiguous selected format facade.
-   * @throws {Error} If no candidate matches or multiple candidates remain.
+  /**
+   * Select one registered format facade for an input and requested outcome.
+   *
+   * @param {string} inputType Input extension with or without a leading dot.
+   * @param {object} [options={}] Optional format, output, media type, and source-byte selectors.
+   * @returns {Function} Unambiguous selected format facade.
+   * @throws {Error} If no candidate matches or multiple candidates remain.
    */
   ResolveFormat(inputType, options = {}) {
     return this.ResolveFormatDescriptor(inputType, options).Format;
   }
 
-  /**
-   * Return the immediate canonical resource handle for a source path and
-   * promised output. Cache hits explicitly renew MotherLode activity. When
-   * `reload: true` finds an existing owner, this synchronous method returns a
-   * distinct off-registry candidate and leaves the canonical handle untouched.
-   * Calling `Ready()` on that candidate, or using `ReloadResource()` /
-   * `ReloadObject()`, prepares it and conditionally commits it through the
-   * asynchronous atomic-reload contract.
-   *
-   * @param {string} path Carbon-style source resource path.
-   * @param {object} [options={}] Promised output, semantic resource, source provenance, and reload settings.
-   * @returns {CjsResource} Canonical handle, or an off-registry reload candidate.
-   * @throws {TypeError} If the path, identity settings, or resource constructor are invalid.
-   * @throws {Error} If MotherLode is inactive or displaced-resource cleanup fails.
+  /**
+   * Return the immediate canonical resource handle for a source path and
+   * promised output. Cache hits explicitly renew MotherLode activity. When
+   * `reload: true` finds an existing owner, this synchronous method returns a
+   * distinct off-registry candidate and leaves the canonical handle untouched.
+   * Calling `Ready()` on that candidate, or using `ReloadResource()` /
+   * `ReloadObject()`, prepares it and conditionally commits it through the
+   * asynchronous atomic-reload contract.
+   *
+   * @param {string} path Carbon-style source resource path.
+   * @param {object} [options={}] Promised output, semantic resource, source provenance, and reload settings.
+   * @returns {CjsResource} Canonical handle, or an off-registry reload candidate.
+   * @throws {TypeError} If the path, identity settings, or resource constructor are invalid.
+   * @throws {Error} If MotherLode is inactive or displaced-resource cleanup fails.
    */
   GetResource(path, options = {}) {
     if (!options || typeof options !== "object" || Array.isArray(options)) {
@@ -1061,19 +1071,19 @@ class CjsResMan extends CjsEventEmitter {
     return canonical;
   }
 
-  /**
-   * Resolve one object outcome for a canonical resource identity. Concurrent
-   * callers share only the active operation. Once settled, a resident payload
-   * is returned without rereading source data and its explicit payload lease is
-   * renewed. If the payload was released, calling this method explicitly starts
-   * reconstruction; liveness queries and purge operations never do so.
-   * `sourceRevision` selects read-cache provenance but does not replace a
-   * resident payload by itself—use one-shot `reload: true` for replacement.
-   *
-   * @param {string} path Carbon-style source resource path.
-   * @param {object} [options={}] Identity, source, format, loader, and queue options.
-   * @returns {Promise<*>} In-flight, resident, or reconstructed object outcome.
-   * @throws {TypeError|Error} If path, identity, source, format, or conversion configuration is invalid.
+  /**
+   * Resolve one object outcome for a canonical resource identity. Concurrent
+   * callers share only the active operation. Once settled, a resident payload
+   * is returned without rereading source data and its explicit payload lease is
+   * renewed. If the payload was released, calling this method explicitly starts
+   * reconstruction; liveness queries and purge operations never do so.
+   * `sourceRevision` selects read-cache provenance but does not replace a
+   * resident payload by itself—use one-shot `reload: true` for replacement.
+   *
+   * @param {string} path Carbon-style source resource path.
+   * @param {object} [options={}] Identity, source, format, loader, and queue options.
+   * @returns {Promise<*>} In-flight, resident, or reconstructed object outcome.
+   * @throws {TypeError|Error} If path, identity, source, format, or conversion configuration is invalid.
    */
   GetObject(path, options = {}) {
     const resource = this.GetResource(path, options);
@@ -1108,31 +1118,31 @@ class CjsResMan extends CjsEventEmitter {
     return promise;
   }
 
-  /**
-   * Loads and hydrates an object graph through the configured resource pipeline
-   * for the resource manager.
+  /**
+   * Loads and hydrates an object graph through the configured resource pipeline
+   * for the resource manager.
    */
   LoadObject(path, options = {}) {
     return this.GetObject(path, options);
   }
 
-  /**
-   * Fetches and hydrates an object graph without retaining a resource handle for
-   * the resource manager.
+  /**
+   * Fetches and hydrates an object graph without retaining a resource handle for
+   * the resource manager.
    */
   FetchObject(path, options = {}) {
     return this.GetObject(path, options);
   }
 
-  /**
-   * Read and atomically publish a distinct replacement object while the
-   * former canonical resource remains available. This is the explicit form of
-   * `GetObject(path, { reload: true })`.
-   *
-   * @param {string} path Carbon-style source resource path.
-   * @param {object} [options={}] Identity, source, format, and queue settings.
-   * @returns {Promise<*>} Published CPU object outcome from the committed candidate.
-   * @throws {TypeError|Error|AggregateError} If candidate creation, conversion, conditional publication, or cleanup fails.
+  /**
+   * Read and atomically publish a distinct replacement object while the
+   * former canonical resource remains available. This is the explicit form of
+   * `GetObject(path, { reload: true })`.
+   *
+   * @param {string} path Carbon-style source resource path.
+   * @param {object} [options={}] Identity, source, format, and queue settings.
+   * @returns {Promise<*>} Published CPU object outcome from the committed candidate.
+   * @throws {TypeError|Error|AggregateError} If candidate creation, conversion, conditional publication, or cleanup fails.
    */
   ReloadObject(path, options = {}) {
     if (!options || typeof options !== "object" || Array.isArray(options)) {
@@ -1144,17 +1154,17 @@ class CjsResMan extends CjsEventEmitter {
     });
   }
 
-  /**
-   * Resolve and load one canonical resource handle. One-shot reload creates
-   * a distinct candidate, keeps the former good handle canonical through every
-   * asynchronous CPU operation, and returns only after an exact-owner conditional
-   * publication succeeds. Readiness receives `reload: false` because the
-   * candidate's private loader owns the one-shot freshness request.
-   *
-   * @param {string} path Carbon-style source resource path.
-   * @param {object} [options={}] Resource identity, source provenance, reload, format, and queue options.
-   * @returns {Promise<CjsResource>} Loaded canonical resource selected by this operation.
-   * @throws {TypeError|Error} If identity, source, format, conversion, or cleanup fails.
+  /**
+   * Resolve and load one canonical resource handle. One-shot reload creates
+   * a distinct candidate, keeps the former good handle canonical through every
+   * asynchronous CPU operation, and returns only after an exact-owner conditional
+   * publication succeeds. Readiness receives `reload: false` because the
+   * candidate's private loader owns the one-shot freshness request.
+   *
+   * @param {string} path Carbon-style source resource path.
+   * @param {object} [options={}] Resource identity, source provenance, reload, format, and queue options.
+   * @returns {Promise<CjsResource>} Loaded canonical resource selected by this operation.
+   * @throws {TypeError|Error} If identity, source, format, conversion, or cleanup fails.
    */
   async FetchResource(path, options = {}) {
     const resource = this.GetResource(path, options);
@@ -1166,15 +1176,15 @@ class CjsResMan extends CjsEventEmitter {
     return resource;
   }
 
-  /**
-   * Load and atomically publish a distinct replacement resource while the
-   * former canonical handle remains available. This is the explicit form of
-   * `FetchResource(path, { reload: true })`.
-   *
-   * @param {string} path Carbon-style source resource path.
-   * @param {object} [options={}] Identity, source, format, and queue settings.
-   * @returns {Promise<CjsResource>} Fully loaded committed replacement.
-   * @throws {TypeError|Error|AggregateError} If candidate creation, conversion, conditional publication, or cleanup fails.
+  /**
+   * Load and atomically publish a distinct replacement resource while the
+   * former canonical handle remains available. This is the explicit form of
+   * `FetchResource(path, { reload: true })`.
+   *
+   * @param {string} path Carbon-style source resource path.
+   * @param {object} [options={}] Identity, source, format, and queue settings.
+   * @returns {Promise<CjsResource>} Fully loaded committed replacement.
+   * @throws {TypeError|Error|AggregateError} If candidate creation, conversion, conditional publication, or cleanup fails.
    */
   ReloadResource(path, options = {}) {
     if (!options || typeof options !== "object" || Array.isArray(options)) {
@@ -1186,15 +1196,15 @@ class CjsResMan extends CjsEventEmitter {
     });
   }
 
-  /**
-   * Run or join one off-registry candidate operation. The returned promise
-   * resolves only after exact-owner publication and displaced-owner cleanup
-   * both succeed. A committed cleanup failure rejects with the new candidate
-   * still canonical and attached on the MotherLode error result.
-   *
-   * @param {object|Function} resource Candidate resource returned by `GetResource`.
-   * @param {object} options Reload source, format, and queue options.
-   * @returns {Promise<*>} Candidate object outcome after conditional publication.
+  /**
+   * Run or join one off-registry candidate operation. The returned promise
+   * resolves only after exact-owner publication and displaced-owner cleanup
+   * both succeed. A committed cleanup failure rejects with the new candidate
+   * still canonical and attached on the MotherLode error result.
+   *
+   * @param {object|Function} resource Candidate resource returned by `GetResource`.
+   * @param {object} options Reload source, format, and queue options.
+   * @returns {Promise<*>} Candidate object outcome after conditional publication.
    */
   #GetReloadCandidateObject(resource, options) {
     const candidate = this.#reloadCandidates.get(resource) || null;
@@ -1220,15 +1230,15 @@ class CjsResMan extends CjsEventEmitter {
     return operation.promise;
   }
 
-  /**
-   * Queue source/read/publication work against a detached candidate, then commit
-   * it only if its former exact owner and newest-request token remain current.
-   * Candidate work is a normal queued root visible to `Wait()` and holds one
-   * purge lock on the former good owner until settlement.
-   *
-   * @param {CjsResourceReloadCandidate} candidate Immutable candidate authority.
-   * @param {object} options Reload source, format, queue, and prepare options.
-   * @returns {Promise<*>} Published object outcome after a successful commit.
+  /**
+   * Queue source/read/publication work against a detached candidate, then commit
+   * it only if its former exact owner and newest-request token remain current.
+   * Candidate work is a normal queued root visible to `Wait()` and holds one
+   * purge lock on the former good owner until settlement.
+   *
+   * @param {CjsResourceReloadCandidate} candidate Immutable candidate authority.
+   * @param {object} options Reload source, format, queue, and prepare options.
+   * @returns {Promise<*>} Published object outcome after a successful commit.
    */
   async #RunReloadCandidate(candidate, options) {
     let committed = false;
@@ -1291,13 +1301,13 @@ class CjsResMan extends CjsEventEmitter {
     }
   }
 
-  /**
-   * Bind a successfully committed candidate and invalidate only the displaced
-   * handle's former publication generation. The resource loader is restored
-   * to ordinary canonical reconstruction behavior.
-   *
-   * @param {CjsResourceReloadCandidate} candidate Committed candidate authority.
-   * @returns {void}
+  /**
+   * Bind a successfully committed candidate and invalidate only the displaced
+   * handle's former publication generation. The resource loader is restored
+   * to ordinary canonical reconstruction behavior.
+   *
+   * @param {CjsResourceReloadCandidate} candidate Committed candidate authority.
+   * @returns {void}
    */
   #FinalizeCommittedReload(candidate) {
     this.#InvalidateResourceOwnership(candidate.expected);
@@ -1329,15 +1339,15 @@ class CjsResMan extends CjsEventEmitter {
     }
   }
 
-  /**
-   * Mark and clean a failed or stale detached candidate. The original
-   * load/prepare/stale error remains the rejection when cleanup succeeds;
-   * state-publication or cleanup errors are aggregated without touching the
-   * preserved canonical owner.
-   *
-   * @param {CjsResourceReloadCandidate} candidate Failed candidate authority.
-   * @param {*} cause Original operation failure.
-   * @returns {*} Original error or a contextual AggregateError.
+  /**
+   * Mark and clean a failed or stale detached candidate. The original
+   * load/prepare/stale error remains the rejection when cleanup succeeds;
+   * state-publication or cleanup errors are aggregated without touching the
+   * preserved canonical owner.
+   *
+   * @param {CjsResourceReloadCandidate} candidate Failed candidate authority.
+   * @param {*} cause Original operation failure.
+   * @returns {*} Original error or a contextual AggregateError.
    */
   #CreateReloadCandidateFailure(candidate, cause) {
     const errors = [cause];
@@ -1359,14 +1369,14 @@ class CjsResMan extends CjsEventEmitter {
     return error;
   }
 
-  /**
-   * Release adapter and CPU-payload ownership accumulated by an off-registry
-   * candidate. This cleanup is idempotent for CjsResource-compatible handles
-   * and never marks the never-canonical candidate `PURGED`.
-   *
-   * @param {object|Function} resource Detached reload candidate.
-   * @returns {void}
-   * @throws {AggregateError} If adapter destruction, payload release, or lifecycle detachment fails.
+  /**
+   * Release adapter and CPU-payload ownership accumulated by an off-registry
+   * candidate. This cleanup is idempotent for CjsResource-compatible handles
+   * and never marks the never-canonical candidate `PURGED`.
+   *
+   * @param {object|Function} resource Detached reload candidate.
+   * @returns {void}
+   * @throws {AggregateError} If adapter destruction, payload release, or lifecycle detachment fails.
    */
   #CleanupReloadCandidate(resource) {
     const errors = [];
@@ -1392,9 +1402,9 @@ class CjsResMan extends CjsEventEmitter {
     }
   }
 
-  /**
-   * Fetches raw source bytes through the configured resource source for the
-   * resource manager.
+  /**
+   * Fetches raw source bytes through the configured resource source for the
+   * resource manager.
    */
   Fetch(path, options = {}) {
     if (options.resource === true || options.requirement !== undefined || options.payload !== undefined) {
@@ -1409,18 +1419,18 @@ class CjsResMan extends CjsEventEmitter {
     return route?.handlerMode === ResourceHandlerMode.RESOURCE ? this.FetchResource(path, options) : this.FetchObject(path, options);
   }
 
-  /**
-   * Read and prepare an existing resource immediately, outside the manager
-   * queues. One balanced purge lock protects the canonical handle for the
-   * complete asynchronous operation; any caller-owned locks remain intact.
-   * Failure is published to the resource before rejection only while its
-   * captured ownership generation remains canonical. A detached operation
-   * preserves its original failure without changing the old handle.
-   *
-   * @param {CjsResource} resource Existing manager-bound resource handle.
-   * @param {object} [options={}] Source, format, semantic outcome, and queue options.
-   * @returns {Promise<*>} Prepared object, or the semantic resource when it owns the payload.
-   * @throws {TypeError|Error} If the resource, source, format, options, or canonical ownership are invalid.
+  /**
+   * Read and prepare an existing resource immediately, outside the manager
+   * queues. One balanced purge lock protects the canonical handle for the
+   * complete asynchronous operation; any caller-owned locks remain intact.
+   * Failure is published to the resource before rejection only while its
+   * captured ownership generation remains canonical. A detached operation
+   * preserves its original failure without changing the old handle.
+   *
+   * @param {CjsResource} resource Existing manager-bound resource handle.
+   * @param {object} [options={}] Source, format, semantic outcome, and queue options.
+   * @returns {Promise<*>} Prepared object, or the semantic resource when it owns the payload.
+   * @throws {TypeError|Error} If the resource, source, format, options, or canonical ownership are invalid.
    */
   async LoadResourceObject(resource, options = {}) {
     const read = this.#BeginReadOperation(resource.GetPath(), options);
@@ -1444,16 +1454,16 @@ class CjsResMan extends CjsEventEmitter {
     }
   }
 
-  /**
-   * Queue a source read followed by CPU conversion and publication. One balanced
-   * purge lock is acquired before request publication and released only after
-   * success or failure, preventing inactivity sweeps from detaching an active
-   * handle. The lock does not reload data and does not consume caller locks.
-   *
-   * @param {CjsResource} resource Existing manager-bound resource handle.
-   * @param {object} [options={}] Source, format, queue, and semantic outcome options.
-   * @returns {Promise<*>} Promise for the loaded object or semantic resource.
-   * @throws {TypeError} If the resource cannot be queued or its options are invalid.
+  /**
+   * Queue a source read followed by CPU conversion and publication. One balanced
+   * purge lock is acquired before request publication and released only after
+   * success or failure, preventing inactivity sweeps from detaching an active
+   * handle. The lock does not reload data and does not consume caller locks.
+   *
+   * @param {CjsResource} resource Existing manager-bound resource handle.
+   * @param {object} [options={}] Source, format, queue, and semantic outcome options.
+   * @returns {Promise<*>} Promise for the loaded object or semantic resource.
+   * @throws {TypeError} If the resource cannot be queued or its options are invalid.
    */
   QueueResourceObject(resource, options = {}) {
     const read = this.#BeginReadOperation(resource.GetPath(), options);
@@ -1485,35 +1495,35 @@ class CjsResMan extends CjsEventEmitter {
     return operation;
   }
 
-  /**
-   * Queue one source read under the selected source/path/revision identity.
-   * Cache policy is tri-state: omitted shares an in-flight or explicitly
-   * retained record, `true` additionally retains success, and `false` bypasses
-   * both sharing and retention. `reload: true` invalidates this source/path
-   * before the new task and does not cancel detached existing consumers.
-   *
-   * @param {string} path Carbon-style source resource path.
-   * @param {CjsResManReadCacheOptions} [options={}] Source, revision, reload, and cache controls forwarded to the read.
-   * @returns {Promise<*>} Promise for source bytes or source-compatible data.
-   * @throws {TypeError} If path, source, revision, or options are invalid.
+  /**
+   * Queue one source read under the selected source/path/revision identity.
+   * Cache policy is tri-state: omitted shares an in-flight or explicitly
+   * retained record, `true` additionally retains success, and `false` bypasses
+   * both sharing and retention. `reload: true` invalidates this source/path
+   * before the new task and does not cancel detached existing consumers.
+   *
+   * @param {string} path Carbon-style source resource path.
+   * @param {CjsResManReadCacheOptions} [options={}] Source, revision, reload, and cache controls forwarded to the read.
+   * @returns {Promise<*>} Promise for source bytes or source-compatible data.
+   * @throws {TypeError} If path, source, revision, or options are invalid.
    */
   QueueReadResource(path, options = {}) {
     const read = this.#BeginReadOperation(path, options);
     return this.#QueueReadResource(read.context, read.options);
   }
 
-  /**
-   * Immediately read, transform, and publish one resource payload outside the
-   * manager queues. Canonical resources capture their current ownership
-   * generation and cannot publish after deletion, clearing, or replacement;
-   * historically supported detached resource-like objects remain usable
-   * without manager ownership guards.
-   *
-   * @param {object|Function} resource Resource receiving the final payload.
-   * @param {*} bytes Source bytes or reader-compatible source data.
-   * @param {object} [options={}] Format and semantic outcome options.
-   * @returns {Promise<*>} Final plain payload or semantic resource handle.
-   * @throws {Error} If reading/preparation fails or canonical ownership becomes stale.
+  /**
+   * Immediately read, transform, and publish one resource payload outside the
+   * manager queues. Canonical resources capture their current ownership
+   * generation and cannot publish after deletion, clearing, or replacement;
+   * historically supported detached resource-like objects remain usable
+   * without manager ownership guards.
+   *
+   * @param {object|Function} resource Resource receiving the final payload.
+   * @param {*} bytes Source bytes or reader-compatible source data.
+   * @param {object} [options={}] Format and semantic outcome options.
+   * @returns {Promise<*>} Final plain payload or semantic resource handle.
+   * @throws {Error} If reading/preparation fails or canonical ownership becomes stale.
    */
   async PrepareResourceObject(resource, bytes, options = {}) {
     const ownership = this.#GetResourceOwnership(resource, "direct-prepare:begin");
@@ -1530,18 +1540,18 @@ class CjsResMan extends CjsEventEmitter {
     }
   }
 
-  /**
-   * Queue one reader/format conversion and then CPU publication on the main
-   * manager queue. A canonical standalone call becomes a queued resource root
-   * for `Wait()` and retains one balanced purge lock through settlement.
-   * The read and publication items validate the captured canonical generation
-   * before dispatch and after asynchronous settlement.
-   *
-   * @param {object|Function} resource Resource receiving the final payload.
-   * @param {*} bytes Source bytes or reader-compatible source data.
-   * @param {object} [options={}] Format and semantic outcome options.
-   * @returns {Promise<*>} Final plain payload or semantic resource handle.
-   * @throws {Error} If queueing/preparation fails or canonical ownership becomes stale.
+  /**
+   * Queue one reader/format conversion and then CPU publication on the main
+   * manager queue. A canonical standalone call becomes a queued resource root
+   * for `Wait()` and retains one balanced purge lock through settlement.
+   * The read and publication items validate the captured canonical generation
+   * before dispatch and after asynchronous settlement.
+   *
+   * @param {object|Function} resource Resource receiving the final payload.
+   * @param {*} bytes Source bytes or reader-compatible source data.
+   * @param {object} [options={}] Format and semantic outcome options.
+   * @returns {Promise<*>} Final plain payload or semantic resource handle.
+   * @throws {Error} If queueing/preparation fails or canonical ownership becomes stale.
    */
   async PrepareResourceObjectQueued(resource, bytes, options = {}) {
     const ownership = this.#GetResourceOwnership(resource, "queued-prepare:begin");
@@ -1558,16 +1568,16 @@ class CjsResMan extends CjsEventEmitter {
     }
   }
 
-  /**
-   * Read and immediately publish one CPU payload with optional hidden
-   * ownership authority. Format classes own every requested conversion;
-   * backend realization runs separately after this CPU publication.
-   *
-   * @param {object|Function} resource Resource receiving the final payload.
-   * @param {*} bytes Source bytes or reader-compatible source data.
-   * @param {object} options Resolved prepare options.
-   * @param {CjsResourceMutationAuthority|null} ownership Captured canonical or reload-candidate authority.
-   * @returns {Promise<*>} Final plain payload or semantic resource handle.
+  /**
+   * Read and immediately publish one CPU payload with optional hidden
+   * ownership authority. Format classes own every requested conversion;
+   * backend realization runs separately after this CPU publication.
+   *
+   * @param {object|Function} resource Resource receiving the final payload.
+   * @param {*} bytes Source bytes or reader-compatible source data.
+   * @param {object} options Resolved prepare options.
+   * @param {CjsResourceMutationAuthority|null} ownership Captured canonical or reload-candidate authority.
+   * @returns {Promise<*>} Final plain payload or semantic resource handle.
    */
   async #PrepareResourceObject(resource, bytes, options, ownership) {
     this.#AssertOptionalResourceOwnership(ownership, "prepare:read");
@@ -1578,16 +1588,16 @@ class CjsResMan extends CjsEventEmitter {
     return this.#PublishResourceObject(ownership, resource, object, options);
   }
 
-  /**
-   * Queue one main-thread reader/format operation followed by guarded CPU
-   * publication. Both remain distinct budgeted queue items under one resource
-   * root so `Wait()` continues to fence dynamically enqueued publication.
-   *
-   * @param {object|Function} resource Resource receiving the final payload.
-   * @param {*} bytes Source bytes or reader-compatible source data.
-   * @param {object} options Resolved prepare options.
-   * @param {CjsResourceMutationAuthority|null} ownership Captured canonical or reload-candidate authority.
-   * @returns {Promise<*>} Final plain payload or semantic resource handle.
+  /**
+   * Queue one main-thread reader/format operation followed by guarded CPU
+   * publication. Both remain distinct budgeted queue items under one resource
+   * root so `Wait()` continues to fence dynamically enqueued publication.
+   *
+   * @param {object|Function} resource Resource receiving the final payload.
+   * @param {*} bytes Source bytes or reader-compatible source data.
+   * @param {object} options Resolved prepare options.
+   * @param {CjsResourceMutationAuthority|null} ownership Captured canonical or reload-candidate authority.
+   * @returns {Promise<*>} Final plain payload or semantic resource handle.
    */
   async #PrepareResourceObjectQueued(resource, bytes, options, ownership) {
     let object = bytes;
@@ -1629,29 +1639,29 @@ class CjsResMan extends CjsEventEmitter {
     return object;
   }
 
-  /**
-   * Decode source bytes with the currently registered reader for the resource
-   * extension. A direct extension loader wins over registered format candidates;
-   * byte support probes may disambiguate those candidates.
-   *
-   * @param {CjsResource} resource Resource whose reader outcome is requested.
-   * @param {*} bytes Source byte payload.
-   * @param {object} [options={}] Requested output plus per-operation controls.
-   * @returns {Promise<*>} Direct-loader or registered-format reader outcome.
-   * @throws {Error|TypeError} If no registered reader matches or its read contract fails.
+  /**
+   * Decode source bytes with the currently registered reader for the resource
+   * extension. A direct extension loader wins over registered format candidates;
+   * byte support probes may disambiguate those candidates.
+   *
+   * @param {CjsResource} resource Resource whose reader outcome is requested.
+   * @param {*} bytes Source byte payload.
+   * @param {object} [options={}] Requested output plus per-operation controls.
+   * @returns {Promise<*>} Direct-loader or registered-format reader outcome.
+   * @throws {Error|TypeError} If no registered reader matches or its read contract fails.
    */
   async ReadResourceObjectPayload(resource, bytes, options = {}) {
     return this.#ReadResolvedResourceObjectPayload(resource, bytes, options, this.#ResolveResourceObjectRead(resource, bytes, options));
   }
 
-  /**
-   * Resolve the configured direct loader or format descriptor once so queue
-   * selection and execution use the same registration snapshot.
-   *
-   * @param {CjsResource} resource Resource whose CPU outcome is requested.
-   * @param {*} bytes Source input.
-   * @param {object} options Requested output options.
-   * @returns {{loader: Function|null, descriptor: object|null, route: object|null}} Resolved reader.
+  /**
+   * Resolve the configured direct loader or format descriptor once so queue
+   * selection and execution use the same registration snapshot.
+   *
+   * @param {CjsResource} resource Resource whose CPU outcome is requested.
+   * @param {*} bytes Source input.
+   * @param {object} options Requested output options.
+   * @returns {{loader: Function|null, descriptor: object|null, route: object|null}} Resolved reader.
    */
   #ResolveResourceObjectRead(resource, bytes, options) {
     const route = this.#resourceExtensionRoutes.get(resource) || null;
@@ -1679,14 +1689,14 @@ class CjsResMan extends CjsEventEmitter {
     };
   }
 
-  /**
-   * Execute one already-resolved reader through its direct or format path.
-   *
-   * @param {CjsResource} resource Resource whose CPU outcome is requested.
-   * @param {*} bytes Source input.
-   * @param {object} options Requested output options.
-   * @param {{loader: Function|null, descriptor: object|null}} resolved Reader selection.
-   * @returns {Promise<*>} Reader result.
+  /**
+   * Execute one already-resolved reader through its direct or format path.
+   *
+   * @param {CjsResource} resource Resource whose CPU outcome is requested.
+   * @param {*} bytes Source input.
+   * @param {object} options Requested output options.
+   * @param {{loader: Function|null, descriptor: object|null}} resolved Reader selection.
+   * @returns {Promise<*>} Reader result.
    */
   #ReadResolvedResourceObjectPayload(resource, bytes, options, resolved) {
     if (resolved.loader) {
@@ -1695,16 +1705,16 @@ class CjsResMan extends CjsEventEmitter {
     return this.ReadFormatOnce(resource, resolved.descriptor, bytes, options);
   }
 
-  /**
-   * Apply a fixed target or dynamic identification policy after format reading
-   * and before payload publication. Worker decoding has settled by this point,
-   * so constructors and Identify functions remain on the caller thread.
-   *
-   * @param {CjsResource} resource Route handler receiving the decoded value.
-   * @param {*} values Decoded format result.
-   * @param {object} options Request options.
-   * @param {{descriptor: object|null, route: object|null}} resolved Captured reader route.
-   * @returns {*} Original or hydrated object value.
+  /**
+   * Apply a fixed target or dynamic identification policy after format reading
+   * and before payload publication. Worker decoding has settled by this point,
+   * so constructors and Identify functions remain on the caller thread.
+   *
+   * @param {CjsResource} resource Route handler receiving the decoded value.
+   * @param {*} values Decoded format result.
+   * @param {object} options Request options.
+   * @param {{descriptor: object|null, route: object|null}} resolved Captured reader route.
+   * @returns {*} Original or hydrated object value.
    */
   #HydrateExtensionObject(resource, values, options, resolved) {
     const route = resolved.route;
@@ -1745,19 +1755,19 @@ class CjsResMan extends CjsEventEmitter {
     }
   }
 
-  /**
-   * Publish the final CPU object outcome and loaded state. Every
-   * CjsResource-compatible handle owns the reader/converter result through
-   * `SetPayload`, making CPU payloads visible to MotherLode retention policy.
-   * Base resources also expose the payload through the compatibility `object`
-   * alias; semantic subclasses continue to return and alias the resource while
-   * retaining their validated payload privately.
-   *
-   * @param {CjsResource} resource Target canonical resource handle.
-   * @param {*} object Final reader or format-converter outcome.
-   * @param {object} [options={}] Semantic resource validation/publication options.
-   * @returns {*} Plain payload for a base resource, or the semantic resource handle.
-   * @throws {TypeError|Error} If ownership, semantic payload validation, or loaded-state publication fails.
+  /**
+   * Publish the final CPU object outcome and loaded state. Every
+   * CjsResource-compatible handle owns the reader/converter result through
+   * `SetPayload`, making CPU payloads visible to MotherLode retention policy.
+   * Base resources also expose the payload through the compatibility `object`
+   * alias; semantic subclasses continue to return and alias the resource while
+   * retaining their validated payload privately.
+   *
+   * @param {CjsResource} resource Target canonical resource handle.
+   * @param {*} object Final reader or format-converter outcome.
+   * @param {object} [options={}] Semantic resource validation/publication options.
+   * @returns {*} Plain payload for a base resource, or the semantic resource handle.
+   * @throws {TypeError|Error} If ownership, semantic payload validation, or loaded-state publication fails.
    */
   PublishResourceObject(resource, object, options = {}) {
     const ownership = this.#GetResourceOwnership(resource, "publish:begin");
@@ -1772,16 +1782,16 @@ class CjsResMan extends CjsEventEmitter {
     }
   }
 
-  /**
-   * Publish only while the captured resource authority remains canonical.
-   * The post-publication check catches synchronous reentrant ownership changes
-   * from state listeners before the caller can treat obsolete work as success.
-   *
-   * @param {CjsResourceMutationAuthority|null} ownership Captured canonical or reload-candidate authority.
-   * @param {object|Function} resource Resource receiving the final payload.
-   * @param {*} object Final reader/converter outcome.
-   * @param {object} options Semantic resource publication options.
-   * @returns {*} Plain payload or semantic resource handle.
+  /**
+   * Publish only while the captured resource authority remains canonical.
+   * The post-publication check catches synchronous reentrant ownership changes
+   * from state listeners before the caller can treat obsolete work as success.
+   *
+   * @param {CjsResourceMutationAuthority|null} ownership Captured canonical or reload-candidate authority.
+   * @param {object|Function} resource Resource receiving the final payload.
+   * @param {*} object Final reader/converter outcome.
+   * @param {object} options Semantic resource publication options.
+   * @returns {*} Plain payload or semantic resource handle.
    */
   #PublishResourceObject(ownership, resource, object, options) {
     this.#AssertOptionalResourceOwnership(ownership, "publish");
@@ -1790,81 +1800,70 @@ class CjsResMan extends CjsEventEmitter {
     return result;
   }
 
-  /**
-   * Apply the unguarded synchronous payload/state mutation after the caller
-   * has established any required canonical authority.
-   *
-   * @param {object|Function} resource Resource receiving the final payload.
-   * @param {*} object Final reader/converter outcome.
-   * @param {object} options Semantic resource publication options.
-   * @returns {*} Plain payload or semantic resource handle.
+  /**
+   * Apply the unguarded synchronous payload/state mutation after the caller
+   * has established any required canonical authority.
+   *
+   * @param {object|Function} resource Resource receiving the final payload.
+   * @param {*} object Final reader/converter outcome.
+   * @param {object} options Semantic resource publication options.
+   * @returns {*} Plain payload or semantic resource handle.
    */
   #PublishResourceObjectValue(resource, object, options) {
-    let result = object;
-    const route = this.#resourceExtensionRoutes.get(resource) || null;
-    const handlerMode = route ? this.#resourceHandlerModes.get(resource) : null;
-    if (handlerMode === ResourceHandlerMode.RESOURCE) {
-      resource.SetPayload?.(object, options);
-      resource.object = resource;
-      result = resource;
-    } else if (handlerMode === ResourceHandlerMode.OBJECT) {
-      resource.SetPayload?.(object, options);
-      resource.object = object;
-    } else if (resource.constructor !== CjsResource && typeof resource.SetPayload === "function") {
-      resource.SetPayload(object, options);
-      resource.object = resource;
-      result = resource;
-    } else {
-      resource.SetPayload?.(object, options);
-      resource.object = object;
-    }
+    const mode = resolveResourceHandlerMode(resource, this.#resourceExtensionRoutes.get(resource) ? this.#resourceHandlerModes.get(resource) : null);
+    resource.SetPayload?.(object, options);
+    // The two modes differ in one thing only: what `object` names and what the
+    // caller is handed back. RESOURCE publishes the stable handle, so both
+    // point at the resource; OBJECT publishes the reader outcome.
+    const published = mode === ResourceHandlerMode.RESOURCE ? resource : object;
+    resource.object = published;
     // PREPARED, not LOADED: `object` is the reader/converter OUTCOME, so the
     // bytes have already been turned into whatever they needed to become.
     // LOADED means raw source data is in hand and still has to be prepared - a
     // resource in that state is not yet good, and marking it here left IsGood()
     // permanently false for every resource that does not prepare itself.
     if (!resource.IsPrepared?.()) resource.MarkPrepared();
-    return result;
+    return published;
   }
 
-  /**
-   * Warms a resource and its discovered dependencies without returning payload
-   * data for the resource manager.
+  /**
+   * Warms a resource and its discovered dependencies without returning payload
+   * data for the resource manager.
    */
   async Prefetch(paths, options = {}) {
     const entries = Array.isArray(paths) ? paths : [paths];
     return Promise.all(entries.map(path => this.LoadObject(path, options)));
   }
 
-  /**
-   * Return the currently registered direct reader for an input extension.
-   *
-   * @param {string} ext Input extension with or without a leading dot.
-   * @returns {Function|null} Registered loader or `null`.
+  /**
+   * Return the currently registered direct reader for an input extension.
+   *
+   * @param {string} ext Input extension with or without a leading dot.
+   * @returns {Function|null} Registered loader or `null`.
    */
   GetObjectLoader(ext) {
     return this.objectLoaders.get(normalizeResourceExtension(ext)) || null;
   }
 
-  /**
-   * Return detached references to the current format descriptors for one input
-   * extension. Each descriptor contains its facade and frozen defaults.
-   *
-   * @param {string} inputType Input extension with or without a leading dot.
-   * @returns {object[]} Descriptor list in registration order.
+  /**
+   * Return detached references to the current format descriptors for one input
+   * extension. Each descriptor contains its facade and frozen defaults.
+   *
+   * @param {string} inputType Input extension with or without a leading dot.
+   * @returns {object[]} Descriptor list in registration order.
    */
   GetFormatDescriptors(inputType) {
     return [...(this.formats.get(normalizeResourceExtension(inputType)) || [])];
   }
 
-  /**
-   * Resolve one current format registration descriptor. Output/media filters
-   * run first; optional source bytes may then run support probes to disambiguate.
-   *
-   * @param {string} inputType Input extension with or without a leading dot.
-   * @param {object} [options={}] Format, output, media type, and optional byte selectors.
-   * @returns {object} Selected immutable registration descriptor.
-   * @throws {Error} If no candidate matches or multiple candidates remain.
+  /**
+   * Resolve one current format registration descriptor. Output/media filters
+   * run first; optional source bytes may then run support probes to disambiguate.
+   *
+   * @param {string} inputType Input extension with or without a leading dot.
+   * @param {object} [options={}] Format, output, media type, and optional byte selectors.
+   * @returns {object} Selected immutable registration descriptor.
+   * @throws {Error} If no candidate matches or multiple candidates remain.
    */
   ResolveFormatDescriptor(inputType, options = {}) {
     const key = normalizeResourceExtension(inputType);
@@ -1876,19 +1875,19 @@ class CjsResMan extends CjsEventEmitter {
     return resolveFormatDescriptorCandidates(candidates, key, options);
   }
 
-  /**
-   * Invoke one format descriptor using its frozen registration defaults and
-   * the request's explicit format options. Static async/sync readers take
-   * precedence over instance `ReadAsync`/`Read` compatibility methods.
-   *
-   * @param {object} descriptor Selected immutable registration descriptor.
-   * @param {*} bytes Source bytes supplied to the format facade.
-   * @param {object} [options={}] Output, class, and `formatOptions` overrides.
-   * @returns {Promise<*>} Parsed format outcome.
-   * @throws {TypeError|Error} If the facade lacks a reader or reading fails.
-   * @remarks Resource-backed calls pass normalized path context as the
-   * reader's third argument; direct descriptor reads without a resource pass
-   * `null`.
+  /**
+   * Invoke one format descriptor using its frozen registration defaults and
+   * the request's explicit format options. Static async/sync readers take
+   * precedence over instance `ReadAsync`/`Read` compatibility methods.
+   *
+   * @param {object} descriptor Selected immutable registration descriptor.
+   * @param {*} bytes Source bytes supplied to the format facade.
+   * @param {object} [options={}] Output, class, and `formatOptions` overrides.
+   * @returns {Promise<*>} Parsed format outcome.
+   * @throws {TypeError|Error} If the facade lacks a reader or reading fails.
+   * @remarks Resource-backed calls pass normalized path context as the
+   * reader's third argument; direct descriptor reads without a resource pass
+   * `null`.
    */
   async ReadFormat(descriptor, bytes, options = {}) {
     const readContext = READ_CONTEXTS.get(options);
@@ -1896,14 +1895,14 @@ class CjsResMan extends CjsEventEmitter {
     return this.resourceLoader.ReadFormat(descriptor, bytes, createFormatReadOptions(descriptor, options), context);
   }
 
-  /**
-   * Look up and explicitly renew an existing canonical resource without
-   * creating, loading, or preparing a new handle.
-   *
-   * @param {string} path Carbon-style source resource path.
-   * @param {object} [options={}] Identity-defining resource outcome settings.
-   * @returns {CjsResource|null} Existing canonical handle, or `null` when absent.
-   * @throws {TypeError} If the path or identity settings cannot be normalized.
+  /**
+   * Look up and explicitly renew an existing canonical resource without
+   * creating, loading, or preparing a new handle.
+   *
+   * @param {string} path Carbon-style source resource path.
+   * @param {object} [options={}] Identity-defining resource outcome settings.
+   * @returns {CjsResource|null} Existing canonical handle, or `null` when absent.
+   * @throws {TypeError} If the path or identity settings cannot be normalized.
    */
   Lookup(path, options = {}) {
     const normalizedPath = normalizeResourcePath(path);
@@ -1916,18 +1915,18 @@ class CjsResMan extends CjsEventEmitter {
     return resource;
   }
 
-  /**
-   * Forget and clean canonical resources for a source path. Omitting options
-   * removes every resolved variant; supplying options removes only the exact
-   * identity derived from those outcome settings. Explicitly retained source
-   * and format records are independent and remain available; call
-   * {@link CjsResMan#InvalidateReadCache} when they must also be forgotten.
-   *
-   * @param {string} path Carbon-style source resource path.
-   * @param {object|null} [options=null] Exact identity settings, or `null` for all variants.
-   * @returns {boolean} Whether at least one canonical resource was removed.
-   * @throws {TypeError} If the path or identity settings cannot be normalized.
-   * @throws {Error|AggregateError} If cleanup fails after identities are forgotten.
+  /**
+   * Forget and clean canonical resources for a source path. Omitting options
+   * removes every resolved variant; supplying options removes only the exact
+   * identity derived from those outcome settings. Explicitly retained source
+   * and format records are independent and remain available; call
+   * {@link CjsResMan#InvalidateReadCache} when they must also be forgotten.
+   *
+   * @param {string} path Carbon-style source resource path.
+   * @param {object|null} [options=null] Exact identity settings, or `null` for all variants.
+   * @returns {boolean} Whether at least one canonical resource was removed.
+   * @throws {TypeError} If the path or identity settings cannot be normalized.
+   * @throws {Error|AggregateError} If cleanup fails after identities are forgotten.
    */
   Delete(path, options = null) {
     if (options !== null && options !== undefined) {
@@ -1958,15 +1957,15 @@ class CjsResMan extends CjsEventEmitter {
     }
   }
 
-  /**
-   * Run one explicit deterministic identity/payload inactivity sweep.
-   * This delegates policy and cleanup to MotherLode; it never fetches or
-   * reloads a purged resource.
-   *
-   * @param {object} [options={}] MotherLode frame/time limits and cleanup policy.
-   * @returns {object} Immutable purge counts and affected canonical keys.
-   * @throws {TypeError} If the configured MotherLode lacks purge support or policy is invalid.
-   * @throws {AggregateError} If one or more candidate resources fail cleanup.
+  /**
+   * Run one explicit deterministic identity/payload inactivity sweep.
+   * This delegates policy and cleanup to MotherLode; it never fetches or
+   * reloads a purged resource.
+   *
+   * @param {object} [options={}] MotherLode frame/time limits and cleanup policy.
+   * @returns {object} Immutable purge counts and affected canonical keys.
+   * @throws {TypeError} If the configured MotherLode lacks purge support or policy is invalid.
+   * @throws {AggregateError} If one or more candidate resources fail cleanup.
    */
   PurgeInactive(options = {}) {
     if (typeof this.motherLode?.PurgeInactive !== "function") {
@@ -1975,16 +1974,16 @@ class CjsResMan extends CjsEventEmitter {
     return this.motherLode.PurgeInactive(options);
   }
 
-  /**
-   * Replace or disable the opt-in automatic inactivity policy. Configuration
-   * resets cadence, so the first subsequent pump performs a sweep immediately.
-   * Frame-based limits are rejected because manager updates are not a reliable
-   * renderer-frame clock. The normalized policy is frozen and never reloads
-   * resources.
-   *
-   * @param {CjsResManAutoPurgePolicy|false|null} [policy=null] Time-based policy, or `false`/`null` to disable automatic sweeping.
-   * @returns {CjsResMan} This resource manager.
-   * @throws {TypeError} If the policy, threshold, cleanup control, or clock is invalid.
+  /**
+   * Replace or disable the opt-in automatic inactivity policy. Configuration
+   * resets cadence, so the first subsequent pump performs a sweep immediately.
+   * Frame-based limits are rejected because manager updates are not a reliable
+   * renderer-frame clock. The normalized policy is frozen and never reloads
+   * resources.
+   *
+   * @param {CjsResManAutoPurgePolicy|false|null} [policy=null] Time-based policy, or `false`/`null` to disable automatic sweeping.
+   * @returns {CjsResMan} This resource manager.
+   * @throws {TypeError} If the policy, threshold, cleanup control, or clock is invalid.
    */
   SetAutoPurgePolicy(policy = null) {
     this.#autoPurgePolicy = normalizeAutoPurgePolicy(policy);
@@ -1992,36 +1991,36 @@ class CjsResMan extends CjsEventEmitter {
     return this;
   }
 
-  /**
-   * Return the immutable normalized automatic inactivity policy.
-   *
-   * @returns {Readonly<CjsResManAutoPurgePolicy>|null} Active policy, or `null` when automatic sweeping is disabled.
+  /**
+   * Return the immutable normalized automatic inactivity policy.
+   *
+   * @returns {Readonly<CjsResManAutoPurgePolicy>|null} Active policy, or `null` when automatic sweeping is disabled.
    */
   GetAutoPurgePolicy() {
     return this.#autoPurgePolicy;
   }
 
-  /**
-   * Report whether {@link CjsResMan#Update} may run automatic inactivity
-   * sweeps. This is a pure query and does not advance cadence or activity.
-   *
-   * @returns {boolean} Whether an automatic purge policy is configured.
+  /**
+   * Report whether {@link CjsResMan#Update} may run automatic inactivity
+   * sweeps. This is a pure query and does not advance cadence or activity.
+   *
+   * @returns {boolean} Whether an automatic purge policy is configured.
    */
   IsAutoPurgeEnabled() {
     return this.#autoPurgePolicy !== null;
   }
 
-  /**
-   * Run the configured automatic sweep when its minimum time interval has
-   * elapsed. The first pump after configuration runs immediately. A regressing
-   * clock rebases cadence and skips that pump; failures consume the interval so
-   * repeated updates cannot form a cleanup-error storm. This method never
-   * creates, fetches, prepares, or reloads a resource.
-   *
-   * @param {CjsResManAutoPurgePumpOptions} [options={}] Optional deterministic timestamp.
-   * @returns {object|null} Immutable MotherLode purge result when due, otherwise `null`.
-   * @throws {TypeError} If options, the clock result, or MotherLode purge policy are invalid.
-   * @throws {AggregateError} If a due sweep cannot clean one or more inactive resources.
+  /**
+   * Run the configured automatic sweep when its minimum time interval has
+   * elapsed. The first pump after configuration runs immediately. A regressing
+   * clock rebases cadence and skips that pump; failures consume the interval so
+   * repeated updates cannot form a cleanup-error storm. This method never
+   * creates, fetches, prepares, or reloads a resource.
+   *
+   * @param {CjsResManAutoPurgePumpOptions} [options={}] Optional deterministic timestamp.
+   * @returns {object|null} Immutable MotherLode purge result when due, otherwise `null`.
+   * @throws {TypeError} If options, the clock result, or MotherLode purge policy are invalid.
+   * @throws {AggregateError} If a due sweep cannot clean one or more inactive resources.
    */
   PumpAutoPurge(options = {}) {
     const pump = normalizeAutoPurgePumpOptions(options);
@@ -2051,12 +2050,12 @@ class CjsResMan extends CjsEventEmitter {
     });
   }
 
-  /**
-   * Cancel queued-but-not-started work, remove every canonical resource through
-   * MotherLode cleanup, and reset all in-flight deduplication ledgers.
-   *
-   * @returns {CjsResMan} This empty resource manager.
-   * @throws {AggregateError} If one or more canonical resources fail cleanup.
+  /**
+   * Cancel queued-but-not-started work, remove every canonical resource through
+   * MotherLode cleanup, and reset all in-flight deduplication ledgers.
+   *
+   * @returns {CjsResMan} This empty resource manager.
+   * @throws {AggregateError} If one or more canonical resources fail cleanup.
    */
   Clear() {
     this.#InvalidateMotherLodeOwnership(this.motherLode);
@@ -2072,21 +2071,21 @@ class CjsResMan extends CjsEventEmitter {
     return this;
   }
 
-  /**
-   * Detach reusable source and parsed-format records for one source path.
-   * Omitting `sourceRevision` removes every revision for the selected source;
-   * supplying it removes only that string/finite-number revision. Existing
-   * consumers keep their promises: invalidation does not abort, reject, touch
-   * MotherLode/payload ownership, or perform source work.
-   *
-   * `Delete()` deliberately remains resource-identity-only. Use this method
-   * when explicitly retained read caches must also be forgotten; `Clear()`
-   * resets every read ledger.
-   *
-   * @param {string} path Carbon-style source resource path.
-   * @param {CjsResManReadCacheOptions} [options={}] Optional `source` and exact `sourceRevision` selection.
-   * @returns {Readonly<{path: string, queuedSource: number, source: number, format: number}>} Frozen detached-record counts.
-   * @throws {TypeError} If path, source, revision, or options are invalid.
+  /**
+   * Detach reusable source and parsed-format records for one source path.
+   * Omitting `sourceRevision` removes every revision for the selected source;
+   * supplying it removes only that string/finite-number revision. Existing
+   * consumers keep their promises: invalidation does not abort, reject, touch
+   * MotherLode/payload ownership, or perform source work.
+   *
+   * `Delete()` deliberately remains resource-identity-only. Use this method
+   * when explicitly retained read caches must also be forgotten; `Clear()`
+   * resets every read ledger.
+   *
+   * @param {string} path Carbon-style source resource path.
+   * @param {CjsResManReadCacheOptions} [options={}] Optional `source` and exact `sourceRevision` selection.
+   * @returns {Readonly<{path: string, queuedSource: number, source: number, format: number}>} Frozen detached-record counts.
+   * @throws {TypeError} If path, source, revision, or options are invalid.
    */
   InvalidateReadCache(path, options = {}) {
     if (!options || typeof options !== "object" || Array.isArray(options)) {
@@ -2110,33 +2109,33 @@ class CjsResMan extends CjsEventEmitter {
     return this.#InvalidateReadCache(source, normalizedPath, revisionKey);
   }
 
-  /**
-   * Read source data under source/path/revision cache identity. Cache policy is
-   * tri-state: omitted shares in-flight or explicitly retained work, `true`
-   * retains success, and `false` bypasses sharing and retention. Failures are
-   * never retained. A joining `true` request upgrades the shared record.
-   *
-   * `reload: true` invalidates the selected source/path synchronously before
-   * beginning fresh work; it does not cancel already detached consumers.
-   *
-   * @param {string} path Carbon-style source resource path.
-   * @param {CjsResManReadCacheOptions} [options={}] Source, revision, reload, and cache controls forwarded to the source.
-   * @returns {Promise<*>} Promise for bytes or source-compatible data.
-   * @throws {TypeError} If path, source, revision, cache policy, or options are invalid.
+  /**
+   * Read source data under source/path/revision cache identity. Cache policy is
+   * tri-state: omitted shares in-flight or explicitly retained work, `true`
+   * retains success, and `false` bypasses sharing and retention. Failures are
+   * never retained. A joining `true` request upgrades the shared record.
+   *
+   * `reload: true` invalidates the selected source/path synchronously before
+   * beginning fresh work; it does not cancel already detached consumers.
+   *
+   * @param {string} path Carbon-style source resource path.
+   * @param {CjsResManReadCacheOptions} [options={}] Source, revision, reload, and cache controls forwarded to the source.
+   * @returns {Promise<*>} Promise for bytes or source-compatible data.
+   * @throws {TypeError} If path, source, revision, cache policy, or options are invalid.
    */
   ReadResource(path, options = {}) {
     const read = this.#BeginReadOperation(path, options);
     return this.#ReadResource(read.context, read.options);
   }
 
-  /**
-   * Normalize one source provenance context and invalidate stale path records
-   * once at the outermost reload boundary.
-   *
-   * @param {string} path Source path.
-   * @param {object} options Read options.
-   * @returns {{context: Readonly<CjsResourceReadContext>, options: object}} Context and detached operation options.
-   * @throws {TypeError} If source provenance or options are invalid.
+  /**
+   * Normalize one source provenance context and invalidate stale path records
+   * once at the outermost reload boundary.
+   *
+   * @param {string} path Source path.
+   * @param {object} options Read options.
+   * @returns {{context: Readonly<CjsResourceReadContext>, options: object}} Context and detached operation options.
+   * @throws {TypeError} If source provenance or options are invalid.
    */
   #BeginReadOperation(path, options) {
     if (!options || typeof options !== "object" || Array.isArray(options)) {
@@ -2187,13 +2186,13 @@ class CjsResMan extends CjsEventEmitter {
     };
   }
 
-  /**
-   * Queue one normalized source operation and deduplicate according to the
-   * caller's cache policy.
-   *
-   * @param {Readonly<CjsResourceReadContext>} context Normalized provenance.
-   * @param {object} options Detached read options.
-   * @returns {Promise<*>} Promise for source bytes/data.
+  /**
+   * Queue one normalized source operation and deduplicate according to the
+   * caller's cache policy.
+   *
+   * @param {Readonly<CjsResourceReadContext>} context Normalized provenance.
+   * @param {object} options Detached read options.
+   * @returns {Promise<*>} Promise for source bytes/data.
    */
   #QueueReadResource(context, options) {
     const cachePolicy = normalizeCachePolicy(options.cacheSource, "cacheSource");
@@ -2232,13 +2231,13 @@ class CjsResMan extends CjsEventEmitter {
     return record.promise;
   }
 
-  /**
-   * Run or join one normalized direct source operation.
-   *
-   * @param {Readonly<CjsResourceReadContext>} context Normalized provenance.
-   * @param {object} options Detached read options.
-   * @param {CjsResourceReadOperationRecord|null} [queuedRecord=null] Parent queued record whose retention may be promoted by a later join.
-   * @returns {Promise<*>} Promise for source bytes/data.
+  /**
+   * Run or join one normalized direct source operation.
+   *
+   * @param {Readonly<CjsResourceReadContext>} context Normalized provenance.
+   * @param {object} options Detached read options.
+   * @param {CjsResourceReadOperationRecord|null} [queuedRecord=null] Parent queued record whose retention may be promoted by a later join.
+   * @returns {Promise<*>} Promise for source bytes/data.
    */
   #ReadResource(context, options, queuedRecord = null) {
     const cachePolicy = normalizeCachePolicy(options.cacheSource, "cacheSource");
@@ -2273,13 +2272,13 @@ class CjsResMan extends CjsEventEmitter {
     return record.promise;
   }
 
-  /**
-   * Retain a settled source result when a queued caller upgraded cache policy
-   * after the direct source promise had already completed its cleanup reaction.
-   *
-   * @param {Readonly<CjsResourceReadContext>} context Normalized provenance.
-   * @param {*} value Settled source result.
-   * @returns {void}
+  /**
+   * Retain a settled source result when a queued caller upgraded cache policy
+   * after the direct source promise had already completed its cleanup reaction.
+   *
+   * @param {Readonly<CjsResourceReadContext>} context Normalized provenance.
+   * @param {*} value Settled source result.
+   * @returns {void}
    */
   #RetainSourceResult(context, value) {
     const operations = getOwnerOperations(this.sourceOperations, context.source, true);
@@ -2297,14 +2296,14 @@ class CjsResMan extends CjsEventEmitter {
     });
   }
 
-  /**
-   * Remove future-reuse records matching one selected source and path.
-   * A null revision removes all revisions.
-   *
-   * @param {object|Function} source Selected source.
-   * @param {string} path Normalized source path.
-   * @param {string|null} revisionKey Exact revision key or `null` for all.
-   * @returns {Readonly<{path: string, queuedSource: number, source: number, format: number}>} Frozen detached counts.
+  /**
+   * Remove future-reuse records matching one selected source and path.
+   * A null revision removes all revisions.
+   *
+   * @param {object|Function} source Selected source.
+   * @param {string} path Normalized source path.
+   * @param {string|null} revisionKey Exact revision key or `null` for all.
+   * @returns {Readonly<{path: string, queuedSource: number, source: number, format: number}>} Frozen detached counts.
    */
   #InvalidateReadCache(source, path, revisionKey) {
     const queuedSource = removeOperationRecords(getOwnerOperations(this.queuedSourceOperations, source, false), path, revisionKey);
@@ -2326,18 +2325,18 @@ class CjsResMan extends CjsEventEmitter {
     });
   }
 
-  /**
-   * Construct and initialize one resource handle, optionally rejecting a
-   * singleton alias before `Initialize()` can mutate the protected owner.
-   *
-   * @param {Function} Constructor Resource constructor selected for the outcome.
-   * @param {string} path Normalized Carbon-style resource path.
-   * @param {string} ext Normalized resource extension.
-   * @param {object} [options={}] Constructor values, requested output, semantic requirement, and source provenance.
-   * @param {object|Function|null} [disallowedAlias=null] Existing owner that a staged candidate must not reuse.
-   * @param {object|null} [extensionRoute=null] Immutable explicit extension route captured for this handle.
-   * @returns {CjsResource} Initialized resource-compatible handle.
-   * @throws {TypeError|Error} If construction, candidate identity, or initialization is invalid.
+  /**
+   * Construct and initialize one resource handle, optionally rejecting a
+   * singleton alias before `Initialize()` can mutate the protected owner.
+   *
+   * @param {Function} Constructor Resource constructor selected for the outcome.
+   * @param {string} path Normalized Carbon-style resource path.
+   * @param {string} ext Normalized resource extension.
+   * @param {object} [options={}] Constructor values, requested output, semantic requirement, and source provenance.
+   * @param {object|Function|null} [disallowedAlias=null] Existing owner that a staged candidate must not reuse.
+   * @param {object|null} [extensionRoute=null] Immutable explicit extension route captured for this handle.
+   * @returns {CjsResource} Initialized resource-compatible handle.
+   * @throws {TypeError|Error} If construction, candidate identity, or initialization is invalid.
    */
   CreateResource(Constructor, path, ext, options = {}, disallowedAlias = null, extensionRoute = null) {
     const resource = new Constructor(options.values);
@@ -2360,35 +2359,46 @@ class CjsResMan extends CjsEventEmitter {
     return resource;
   }
 
-  /**
-   * Resolve the current resource constructor for a semantic request. Explicit
-   * requirement/payload selection precedes an emitted-output registration;
-   * otherwise the generic `CjsResource` handle is used.
-   *
-   * @param {object} [options={}] Semantic requirement, payload, and emit request.
-   * @param {object|null} [extensionRoute=null] Captured extension-selected default handler.
-   * @returns {Function} Registered resource constructor or `CjsResource`.
+  /**
+   * Resolve the current resource constructor for a semantic request. Explicit
+   * requirement/payload selection normally precedes an emitted-output
+   * registration. When an extension handler declares the same requirement it
+   * wins, because the route is what distinguishes concrete resource classes
+   * sharing one semantic key. Otherwise the generic `CjsResource` is used.
+   *
+   * @param {object} [options={}] Semantic requirement, payload, and emit request.
+   * @param {object|null} [extensionRoute=null] Captured extension-selected default handler.
+   * @returns {Function} Registered resource constructor or `CjsResource`.
    */
   ResolveResourceConstructor(options = {}, extensionRoute = null) {
     const requested = normalizeRequirement(options.requirement || options.payload);
-    if (requested && this.resourceTypes.has(requested)) return this.resourceTypes.get(requested);
+    if (requested) {
+      if (extensionRoute && normalizeRequirement(extensionRoute.Handler?.payload) === requested) {
+        return extensionRoute.Handler;
+      }
+      const candidates = this.#resourceTypeCandidates.get(requested);
+      if (candidates?.size > 1) {
+        throw createAmbiguousResourceTypeError(requested, candidates);
+      }
+      if (this.resourceTypes.has(requested)) return this.resourceTypes.get(requested);
+    }
     const emitted = normalizeRequirement(options.emit);
     if (emitted && this.resourceTypes.has(emitted)) return this.resourceTypes.get(emitted);
     if (extensionRoute) return extensionRoute.Handler;
     return CjsResource;
   }
 
-  /**
-   * Resolve the promised output tag used with the normalized source path.
-   *
-   * An explicit `variant` wins. Otherwise the requested emitted output is the
-   * promise, followed by the semantic requirement/payload for resource-only
-   * requests. Reader classes, constructors, and format options
-   * are execution details and never enter this identity.
-   *
-   * @param {object} [options={}] Resource request containing an optional output tag.
-   * @returns {string} Normalized promised output tag, or an empty string for the default outcome.
-   * @throws {TypeError} If options or its selected tag is invalid.
+  /**
+   * Resolve the promised output tag used with the normalized source path.
+   *
+   * An explicit `variant` wins. Otherwise the requested emitted output is the
+   * promise, followed by the semantic requirement/payload for resource-only
+   * requests. Reader classes, constructors, and format options
+   * are execution details and never enter this identity.
+   *
+   * @param {object} [options={}] Resource request containing an optional output tag.
+   * @returns {string} Normalized promised output tag, or an empty string for the default outcome.
+   * @throws {TypeError} If options or its selected tag is invalid.
    */
   GetResourceVariant(options = {}) {
     if (!options || typeof options !== "object" || Array.isArray(options)) {
@@ -2403,12 +2413,12 @@ class CjsResMan extends CjsEventEmitter {
     return normalizeResourceVariant(options.emit ?? options.requirement ?? options.payload ?? "");
   }
 
-  /**
-   * Retain a low-level queue task only until settlement so `Wait()` can take a
-   * synchronous snapshot without making completed values long-lived.
-   *
-   * @param {object} task Queue task returned by `CjsResManWorkQueue.Add()`.
-   * @returns {object} The supplied task.
+  /**
+   * Retain a low-level queue task only until settlement so `Wait()` can take a
+   * synchronous snapshot without making completed values long-lived.
+   *
+   * @param {object} task Queue task returned by `CjsResManWorkQueue.Add()`.
+   * @returns {object} The supplied task.
    */
   #TrackQueueTask(task) {
     this.#queueOperations.set(task, task.promise);
@@ -2424,14 +2434,14 @@ class CjsResMan extends CjsEventEmitter {
     return task;
   }
 
-  /**
-   * Open one active resource-mutation record. Queued records additionally own
-   * a settlement promise visible to contemporaneous `Wait()` snapshots;
-   * direct records block unsafe MotherLode replacement but remain outside that
-   * two-queue fence.
-   *
-   * @param {boolean} queued Whether the operation belongs to the queued fence.
-   * @returns {() => void} Idempotent record completion callback.
+  /**
+   * Open one active resource-mutation record. Queued records additionally own
+   * a settlement promise visible to contemporaneous `Wait()` snapshots;
+   * direct records block unsafe MotherLode replacement but remain outside that
+   * two-queue fence.
+   *
+   * @param {boolean} queued Whether the operation belongs to the queued fence.
+   * @returns {() => void} Idempotent record completion callback.
    */
   #BeginResourceOperation(queued) {
     this.#activeResourceOperations += 1;
@@ -2453,15 +2463,15 @@ class CjsResMan extends CjsEventEmitter {
     };
   }
 
-  /**
-   * Return the known canonical authority for a resource and reject a known
-   * stale generation. A never-bound resource returns `null` so historical
-   * detached prepare/publication helpers remain compatible.
-   *
-   * @param {object|Function} resource Candidate resource handle.
-   * @param {string} phase Operation phase used for stale diagnostics.
-   * @returns {CjsResourceOwnership|null} Current authority or `null` when never bound.
-   * @throws {Error} If a previously bound resource is no longer canonical.
+  /**
+   * Return the known canonical authority for a resource and reject a known
+   * stale generation. A never-bound resource returns `null` so historical
+   * detached prepare/publication helpers remain compatible.
+   *
+   * @param {object|Function} resource Candidate resource handle.
+   * @param {string} phase Operation phase used for stale diagnostics.
+   * @returns {CjsResourceOwnership|null} Current authority or `null` when never bound.
+   * @throws {Error} If a previously bound resource is no longer canonical.
    */
   #GetResourceOwnership(resource, phase) {
     const ownership = this.#resourceOwnership.get(resource) || null;
@@ -2470,13 +2480,13 @@ class CjsResMan extends CjsEventEmitter {
     return ownership;
   }
 
-  /**
-   * Require a current manager-owned canonical resource authority.
-   *
-   * @param {object|Function} resource Candidate resource handle.
-   * @param {string} phase Operation phase used for diagnostics.
-   * @returns {CjsResourceOwnership} Current canonical authority.
-   * @throws {Error} If the resource is unknown or no longer canonical.
+  /**
+   * Require a current manager-owned canonical resource authority.
+   *
+   * @param {object|Function} resource Candidate resource handle.
+   * @param {string} phase Operation phase used for diagnostics.
+   * @returns {CjsResourceOwnership} Current canonical authority.
+   * @throws {Error} If the resource is unknown or no longer canonical.
    */
   #RequireResourceOwnership(resource, phase) {
     const ownership = this.#GetResourceOwnership(resource, phase);
@@ -2484,13 +2494,13 @@ class CjsResMan extends CjsEventEmitter {
     throw resourceNotOwnedError(resource, phase);
   }
 
-  /**
-   * Test whether an asynchronous operation still owns publication authority.
-   * Registry lookup failures are treated as stale ownership so they cannot
-   * replace an operation's more useful underlying source/stage rejection.
-   *
-   * @param {CjsResourceOwnership} ownership Captured authority.
-   * @returns {boolean} Whether the exact generation remains canonical.
+  /**
+   * Test whether an asynchronous operation still owns publication authority.
+   * Registry lookup failures are treated as stale ownership so they cannot
+   * replace an operation's more useful underlying source/stage rejection.
+   *
+   * @param {CjsResourceOwnership} ownership Captured authority.
+   * @returns {boolean} Whether the exact generation remains canonical.
    */
   #IsResourceOwnershipCurrent(ownership) {
     try {
@@ -2500,13 +2510,13 @@ class CjsResMan extends CjsEventEmitter {
     }
   }
 
-  /**
-   * Assert exact canonical publication authority for one operation phase.
-   *
-   * @param {CjsResourceOwnership} ownership Captured authority.
-   * @param {string} phase Human-readable operation phase.
-   * @returns {void}
-   * @throws {Error} Stable stale-operation error when ownership changed.
+  /**
+   * Assert exact canonical publication authority for one operation phase.
+   *
+   * @param {CjsResourceOwnership} ownership Captured authority.
+   * @param {string} phase Human-readable operation phase.
+   * @returns {void}
+   * @throws {Error} Stable stale-operation error when ownership changed.
    */
   #AssertResourceOwnership(ownership, phase) {
     if (!this.#IsResourceOwnershipCurrent(ownership)) {
@@ -2514,12 +2524,12 @@ class CjsResMan extends CjsEventEmitter {
     }
   }
 
-  /**
-   * Assert a captured authority when a compatibility path supplied one.
-   *
-   * @param {CjsResourceMutationAuthority|null} ownership Optional canonical or reload-candidate authority.
-   * @param {string} phase Human-readable operation phase.
-   * @returns {void}
+  /**
+   * Assert a captured authority when a compatibility path supplied one.
+   *
+   * @param {CjsResourceMutationAuthority|null} ownership Optional canonical or reload-candidate authority.
+   * @param {string} phase Human-readable operation phase.
+   * @returns {void}
    */
   #AssertOptionalResourceOwnership(ownership, phase) {
     if (!ownership) return;
@@ -2530,13 +2540,13 @@ class CjsResMan extends CjsEventEmitter {
     this.#AssertResourceOwnership(ownership, phase);
   }
 
-  /**
-   * Test the exact former owner plus newest-request token for an off-registry
-   * candidate. Lookup failures are treated as stale so detached work cannot
-   * resurrect a deleted, cleared, replaced, or superseded identity.
-   *
-   * @param {CjsResourceReloadCandidate} candidate Candidate authority.
-   * @returns {boolean} Whether this candidate alone may still commit.
+  /**
+   * Test the exact former owner plus newest-request token for an off-registry
+   * candidate. Lookup failures are treated as stale so detached work cannot
+   * resurrect a deleted, cleared, replaced, or superseded identity.
+   *
+   * @param {CjsResourceReloadCandidate} candidate Candidate authority.
+   * @returns {boolean} Whether this candidate alone may still commit.
    */
   #IsReloadCandidateCurrent(candidate) {
     try {
@@ -2546,14 +2556,14 @@ class CjsResMan extends CjsEventEmitter {
     }
   }
 
-  /**
-   * Assert that a staged candidate still owns newest-request publication
-   * authority for one operation phase.
-   *
-   * @param {CjsResourceReloadCandidate} candidate Candidate authority.
-   * @param {string} phase Human-readable operation phase.
-   * @returns {void}
-   * @throws {Error} Stable stale-candidate error when authority changed.
+  /**
+   * Assert that a staged candidate still owns newest-request publication
+   * authority for one operation phase.
+   *
+   * @param {CjsResourceReloadCandidate} candidate Candidate authority.
+   * @param {string} phase Human-readable operation phase.
+   * @returns {void}
+   * @throws {Error} Stable stale-candidate error when authority changed.
    */
   #AssertReloadCandidate(candidate, phase) {
     if (!this.#IsReloadCandidateCurrent(candidate)) {
@@ -2561,11 +2571,11 @@ class CjsResMan extends CjsEventEmitter {
     }
   }
 
-  /**
-   * Invalidate the currently recorded generation for a removed resource.
-   *
-   * @param {object|Function} resource Removed or displaced resource.
-   * @returns {void}
+  /**
+   * Invalidate the currently recorded generation for a removed resource.
+   *
+   * @param {object|Function} resource Removed or displaced resource.
+   * @returns {void}
    */
   #InvalidateResourceOwnership(resource) {
     if (resource && (typeof resource === "object" || typeof resource === "function")) {
@@ -2573,13 +2583,13 @@ class CjsResMan extends CjsEventEmitter {
     }
   }
 
-  /**
-   * Invalidate every generation currently owned by one registry. This runs
-   * before Clear cancellation/cleanup so reentrant observers cannot retain
-   * authority after canonical ownership removal begins.
-   *
-   * @param {CjsMotherLode|null|undefined} owner Registry losing ownership.
-   * @returns {void}
+  /**
+   * Invalidate every generation currently owned by one registry. This runs
+   * before Clear cancellation/cleanup so reentrant observers cannot retain
+   * authority after canonical ownership removal begins.
+   *
+   * @param {CjsMotherLode|null|undefined} owner Registry losing ownership.
+   * @returns {void}
    */
   #InvalidateMotherLodeOwnership(owner) {
     if (typeof owner?.Entries !== "function") return;
@@ -2589,14 +2599,14 @@ class CjsResMan extends CjsEventEmitter {
     }
   }
 
-  /**
-   * Add one operation-owned purge lock and release it only while the exact
-   * captured canonical record still exists. If removal/replacement made the
-   * operation stale, its former MotherLode record (and lock count) no longer
-   * exists, so releasing through a rebound resource would corrupt a new owner.
-   *
-   * @param {CjsResourceOwnership} ownership Captured canonical authority.
-   * @returns {() => void} Idempotent balanced release callback.
+  /**
+   * Add one operation-owned purge lock and release it only while the exact
+   * captured canonical record still exists. If removal/replacement made the
+   * operation stale, its former MotherLode record (and lock count) no longer
+   * exists, so releasing through a rebound resource would corrupt a new owner.
+   *
+   * @param {CjsResourceOwnership} ownership Captured canonical authority.
+   * @returns {() => void} Idempotent balanced release callback.
    */
   #AcquireResourcePurgeLock(ownership) {
     const {
@@ -2616,35 +2626,35 @@ class CjsResMan extends CjsEventEmitter {
     };
   }
 
-  /**
-   * Bind resource-facing liveness methods to one canonical MotherLode key.
-   * The controller contains no loader/reload callback, so touching a detached
-   * or purged handle cannot start browser/network work.
-   *
-   * @param {string} key Canonical MotherLode identity.
-   * @param {object|Function} resource Canonical resource handle.
-   * @returns {object|Function} The supplied resource.
-   */
-  /**
-   * Reload a purged handle back into itself.
-   *
-   * Purge deletes the payload and drops the registry entry, so a consumer left
-   * holding the handle has no way to reach a replacement - it cannot discover
-   * one, and nothing hands it over. Recovery therefore has to fill THIS handle
-   * rather than resolve whatever the manager currently caches for the path.
-   *
-   * The handle is re-registered BEFORE loading, so the ordinary load path finds
-   * it as the canonical identity and loads into it instead of minting another.
-   *
-   * Declines rather than guesses in two cases: when another resource has since
-   * claimed the identity - displacing it would kill whoever holds that one, the
-   * very failure being fixed here - and when the retained request no longer
-   * resolves to the same identity, which would re-register the handle under the
-   * wrong key.
-   *
-   * @param {string} key Canonical resolved identity key.
-   * @param {CjsResource} resource The purged handle to restore.
-   * @returns {boolean} Whether a reload was started.
+  /**
+   * Bind resource-facing liveness methods to one canonical MotherLode key.
+   * The controller contains no loader/reload callback, so touching a detached
+   * or purged handle cannot start browser/network work.
+   *
+   * @param {string} key Canonical MotherLode identity.
+   * @param {object|Function} resource Canonical resource handle.
+   * @returns {object|Function} The supplied resource.
+   */
+  /**
+   * Reload a purged handle back into itself.
+   *
+   * Purge deletes the payload and drops the registry entry, so a consumer left
+   * holding the handle has no way to reach a replacement - it cannot discover
+   * one, and nothing hands it over. Recovery therefore has to fill THIS handle
+   * rather than resolve whatever the manager currently caches for the path.
+   *
+   * The handle is re-registered BEFORE loading, so the ordinary load path finds
+   * it as the canonical identity and loads into it instead of minting another.
+   *
+   * Declines rather than guesses in two cases: when another resource has since
+   * claimed the identity - displacing it would kill whoever holds that one, the
+   * very failure being fixed here - and when the retained request no longer
+   * resolves to the same identity, which would re-register the handle under the
+   * wrong key.
+   *
+   * @param {string} key Canonical resolved identity key.
+   * @param {CjsResource} resource The purged handle to restore.
+   * @returns {boolean} Whether a reload was started.
    */
   #ReloadPurgedResource(key, resource) {
     if (!resource?.IsPurged?.()) return false;
@@ -2672,19 +2682,19 @@ class CjsResMan extends CjsEventEmitter {
     }
   }
 
-  /**
-   * Give one resource the liveness callbacks its consumers never manage
-   * themselves: activity renewal, payload renewal, lock counting, and the
-   * reload hook that revives the handle after a purge.
-   *
-   * Ownership is captured by generation, so a late release can never renew or
-   * unlock a rebound owner. The reload hook is bound outside the lifecycle
-   * controller because that controller is detached exactly when canonical
-   * ownership ends, which is precisely when a purged handle needs to come back.
-   *
-   * @param {string} key Canonical resolved key.
-   * @param {object} resource Resource handle to bind.
-   * @returns {object} The same resource handle.
+  /**
+   * Give one resource the liveness callbacks its consumers never manage
+   * themselves: activity renewal, payload renewal, lock counting, and the
+   * reload hook that revives the handle after a purge.
+   *
+   * Ownership is captured by generation, so a late release can never renew or
+   * unlock a rebound owner. The reload hook is bound outside the lifecycle
+   * controller because that controller is detached exactly when canonical
+   * ownership ends, which is precisely when a purged handle needs to come back.
+   *
+   * @param {string} key Canonical resolved key.
+   * @param {object} resource Resource handle to bind.
+   * @returns {object} The same resource handle.
    */
   #BindResourceLifecycle(key, resource) {
     const owner = this.motherLode;
@@ -2723,11 +2733,11 @@ class CjsResMan extends CjsEventEmitter {
     return resource;
   }
 
-  /**
-   * Bind lifecycle callbacks for resources supplied by a configured custom
-   * MotherLode before CjsResMan begins serving them.
-   *
-   * @returns {CjsResMan} This resource manager.
+  /**
+   * Bind lifecycle callbacks for resources supplied by a configured custom
+   * MotherLode before CjsResMan begins serving them.
+   *
+   * @returns {CjsResMan} This resource manager.
    */
   #BindMotherLodeResources() {
     if (typeof this.motherLode?.Entries !== "function") return this;
@@ -2737,25 +2747,25 @@ class CjsResMan extends CjsEventEmitter {
     return this;
   }
 
-  /**
-   * Run or join one format read under source/path/revision, frozen descriptor,
-   * and effective output-option identity. Descriptor identity prevents a
-   * re-registration with different defaults from reusing an old parse, while
-   * source identity prevents same-path reads from different sources colliding.
-   *
-   * `cacheFormat` uses the same tri-state policy as source caching: omitted is
-   * in-flight by default, `true` retains success, and `false` bypasses sharing
-   * and retention. `reload: true` never joins a prior parse. Failures are never
-   * retained, and a joining `true` request upgrades a shared record. Requests
-   * with option instances that cannot be represented safely bypass format
-   * sharing regardless of cache policy.
-   *
-   * @param {CjsResource} resource Resource whose normalized path identifies the source data.
-   * @param {object} descriptor Frozen registered format descriptor.
-   * @param {*} bytes Source bytes or source-compatible reader input.
-   * @param {object} [options={}] Source provenance, reload, cacheFormat, emit, classes, and format options.
-   * @returns {Promise<*>} Promise for the parsed or converted format result.
-   * @throws {TypeError|Error} If resource, source, revision, descriptor, cache policy, or format execution is invalid.
+  /**
+   * Run or join one format read under source/path/revision, frozen descriptor,
+   * and effective output-option identity. Descriptor identity prevents a
+   * re-registration with different defaults from reusing an old parse, while
+   * source identity prevents same-path reads from different sources colliding.
+   *
+   * `cacheFormat` uses the same tri-state policy as source caching: omitted is
+   * in-flight by default, `true` retains success, and `false` bypasses sharing
+   * and retention. `reload: true` never joins a prior parse. Failures are never
+   * retained, and a joining `true` request upgrades a shared record. Requests
+   * with option instances that cannot be represented safely bypass format
+   * sharing regardless of cache policy.
+   *
+   * @param {CjsResource} resource Resource whose normalized path identifies the source data.
+   * @param {object} descriptor Frozen registered format descriptor.
+   * @param {*} bytes Source bytes or source-compatible reader input.
+   * @param {object} [options={}] Source provenance, reload, cacheFormat, emit, classes, and format options.
+   * @returns {Promise<*>} Promise for the parsed or converted format result.
+   * @throws {TypeError|Error} If resource, source, revision, descriptor, cache policy, or format execution is invalid.
    */
   ReadFormatOnce(resource, descriptor, bytes, options = {}) {
     const read = this.#BeginReadOperation(resource.GetPath(), options);
@@ -2791,16 +2801,16 @@ class CjsResMan extends CjsEventEmitter {
   }
 }
 
-/**
- * Copy supported registered format defaults into a deeply frozen snapshot.
- * Plain objects and arrays may be cyclic. Functions and primitives are stable
- * leaves; values with hidden mutable state are rejected because freezing their
- * wrapper would not make the represented behavior immutable.
- *
- * @param {object} defaults Registered format defaults.
- * @param {WeakMap<object, object>} [seen=new WeakMap()] Source-to-snapshot cycle map.
- * @returns {Readonly<object>} Deeply frozen plain defaults snapshot.
- * @throws {TypeError} If defaults contain unsupported objects, accessors, symbols, or byte buffers.
+/**
+ * Copy supported registered format defaults into a deeply frozen snapshot.
+ * Plain objects and arrays may be cyclic. Functions and primitives are stable
+ * leaves; values with hidden mutable state are rejected because freezing their
+ * wrapper would not make the represented behavior immutable.
+ *
+ * @param {object} defaults Registered format defaults.
+ * @param {WeakMap<object, object>} [seen=new WeakMap()] Source-to-snapshot cycle map.
+ * @returns {Readonly<object>} Deeply frozen plain defaults snapshot.
+ * @throws {TypeError} If defaults contain unsupported objects, accessors, symbols, or byte buffers.
  */
 function snapshotFormatDefaults(defaults, seen = new WeakMap()) {
   if (!defaults || typeof defaults !== "object" || Array.isArray(defaults)) {
@@ -2809,14 +2819,14 @@ function snapshotFormatDefaults(defaults, seen = new WeakMap()) {
   return snapshotFormatDefaultValue(defaults, seen, "defaults");
 }
 
-/**
- * Snapshot one value in a registered format-default tree.
- *
- * @param {*} value Source value.
- * @param {WeakMap<object, object>} seen Source-to-snapshot cycle map.
- * @param {string} path Diagnostic property path.
- * @returns {*} Frozen snapshot value or stable primitive/function leaf.
- * @throws {TypeError} If the value cannot be made structurally immutable.
+/**
+ * Snapshot one value in a registered format-default tree.
+ *
+ * @param {*} value Source value.
+ * @param {WeakMap<object, object>} seen Source-to-snapshot cycle map.
+ * @param {string} path Diagnostic property path.
+ * @returns {*} Frozen snapshot value or stable primitive/function leaf.
+ * @throws {TypeError} If the value cannot be made structurally immutable.
  */
 function snapshotFormatDefaultValue(value, seen, path) {
   if (value === null || value === undefined) return value;
@@ -2858,14 +2868,14 @@ function snapshotFormatDefaultValue(value, seen, path) {
   return Object.freeze(snapshot);
 }
 
-/**
- * Normalize an opaque caller/source revision without interpreting content.
- * String and number tokens remain type-distinct; finite numeric `-0` and `0`
- * intentionally identify the same revision.
- *
- * @param {string|number|undefined} value Caller-provided source content token.
- * @returns {string} Type-stable internal revision key.
- * @throws {TypeError} If the token is neither a string nor finite number.
+/**
+ * Normalize an opaque caller/source revision without interpreting content.
+ * String and number tokens remain type-distinct; finite numeric `-0` and `0`
+ * intentionally identify the same revision.
+ *
+ * @param {string|number|undefined} value Caller-provided source content token.
+ * @returns {string} Type-stable internal revision key.
+ * @throws {TypeError} If the token is neither a string nor finite number.
  */
 function normalizeSourceRevision(value) {
   if (value === undefined) return "undefined";
@@ -2876,13 +2886,13 @@ function normalizeSourceRevision(value) {
   throw new TypeError("CjsResMan sourceRevision must be a string or finite number.");
 }
 
-/**
- * Validate tri-state source/format cache policy.
- *
- * @param {boolean|undefined} value Cache policy value.
- * @param {string} name Option name used in failures.
- * @returns {boolean|undefined} The validated policy.
- * @throws {TypeError} If the value is not boolean or omitted.
+/**
+ * Validate tri-state source/format cache policy.
+ *
+ * @param {boolean|undefined} value Cache policy value.
+ * @param {string} name Option name used in failures.
+ * @returns {boolean|undefined} The validated policy.
+ * @throws {TypeError} If the value is not boolean or omitted.
  */
 function normalizeCachePolicy(value, name) {
   if (value !== undefined && typeof value !== "boolean") {
@@ -2891,13 +2901,13 @@ function normalizeCachePolicy(value, name) {
   return value;
 }
 
-/**
- * Get the operation map owned by one source object.
- *
- * @param {WeakMap<object|Function, Map<string, CjsResourceReadOperationRecord>>} ledger Source-keyed ledger.
- * @param {object|Function} owner Source owner.
- * @param {boolean} create Whether a missing map should be allocated.
- * @returns {Map<string, CjsResourceReadOperationRecord>|null} Owner map or `null`.
+/**
+ * Get the operation map owned by one source object.
+ *
+ * @param {WeakMap<object|Function, Map<string, CjsResourceReadOperationRecord>>} ledger Source-keyed ledger.
+ * @param {object|Function} owner Source owner.
+ * @param {boolean} create Whether a missing map should be allocated.
+ * @returns {Map<string, CjsResourceReadOperationRecord>|null} Owner map or `null`.
  */
 function getOwnerOperations(ledger, owner, create) {
   let operations = ledger.get(owner);
@@ -2908,25 +2918,25 @@ function getOwnerOperations(ledger, owner, create) {
   return operations || null;
 }
 
-/**
- * Get the source/path/revision operation key for one normalized read context.
- *
- * @param {Readonly<CjsResourceReadContext>} context Normalized provenance.
- * @returns {string} Internal read-operation key.
+/**
+ * Get the source/path/revision operation key for one normalized read context.
+ *
+ * @param {Readonly<CjsResourceReadContext>} context Normalized provenance.
+ * @returns {string} Internal read-operation key.
  */
 function getReadOperationKey(context) {
   return `${context.path}\u0000${context.revisionKey}`;
 }
 
-/**
- * Get the descriptor-specific format operation map for a selected source.
- * Frozen descriptor identity isolates changed registration defaults.
- *
- * @param {WeakMap<object|Function, Map<object, Map<string, CjsResourceReadOperationRecord>>>} ledger Format ledger.
- * @param {object|Function} source Selected source owner.
- * @param {object} descriptor Frozen registered descriptor.
- * @param {boolean} create Whether missing maps should be allocated.
- * @returns {Map<string, CjsResourceReadOperationRecord>|null} Descriptor map or `null`.
+/**
+ * Get the descriptor-specific format operation map for a selected source.
+ * Frozen descriptor identity isolates changed registration defaults.
+ *
+ * @param {WeakMap<object|Function, Map<object, Map<string, CjsResourceReadOperationRecord>>>} ledger Format ledger.
+ * @param {object|Function} source Selected source owner.
+ * @param {object} descriptor Frozen registered descriptor.
+ * @param {boolean} create Whether missing maps should be allocated.
+ * @returns {Map<string, CjsResourceReadOperationRecord>|null} Descriptor map or `null`.
  */
 function getFormatDescriptorOperations(ledger, source, descriptor, create) {
   let descriptors = ledger.get(source);
@@ -2943,15 +2953,15 @@ function getFormatDescriptorOperations(ledger, source, descriptor, create) {
   return operations || null;
 }
 
-/**
- * Build a descriptor-local format cache key from source provenance and the
- * output options that materially affect the format reader result.
- * Requests containing non-canonical mutable option objects bypass format-cache
- * sharing instead of risking a false key match.
- *
- * @param {Readonly<CjsResourceReadContext>} context Normalized provenance.
- * @param {object} options Format request options.
- * @returns {string|null} Internal format-operation key, or `null` to bypass caching.
+/**
+ * Build a descriptor-local format cache key from source provenance and the
+ * output options that materially affect the format reader result.
+ * Requests containing non-canonical mutable option objects bypass format-cache
+ * sharing instead of risking a false key match.
+ *
+ * @param {Readonly<CjsResourceReadContext>} context Normalized provenance.
+ * @param {object} options Format request options.
+ * @returns {string|null} Internal format-operation key, or `null` to bypass caching.
  */
 function getFormatOperationKey(context, options) {
   const material = [options.emit, options.mediaType, options.classes, options.formatOptions];
@@ -2959,15 +2969,15 @@ function getFormatOperationKey(context, options) {
   return `${getReadOperationKey(context)}\u0000${material.map(value => serializeFormatCacheValue(value)).join("\u0001")}`;
 }
 
-/**
- * Return true when a format cache option can be represented without guessing
- * hidden mutable state. Plain objects/arrays, functions by identity, and
- * byte-addressable buffers/views are supported. Other class instances bypass
- * format-cache sharing.
- *
- * @param {*} value Candidate material format option.
- * @param {WeakSet<object|Function>} [seen=new WeakSet()] Cycle guard.
- * @returns {boolean} Whether deterministic cache serialization is supported.
+/**
+ * Return true when a format cache option can be represented without guessing
+ * hidden mutable state. Plain objects/arrays, functions by identity, and
+ * byte-addressable buffers/views are supported. Other class instances bypass
+ * format-cache sharing.
+ *
+ * @param {*} value Candidate material format option.
+ * @param {WeakSet<object|Function>} [seen=new WeakSet()] Cycle guard.
+ * @returns {boolean} Whether deterministic cache serialization is supported.
  */
 function isCanonicalFormatCacheValue(value, seen = new WeakSet()) {
   if (value === null || value === undefined) return true;
@@ -2989,15 +2999,15 @@ function isCanonicalFormatCacheValue(value, seen = new WeakSet()) {
   });
 }
 
-/**
- * Serialize one supported material format option with process-local identity
- * for objects and functions. Identity prevents same-named constructors and
- * separate option graphs from colliding; visible plain-object/array/buffer
- * contents ensure mutation changes the next operation key.
- *
- * @param {*} value Canonically supported format option.
- * @param {WeakSet<object|Function>} [seen=new WeakSet()] Cycle guard.
- * @returns {string} Deterministic cache-local representation.
+/**
+ * Serialize one supported material format option with process-local identity
+ * for objects and functions. Identity prevents same-named constructors and
+ * separate option graphs from colliding; visible plain-object/array/buffer
+ * contents ensure mutation changes the next operation key.
+ *
+ * @param {*} value Canonically supported format option.
+ * @param {WeakSet<object|Function>} [seen=new WeakSet()] Cycle guard.
+ * @returns {string} Deterministic cache-local representation.
  */
 function serializeFormatCacheValue(value, seen = new WeakSet()) {
   if (value === undefined) return "undefined";
@@ -3027,11 +3037,11 @@ function serializeFormatCacheValue(value, seen = new WeakSet()) {
   return `object:${identity}:{${Object.keys(value).sort().map(key => `${JSON.stringify(key)}:${serializeFormatCacheValue(value[key], seen)}`).join(",")}}`;
 }
 
-/**
- * Return a process-local identity for a parsed-format cache object or function.
- *
- * @param {object|Function} value Candidate option identity owner.
- * @returns {number} Stable identity for the life of the value.
+/**
+ * Return a process-local identity for a parsed-format cache object or function.
+ *
+ * @param {object|Function} value Candidate option identity owner.
+ * @returns {number} Stable identity for the life of the value.
  */
 function getLocalValueIdentity(value) {
   let identity = LOCAL_VALUE_IDENTITIES.get(value);
@@ -3042,14 +3052,14 @@ function getLocalValueIdentity(value) {
   return identity;
 }
 
-/**
- * Remove operation records matching a normalized path and optional revision.
- * Detached promises continue for their existing consumers.
- *
- * @param {Map<string, CjsResourceReadOperationRecord>|null} operations Candidate operation map.
- * @param {string} path Normalized source path.
- * @param {string|null} revisionKey Exact revision or `null` for all revisions.
- * @returns {number} Number of detached records.
+/**
+ * Remove operation records matching a normalized path and optional revision.
+ * Detached promises continue for their existing consumers.
+ *
+ * @param {Map<string, CjsResourceReadOperationRecord>|null} operations Candidate operation map.
+ * @param {string} path Normalized source path.
+ * @param {string|null} revisionKey Exact revision or `null` for all revisions.
+ * @returns {number} Number of detached records.
  */
 function removeOperationRecords(operations, path, revisionKey) {
   if (!operations) return 0;
@@ -3062,13 +3072,13 @@ function removeOperationRecords(operations, path, revisionKey) {
   return removed;
 }
 
-/**
- * Copy the compact requested-output fields needed for explicit payload
- * reconstruction. This request is retained with the handle but never enters
- * MotherLode identity beyond its `variant`/`emit` output tag.
- *
- * @param {object} [options={}] Original resource request.
- * @returns {object} Shallow reconstruction request without cache/reload policy.
+/**
+ * Copy the compact requested-output fields needed for explicit payload
+ * reconstruction. This request is retained with the handle but never enters
+ * MotherLode identity beyond its `variant`/`emit` output tag.
+ *
+ * @param {object} [options={}] Original resource request.
+ * @returns {object} Shallow reconstruction request without cache/reload policy.
  */
 function getResourceRequestOptions(options = {}) {
   const request = {};
@@ -3078,15 +3088,15 @@ function getResourceRequestOptions(options = {}) {
   return request;
 }
 
-/**
- * Capture the compact output request plus effective source provenance needed
- * to reconstruct a released resource payload. Cache policy and one-shot reload
- * are intentionally not retained. Retaining the effective source prevents an
- * old revision token from being applied to a later manager default source.
- *
- * @param {object} [options={}] Requested output and source provenance options.
- * @param {object|Function|null} [effectiveSource=null] Source selected when the resource was created.
- * @returns {object} Detached loader options safe to retain with the resource.
+/**
+ * Capture the compact output request plus effective source provenance needed
+ * to reconstruct a released resource payload. Cache policy and one-shot reload
+ * are intentionally not retained. Retaining the effective source prevents an
+ * old revision token from being applied to a later manager default source.
+ *
+ * @param {object} [options={}] Requested output and source provenance options.
+ * @param {object|Function|null} [effectiveSource=null] Source selected when the resource was created.
+ * @returns {object} Detached loader options safe to retain with the resource.
  */
 function getResourceLoaderOptions(options = {}, effectiveSource = null) {
   const loaderOptions = getResourceRequestOptions(options);
@@ -3099,17 +3109,17 @@ function getResourceLoaderOptions(options = {}, effectiveSource = null) {
   return loaderOptions;
 }
 
-/**
- * Merge per-operation controls with a resource's compact reconstruction
- * request. Once the handle has a promised-output field, all output selectors
- * remain pinned to the retained request so `Ready()` cannot publish a
- * different result under the existing MotherLode identity. Retained source
- * provenance is pinned as well; cache/reload controls remain explicit per-call
- * overrides.
- *
- * @param {object} base Retained reconstruction request.
- * @param {object} [overrides={}] Per-call operation controls.
- * @returns {object} Merged request with stable promised-output fields.
+/**
+ * Merge per-operation controls with a resource's compact reconstruction
+ * request. Once the handle has a promised-output field, all output selectors
+ * remain pinned to the retained request so `Ready()` cannot publish a
+ * different result under the existing MotherLode identity. Retained source
+ * provenance is pinned as well; cache/reload controls remain explicit per-call
+ * overrides.
+ *
+ * @param {object} base Retained reconstruction request.
+ * @param {object} [overrides={}] Per-call operation controls.
+ * @returns {object} Merged request with stable promised-output fields.
  */
 function mergeResourceLoaderOptions(base, overrides = {}) {
   const result = {
@@ -3132,13 +3142,13 @@ function mergeResourceLoaderOptions(base, overrides = {}) {
   return result;
 }
 
-/**
- * Filter current format descriptors using request material available before
- * source bytes are read. Byte-dependent support probes are deferred.
- *
- * @param {readonly object[]} descriptors Registered descriptors for one extension.
- * @param {object} options Format, output, and media selection.
- * @returns {object[]} Matching descriptors in registration order.
+/**
+ * Filter current format descriptors using request material available before
+ * source bytes are read. Byte-dependent support probes are deferred.
+ *
+ * @param {readonly object[]} descriptors Registered descriptors for one extension.
+ * @param {object} options Format, output, and media selection.
+ * @returns {object[]} Matching descriptors in registration order.
  */
 function filterFormatDescriptors(descriptors, options) {
   let candidates = [...descriptors];
@@ -3160,16 +3170,16 @@ function filterFormatDescriptors(descriptors, options) {
   return candidates;
 }
 
-/**
- * Resolve an ordered explicit extension route. Probes are evaluated in route
- * order and the sole unprobed final descriptor is the fallback. Selection is
- * final: reader failures are never interpreted as a reason to try another
- * format.
- *
- * @param {readonly object[]} descriptors Captured ordered route descriptors.
- * @param {string} ext Normalized resource extension.
- * @param {object} options Output filters and source bytes.
- * @returns {object} Selected immutable format descriptor.
+/**
+ * Resolve an ordered explicit extension route. Probes are evaluated in route
+ * order and the sole unprobed final descriptor is the fallback. Selection is
+ * final: reader failures are never interpreted as a reason to try another
+ * format.
+ *
+ * @param {readonly object[]} descriptors Captured ordered route descriptors.
+ * @param {string} ext Normalized resource extension.
+ * @param {object} options Output filters and source bytes.
+ * @returns {object} Selected immutable format descriptor.
  */
 function resolveOrderedExtensionFormatDescriptor(descriptors, ext, options) {
   const candidates = filterFormatDescriptors(descriptors, options);
@@ -3187,8 +3197,8 @@ function resolveOrderedExtensionFormatDescriptor(descriptors, ext, options) {
       Format,
       defaults
     } = descriptor;
-    if (typeof Format.isSupported !== "function") return descriptor;
-    const report = Format.isSupported(options.bytes, {
+    if (typeof Format.is !== "function") return descriptor;
+    const report = Format.is(options.bytes, {
       ...defaults,
       ...(options.formatOptions || {})
     });
@@ -3210,24 +3220,24 @@ function isPositiveFormatProbe(report) {
   return report.supported === true || report.supported === "full" || report.supported === "partial";
 }
 
-/**
- * Return one format facade's normal and diagnostic output declarations.
- *
- * @param {Function} Format Registered format facade.
- * @returns {Array<*>} Declared output values in selection order.
+/**
+ * Return one format facade's normal and diagnostic output declarations.
+ *
+ * @param {Function} Format Registered format facade.
+ * @returns {Array<*>} Declared output values in selection order.
  */
 function getFormatOutputs(Format) {
-  return [...(Format.outputTypes || []), ...(Format.debugOutputTypes || [])];
+  return Object.keys(Format.outputs || {});
 }
 
-/**
- * Resolve a case-insensitive output selector to its canonical declared
- * spelling. MotherLode tags stay lowercase while readers receive declarations
- * such as `cmfJson` or `gr2Json` exactly as authored.
- *
- * @param {readonly *[]} outputs Declared output values.
- * @param {*} requested Requested output selector.
- * @returns {string|null} Canonical declaration, or `null` when unsupported.
+/**
+ * Resolve a case-insensitive output selector to its canonical declared
+ * spelling. MotherLode tags stay lowercase while readers receive declarations
+ * such as `cmfJson` or `gr2Json` exactly as authored.
+ *
+ * @param {readonly *[]} outputs Declared output values.
+ * @param {*} requested Requested output selector.
+ * @returns {string|null} Canonical declaration, or `null` when unsupported.
  */
 function findDeclaredOutput(outputs, requested) {
   const normalized = normalizeResourceVariant(requested);
@@ -3238,14 +3248,14 @@ function findDeclaredOutput(outputs, requested) {
   return null;
 }
 
-/**
- * Create the stable failure used when a registered input format cannot emit a
- * requested output tag.
- *
- * @param {string} ext Normalized source extension.
- * @param {*} emit Requested output tag.
- * @param {readonly object[]} descriptors Registered input-format descriptors.
- * @returns {Error} Contextual unsupported-output error.
+/**
+ * Create the stable failure used when a registered input format cannot emit a
+ * requested output tag.
+ *
+ * @param {string} ext Normalized source extension.
+ * @param {*} emit Requested output tag.
+ * @param {readonly object[]} descriptors Registered input-format descriptors.
+ * @returns {Error} Contextual unsupported-output error.
  */
 function createFormatOutputMissingError(ext, emit, descriptors) {
   const error = new Error(`No format registered for .${ext} emits ${JSON.stringify(emit)}.`);
@@ -3258,13 +3268,13 @@ function createFormatOutputMissingError(ext, emit, descriptors) {
   return error;
 }
 
-/**
- * Create the stable failure used when a direct object loader cannot satisfy a
- * forced output request.
- *
- * @param {string} ext Normalized source extension.
- * @param {*} emit Requested output tag.
- * @returns {Error} Contextual unsupported-output error.
+/**
+ * Create the stable failure used when a direct object loader cannot satisfy a
+ * forced output request.
+ *
+ * @param {string} ext Normalized source extension.
+ * @param {*} emit Requested output tag.
+ * @returns {Error} Contextual unsupported-output error.
  */
 function createObjectLoaderOutputMissingError(ext, emit) {
   const error = new Error(`Direct loader for .${ext} exposes only its unforced default; it does not emit ${JSON.stringify(emit)}.`);
@@ -3275,15 +3285,15 @@ function createObjectLoaderOutputMissingError(ext, emit) {
   return error;
 }
 
-/**
- * Resolve one descriptor from the current candidate set. When bytes are
- * present, support probes may disambiguate candidates.
- *
- * @param {readonly object[]} descriptors Candidate descriptors from current registration.
- * @param {string} ext Normalized resource extension.
- * @param {object} options Effective format options and optional source bytes.
- * @returns {object} Selected descriptor.
- * @throws {Error} If the candidate set is missing or remains ambiguous.
+/**
+ * Resolve one descriptor from the current candidate set. When bytes are
+ * present, support probes may disambiguate candidates.
+ *
+ * @param {readonly object[]} descriptors Candidate descriptors from current registration.
+ * @param {string} ext Normalized resource extension.
+ * @param {object} options Effective format options and optional source bytes.
+ * @returns {object} Selected descriptor.
+ * @throws {Error} If the candidate set is missing or remains ambiguous.
  */
 function resolveFormatDescriptorCandidates(descriptors, ext, options) {
   let candidates = [...descriptors];
@@ -3293,9 +3303,9 @@ function resolveFormatDescriptorCandidates(descriptors, ext, options) {
         Format,
         defaults
       } = descriptor;
-      const isSupported = Format.isSupported;
-      if (typeof isSupported !== "function") return false;
-      const report = isSupported.call(Format, options.bytes, {
+      const isFormat = Format.is;
+      if (typeof isFormat !== "function") return false;
+      const report = isFormat.call(Format, options.bytes, {
         ...defaults,
         ...(options.formatOptions || {})
       });
@@ -3320,16 +3330,33 @@ function resolveFormatDescriptorCandidates(descriptors, ext, options) {
   }
   return candidates[0];
 }
+
+/**
+ * Report shorthand resource registrations that need an extension route or an
+ * explicit keyed default to choose between them.
+ *
+ * @param {string} requirement Normalized semantic requirement.
+ * @param {Set<Function>} candidates Registered constructors.
+ * @returns {Error} Contextual ambiguity error.
+ */
+function createAmbiguousResourceTypeError(requirement, candidates) {
+  const names = [...candidates].map(Constructor => Constructor.name || "resource");
+  const error = new Error(`Ambiguous resource types registered for requirement ${JSON.stringify(requirement)}: ` + `${names.join(", ")}. Register an extension handler to select the concrete ` + "resource for that file, or register one explicit keyed default.");
+  error.code = "CJS_RESOURCE_TYPE_AMBIGUOUS";
+  error.requirement = requirement;
+  error.resourceTypes = names;
+  return error;
+}
 function normalizeRequirement(value) {
   return value === null || value === undefined ? "" : String(value).trim().toLowerCase();
 }
 
-/**
- * Normalize one human-readable promised output tag.
- *
- * @param {*} value Candidate `variant`, `emit`, requirement, or payload tag.
- * @returns {string} Trimmed lowercase tag, or an empty string.
- * @throws {TypeError} If a non-empty tag is not a string or contains the internal key delimiter.
+/**
+ * Normalize one human-readable promised output tag.
+ *
+ * @param {*} value Candidate `variant`, `emit`, requirement, or payload tag.
+ * @returns {string} Trimmed lowercase tag, or an empty string.
+ * @throws {TypeError} If a non-empty tag is not a string or contains the internal key delimiter.
  */
 function normalizeResourceVariant(value) {
   if (value === null || value === undefined || value === "") return "";
@@ -3353,13 +3380,13 @@ function createPrepareContext(resMan, resource, bytes, options, stage) {
   });
 }
 
-/**
- * Create the immutable, source-neutral path context shared by format readers,
- * direct object loaders, target identification, and target hydration.
- *
- * @param {string} path Normalized or caller-supplied resource path.
- * @param {CjsResourceReadContext|null|undefined} [readContext] Active source read context.
- * @returns {Readonly<{path: string, resFilePath: string, ext: string, fileName: string, url: string|null}>}
+/**
+ * Create the immutable, source-neutral path context shared by format readers,
+ * direct object loaders, target identification, and target hydration.
+ *
+ * @param {string} path Normalized or caller-supplied resource path.
+ * @param {CjsResourceReadContext|null|undefined} [readContext] Active source read context.
+ * @returns {Readonly<{path: string, resFilePath: string, ext: string, fileName: string, url: string|null}>}
  */
 function createResourcePathContext(path, readContext = null) {
   const resFilePath = normalizeResourcePath(path);
@@ -3372,12 +3399,12 @@ function createResourcePathContext(path, readContext = null) {
   });
 }
 
-/**
- * Return the normalized final component of a resource path without query or
- * fragment material.
- *
- * @param {string} path Resource path.
- * @returns {string} Lowercase normalized filename, or an empty string.
+/**
+ * Return the normalized final component of a resource path without query or
+ * fragment material.
+ *
+ * @param {string} path Resource path.
+ * @returns {string} Lowercase normalized filename, or an empty string.
  */
 function getResourceFileName(path) {
   const normalized = normalizeResourcePath(path);
@@ -3387,20 +3414,49 @@ function getResourceFileName(path) {
   return cleanPath.slice(slashIndex + 1);
 }
 
-/**
- * Recover the public object result represented by a resident resource payload.
- * The publication contract returns semantic subclasses as their resource
- * handle and base resources as their plain payload.
- *
- * @param {CjsResource} resource Resource with an attached CPU payload.
- * @param {object|null} route Captured explicit extension route.
- * @param {string|null} handlerMode Captured effective handler mode.
- * @returns {*} Resident public object outcome.
+/**
+ * The mode this resource publishes under.
+ *
+ * There are two modes and there have only ever been two - RESOURCE hands back
+ * the stable handle, OBJECT hands back the reader outcome - but the question
+ * was answered in four branches at each of two call sites, because a resource
+ * reached without a registered route has no captured mode to read. Both sites
+ * then re-derived the same rule inline, and both had to be kept in agreement by
+ * hand.
+ *
+ * The route's captured mode wins when there is one, since that is what the
+ * registration declared. Otherwise the class answers for itself: anything
+ * deriving from `CjsResource` carries a `handlerMode`, and a bare `CjsResource`
+ * is a carrier rather than a semantic resource, so it publishes its payload.
+ * That last case is why the class static cannot simply be trusted - the base
+ * declares RESOURCE for the subclasses that inherit it, not for itself.
+ *
+ * @param {object} resource Resource being published or read back.
+ * @param {string|null} [routedMode] Mode captured at registration, when routed.
+ * @returns {string} A `ResourceHandlerMode` value.
+ */
+function resolveResourceHandlerMode(resource, routedMode = null) {
+  if (routedMode === ResourceHandlerMode.RESOURCE) return ResourceHandlerMode.RESOURCE;
+  if (routedMode === ResourceHandlerMode.OBJECT) return ResourceHandlerMode.OBJECT;
+  if (resource?.constructor === CjsResource) return ResourceHandlerMode.OBJECT;
+  return typeof resource?.SetPayload === "function" ? ResourceHandlerMode.RESOURCE : ResourceHandlerMode.OBJECT;
+}
+
+/**
+ * Recover the public object result represented by a resident resource payload.
+ *
+ * The read-back counterpart of publication, and it must agree with it exactly:
+ * a resource published as its handle has to be recovered as its handle, or a
+ * cache hit answers differently from the load that filled it.
+ *
+ * @param {CjsResource} resource Resource with an attached CPU payload.
+ * @param {object|null} route Captured explicit extension route.
+ * @param {string|null} handlerMode Captured effective handler mode.
+ * @returns {*} Resident public object outcome.
  */
 function getPublishedResourceObject(resource, route = null, handlerMode = null) {
-  if (route && handlerMode === ResourceHandlerMode.RESOURCE) return resource;
-  if (route && handlerMode === ResourceHandlerMode.OBJECT) return resource.GetPayload();
-  return resource.constructor !== CjsResource ? resource : resource.GetPayload();
+  const mode = resolveResourceHandlerMode(resource, route ? handlerMode : null);
+  return mode === ResourceHandlerMode.RESOURCE ? resource : resource.GetPayload();
 }
 function assertPositiveInteger(value, name) {
   if (!Number.isInteger(value) || value < 1) {
@@ -3418,12 +3474,12 @@ function assertNonNegativeNumber(value, name) {
   }
 }
 
-/**
- * Normalize and freeze an opt-in time-based automatic purge policy.
- *
- * @param {CjsResManAutoPurgePolicy|false|null} policy Caller policy or disable marker.
- * @returns {Readonly<CjsResManAutoPurgePolicy>|null} Frozen normalized policy, or `null` when disabled.
- * @throws {TypeError} If fields, limits, cleanup controls, or the cadence clock are invalid.
+/**
+ * Normalize and freeze an opt-in time-based automatic purge policy.
+ *
+ * @param {CjsResManAutoPurgePolicy|false|null} policy Caller policy or disable marker.
+ * @returns {Readonly<CjsResManAutoPurgePolicy>|null} Frozen normalized policy, or `null` when disabled.
+ * @throws {TypeError} If fields, limits, cleanup controls, or the cadence clock are invalid.
  */
 function normalizeAutoPurgePolicy(policy) {
   if (policy === null || policy === undefined || policy === false) return null;
@@ -3469,12 +3525,12 @@ function normalizeAutoPurgePolicy(policy) {
   });
 }
 
-/**
- * Validate one automatic-purge pump request without advancing cadence.
- *
- * @param {CjsResManAutoPurgePumpOptions} options Per-call pump options.
- * @returns {CjsResManAutoPurgePumpOptions} Validated options.
- * @throws {TypeError} If options or an explicit timestamp are invalid.
+/**
+ * Validate one automatic-purge pump request without advancing cadence.
+ *
+ * @param {CjsResManAutoPurgePumpOptions} options Per-call pump options.
+ * @returns {CjsResManAutoPurgePumpOptions} Validated options.
+ * @throws {TypeError} If options or an explicit timestamp are invalid.
  */
 function normalizeAutoPurgePumpOptions(options) {
   if (!options || typeof options !== "object" || Array.isArray(options)) {
@@ -3490,12 +3546,12 @@ function normalizeAutoPurgePumpOptions(options) {
   return options;
 }
 
-/**
- * Create the stable failure used when synchronous MotherLode replacement
- * would detach ownership beneath active asynchronous resource mutation.
- *
- * @param {number} activeOperations Number of queued and direct mutations.
- * @returns {Error} Contextual active-operation error.
+/**
+ * Create the stable failure used when synchronous MotherLode replacement
+ * would detach ownership beneath active asynchronous resource mutation.
+ *
+ * @param {number} activeOperations Number of queued and direct mutations.
+ * @returns {Error} Contextual active-operation error.
  */
 function activeResourceOperationsError(activeOperations) {
   const error = new Error(`CjsResMan cannot replace MotherLode while ${activeOperations} resource operation(s) are active.`);
@@ -3504,13 +3560,13 @@ function activeResourceOperationsError(activeOperations) {
   return error;
 }
 
-/**
- * Create the stable failure used when a manager-only load API receives a
- * resource that was never bound to this manager.
- *
- * @param {*} resource Candidate resource.
- * @param {string} phase Operation phase.
- * @returns {Error} Contextual ownership error.
+/**
+ * Create the stable failure used when a manager-only load API receives a
+ * resource that was never bound to this manager.
+ *
+ * @param {*} resource Candidate resource.
+ * @param {string} phase Operation phase.
+ * @returns {Error} Contextual ownership error.
  */
 function resourceNotOwnedError(resource, phase) {
   const path = getResourceDiagnosticPath(resource);
@@ -3522,13 +3578,13 @@ function resourceNotOwnedError(resource, phase) {
   return error;
 }
 
-/**
- * Create the stable failure used when otherwise-successful obsolete work
- * reaches a canonical mutation boundary.
- *
- * @param {CjsResourceOwnership} ownership Captured stale authority.
- * @param {string} phase Operation phase that detected staleness.
- * @returns {Error} Contextual stale-operation error.
+/**
+ * Create the stable failure used when otherwise-successful obsolete work
+ * reaches a canonical mutation boundary.
+ *
+ * @param {CjsResourceOwnership} ownership Captured stale authority.
+ * @param {string} phase Operation phase that detected staleness.
+ * @returns {Error} Contextual stale-operation error.
  */
 function staleResourceOperationError(ownership, phase) {
   const path = getResourceDiagnosticPath(ownership?.resource);
@@ -3542,13 +3598,13 @@ function staleResourceOperationError(ownership, phase) {
   return error;
 }
 
-/**
- * Reject a resource constructor that returns the protected canonical singleton
- * when a distinct reload candidate is required.
- *
- * @param {string} path Requested resource path.
- * @param {object|Function} resource Aliased canonical resource.
- * @returns {Error} Stable candidate-alias error.
+/**
+ * Reject a resource constructor that returns the protected canonical singleton
+ * when a distinct reload candidate is required.
+ *
+ * @param {string} path Requested resource path.
+ * @param {object|Function} resource Aliased canonical resource.
+ * @returns {Error} Stable candidate-alias error.
  */
 function reloadCandidateAliasError(path, resource) {
   const error = new Error(`CjsResMan reload candidate aliases the canonical resource: ${path}.`);
@@ -3558,12 +3614,12 @@ function reloadCandidateAliasError(path, resource) {
   return error;
 }
 
-/**
- * Create the stable failure used when a candidate loader no longer has a
- * staged authority record.
- *
- * @param {object|Function} resource Candidate resource.
- * @returns {Error} Stable unavailable-candidate error.
+/**
+ * Create the stable failure used when a candidate loader no longer has a
+ * staged authority record.
+ *
+ * @param {object|Function} resource Candidate resource.
+ * @returns {Error} Stable unavailable-candidate error.
  */
 function reloadCandidateUnavailableError(resource) {
   const path = getResourceDiagnosticPath(resource);
@@ -3574,13 +3630,13 @@ function reloadCandidateUnavailableError(resource) {
   return error;
 }
 
-/**
- * Create the stable failure used when a deleted, cleared, replaced, or
- * superseded reload candidate reaches a mutation or commit boundary.
- *
- * @param {CjsResourceReloadCandidate} candidate Captured candidate authority.
- * @param {string} phase Operation phase that detected staleness.
- * @returns {Error} Contextual stale-candidate error.
+/**
+ * Create the stable failure used when a deleted, cleared, replaced, or
+ * superseded reload candidate reaches a mutation or commit boundary.
+ *
+ * @param {CjsResourceReloadCandidate} candidate Captured candidate authority.
+ * @param {string} phase Operation phase that detected staleness.
+ * @returns {Error} Contextual stale-candidate error.
  */
 function staleReloadCandidateError(candidate, phase) {
   const path = getResourceDiagnosticPath(candidate?.resource);
@@ -3595,12 +3651,12 @@ function staleReloadCandidateError(candidate, phase) {
   return error;
 }
 
-/**
- * Read a resource path for diagnostics without allowing an unusual custom
- * resource getter to hide the primary ownership error.
- *
- * @param {*} resource Candidate resource.
- * @returns {string} Best-effort resource path label.
+/**
+ * Read a resource path for diagnostics without allowing an unusual custom
+ * resource getter to hide the primary ownership error.
+ *
+ * @param {*} resource Candidate resource.
+ * @returns {string} Best-effort resource path label.
  */
 function getResourceDiagnosticPath(resource) {
   try {
@@ -3610,19 +3666,19 @@ function getResourceDiagnosticPath(resource) {
   }
 }
 
-/**
- * Perform no action for lifecycle-compatible optional operations.
- *
- * @returns {void}
+/**
+ * Perform no action for lifecycle-compatible optional operations.
+ *
+ * @returns {void}
  */
 function noop() {}
 
-/**
- * Validate a resource execution strategy.
- *
- * @param {*} loader Candidate loader.
- * @param {string} name Configuration field name.
- * @returns {void}
+/**
+ * Validate a resource execution strategy.
+ *
+ * @param {*} loader Candidate loader.
+ * @param {string} name Configuration field name.
+ * @returns {void}
  */
 function assertResourceLoader(loader, name) {
   if (!isResourceLoader(loader)) {
@@ -3630,22 +3686,22 @@ function assertResourceLoader(loader, name) {
   }
 }
 
-/**
- * Test the structural resource loader contract.
- *
- * @param {*} loader Candidate loader.
- * @returns {boolean}
+/**
+ * Test the structural resource loader contract.
+ *
+ * @param {*} loader Candidate loader.
+ * @returns {boolean}
  */
 function isResourceLoader(loader) {
   return Boolean(loader && typeof loader.Read === "function" && typeof loader.ReadFormat === "function");
 }
 
-/**
- * Merge frozen registration defaults with one request's format overrides.
- *
- * @param {object} descriptor Registered format descriptor.
- * @param {object} options Resource read options.
- * @returns {object} Effective format reader options.
+/**
+ * Merge frozen registration defaults with one request's format overrides.
+ *
+ * @param {object} descriptor Registered format descriptor.
+ * @param {object} options Resource read options.
+ * @returns {object} Effective format reader options.
  */
 function createFormatReadOptions(descriptor, options) {
   const {
@@ -3663,32 +3719,32 @@ function createFormatReadOptions(descriptor, options) {
   return formatOptions;
 }
 
-/**
- * Reports whether a source requires CjsResMan to build a URL before reading.
- *
- * @param {*} source Selected source/provider.
- * @returns {boolean}
+/**
+ * Reports whether a source requires CjsResMan to build a URL before reading.
+ *
+ * @param {*} source Selected source/provider.
+ * @returns {boolean}
  */
 function sourceRequiresUrl(source) {
   return source?.requiresUrl === true || source?.constructor?.requiresUrl === true;
 }
 
-/**
- * Tests whether an object owns one property.
- *
- * @param {*} object Candidate object.
- * @param {string|number|symbol} property Property key.
- * @returns {boolean}
+/**
+ * Tests whether an object owns one property.
+ *
+ * @param {*} object Candidate object.
+ * @param {string|number|symbol} property Property key.
+ * @returns {boolean}
  */
 function hasOwn(object, property) {
   return Object.prototype.hasOwnProperty.call(object, property);
 }
 
-/**
- * Normalizes one resource-path scheme key.
- *
- * @param {*} value Candidate scheme.
- * @returns {string}
+/**
+ * Normalizes one resource-path scheme key.
+ *
+ * @param {*} value Candidate scheme.
+ * @returns {string}
  */
 function normalizePathPrefix(value) {
   const prefix = String(value ?? "").trim().replace(/:\/?$/u, "").toLowerCase();
@@ -3698,12 +3754,12 @@ function normalizePathPrefix(value) {
   return prefix;
 }
 
-/**
- * Normalizes one registered URL base without altering case-sensitive path
- * content.
- *
- * @param {*} value Candidate URL base.
- * @returns {string}
+/**
+ * Normalizes one registered URL base without altering case-sensitive path
+ * content.
+ *
+ * @param {*} value Candidate URL base.
+ * @returns {string}
  */
 function normalizeUrlBase(value) {
   const url = normalizePath(value);
@@ -3713,11 +3769,11 @@ function normalizeUrlBase(value) {
   return url.endsWith("/") ? url : `${url}/`;
 }
 
-/**
- * Validates a URL returned by an injected path resolver.
- *
- * @param {*} value Resolver output.
- * @returns {string}
+/**
+ * Validates a URL returned by an injected path resolver.
+ *
+ * @param {*} value Resolver output.
+ * @returns {string}
  */
 function normalizeResolvedUrl(value) {
   const url = normalizePath(value);
@@ -3727,10 +3783,10 @@ function normalizeResolvedUrl(value) {
   return url;
 }
 
-/**
- * Return the wall-clock timestamp used by default automatic purge cadence.
- *
- * @returns {number} Milliseconds since the Unix epoch.
+/**
+ * Return the wall-clock timestamp used by default automatic purge cadence.
+ *
+ * @returns {number} Milliseconds since the Unix epoch.
  */
 function defaultAutoPurgeNow() {
   return Date.now();
@@ -3833,7 +3889,7 @@ function createExtensionFormatDescriptor(entry, defaults, label) {
 function validateOrderedExtensionFormats(descriptors, ext) {
   for (let index = 0; index < descriptors.length - 1; index++) {
     const Format = descriptors[index].Format;
-    if (typeof Format.isSupported !== "function") {
+    if (typeof Format.is !== "function") {
       throw new TypeError(`CjsResMan extension .${ext} format ${Format.name || index} has no support probe and must be last.`);
     }
   }