@downdraft/engine 0.1.1 → 0.2.0

package/dist/core/src/physics/realm-manager.js

@@ -0,0 +1,431 @@
+import { RealmTier } from "./interface.js";
+import { PhysicsRealm } from "./realm.js";
+const DEFAULT_NEAR_CONFIG = {
+    tickFrequency: 1,
+    solverIterations: 4,
+    promoteThreshold: 50,
+    demoteThreshold: 60,
+    demoteDwellTime: 1,
+};
+const DEFAULT_MID_CONFIG = {
+    tickFrequency: 2,
+    solverIterations: 2,
+    promoteThreshold: 120,
+    demoteThreshold: 150,
+    demoteDwellTime: 2,
+};
+const DEFAULT_FAR_CONFIG = {
+    tickFrequency: 6,
+    solverIterations: 1,
+    promoteThreshold: Infinity,
+    demoteThreshold: Infinity,
+    demoteDwellTime: 5,
+};
+/**
+ * Manages three physics realm tiers (near/mid/far) with LOD-based body
+ * transfers. Promotes bodies immediately when they approach a higher-fidelity
+ * realm; demotes after a configurable dwell time (hysteresis).
+ *
+ * Static bodies are duplicated into all three realms by default so they
+ * collide correctly in every tier without transfer overhead.
+ */
+export class RealmManager {
+    realms = new Map();
+    tierConfigs = new Map();
+    /** All tracked bodies keyed by stable RealmManager bodyId. */
+    bodies = new Map();
+    /** Reverse lookup: PhysicsBody.id (backend id) → stable bodyId. */
+    bodyIdByBackendId = new Map();
+    /** Monotonic body-id allocator (stable across transfers). */
+    nextBodyId = 1;
+    transferHook = null;
+    duplicateStatics;
+    tickCount = 0;
+    pendingTransfers = [];
+    constructor(config) {
+        this.duplicateStatics = config.duplicateStatics ?? true;
+        const nearTierConfig = config.nearConfig.tierConfig ?? DEFAULT_NEAR_CONFIG;
+        const midTierConfig = config.midConfig.tierConfig ?? DEFAULT_MID_CONFIG;
+        const farTierConfig = config.farConfig.tierConfig ?? DEFAULT_FAR_CONFIG;
+        this.tierConfigs.set(RealmTier.Near, nearTierConfig);
+        this.tierConfigs.set(RealmTier.Mid, midTierConfig);
+        this.tierConfigs.set(RealmTier.Far, farTierConfig);
+        const nearRealm = new PhysicsRealm(config.backend, {
+            ...config.nearConfig,
+            tier: RealmTier.Near,
+            tierConfig: nearTierConfig,
+        });
+        const midRealm = new PhysicsRealm(config.backend, {
+            ...config.midConfig,
+            tier: RealmTier.Mid,
+            tierConfig: midTierConfig,
+        });
+        const farRealm = new PhysicsRealm(config.backend, {
+            ...config.farConfig,
+            tier: RealmTier.Far,
+            tierConfig: farTierConfig,
+        });
+        this.realms.set(RealmTier.Near, nearRealm);
+        this.realms.set(RealmTier.Mid, midRealm);
+        this.realms.set(RealmTier.Far, farRealm);
+        // Apply solver iterations per tier
+        nearRealm.setSolverIterations(nearTierConfig.solverIterations);
+        midRealm.setSolverIterations(midTierConfig.solverIterations);
+        farRealm.setSolverIterations(farTierConfig.solverIterations);
+        // Use small islands so clusters of props can sleep independently.
+        // Rapier default is 128 (large monolithic islands); 16 lets small
+        // groups settle and sleep without waiting for the whole scene.
+        nearRealm.setMinIslandSize(16);
+        midRealm.setMinIslandSize(16);
+        farRealm.setMinIslandSize(16);
+    }
+    getRealm(tier) {
+        const r = this.realms.get(tier);
+        if (!r)
+            throw new Error(`Realm for tier ${tier} not found`);
+        return r;
+    }
+    getRealmForBody(body) {
+        // Look up by the current body ref first, then fall back to searching
+        const meta = this.findBodyMeta(body);
+        return meta ? meta.tier : RealmTier.Near;
+    }
+    getBodyMetadata(body) {
+        return this.findBodyMeta(body);
+    }
+    /**
+     * Find body metadata by PhysicsBody reference. Uses reverse lookup
+     * by backend body id; falls back to linear search for static copies.
+     */
+    findBodyMeta(body) {
+        // Fast path: reverse lookup by backend body id
+        const bodyId = this.bodyIdByBackendId.get(body.id);
+        if (bodyId !== undefined) {
+            const meta = this.bodies.get(bodyId);
+            if (meta)
+                return meta;
+        }
+        // Fallback: search static copies (they have different backend ids)
+        for (const meta of this.bodies.values()) {
+            if (meta.staticCopies) {
+                for (const copy of meta.staticCopies.values()) {
+                    if (copy.id === body.id && copy.realmId === body.realmId)
+                        return meta;
+                }
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Register a new body. Dynamic bodies are placed in the near realm by
+     * default (or the realm matching their `importance`). Static bodies are
+     * duplicated into all three realms when `duplicateStatics` is true.
+     */
+    registerBody(entity, desc, importance = 0) {
+        const bodyId = this.nextBodyId++;
+        const isStatic = desc.type === "static";
+        const initialTier = isStatic ? RealmTier.Near : RealmTier.Near;
+        const primaryRealm = this.getRealm(initialTier);
+        const body = primaryRealm.createBody(desc, entity);
+        const meta = {
+            bodyId,
+            entity,
+            tier: initialTier,
+            importance,
+            dwellTimer: 0,
+            lastTransferTick: this.tickCount,
+            desc,
+            colliders: [],
+            body,
+            isStatic,
+        };
+        if (isStatic && this.duplicateStatics) {
+            const copies = new Map();
+            copies.set(initialTier, body);
+            [RealmTier.Mid, RealmTier.Far].forEach((tier) => {
+                const r = this.getRealm(tier);
+                copies.set(tier, r.createBody(desc, entity));
+            });
+            meta.staticCopies = copies;
+        }
+        this.bodies.set(bodyId, meta);
+        this.bodyIdByBackendId.set(body.id, bodyId);
+        return body;
+    }
+    unregisterBody(body) {
+        const meta = this.findBodyMeta(body);
+        if (!meta)
+            return;
+        if (meta.staticCopies) {
+            for (const [tier, copy] of meta.staticCopies.entries()) {
+                this.getRealm(tier).destroyBody(copy);
+                this.bodyIdByBackendId.delete(copy.id);
+            }
+        }
+        else {
+            this.getRealm(meta.tier).destroyBody(meta.body);
+            this.bodyIdByBackendId.delete(meta.body.id);
+        }
+        this.bodies.delete(meta.bodyId);
+    }
+    addCollider(body, desc) {
+        const meta = this.findBodyMeta(body);
+        if (!meta)
+            return -1;
+        let colliderId = -1;
+        if (meta.staticCopies) {
+            // Add to all copies; return the near-realm collider id as canonical
+            for (const [tier, copy] of meta.staticCopies.entries()) {
+                const id = this.getRealm(tier).addCollider(copy, desc);
+                if (tier === meta.tier)
+                    colliderId = id;
+            }
+        }
+        else {
+            colliderId = this.getRealm(meta.tier).addCollider(meta.body, desc);
+        }
+        if (colliderId >= 0)
+            meta.colliders.push({ id: colliderId, desc });
+        return colliderId;
+    }
+    /**
+     * Remove a collider from a body (and all static copies).
+     * The collider is removed from the `colliders` metadata array too.
+     */
+    removeCollider(body, colliderId) {
+        const meta = this.findBodyMeta(body);
+        if (!meta)
+            return;
+        if (meta.staticCopies) {
+            // Remove from each copy's own realm. Collider ids may differ per realm;
+            // the backend handles missing ids gracefully (no-op if not found).
+            for (const [tier, copy] of meta.staticCopies.entries()) {
+                this.getRealm(tier).removeCollider(copy, colliderId);
+            }
+        }
+        else {
+            this.getRealm(meta.tier).removeCollider(meta.body, colliderId);
+        }
+        // Remove from metadata by canonical id
+        const idx = meta.colliders.findIndex((c) => c.id === colliderId);
+        if (idx >= 0)
+            meta.colliders.splice(idx, 1);
+    }
+    setImportance(body, importance) {
+        const meta = this.findBodyMeta(body);
+        if (meta)
+            meta.importance = importance;
+    }
+    setTransferHook(hook) {
+        this.transferHook = hook;
+    }
+    /**
+     * Per-frame realm membership update. Computes the minimum distance from
+     * each dynamic body to any player camera and promotes/demotes as needed.
+     *
+     * Promotion is immediate (with swept-position prediction). Demotion is
+     * debounced by `demoteDwellTime` (hysteresis).
+     */
+    updateRealmMembership(playerCameras, dt) {
+        if (playerCameras.length === 0)
+            return;
+        for (const meta of this.bodies.values()) {
+            if (meta.isStatic)
+                continue;
+            const realm = this.getRealm(meta.tier);
+            const pos = realm.getPosition(meta.body);
+            const vel = realm.getLinearVelocity(meta.body);
+            // Swept / predicted position (look-ahead to promote fast-approaching bodies)
+            const predicted = [
+                pos[0] + vel[0] * dt,
+                pos[1] + vel[1] * dt,
+                pos[2] + vel[2] * dt,
+            ];
+            let minDist = Infinity;
+            playerCameras.forEach((cam) => {
+                const dx = predicted[0] - cam[0];
+                const dy = predicted[1] - cam[1];
+                const dz = predicted[2] - cam[2];
+                const d = Math.sqrt(dx * dx + dy * dy + dz * dz);
+                if (d < minDist)
+                    minDist = d;
+            });
+            // Promotion: immediate if within a higher tier's promote threshold
+            const higherTier = this.nextHigherTier(meta.tier);
+            if (higherTier !== null) {
+                const higherConfig = this.getRealm(higherTier);
+                const promoteThreshold = this.getTierConfig(higherTier).promoteThreshold;
+                if (minDist < promoteThreshold) {
+                    // Allow hook to override
+                    let targetTier = higherTier;
+                    if (this.transferHook?.shouldTransfer) {
+                        let override = this.transferHook.shouldTransfer(meta.bodyId, meta.tier, [minDist]);
+                        if (override !== null && ![0, 1, 2].includes(override))
+                            override = null;
+                        if (override !== null)
+                            targetTier = override;
+                    }
+                    if (targetTier !== null && targetTier !== meta.tier) {
+                        this.scheduleTransfer(meta, targetTier);
+                        continue;
+                    }
+                }
+            }
+            // Demotion: debounced by dwell time (hysteresis)
+            const demoteThreshold = this.getTierConfig(meta.tier).demoteThreshold;
+            if (minDist > demoteThreshold) {
+                meta.dwellTimer += dt;
+                const dwellRequired = this.getTierConfig(meta.tier).demoteDwellTime;
+                if (meta.dwellTimer >= dwellRequired) {
+                    const lowerTier = this.nextLowerTier(meta.tier);
+                    if (lowerTier !== null) {
+                        let targetTier = lowerTier;
+                        if (this.transferHook?.shouldTransfer) {
+                            let override = this.transferHook.shouldTransfer(meta.bodyId, meta.tier, [minDist]);
+                            if (override !== null && ![0, 1, 2].includes(override))
+                                override = null;
+                            if (override !== null)
+                                targetTier = override;
+                        }
+                        if (targetTier !== null && targetTier !== meta.tier) {
+                            this.scheduleTransfer(meta, targetTier);
+                        }
+                    }
+                }
+            }
+            else {
+                // Inside threshold — reset dwell timer
+                meta.dwellTimer = 0;
+            }
+        }
+        this.flushTransfers();
+    }
+    /**
+     * Step all realms at their respective tick frequencies.
+     * `tickCount` is incremented once per call.
+     */
+    step(dt) {
+        this.tickCount++;
+        const nearConfig = this.getTierConfig(RealmTier.Near);
+        const midConfig = this.getTierConfig(RealmTier.Mid);
+        const farConfig = this.getTierConfig(RealmTier.Far);
+        // Near: every tick
+        this.getRealm(RealmTier.Near).step(dt);
+        // Mid: every tickFrequency-th tick
+        if (midConfig.tickFrequency > 0 && this.tickCount % midConfig.tickFrequency === 0) {
+            this.getRealm(RealmTier.Mid).step(dt);
+        }
+        // Far: every tickFrequency-th tick
+        if (farConfig.tickFrequency > 0 && this.tickCount % farConfig.tickFrequency === 0) {
+            this.getRealm(RealmTier.Far).step(dt);
+        }
+    }
+    getTickCount() {
+        return this.tickCount;
+    }
+    getBodyCount() {
+        return this.bodies.size;
+    }
+    getFrozenCount() {
+        return 0; // Tracked by LoadShedder (Phase 5)
+    }
+    destroy() {
+        for (const realm of this.realms.values()) {
+            realm.destroy();
+        }
+        this.realms.clear();
+        this.bodies.clear();
+        this.bodyIdByBackendId.clear();
+        this.pendingTransfers = [];
+    }
+    // --- Private helpers ---
+    getTierConfig(tier) {
+        const cfg = this.tierConfigs.get(tier);
+        if (cfg)
+            return cfg;
+        switch (tier) {
+            case RealmTier.Near: return DEFAULT_NEAR_CONFIG;
+            case RealmTier.Mid: return DEFAULT_MID_CONFIG;
+            case RealmTier.Far: return DEFAULT_FAR_CONFIG;
+            default: return DEFAULT_NEAR_CONFIG;
+        }
+    }
+    nextHigherTier(tier) {
+        if (tier === RealmTier.Mid)
+            return RealmTier.Near;
+        if (tier === RealmTier.Far)
+            return RealmTier.Mid;
+        return null; // Already at near
+    }
+    nextLowerTier(tier) {
+        if (tier === RealmTier.Near)
+            return RealmTier.Mid;
+        if (tier === RealmTier.Mid)
+            return RealmTier.Far;
+        return null; // Already at far
+    }
+    scheduleTransfer(meta, toTier) {
+        // Avoid duplicate scheduling
+        const existing = this.pendingTransfers.find((p) => p.meta === meta);
+        if (existing) {
+            existing.toTier = toTier;
+        }
+        else {
+            this.pendingTransfers.push({ meta, toTier });
+        }
+    }
+    flushTransfers() {
+        if (this.pendingTransfers.length === 0)
+            return;
+        for (let _i = 0, _it = this.pendingTransfers, _n = _it.length; _i < _n; _i++) {
+            const { meta, toTier } = _it[_i];
+            if (meta.tier === toTier)
+                continue;
+            this.transferBody(meta, toTier);
+        }
+        this.pendingTransfers = [];
+    }
+    transferBody(meta, toTier) {
+        const fromRealm = this.getRealm(meta.tier);
+        const toRealm = this.getRealm(toTier);
+        // Read current state from the old realm
+        const pos = fromRealm.getPosition(meta.body);
+        const rot = fromRealm.getRotation(meta.body);
+        const linVel = fromRealm.getLinearVelocity(meta.body);
+        const angVel = fromRealm.getAngularVelocity(meta.body);
+        // Destroy from old realm
+        const oldBody = meta.body;
+        fromRealm.destroyBody(meta.body);
+        // Delete the old backend id from the reverse lookup so stale refs
+        // don't accidentally resolve to this metadata via the old id.
+        this.bodyIdByBackendId.delete(oldBody.id);
+        // Recreate in new realm with current state
+        const newDesc = {
+            ...meta.desc,
+            position: pos,
+            rotation: rot,
+            linearVelocity: linVel,
+            angularVelocity: angVel,
+        };
+        const newBody = toRealm.createBody(newDesc, meta.entity);
+        // Re-add colliders
+        meta.colliders.forEach(({ desc: colliderDesc }) => {
+            toRealm.addCollider(newBody, colliderDesc);
+        });
+        // Update metadata + reverse lookup (add new backend id)
+        const fromTier = meta.tier;
+        meta.body = newBody;
+        meta.tier = toTier;
+        meta.dwellTimer = 0;
+        meta.lastTransferTick = this.tickCount;
+        this.bodyIdByBackendId.set(newBody.id, meta.bodyId);
+        // Invoke hooks
+        const promoted = toTier < fromTier; // Near=0 < Mid=1 < Far=2
+        if (promoted) {
+            this.transferHook?.onPromote?.(meta.bodyId, fromTier, toTier);
+        }
+        else {
+            this.transferHook?.onDemote?.(meta.bodyId, fromTier, toTier);
+        }
+    }
+}

package/dist/core/src/physics/realm-worker-pool.js

@@ -0,0 +1,181 @@
+import { RealmTier } from "./interface.js";
+import { RealmWorker, supportsNestedWorkers, supportsSharedArrayBuffer } from "./realm-worker.js";
+/**
+ * Pool of realm workers for parallel mid/far realm simulation.
+ *
+ * The near realm always runs on the sim thread (tightest latency).
+ * Mid/far realms are delegated to workers when `workerCount > 0`.
+ *
+ * `workerCount: 0` = single-threaded fallback (all realms on sim thread).
+ */
+export class RealmWorkerPool {
+    workers = new Map();
+    workerUrl;
+    workerCount;
+    useSharedBuffer;
+    initialized = false;
+    constructor(opts) {
+        this.workerUrl = opts.workerUrl;
+        this.workerCount = opts.workerCount ?? 0;
+        this.useSharedBuffer = supportsSharedArrayBuffer() && supportsNestedWorkers();
+    }
+    isInitialized() {
+        return this.initialized;
+    }
+    isParallel() {
+        return this.workers.size > 0;
+    }
+    supportsSharedBuffer() {
+        return this.useSharedBuffer;
+    }
+    /**
+     * Initialize workers for mid/far realms. Returns true if workers are
+     * available; false if single-threaded fallback should be used.
+     */
+    async init() {
+        if (this.workerCount === 0) {
+            this.initialized = true;
+            return false;
+        }
+        if (!supportsNestedWorkers()) {
+            // Single-threaded fallback
+            this.initialized = true;
+            return false;
+        }
+        try {
+            // Create one worker per tier (mid, far) up to workerCount
+            const tiers = [RealmTier.Mid, RealmTier.Far];
+            for (let i = 0; i < Math.min(this.workerCount, tiers.length); i++) {
+                const tier = tiers[i];
+                const worker = new RealmWorker(this.workerUrl, tier);
+                this.workers.set(tier, worker);
+            }
+            this.initialized = true;
+            return this.workers.size > 0;
+        }
+        catch {
+            this.initialized = true;
+            return false;
+        }
+    }
+    hasWorkerForTier(tier) {
+        return this.workers.has(tier);
+    }
+    getWorker(tier) {
+        return this.workers.get(tier);
+    }
+    /**
+     * Initialize a realm on the appropriate worker.
+     */
+    async initRealm(tier, realmId, gravity) {
+        const worker = this.workers.get(tier);
+        if (!worker)
+            return false;
+        worker.addRealm(realmId);
+        const req = { type: "INIT_REALM", realmId, tier, gravity };
+        await worker.request(req);
+        return true;
+    }
+    /**
+     * Step a realm on its worker. Returns the wall time in ms, or 0 if
+     * no worker is available (caller should step in-process).
+     */
+    async stepRealm(tier, realmId, dt, solverIterations) {
+        const worker = this.workers.get(tier);
+        if (!worker || !worker.hasRealm(realmId))
+            return 0;
+        const req = { type: "STEP_REALM", realmId, dt, solverIterations };
+        const resp = await worker.request(req);
+        if (resp.type === "STEP_RESULT")
+            return resp.wallTimeMs;
+        return 0;
+    }
+    /**
+     * Create a body on the worker for the given realm.
+     */
+    async createBody(tier, realmId, bodyId, desc, entity) {
+        const worker = this.workers.get(tier);
+        if (!worker)
+            return false;
+        const req = { type: "CREATE_BODY", realmId, bodyId, desc, entity };
+        const resp = await worker.request(req);
+        return resp.type === "CREATE_BODY_RESULT" && resp.success;
+    }
+    /**
+     * Destroy a body on the worker.
+     */
+    async destroyBody(tier, realmId, bodyId) {
+        const worker = this.workers.get(tier);
+        if (!worker)
+            return;
+        const req = { type: "DESTROY_BODY", realmId, bodyId };
+        await worker.request(req);
+    }
+    /**
+     * Add a collider on the worker.
+     */
+    async addCollider(tier, realmId, bodyId, colliderId, desc) {
+        const worker = this.workers.get(tier);
+        if (!worker)
+            return false;
+        const req = { type: "ADD_COLLIDER", realmId, bodyId, colliderId, desc };
+        const resp = await worker.request(req);
+        return resp.type === "ADD_COLLIDER_RESULT" && resp.success;
+    }
+    /**
+     * Read transforms from the worker into the provided buffer.
+     * The buffer is transferred to the worker and back.
+     */
+    async readTransforms(tier, realmId, buffer, entityCount) {
+        const worker = this.workers.get(tier);
+        if (!worker)
+            return buffer;
+        const req = { type: "READ_TRANSFORMS", realmId, buffer, entityCount };
+        const resp = await worker.request(req, [buffer.buffer]);
+        if (resp.type === "READ_TRANSFORMS_RESULT")
+            return resp.buffer;
+        return buffer;
+    }
+    /**
+     * Snapshot a realm on the worker.
+     */
+    async snapshotRealm(tier, realmId) {
+        const worker = this.workers.get(tier);
+        if (!worker)
+            return null;
+        const req = { type: "SNAPSHOT_REALM", realmId };
+        const resp = await worker.request(req);
+        if (resp.type === "SNAPSHOT_RESULT")
+            return resp.data;
+        return null;
+    }
+    /**
+     * Restore a realm on the worker from snapshot data.
+     */
+    async restoreRealm(tier, realmId, data) {
+        const worker = this.workers.get(tier);
+        if (!worker)
+            return false;
+        const req = { type: "RESTORE_REALM", realmId, data };
+        const resp = await worker.request(req, [data.buffer]);
+        return resp.type === "RESTORE_REALM_RESULT" && resp.success;
+    }
+    /**
+     * Destroy a realm on the worker.
+     */
+    async destroyRealm(tier, realmId) {
+        const worker = this.workers.get(tier);
+        if (!worker)
+            return;
+        worker.removeRealm(realmId);
+        const req = { type: "DESTROY_REALM", realmId };
+        await worker.request(req);
+    }
+    destroy() {
+        for (const worker of this.workers.values()) {
+            worker.terminate();
+        }
+        this.workers.clear();
+        this.initialized = false;
+    }
+}

package/dist/core/src/physics/realm-worker.js

@@ -0,0 +1,91 @@
+/**
+ * Wraps a single Web Worker that owns one or more physics realm `World`
+ * instances. The host communicates via postMessage; transform buffers are
+ * transferred (not copied) where possible.
+ *
+ * If `SharedArrayBuffer` is available, transform buffers can be shared
+ * between host and worker (zero-copy reads). Otherwise, buffers are
+ * transferred back and forth.
+ */
+export class RealmWorker {
+    worker;
+    nextRequestId = 0;
+    pending = new Map();
+    realmIds = new Set();
+    tier;
+    constructor(workerUrl, tier) {
+        this.tier = tier;
+        this.worker = new Worker(workerUrl, { type: "module" });
+        this.worker.onmessage = (e) => {
+            const resp = e.data;
+            if (resp.requestId !== undefined) {
+                const pending = this.pending.get(resp.requestId);
+                if (pending) {
+                    this.pending.delete(resp.requestId);
+                    pending.resolve(resp);
+                }
+            }
+        };
+        this.worker.onerror = (e) => {
+            // Reject all pending requests on error
+            for (const [, pending] of this.pending.entries()) {
+                pending.reject(new Error(`Worker error: ${e.message}`));
+            }
+            this.pending.clear();
+        };
+    }
+    hasRealm(realmId) {
+        return this.realmIds.has(realmId);
+    }
+    addRealm(realmId) {
+        this.realmIds.add(realmId);
+    }
+    removeRealm(realmId) {
+        this.realmIds.delete(realmId);
+    }
+    /**
+     * Send a request to the worker and await the response.
+     * Transferable buffers are transferred (not copied).
+     */
+    request(req, transfer = []) {
+        const requestId = this.nextRequestId++;
+        return new Promise((resolve, reject) => {
+            this.pending.set(requestId, { resolve, reject });
+            this.worker.postMessage({ ...req, requestId }, transfer);
+        });
+    }
+    /**
+     * Send a fire-and-forget message (no response expected).
+     */
+    notify(req, transfer = []) {
+        this.worker.postMessage(req, transfer);
+    }
+    terminate() {
+        this.worker.terminate();
+        for (const [, pending] of this.pending.entries()) {
+            pending.reject(new Error("Worker terminated"));
+        }
+        this.pending.clear();
+        this.realmIds.clear();
+    }
+}
+/**
+ * Checks if SharedArrayBuffer is available (requires COOP/COEP headers).
+ */
+export function supportsSharedArrayBuffer() {
+    return typeof SharedArrayBuffer !== "undefined";
+}
+/**
+ * Checks if nested Web Workers are supported (creating a Worker from within
+ * another Worker). Not every worker host allows this.
+ */
+export function supportsNestedWorkers() {
+    try {
+        // We can't fully test without creating a worker, but we can check
+        // that the Worker constructor exists in the current context.
+        return typeof Worker !== "undefined";
+    }
+    catch {
+        return false;
+    }
+}