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

package/dist/global/blue/IBlueOS.js

@@ -0,0 +1,132 @@
+import { CjsSchema, compose, impl } from '#schema';
+
+// Source: blue/include/IBlueOS.h
+//
+// The OS as its consumers see it, reached through its own extern beside
+// `BeResMan` and `BePaths`:
+//
+//     extern BLUEIMPORT IBlueOS* BeOS;      // :226
+//
+// IT IS THE ROOT CLOCK, and that is what this port is for. Of roughly 180
+// `BeOS->` calls in Carbon, 71 are the two time getters and 33 are tick and
+// sim-rebase registration - so more than half of this service is the clock and
+// the pump that drives it. Everything downstream hangs off it:
+//
+//   BeOS pumps -> IBlueEvents::OnTick( realTime, simTime )
+//              -> TriDevice::OnTick advances m_animationTime (TriDevice.cpp:805-823)
+//              -> Tr2Renderer::GetAnimationTime reads it back through gTriDev
+//
+// `TriDevice` registers itself with the cookie "Trinity"
+// (`TriDevice.cpp:148,310,678`), which is why the device tick had no caller
+// here until this existed.
+//
+// TIME IS `Be::Time`: a signed 64-bit count of 100-nanosecond ticks, "Same as
+// Win32 FILETIME" (`blueexposure/include/BlueTypes.h:29`), so the epoch is
+// 1601. TWO BASES, and confusing them is a four-century error:
+//
+// - `OnTick`'s `realTime` and `simTime` are SINCE THE CLIENT STARTED, per the
+//   header's comments on those parameters;
+// - `GetActualTime` and `GetCurrentFrameTime` are absolute Blue UTC.
+//
+// A JavaScript number holds a since-startup tick count exactly for about nine
+// years. It CANNOT hold absolute Blue UTC exactly: 2026 is around 1.33e17
+// ticks against a safe integer limit of 9.01e15, so absolute readings carry
+// roughly 1.6-microsecond granularity rather than 100 nanoseconds. That is a
+// platform fact, it is stated rather than worked around, and it matters to
+// nothing that currently reads these - but it would matter to a caller
+// differencing two absolute readings taken microseconds apart.
+//
+// The error, startup-argument and process-control half of this interface is
+// declared and refused. It is a genuine operating-system service, it has no
+// consumer in this runtime, and guessing at it would be inventing.
+
+/** `IBlueOS` - the clock, the pump, error reporting and process control, per blue/include/IBlueOS.h. */
+class IBlueOS {
+  // ----- Startup and shutdown -----
+
+  /** `Startup` - bring Blue up. */
+  Startup(_pyOptimizeFlag) {}
+
+  /** `Terminate` - end the process; Blue always shuts down by terminating. */
+  Terminate(_retCode) {}
+
+  /** `RegisterIndispensableTerminationStep` - work a DLL must do before a termination signal. */
+  RegisterIndispensableTerminationStep(_callback) {}
+
+  // ----- Scheduling -----
+
+  /** `RegisterForTicks` - drive an IBlueEvents from the pump, with a cookie of the caller's choosing. */
+  RegisterForTicks(_cb, _cookie) {}
+
+  /** `UnregisterForTicks` - stop driving one. */
+  UnregisterForTicks(_cb, _cookie) {}
+
+  /** `RegisterForSimTimeRebase` - be told when the simulation clock is moved. */
+  RegisterForSimTimeRebase(_cb) {}
+
+  /** `UnregisterForSimTimeRebase` - stop being told. */
+  UnregisterForSimTimeRebase(_cb) {}
+
+  // ----- Error reporting -----
+
+  /** `SetError` - report a BLUEERROR or HRESULT, optionally naming the reporter. */
+  SetError(_error, _reporter, _format, ..._args) {}
+
+  /** `GetError` - the error log by index, null once there are no more. */
+  GetError(_index) {}
+
+  /** `FormatError` - the error log formatted as a report. */
+  FormatError() {}
+
+  /** `GetLanguageId` - the language the client is running in. */
+  GetLanguageId() {}
+
+  // ----- Management -----
+
+  /** `PumpOS` - one pump cycle: advance the clocks and tick every registrant. */
+  PumpOS() {}
+
+  // ----- Information -----
+
+  /** `GetInfo` - the BeInfo record: real and simulation time, dilation, fps, pump counters. */
+  GetInfo() {}
+
+  /** `GetActualTime` - the wallclock, adjusted for server sync, in Blue UTC ticks. */
+  GetActualTime() {}
+
+  /** `IsPackaged` - whether the client is running from a package. */
+  IsPackaged() {}
+
+  /** `GetCurrentFrameTime` - the cached smoothed time for this frame, in Blue UTC ticks. */
+  GetCurrentFrameTime() {}
+
+  /** `RunStackless` - whether the stackless scheduler is in use. */
+  RunStackless() {}
+
+  /** `SetStartupArgs` - the command line, after any expansion from an @ file. */
+  SetStartupArgs(_args) {}
+
+  /** `GetStartupArgs` - that expanded command line. */
+  GetStartupArgs() {}
+
+  /** `HasStartupArg` - whether an argument was passed. */
+  HasStartupArg(_arg) {}
+
+  /** `GetInitTab` - the Python init table. */
+  GetInitTab(_tabs) {}
+
+  /** `GetStartupArgValue` - the value of a /arg=value argument. */
+  GetStartupArgValue(_arg) {}
+
+  /** `SetMarkupZonesInPython` - whether profiling zones are marked up in Python. */
+  SetMarkupZonesInPython(_markupZonesInPython) {}
+
+  /** `ConstructPathListFromManifest` - the path list a manifest describes. */
+  ConstructPathListFromManifest(_pathlist, _verifyManifest) {}
+}
+for (const method of ["Startup", "Terminate", "RegisterIndispensableTerminationStep", "RegisterForTicks", "UnregisterForTicks", "RegisterForSimTimeRebase", "UnregisterForSimTimeRebase", "SetError", "GetError", "FormatError", "GetLanguageId", "PumpOS", "GetInfo", "GetActualTime", "IsPackaged", "GetCurrentFrameTime", "RunStackless", "SetStartupArgs", "GetStartupArgs", "HasStartupArg", "GetInitTab", "GetStartupArgValue", "SetMarkupZonesInPython", "ConstructPathListFromManifest"]) {
+  CjsSchema.decorateMethod(IBlueOS, method, compose.abstract, impl.abstract);
+}
+
+export { IBlueOS };
+//# sourceMappingURL=IBlueOS.js.map

package/dist/global/blue/IBlueOS.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IBlueOS.js","sources":["../../../../src/global/blue/IBlueOS.js"],"sourcesContent":["// Source: blue/include/IBlueOS.h\n//\n// The OS as its consumers see it, reached through its own extern beside\n// `BeResMan` and `BePaths`:\n//\n//     extern BLUEIMPORT IBlueOS* BeOS;      // :226\n//\n// IT IS THE ROOT CLOCK, and that is what this port is for. Of roughly 180\n// `BeOS->` calls in Carbon, 71 are the two time getters and 33 are tick and\n// sim-rebase registration - so more than half of this service is the clock and\n// the pump that drives it. Everything downstream hangs off it:\n//\n//   BeOS pumps -> IBlueEvents::OnTick( realTime, simTime )\n//              -> TriDevice::OnTick advances m_animationTime (TriDevice.cpp:805-823)\n//              -> Tr2Renderer::GetAnimationTime reads it back through gTriDev\n//\n// `TriDevice` registers itself with the cookie \"Trinity\"\n// (`TriDevice.cpp:148,310,678`), which is why the device tick had no caller\n// here until this existed.\n//\n// TIME IS `Be::Time`: a signed 64-bit count of 100-nanosecond ticks, \"Same as\n// Win32 FILETIME\" (`blueexposure/include/BlueTypes.h:29`), so the epoch is\n// 1601. TWO BASES, and confusing them is a four-century error:\n//\n// - `OnTick`'s `realTime` and `simTime` are SINCE THE CLIENT STARTED, per the\n//   header's comments on those parameters;\n// - `GetActualTime` and `GetCurrentFrameTime` are absolute Blue UTC.\n//\n// A JavaScript number holds a since-startup tick count exactly for about nine\n// years. It CANNOT hold absolute Blue UTC exactly: 2026 is around 1.33e17\n// ticks against a safe integer limit of 9.01e15, so absolute readings carry\n// roughly 1.6-microsecond granularity rather than 100 nanoseconds. That is a\n// platform fact, it is stated rather than worked around, and it matters to\n// nothing that currently reads these - but it would matter to a caller\n// differencing two absolute readings taken microseconds apart.\n//\n// The error, startup-argument and process-control half of this interface is\n// declared and refused. It is a genuine operating-system service, it has no\n// consumer in this runtime, and guessing at it would be inventing.\nimport { CjsSchema, compose, impl } from \"#schema\";\n\n/** `IBlueOS` - the clock, the pump, error reporting and process control, per blue/include/IBlueOS.h. */\nexport class IBlueOS\n{\n  // ----- Startup and shutdown -----\n\n  /** `Startup` - bring Blue up. */\n  Startup(_pyOptimizeFlag) {}\n\n  /** `Terminate` - end the process; Blue always shuts down by terminating. */\n  Terminate(_retCode) {}\n\n  /** `RegisterIndispensableTerminationStep` - work a DLL must do before a termination signal. */\n  RegisterIndispensableTerminationStep(_callback) {}\n\n  // ----- Scheduling -----\n\n  /** `RegisterForTicks` - drive an IBlueEvents from the pump, with a cookie of the caller's choosing. */\n  RegisterForTicks(_cb, _cookie) {}\n\n  /** `UnregisterForTicks` - stop driving one. */\n  UnregisterForTicks(_cb, _cookie) {}\n\n  /** `RegisterForSimTimeRebase` - be told when the simulation clock is moved. */\n  RegisterForSimTimeRebase(_cb) {}\n\n  /** `UnregisterForSimTimeRebase` - stop being told. */\n  UnregisterForSimTimeRebase(_cb) {}\n\n  // ----- Error reporting -----\n\n  /** `SetError` - report a BLUEERROR or HRESULT, optionally naming the reporter. */\n  SetError(_error, _reporter, _format, ..._args) {}\n\n  /** `GetError` - the error log by index, null once there are no more. */\n  GetError(_index) {}\n\n  /** `FormatError` - the error log formatted as a report. */\n  FormatError() {}\n\n  /** `GetLanguageId` - the language the client is running in. */\n  GetLanguageId() {}\n\n  // ----- Management -----\n\n  /** `PumpOS` - one pump cycle: advance the clocks and tick every registrant. */\n  PumpOS() {}\n\n  // ----- Information -----\n\n  /** `GetInfo` - the BeInfo record: real and simulation time, dilation, fps, pump counters. */\n  GetInfo() {}\n\n  /** `GetActualTime` - the wallclock, adjusted for server sync, in Blue UTC ticks. */\n  GetActualTime() {}\n\n  /** `IsPackaged` - whether the client is running from a package. */\n  IsPackaged() {}\n\n  /** `GetCurrentFrameTime` - the cached smoothed time for this frame, in Blue UTC ticks. */\n  GetCurrentFrameTime() {}\n\n  /** `RunStackless` - whether the stackless scheduler is in use. */\n  RunStackless() {}\n\n  /** `SetStartupArgs` - the command line, after any expansion from an @ file. */\n  SetStartupArgs(_args) {}\n\n  /** `GetStartupArgs` - that expanded command line. */\n  GetStartupArgs() {}\n\n  /** `HasStartupArg` - whether an argument was passed. */\n  HasStartupArg(_arg) {}\n\n  /** `GetInitTab` - the Python init table. */\n  GetInitTab(_tabs) {}\n\n  /** `GetStartupArgValue` - the value of a /arg=value argument. */\n  GetStartupArgValue(_arg) {}\n\n  /** `SetMarkupZonesInPython` - whether profiling zones are marked up in Python. */\n  SetMarkupZonesInPython(_markupZonesInPython) {}\n\n  /** `ConstructPathListFromManifest` - the path list a manifest describes. */\n  ConstructPathListFromManifest(_pathlist, _verifyManifest) {}\n}\n\nfor (const method of [\n  \"Startup\", \"Terminate\", \"RegisterIndispensableTerminationStep\",\n  \"RegisterForTicks\", \"UnregisterForTicks\", \"RegisterForSimTimeRebase\", \"UnregisterForSimTimeRebase\",\n  \"SetError\", \"GetError\", \"FormatError\", \"GetLanguageId\",\n  \"PumpOS\",\n  \"GetInfo\", \"GetActualTime\", \"IsPackaged\", \"GetCurrentFrameTime\", \"RunStackless\",\n  \"SetStartupArgs\", \"GetStartupArgs\", \"HasStartupArg\", \"GetInitTab\", \"GetStartupArgValue\",\n  \"SetMarkupZonesInPython\", \"ConstructPathListFromManifest\"\n])\n{\n  CjsSchema.decorateMethod(IBlueOS, method, compose.abstract, impl.abstract);\n}\n"],"names":["IBlueOS","Startup","_pyOptimizeFlag","Terminate","_retCode","RegisterIndispensableTerminationStep","_callback","RegisterForTicks","_cb","_cookie","UnregisterForTicks","RegisterForSimTimeRebase","UnregisterForSimTimeRebase","SetError","_error","_reporter","_format","_args","GetError","_index","FormatError","GetLanguageId","PumpOS","GetInfo","GetActualTime","IsPackaged","GetCurrentFrameTime","RunStackless","SetStartupArgs","GetStartupArgs","HasStartupArg","_arg","GetInitTab","_tabs","GetStartupArgValue","SetMarkupZonesInPython","_markupZonesInPython","ConstructPathListFromManifest","_pathlist","_verifyManifest","method","CjsSchema","decorateMethod","compose","abstract","impl"],"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;AACA;AACA;AACA;;AAGA;AACO,MAAMA,OAAO,CACpB;AACE;;AAEA;EACAC,OAAOA,CAACC,eAAe,EAAE,CAAC;;AAE1B;EACAC,SAASA,CAACC,QAAQ,EAAE,CAAC;;AAErB;EACAC,oCAAoCA,CAACC,SAAS,EAAE,CAAC;;AAEjD;;AAEA;AACAC,EAAAA,gBAAgBA,CAACC,GAAG,EAAEC,OAAO,EAAE,CAAC;;AAEhC;AACAC,EAAAA,kBAAkBA,CAACF,GAAG,EAAEC,OAAO,EAAE,CAAC;;AAElC;EACAE,wBAAwBA,CAACH,GAAG,EAAE,CAAC;;AAE/B;EACAI,0BAA0BA,CAACJ,GAAG,EAAE,CAAC;;AAEjC;;AAEA;EACAK,QAAQA,CAACC,MAAM,EAAEC,SAAS,EAAEC,OAAO,EAAE,GAAGC,KAAK,EAAE,CAAC;;AAEhD;EACAC,QAAQA,CAACC,MAAM,EAAE,CAAC;;AAElB;EACAC,WAAWA,GAAG,CAAC;;AAEf;EACAC,aAAaA,GAAG,CAAC;;AAEjB;;AAEA;EACAC,MAAMA,GAAG,CAAC;;AAEV;;AAEA;EACAC,OAAOA,GAAG,CAAC;;AAEX;EACAC,aAAaA,GAAG,CAAC;;AAEjB;EACAC,UAAUA,GAAG,CAAC;;AAEd;EACAC,mBAAmBA,GAAG,CAAC;;AAEvB;EACAC,YAAYA,GAAG,CAAC;;AAEhB;EACAC,cAAcA,CAACX,KAAK,EAAE,CAAC;;AAEvB;EACAY,cAAcA,GAAG,CAAC;;AAElB;EACAC,aAAaA,CAACC,IAAI,EAAE,CAAC;;AAErB;EACAC,UAAUA,CAACC,KAAK,EAAE,CAAC;;AAEnB;EACAC,kBAAkBA,CAACH,IAAI,EAAE,CAAC;;AAE1B;EACAI,sBAAsBA,CAACC,oBAAoB,EAAE,CAAC;;AAE9C;AACAC,EAAAA,6BAA6BA,CAACC,SAAS,EAAEC,eAAe,EAAE,CAAC;AAC7D;AAEA,KAAK,MAAMC,MAAM,IAAI,CACnB,SAAS,EAAE,WAAW,EAAE,sCAAsC,EAC9D,kBAAkB,EAAE,oBAAoB,EAAE,0BAA0B,EAAE,4BAA4B,EAClG,UAAU,EAAE,UAAU,EAAE,aAAa,EAAE,eAAe,EACtD,QAAQ,EACR,SAAS,EAAE,eAAe,EAAE,YAAY,EAAE,qBAAqB,EAAE,cAAc,EAC/E,gBAAgB,EAAE,gBAAgB,EAAE,eAAe,EAAE,YAAY,EAAE,oBAAoB,EACvF,wBAAwB,EAAE,+BAA+B,CAC1D,EACD;AACEC,EAAAA,SAAS,CAACC,cAAc,CAAC1C,OAAO,EAAEwC,MAAM,EAAEG,OAAO,CAACC,QAAQ,EAAEC,IAAI,CAACD,QAAQ,CAAC;AAC5E;;;;"}

package/dist/global/blue/IBluePaths.js

@@ -0,0 +1,72 @@
+import { CjsSchema, compose, impl } from '#schema';
+
+// Source: blue/include/IBluePaths.h
+//
+// Paths as its CONSUMERS see it, and a separate service from the resource
+// manager on purpose: Carbon reaches it through its own extern, `BePaths`
+// (`:49`), beside `BeResMan`. "Does this res file exist" is a question about
+// the machine, not about fetching, and keeping the two apart is what stops a
+// caller needing the manager to ask it.
+//
+// The `W` variants collapse, as they do on the manager: they are Carbon's
+// wide-character twins.
+
+/** `IBluePaths` - search paths, resolution, existence and streams, per blue/include/IBluePaths.h. */
+class IBluePaths {
+  /** `InitializeStdAppPaths` - install the standard application search paths. */
+  InitializeStdAppPaths() {}
+
+  /** `SetSearchPath` - bind a search-path key to a location. */
+  SetSearchPath(_key, _value) {}
+
+  /** `GetSearchPath` - the location bound to a search-path key. */
+  GetSearchPath(_key) {}
+
+  /** `ResolvePath` - a res path resolved through the search paths. */
+  ResolvePath(_path) {}
+
+  /** `ResolvePathForWriting` - a res path resolved to where a write may go. */
+  ResolvePathForWriting(_path) {}
+
+  /** `ResolvePathToRoot` - a res path resolved against one named root. */
+  ResolvePathToRoot(_root, _path) {}
+
+  /** `GetExpandedSearchPaths` - every location a search-path key expands to. */
+  GetExpandedSearchPaths(_key) {}
+
+  /** `GetDirectoryContents` - what a directory holds. */
+  GetDirectoryContents(_directory) {}
+
+  /** `IsDirectory` - whether a path is a directory. */
+  IsDirectory(_path) {}
+
+  /** `FileExists` - whether a file is reachable at all, including a black file standing in for a red one. */
+  FileExists(_path) {}
+
+  /** `FileExistsLocally` - whether a file is on the local machine, rather than in a stuff file or a remote cache. */
+  FileExistsLocally(_path) {}
+
+  /** `FileNeedsDownload` - whether reaching a file would require a download. */
+  FileNeedsDownload(_path) {}
+
+  /** `GetStreamFromPath` - a stream over the file at a res path. */
+  GetStreamFromPath(_path) {}
+
+  /** `GetFileContentsWithYield` - the contents of a file, yielding while it is read. */
+  GetFileContentsWithYield(_path) {}
+
+  /** `LogPaths` - write the current search paths to the log. */
+  LogPaths() {}
+}
+for (const method of ["InitializeStdAppPaths", "SetSearchPath", "GetSearchPath", "ResolvePath", "ResolvePathForWriting", "ResolvePathToRoot", "GetExpandedSearchPaths", "GetDirectoryContents", "IsDirectory", "FileExists", "FileExistsLocally", "FileNeedsDownload", "GetStreamFromPath", "GetFileContentsWithYield", "LogPaths"]) {
+  CjsSchema.decorateMethod(IBluePaths, method, compose.abstract, impl.abstract);
+}
+CjsSchema.define(IBluePaths, {
+  className: "IBluePaths",
+  carbon: "IBluePaths",
+  family: "blue",
+  fields: {}
+});
+
+export { IBluePaths };
+//# sourceMappingURL=IBluePaths.js.map

package/dist/global/blue/IBluePaths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IBluePaths.js","sources":["../../../../src/global/blue/IBluePaths.js"],"sourcesContent":["// Source: blue/include/IBluePaths.h\n//\n// Paths as its CONSUMERS see it, and a separate service from the resource\n// manager on purpose: Carbon reaches it through its own extern, `BePaths`\n// (`:49`), beside `BeResMan`. \"Does this res file exist\" is a question about\n// the machine, not about fetching, and keeping the two apart is what stops a\n// caller needing the manager to ask it.\n//\n// The `W` variants collapse, as they do on the manager: they are Carbon's\n// wide-character twins.\nimport { CjsSchema, compose, impl } from \"#schema\";\n\n/** `IBluePaths` - search paths, resolution, existence and streams, per blue/include/IBluePaths.h. */\nexport class IBluePaths\n{\n  /** `InitializeStdAppPaths` - install the standard application search paths. */\n  InitializeStdAppPaths() {}\n\n  /** `SetSearchPath` - bind a search-path key to a location. */\n  SetSearchPath(_key, _value) {}\n\n  /** `GetSearchPath` - the location bound to a search-path key. */\n  GetSearchPath(_key) {}\n\n  /** `ResolvePath` - a res path resolved through the search paths. */\n  ResolvePath(_path) {}\n\n  /** `ResolvePathForWriting` - a res path resolved to where a write may go. */\n  ResolvePathForWriting(_path) {}\n\n  /** `ResolvePathToRoot` - a res path resolved against one named root. */\n  ResolvePathToRoot(_root, _path) {}\n\n  /** `GetExpandedSearchPaths` - every location a search-path key expands to. */\n  GetExpandedSearchPaths(_key) {}\n\n  /** `GetDirectoryContents` - what a directory holds. */\n  GetDirectoryContents(_directory) {}\n\n  /** `IsDirectory` - whether a path is a directory. */\n  IsDirectory(_path) {}\n\n  /** `FileExists` - whether a file is reachable at all, including a black file standing in for a red one. */\n  FileExists(_path) {}\n\n  /** `FileExistsLocally` - whether a file is on the local machine, rather than in a stuff file or a remote cache. */\n  FileExistsLocally(_path) {}\n\n  /** `FileNeedsDownload` - whether reaching a file would require a download. */\n  FileNeedsDownload(_path) {}\n\n  /** `GetStreamFromPath` - a stream over the file at a res path. */\n  GetStreamFromPath(_path) {}\n\n  /** `GetFileContentsWithYield` - the contents of a file, yielding while it is read. */\n  GetFileContentsWithYield(_path) {}\n\n  /** `LogPaths` - write the current search paths to the log. */\n  LogPaths() {}\n}\n\nfor (const method of [\n  \"InitializeStdAppPaths\", \"SetSearchPath\", \"GetSearchPath\", \"ResolvePath\", \"ResolvePathForWriting\",\n  \"ResolvePathToRoot\", \"GetExpandedSearchPaths\", \"GetDirectoryContents\", \"IsDirectory\", \"FileExists\",\n  \"FileExistsLocally\", \"FileNeedsDownload\", \"GetStreamFromPath\", \"GetFileContentsWithYield\", \"LogPaths\"\n])\n{\n  CjsSchema.decorateMethod(IBluePaths, method, compose.abstract, impl.abstract);\n}\n\nCjsSchema.define(IBluePaths, { className: \"IBluePaths\", carbon: \"IBluePaths\", family: \"blue\", fields: {} });\n"],"names":["IBluePaths","InitializeStdAppPaths","SetSearchPath","_key","_value","GetSearchPath","ResolvePath","_path","ResolvePathForWriting","ResolvePathToRoot","_root","GetExpandedSearchPaths","GetDirectoryContents","_directory","IsDirectory","FileExists","FileExistsLocally","FileNeedsDownload","GetStreamFromPath","GetFileContentsWithYield","LogPaths","method","CjsSchema","decorateMethod","compose","abstract","impl","define","className","carbon","family","fields"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGA;AACO,MAAMA,UAAU,CACvB;AACE;EACAC,qBAAqBA,GAAG,CAAC;;AAEzB;AACAC,EAAAA,aAAaA,CAACC,IAAI,EAAEC,MAAM,EAAE,CAAC;;AAE7B;EACAC,aAAaA,CAACF,IAAI,EAAE,CAAC;;AAErB;EACAG,WAAWA,CAACC,KAAK,EAAE,CAAC;;AAEpB;EACAC,qBAAqBA,CAACD,KAAK,EAAE,CAAC;;AAE9B;AACAE,EAAAA,iBAAiBA,CAACC,KAAK,EAAEH,KAAK,EAAE,CAAC;;AAEjC;EACAI,sBAAsBA,CAACR,IAAI,EAAE,CAAC;;AAE9B;EACAS,oBAAoBA,CAACC,UAAU,EAAE,CAAC;;AAElC;EACAC,WAAWA,CAACP,KAAK,EAAE,CAAC;;AAEpB;EACAQ,UAAUA,CAACR,KAAK,EAAE,CAAC;;AAEnB;EACAS,iBAAiBA,CAACT,KAAK,EAAE,CAAC;;AAE1B;EACAU,iBAAiBA,CAACV,KAAK,EAAE,CAAC;;AAE1B;EACAW,iBAAiBA,CAACX,KAAK,EAAE,CAAC;;AAE1B;EACAY,wBAAwBA,CAACZ,KAAK,EAAE,CAAC;;AAEjC;EACAa,QAAQA,GAAG,CAAC;AACd;AAEA,KAAK,MAAMC,MAAM,IAAI,CACnB,uBAAuB,EAAE,eAAe,EAAE,eAAe,EAAE,aAAa,EAAE,uBAAuB,EACjG,mBAAmB,EAAE,wBAAwB,EAAE,sBAAsB,EAAE,aAAa,EAAE,YAAY,EAClG,mBAAmB,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,0BAA0B,EAAE,UAAU,CACtG,EACD;AACEC,EAAAA,SAAS,CAACC,cAAc,CAACvB,UAAU,EAAEqB,MAAM,EAAEG,OAAO,CAACC,QAAQ,EAAEC,IAAI,CAACD,QAAQ,CAAC;AAC/E;AAEAH,SAAS,CAACK,MAAM,CAAC3B,UAAU,EAAE;AAAE4B,EAAAA,SAAS,EAAE,YAAY;AAAEC,EAAAA,MAAM,EAAE,YAAY;AAAEC,EAAAA,MAAM,EAAE,MAAM;AAAEC,EAAAA,MAAM,EAAE;AAAG,CAAC,CAAC;;;;"}

package/dist/global/blue/IBlueResMan.js

@@ -0,0 +1,93 @@
+import { CjsSchema, compose, impl } from '#schema';
+
+// Source: blue/include/IBlueResMan.h
+//
+// The resource manager as its CONSUMERS see it. Carbon publishes this
+// interface and the extern `BeResMan` that points at one (`:135`); the
+// implementation, `BlueResMan`, is never visible outside blue. Trinity takes
+// this one header through `StdAfx.h:54` and calls it at 94 sites.
+//
+// That split is the point. `CjsResMan` has 68 public methods - configuration,
+// queue driving, diagnostics and internals alongside the verbs a caller
+// actually uses - and publishing all of it to everybody is why nothing can
+// tell which methods are the interface. Eighteen are.
+//
+// The `W` variants collapse: they are Carbon's wide-character twins, and
+// JavaScript strings carry no such distinction.
+
+/** `BlueResManQueue` - the queues the manager runs work on. */
+const BlueResManQueue = Object.freeze({
+  BRMQ_MAIN: 0,
+  BRMQ_BACKGROUND: 1,
+  BRMQ_COUNT: 2
+});
+
+/** `IBlueResMan` - the resource manager a consumer sees, per blue/include/IBlueResMan.h. */
+class IBlueResMan {
+  /** `GetResource` - the resource at this path, created or taken from the cache. */
+  GetResource(_path, _options) {}
+
+  /** `LoadObject` - an object built from a blue or red file, chosen by extension. */
+  LoadObject(_path, _init) {}
+
+  /** `SaveObject` - write an object to a blue or red file, chosen by extension. */
+  SaveObject(_object, _path) {}
+
+  /** `IsOnMainThread` - whether the caller shares the main-thread queue's thread. */
+  IsOnMainThread() {}
+
+  /** `AddToQueue` - queue a callback on one of the manager's queues. */
+  AddToQueue(_queue, _callback, _context, _flags, _id) {}
+
+  /** `CancelFromQueue` - cancel a previously queued callback. */
+  CancelFromQueue(_queue, _id) {}
+
+  /** `GetNextIdForQueue` - the id a queue would issue next, so a caller can tell whether anything was added. */
+  GetNextIdForQueue(_queue) {}
+
+  /** `PumpMainThreadQueue` - run one main-thread item; false when the queue was empty. */
+  PumpMainThreadQueue() {}
+
+  /** `PauseQueue` - stop a queue running work. */
+  PauseQueue(_queue) {}
+
+  /** `ResumeQueue` - let a paused queue run again. */
+  ResumeQueue(_queue) {}
+
+  /** `SetUrgentResourceLoads` - mark subsequent loads urgent. */
+  SetUrgentResourceLoads(_urgent) {}
+
+  /** `IsUrgentResourceLoads` - whether loads are currently marked urgent. */
+  IsUrgentResourceLoads() {}
+
+  /** `ReserveBackgroundLoadMemory` - claim background-load memory, blocking while over budget. */
+  ReserveBackgroundLoadMemory(_size) {}
+
+  /** `ReleaseBackgroundLoadMemory` - return claimed background-load memory. */
+  ReleaseBackgroundLoadMemory(_size) {}
+
+  /** `GetPendingLoads` - how many loads have not finished. */
+  GetPendingLoads() {}
+
+  /** `GetPendingPrepares` - how many prepares have not finished. */
+  GetPendingPrepares() {}
+
+  /** `RegisterResourceConstructor` - bind a `dynamic:/<name>` factory, as the gradient and colour textures do for themselves. */
+  RegisterResourceConstructor(_name, _constructor) {}
+
+  /** `UnregisterResourceConstructor` - remove a `dynamic:/<name>` factory. */
+  UnregisterResourceConstructor(_name) {}
+  static Queue = BlueResManQueue;
+}
+for (const method of ["GetResource", "LoadObject", "SaveObject", "IsOnMainThread", "AddToQueue", "CancelFromQueue", "GetNextIdForQueue", "PumpMainThreadQueue", "PauseQueue", "ResumeQueue", "SetUrgentResourceLoads", "IsUrgentResourceLoads", "ReserveBackgroundLoadMemory", "ReleaseBackgroundLoadMemory", "GetPendingLoads", "GetPendingPrepares", "RegisterResourceConstructor", "UnregisterResourceConstructor"]) {
+  CjsSchema.decorateMethod(IBlueResMan, method, compose.abstract, impl.abstract);
+}
+CjsSchema.define(IBlueResMan, {
+  className: "IBlueResMan",
+  carbon: "IBlueResMan",
+  family: "blue",
+  fields: {}
+});
+
+export { BlueResManQueue, IBlueResMan };
+//# sourceMappingURL=IBlueResMan.js.map

package/dist/global/blue/IBlueResMan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IBlueResMan.js","sources":["../../../../src/global/blue/IBlueResMan.js"],"sourcesContent":["// Source: blue/include/IBlueResMan.h\n//\n// The resource manager as its CONSUMERS see it. Carbon publishes this\n// interface and the extern `BeResMan` that points at one (`:135`); the\n// implementation, `BlueResMan`, is never visible outside blue. Trinity takes\n// this one header through `StdAfx.h:54` and calls it at 94 sites.\n//\n// That split is the point. `CjsResMan` has 68 public methods - configuration,\n// queue driving, diagnostics and internals alongside the verbs a caller\n// actually uses - and publishing all of it to everybody is why nothing can\n// tell which methods are the interface. Eighteen are.\n//\n// The `W` variants collapse: they are Carbon's wide-character twins, and\n// JavaScript strings carry no such distinction.\nimport { CjsSchema, compose, impl } from \"#schema\";\n\n/** `BlueResManQueue` - the queues the manager runs work on. */\nexport const BlueResManQueue = Object.freeze({\n  BRMQ_MAIN: 0,\n  BRMQ_BACKGROUND: 1,\n  BRMQ_COUNT: 2\n});\n\n/** `IBlueResMan` - the resource manager a consumer sees, per blue/include/IBlueResMan.h. */\nexport class IBlueResMan\n{\n  /** `GetResource` - the resource at this path, created or taken from the cache. */\n  GetResource(_path, _options) {}\n\n  /** `LoadObject` - an object built from a blue or red file, chosen by extension. */\n  LoadObject(_path, _init) {}\n\n  /** `SaveObject` - write an object to a blue or red file, chosen by extension. */\n  SaveObject(_object, _path) {}\n\n  /** `IsOnMainThread` - whether the caller shares the main-thread queue's thread. */\n  IsOnMainThread() {}\n\n  /** `AddToQueue` - queue a callback on one of the manager's queues. */\n  AddToQueue(_queue, _callback, _context, _flags, _id) {}\n\n  /** `CancelFromQueue` - cancel a previously queued callback. */\n  CancelFromQueue(_queue, _id) {}\n\n  /** `GetNextIdForQueue` - the id a queue would issue next, so a caller can tell whether anything was added. */\n  GetNextIdForQueue(_queue) {}\n\n  /** `PumpMainThreadQueue` - run one main-thread item; false when the queue was empty. */\n  PumpMainThreadQueue() {}\n\n  /** `PauseQueue` - stop a queue running work. */\n  PauseQueue(_queue) {}\n\n  /** `ResumeQueue` - let a paused queue run again. */\n  ResumeQueue(_queue) {}\n\n  /** `SetUrgentResourceLoads` - mark subsequent loads urgent. */\n  SetUrgentResourceLoads(_urgent) {}\n\n  /** `IsUrgentResourceLoads` - whether loads are currently marked urgent. */\n  IsUrgentResourceLoads() {}\n\n  /** `ReserveBackgroundLoadMemory` - claim background-load memory, blocking while over budget. */\n  ReserveBackgroundLoadMemory(_size) {}\n\n  /** `ReleaseBackgroundLoadMemory` - return claimed background-load memory. */\n  ReleaseBackgroundLoadMemory(_size) {}\n\n  /** `GetPendingLoads` - how many loads have not finished. */\n  GetPendingLoads() {}\n\n  /** `GetPendingPrepares` - how many prepares have not finished. */\n  GetPendingPrepares() {}\n\n  /** `RegisterResourceConstructor` - bind a `dynamic:/<name>` factory, as the gradient and colour textures do for themselves. */\n  RegisterResourceConstructor(_name, _constructor) {}\n\n  /** `UnregisterResourceConstructor` - remove a `dynamic:/<name>` factory. */\n  UnregisterResourceConstructor(_name) {}\n\n  static Queue = BlueResManQueue;\n}\n\nfor (const method of [\n  \"GetResource\", \"LoadObject\", \"SaveObject\", \"IsOnMainThread\", \"AddToQueue\", \"CancelFromQueue\",\n  \"GetNextIdForQueue\", \"PumpMainThreadQueue\", \"PauseQueue\", \"ResumeQueue\", \"SetUrgentResourceLoads\",\n  \"IsUrgentResourceLoads\", \"ReserveBackgroundLoadMemory\", \"ReleaseBackgroundLoadMemory\",\n  \"GetPendingLoads\", \"GetPendingPrepares\", \"RegisterResourceConstructor\", \"UnregisterResourceConstructor\"\n])\n{\n  CjsSchema.decorateMethod(IBlueResMan, method, compose.abstract, impl.abstract);\n}\n\nCjsSchema.define(IBlueResMan, { className: \"IBlueResMan\", carbon: \"IBlueResMan\", family: \"blue\", fields: {} });\n"],"names":["BlueResManQueue","Object","freeze","BRMQ_MAIN","BRMQ_BACKGROUND","BRMQ_COUNT","IBlueResMan","GetResource","_path","_options","LoadObject","_init","SaveObject","_object","IsOnMainThread","AddToQueue","_queue","_callback","_context","_flags","_id","CancelFromQueue","GetNextIdForQueue","PumpMainThreadQueue","PauseQueue","ResumeQueue","SetUrgentResourceLoads","_urgent","IsUrgentResourceLoads","ReserveBackgroundLoadMemory","_size","ReleaseBackgroundLoadMemory","GetPendingLoads","GetPendingPrepares","RegisterResourceConstructor","_name","_constructor","UnregisterResourceConstructor","Queue","method","CjsSchema","decorateMethod","compose","abstract","impl","define","className","carbon","family","fields"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGA;MACaA,eAAe,GAAGC,MAAM,CAACC,MAAM,CAAC;AAC3CC,EAAAA,SAAS,EAAE,CAAC;AACZC,EAAAA,eAAe,EAAE,CAAC;AAClBC,EAAAA,UAAU,EAAE;AACd,CAAC;;AAED;AACO,MAAMC,WAAW,CACxB;AACE;AACAC,EAAAA,WAAWA,CAACC,KAAK,EAAEC,QAAQ,EAAE,CAAC;;AAE9B;AACAC,EAAAA,UAAUA,CAACF,KAAK,EAAEG,KAAK,EAAE,CAAC;;AAE1B;AACAC,EAAAA,UAAUA,CAACC,OAAO,EAAEL,KAAK,EAAE,CAAC;;AAE5B;EACAM,cAAcA,GAAG,CAAC;;AAElB;EACAC,UAAUA,CAACC,MAAM,EAAEC,SAAS,EAAEC,QAAQ,EAAEC,MAAM,EAAEC,GAAG,EAAE,CAAC;;AAEtD;AACAC,EAAAA,eAAeA,CAACL,MAAM,EAAEI,GAAG,EAAE,CAAC;;AAE9B;EACAE,iBAAiBA,CAACN,MAAM,EAAE,CAAC;;AAE3B;EACAO,mBAAmBA,GAAG,CAAC;;AAEvB;EACAC,UAAUA,CAACR,MAAM,EAAE,CAAC;;AAEpB;EACAS,WAAWA,CAACT,MAAM,EAAE,CAAC;;AAErB;EACAU,sBAAsBA,CAACC,OAAO,EAAE,CAAC;;AAEjC;EACAC,qBAAqBA,GAAG,CAAC;;AAEzB;EACAC,2BAA2BA,CAACC,KAAK,EAAE,CAAC;;AAEpC;EACAC,2BAA2BA,CAACD,KAAK,EAAE,CAAC;;AAEpC;EACAE,eAAeA,GAAG,CAAC;;AAEnB;EACAC,kBAAkBA,GAAG,CAAC;;AAEtB;AACAC,EAAAA,2BAA2BA,CAACC,KAAK,EAAEC,YAAY,EAAE,CAAC;;AAElD;EACAC,6BAA6BA,CAACF,KAAK,EAAE,CAAC;EAEtC,OAAOG,KAAK,GAAGtC,eAAe;AAChC;AAEA,KAAK,MAAMuC,MAAM,IAAI,CACnB,aAAa,EAAE,YAAY,EAAE,YAAY,EAAE,gBAAgB,EAAE,YAAY,EAAE,iBAAiB,EAC5F,mBAAmB,EAAE,qBAAqB,EAAE,YAAY,EAAE,aAAa,EAAE,wBAAwB,EACjG,uBAAuB,EAAE,6BAA6B,EAAE,6BAA6B,EACrF,iBAAiB,EAAE,oBAAoB,EAAE,6BAA6B,EAAE,+BAA+B,CACxG,EACD;AACEC,EAAAA,SAAS,CAACC,cAAc,CAACnC,WAAW,EAAEiC,MAAM,EAAEG,OAAO,CAACC,QAAQ,EAAEC,IAAI,CAACD,QAAQ,CAAC;AAChF;AAEAH,SAAS,CAACK,MAAM,CAACvC,WAAW,EAAE;AAAEwC,EAAAA,SAAS,EAAE,aAAa;AAAEC,EAAAA,MAAM,EAAE,aAAa;AAAEC,EAAAA,MAAM,EAAE,MAAM;AAAEC,EAAAA,MAAM,EAAE;AAAG,CAAC,CAAC;;;;"}

package/dist/global/blue/IBlueResManNotifications.js

@@ -0,0 +1,51 @@
+import { CjsSchema, impl } from '#schema';
+
+// Source: blue/include/IBlueResMan.h:20-34
+//
+// Optional callbacks a caller may pass to GetResource to learn which of the two
+// things happened. Carbon's comment states the rule: "All callbacks are
+// guaranteed to be made during the (blocking) call to GetResource on the main
+// thread, so temporary lifetime objects that implement the callbacks are
+// valid."
+//
+// Both have empty bodies in Carbon rather than being pure virtual, so an
+// implementer overrides only the half it cares about. So they are marked
+// `impl.noop` at the foot of this file and never `impl.abstract`: doing
+// nothing IS the declared default, and a caller who supplied the object still
+// gets the other callback.
+
+/** `IBlueResManNotifications` - optional per-call notice of how GetResource answered. */
+class IBlueResManNotifications {
+  /**
+   * `OnResourceCreated` - the resource was not cached and has just been made.
+   *
+   * Carbon is precise about when: the instance exists but has NOT yet been
+   * Initialize()'d.
+   */
+  OnResourceCreated(_resource) {}
+
+  /** `OnResourceFromCache` - the resource was already in the cache. */
+  OnResourceFromCache(_resource) {}
+}
+CjsSchema.define(IBlueResManNotifications, {
+  className: "IBlueResManNotifications",
+  carbon: "IBlueResManNotifications",
+  family: "blue",
+  fields: {}
+});
+
+// BOTH CALLBACKS ARE EMPTY IN THE DONOR, NOT PURE VIRTUAL:
+//
+//     virtual void OnResourceCreated( void* ) {}
+//     virtual void OnResourceFromCache( void* ) {}
+//                                      // IBlueResMan.h:28,31
+//
+// So an implementer overrides only the half it cares about, and neither is a
+// divergence when left alone. That is `impl.noop`, not `impl.abstract`, and
+// declaring it is what stops `@carbon.inherit` falling back to abstract and
+// writing "Carbon leaves this unimplemented" onto every consumer.
+CjsSchema.decorateMethod(IBlueResManNotifications, "OnResourceCreated", impl.noop);
+CjsSchema.decorateMethod(IBlueResManNotifications, "OnResourceFromCache", impl.noop);
+
+export { IBlueResManNotifications };
+//# sourceMappingURL=IBlueResManNotifications.js.map

package/dist/global/blue/IBlueResManNotifications.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IBlueResManNotifications.js","sources":["../../../../src/global/blue/IBlueResManNotifications.js"],"sourcesContent":["// Source: blue/include/IBlueResMan.h:20-34\n//\n// Optional callbacks a caller may pass to GetResource to learn which of the two\n// things happened. Carbon's comment states the rule: \"All callbacks are\n// guaranteed to be made during the (blocking) call to GetResource on the main\n// thread, so temporary lifetime objects that implement the callbacks are\n// valid.\"\n//\n// Both have empty bodies in Carbon rather than being pure virtual, so an\n// implementer overrides only the half it cares about. So they are marked\n// `impl.noop` at the foot of this file and never `impl.abstract`: doing\n// nothing IS the declared default, and a caller who supplied the object still\n// gets the other callback.\nimport { CjsSchema, impl } from \"#schema\";\n\n/** `IBlueResManNotifications` - optional per-call notice of how GetResource answered. */\nexport class IBlueResManNotifications\n{\n  /**\n   * `OnResourceCreated` - the resource was not cached and has just been made.\n   *\n   * Carbon is precise about when: the instance exists but has NOT yet been\n   * Initialize()'d.\n   */\n  OnResourceCreated(_resource) {}\n\n  /** `OnResourceFromCache` - the resource was already in the cache. */\n  OnResourceFromCache(_resource) {}\n}\n\nCjsSchema.define(IBlueResManNotifications, {\n  className: \"IBlueResManNotifications\", carbon: \"IBlueResManNotifications\", family: \"blue\", fields: {}\n});\n\n// BOTH CALLBACKS ARE EMPTY IN THE DONOR, NOT PURE VIRTUAL:\n//\n//     virtual void OnResourceCreated( void* ) {}\n//     virtual void OnResourceFromCache( void* ) {}\n//                                      // IBlueResMan.h:28,31\n//\n// So an implementer overrides only the half it cares about, and neither is a\n// divergence when left alone. That is `impl.noop`, not `impl.abstract`, and\n// declaring it is what stops `@carbon.inherit` falling back to abstract and\n// writing \"Carbon leaves this unimplemented\" onto every consumer.\nCjsSchema.decorateMethod(IBlueResManNotifications, \"OnResourceCreated\", impl.noop);\nCjsSchema.decorateMethod(IBlueResManNotifications, \"OnResourceFromCache\", impl.noop);\n"],"names":["IBlueResManNotifications","OnResourceCreated","_resource","OnResourceFromCache","CjsSchema","define","className","carbon","family","fields","decorateMethod","impl","noop"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGA;AACO,MAAMA,wBAAwB,CACrC;AACE;AACF;AACA;AACA;AACA;AACA;EACEC,iBAAiBA,CAACC,SAAS,EAAE,CAAC;;AAE9B;EACAC,mBAAmBA,CAACD,SAAS,EAAE,CAAC;AAClC;AAEAE,SAAS,CAACC,MAAM,CAACL,wBAAwB,EAAE;AACzCM,EAAAA,SAAS,EAAE,0BAA0B;AAAEC,EAAAA,MAAM,EAAE,0BAA0B;AAAEC,EAAAA,MAAM,EAAE,MAAM;AAAEC,EAAAA,MAAM,EAAE;AACrG,CAAC,CAAC;;AAEF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAL,SAAS,CAACM,cAAc,CAACV,wBAAwB,EAAE,mBAAmB,EAAEW,IAAI,CAACC,IAAI,CAAC;AAClFR,SAAS,CAACM,cAAc,CAACV,wBAAwB,EAAE,qBAAqB,EAAEW,IAAI,CAACC,IAAI,CAAC;;;;"}

package/dist/global/blue/ICatchupTicks.js

@@ -0,0 +1,25 @@
+import { CjsSchema, compose, impl } from '#schema';
+import { IVariableTicker } from './IVariableTicker.js';
+
+// Source: blue/include/IBlueOS.h:255-265
+//
+//     struct ICatchupTicks : public IVariableTicker
+//
+// A variable-rate ticker that also wants to know when the frame is over.
+// Carbon's comment says the inheritance exists "to make CatchupTicks
+// compatible with the new ticking code", so the base is the newer of the two.
+
+/** `ICatchupTicks` - a variable-rate ticker told when the frame ends, per blue/include/IBlueOS.h:256. */
+class ICatchupTicks extends IVariableTicker {
+  /**
+   * `OnPostFrameTick` - every tick for this system in this frame has completed.
+   *
+   * @param {number} _timestamp Time since the client started, in 100ns ticks.
+   * @param {*} _cookie Whatever the registrant passed when it registered.
+   */
+  OnPostFrameTick(_timestamp, _cookie) {}
+}
+CjsSchema.decorateMethod(ICatchupTicks, "OnPostFrameTick", compose.abstract, impl.abstract);
+
+export { ICatchupTicks };
+//# sourceMappingURL=ICatchupTicks.js.map

package/dist/global/blue/ICatchupTicks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ICatchupTicks.js","sources":["../../../../src/global/blue/ICatchupTicks.js"],"sourcesContent":["// Source: blue/include/IBlueOS.h:255-265\n//\n//     struct ICatchupTicks : public IVariableTicker\n//\n// A variable-rate ticker that also wants to know when the frame is over.\n// Carbon's comment says the inheritance exists \"to make CatchupTicks\n// compatible with the new ticking code\", so the base is the newer of the two.\nimport { CjsSchema, compose, impl } from \"#schema\";\nimport { IVariableTicker } from \"./IVariableTicker.js\";\n\n/** `ICatchupTicks` - a variable-rate ticker told when the frame ends, per blue/include/IBlueOS.h:256. */\nexport class ICatchupTicks extends IVariableTicker\n{\n  /**\n   * `OnPostFrameTick` - every tick for this system in this frame has completed.\n   *\n   * @param {number} _timestamp Time since the client started, in 100ns ticks.\n   * @param {*} _cookie Whatever the registrant passed when it registered.\n   */\n  OnPostFrameTick(_timestamp, _cookie) {}\n}\n\nCjsSchema.decorateMethod(ICatchupTicks, \"OnPostFrameTick\", compose.abstract, impl.abstract);\n"],"names":["ICatchupTicks","IVariableTicker","OnPostFrameTick","_timestamp","_cookie","CjsSchema","decorateMethod","compose","abstract","impl"],"mappings":";;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;;AAIA;AACO,MAAMA,aAAa,SAASC,eAAe,CAClD;AACE;AACF;AACA;AACA;AACA;AACA;AACEC,EAAAA,eAAeA,CAACC,UAAU,EAAEC,OAAO,EAAE,CAAC;AACxC;AAEAC,SAAS,CAACC,cAAc,CAACN,aAAa,EAAE,iBAAiB,EAAEO,OAAO,CAACC,QAAQ,EAAEC,IAAI,CAACD,QAAQ,CAAC;;;;"}

package/dist/global/blue/IInitialize.js

@@ -0,0 +1,47 @@
+import { CjsSchema, compose, impl } from '#schema';
+
+// Source: blueexposure/include/IInitialize.h:12-15
+//
+// One pure method. The interface is three lines; the whole contract is in who
+// calls it and when.
+//
+// A READER CALLS THIS INSTEAD OF INotify, NEVER BOTH. Every reader casts for
+// each and, finding this one, drops the notify pointer - DictReader.cpp:163-168
+// says it outright: "If IInitialize is provided, don't do individual
+// notifications." So a class implementing this is asking to be told ONCE, after
+// every member has been written, rather than once per member as it is written.
+// That is the entire reason it exists.
+//
+// The call comes after ReadMembers returns (DictReader.cpp:82-91,
+// BlackReader.cpp:395-401, and the same shape in YamlReader), and only when the
+// reader's own m_doInitialize flag is set - a reader can be configured to skip
+// it and leave the object uninitialised.
+//
+// THE RETURN VALUE HAS TWO AUDIENCES. The readers discard it. The paths that
+// build or duplicate an object honour it: BlueClasses_Blue.cpp:57 fails
+// construction on false, and Copier.cpp:209 returns it as the copy's own
+// result. Subclasses chain - `return EveChildMesh::Initialize();` is the
+// donor's own idiom (EveChildTurret.cpp:59).
+
+
+/** `IInitialize` - everything has been written; link it up. */
+class IInitialize {
+  /**
+   * `Initialize` - called once after a read fills every member, in place of
+   * per-member notification.
+   *
+   * @returns {boolean} False when initialization failed. Readers ignore this;
+   * object construction and copying do not.
+   */
+  Initialize() {}
+}
+CjsSchema.decorateMethod(IInitialize, "Initialize", compose.abstract, impl.abstract);
+CjsSchema.define(IInitialize, {
+  className: "IInitialize",
+  carbon: "IInitialize",
+  family: "blue",
+  fields: {}
+});
+
+export { IInitialize };
+//# sourceMappingURL=IInitialize.js.map

package/dist/global/blue/IInitialize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IInitialize.js","sources":["../../../../src/global/blue/IInitialize.js"],"sourcesContent":["// Source: blueexposure/include/IInitialize.h:12-15\n//\n// One pure method. The interface is three lines; the whole contract is in who\n// calls it and when.\n//\n// A READER CALLS THIS INSTEAD OF INotify, NEVER BOTH. Every reader casts for\n// each and, finding this one, drops the notify pointer - DictReader.cpp:163-168\n// says it outright: \"If IInitialize is provided, don't do individual\n// notifications.\" So a class implementing this is asking to be told ONCE, after\n// every member has been written, rather than once per member as it is written.\n// That is the entire reason it exists.\n//\n// The call comes after ReadMembers returns (DictReader.cpp:82-91,\n// BlackReader.cpp:395-401, and the same shape in YamlReader), and only when the\n// reader's own m_doInitialize flag is set - a reader can be configured to skip\n// it and leave the object uninitialised.\n//\n// THE RETURN VALUE HAS TWO AUDIENCES. The readers discard it. The paths that\n// build or duplicate an object honour it: BlueClasses_Blue.cpp:57 fails\n// construction on false, and Copier.cpp:209 returns it as the copy's own\n// result. Subclasses chain - `return EveChildMesh::Initialize();` is the\n// donor's own idiom (EveChildTurret.cpp:59).\n\nimport { CjsSchema, compose, impl } from \"#schema\";\n\n/** `IInitialize` - everything has been written; link it up. */\nexport class IInitialize\n{\n  /**\n   * `Initialize` - called once after a read fills every member, in place of\n   * per-member notification.\n   *\n   * @returns {boolean} False when initialization failed. Readers ignore this;\n   * object construction and copying do not.\n   */\n  Initialize() {}\n}\n\nCjsSchema.decorateMethod(IInitialize, \"Initialize\", compose.abstract, impl.abstract);\n\nCjsSchema.define(IInitialize, {\n  className: \"IInitialize\", carbon: \"IInitialize\", family: \"blue\", fields: {}\n});\n"],"names":["IInitialize","Initialize","CjsSchema","decorateMethod","compose","abstract","impl","define","className","carbon","family","fields"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAIA;AACO,MAAMA,WAAW,CACxB;AACE;AACF;AACA;AACA;AACA;AACA;AACA;EACEC,UAAUA,GAAG,CAAC;AAChB;AAEAC,SAAS,CAACC,cAAc,CAACH,WAAW,EAAE,YAAY,EAAEI,OAAO,CAACC,QAAQ,EAAEC,IAAI,CAACD,QAAQ,CAAC;AAEpFH,SAAS,CAACK,MAAM,CAACP,WAAW,EAAE;AAC5BQ,EAAAA,SAAS,EAAE,aAAa;AAAEC,EAAAA,MAAM,EAAE,aAAa;AAAEC,EAAAA,MAAM,EAAE,MAAM;AAAEC,EAAAA,MAAM,EAAE;AAC3E,CAAC,CAAC;;;;"}

package/dist/global/blue/IListNotify.js

@@ -0,0 +1,44 @@
+import { CjsSchema, compose, impl } from '#schema';
+
+// Source: blueexposure/include/IList.h:56-66
+//
+// The `IList` container interface shares this header and is not ported.
+//
+// BLUELISTEVENT, declared just above IListNotify in the donor, is NOT a static
+// here. The enum-placement rule makes class ownership the default, and this
+// enum has exactly one owner - nothing consumes it but code implementing this
+// interface. Our layering forbids it anyway: `global/blue` may import only
+// `global/schema`, and `global/model` may not import `global/blue` at all,
+// while `CjsModel` is what fires these events. So it lands under the rule's
+// other clause, as cross-layer vocabulary in the leaf layer everything may
+// read: `#consts/blue`. Carbon has no such constraint, being one binary.
+
+
+/** `IListNotify` - the single observer a Blue list notifies. */
+class IListNotify {
+  /**
+   * `OnListModified` - the list changed.
+   *
+   * Every event fires AFTER the mutation, which is what the donor's own
+   * comments say (`//after insertion`, `//after removal`). The event may carry
+   * a load or unload flag, so mask with `BELIST_EVENTMASK` before comparing.
+   *
+   * @param {number} _event A `BLUELISTEVENT` value from `#consts/blue`.
+   * @param {number} _key The index acted on.
+   * @param {number} _key2 The second index, for swaps and moves.
+   * @param {*} _value The item inserted, removed or moved.
+   * @param {*} _theList The list that changed, so one observer can serve several.
+   * @returns {void}
+   */
+  OnListModified(_event, _key, _key2, _value, _theList) {}
+}
+CjsSchema.decorateMethod(IListNotify, "OnListModified", compose.abstract, impl.abstract);
+CjsSchema.define(IListNotify, {
+  className: "IListNotify",
+  carbon: "IListNotify",
+  family: "blue",
+  fields: {}
+});
+
+export { IListNotify };
+//# sourceMappingURL=IListNotify.js.map

package/dist/global/blue/IListNotify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IListNotify.js","sources":["../../../../src/global/blue/IListNotify.js"],"sourcesContent":["// Source: blueexposure/include/IList.h:56-66\n//\n// The `IList` container interface shares this header and is not ported.\n//\n// BLUELISTEVENT, declared just above IListNotify in the donor, is NOT a static\n// here. The enum-placement rule makes class ownership the default, and this\n// enum has exactly one owner - nothing consumes it but code implementing this\n// interface. Our layering forbids it anyway: `global/blue` may import only\n// `global/schema`, and `global/model` may not import `global/blue` at all,\n// while `CjsModel` is what fires these events. So it lands under the rule's\n// other clause, as cross-layer vocabulary in the leaf layer everything may\n// read: `#consts/blue`. Carbon has no such constraint, being one binary.\n\nimport { CjsSchema, compose, impl } from \"#schema\";\n\n/** `IListNotify` - the single observer a Blue list notifies. */\nexport class IListNotify\n{\n  /**\n   * `OnListModified` - the list changed.\n   *\n   * Every event fires AFTER the mutation, which is what the donor's own\n   * comments say (`//after insertion`, `//after removal`). The event may carry\n   * a load or unload flag, so mask with `BELIST_EVENTMASK` before comparing.\n   *\n   * @param {number} _event A `BLUELISTEVENT` value from `#consts/blue`.\n   * @param {number} _key The index acted on.\n   * @param {number} _key2 The second index, for swaps and moves.\n   * @param {*} _value The item inserted, removed or moved.\n   * @param {*} _theList The list that changed, so one observer can serve several.\n   * @returns {void}\n   */\n  OnListModified(_event, _key, _key2, _value, _theList) {}\n}\n\nCjsSchema.decorateMethod(IListNotify, \"OnListModified\", compose.abstract, impl.abstract);\n\nCjsSchema.define(IListNotify, {\n  className: \"IListNotify\", carbon: \"IListNotify\", family: \"blue\", fields: {}\n});\n"],"names":["IListNotify","OnListModified","_event","_key","_key2","_value","_theList","CjsSchema","decorateMethod","compose","abstract","impl","define","className","carbon","family","fields"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAIA;AACO,MAAMA,WAAW,CACxB;AACE;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACEC,cAAcA,CAACC,MAAM,EAAEC,IAAI,EAAEC,KAAK,EAAEC,MAAM,EAAEC,QAAQ,EAAE,CAAC;AACzD;AAEAC,SAAS,CAACC,cAAc,CAACR,WAAW,EAAE,gBAAgB,EAAES,OAAO,CAACC,QAAQ,EAAEC,IAAI,CAACD,QAAQ,CAAC;AAExFH,SAAS,CAACK,MAAM,CAACZ,WAAW,EAAE;AAC5Ba,EAAAA,SAAS,EAAE,aAAa;AAAEC,EAAAA,MAAM,EAAE,aAAa;AAAEC,EAAAA,MAAM,EAAE,MAAM;AAAEC,EAAAA,MAAM,EAAE;AAC3E,CAAC,CAAC;;;;"}

package/dist/global/blue/INotify.js

@@ -0,0 +1,65 @@
+import { CjsSchema, compose, impl } from '#schema';
+
+// Source: blueexposure/include/INotify.h:16-39
+//
+// One method. Carbon's own comment states the calling rule precisely, and it is
+// worth keeping because it is what separates this from an event system:
+//
+//   "Called when a member of an instance is modified. Usually it's Python or
+//    Jennifer which calls this function. This function is only called for
+//    members that are flagged with Be::NOTIFY in the members mapping."
+//
+// So it fires when something OUTSIDE the object edits a mapped member - a tool,
+// a reader, a script - and the object then sorts itself out. It is not a
+// broadcast, it has one implementor per class, and it is not the event emitter.
+// The exposure gate above is not universal: explicit callers such as Copier
+// have their own selection rules. Keep those rules at the calling site.
+//
+// A reader calls this OR IInitialize, never both: DictReader.cpp:163-168 casts
+// for each and, finding IInitialize, nulls the notify pointer with the comment
+// "If IInitialize is provided, don't do individual notifications."
+
+
+/** `INotify` - a mapped member of this instance was modified from outside. */
+class INotify {
+  /**
+   * `OnModified` - a Be::NOTIFY member changed; re-derive whatever depended on
+   * it. Returning false stops the caller, which is what `CjsModel` tests for.
+   *
+   * @param {string|null} _propertyName The changed member's name in JavaScript.
+   * @returns {boolean} False to halt the caller.
+   */
+  OnModified(_propertyName) {}
+}
+CjsSchema.decorateMethod(INotify, "OnModified", compose.abstract, impl.abstract);
+CjsSchema.define(INotify, {
+  className: "INotify",
+  carbon: "INotify",
+  family: "blue",
+  fields: {}
+});
+
+/**
+ * `IsMatch` - whether the modified member is the one named.
+ *
+ * Carbon has nine overloads of this (INotify.h:42-83) and they all do one
+ * thing: compare the `Be::Var*` against the ADDRESS of a member, taking the
+ * inner member for smart pointers and strings so the wrapper's address is never
+ * compared by mistake. The overloads exist only to reach that inner member for
+ * each wrapper type.
+ *
+ * @impl.reason C++ compares member addresses; JavaScript has no address to
+ * take, so the port identifies the member by NAME instead of a pointer.
+ * That collapses all nine overloads into one comparison and removes the trap
+ * the overloads exist to prevent, since a name has no wrapper to look past.
+ *
+ * @param {string|null} propertyName The argument `OnModified` received.
+ * @param {string} name The member being tested for.
+ * @returns {boolean} True when that member is the one that changed.
+ */
+function IsMatch(propertyName, name) {
+  return propertyName === name;
+}
+
+export { INotify, IsMatch };
+//# sourceMappingURL=INotify.js.map

package/dist/global/blue/INotify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"INotify.js","sources":["../../../../src/global/blue/INotify.js"],"sourcesContent":["// Source: blueexposure/include/INotify.h:16-39\r\n//\r\n// One method. Carbon's own comment states the calling rule precisely, and it is\r\n// worth keeping because it is what separates this from an event system:\r\n//\r\n//   \"Called when a member of an instance is modified. Usually it's Python or\r\n//    Jennifer which calls this function. This function is only called for\r\n//    members that are flagged with Be::NOTIFY in the members mapping.\"\r\n//\r\n// So it fires when something OUTSIDE the object edits a mapped member - a tool,\r\n// a reader, a script - and the object then sorts itself out. It is not a\r\n// broadcast, it has one implementor per class, and it is not the event emitter.\n// The exposure gate above is not universal: explicit callers such as Copier\n// have their own selection rules. Keep those rules at the calling site.\n//\r\n// A reader calls this OR IInitialize, never both: DictReader.cpp:163-168 casts\r\n// for each and, finding IInitialize, nulls the notify pointer with the comment\r\n// \"If IInitialize is provided, don't do individual notifications.\"\r\n\r\nimport { CjsSchema, compose, impl } from \"#schema\";\r\n\r\n/** `INotify` - a mapped member of this instance was modified from outside. */\r\nexport class INotify\r\n{\r\n  /**\r\n   * `OnModified` - a Be::NOTIFY member changed; re-derive whatever depended on\r\n   * it. Returning false stops the caller, which is what `CjsModel` tests for.\r\n   *\r\n   * @param {string|null} _propertyName The changed member's name in JavaScript.\n   * @returns {boolean} False to halt the caller.\r\n   */\r\n  OnModified(_propertyName) {}\n}\r\n\r\nCjsSchema.decorateMethod(INotify, \"OnModified\", compose.abstract, impl.abstract);\r\n\r\nCjsSchema.define(INotify, {\r\n  className: \"INotify\", carbon: \"INotify\", family: \"blue\", fields: {}\r\n});\r\n\r\n\r\n/**\r\n * `IsMatch` - whether the modified member is the one named.\r\n *\r\n * Carbon has nine overloads of this (INotify.h:42-83) and they all do one\r\n * thing: compare the `Be::Var*` against the ADDRESS of a member, taking the\r\n * inner member for smart pointers and strings so the wrapper's address is never\r\n * compared by mistake. The overloads exist only to reach that inner member for\r\n * each wrapper type.\r\n *\r\n * @impl.reason C++ compares member addresses; JavaScript has no address to\r\n * take, so the port identifies the member by NAME instead of a pointer.\n * That collapses all nine overloads into one comparison and removes the trap\r\n * the overloads exist to prevent, since a name has no wrapper to look past.\r\n *\r\n * @param {string|null} propertyName The argument `OnModified` received.\n * @param {string} name The member being tested for.\r\n * @returns {boolean} True when that member is the one that changed.\r\n */\r\nexport function IsMatch(propertyName, name)\n{\n  return propertyName === name;\n}\n"],"names":["INotify","OnModified","_propertyName","CjsSchema","decorateMethod","compose","abstract","impl","define","className","carbon","family","fields","IsMatch","propertyName","name"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAIA;AACO,MAAMA,OAAO,CACpB;AACE;AACF;AACA;AACA;AACA;AACA;AACA;EACEC,UAAUA,CAACC,aAAa,EAAE,CAAC;AAC7B;AAEAC,SAAS,CAACC,cAAc,CAACJ,OAAO,EAAE,YAAY,EAAEK,OAAO,CAACC,QAAQ,EAAEC,IAAI,CAACD,QAAQ,CAAC;AAEhFH,SAAS,CAACK,MAAM,CAACR,OAAO,EAAE;AACxBS,EAAAA,SAAS,EAAE,SAAS;AAAEC,EAAAA,MAAM,EAAE,SAAS;AAAEC,EAAAA,MAAM,EAAE,MAAM;AAAEC,EAAAA,MAAM,EAAE;AACnE,CAAC,CAAC;;AAGF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,OAAOA,CAACC,YAAY,EAAEC,IAAI,EAC1C;EACE,OAAOD,YAAY,KAAKC,IAAI;AAC9B;;;;"}