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

package/dist/trinity/core/device/TriDevice.js

@@ -1,10 +1,16 @@
 import { identity as _identity, applyDecs2311 as _applyDecs2311 } from '../../../_virtual/_rollupPluginBabelHelpers.js';
-import { io, type, carbon, impl } from '#schema';
+import { edit, type, carbon, impl } from '#schema';
 import { CjsModel } from '#model';
 import { PresentInterval, SwapEffect, UpscalingSetting, UpscalingTechnique } from '#consts/render-context';
 import { screenToProjection, convertProjectionCoordToWorldPickRay } from '../view/pickRay.js';
+import { IBlueEvents, ISimTimeRebaseNotify, blue } from '#blue';
+import { TriStorageFlags } from '#consts/graphics';
+import { ALResult, Failed } from '../../../trinityal/ALResult.js';
+import { TriViewport as _TriViewport } from '../view/TriViewport.js';
+import { Tr2RenderContext_GetMainThreadRenderContext, Tr2RenderContext as _Tr2RenderContext } from '../context/Tr2RenderContext.js';
+import { Tr2Renderer as _Tr2Renderer } from '../Tr2Renderer.js';
 
-let _initProto, _initClass, _init_presentationInterval, _init_extra_presentationInterval, _init_swapEffect, _init_extra_swapEffect, _init_throttlingState, _init_extra_throttlingState, _init_deviceType, _init_extra_deviceType, _init_allowThrottling, _init_extra_allowThrottling, _init_onDeviceRemoved, _init_extra_onDeviceRemoved, _init_curveSets, _init_extra_curveSets, _init_supportedUpscalingTechniques, _init_extra_supportedUpscalingTechniques, _init_viewport, _init_extra_viewport, _init_adapterWidth, _init_extra_adapterWidth, _init_adapterHeight, _init_extra_adapterHeight, _init_adapterRefreshRate, _init_extra_adapterRefreshRate, _init_adapter, _init_extra_adapter, _init_width, _init_extra_width, _init_height, _init_extra_height, _init_multiSampleType, _init_extra_multiSampleType, _init_multiSampleQuality, _init_extra_multiSampleQuality, _init_scene, _init_extra_scene, _init_backBufferCount, _init_extra_backBufferCount, _init_tickInterval, _init_extra_tickInterval, _init_mipLevelSkipCount, _init_extra_mipLevelSkipCount, _init_animationTimeScale, _init_extra_animationTimeScale, _init_animationTime, _init_extra_animationTime, _init_upscalingSetting, _init_extra_upscalingSetting, _init_upscalingTechnique, _init_extra_upscalingTechnique, _init_frameGeneration, _init_extra_frameGeneration, _init_disableGeometryLoad, _init_extra_disableGeometryLoad, _init_disableTextureLoad, _init_extra_disableTextureLoad, _init_disableAsyncLoad, _init_extra_disableAsyncLoad, _init_minimumModelLOD, _init_extra_minimumModelLOD;
+let _initProto, _initStatic, _initClass, _init_presentationInterval, _init_extra_presentationInterval, _init_swapEffect, _init_extra_swapEffect, _init_throttlingState, _init_extra_throttlingState, _init_deviceType, _init_extra_deviceType, _init_allowThrottling, _init_extra_allowThrottling, _init_onDeviceRemoved, _init_extra_onDeviceRemoved, _init_curveSets, _init_extra_curveSets, _init_supportedUpscalingTechniques, _init_extra_supportedUpscalingTechniques, _init_viewport, _init_extra_viewport, _init_adapterWidth, _init_extra_adapterWidth, _init_adapterHeight, _init_extra_adapterHeight, _init_adapterRefreshRate, _init_extra_adapterRefreshRate, _init_adapter, _init_extra_adapter, _init_width, _init_extra_width, _init_height, _init_extra_height, _init_multiSampleType, _init_extra_multiSampleType, _init_multiSampleQuality, _init_extra_multiSampleQuality, _init_scene, _init_extra_scene, _init_backBufferCount, _init_extra_backBufferCount, _init_tickInterval, _init_extra_tickInterval, _init_mipLevelSkipCount, _init_extra_mipLevelSkipCount, _init_animationTimeScale, _init_extra_animationTimeScale, _init_animationTime, _init_extra_animationTime, _init_upscalingSetting, _init_extra_upscalingSetting, _init_upscalingTechnique, _init_extra_upscalingTechnique, _init_frameGeneration, _init_extra_frameGeneration, _init_disableGeometryLoad, _init_extra_disableGeometryLoad, _init_disableTextureLoad, _init_extra_disableTextureLoad, _init_disableAsyncLoad, _init_extra_disableAsyncLoad, _init_minimumModelLOD, _init_extra_minimumModelLOD;
 
 /** TriDevice (trinityCore) - generated from schema shapeHash 1db3a492.... */
 let _TriDevice;
@@ -12,16 +18,13 @@ new class extends _identity {
   static [class TriDevice extends CjsModel {
     static {
       ({
-        e: [_init_presentationInterval, _init_extra_presentationInterval, _init_swapEffect, _init_extra_swapEffect, _init_throttlingState, _init_extra_throttlingState, _init_deviceType, _init_extra_deviceType, _init_allowThrottling, _init_extra_allowThrottling, _init_onDeviceRemoved, _init_extra_onDeviceRemoved, _init_curveSets, _init_extra_curveSets, _init_supportedUpscalingTechniques, _init_extra_supportedUpscalingTechniques, _init_viewport, _init_extra_viewport, _init_adapterWidth, _init_extra_adapterWidth, _init_adapterHeight, _init_extra_adapterHeight, _init_adapterRefreshRate, _init_extra_adapterRefreshRate, _init_adapter, _init_extra_adapter, _init_width, _init_extra_width, _init_height, _init_extra_height, _init_multiSampleType, _init_extra_multiSampleType, _init_multiSampleQuality, _init_extra_multiSampleQuality, _init_scene, _init_extra_scene, _init_backBufferCount, _init_extra_backBufferCount, _init_tickInterval, _init_extra_tickInterval, _init_mipLevelSkipCount, _init_extra_mipLevelSkipCount, _init_animationTimeScale, _init_extra_animationTimeScale, _init_animationTime, _init_extra_animationTime, _init_upscalingSetting, _init_extra_upscalingSetting, _init_upscalingTechnique, _init_extra_upscalingTechnique, _init_frameGeneration, _init_extra_frameGeneration, _init_disableGeometryLoad, _init_extra_disableGeometryLoad, _init_disableTextureLoad, _init_extra_disableTextureLoad, _init_disableAsyncLoad, _init_extra_disableAsyncLoad, _init_minimumModelLOD, _init_extra_minimumModelLOD, _initProto],
+        e: [_init_presentationInterval, _init_extra_presentationInterval, _init_swapEffect, _init_extra_swapEffect, _init_throttlingState, _init_extra_throttlingState, _init_deviceType, _init_extra_deviceType, _init_allowThrottling, _init_extra_allowThrottling, _init_onDeviceRemoved, _init_extra_onDeviceRemoved, _init_curveSets, _init_extra_curveSets, _init_supportedUpscalingTechniques, _init_extra_supportedUpscalingTechniques, _init_viewport, _init_extra_viewport, _init_adapterWidth, _init_extra_adapterWidth, _init_adapterHeight, _init_extra_adapterHeight, _init_adapterRefreshRate, _init_extra_adapterRefreshRate, _init_adapter, _init_extra_adapter, _init_width, _init_extra_width, _init_height, _init_extra_height, _init_multiSampleType, _init_extra_multiSampleType, _init_multiSampleQuality, _init_extra_multiSampleQuality, _init_scene, _init_extra_scene, _init_backBufferCount, _init_extra_backBufferCount, _init_tickInterval, _init_extra_tickInterval, _init_mipLevelSkipCount, _init_extra_mipLevelSkipCount, _init_animationTimeScale, _init_extra_animationTimeScale, _init_animationTime, _init_extra_animationTime, _init_upscalingSetting, _init_extra_upscalingSetting, _init_upscalingTechnique, _init_extra_upscalingTechnique, _init_frameGeneration, _init_extra_frameGeneration, _init_disableGeometryLoad, _init_extra_disableGeometryLoad, _init_disableTextureLoad, _init_extra_disableTextureLoad, _init_disableAsyncLoad, _init_extra_disableAsyncLoad, _init_minimumModelLOD, _init_extra_minimumModelLOD, _initProto, _initStatic],
         c: [_TriDevice, _initClass]
       } = _applyDecs2311(this, [type.define({
         className: "TriDevice",
         family: "trinityCore"
-      })], [[[io, io.notify, io, io.persist, type, type.int32, void 0, type.enum("PresentInterval")], 16, "presentationInterval"], [[io, io.notify, io, io.persist, type, type.int32, void 0, type.enum("SwapEffect")], 16, "swapEffect"], [[io, io.read, type, type.uint32], 16, "throttlingState"], [[io, io.readwrite, type, type.int32, void 0, type.enum("DeviceType")], 16, "deviceType"], [[io, io.readwrite, type, type.boolean], 16, "allowThrottling"], [[io, io.readwrite, void 0, type.rawStruct("BlueScriptCallback")], 16, "onDeviceRemoved"], [[io, io.persist, void 0, type.list("TriCurveSet")], 16, "curveSets"], [[io, io.read, void 0, type.list("Tr2UpscalingTechniqueInfo")], 16, "supportedUpscalingTechniques"], [[io, io.persist, void 0, type.objectRef("TriViewport")], 16, "viewport"], [[io, io.read, type, type.uint32], 16, "adapterWidth"], [[io, io.read, type, type.uint32], 16, "adapterHeight"], [[io, io.read, type, type.uint32], 16, "adapterRefreshRate"], [[io, io.read, type, type.int32], 16, "adapter"], [[io, io.read, type, type.int32], 16, "width"], [[io, io.read, type, type.int32], 16, "height"], [[io, io.notify, io, io.persist, type, type.uint32], 16, "multiSampleType"], [[io, io.notify, io, io.persist, type, type.uint32], 16, "multiSampleQuality"], [[io, io.notify, io, io.readwrite, void 0, type.objectRef("ITr2Scene")], 16, "scene"], [[io, io.notify, io, io.readwrite, type, type.int32], 16, "backBufferCount"], [[io, io.readwrite, type, type.int32], 16, "tickInterval"], [[io, io.readwrite, type, type.uint32], 16, "mipLevelSkipCount"], [[io, io.readwrite, type, type.float32], 16, "animationTimeScale"], [[io, io.readwrite, type, type.float32], 16, "animationTime"], [[io, io.read, type, type.uint32, void 0, type.enum("UpscalingSetting")], 16, "upscalingSetting"], [[io, io.read, type, type.uint32, void 0, type.enum("UpscalingTechnique")], 16, "upscalingTechnique"], [[io, io.read, type, type.boolean], 16, "frameGeneration"], [[io, io.readwrite, type, type.boolean], 16, "disableGeometryLoad"], [[io, io.readwrite, type, type.boolean], 16, "disableTextureLoad"], [[io, io.readwrite, type, type.boolean], 16, "disableAsyncLoad"], [[io, io.readwrite, type, type.int32], 16, "minimumModelLOD"], [[carbon, carbon.method, impl, impl.implemented], 18, "AspectRatio"], [[carbon, carbon.method, impl, impl.adapted], 18, "ScreenToProjection"], [[carbon, carbon.method, impl, impl.adapted], 18, "GetPickRayFromViewport"], [[carbon, carbon.method, impl, impl.implemented], 18, "GetAnimationTime"], [[carbon, carbon.method, impl, impl.implemented], 18, "GetAnimationTimeElapsed"], [[carbon, carbon.method, impl, impl.notImplemented], 18, "CreateUpscalingContext"], [[carbon, carbon.method, impl, impl.notImplemented], 18, "DeleteUpscalingContext"], [[carbon, carbon.method, impl, impl.notImplemented], 18, "GetRenderResolution"], [[carbon, carbon.method, impl, impl.notImplemented], 18, "RefreshDeviceResources"], [[carbon, carbon.method, impl, impl.notImplemented], 18, "Render"], [[carbon, carbon.method, impl, impl.notImplemented], 18, "GetRenderingPlatformID"], [[carbon, carbon.method, impl, impl.notImplemented], 18, "SupportsRenderTargetFormat"], [[carbon, carbon.method, impl, impl.notImplemented], 18, "IsVariableRefreshRateSupported"], [[carbon, carbon.method, impl, impl.notImplemented], 18, "SupportsRaytracing"], [[carbon, carbon.method, impl, impl.notImplemented], 18, "DoesD3DDeviceExist"], [[carbon, carbon.method, impl, impl.notImplemented], 18, "SetRenderJobs"], [[carbon, carbon.method, impl, impl.notImplemented], 18, "SetUpscaling"], [[carbon, carbon.method, impl, impl.notImplemented], 18, "GetRenderContext"], [[carbon, carbon.method, impl, impl.notImplemented], 18, "UpdateAvailableUpscalingTechniques"]], 0, void 0, CjsModel));
-    }
-    constructor(...args) {
-      super(...args);
-      _init_extra_minimumModelLOD(this);
+      }), carbon.inherit(IBlueEvents, ISimTimeRebaseNotify)], [[[edit, edit.notify, edit, edit.persist, type, type.int32, void 0, type.enum("PresentInterval")], 16, "presentationInterval"], [[edit, edit.notify, edit, edit.persist, type, type.int32, void 0, type.enum("SwapEffect")], 16, "swapEffect"], [[edit, edit.read, type, type.uint32], 16, "throttlingState"], [[edit, edit.readwrite, type, type.int32, void 0, type.enum("DeviceType")], 16, "deviceType"], [[edit, edit.readwrite, type, type.boolean], 16, "allowThrottling"], [[edit, edit.readwrite, void 0, type.rawStruct("BlueScriptCallback")], 16, "onDeviceRemoved"], [[edit, edit.persist, void 0, type.list("TriCurveSet")], 16, "curveSets"], [[edit, edit.read, void 0, type.list("Tr2UpscalingTechniqueInfo")], 16, "supportedUpscalingTechniques"], [[edit, edit.persist, void 0, type.objectRef("TriViewport")], 16, "viewport"], [[edit, edit.read, type, type.uint32], 16, "adapterWidth"], [[edit, edit.read, type, type.uint32], 16, "adapterHeight"], [[edit, edit.read, type, type.uint32], 16, "adapterRefreshRate"], [[edit, edit.read, type, type.int32], 16, "adapter"], [[edit, edit.read, type, type.int32], 16, "width"], [[edit, edit.read, type, type.int32], 16, "height"], [[edit, edit.notify, edit, edit.persist, type, type.uint32], 16, "multiSampleType"], [[edit, edit.notify, edit, edit.persist, type, type.uint32], 16, "multiSampleQuality"], [[edit, edit.notify, edit, edit.readwrite, void 0, type.objectRef("ITr2Scene")], 16, "scene"], [[edit, edit.notify, edit, edit.readwrite, type, type.int32], 16, "backBufferCount"], [[edit, edit.readwrite, type, type.int32], 16, "tickInterval"], [[edit, edit.readwrite, type, type.uint32], 16, "mipLevelSkipCount"], [[edit, edit.readwrite, type, type.float32], 16, "animationTimeScale"], [[edit, edit.readwrite, type, type.float32], 16, "animationTime"], [[edit, edit.read, type, type.uint32, void 0, type.enum("UpscalingSetting")], 16, "upscalingSetting"], [[edit, edit.read, type, type.uint32, void 0, type.enum("UpscalingTechnique")], 16, "upscalingTechnique"], [[edit, edit.read, type, type.boolean], 16, "frameGeneration"], [[edit, edit.readwrite, type, type.boolean], 16, "disableGeometryLoad"], [[edit, edit.readwrite, type, type.boolean], 16, "disableTextureLoad"], [[edit, edit.readwrite, type, type.boolean], 16, "disableAsyncLoad"], [[edit, edit.readwrite, type, type.int32], 16, "minimumModelLOD"], [[carbon, carbon.method, impl, impl.implemented], 18, "AspectRatio"], [[carbon, carbon.method, impl, impl.adapted], 18, "ScreenToProjection"], [[carbon, carbon.method, impl, impl.adapted], 18, "GetPickRayFromViewport"], [[carbon, carbon.method, impl, impl.implemented], 18, "GetAnimationTime"], [[carbon, carbon.method, impl, impl.implemented], 18, "GetAnimationTimeElapsed"], [[carbon, carbon.method, impl, impl.implemented], 18, "GetCurrentFrameCounter"], [[carbon, carbon.method, impl, impl.adapted, void 0, impl.reason("The clock half only. Carbon's OnTick also sets a crash key, schedules the next event, and runs Update, HandleRenderTick, the main-thread actions and the resource-pool sweep; none of those are ported. The cookie is accepted so the signature matches IBlueEvents, and ignored because Carbon's body ignores it too - it exists for registrants that register more than once.")], 18, "OnTick"], [[carbon, carbon.method, impl, impl.implemented], 18, "InvalidateAndUnregisterForTicks"], [[carbon, carbon.method, impl, impl.adapted, void 0, impl.reason("Carbon guards this set with a mutex because EveShip2Builder registers sprite sets from a background thread (TriDevice.cpp:1075-1080). JavaScript has no shared-memory threads, so there is nothing to guard and the mutex has no counterpart.")], 26, "GetResourcesRegistered"], [[carbon, carbon.method, impl, impl.implemented], 26, "RegisterResource"], [[carbon, carbon.method, impl, impl.implemented], 26, "UnregisterResource"], [[carbon, carbon.method, impl, impl.implemented], 18, "DeviceExists"], [[carbon, carbon.method, impl, impl.implemented], 18, "DoesD3DDeviceExist"], [[carbon, carbon.method, impl, impl.implemented], 18, "DestroyRenderContext"], [[carbon, carbon.method, impl, impl.adapted, void 0, impl.reason("Carbon guards against a resource unregistering itself mid-iteration with an s_resourcesToBeRemoved set and an s_iteratingForRelease flag; iterating over a copy of the registry answers the same problem without two statics to keep in step. Carbon also logs a warning for a null entry, which this registry cannot hold because RegisterResource refuses it at the door.")], 18, "ReleaseDeviceResources"], [[carbon, carbon.method, impl, impl.adapted, void 0, impl.reason("Carbon's third step is RebuildDeviceResourcesInPython, which has no counterpart: there is no Python here and no second resource registry to rebuild.")], 18, "PrepareDeviceResources"], [[carbon, carbon.method, impl, impl.adapted, void 0, impl.reason("Carbon logs every live video-memory resource and the HRESULT before returning false, through LogAllLiveResources and CCP_LOGERR; neither logging facility is ported, so the failure is reported by the return value alone.")], 18, "SetPresentParameters"], [[carbon, carbon.method, impl, impl.adapted, void 0, impl.reason("Carbon also reads the adapter display mode into mDisplayMode when there is an output window or the device is not software. That enumeration has no browser counterpart - see CreateSimpleDevice - so the viewport half is ported and the display-mode half is not.")], 18, "InitD3DDevice"], [[carbon, carbon.method, impl, impl.adapted, void 0, impl.reason("FULLSCREEN refuses because display-mode enumeration has no browser counterpart. CreateUpscalingTechnique and the nvperfhud accommodation have no backend that offers them. Carbon's two CCP_LOGERR calls are absent with the logging facility. Everything else is Carbon's order, including that registration is the last step and happens only once a device exists.")], 18, "CreateSimpleDevice"], [[carbon, carbon.method, impl, impl.implemented], 18, "SetPresentation"], [[impl, impl.custom, void 0, impl.reason("Carbon's mPresentParam is a member its own methods read directly; a private field needs an accessor for a host to see what the device was created with.")], 18, "GetPresentParameters"], [[impl, impl.custom, void 0, impl.reason("Carbon's mHwnd is a member its own methods read directly; same reason as GetPresentParameters.")], 18, "GetOutputWindow"], [[carbon, carbon.method, impl, impl.adapted, void 0, impl.reason("Carbon delegates to an IBlueCallbackMan, which carries flags and a comparison function neither of which has a caller here; this is the list itself.")], 18, "AddPostUpdateCallback"], [[carbon, carbon.method, impl, impl.adapted, void 0, impl.reason("Carbon opens with TriSrand( simTime ), seeding its global random stream so a frame is reproducible from its simulation time; the math layer's random is not a seedable global, so there is nothing to seed. The BlueList refcount dance around Remove has no counterpart either, because a JS array holds no references to release.")], 18, "Update"], [[carbon, carbon.method, impl, impl.implemented], 18, "HandleRenderTick"], [[carbon, carbon.method, impl, impl.implemented], 18, "OnSimClockRebase"], [[carbon, carbon.method, impl, impl.notImplemented], 18, "CreateUpscalingContext"], [[carbon, carbon.method, impl, impl.notImplemented], 18, "DeleteUpscalingContext"], [[carbon, carbon.method, impl, impl.notImplemented], 18, "GetRenderResolution"], [[carbon, carbon.method, impl, impl.notImplemented], 18, "RefreshDeviceResources"], [[carbon, carbon.method, impl, impl.adapted, void 0, impl.reason("Tr2SyncToGpu is unported and Tr2GpuProfiler is a fields-only shell, so their two calls are absent from the body. Everything else is Carbon's order verbatim.")], 18, "Render"], [[carbon, carbon.method, impl, impl.notSupported, void 0, impl.reason("Carbon throttles by blocking the render thread with CcpThreadSleep and by shrinking the TBB thread pool. A browser has neither: blocking the main thread is what a frame budget is trying to avoid, and requestAnimationFrame already stops delivering frames to a hidden document, which is the case this exists for. Kept as a call site so the frame body is Carbon's order and a host that CAN throttle has somewhere to do it.")], 18, "Throttle"], [[carbon, carbon.method, impl, impl.implemented], 18, "SetRenderJobs"], [[impl, impl.custom, void 0, impl.reason("Carbon's m_renderJobs is a member the frame body reads directly; a private field needs an accessor for anyone else to see what is installed.")], 18, "GetRenderJobs"], [[carbon, carbon.method, impl, impl.notImplemented], 18, "GetRenderingPlatformID"], [[carbon, carbon.method, impl, impl.notImplemented], 18, "SupportsRenderTargetFormat"], [[carbon, carbon.method, impl, impl.adapted, void 0, impl.reason("Carbon asks the adapter through DXGI. A browser is never told whether the display has a variable refresh rate - requestAnimationFrame reports no such thing - so the only truthful answer is no. Constant rather than a refusal because CreateSimpleDevice records it in the present parameters on every creation, and a device that cannot be created is worse than one that reports a capability it does not have.")], 18, "IsVariableRefreshRateSupported"], [[carbon, carbon.method, impl, impl.notImplemented], 18, "SupportsRaytracing"], [[carbon, carbon.method, impl, impl.notImplemented], 18, "SetUpscaling"], [[carbon, carbon.method, impl, impl.notImplemented], 18, "GetRenderContext"], [[carbon, carbon.method, impl, impl.adapted, void 0, impl.reason("Carbon enumerates DLSS, FSR and XeSS through vendor SDKs. No backend here offers any of them, so the list is empty - which is the truthful answer, not a stub. SetUpscaling still REFUSES, because that is the verb where a caller asks for upscaling and would otherwise be silently given none. CreateSimpleDevice calls this on every creation, so a refusal here would break device creation to report a capability nobody asked for.")], 18, "UpdateAvailableUpscalingTechniques"]], 0, void 0, CjsModel));
+      _initStatic(this);
     }
     /** mPresentParam.presentInterval (Tr2PresentParametersAL - enum Tr2PresentParametersAL) [READWRITE, NOTIFY, PERSIST, ENUM] */
     presentationInterval = (_initProto(this), _init_presentationInterval(this, 1));
@@ -113,9 +116,9 @@ new class extends _identity {
     /** Get/SetMinimumModelLOD (MAP_PROPERTY) - prevents the first N model LODs from loading; 0 disables. */
     minimumModelLOD = (_init_extra_disableAsyncLoad(this), _init_minimumModelLOD(this, 0));
 
-    /**
-     * Width over height of the device viewport in pixels; zero when there is no
-     * viewport or its height is zero.
+    /**
+     * Width over height of the device viewport in pixels; zero when there is no
+     * viewport or its height is zero.
      */
     AspectRatio() {
       const viewport = this.viewport;
@@ -125,10 +128,10 @@ new class extends _identity {
       return viewport.width / viewport.height;
     }
 
-    /**
-     * Maps window-space pixel coordinates into the [-1, 1] projection space.
-     * DX maps viewport pixel CENTRES to view space, so for four pixels, pixel
-     * 3 maps to 1 and pixel 0 to -1.
+    /**
+     * Maps window-space pixel coordinates into the [-1, 1] projection space.
+     * DX maps viewport pixel CENTRES to view space, so for four pixels, pixel
+     * 3 maps to 1 and pixel 0 to -1.
      */
     ScreenToProjection(x, y, viewport = this.viewport, out = {}) {
       const vx = x - (viewport?.x ?? 0);
@@ -161,9 +164,9 @@ new class extends _identity {
       return this.animationTime;
     }
 
-    /**
-     * Elapsed animation time since startTime, correct across the hourly
-     * ANIMATION_TIME_MAX recenter.
+    /**
+     * Elapsed animation time since startTime, correct across the hourly
+     * ANIMATION_TIME_MAX recenter.
      */
     GetAnimationTimeElapsed(startTime) {
       let elapsed = this.animationTime - startTime;
@@ -173,6 +176,473 @@ new class extends _identity {
       return elapsed;
     }
 
+    // Source: trinity/trinity/TriDevice.cpp:697,805-833
+    //
+    // The clock half of Carbon's tick. The rest of TriDevice::OnTick - the crash
+    // key, the scheduled event, Update, HandleRenderTick, the main-thread action
+    // queue and the resource-pool sweep - is not ported, and this does not
+    // pretend otherwise.
+    //
+    // Carbon keeps the frame counter in a file-scope `g_currentFrameCounter`
+    // rather than on the device, and reads it back through
+    // Tr2Renderer::GetCurrentFrameCounter. It is a device member here because
+    // `gTriDev` is how everything reaches the device anyway, and a second
+    // module-scope counter would be a second thing to keep in step.
+
+    /** `g_currentFrameCounter` - the frame the device is on. */
+    frameCounter = (_init_extra_minimumModelLOD(this), 0);
+
+    /** m_simTime, the simulation clock the animation delta is taken from. */
+    simTime = 0;
+
+    /** m_realTime. */
+    realTime = 0;
+
+    /** The animation time before the current tick, for the render-time vector. */
+    previousAnimationTime = 0;
+
+    /** `Tr2Renderer::GetCurrentFrameCounter` reads this through gTriDev. */
+    GetCurrentFrameCounter() {
+      return this.frameCounter;
+    }
+
+    /**
+     * Blue's tick: advance the frame counter and the animation time by the
+     * simulation delta (`TriDevice::OnTick`, `TriDevice.cpp:697,805-833`).
+     *
+     * THIS IS A CALLBACK, not a method a caller invokes directly. Carbon
+     * declares it under an `// IBlueEvents` banner (`TriDevice.h:154-159`) and
+     * the device hands ITSELF to `BeOS->RegisterForTicks( this, TRINITY )`
+     * (`TriDevice.cpp:310`), so the pump calls it. `blue.os` is that pump here.
+     *
+     * BOTH TIMES ARE `Be::Time` - 100-nanosecond ticks since the client started,
+     * not seconds. Carbon divides the delta by 10,000,000 to get the seconds the
+     * animation clock advances by, and so does this. The clamp is to one second,
+     * so a stall does not jump every animation forward, and the clock recentres
+     * hourly.
+     *
+     * @param {number} realTime Time since the client started, in 100ns ticks.
+     * @param {number} simTime The same, slowed under load to manage it.
+     * @param {*} [_cookie] The cookie this device registered with; unread.
+     * @returns {TriDevice} This device.
+     */
+    OnTick(realTime = 0, simTime = 0, _cookie = null) {
+      this.frameCounter++;
+      let delta = Number(simTime) - this.simTime;
+      if (!(delta > 0)) delta = 0;
+
+      // cpp:817-822. Be::Time is 100ns ticks, so the seconds delta is the tick
+      // delta over ten million; the clamp is applied to the SECONDS value, as
+      // Carbon applies it to fDelta rather than to delta.
+      let deltaSeconds = delta / 10000000;
+      if (deltaSeconds > 1) deltaSeconds = 1;
+      this.previousAnimationTime = this.animationTime;
+      this.animationTime += deltaSeconds * this.animationTimeScale;
+
+      // cpp:823-826. Carbon also rebases every animation player and Granny
+      // control clock by the same amount here; neither is ported, so a clock
+      // that runs past an hour will step those consumers.
+      if (this.animationTime > _TriDevice.ANIMATION_TIME_MAX) {
+        this.animationTime -= _TriDevice.ANIMATION_TIME_MAX;
+      }
+      this.simTime = Number(simTime) || 0;
+      this.realTime = Number(realTime) || 0;
+
+      // cpp:840-845. ExecuteMainThreadActions and
+      // Tr2GpuResourcePool::ClearAllUnusedResources close Carbon's tick; neither
+      // is ported, and both are named here rather than silently absent.
+      this.Update(this.realTime, this.simTime);
+      this.HandleRenderTick(this.realTime, this.simTime);
+      return this;
+    }
+
+    /**
+     * Tears the device down and stops it being ticked (`TriDevice.cpp:687-691`).
+     *
+     * @returns {TriDevice} This device.
+     */
+    InvalidateAndUnregisterForTicks() {
+      this.DestroyRenderContext();
+      blue.os.UnregisterForTicks(this, _TriDevice.TICK_COOKIE);
+      this.#hwnd = null;
+      this.width = 0;
+      this.height = 0;
+      return this;
+    }
+
+    /** Carbon's tick cookie, the string "Trinity" (`TriDevice.cpp:148`). */
+
+    // ==========================================================================
+    // THE DEVICE LIFECYCLE. Source: TriDevice.cpp:230-341, :480-487, :669-691,
+    // :1019-1060, and TriDeviceStub.cpp:16-37 for the headless backend.
+    //
+    // This is the path that ends in `BeOS->RegisterForTicks`, which is why it
+    // matters beyond device creation: until something here runs, nothing ticks
+    // the device and the animation clock never moves.
+    //
+    // CARBON SPLITS IT PER BACKEND AND WE HAVE ONE SEAM INSTEAD. `CreateDeviceInt`
+    // and `DeviceExists` live in TriDevice11/12/Metal/Stub; the abstraction layer
+    // is that seam here, so device creation is the AL's `CreateDevice` and
+    // existence is the ambient context's own `IsValid`. The headless backend
+    // (`TriDeviceStub.cpp:34-37`) answers existence exactly that way, which is the
+    // evidence this is the right seam rather than a convenience.
+    // ==========================================================================
+
+    /** Carbon mHwnd - the output window the device presents to. */
+    #hwnd = null;
+
+    /** Carbon mPresentParam - the present parameters the device was created with. */
+    #presentParam = null;
+
+    /** Carbon mDeviceLost. */
+    #deviceLost = false;
+
+    /** Carbon m_postUpdateCallbacks (TriDevice.h:313). */
+    #postUpdateCallbacks = [];
+
+    /** Carbon's static resource registry (TriDevice.h:265-266). */
+
+    /**
+     * Every `Tr2DeviceResource` that has registered itself
+     * (`TriDevice.cpp:1061-1065`).
+     *
+     * STATIC, AND A PROCESS-WIDE SINGLETON IN CARBON TOO - resources register
+     * without knowing which device they belong to, because there is one.
+     *
+     * @returns {Set<object>} The live registry, not a copy.
+     */
+    static GetResourcesRegistered() {
+      return _TriDevice.#resourcesRegistered;
+    }
+
+    /**
+     * Registers a device resource so it is prepared and released with the device.
+     *
+     * @param {object} resource A `Tr2DeviceResource`.
+     * @returns {void}
+     */
+    static RegisterResource(resource) {
+      // CHECKED AT THE DOOR, because both verbs are non-optional on Carbon's
+      // base: ReleaseResources is pure virtual and PrepareResources is concrete
+      // on Tr2DeviceResource itself (`Tr2DeviceResource.h:45,53`). A registry
+      // that accepted something without them would have to hedge every call, and
+      // a resource silently never released is exactly the failure this device is
+      // meant to prevent.
+      if (typeof resource?.ReleaseResources !== "function" || typeof resource?.PrepareResources !== "function") {
+        throw new TypeError("TriDevice.RegisterResource expects a Tr2DeviceResource with " + "PrepareResources and ReleaseResources.");
+      }
+      _TriDevice.#resourcesRegistered.add(resource);
+    }
+
+    /**
+     * Unregisters one.
+     *
+     * @param {object} resource The registered resource.
+     * @returns {void}
+     */
+    static UnregisterResource(resource) {
+      _TriDevice.#resourcesRegistered.delete(resource);
+    }
+
+    /**
+     * Whether a device exists at all (`TriDeviceStub.cpp:31-37`).
+     *
+     * Carbon's comment is worth keeping: this is a LOWER-level question than
+     * "do we have a valid render context", so it can be true while that is still
+     * false. On the headless backend the two coincide, because the AL's validity
+     * IS the device.
+     *
+     * @returns {boolean} Whether the ambient context has a live backend.
+     */
+    DeviceExists() {
+      return Tr2RenderContext_GetMainThreadRenderContext().IsValid();
+    }
+
+    /**
+     * The Blue-exposed spelling of `DeviceExists`.
+     *
+     * TWO NAMES FOR ONE METHOD, AND BOTH ARE CARBON'S. The C++ method is
+     * `DeviceExists` (`TriDevice.h:209`); `TriDevice_Blue.cpp` exposes it to
+     * script as `DoesD3DDeviceExist`, which is why the generated schema carries
+     * both. The alias forwards rather than being the implementation, so there is
+     * one body to be wrong.
+     *
+     * @returns {boolean} Whether the ambient context has a live backend.
+     */
+    DoesD3DDeviceExist() {
+      return this.DeviceExists();
+    }
+
+    /**
+     * Releases the device's resources and the ambient render context with it
+     * (`TriDevice.cpp:480-487`).
+     *
+     * @returns {TriDevice} This device.
+     */
+    DestroyRenderContext() {
+      if (this.DeviceExists()) {
+        this.ReleaseDeviceResources(TriStorageFlags.TRISTORAGE_ALL);
+        _Tr2RenderContext.DestroyMainThreadRenderContext();
+      }
+      return this;
+    }
+
+    /**
+     * Releases every registered resource's device storage
+     * (`TriDevice.cpp:492-520`), which Carbon must do before resetting a device.
+     *
+     * @param {number} [storage] A `TriStorage` mask.
+     * @returns {TriDevice} This device.
+     */
+    ReleaseDeviceResources(storage = TriStorageFlags.TRISTORAGE_ALL) {
+      for (const resource of [..._TriDevice.#resourcesRegistered]) {
+        resource.ReleaseResources(storage);
+      }
+      return this;
+    }
+
+    /**
+     * Rebuilds every registered resource after a device comes up
+     * (`TriDevice.cpp:1038-1059`).
+     *
+     * @returns {TriDevice} This device.
+     */
+    PrepareDeviceResources() {
+      for (const resource of [..._TriDevice.#resourcesRegistered]) {
+        resource.PrepareResources();
+      }
+
+      // Carbon's second step is Tr2Renderer::PrepareDeviceResources, a STATIC
+      // that builds the blitter and the debug line set (Tr2Renderer.cpp:1273).
+      // Ours is an instance method on a renderer this device has no handle to,
+      // which is the same "Tr2Renderer is 106/106 static in Carbon" gap recorded
+      // in the wrong-shape register. Calling it optionally would be a hedge that
+      // silently does nothing, so it is named and left undone instead.
+      return this;
+    }
+
+    /**
+     * Hands the present parameters to the ambient render context
+     * (`TriDevice.cpp:1019-1037`).
+     *
+     * The early return is Carbon's: a software device with no output window has
+     * nothing to present to, and saying so is not a failure.
+     *
+     * @param {number} adapter Which adapter.
+     * @param {object} presentParameters A `Tr2PresentParametersAL`.
+     * @returns {boolean} Whether the parameters were accepted.
+     */
+    SetPresentParameters(adapter, presentParameters) {
+      if (!this.#hwnd && presentParameters.software) return true;
+      const al = Tr2RenderContext_GetMainThreadRenderContext().GetRenderContextAL();
+      const result = al ? al.SetPresentParameters(presentParameters, adapter) : ALResult.S_OK;
+      return !Failed(result);
+    }
+
+    /**
+     * Fills in the default viewport once a device exists
+     * (`TriDevice.cpp:315-338`).
+     *
+     * @returns {boolean} False when there is no device to describe.
+     */
+    InitD3DDevice() {
+      if (!this.DeviceExists()) return false;
+      const viewport = new _TriViewport();
+      viewport.__init__(0, 0, this.width, this.height, 0, 1);
+      this.viewport = viewport;
+      this.#deviceLost = false;
+      return true;
+    }
+
+    /**
+     * Creates a device and starts ticking it (`TriDevice.cpp:230-312`).
+     *
+     * THE LAST LINE IS THE POINT: `BeOS->RegisterForTicks( this, TRINITY )`. A
+     * device that was never created is never ticked, which is why the animation
+     * clock sat at zero before this existed.
+     *
+     * FULLSCREEN IS REFUSED, and that is the one genuine platform limitation
+     * here. Carbon reads the adapter's current display mode and adopts its
+     * format and refresh rate (`cpp:252-262`); a browser cannot enumerate display
+     * modes and its Fullscreen API does not change one, so there is nothing
+     * truthful to put in those fields. Windowed and adapterless creation are
+     * complete.
+     *
+     * @param {*} hwnd The output window; a canvas here.
+     * @param {number} width Back-buffer width.
+     * @param {number} height Back-buffer height.
+     * @param {number} [type] A `TriDevice.DeviceScreenType`.
+     * @param {number} [presentInterval] A `PresentInterval`.
+     * @param {number} [adapter] Which adapter.
+     * @returns {boolean} Whether a device now exists.
+     */
+    CreateSimpleDevice(hwnd, width, height, type = _TriDevice.DeviceScreenType.WINDOWED, presentInterval = this.presentationInterval, adapter = 0) {
+      // Clean out the old resources and the old device, if there is one.
+      this.DestroyRenderContext();
+      if (type === _TriDevice.DeviceScreenType.FULLSCREEN) {
+        throw new Error("TriDevice.CreateSimpleDevice cannot create a FULLSCREEN device: " + "adapter display-mode enumeration is not available in CarbonEngineJS.");
+      }
+      const pp = {
+        ...(this.#presentParam ?? {}),
+        mode: {
+          ...(this.#presentParam?.mode ?? {}),
+          width,
+          height
+        },
+        outputWindow: hwnd,
+        software: this.deviceType === _TriDevice.DeviceType.DEVICE_TYPE_SOFTWARE,
+        windowed: type === _TriDevice.DeviceScreenType.WINDOWED,
+        presentInterval,
+        variableRefreshRateSupported: this.IsVariableRefreshRateSupported()
+      };
+
+      // Carbon: CreateUpscalingTechnique( adapter ) then CreateDeviceInt. No
+      // backend here offers upscaling, and CreateDeviceInt is the abstraction
+      // layer's CreateDevice.
+      Tr2RenderContext_GetMainThreadRenderContext().GetRenderContextAL()?.CreateDevice(pp);
+      if (!this.DeviceExists()) return false;
+      this.#presentParam = pp;
+      this.width = width;
+      this.height = height;
+      this.#hwnd = hwnd;
+      this.#deviceLost = false;
+
+      // Tr2VideoAdapterInfo::AreAdaptersDifferent (cpp:288). Adapters are indices
+      // here, so the comparison is the identity Carbon's helper performs.
+      const adapterChanged = adapter !== this.adapter;
+      this.adapter = adapter;
+      if (type !== _TriDevice.DeviceScreenType.NO_ADAPTER && !this.SetPresentParameters(this.adapter, this.#presentParam)) {
+        return false;
+      }
+      if (!this.InitD3DDevice()) return false;
+      if (adapterChanged || this.supportedUpscalingTechniques.length === 0) {
+        this.UpdateAvailableUpscalingTechniques();
+      }
+      this.PrepareDeviceResources();
+      blue.os.RegisterForTicks(this, _TriDevice.TICK_COOKIE);
+      return true;
+    }
+
+    /**
+     * Adopts present parameters supplied by the application, and starts or stops
+     * ticking accordingly (`ITriDevice::SetPresentation`, `TriDevice.cpp:669-685`).
+     *
+     * Carbon's own comment is "Called from the App to set some attributes", and
+     * passing null is how the App says it is done: that branch tears the device
+     * down and unregisters it.
+     *
+     * @param {number} adapter Which adapter.
+     * @param {object|null} presentParameters A `Tr2PresentParametersAL`, or null.
+     * @returns {boolean} True, as Carbon's does unconditionally.
+     */
+    SetPresentation(adapter, presentParameters) {
+      if (presentParameters) {
+        this.adapter = adapter;
+        this.#presentParam = presentParameters;
+        this.#hwnd = presentParameters.outputWindow;
+        this.width = presentParameters.mode.width;
+        this.height = presentParameters.mode.height;
+        blue.os.RegisterForTicks(this, _TriDevice.TICK_COOKIE);
+      } else {
+        this.InvalidateAndUnregisterForTicks();
+      }
+      return true;
+    }
+
+    /**
+     * The present parameters this device holds, or null.
+     *
+     * @returns {object|null} A `Tr2PresentParametersAL`.
+     */
+    GetPresentParameters() {
+      return this.#presentParam;
+    }
+
+    /**
+     * The output window this device presents to, or null.
+     *
+     * @returns {*} The window, a canvas here.
+     */
+    GetOutputWindow() {
+      return this.#hwnd;
+    }
+
+    /**
+     * Registers a callback to run after the update, before the frame
+     * (`TriDevice.cpp:1189-1192`).
+     *
+     * @param {Function} callback The callback.
+     * @param {*} [context] Passed back to it.
+     * @returns {TriDevice} This device.
+     */
+    AddPostUpdateCallback(callback, context = null) {
+      if (typeof callback === "function") this.#postUpdateCallbacks.push({
+        callback,
+        context
+      });
+      return this;
+    }
+
+    // ==========================================================================
+    // THE TICK BODY. Source: TriDevice.cpp:840-845, TriDeviceStub.cpp:16-28.
+    // ==========================================================================
+
+    /**
+     * The simulation half of the tick (`TriDevice.cpp:444-477`): update every
+     * playing curve set, and drop the ones that finished.
+     *
+     * ITERATED OVER A COPY, as Carbon does and for the reason Carbon gives: a
+     * curve set finishing can add curve sets to this list.
+     *
+     * @param {number} realTime Time since the client started, in 100ns ticks.
+     * @param {number} simTime The same, for simulation.
+     * @returns {TriDevice} This device.
+     */
+    Update(realTime, simTime) {
+      for (const curveSet of [...this.curveSets]) {
+        curveSet.Update(realTime, simTime);
+      }
+      this.curveSets = this.curveSets.filter(curveSet => curveSet.IsPlaying());
+      return this;
+    }
+
+    /**
+     * The render half of the tick (`TriDeviceStub.cpp:16-28`).
+     *
+     * PRESENTATION IS HERE, AND IT IS BEFORE THE FRAME. The previous frame is
+     * presented at the top of THIS tick, then the new one is rendered - which is
+     * what overlaps CPU and GPU work, and why `Render` does not present.
+     *
+     * @param {number} realTime Time since the client started, in 100ns ticks.
+     * @param {number} simTime The same, for simulation.
+     * @returns {TriDevice} This device.
+     */
+    HandleRenderTick(realTime, simTime) {
+      this.#renderJobs?.RunUpdate(realTime, simTime);
+      for (const {
+        callback,
+        context
+      } of [...this.#postUpdateCallbacks]) {
+        callback(context);
+      }
+      Tr2RenderContext_GetMainThreadRenderContext().Present();
+      this.Render();
+      return this;
+    }
+
+    /**
+     * Carbon's `ISimTimeRebaseNotify` half (`TriDevice.cpp:848-851`): the
+     * simulation clock was MOVED, so carry the device's copy with it.
+     *
+     * @param {number} oldTime The simulation time before the move.
+     * @param {number} newTime The simulation time after it.
+     * @returns {TriDevice} This device.
+     */
+    OnSimClockRebase(oldTime, newTime) {
+      this.simTime += newTime - oldTime;
+      return this;
+    }
+
     /** Carbon method CreateUpscalingContext (MAP_METHOD_AND_WRAP_OPTIONAL_ARGS). */
     CreateUpscalingContext(...args) {
       throw new Error("TriDevice.CreateUpscalingContext is not implemented in CarbonEngineJS.");
@@ -193,11 +663,78 @@ new class extends _identity {
       throw new Error("TriDevice.RefreshDeviceResources is not implemented in CarbonEngineJS.");
     }
 
-    /** Carbon method Render -> PyRender (MAP_METHOD_AND_WRAP). */
-    Render(...args) {
-      throw new Error("TriDevice.Render is not implemented in CarbonEngineJS.");
+    /**
+     * The backend-neutral frame body (`TriDevice.cpp:1151-1187`).
+     *
+     * THE ORDER IS THE CONTRACT, and two parts of it are load bearing:
+     *
+     * - the bracket is ASYMMETRIC. `EndRenderContext` rewinds the per-object
+     *   pool before ending the scene, so every transient payload leased during
+     *   the frame dies inside the bracket that leased it;
+     * - PRESENTATION IS NOT HERE. The previous frame is presented at the top of
+     *   the NEXT tick, which is what overlaps CPU and GPU work.
+     *
+     * TWO CARBON STEPS ARE MISSING, and they are absent rather than reworked.
+     * `Tr2SyncToGpu::GetInstance().Tick()` has no port at all, and
+     * `Tr2GpuProfiler` exists only as a generated shell with fields and no
+     * `BeginFrame`/`EndFrame`. Both are named here so the gap is visible at the
+     * site that needs them, rather than being discovered as a silent omission.
+     *
+     * @returns {boolean} True, as Carbon's does.
+     */
+    Render() {
+      this.Throttle();
+      const renderContext = Tr2RenderContext_GetMainThreadRenderContext();
+
+      // Tr2SyncToGpu::GetInstance().Tick() belongs here - unported.
+
+      if (this.viewport) renderContext.SetViewport(this.viewport);
+
+      // Tr2GpuProfiler::GetProfiler().BeginFrame(Tr2Renderer.GetCurrentFrameCounter()) belongs here - unported.
+
+      _Tr2Renderer.BeginFrame();
+      _Tr2Renderer.BeginRenderContext();
+      _Tr2Renderer.ReserveQuadListIndexBuffer(0);
+      this.#renderJobs?.Run(this.realTime, this.simTime);
+
+      // Tr2GpuProfiler::GetProfiler().EndFrame() belongs here - unported.
+
+      _Tr2Renderer.EndRenderContext();
+      _Tr2Renderer.EndFrame();
+      return true;
     }
 
+    /**
+     * Sleeps the frame when the window is out of focus, hidden, or the machine
+     * is thermally throttled (`TriDevice.cpp:1227-1260`).
+     *
+     * @returns {void}
+     */
+    Throttle() {}
+
+    /**
+     * The render jobs the frame body runs (`TriDevice.cpp:1119-1122`).
+     *
+     * @param {object|null} renderJobs A `Tr2RenderJobs`, or null to detach.
+     * @returns {TriDevice} This device.
+     */
+    SetRenderJobs(renderJobs) {
+      this.#renderJobs = renderJobs ?? null;
+      return this;
+    }
+
+    /**
+     * The render jobs installed on this device, or null.
+     *
+     * @returns {object|null} The installed `Tr2RenderJobs`.
+     */
+    GetRenderJobs() {
+      return this.#renderJobs;
+    }
+
+    /** Carbon m_renderJobs (TriDevice.h:311). */
+    #renderJobs = null;
+
     /** Carbon method GetRenderingPlatformID (MAP_METHOD_AND_WRAP). */
     GetRenderingPlatformID(...args) {
       throw new Error("TriDevice.GetRenderingPlatformID is not implemented in CarbonEngineJS.");
@@ -208,9 +745,13 @@ new class extends _identity {
       throw new Error("TriDevice.SupportsRenderTargetFormat is not implemented in CarbonEngineJS.");
     }
 
-    /** Carbon method IsVariableRefreshRateSupported (MAP_METHOD_AND_WRAP). */
-    IsVariableRefreshRateSupported(...args) {
-      throw new Error("TriDevice.IsVariableRefreshRateSupported is not implemented in CarbonEngineJS.");
+    /**
+     * Whether the adapter supports a variable refresh rate (G-Sync, FreeSync).
+     *
+     * @returns {boolean} False.
+     */
+    IsVariableRefreshRateSupported() {
+      return false;
     }
 
     /** Carbon method SupportsRaytracing (MAP_METHOD_AND_WRAP). */
@@ -218,16 +759,6 @@ new class extends _identity {
       throw new Error("TriDevice.SupportsRaytracing is not implemented in CarbonEngineJS.");
     }
 
-    /** Carbon method DoesD3DDeviceExist -> DeviceExists (MAP_METHOD_AND_WRAP). */
-    DoesD3DDeviceExist(...args) {
-      throw new Error("TriDevice.DoesD3DDeviceExist is not implemented in CarbonEngineJS.");
-    }
-
-    /** Carbon method SetRenderJobs (MAP_METHOD_AND_WRAP). */
-    SetRenderJobs(...args) {
-      throw new Error("TriDevice.SetRenderJobs is not implemented in CarbonEngineJS.");
-    }
-
     /** Carbon method SetUpscaling (MAP_METHOD_AND_WRAP). */
     SetUpscaling(...args) {
       throw new Error("TriDevice.SetUpscaling is not implemented in CarbonEngineJS.");
@@ -238,9 +769,15 @@ new class extends _identity {
       throw new Error("TriDevice.GetRenderContext is not implemented in CarbonEngineJS.");
     }
 
-    /** Carbon method UpdateAvailableUpscalingTechniques (MAP_METHOD_AND_WRAP). */
-    UpdateAvailableUpscalingTechniques(...args) {
-      throw new Error("TriDevice.UpdateAvailableUpscalingTechniques is not implemented in CarbonEngineJS.");
+    /**
+     * Refreshes the list of upscaling techniques this adapter offers
+     * (`TriDevice.cpp:1330` and the DX12 backends).
+     *
+     * @returns {TriDevice} This device.
+     */
+    UpdateAvailableUpscalingTechniques() {
+      this.supportedUpscalingTechniques = [];
+      return this;
     }
 
     /** One hour - the animation-clock recenter period. */
@@ -263,6 +800,8 @@ new class extends _identity {
     APP_ACTIVATED: 0,
     APP_DEACTIVATED: 1
   });
+  TICK_COOKIE = "Trinity";
+  #resourcesRegistered = new Set();
   ANIMATION_TIME_MAX = 3600;
   PresentInterval = PresentInterval;
   SwapEffect = SwapEffect;