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

package/dist/index.js

@@ -31,11 +31,28 @@ import * as index$1 from './global/utils/errors/index.js';
 export { index$1 as errors };
 export { CjsBackendCandidate } from './global/contracts/CjsBackendCandidate.js';
 export { CjsConstantPayload } from './global/contracts/CjsConstantPayload.js';
-export { CjsFrameLifecycle } from './global/contracts/CjsFrameLifecycle.js';
-export { CjsInstancedMeshManager } from './global/contracts/CjsInstancedMeshManager.js';
-export { ITr2BoundingBox, withITr2BoundingBox } from './global/contracts/ITr2BoundingBox.js';
-export { ITr2RenderNode, withITr2RenderNode } from './global/contracts/ITr2RenderNode.js';
+export { ITr2BoundingBox } from './global/contracts/ITr2BoundingBox.js';
+export { ITr2RenderNode } from './global/contracts/ITr2RenderNode.js';
 export { CjsScriptCallback } from './global/blue/CjsScriptCallback.js';
+export { IBlueDynamicResourceConstructor } from './global/blue/IBlueDynamicResourceConstructor.js';
+export { BeInfo } from './global/blue/BeInfo.js';
+export { IBlueEvents } from './global/blue/IBlueEvents.js';
+export { IVariableTicker } from './global/blue/IVariableTicker.js';
+export { ICatchupTicks } from './global/blue/ICatchupTicks.js';
+export { ISimTimeRebaseNotify } from './global/blue/ISimTimeRebaseNotify.js';
+export { IBlueOS } from './global/blue/IBlueOS.js';
+export { CjsBlueOS } from './global/blue/CjsBlueOS.js';
+export { CcpDateTime } from './global/blue/CcpDateTime.js';
+export { TimeAsDateTime, TimeAsDouble, TimeFromDateTime, TimeIsUTC } from './global/blue/CcpTime.js';
+export { BlueResManQueue, IBlueResMan } from './global/blue/IBlueResMan.js';
+export { IBlueResManNotifications } from './global/blue/IBlueResManNotifications.js';
+export { IInitialize } from './global/blue/IInitialize.js';
+export { IListNotify } from './global/blue/IListNotify.js';
+export { INotify, IsMatch } from './global/blue/INotify.js';
+export { CjsBluePaths } from './global/blue/CjsBluePaths.js';
+export { IBluePaths } from './global/blue/IBluePaths.js';
+export { blue } from './global/blue/blue.js';
+export { CjsBlueEnumRegistry, EnumRegistrationType } from './global/blue/enums/CjsBlueEnumRegistry.js';
 import * as index from './global/consts/index.js';
 export { index as constants };
 import * as num from './global/math/num.js';
@@ -134,6 +151,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 +164,16 @@ 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 { AudioMetadata } from './resource/video/AudioMetadata.js';
+export { IAudioSink } from './resource/video/IAudioSink.js';
+export { IEncodedFrame } from './resource/video/IEncodedFrame.js';
+export { IVideoContainerParser } from './resource/video/IVideoContainerParser.js';
+export { IVideoDecoder } from './resource/video/IVideoDecoder.js';
+export { PcmFrame } from './resource/video/PcmFrame.js';
+export { VideoFrame } from './resource/video/VideoFrame.js';
+export { VideoMetadata } from './resource/video/VideoMetadata.js';
+export { DecoderError, ParserError, StreamType } from './resource/video/enums.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';
@@ -157,16 +185,16 @@ export { CjsResManMainThreadLoader } from './resource/worker/CjsResManMainThread
 export { CjsResManWorkerLoader } from './resource/worker/CjsResManWorkerLoader.js';
 export { CjsResManQueue } from './resource/CjsResManWorkQueue.js';
 export { CjsResMan } from './resource/CjsResMan.js';
-export { Adopt, Brand, ITr2Controller, withITr2Controller } from './trinity/controllers/ITr2Controller/ITr2Controller.js';
-export { ITr2ActionController, withITr2ActionController } from './trinity/controllers/ITr2Controller/ITr2ActionController.js';
-export { ITr2ControllerOwner, withITr2ControllerOwner } from './trinity/controllers/ITr2ControllerOwner.js';
+export { ITr2Controller } from './trinity/controllers/ITr2Controller/ITr2Controller.js';
+export { ITr2ActionController } from './trinity/controllers/ITr2Controller/ITr2ActionController.js';
+export { ITr2ControllerOwner } from './trinity/controllers/ITr2ControllerOwner.js';
 export { Tr2Controller } from './trinity/controllers/Tr2Controller.js';
 export { Tr2ControllerEventHandler } from './trinity/controllers/Tr2ControllerEventHandler.js';
 export { Tr2ControllerReference } from './trinity/controllers/Tr2ControllerReference.js';
 export { Tr2SyncToAnimation } from './trinity/controllers/Tr2SyncToAnimation.js';
-export { BELIST_EVENTMASK, BELIST_INSERTED, BELIST_LOADFINISHED, BELIST_LOADING, BELIST_REMOVED, BELIST_UNLOADSTART, GetControllerActualTimeSeconds, GetControllerFrameTimeSeconds, GetControllerTimeSeconds, TR2_DIRTY_ALL, ToDirtyMask } from './trinity/controllers/contracts.js';
+export { BELIST_EVENTMASK, BELIST_INSERTED, BELIST_LOADFINISHED, BELIST_LOADING, BELIST_MOVED, BELIST_REMOVED, BELIST_SWAPPED, BELIST_UNLOADING, BELIST_UNLOADSTART, GetControllerActualTimeSeconds, GetControllerFrameTimeSeconds, GetControllerTimeSeconds, TR2_DIRTY_ALL, ToDirtyMask } from './trinity/controllers/contracts.js';
 export { DestinationType, PlayAction, ResetBehavior, StopAction, Type, UnlinkReason } from './trinity/controllers/enums.js';
-export { ITr2ControllerAction, withITr2ControllerAction } from './trinity/controllers/action/ITr2ControllerAction.js';
+export { ITr2ControllerAction } from './trinity/controllers/action/ITr2ControllerAction.js';
 export { Tr2ActionAnimateCurveSet } from './trinity/controllers/action/Tr2ActionAnimateCurveSet.js';
 export { Tr2ActionAnimateValue } from './trinity/controllers/action/Tr2ActionAnimateValue.js';
 export { Tr2ActionBindRTPC } from './trinity/controllers/action/Tr2ActionBindRTPC.js';
@@ -191,7 +219,7 @@ export { CjsControllerExpressionEvaluateError } from './trinity/controllers/expr
 export { Tr2BindingPoint } from './trinity/controllers/expression/Tr2BindingPoint.js';
 export { Tr2ControllerExpression } from './trinity/controllers/expression/Tr2ControllerExpression.js';
 export { Tr2ControllerFloatVariable } from './trinity/controllers/expression/Tr2ControllerFloatVariable.js';
-export { ITr2StateMachineStateFinalizer, withITr2StateMachineStateFinalizer } from './trinity/controllers/state/ITr2StateMachineStateFinalizer.js';
+export { ITr2StateMachineStateFinalizer } from './trinity/controllers/state/ITr2StateMachineStateFinalizer.js';
 export { Tr2StateMachine } from './trinity/controllers/state/Tr2StateMachine.js';
 export { Tr2StateMachineState } from './trinity/controllers/state/Tr2StateMachineState.js';
 export { Tr2StateMachineTransition } from './trinity/controllers/state/Tr2StateMachineTransition.js';
@@ -255,9 +283,9 @@ export { FormationData } from './trinity/eve/FormationData.js';
 export { InertiaData } from './trinity/eve/InertiaData.js';
 export { IEveBallpark } from './trinity/eve/IEveBallpark.js';
 export { IEveFiringEffectElement } from './trinity/eve/IEveFiringEffectElement.js';
-export { IEveInheritPropertiesOwner, withIEveInheritPropertiesOwner } from './trinity/eve/IEveInheritPropertiesOwner.js';
-export { IEveSpaceObject2, withIEveSpaceObject2 } from './trinity/eve/IEveSpaceObject2.js';
-export { IEveTransform, withIEveTransform } from './trinity/eve/IEveTransform.js';
+export { IEveInheritPropertiesOwner } from './trinity/eve/IEveInheritPropertiesOwner.js';
+export { IEveSpaceObject2 } from './trinity/eve/IEveSpaceObject2.js';
+export { IEveTransform } from './trinity/eve/IEveTransform.js';
 export { IEveReferencePoint } from './trinity/eve/IEveReferencePoint.js';
 export { PlacementDataWithIdentifier } from './trinity/eve/PlacementDataWithIdentifier.js';
 export { PlayFXData } from './trinity/eve/PlayFXData.js';
@@ -375,7 +403,7 @@ export { EveChildCloud2 } from './trinity/eve/child/EveChildCloud2.js';
 export { EveChildPartDataPartData } from './trinity/eve/child/EveChildPartData/EveChildPartDataPartData.js';
 export { EveChildPartData } from './trinity/eve/child/EveChildPartData/EveChildPartData.js';
 export { ITr2FroxelFogSettings } from './trinity/eve/child/ITr2FroxelFogSettings.js';
-export { IEveLightingOverride, withIEveLightingOverride } from './trinity/eve/child/IEveLightingOverride.js';
+export { IEveLightingOverride } from './trinity/eve/child/IEveLightingOverride.js';
 export { CjsLightData, createCjsLightDataView, setCjsLightDataOwnerValues } from './trinity/eve/lights/CjsLightData.js';
 export { LightFeatures } from './trinity/eve/lights/LightFeatures.js';
 export { Tr2Light } from './trinity/eve/lights/Tr2Light.js';
@@ -535,7 +563,7 @@ export { createChildPerObjectRecords, inheritParentPerObjectData, stampChildTran
 export { AudioGameObject } from './trinity/eve/AudioGameObject.js';
 export { Tr2ParticleSystem } from './trinity/particle/Tr2ParticleSystem.js';
 export { ITr2GenericEmitterUpdateArguments } from './trinity/particle/ITr2GenericEmitter/ITr2GenericEmitterUpdateArguments.js';
-export { ITr2GenericEmitter, withITr2GenericEmitter } from './trinity/particle/ITr2GenericEmitter/ITr2GenericEmitter.js';
+export { ITr2GenericEmitter } from './trinity/particle/ITr2GenericEmitter/ITr2GenericEmitter.js';
 export { ITr2AttributeGenerator } from './trinity/particle/attribute/ITr2AttributeGenerator.js';
 export { Tr2CapsuleShapeAttributeGenerator } from './trinity/particle/attribute/Tr2CapsuleShapeAttributeGenerator.js';
 export { Tr2ConsecutiveIntegerAttributeGenerator } from './trinity/particle/attribute/Tr2ConsecutiveIntegerAttributeGenerator.js';
@@ -672,6 +700,9 @@ export { Tr2RuntimeTextureParameter } from './trinity/shader/parameter/Tr2Runtim
 export { Tr2TextureAnimationParameter } from './trinity/shader/parameter/Tr2TextureAnimationParameter.js';
 export { Tr2Vector2Parameter } from './trinity/shader/parameter/Tr2Vector2Parameter.js';
 export { Tr2Vector3Parameter } from './trinity/shader/parameter/Tr2Vector3Parameter.js';
+export { ITriEffectParameter } from './trinity/shader/parameter/ITriEffectParameter.js';
+export { ITriEffectResourceParameter } from './trinity/shader/parameter/ITriEffectResourceParameter.js';
+export { ITriEffectTextureParameter } from './trinity/shader/parameter/ITriEffectTextureParameter.js';
 export { Tr2Vector4Parameter } from './trinity/shader/parameter/Tr2Vector4Parameter.js';
 export { TriFloatArrayParameter } from './trinity/shader/parameter/TriFloatArrayParameter.js';
 export { TriTextureParameter } from './trinity/shader/parameter/TriTextureParameter.js';
@@ -690,8 +721,9 @@ export { Tr2MaterialBoundsAdjustment } from './trinity/utilities/Tr2MaterialBoun
 export { Float4x3 } from './trinity/utilities/Float4x3.js';
 export { Obb } from './trinity/utilities/Obb.js';
 export { Tr2MaterialParameterStore } from './trinity/core/Tr2MaterialParameterStore.js';
-export { ITr2Renderable, withITr2Renderable } from './trinity/core/ITr2Renderable.js';
-export { ITr2Updateable, withITr2Updateable } from './trinity/core/ITr2Updateable.js';
+export { ITr2Renderable } from './trinity/core/ITr2Renderable.js';
+export { ITriReroutable } from './trinity/core/ITriReroutable.js';
+export { ITr2Updateable } from './trinity/core/ITr2Updateable.js';
 export { Tr2QuadRendererEffectRecord } from './trinity/core/Tr2QuadRenderer/Tr2QuadRendererEffectRecord.js';
 export { Tr2QuadRenderer } from './trinity/core/Tr2QuadRenderer/Tr2QuadRenderer.js';
 export { Tr2Transform } from './trinity/core/Tr2Transform.js';
@@ -727,7 +759,7 @@ export { EFFECT_CONSTANTS, PER_FRAME_PS, PER_FRAME_VS, PER_OBJECT_PS, PER_OBJECT
 export { AdjustTextureCoordsToViewport, FillAndSetConstants, SCREEN_QUAD_FLOATS, SCREEN_VERTEX_BYTES, SCREEN_VERTEX_FLOATS, SetConstants, SetupScreenQuad, SetupScreenQuadInCameraSpace } from './trinity/core/Tr2RenderUtils.js';
 export { BLIT_EFFECT_PATH, BLIT_FILTERED_EFFECT_PATH, Filtering, Tr2Blitter } from './trinity/core/Tr2Blitter.js';
 export { Tr2Denoiser } from './trinity/core/Tr2Denoiser.js';
-export { Tr2RenderContext } from './trinity/core/context/Tr2RenderContext.js';
+export { Tr2RenderContext, Tr2RenderContext_GetMainThreadRenderContext } from './trinity/core/context/Tr2RenderContext.js';
 export { Tr2PrimaryRenderContext } from './trinity/core/context/Tr2PrimaryRenderContext.js';
 export { Tr2VisibilityResults } from './trinity/core/context/Tr2VisibilityResults/Tr2VisibilityResults.js';
 export { Tr2VisibilityEvent } from './trinity/core/context/Tr2VisibilityResults/Tr2VisibilityEvent.js';
@@ -744,6 +776,7 @@ export { Tr2GpuBuffer } from './trinity/core/device/Tr2GpuBuffer.js';
 export { Tr2RingBufferOffsets } from './trinity/core/device/Tr2RingBuffer/Tr2RingBufferOffsets.js';
 export { Tr2RingBuffer } from './trinity/core/device/Tr2RingBuffer/Tr2RingBuffer.js';
 export { Tr2RuntimeGpuBuffer } from './trinity/core/device/Tr2RuntimeGpuBuffer.js';
+export { gTriDev } from './trinity/core/device/gTriDev.js';
 export { Tr2LightManager } from './trinity/core/lighting/Tr2LightManager.js';
 export { Tr2ShLightingManager } from './trinity/core/lighting/Tr2ShLightingManager.js';
 export { Tr2KelvinColor } from './trinity/core/lighting/Tr2KelvinColor.js';
@@ -763,9 +796,11 @@ export { Tr2SerializedMorphAnimation } from './trinity/core/mesh/Tr2SerializedMo
 export { Tr2DirectInstanceData } from './trinity/core/mesh/Tr2DirectInstanceData.js';
 export { Tr2RuntimeInstanceData } from './trinity/core/mesh/Tr2RuntimeInstanceData.js';
 export { ITr2InstanceDataInstanceData } from './trinity/core/mesh/ITr2InstanceData/ITr2InstanceDataInstanceData.js';
-export { ITr2InstanceData, withITr2InstanceData } from './trinity/core/mesh/ITr2InstanceData/ITr2InstanceData.js';
+export { ITr2InstanceData } from './trinity/core/mesh/ITr2InstanceData/ITr2InstanceData.js';
 export { ITr2ImpostorSourceImpostorHash } from './trinity/core/mesh/ITr2ImpostorSource/ITr2ImpostorSourceImpostorHash.js';
-export { ITr2ImpostorSource, withITr2ImpostorSource } from './trinity/core/mesh/ITr2ImpostorSource/ITr2ImpostorSource.js';
+export { ITr2ImpostorSource } from './trinity/core/mesh/ITr2ImpostorSource/ITr2ImpostorSource.js';
+export { GradientTextureConstructor, RegisterGradientTexture } from './trinity/core/procedural/GradientTextureConstructor.js';
+export { GradientPathToCurve, GradientPrefix, IsGradientTexturePath, RasterizeGradient } from './trinity/core/procedural/gradientTexture.js';
 export { RawData, RawDataEncoders, RawDataType } from './trinity/core/rawData/RawData.js';
 export { TriPoolAllocator } from './trinity/core/rawData/TriPoolAllocator.js';
 export { Tr2PerObjectData } from './trinity/core/rawData/perObjectData/Tr2PerObjectData.js';
@@ -1002,7 +1037,7 @@ export { StretchAudio } from './audio/trinity/audio/StretchAudio.js';
 export { Tr2AudioStretchAuto } from './audio/trinity/trinityAudio/Tr2AudioStretchAuto.js';
 export { Tr2AudioStretchBase } from './audio/trinity/trinityAudio/Tr2AudioStretchBase.js';
 export { IStretchAudio } from './audio/trinity/trinityAudioApi/IStretchAudio.js';
-export { ITr2AudEmitter, withITr2AudEmitter } from './audio/trinity/trinityAudioApi/ITr2AudEmitter.js';
+export { ITr2AudEmitter } from './audio/trinity/trinityAudioApi/ITr2AudEmitter.js';
 export { Tr2AudGeometryData } from './audio/generated/trinityAudioApi/Tr2AudGeometryData.js';
 export { CjsAudioBackend } from './audio/CjsAudioBackend.js';
 export { CjsAudioMan } from './audio/CjsAudioMan.js';
@@ -1104,8 +1139,7 @@ export { Tr2MainWindow } from './input/Tr2MainWindow.js';
 export { Tr2MainWindowState } from './input/Tr2MainWindowState.js';
 export { Tr2MouseCursor } from './input/Tr2MouseCursor.js';
 export { GetUIScancode, SCANCODES, UIScancode } from './input/UIScancode.js';
-export { CjsLibrary, CjsServiceKey } from './core/CjsLibrary.js';
-export { CjsFrameDriver } from './core/CjsFrameDriver.js';
+export { CjsLibrary } from './core/CjsLibrary.js';
 export { CjsBackendPreference, CjsBackendRejection, SelectBackend } from './core/platform/backendSelection.js';
 export { CjsWebGLProbe, WEBGL2_PARAMETERS } from './core/platform/CjsWebGLProbe.js';
 export { ResolveDeviceRequirements, ResolveRequiredFeatures, ResolveRequiredLimits, WEBGPU_DEFAULT_LIMITS } from './core/platform/deviceLimits.js';
@@ -1116,6 +1150,7 @@ export { Tr2VideoAdapter } from './core/platform/Tr2VideoAdapter.js';
 export { Tr2VideoAdapters } from './core/platform/Tr2VideoAdapters.js';
 export { Tr2VideoDriver } from './core/platform/Tr2VideoDriver.js';
 export { AudioChannelLayout, AudioSampleFormat, normalizeAudioSampleFormat } from './global/consts/audio/audioFormats.js';
+export { BLUEERROR, BLUELISTEVENT } from './global/consts/blue.js';
 export { CJS_OPERATION_CANCELLED, CjsCancellationError } from './global/utils/errors/CjsCancellationError.js';
 export { CarbonPixelFormatToWebGpu, DxgiFormatToPixelFormat, GpuTextureFormat, PixelFormatToWebGpu, SrgbSiblingOf, dxgiToPixelFormat, toWebGpuTextureFormat } from './global/consts/webgpu/textureFormats.js';
 export { CjsError } from './global/utils/errors/CjsError.js';
@@ -1124,7 +1159,7 @@ export { D3dPrimitiveTopology } from './global/consts/d3d/primitiveTopology.js';
 export { DxgiFormat, normalizeDxgiFormat } from './global/consts/d3d/dxgiFormats.js';
 export { MediaType, PayloadType, normalizeMediaType, normalizePayloadType } from './global/consts/media/mediaTypes.js';
 export { PixelFormat, getPixelFormatBlockHeight, getPixelFormatBlockWidth, getPixelFormatBytesPerBlock, isCompressedPixelFormat, isSrgbPixelFormat, normalizePixelFormat } from './global/consts/graphics/pixelFormats.js';
-export { ReflectionMode, RenderingMode, TriBatchType, TriExtrapolation, TriOperator, TriTransformBase } from './global/consts/graphics/trinityEnums.js';
+export { ReflectionMode, RenderingMode, TRIEXTRAPOLATION, TRIOPERATOR, TRITRANSFORMBASE, TriBatchType, TriStorageFlags } from './global/consts/graphics/trinityEnums.js';
 export { ShaderModel, ShaderStage, normalizeShaderStage } from './global/consts/shader/shaderStages.js';
 export { TextureDimension, normalizeTextureDimension } from './global/consts/graphics/textureDimensions.js';
 export { Tr2Lod } from './global/consts/trinity.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,48 +157,62 @@ 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. Carbon
+// accepts both separators after the scheme (BlueFileUtil.cpp:33), and both are
+// nine characters, so the split below is the same either way.
+const DYNAMIC_RESOURCE_PREFIXES = ["dynamic:/", "dynamic:\\"];
+const DYNAMIC_PREFIX_LENGTH = 9;
+
+/**
+ * Whether a normalized path names a dynamic resource.
+ *
+ * @param {string} key Normalized resource path.
+ * @returns {boolean}
+ */
+function isDynamicResourcePath(key) {
+  return DYNAMIC_RESOURCE_PREFIXES.some(prefix => key.startsWith(prefix));
+}
+
+/**
+ * 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;
+}
+
+/**
+ * GPU-free resource manager that resolves paths through registered sources and
+ * formats, publishes canonical resources into a `CjsMotherLode` registry under
+ * exact-owner generation guards, and drives the main/background work queues,
+ * read-operation caching, reload staging, and automatic purge policy.
+ */
 class CjsResMan {
-  // Carbon reaches its manager through the process-wide `BeResMan`
-  // (Tr2Effect.cpp:397). Ours needs the same reach for the same reason: a
-  // Tr2Effect arrives from schema hydration, so nobody holds it at construction
-  // to inject a manager into, and it must be able to acquire its own effect
-  // resource during Initialize.
+  // The manager is no longer reachable from itself. Carbon's process-wide
+  // handle is an extern beside the interface it points at, not a static on
+  // the implementation (`blue/include/IBlueResMan.h:135`), and the port of
+  // that is `blue.resMan`. The static slot here was never installed by
+  // anything in src, so every consumer received null and silently skipped
+  // its acquisition.
   //
-  // Read at CALL time, never captured, exactly as the global variable store is
-  // (Tr2VariableStore.GlobalStore) - an installer that swaps the manager has
-  // to be seen by objects already built. Null is a real state: no manager
-  // installed means a caller composing by hand, and the caller assigns
-  // resources itself.
-  static #global = null;
-
-  /**
-   * Installs the manager that hydrated objects acquire their resources from.
-   *
-   * Composition owns this. Passing null uninstalls, which is how a test or a
-   * hand-composed caller keeps the global path from firing at all.
-   *
-   * @param {CjsResMan|null} resourceManager Manager to install.
-   * @returns {void}
-   */
-  static SetGlobal(resourceManager = null) {
-    if (resourceManager !== null && !(resourceManager instanceof CjsResMan)) {
-      throw new TypeError("CjsResMan.SetGlobal expects a CjsResMan or null.");
-    }
-    CjsResMan.#global = resourceManager;
-  }
+  // The res-file existence oracle went with it, to `blue.paths`, where
+  // Carbon keeps it: FileExistsLocally is IBluePaths.h:38, a different
+  // service behind a different extern.
 
-  /**
-   * The installed manager, or null when none is.
-   *
-   * Unlike the variable store this does NOT create one on demand: a resource
-   * manager carries configuration, sources and a cache, so a fabricated default
-   * would be a silently wrong one.
-   *
-   * @returns {CjsResMan|null} Installed manager.
-   */
-  static GetGlobal() {
-    return CjsResMan.#global;
-  }
   #autoPurgePolicy = null;
   #activeResourceOperations = 0;
   #invalidResourceOwnership = new WeakSet();
@@ -216,6 +230,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 +1019,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 +1116,11 @@ class CjsResMan {
       this.motherLode.KeepAlive(cacheKey);
       return existing;
     }
+    // Below the cache lookup, as in BlueResMan::GetResourceHelper, so identical
+    // queries share one resource.
+    if (isDynamicResourcePath(key)) {
+      return this.#CreateDynamicResource(key, cacheKey);
+    }
     if (!existing && options.reload === true) {
       this.InvalidateReadCache(key, {
         source: options.source || this.source
@@ -1133,12 +1193,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 +1827,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 +1855,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 +1897,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_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 +2000,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