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

package/dist/global/contracts/ITr2BoundingBox.js.map

@@ -1 +1 @@
-{"version":3,"file":"ITr2BoundingBox.js","sources":["../../../../src/global/contracts/ITr2BoundingBox.js"],"sourcesContent":["import { CjsSchema, impl } from \"../schema/index.js\";\n\n\nconst ITR2_BOUNDING_BOX = Symbol.for(\"carbonenginejs.contract.ITr2BoundingBox\");\n\n\n/**\n * Dependency-free contract for objects that publish a ready world-space axis-aligned bounding box.\n */\nexport class ITr2BoundingBox\n{\n    static [Symbol.hasInstance](value)\n    {\n        return value !== null && value !== undefined && value[ITR2_BOUNDING_BOX] === true;\n    }\n\n    /** Writes the current world-space minimum and maximum bounds. */\n    GetWorldBoundingBox(_minBounds, _maxBounds)\n    {\n        throw new Error(\"ITr2BoundingBox.GetWorldBoundingBox must be implemented by a bounding-box provider.\");\n    }\n\n    /** Reports whether the provider can currently answer a bounds query. */\n    IsBoundingBoxReady()\n    {\n        throw new Error(\"ITr2BoundingBox.IsBoundingBoxReady must be implemented by a bounding-box provider.\");\n    }\n}\n\nObject.defineProperty(ITr2BoundingBox.prototype, ITR2_BOUNDING_BOX, { value: true });\n\nCjsSchema.decorateMethod(ITr2BoundingBox, \"GetWorldBoundingBox\", impl.abstract);\nCjsSchema.decorateMethod(ITr2BoundingBox, \"IsBoundingBoxReady\", impl.abstract);\nCjsSchema.define(ITr2BoundingBox, { className: \"ITr2BoundingBox\" });\n\n\n/**\n * Adds the dependency-free ITr2BoundingBox contract to an existing model base\n * without replacing that base's JavaScript inheritance chain.\n */\nexport function withITr2BoundingBox(Base)\n{\n    const Provider = class extends Base\n    {\n        /** Delegates to the required world-bounds implementation. */\n        GetWorldBoundingBox(minBounds, maxBounds)\n        {\n            return ITr2BoundingBox.prototype.GetWorldBoundingBox.call(this, minBounds, maxBounds);\n        }\n\n        /** Delegates to the required bounds-readiness implementation. */\n        IsBoundingBoxReady()\n        {\n            return ITr2BoundingBox.prototype.IsBoundingBoxReady.call(this);\n        }\n    }\n\n    Object.defineProperty(Provider.prototype, ITR2_BOUNDING_BOX, { value: true });\n    CjsSchema.decorateMethod(Provider, \"GetWorldBoundingBox\", impl.abstract);\n    CjsSchema.decorateMethod(Provider, \"IsBoundingBoxReady\", impl.abstract);\n    return Provider;\n}\n"],"names":["ITR2_BOUNDING_BOX","Symbol","for","ITr2BoundingBox","hasInstance","value","undefined","GetWorldBoundingBox","_minBounds","_maxBounds","Error","IsBoundingBoxReady","Object","defineProperty","prototype","CjsSchema","decorateMethod","impl","abstract","define","className","withITr2BoundingBox","Base","Provider","minBounds","maxBounds","call"],"mappings":";;;AAGA,MAAMA,iBAAiB,GAAGC,MAAM,CAACC,GAAG,CAAC,yCAAyC,CAAC;;AAG/E;AACA;AACA;AACO,MAAMC,eAAe,CAC5B;AACI,EAAA,QAAQF,MAAM,CAACG,WAAW,CAAA,CAAEC,KAAK,EACjC;AACI,IAAA,OAAOA,KAAK,KAAK,IAAI,IAAIA,KAAK,KAAKC,SAAS,IAAID,KAAK,CAACL,iBAAiB,CAAC,KAAK,IAAI;AACrF,EAAA;;AAEA;AACAO,EAAAA,mBAAmBA,CAACC,UAAU,EAAEC,UAAU,EAC1C;AACI,IAAA,MAAM,IAAIC,KAAK,CAAC,qFAAqF,CAAC;AAC1G,EAAA;;AAEA;AACAC,EAAAA,kBAAkBA,GAClB;AACI,IAAA,MAAM,IAAID,KAAK,CAAC,oFAAoF,CAAC;AACzG,EAAA;AACJ;AAEAE,MAAM,CAACC,cAAc,CAACV,eAAe,CAACW,SAAS,EAAEd,iBAAiB,EAAE;AAAEK,EAAAA,KAAK,EAAE;AAAK,CAAC,CAAC;AAEpFU,SAAS,CAACC,cAAc,CAACb,eAAe,EAAE,qBAAqB,EAAEc,IAAI,CAACC,QAAQ,CAAC;AAC/EH,SAAS,CAACC,cAAc,CAACb,eAAe,EAAE,oBAAoB,EAAEc,IAAI,CAACC,QAAQ,CAAC;AAC9EH,SAAS,CAACI,MAAM,CAAChB,eAAe,EAAE;AAAEiB,EAAAA,SAAS,EAAE;AAAkB,CAAC,CAAC;;AAGnE;AACA;AACA;AACA;AACO,SAASC,mBAAmBA,CAACC,IAAI,EACxC;AACI,EAAA,MAAMC,QAAQ,GAAG,cAAcD,IAAI,CACnC;AACI;AACAf,IAAAA,mBAAmBA,CAACiB,SAAS,EAAEC,SAAS,EACxC;AACI,MAAA,OAAOtB,eAAe,CAACW,SAAS,CAACP,mBAAmB,CAACmB,IAAI,CAAC,IAAI,EAAEF,SAAS,EAAEC,SAAS,CAAC;AACzF,IAAA;;AAEA;AACAd,IAAAA,kBAAkBA,GAClB;MACI,OAAOR,eAAe,CAACW,SAAS,CAACH,kBAAkB,CAACe,IAAI,CAAC,IAAI,CAAC;AAClE,IAAA;GACH;EAEDd,MAAM,CAACC,cAAc,CAACU,QAAQ,CAACT,SAAS,EAAEd,iBAAiB,EAAE;AAAEK,IAAAA,KAAK,EAAE;AAAK,GAAC,CAAC;EAC7EU,SAAS,CAACC,cAAc,CAACO,QAAQ,EAAE,qBAAqB,EAAEN,IAAI,CAACC,QAAQ,CAAC;EACxEH,SAAS,CAACC,cAAc,CAACO,QAAQ,EAAE,oBAAoB,EAAEN,IAAI,CAACC,QAAQ,CAAC;AACvE,EAAA,OAAOK,QAAQ;AACnB;;;;"}
+{"version":3,"file":"ITr2BoundingBox.js","sources":["../../../../src/global/contracts/ITr2BoundingBox.js"],"sourcesContent":["import { CjsSchema, impl } from \"../schema/index.js\";\n\n\n/**\n * Dependency-free contract for objects that publish a ready world-space axis-aligned bounding box.\n */\nexport class ITr2BoundingBox\n{\n\n    /** Writes the current world-space minimum and maximum bounds. */\n    GetWorldBoundingBox(_minBounds, _maxBounds)\n    {\n        throw new Error(\"ITr2BoundingBox.GetWorldBoundingBox must be implemented by a bounding-box provider.\");\n    }\n\n    /** Reports whether the provider can currently answer a bounds query. */\n    IsBoundingBoxReady()\n    {\n        throw new Error(\"ITr2BoundingBox.IsBoundingBoxReady must be implemented by a bounding-box provider.\");\n    }\n}\n\nCjsSchema.decorateMethod(ITr2BoundingBox, \"GetWorldBoundingBox\", impl.abstract);\nCjsSchema.decorateMethod(ITr2BoundingBox, \"IsBoundingBoxReady\", impl.abstract);\nCjsSchema.define(ITr2BoundingBox, { className: \"ITr2BoundingBox\" });\n"],"names":["ITr2BoundingBox","GetWorldBoundingBox","_minBounds","_maxBounds","Error","IsBoundingBoxReady","CjsSchema","decorateMethod","impl","abstract","define","className"],"mappings":";;;AAGA;AACA;AACA;AACO,MAAMA,eAAe,CAC5B;AAEI;AACAC,EAAAA,mBAAmBA,CAACC,UAAU,EAAEC,UAAU,EAC1C;AACI,IAAA,MAAM,IAAIC,KAAK,CAAC,qFAAqF,CAAC;AAC1G,EAAA;;AAEA;AACAC,EAAAA,kBAAkBA,GAClB;AACI,IAAA,MAAM,IAAID,KAAK,CAAC,oFAAoF,CAAC;AACzG,EAAA;AACJ;AAEAE,SAAS,CAACC,cAAc,CAACP,eAAe,EAAE,qBAAqB,EAAEQ,IAAI,CAACC,QAAQ,CAAC;AAC/EH,SAAS,CAACC,cAAc,CAACP,eAAe,EAAE,oBAAoB,EAAEQ,IAAI,CAACC,QAAQ,CAAC;AAC9EH,SAAS,CAACI,MAAM,CAACV,eAAe,EAAE;AAAEW,EAAAA,SAAS,EAAE;AAAkB,CAAC,CAAC;;;;"}

package/dist/global/contracts/ITr2RenderNode.js

@@ -2,14 +2,9 @@ import { impl } from '../schema/index.js';
 import { CjsSchema } from '../schema/CjsSchema.js';
 
 // Source: trinity/trinity/ITr2RenderNode.h
-const ITR2_RENDER_NODE = Symbol.for("carbonenginejs.contract.ITr2RenderNode");
 
 /** Dependency-free contract for one node in a Trinity render graph. */
 class ITr2RenderNode {
-  static [Symbol.hasInstance](value) {
-    return value !== null && value !== undefined && value[ITR2_RENDER_NODE] === true;
-  }
-
   /** Validates the node against its requested destinations and named outputs. */
   Validate(_destinationDimensions, _outputs, _realTime, _simTime) {
     throw new Error("ITr2RenderNode.Validate must be implemented by a render node.");
@@ -20,32 +15,11 @@ class ITr2RenderNode {
     throw new Error("ITr2RenderNode.Execute must be implemented by a render node.");
   }
 }
-Object.defineProperty(ITr2RenderNode.prototype, ITR2_RENDER_NODE, {
-  value: true
-});
 CjsSchema.decorateMethod(ITr2RenderNode, "Validate", impl.abstract);
 CjsSchema.decorateMethod(ITr2RenderNode, "Execute", impl.abstract);
 CjsSchema.define(ITr2RenderNode, {
   className: "ITr2RenderNode"
 });
 
-/** Adds the ITr2RenderNode contract without replacing an existing model base. */
-function withITr2RenderNode(Base) {
-  const RenderNode = class extends Base {
-    Validate(destinationDimensions, outputs, realTime, simTime) {
-      return ITr2RenderNode.prototype.Validate.call(this, destinationDimensions, outputs, realTime, simTime);
-    }
-    Execute(destinations, outputs, realTime, simTime, rootTimer, renderContext) {
-      return ITr2RenderNode.prototype.Execute.call(this, destinations, outputs, realTime, simTime, rootTimer, renderContext);
-    }
-  };
-  Object.defineProperty(RenderNode.prototype, ITR2_RENDER_NODE, {
-    value: true
-  });
-  CjsSchema.decorateMethod(RenderNode, "Validate", impl.abstract);
-  CjsSchema.decorateMethod(RenderNode, "Execute", impl.abstract);
-  return RenderNode;
-}
-
-export { ITr2RenderNode, withITr2RenderNode };
+export { ITr2RenderNode };
 //# sourceMappingURL=ITr2RenderNode.js.map

package/dist/global/contracts/ITr2RenderNode.js.map

@@ -1 +1 @@
-{"version":3,"file":"ITr2RenderNode.js","sources":["../../../../src/global/contracts/ITr2RenderNode.js"],"sourcesContent":["// Source: trinity/trinity/ITr2RenderNode.h\nimport { CjsSchema, impl } from \"../schema/index.js\";\n\n\nconst ITR2_RENDER_NODE = Symbol.for(\"carbonenginejs.contract.ITr2RenderNode\");\n\n\n/** Dependency-free contract for one node in a Trinity render graph. */\nexport class ITr2RenderNode\n{\n  static [Symbol.hasInstance](value)\n  {\n    return value !== null && value !== undefined && value[ITR2_RENDER_NODE] === true;\n  }\n\n  /** Validates the node against its requested destinations and named outputs. */\n  Validate(_destinationDimensions, _outputs, _realTime, _simTime)\n  {\n    throw new Error(\"ITr2RenderNode.Validate must be implemented by a render node.\");\n  }\n\n  /** Executes the node into its requested destinations. */\n  Execute(_destinations, _outputs, _realTime, _simTime, _rootTimer, _renderContext)\n  {\n    throw new Error(\"ITr2RenderNode.Execute must be implemented by a render node.\");\n  }\n}\n\nObject.defineProperty(ITr2RenderNode.prototype, ITR2_RENDER_NODE, { value: true });\nCjsSchema.decorateMethod(ITr2RenderNode, \"Validate\", impl.abstract);\nCjsSchema.decorateMethod(ITr2RenderNode, \"Execute\", impl.abstract);\nCjsSchema.define(ITr2RenderNode, { className: \"ITr2RenderNode\" });\n\n\n/** Adds the ITr2RenderNode contract without replacing an existing model base. */\nexport function withITr2RenderNode(Base)\n{\n  const RenderNode = class extends Base\n  {\n    Validate(destinationDimensions, outputs, realTime, simTime)\n    {\n      return ITr2RenderNode.prototype.Validate.call(\n        this, destinationDimensions, outputs, realTime, simTime);\n    }\n\n    Execute(destinations, outputs, realTime, simTime, rootTimer, renderContext)\n    {\n      return ITr2RenderNode.prototype.Execute.call(\n        this, destinations, outputs, realTime, simTime, rootTimer, renderContext);\n    }\n  };\n\n  Object.defineProperty(RenderNode.prototype, ITR2_RENDER_NODE, { value: true });\n  CjsSchema.decorateMethod(RenderNode, \"Validate\", impl.abstract);\n  CjsSchema.decorateMethod(RenderNode, \"Execute\", impl.abstract);\n  return RenderNode;\n}\n"],"names":["ITR2_RENDER_NODE","Symbol","for","ITr2RenderNode","hasInstance","value","undefined","Validate","_destinationDimensions","_outputs","_realTime","_simTime","Error","Execute","_destinations","_rootTimer","_renderContext","Object","defineProperty","prototype","CjsSchema","decorateMethod","impl","abstract","define","className","withITr2RenderNode","Base","RenderNode","destinationDimensions","outputs","realTime","simTime","call","destinations","rootTimer","renderContext"],"mappings":";;;AAAA;AAIA,MAAMA,gBAAgB,GAAGC,MAAM,CAACC,GAAG,CAAC,wCAAwC,CAAC;;AAG7E;AACO,MAAMC,cAAc,CAC3B;AACE,EAAA,QAAQF,MAAM,CAACG,WAAW,CAAA,CAAEC,KAAK,EACjC;AACE,IAAA,OAAOA,KAAK,KAAK,IAAI,IAAIA,KAAK,KAAKC,SAAS,IAAID,KAAK,CAACL,gBAAgB,CAAC,KAAK,IAAI;AAClF,EAAA;;AAEA;EACAO,QAAQA,CAACC,sBAAsB,EAAEC,QAAQ,EAAEC,SAAS,EAAEC,QAAQ,EAC9D;AACE,IAAA,MAAM,IAAIC,KAAK,CAAC,+DAA+D,CAAC;AAClF,EAAA;;AAEA;AACAC,EAAAA,OAAOA,CAACC,aAAa,EAAEL,QAAQ,EAAEC,SAAS,EAAEC,QAAQ,EAAEI,UAAU,EAAEC,cAAc,EAChF;AACE,IAAA,MAAM,IAAIJ,KAAK,CAAC,8DAA8D,CAAC;AACjF,EAAA;AACF;AAEAK,MAAM,CAACC,cAAc,CAACf,cAAc,CAACgB,SAAS,EAAEnB,gBAAgB,EAAE;AAAEK,EAAAA,KAAK,EAAE;AAAK,CAAC,CAAC;AAClFe,SAAS,CAACC,cAAc,CAAClB,cAAc,EAAE,UAAU,EAAEmB,IAAI,CAACC,QAAQ,CAAC;AACnEH,SAAS,CAACC,cAAc,CAAClB,cAAc,EAAE,SAAS,EAAEmB,IAAI,CAACC,QAAQ,CAAC;AAClEH,SAAS,CAACI,MAAM,CAACrB,cAAc,EAAE;AAAEsB,EAAAA,SAAS,EAAE;AAAiB,CAAC,CAAC;;AAGjE;AACO,SAASC,kBAAkBA,CAACC,IAAI,EACvC;AACE,EAAA,MAAMC,UAAU,GAAG,cAAcD,IAAI,CACrC;IACEpB,QAAQA,CAACsB,qBAAqB,EAAEC,OAAO,EAAEC,QAAQ,EAAEC,OAAO,EAC1D;AACE,MAAA,OAAO7B,cAAc,CAACgB,SAAS,CAACZ,QAAQ,CAAC0B,IAAI,CAC3C,IAAI,EAAEJ,qBAAqB,EAAEC,OAAO,EAAEC,QAAQ,EAAEC,OAAO,CAAC;AAC5D,IAAA;AAEAnB,IAAAA,OAAOA,CAACqB,YAAY,EAAEJ,OAAO,EAAEC,QAAQ,EAAEC,OAAO,EAAEG,SAAS,EAAEC,aAAa,EAC1E;MACE,OAAOjC,cAAc,CAACgB,SAAS,CAACN,OAAO,CAACoB,IAAI,CAC1C,IAAI,EAAEC,YAAY,EAAEJ,OAAO,EAAEC,QAAQ,EAAEC,OAAO,EAAEG,SAAS,EAAEC,aAAa,CAAC;AAC7E,IAAA;GACD;EAEDnB,MAAM,CAACC,cAAc,CAACU,UAAU,CAACT,SAAS,EAAEnB,gBAAgB,EAAE;AAAEK,IAAAA,KAAK,EAAE;AAAK,GAAC,CAAC;EAC9Ee,SAAS,CAACC,cAAc,CAACO,UAAU,EAAE,UAAU,EAAEN,IAAI,CAACC,QAAQ,CAAC;EAC/DH,SAAS,CAACC,cAAc,CAACO,UAAU,EAAE,SAAS,EAAEN,IAAI,CAACC,QAAQ,CAAC;AAC9D,EAAA,OAAOK,UAAU;AACnB;;;;"}
+{"version":3,"file":"ITr2RenderNode.js","sources":["../../../../src/global/contracts/ITr2RenderNode.js"],"sourcesContent":["// Source: trinity/trinity/ITr2RenderNode.h\nimport { CjsSchema, impl } from \"../schema/index.js\";\n\n\n/** Dependency-free contract for one node in a Trinity render graph. */\nexport class ITr2RenderNode\n{\n\n  /** Validates the node against its requested destinations and named outputs. */\n  Validate(_destinationDimensions, _outputs, _realTime, _simTime)\n  {\n    throw new Error(\"ITr2RenderNode.Validate must be implemented by a render node.\");\n  }\n\n  /** Executes the node into its requested destinations. */\n  Execute(_destinations, _outputs, _realTime, _simTime, _rootTimer, _renderContext)\n  {\n    throw new Error(\"ITr2RenderNode.Execute must be implemented by a render node.\");\n  }\n}\n\nCjsSchema.decorateMethod(ITr2RenderNode, \"Validate\", impl.abstract);\nCjsSchema.decorateMethod(ITr2RenderNode, \"Execute\", impl.abstract);\nCjsSchema.define(ITr2RenderNode, { className: \"ITr2RenderNode\" });\n"],"names":["ITr2RenderNode","Validate","_destinationDimensions","_outputs","_realTime","_simTime","Error","Execute","_destinations","_rootTimer","_renderContext","CjsSchema","decorateMethod","impl","abstract","define","className"],"mappings":";;;AAAA;;AAIA;AACO,MAAMA,cAAc,CAC3B;AAEE;EACAC,QAAQA,CAACC,sBAAsB,EAAEC,QAAQ,EAAEC,SAAS,EAAEC,QAAQ,EAC9D;AACE,IAAA,MAAM,IAAIC,KAAK,CAAC,+DAA+D,CAAC;AAClF,EAAA;;AAEA;AACAC,EAAAA,OAAOA,CAACC,aAAa,EAAEL,QAAQ,EAAEC,SAAS,EAAEC,QAAQ,EAAEI,UAAU,EAAEC,cAAc,EAChF;AACE,IAAA,MAAM,IAAIJ,KAAK,CAAC,8DAA8D,CAAC;AACjF,EAAA;AACF;AAEAK,SAAS,CAACC,cAAc,CAACZ,cAAc,EAAE,UAAU,EAAEa,IAAI,CAACC,QAAQ,CAAC;AACnEH,SAAS,CAACC,cAAc,CAACZ,cAAc,EAAE,SAAS,EAAEa,IAAI,CAACC,QAAQ,CAAC;AAClEH,SAAS,CAACI,MAAM,CAACf,cAAc,EAAE;AAAEgB,EAAAA,SAAS,EAAE;AAAiB,CAAC,CAAC;;;;"}

package/dist/global/contracts/index.js

@@ -1,7 +1,5 @@
 export { CjsBackendCandidate } from './CjsBackendCandidate.js';
 export { CjsConstantPayload } from './CjsConstantPayload.js';
-export { CjsFrameLifecycle } from './CjsFrameLifecycle.js';
-export { CjsInstancedMeshManager } from './CjsInstancedMeshManager.js';
-export { ITr2BoundingBox, withITr2BoundingBox } from './ITr2BoundingBox.js';
-export { ITr2RenderNode, withITr2RenderNode } from './ITr2RenderNode.js';
+export { ITr2BoundingBox } from './ITr2BoundingBox.js';
+export { ITr2RenderNode } from './ITr2RenderNode.js';
 //# sourceMappingURL=index.js.map

package/dist/global/contracts/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/global/index.js

@@ -31,11 +31,28 @@ import * as index$1 from './utils/errors/index.js';
 export { index$1 as errors };
 export { CjsBackendCandidate } from './contracts/CjsBackendCandidate.js';
 export { CjsConstantPayload } from './contracts/CjsConstantPayload.js';
-export { CjsFrameLifecycle } from './contracts/CjsFrameLifecycle.js';
-export { CjsInstancedMeshManager } from './contracts/CjsInstancedMeshManager.js';
-export { ITr2BoundingBox, withITr2BoundingBox } from './contracts/ITr2BoundingBox.js';
-export { ITr2RenderNode, withITr2RenderNode } from './contracts/ITr2RenderNode.js';
+export { ITr2BoundingBox } from './contracts/ITr2BoundingBox.js';
+export { ITr2RenderNode } from './contracts/ITr2RenderNode.js';
 export { CjsScriptCallback } from './blue/CjsScriptCallback.js';
+export { IBlueDynamicResourceConstructor } from './blue/IBlueDynamicResourceConstructor.js';
+export { BeInfo } from './blue/BeInfo.js';
+export { IBlueEvents } from './blue/IBlueEvents.js';
+export { IVariableTicker } from './blue/IVariableTicker.js';
+export { ICatchupTicks } from './blue/ICatchupTicks.js';
+export { ISimTimeRebaseNotify } from './blue/ISimTimeRebaseNotify.js';
+export { IBlueOS } from './blue/IBlueOS.js';
+export { CjsBlueOS } from './blue/CjsBlueOS.js';
+export { CcpDateTime } from './blue/CcpDateTime.js';
+export { TimeAsDateTime, TimeAsDouble, TimeFromDateTime, TimeIsUTC } from './blue/CcpTime.js';
+export { BlueResManQueue, IBlueResMan } from './blue/IBlueResMan.js';
+export { IBlueResManNotifications } from './blue/IBlueResManNotifications.js';
+export { IInitialize } from './blue/IInitialize.js';
+export { IListNotify } from './blue/IListNotify.js';
+export { INotify, IsMatch } from './blue/INotify.js';
+export { CjsBluePaths } from './blue/CjsBluePaths.js';
+export { IBluePaths } from './blue/IBluePaths.js';
+export { blue } from './blue/blue.js';
+export { CjsBlueEnumRegistry, EnumRegistrationType } from './blue/enums/CjsBlueEnumRegistry.js';
 import * as index from './consts/index.js';
 export { index as constants };
 import * as num from './math/num.js';
@@ -86,6 +103,7 @@ import * as tangent from './math/tangent.js';
 export { tangent };
 export { isResFileAddressFor, parseResFileAddress, resFileAddress } from './utils/resFile.js';
 export { AudioChannelLayout, AudioSampleFormat, normalizeAudioSampleFormat } from './consts/audio/audioFormats.js';
+export { BLUEERROR, BLUELISTEVENT } from './consts/blue.js';
 export { CJS_OPERATION_CANCELLED, CjsCancellationError } from './utils/errors/CjsCancellationError.js';
 export { CarbonPixelFormatToWebGpu, DxgiFormatToPixelFormat, GpuTextureFormat, PixelFormatToWebGpu, SrgbSiblingOf, dxgiToPixelFormat, toWebGpuTextureFormat } from './consts/webgpu/textureFormats.js';
 export { CjsError } from './utils/errors/CjsError.js';
@@ -94,7 +112,7 @@ export { D3dPrimitiveTopology } from './consts/d3d/primitiveTopology.js';
 export { DxgiFormat, normalizeDxgiFormat } from './consts/d3d/dxgiFormats.js';
 export { MediaType, PayloadType, normalizeMediaType, normalizePayloadType } from './consts/media/mediaTypes.js';
 export { PixelFormat, getPixelFormatBlockHeight, getPixelFormatBlockWidth, getPixelFormatBytesPerBlock, isCompressedPixelFormat, isSrgbPixelFormat, normalizePixelFormat } from './consts/graphics/pixelFormats.js';
-export { ReflectionMode, RenderingMode, TriBatchType, TriExtrapolation, TriOperator, TriTransformBase } from './consts/graphics/trinityEnums.js';
+export { ReflectionMode, RenderingMode, TRIEXTRAPOLATION, TRIOPERATOR, TRITRANSFORMBASE, TriBatchType, TriStorageFlags } from './consts/graphics/trinityEnums.js';
 export { ShaderModel, ShaderStage, normalizeShaderStage } from './consts/shader/shaderStages.js';
 export { TextureDimension, normalizeTextureDimension } from './consts/graphics/textureDimensions.js';
 export { Tr2Lod } from './consts/trinity.js';

package/dist/global/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/global/model/CjsModel.js

@@ -1,6 +1,8 @@
 import { coerceCarbonMathInto, coerceCarbonTypedArrayInto, normalizeCarbonValue, exportCarbonValue } from '../schema/types/carbonTypes.js';
 import '../schema/index.js';
 import { getRuntimeState } from '../compose/runtimeState.js';
+import { queueModifiedMember, settleModifiedMembers, isExportableField, isWritableField } from '../compose/values.js';
+import { BLUELISTEVENT } from '../consts/blue.js';
 import { CjsModelState } from './CjsModelState.js';
 import { CjsEventEmitter } from './CjsEventEmitter.js';
 import { CjsSchema, CJS_MODEL_BRAND } from '../schema/CjsSchema.js';
@@ -30,13 +32,7 @@ import { CjsSchema, CJS_MODEL_BRAND } from '../schema/CjsSchema.js';
 function isModelInstance(value) {
   return CjsSchema.isModelInstance(value);
 }
-const MAX_UPDATE_PASSES = 32;
 const CHILD_COLLECTION_KINDS = new Set(["array", "list"]);
-const CHILD_LIST_EVENT = {
-  UNLOAD_START: 0x07,
-  INSERTED: 0x08,
-  REMOVED: 0x09
-};
 
 /**
  * Shared base for schema-backed CarbonEngineJS runtime classes.
@@ -163,7 +159,7 @@ class CjsModel extends CjsEventEmitter {
    * Appends an existing object to a schema-backed child collection.
    *
    * The mutation invokes Carbon-shaped `OnListModified` when present,
-   * records the field's declared flag/rebuild consequences, emits one
+   * queues the field's declared member notification, emits one
    * `childadded` event, and settles the parent unless suppressed by options.
    *
    * @param {CjsModel} target Owning model instance.
@@ -182,7 +178,7 @@ class CjsModel extends CjsEventEmitter {
     const index = collection.length;
     collection.push(child);
     recordChildMutation(target, field, options);
-    notifyListModified(target, CHILD_LIST_EVENT.INSERTED, index, 0, child, collection);
+    notifyListModified(target, BLUELISTEVENT.BELIST_INSERTED, index, 0, child, collection);
     const payload = createChildEventPayload(target, field.name, child, index, options);
     invokeChildCallback(options.onAdded, target, payload, "onAdded");
     emitChildEvent(target, "childadded", payload, options);
@@ -210,7 +206,7 @@ class CjsModel extends CjsEventEmitter {
     assertChildCallback(options.onRemoved, "onRemoved");
     collection.splice(index, 1);
     recordChildMutation(target, field, options);
-    notifyListModified(target, CHILD_LIST_EVENT.REMOVED, index, 0, child, collection);
+    notifyListModified(target, BLUELISTEVENT.BELIST_REMOVED, index, 0, child, collection);
     const payload = createChildEventPayload(target, field.name, child, index, options);
     invokeChildCallback(options.onRemoved, target, payload, "onRemoved");
     emitChildEvent(target, "childremoved", payload, options);
@@ -280,7 +276,7 @@ class CjsModel extends CjsEventEmitter {
     if (!count) return false;
     assertChildCallback(options.onCleared, "onCleared");
     recordChildMutation(target, field, options);
-    notifyListModified(target, CHILD_LIST_EVENT.UNLOAD_START, 0, 0, null, collection);
+    notifyListModified(target, BLUELISTEVENT.BELIST_UNLOADSTART, 0, 0, null, collection);
     collection.length = 0;
     const payload = {
       property: field.name,
@@ -304,39 +300,21 @@ class CjsModel extends CjsEventEmitter {
    * `__state.IsDirty()` before calling.
    *
    * @param {object} [options={}]
-   * @param {string|Iterable<string>} [options.property] Fields the caller changed directly; their declared flag/rebuild tokens are added first.
+   * @param {string|Iterable<string>} [options.property] Fields the caller changed directly; queued before settling.
    * @param {string|Iterable<string>} [options.properties] Alias of `property`.
-   * @param {*} [options.source=this] Origin forwarded to the hook and event (binding feedback control).
+   * @param {*} [options.source=this] Origin carried by the completion event (binding feedback control).
    * @param {boolean} [options.skipEvents=false] Prevents the final modified event.
    * @returns {boolean} False when the hook rejected the update (dirty is retained).
    * @throws {Error} If local changes do not settle within the update-pass limit.
    */
   UpdateValues(options = {}) {
     addExplicitUpdateProperties(this, options.property ?? options.properties);
+    if (options.property == null && options.properties == null && options.changedFields == null && (this.__state.updating || !this.__state.pendingModified?.size)) {
+      queueModifiedMember(this, null);
+    }
     if (this.__state.updating) return true;
     const source = options.source ?? this;
-    this.__state.updating = true;
-    try {
-      for (let pass = 0;; pass++) {
-        if (pass >= MAX_UPDATE_PASSES) {
-          throw new Error(`${CjsSchema.getClassName(this.constructor)}.UpdateValues exceeded ${MAX_UPDATE_PASSES} local settle passes.`);
-        }
-        this.__state.dirty = false;
-        if (this.OnModified({
-          ...options,
-          source
-        }) === false) {
-          this.__state.dirty = true;
-          return false;
-        }
-        if (!this.__state.dirty) break;
-      }
-    } catch (err) {
-      this.__state.dirty = true;
-      throw err;
-    } finally {
-      this.__state.updating = false;
-    }
+    if (!settleModifiedMembers(this)) return false;
     if (options.skipEvents !== true && this.__state.suppressEvents === 0) {
       this.EmitEvent("modified", this, {
         source
@@ -349,18 +327,16 @@ class CjsModel extends CjsEventEmitter {
    * The settle hook: reproduces the meaningful consequences of the
    * corresponding Carbon INotify::OnModified implementation.
    *
-   * Invoked only by UpdateValues. Receives the mutation options bag
-   * (source, caller context, skipEvents, ...). There is no changed-property
-   * list - the pipeline is cooperative and cannot guarantee one - so
-   * overrides are written broad-safe: consult own state, compare cached
-   * derivations, and rely on `__state.flags`/`__state.rebuild` tokens for
-   * targeted signals. Returning `false` rejects the update and retains the
-   * dirty mark.
+   * Receives one exposed member name, corresponding to Carbon's member
+   * address. The values transport applies its NOTIFY gate before queuing.
+   * Direct native-shaped callers choose their own gate. A null identity
+   * preserves the existing explicit unnamed UpdateValues call; its wider
+   * UI policy remains separate. No options bag is passed to this hook.
    *
-   * @param {object} [options={}]
+   * @param {string|null} [_propertyName]
    * @returns {boolean} Whether the update may complete.
    */
-  OnModified(options = {}) {
+  OnModified(_propertyName = null) {
     return true;
   }
 
@@ -469,6 +445,7 @@ class CjsModel extends CjsEventEmitter {
    */
   MarkDirty() {
     this.__state.MarkDirty();
+    if (this.__state.updating) queueModifiedMember(this, null);
     return this;
   }
 
@@ -539,6 +516,7 @@ class CjsModel extends CjsEventEmitter {
     }
     if (!hasAdvancedExportOptions(options)) {
       for (const field of getModelFields(value)) {
+        if (!isExportableField(field, options)) continue;
         out[field.name] = exportSourceValue(value[field.name], options);
       }
       return out;
@@ -571,7 +549,7 @@ class CjsModel extends CjsEventEmitter {
     if (!(out instanceof CjsModel)) {
       throw new TypeError("CjsModel.set requires a CjsModel target.");
     }
-    if (!values || typeof values !== "object") return false;
+    if (!CjsSchema.assertValues(values, "CjsModel.set")) return false;
     if (typeof values._type === "string") {
       assertTargetTypeMatches(out, values._type, options);
     }
@@ -590,6 +568,7 @@ class CjsModel extends CjsEventEmitter {
     }
     const enumTranslations = validateEnumInputs(out, values);
     const changed = new Set();
+    let notifyRequested = false;
     for (const field of getModelFields(out)) {
       if (!isWritableModelField(field)) continue;
       const key = findIncomingKey(values, field);
@@ -605,7 +584,7 @@ class CjsModel extends CjsEventEmitter {
           // instance rather than replacing it with an imported object.
           const structChanged = applyIncomingStructInPlace(oldValue, incoming, field, importOptions);
           if (structChanged !== null) {
-            didChange = field.io?.always === true || structChanged;
+            didChange = structChanged;
           } else {
             // Fast path: a math field with an existing compatible typed array
             // is coerced IN PLACE (no allocation, buffer reference preserved).
@@ -614,24 +593,22 @@ class CjsModel extends CjsEventEmitter {
             // big buffers, and they allocated on every write until 2026-09-08.
             const mathChanged = coerceCarbonMathInto(oldValue, incoming, field) ?? coerceCarbonTypedArrayInto(oldValue, incoming, field);
             if (mathChanged !== null) {
-              didChange = field.io?.always === true || mathChanged;
+              didChange = mathChanged;
             } else {
               const newValue = importSourceValue(incoming, field, importOptions);
-              didChange = field.io?.always === true || !areEquivalentSourceValues(oldValue, newValue);
-              if (didChange) out[field.name] = newValue;
+              didChange = !areEquivalentSourceValues(oldValue, newValue);
+              out[field.name] = newValue;
             }
           }
         }
-        if (didChange) {
-          changed.add(field.name);
-          if (options.markDirty !== false) {
+        if (didChange) changed.add(field.name);
+        if (options.markDirty !== false) {
+          if (didChange) out.__state.dirty = true;
+          // BluePyWrap writes first, then tests NOTIFY without equality.
+          if (options.notify !== false && field.edit?.notify) {
+            queueModifiedMember(out, field.name);
             out.__state.dirty = true;
-            // Write-time token adds: the knowledge of WHICH field
-            // changed lives here, so declared consequences land
-            // here (props are not tracked in state).
-            if (options.notify !== false) {
-              addDeclaredFieldTokens(out, field);
-            }
+            notifyRequested = true;
           }
         }
       }
@@ -644,8 +621,12 @@ class CjsModel extends CjsEventEmitter {
       if (options.skipUpdate !== true && options.skipEvents !== true && out.__state.suppressEvents === 0) {
         out.EmitEvent("modified", out, createModifiedPayload(changed, options.source ?? out));
       }
-    } else if (changed.size && options.skipUpdate !== true && !out.__state.updating) {
-      out.UpdateValues(options);
+    } else if ((changed.size || notifyRequested) && options.skipUpdate !== true && !out.__state.updating) {
+      // Members were queued at mutation time, including deferred writes.
+      out.UpdateValues({
+        ...options,
+        changedFields: changed
+      });
     }
     return options.returnBoolean === true ? changed.size > 0 : changed.size ? changed : false;
   }
@@ -714,6 +695,8 @@ class CjsModel extends CjsEventEmitter {
    * @throws {Error} If any owned model explicitly fails initialization.
    */
   static from(values = {}, options = {}) {
+    // null still means "no values": a default instance, as before.
+    if (!CjsSchema.assertValues(values, "CjsModel.from")) values = {};
     if (isReferenceValue(values)) {
       throw new TypeError(`${CjsSchema.getClassName(this) || this.name}.from cannot construct from a { _ref } value; references resolve only inside the owning import operation.`);
     }
@@ -770,7 +753,21 @@ class CjsModel extends CjsEventEmitter {
     if (!value || typeof value.GetValues !== "function") {
       return this.from(value || {}, options);
     }
-    return this.from(value.GetValues(options), options);
+
+    // `refs` IS the clone contract, and a caller cannot turn it off
+    // (operator, 2026-09-17): a totally new version of the target, every
+    // object new, internal references intact. Identity is what delivers
+    // that - without `refs` no `_id` is emitted at all, so a child
+    // referenced twice exports as two full copies and rebuilds as two
+    // separate objects, silently. It was the caller's to pass until now,
+    // and none of the three in `src` passed it.
+    return this.from(value.GetValues({
+      ...options,
+      refs: true
+    }), {
+      ...options,
+      refs: true
+    });
   }
 }
 CjsSchema.define(CjsModel, {
@@ -778,8 +775,9 @@ CjsSchema.define(CjsModel, {
 });
 const carbon = CjsSchema.carbon;
 const impl = CjsSchema.impl;
-const io = CjsSchema.io;
+const edit = CjsSchema.edit;
 const jessica = CjsSchema.jessica;
+const lifecycle = CjsSchema.lifecycle;
 const schema = CjsSchema;
 const type = CjsSchema.type;
 function mergeValueBag(out, value, options = {}) {
@@ -830,9 +828,8 @@ function initializeOwnedGraph(root, options = {}) {
     try {
       if (value.__state instanceof CjsModelState) {
         // Construction: everything is new, so every declared consequence
-        // applies - all flag/rebuild tokens are added, and the object is
+        // applies; the object is
         // marked for one settle.
-        addAllDeclaredTokens(value);
         value.__state.dirty = true;
       }
 
@@ -886,11 +883,7 @@ function schemaFieldToModelField(field) {
   };
 }
 function isWritableModelField(field) {
-  const io = field?.io;
-  if (!io) return true;
-  if (io.write || io.persist || io.persistOnly) return true;
-  if (io.read && !io.write) return false;
-  return true;
+  return isWritableField(field);
 }
 function findIncomingKey(values, field) {
   for (const key of incomingKeyCandidates(field)) {
@@ -939,7 +932,7 @@ function assertChildCallback(callback, optionName) {
 function recordChildMutation(target, field, options) {
   if (options.markDirty === false) return;
   target.__state.dirty = true;
-  if (options.notify !== false) addDeclaredFieldTokens(target, field);
+  if (options.notify !== false && field.edit?.notify) queueModifiedMember(target, field.name);
 }
 function notifyListModified(target, event, index, secondIndex, child, collection) {
   if (typeof target.OnListModified === "function") {
@@ -972,33 +965,18 @@ function settleChildMutation(target, field, options) {
     }
     return;
   }
-  if (!target.__state.updating) target.UpdateValues(options);
-}
-
-// Adds one field's declared @io.flag / @io.rebuild tokens to their stores.
-// Duplicate adds are no-ops (Sets). Nothing in the model layer ever clears
-// these stores - getters clear flags, work methods clear rebuild tokens.
-function addDeclaredFieldTokens(target, field) {
-  const io = field?.io;
-  if (!io) return;
-  if (io.flag) for (const token of io.flag) target.__state.flags.add(token);
-  if (io.rebuild) for (const token of io.rebuild) target.__state.rebuild.add(token);
-}
-
-// Construction / broad invalidation: every declared token applies.
-function addAllDeclaredTokens(target) {
-  const fields = CjsSchema.getSchema(target.constructor)?.fields || [];
-  for (const field of fields) addDeclaredFieldTokens(target, field);
+  if (!target.__state.updating) target.UpdateValues({
+    ...options,
+    changedFields: new Set([field.name])
+  });
 }
 
-// Direct-mutation courtesy: a caller that knows which fields it touched
-// (bindings) passes them so declared consequences stay precise.
+// Direct callers supply their own identities and notification policy.
 function addExplicitUpdateProperties(target, properties) {
   if (properties === null || properties === undefined) return;
   target.__state.dirty = true;
   for (const property of typeof properties === "string" ? [properties] : properties) {
-    const field = CjsSchema.getField(target.constructor, property);
-    if (field) addDeclaredFieldTokens(target, field);
+    queueModifiedMember(target, property);
   }
 }
 function createModifiedPayload(properties, source) {
@@ -1044,6 +1022,14 @@ const ENUM_REVERSE_CACHE = new WeakMap();
 function resolveEnumStaticForField(Constructor, field) {
   const name = field?.enum?.enumType;
   if (!name) return null;
+  if (name.includes(".")) {
+    const info = CjsSchema.getEnum(name);
+    if (!info) throw new ReferenceError(`Enum is not registered: ${name}`);
+    return {
+      name,
+      members: info.type
+    };
+  }
   const members = Constructor?.[name];
   if (!members || typeof members !== "object") return null;
   return {
@@ -1064,6 +1050,7 @@ function enumMemberName(members, value) {
   return reverse.get(value);
 }
 function enumIdentity(Constructor, name) {
+  if (name.includes(".")) return name;
   let current = Constructor;
   while (typeof current === "function") {
     if (Object.hasOwn(current, name)) {
@@ -1124,10 +1111,6 @@ function exportEnumFieldValue(value, spec, Constructor, options) {
   if (options.enumFormat === "names") return memberName;
   return [memberName, enumIdentity(Constructor, spec.name)];
 }
-function isPersistedModelField(field) {
-  const io = field?.io;
-  return !!(io && (io.persist || io.persistOnly));
-}
 function declaredExportClassName(fieldType) {
   if (!fieldType) return null;
   if (typeof fieldType === "string") return fieldType;
@@ -1166,7 +1149,7 @@ function createExportContext(root, options) {
       counts.set(value, count);
       if (count > 1) return;
       for (const field of getModelFields(value)) {
-        if (options.persistOnly && !isPersistedModelField(field)) continue;
+        if (!isExportableField(field, options)) continue;
         walk(value[field.name]);
       }
     })(root);
@@ -1201,7 +1184,7 @@ function exportModelInto(model, out, declaredClassName, options, context) {
   }
   const enumMode = options.enumFormat && options.enumFormat !== "values";
   for (const field of fields) {
-    if (options.persistOnly && !isPersistedModelField(field)) continue;
+    if (!isExportableField(field, options)) continue;
     if (enumMode) {
       const spec = resolveEnumStaticForField(model.constructor, field);
       if (spec) {
@@ -1526,9 +1509,9 @@ function applyIncomingReference(out, field, incoming, options) {
     });
     return true;
   }
-  if (field.io?.always !== true && Object.is(out[fieldName], resolved)) return false;
+  const changed = !Object.is(out[fieldName], resolved);
   out[fieldName] = resolved;
-  return true;
+  return changed;
 }
 function resolveRegisteredModelClass(typeName, options = {}) {
   const Schema = options.registry || CjsModel.schema;
@@ -1590,5 +1573,5 @@ CjsSchema.registerValuesService({
   }
 });
 
-export { CjsModel, CjsSchema, carbon, exportSourceValue, impl, importSourceValue, io, isModelInstance, jessica, schema, type };
+export { CjsModel, CjsSchema, carbon, edit, exportSourceValue, impl, importSourceValue, isModelInstance, jessica, lifecycle, schema, type };
 //# sourceMappingURL=CjsModel.js.map