@carbonenginejs/runtime 0.1.0-alpha.2 → 0.1.0-alpha.3

package/dist/global/schema/hydration.js

@@ -27,12 +27,14 @@ import { CjsSchema } from './CjsSchema.js';
  * reader works with only the schema layer loaded; the two are the same path
  * for every class that has the method.
  *
- * A REGISTERED class without SetValues - one that no longer extends CjsModel -
- * is still a resolved class, so it populates through CjsSchema.setValues, which
- * answers without the model layer. Only an unregistered carrier (the reader's
- * `{ _sourceClassName }` fallback) takes raw assignment. Without this middle
- * arm, taking a class off the base would silently drop it to Object.assign:
- * no coercion, no writability gate, no settle.
+ * A schema-declared class without SetValues - one that no longer extends
+ * CjsModel - populates through CjsSchema.setValues, which answers without the
+ * model layer. The READER says so, as `ctx.declared`: it resolved the kind to
+ * a constructor itself and asks CjsSchema whether that class declares fields,
+ * so the adapter never inspects the object. Raw assignment stays for what
+ * declares nothing - the reader's fallback carrier, and a caller-supplied
+ * plain class. Without this arm, taking a class off the base would silently
+ * drop it to Object.assign: no coercion, no writability gate, no settle.
  */
 
 
@@ -57,8 +59,8 @@ function resolveHydrationAdapter(options = {}) {
         instance.SetValues(values, ctx?.options);
         return instance;
       }
-      if (instance && CjsSchema.getClassName(instance.constructor)) {
-        CjsSchema.setValues(instance, values, ctx?.options);
+      if (ctx?.declared === true) {
+        CjsSchema.setValues(instance, values, ctx.options);
         return instance;
       }
       return Object.assign(instance, values);

package/dist/global/schema/hydration.js.map

@@ -1 +1 @@
-{"version":3,"file":"hydration.js","sources":["../../../../src/global/schema/hydration.js"],"sourcesContent":["/**\n * Hydration adapter seam - the population contract for readers that build\n * runtime objects incrementally (black/red). The ordering guarantee:\n *\n *   1. construct   - build every instance (register refs before values, so\n *                    cycles/back-references resolve)\n *   2. applyValues - apply each node's field values\n *   3. finalize    - run once per instance AFTER the whole graph is built,\n *                    so references are already resolved\n *\n * DEFAULTS (operator ruling, 2026-09-05; resource-population.md owns the\n * decision): a resolved class is populated through its own validated setter -\n * \"if someone is using Object.assign, they probably should be using\n * SetValues\" - and a class-owned Initialize runs once post-graph, which is\n * the incremental-reader counterpart of the reader+IInitialize handshake\n * Blue performs and CjsModel.from performs for whole-bag JSON. Plain\n * fallback carriers (unresolved kinds) keep raw assignment: that IS their\n * contract, not a bypass.\n *\n * The single escape hatch is `options.adapter`, per-hook optional. The\n * per-kind adapters map and the hydrationAdapter alias are gone - they had\n * zero consumers. Callers wanting raw assignment pass their own adapter.\n *\n * SetValues is called directly rather than through CjsSchema.setValues so a\n * reader works with only the schema layer loaded; the two are the same path\n * for every class that has the method.\n *\n * A REGISTERED class without SetValues - one that no longer extends CjsModel -\n * is still a resolved class, so it populates through CjsSchema.setValues, which\n * answers without the model layer. Only an unregistered carrier (the reader's\n * `{ _sourceClassName }` fallback) takes raw assignment. Without this middle\n * arm, taking a class off the base would silently drop it to Object.assign:\n * no coercion, no writability gate, no settle.\n */\n\nimport { CjsSchema } from \"./CjsSchema.js\";\n\n/**\n * Resolves a normalized adapter from hydration options. The returned object\n * always exposes construct/applyValues/finalize with the documented defaults.\n *\n * @param {Object} [options]\n * @param {Object} [options.adapter] Per-hook overrides: construct/applyValues/finalize.\n * @returns {{ construct: Function, applyValues: Function, finalize: Function }}\n */\nexport function resolveHydrationAdapter(options = {})\n{\n    const custom = options.adapter || null;\n\n    return {\n        construct(kind, ctx)\n        {\n            if (custom && typeof custom.construct === \"function\") return custom.construct(kind, ctx);\n            return undefined;\n        },\n        applyValues(instance, values, ctx)\n        {\n            if (custom && typeof custom.applyValues === \"function\") return custom.applyValues(instance, values, ctx);\n            if (instance && typeof instance.SetValues === \"function\")\n            {\n                instance.SetValues(values, ctx?.options);\n                return instance;\n            }\n            if (instance && CjsSchema.getClassName(instance.constructor))\n            {\n                CjsSchema.setValues(instance, values, ctx?.options);\n                return instance;\n            }\n            return Object.assign(instance, values);\n        },\n        finalize(instance, ctx)\n        {\n            if (custom && typeof custom.finalize === \"function\")\n            {\n                custom.finalize(instance, ctx);\n                return;\n            }\n            if (instance && typeof instance.Initialize === \"function\") instance.Initialize();\n        }\n    };\n}\n"],"names":["resolveHydrationAdapter","options","custom","adapter","construct","kind","ctx","undefined","applyValues","instance","values","SetValues","CjsSchema","getClassName","constructor","setValues","Object","assign","finalize","Initialize"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASA,uBAAuBA,CAACC,OAAO,GAAG,EAAE,EACpD;AACI,EAAA,MAAMC,MAAM,GAAGD,OAAO,CAACE,OAAO,IAAI,IAAI;EAEtC,OAAO;AACHC,IAAAA,SAASA,CAACC,IAAI,EAAEC,GAAG,EACnB;AACI,MAAA,IAAIJ,MAAM,IAAI,OAAOA,MAAM,CAACE,SAAS,KAAK,UAAU,EAAE,OAAOF,MAAM,CAACE,SAAS,CAACC,IAAI,EAAEC,GAAG,CAAC;AACxF,MAAA,OAAOC,SAAS;IACpB,CAAC;AACDC,IAAAA,WAAWA,CAACC,QAAQ,EAAEC,MAAM,EAAEJ,GAAG,EACjC;AACI,MAAA,IAAIJ,MAAM,IAAI,OAAOA,MAAM,CAACM,WAAW,KAAK,UAAU,EAAE,OAAON,MAAM,CAACM,WAAW,CAACC,QAAQ,EAAEC,MAAM,EAAEJ,GAAG,CAAC;MACxG,IAAIG,QAAQ,IAAI,OAAOA,QAAQ,CAACE,SAAS,KAAK,UAAU,EACxD;QACIF,QAAQ,CAACE,SAAS,CAACD,MAAM,EAAEJ,GAAG,EAAEL,OAAO,CAAC;AACxC,QAAA,OAAOQ,QAAQ;AACnB,MAAA;MACA,IAAIA,QAAQ,IAAIG,SAAS,CAACC,YAAY,CAACJ,QAAQ,CAACK,WAAW,CAAC,EAC5D;QACIF,SAAS,CAACG,SAAS,CAACN,QAAQ,EAAEC,MAAM,EAAEJ,GAAG,EAAEL,OAAO,CAAC;AACnD,QAAA,OAAOQ,QAAQ;AACnB,MAAA;AACA,MAAA,OAAOO,MAAM,CAACC,MAAM,CAACR,QAAQ,EAAEC,MAAM,CAAC;IAC1C,CAAC;AACDQ,IAAAA,QAAQA,CAACT,QAAQ,EAAEH,GAAG,EACtB;MACI,IAAIJ,MAAM,IAAI,OAAOA,MAAM,CAACgB,QAAQ,KAAK,UAAU,EACnD;AACIhB,QAAAA,MAAM,CAACgB,QAAQ,CAACT,QAAQ,EAAEH,GAAG,CAAC;AAC9B,QAAA;AACJ,MAAA;AACA,MAAA,IAAIG,QAAQ,IAAI,OAAOA,QAAQ,CAACU,UAAU,KAAK,UAAU,EAAEV,QAAQ,CAACU,UAAU,EAAE;AACpF,IAAA;GACH;AACL;;;;"}
+{"version":3,"file":"hydration.js","sources":["../../../../src/global/schema/hydration.js"],"sourcesContent":["/**\n * Hydration adapter seam - the population contract for readers that build\n * runtime objects incrementally (black/red). The ordering guarantee:\n *\n *   1. construct   - build every instance (register refs before values, so\n *                    cycles/back-references resolve)\n *   2. applyValues - apply each node's field values\n *   3. finalize    - run once per instance AFTER the whole graph is built,\n *                    so references are already resolved\n *\n * DEFAULTS (operator ruling, 2026-09-05; resource-population.md owns the\n * decision): a resolved class is populated through its own validated setter -\n * \"if someone is using Object.assign, they probably should be using\n * SetValues\" - and a class-owned Initialize runs once post-graph, which is\n * the incremental-reader counterpart of the reader+IInitialize handshake\n * Blue performs and CjsModel.from performs for whole-bag JSON. Plain\n * fallback carriers (unresolved kinds) keep raw assignment: that IS their\n * contract, not a bypass.\n *\n * The single escape hatch is `options.adapter`, per-hook optional. The\n * per-kind adapters map and the hydrationAdapter alias are gone - they had\n * zero consumers. Callers wanting raw assignment pass their own adapter.\n *\n * SetValues is called directly rather than through CjsSchema.setValues so a\n * reader works with only the schema layer loaded; the two are the same path\n * for every class that has the method.\n *\n * A schema-declared class without SetValues - one that no longer extends\n * CjsModel - populates through CjsSchema.setValues, which answers without the\n * model layer. The READER says so, as `ctx.declared`: it resolved the kind to\n * a constructor itself and asks CjsSchema whether that class declares fields,\n * so the adapter never inspects the object. Raw assignment stays for what\n * declares nothing - the reader's fallback carrier, and a caller-supplied\n * plain class. Without this arm, taking a class off the base would silently\n * drop it to Object.assign: no coercion, no writability gate, no settle.\n */\n\nimport { CjsSchema } from \"./CjsSchema.js\";\n\n/**\n * Resolves a normalized adapter from hydration options. The returned object\n * always exposes construct/applyValues/finalize with the documented defaults.\n *\n * @param {Object} [options]\n * @param {Object} [options.adapter] Per-hook overrides: construct/applyValues/finalize.\n * @returns {{ construct: Function, applyValues: Function, finalize: Function }}\n */\nexport function resolveHydrationAdapter(options = {})\n{\n    const custom = options.adapter || null;\n\n    return {\n        construct(kind, ctx)\n        {\n            if (custom && typeof custom.construct === \"function\") return custom.construct(kind, ctx);\n            return undefined;\n        },\n        applyValues(instance, values, ctx)\n        {\n            if (custom && typeof custom.applyValues === \"function\") return custom.applyValues(instance, values, ctx);\n            if (instance && typeof instance.SetValues === \"function\")\n            {\n                instance.SetValues(values, ctx?.options);\n                return instance;\n            }\n            if (ctx?.declared === true)\n            {\n                CjsSchema.setValues(instance, values, ctx.options);\n                return instance;\n            }\n            return Object.assign(instance, values);\n        },\n        finalize(instance, ctx)\n        {\n            if (custom && typeof custom.finalize === \"function\")\n            {\n                custom.finalize(instance, ctx);\n                return;\n            }\n            if (instance && typeof instance.Initialize === \"function\") instance.Initialize();\n        }\n    };\n}\n"],"names":["resolveHydrationAdapter","options","custom","adapter","construct","kind","ctx","undefined","applyValues","instance","values","SetValues","declared","CjsSchema","setValues","Object","assign","finalize","Initialize"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASA,uBAAuBA,CAACC,OAAO,GAAG,EAAE,EACpD;AACI,EAAA,MAAMC,MAAM,GAAGD,OAAO,CAACE,OAAO,IAAI,IAAI;EAEtC,OAAO;AACHC,IAAAA,SAASA,CAACC,IAAI,EAAEC,GAAG,EACnB;AACI,MAAA,IAAIJ,MAAM,IAAI,OAAOA,MAAM,CAACE,SAAS,KAAK,UAAU,EAAE,OAAOF,MAAM,CAACE,SAAS,CAACC,IAAI,EAAEC,GAAG,CAAC;AACxF,MAAA,OAAOC,SAAS;IACpB,CAAC;AACDC,IAAAA,WAAWA,CAACC,QAAQ,EAAEC,MAAM,EAAEJ,GAAG,EACjC;AACI,MAAA,IAAIJ,MAAM,IAAI,OAAOA,MAAM,CAACM,WAAW,KAAK,UAAU,EAAE,OAAON,MAAM,CAACM,WAAW,CAACC,QAAQ,EAAEC,MAAM,EAAEJ,GAAG,CAAC;MACxG,IAAIG,QAAQ,IAAI,OAAOA,QAAQ,CAACE,SAAS,KAAK,UAAU,EACxD;QACIF,QAAQ,CAACE,SAAS,CAACD,MAAM,EAAEJ,GAAG,EAAEL,OAAO,CAAC;AACxC,QAAA,OAAOQ,QAAQ;AACnB,MAAA;AACA,MAAA,IAAIH,GAAG,EAAEM,QAAQ,KAAK,IAAI,EAC1B;QACIC,SAAS,CAACC,SAAS,CAACL,QAAQ,EAAEC,MAAM,EAAEJ,GAAG,CAACL,OAAO,CAAC;AAClD,QAAA,OAAOQ,QAAQ;AACnB,MAAA;AACA,MAAA,OAAOM,MAAM,CAACC,MAAM,CAACP,QAAQ,EAAEC,MAAM,CAAC;IAC1C,CAAC;AACDO,IAAAA,QAAQA,CAACR,QAAQ,EAAEH,GAAG,EACtB;MACI,IAAIJ,MAAM,IAAI,OAAOA,MAAM,CAACe,QAAQ,KAAK,UAAU,EACnD;AACIf,QAAAA,MAAM,CAACe,QAAQ,CAACR,QAAQ,EAAEH,GAAG,CAAC;AAC9B,QAAA;AACJ,MAAA;AACA,MAAA,IAAIG,QAAQ,IAAI,OAAOA,QAAQ,CAACS,UAAU,KAAK,UAAU,EAAET,QAAQ,CAACS,UAAU,EAAE;AACpF,IAAA;GACH;AACL;;;;"}

package/dist/index.js

@@ -134,6 +134,7 @@ export { Tr2SamplerSetup } from './resource/shader/sampler/Tr2SamplerSetup.js';
 export { RegisterShaderResources, ShaderResourceExtensions } from './resource/shader/registerShaderResources.js';
 export { CjsTextureArrayRes } from './resource/texture/CjsTextureArrayRes.js';
 export { CjsTextureArrayResParameterProxy } from './resource/texture/CjsTextureArrayResParameterProxy.js';
+export { RegisterSolidColorTexture, SolidColorTextureConstructor } from './resource/texture/SolidColorTextureConstructor.js';
 export { Tr2ImageRes } from './resource/texture/Tr2ImageRes.js';
 export { Tr2TextureLodManager } from './resource/texture/Tr2TextureLodManager.js';
 export { Tr2TextureLodUpdateRequest } from './resource/texture/Tr2TextureLodUpdateRequest.js';
@@ -146,6 +147,7 @@ export { Tr2TexturePipelineStepLimitSize } from './resource/texture/Tr2TexturePi
 export { Tr2TexturePipelineStepLoad } from './resource/texture/Tr2TexturePipelineStepLoad.js';
 export { Tr2TexturePipelineStepPack } from './resource/texture/Tr2TexturePipelineStepPack.js';
 export { TriTextureRes } from './resource/texture/TriTextureRes.js';
+export { ColorPrefix, IsSolidColorTexturePath, ParseColor, RasterizeSolidColor } from './resource/texture/solidColorTexture.js';
 export { CjsResourceProbe } from './resource/format/CjsResourceProbe.js';
 export { ResourcePayloadType, ResourcePayloadValues, validateAudioPayload, validateRgbaPayload, validateTexturePayload, validateVideoPayload } from './resource/format/payloadContract.js';
 export { CjsFormat, CjsFormatOutputRole, CjsFormatReadMode } from './resource/format/CjsFormat.js';

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/resource/CjsResMan.js

@@ -157,6 +157,30 @@ let nextLocalValueIdentity = 1;
  * @typedef {CjsResourceOwnership|CjsResourceReloadCandidate} CjsResourceMutationAuthority
  */
 
+// `dynamic:` protocol (BlueResMan.cpp:219-223): the name is the segment after
+// this prefix, and everything after the following slash is the query.
+const DYNAMIC_RESOURCE_PREFIX = "dynamic:/";
+
+/**
+ * Carbon logs and returns null for an unknown dynamic name or a constructor that
+ * yields nothing (BlueResMan.cpp:225-235). There is no log channel here, and a
+ * null handle breaks every caller that composes on GetResource, so the same
+ * condition is raised, named.
+ *
+ * @param {string} path Normalized dynamic path.
+ * @param {string} name Constructor name.
+ * @param {string} code Error code.
+ * @param {string} message Error message.
+ * @returns {Error}
+ */
+function dynamicResourceError(path, name, code, message) {
+  const error = new Error(`CjsResMan ${message} (${path})`);
+  error.code = code;
+  error.path = path;
+  error.name = "CjsResManDynamicResourceError";
+  error.constructorName = name;
+  return error;
+}
 class CjsResMan {
   // Carbon reaches its manager through the process-wide `BeResMan`
   // (Tr2Effect.cpp:397). Ours needs the same reach for the same reason: a
@@ -216,6 +240,14 @@ class CjsResMan {
   #resourceExtensionRoutes = new WeakMap();
   #resourceHandlerModes = new WeakMap();
   #resourceTypeCandidates = new Map();
+  // BlueResMan::m_dynamicConstructors (BlueResMan.h:154-155).
+  #dynamicConstructors = new Map();
+  #dynamicResources = new WeakSet();
+  // Carbon caches a LoadObject BUILDER and creates a new object per call
+  // (BlueResMan.cpp:653-795). For an OBJECT-mode route that hydrates, the
+  // payload is the decoded plain values - the builder - and this records what
+  // builds from them.
+  #objectBuilders = new WeakMap();
 
   /**
    * Create a GPU-free resource manager and apply its initial registration.
@@ -997,6 +1029,39 @@ class CjsResMan {
     return this.#extensionRoutes.get(normalizeResourceExtension(extension)) || null;
   }
 
+  /**
+   * Registers the constructor that builds `dynamic:/<name>/<query>` resources
+   * (BlueResMan.cpp:296-305). The name is lowercased, as Carbon's is; the
+   * constructor's `GetResource(query)` returns a resource for that query.
+   *
+   * @param {string} name Name following `dynamic:/`.
+   * @param {{GetResource: function(string): object}} constructor Resource constructor.
+   * @returns {CjsResMan} This resource manager.
+   * @throws {TypeError} If the name is empty or the constructor has no GetResource.
+   */
+  RegisterResourceConstructor(name, constructor) {
+    const key = String(name ?? "").toLowerCase();
+    if (!key) {
+      throw new TypeError("CjsResMan.RegisterResourceConstructor requires a name.");
+    }
+    if (typeof constructor?.GetResource !== "function") {
+      throw new TypeError(`CjsResMan dynamic resource constructor "${key}" must implement GetResource.`);
+    }
+    this.#dynamicConstructors.set(key, constructor);
+    return this;
+  }
+
+  /**
+   * Removes a dynamic resource constructor (BlueResMan.cpp:312-325).
+   *
+   * @param {string} name Name following `dynamic:/`.
+   * @returns {CjsResMan} This resource manager.
+   */
+  UnregisterResourceConstructor(name) {
+    this.#dynamicConstructors.delete(String(name ?? "").toLowerCase());
+    return this;
+  }
+
   /**
    * Return registered format facades for one normalized input extension.
    *
@@ -1061,6 +1126,11 @@ class CjsResMan {
       this.motherLode.KeepAlive(cacheKey);
       return existing;
     }
+    // Below the cache lookup, as in BlueResMan::GetResourceHelper, so identical
+    // queries share one resource.
+    if (key.startsWith(DYNAMIC_RESOURCE_PREFIX)) {
+      return this.#CreateDynamicResource(key, cacheKey);
+    }
     if (!existing && options.reload === true) {
       this.InvalidateReadCache(key, {
         source: options.source || this.source
@@ -1133,12 +1203,25 @@ class CjsResMan {
     const ownership = this.#RequireResourceOwnership(resource, "object:begin");
     const existing = this.objectOperations.get(resource);
     if (existing?.ownership === ownership) {
-      return existing.promise;
+      // Joining an in-flight load shares its promise - unless the route builds
+      // per caller, when the load's own caller receives the instance built at
+      // publication and a joiner gets its own.
+      const route = this.#resourceExtensionRoutes.get(resource);
+      if (!route?.Target && !route?.Identify) return existing.promise;
+      return existing.promise.then(result => this.#objectBuilders.has(resource) ? this.#BuildObject(resource) : result);
     }
     if (resource.HasPayload?.()) {
       resource.KeepPayloadAlive?.();
+      if (this.#objectBuilders.has(resource)) {
+        return Promise.resolve().then(() => this.#BuildObject(resource));
+      }
       return Promise.resolve(getPublishedResourceObject(resource, this.#resourceExtensionRoutes.get(resource) || null, this.#resourceHandlerModes.get(resource) || null));
     }
+    if (this.#dynamicResources.has(resource)) {
+      // A dynamic resource is built by its constructor, never read from a
+      // source: without a payload it failed, and there is nothing to fetch.
+      return Promise.reject(resource.error || dynamicResourceError(resource.GetPath(), "", "CJS_RESMAN_DYNAMIC_RESOURCE_UNAVAILABLE", "dynamic resource has no payload"));
+    }
     const promise = this.QueueResourceObject(resource, operationOptions);
     const operation = {
       promise,
@@ -1754,6 +1837,7 @@ class CjsResMan {
    * @returns {*} Original or hydrated object value.
    */
   #HydrateExtensionObject(resource, values, options, resolved) {
+    this.#objectBuilders.delete(resource);
     const route = resolved.route;
     if (!route || !route.Target && !route.Identify) return values;
     const Format = resolved.descriptor?.Format || null;
@@ -1781,8 +1865,39 @@ class CjsResMan {
         throw createExtensionTargetError(resource, "Identify returned an invalid target constructor.", error);
       }
     }
+    const hydrated = this.#HydrateTarget(resource, Target, values, context);
+    // Publication decides whether this route builds per caller: only an
+    // OBJECT-mode handle hands its object out, so only it keeps the builder.
+    this.#objectBuilders.set(resource, {
+      Target,
+      context,
+      values,
+      hydrated
+    });
+    return hydrated;
+  }
+
+  /**
+   * Build one object from decoded values. Every build receives its own
+   * structured copy, so no two callers share a nested array, typed array or
+   * reader carrier however `from` treats its input - Carbon's objects are
+   * likewise independent, each read out of the cached reader's bytes.
+   *
+   * @param {CjsResource} resource Resource whose values are built.
+   * @param {Function} Target Resolved target constructor.
+   * @param {*} values Decoded plain values.
+   * @param {object} context Hydration context captured at publication.
+   * @returns {*} A new hydrated object.
+   */
+  #HydrateTarget(resource, Target, values, context) {
+    let copy;
+    try {
+      copy = structuredClone(values);
+    } catch (error) {
+      throw createExtensionTargetError(resource, "Decoded values could not be copied for a per-caller build.", error);
+    }
     try {
-      const hydrated = typeof Target.fromYAML === "function" ? Target.fromYAML(values, context) : Target.from(values);
+      const hydrated = typeof Target.fromYAML === "function" ? Target.fromYAML(copy, context) : Target.from(copy);
       if (hydrated && typeof hydrated.then === "function") {
         throw new TypeError("Extension target hydration must be synchronous.");
       }
@@ -1792,6 +1907,53 @@ class CjsResMan {
     }
   }
 
+  /**
+   * A fresh object from a resident builder: Carbon's
+   * `builder->CreateObjectWithYield` (BlueResMan.cpp:785).
+   *
+   * @param {CjsResource} resource Resource holding the decoded values as payload.
+   * @returns {*} A new hydrated object.
+   */
+  #BuildObject(resource) {
+    const builder = this.#objectBuilders.get(resource);
+    return this.#HydrateTarget(resource, builder.Target, resource.GetPayload(), builder.context);
+  }
+
+  /**
+   * `dynamic:` branch of BlueResMan::GetResourceHelper (BlueResMan.cpp:219-245).
+   * Inserted not cacheable, Carbon's `CACHING_NOT_ALLOWED`: a dynamic resource is
+   * never admitted to the byte cache.
+   *
+   * @param {string} key Normalized `dynamic:/<name>/<query>` path.
+   * @param {string} cacheKey MotherLode key.
+   * @returns {CjsResource} Canonical dynamic resource.
+   * @throws {Error} If no constructor is registered or it yields no resource.
+   */
+  #CreateDynamicResource(key, cacheKey) {
+    const rest = key.slice(DYNAMIC_RESOURCE_PREFIX.length);
+    const slash = rest.indexOf("/");
+    const name = slash === -1 ? rest : rest.slice(0, slash);
+    const query = slash === -1 ? "" : rest.slice(slash + 1);
+    const constructor = this.#dynamicConstructors.get(name);
+    if (!constructor) {
+      throw dynamicResourceError(key, name, "CJS_RESMAN_DYNAMIC_CONSTRUCTOR_MISSING", `no dynamic constructor is registered for "${name}"`);
+    }
+    const resource = constructor.GetResource(query);
+    if (!resource || typeof resource.Initialize !== "function" || typeof resource.SetObjectLoader !== "function") {
+      throw dynamicResourceError(key, name, "CJS_RESMAN_DYNAMIC_RESOURCE_UNAVAILABLE", `dynamic constructor "${name}" returned no CjsResource-compatible resource`);
+    }
+    this.#dynamicResources.add(resource);
+    resource.SetObjectLoader(() => this.GetObject(key));
+    const insertion = this.motherLode.Insert(cacheKey, resource, {
+      replace: true,
+      cacheable: false
+    });
+    const canonical = insertion?.resource || resource;
+    this.#BindResourceLifecycle(cacheKey, canonical);
+    this.motherLode.KeepAlive(cacheKey);
+    return canonical;
+  }
+
   /**
    * Publish the final CPU object outcome and loaded state. Every
    * CjsResource-compatible handle owns the reader/converter result through
@@ -1848,12 +2010,23 @@ class CjsResMan {
    */
   #PublishResourceObjectValue(resource, object, options) {
     const mode = resolveResourceHandlerMode(resource, this.#resourceExtensionRoutes.get(resource) ? this.#resourceHandlerModes.get(resource) : null);
-    resource.SetPayload?.(object, options);
+    const builder = this.#objectBuilders.get(resource);
+    const buildsPerCaller = mode === ResourceHandlerMode.OBJECT && builder?.hydrated === object;
+    if (builder && !buildsPerCaller) this.#objectBuilders.delete(resource);
+    // A per-caller route retains the decoded values - the builder - and hands
+    // `object` to this publication's caller only. The values then live under the
+    // payload lease, like any payload.
+    const payload = buildsPerCaller ? builder.values : object;
+    if (buildsPerCaller) {
+      delete builder.values;
+      delete builder.hydrated;
+    }
+    resource.SetPayload?.(payload, 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;
+    resource.object = buildsPerCaller ? payload : 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