@downdraft/engine 0.0.0 → 0.1.1

package/core/src/plugin/context.ts

@@ -0,0 +1,364 @@
+// ============================================================================
+// Plugin context — the tiered capability surface exposed to a plugin.
+//
+// A plugin's `register(ctx)` receives a context whose shape depends on its
+// declared tier:
+//   - `data`   → no context (asset plugins just register assets at load).
+//   - `script` → ScriptPluginContext (events + KV state + tick + log).
+//   - `native` → NativePluginContext (extends ModuleContext-shape: ECS
+//                systems/components, typed-token provide/inject, SAB channels,
+//                onDispose, devtools). GPU/render-pass access is deferred.
+//
+// The host constructs the appropriate facade and the TypeScript types ensure
+// a script-tier plugin literally cannot call native-only APIs (the methods
+// aren't on the narrower type). At runtime the facade simply doesn't expose
+// them.
+//
+// For worker-js / wasm / quickjs plugins that run off-thread or in a VM,
+// `ctx` is a `MessageChannel`- / marshal-backed proxy to the host's real
+// context object. The interfaces below are the contract both sides share.
+// ============================================================================
+
+import type { ComponentId } from "../ecs/component";
+import type { ResourceToken } from "../ecs/resource";
+import type { Stage, SystemFn } from "../ecs/system";
+import type { ModuleDevToolsAPI, SABChannel } from "../module/module";
+import type { PluginPermission } from "./manifest";
+
+// ── Event bus ──
+
+/**
+ * Game-defined event catalog. A game publishes a set of named events with
+ * typed payloads that plugins may subscribe to / publish. The host validates
+ * event names against this catalog (if provided) and rejects unknown events.
+ */
+export type PluginEventCatalog = Record<string, unknown>;
+
+export type PluginEventHandler<E = unknown> = (data: E) => void;
+
+export interface PluginEventBus {
+  subscribe<E>(event: string, handler: PluginEventHandler<E>): () => void;
+  publish<E>(event: string, data: E): void;
+}
+
+// ── Per-plugin KV state store ──
+
+export interface PluginStateStore {
+  get<T = unknown>(key: string): T | undefined;
+  set<T>(key: string, value: T): void;
+  delete(key: string): void;
+  keys(): string[];
+  /** Persist current state to OPFS (only if `storage` permission granted). */
+  save(): Promise<void>;
+  /** Reload persisted state. */
+  load(): Promise<void>;
+}
+
+// ── Logger ──
+
+export interface PluginLogger {
+  info(msg: string, ...args: unknown[]): void;
+  warn(msg: string, ...args: unknown[]): void;
+  error(msg: string, ...args: unknown[]): void;
+  debug(msg: string, ...args: unknown[]): void;
+}
+
+// ── Tick budget ──
+
+/**
+ * Register a per-frame tick callback. The host enforces a per-tick time
+ * budget (worker-js: setTimeout watchdog; quickjs: interrupt handler). A
+ * callback that overruns its budget is terminated and the plugin is unloaded
+ * with an error reported to the doctor panel.
+ */
+export interface PluginTickApi {
+  onTick(fn: (dt: number, elapsedTime: number) => void): () => void;
+}
+
+// ── Script tier context ──
+
+export interface ScriptPluginContext {
+  readonly id: string;
+  readonly events: PluginEventBus;
+  readonly state: PluginStateStore;
+  readonly tick: PluginTickApi;
+  readonly log: PluginLogger;
+  onDispose(fn: () => void): void;
+}
+
+// ── Host-call bridge (game mutation API) ──
+//
+// Logic extensions (worker-js / wasm) mutate the game through a set of bridged
+// host calls rather than touching renderer/sim internals directly. The game
+// implements `PluginHostCalls` and injects it into the PluginHost; the host
+// exposes the methods on `NativePluginContext`. Each call is gated by a
+// permission (physics / assets / ecs). The bridge is game-agnostic — the host
+// just forwards to the injected implementation.
+
+/** A spawned prop descriptor (returned by spawnProp). */
+export interface SpawnedProp {
+  entityId: number;
+}
+
+/** Descriptor for spawning a prop via host call. */
+export interface SpawnPropDesc {
+  /** Content id of the prop to spawn (e.g. "my-mod:crate"). */
+  contentId: string;
+  /** World position [x, y, z]. */
+  position: [number, number, number];
+  /** Optional rotation quaternion [x, y, z, w]. Default: identity. */
+  rotation?: [number, number, number, number];
+  /** Optional scale. Default: 1. */
+  scale?: number;
+}
+
+/** Descriptor for setting physics properties on a body. */
+export interface PhysicsDesc {
+  mass: number;
+  restitution: number;
+  friction: number;
+  gravityScale: number;
+}
+
+/** The game-implemented host-call bridge. Injected into PluginHostOptions.
+ *  All methods are optional — a game that doesn't support physics mutation
+ *  simply omits them, and the host throws a clear error if a plugin calls one. */
+export interface PluginHostCalls {
+  /** Spawn a prop by content id at a world transform. Returns the entity id.
+   *  Requires the `assets` + `ecs` permissions. */
+  spawnProp?(desc: SpawnPropDesc): Promise<SpawnedProp>;
+  /** Remove a spawned prop by entity id. Requires `ecs`. */
+  removeProp?(entityId: number): Promise<void>;
+  /** Set physics properties on a body. Requires `physics`. */
+  setPhysics?(entityId: number, desc: Partial<PhysicsDesc>): Promise<void>;
+  /** Get physics properties of a body. Requires `physics`. */
+  getPhysics?(entityId: number): Promise<PhysicsDesc>;
+  /** Apply a linear impulse to a body. Requires `physics`. */
+  applyImpulse?(entityId: number, impulse: [number, number, number]): Promise<void>;
+  /** Apply a torque to a body. Requires `physics`. */
+  applyTorque?(entityId: number, torque: [number, number, number]): Promise<void>;
+  /** Resolve an asset id to an opaque handle the plugin can pass back to host
+   *  calls. Requires `assets`. The handle is a stable integer. */
+  getAssetRef?(assetId: string): Promise<number>;
+}
+
+// ── Native tier context ──
+//
+// Mirrors ModuleContext (ECS + typed DI + SAB + devtools + dispose) so a
+// native plugin can register systems, provide/inject typed tokens, and
+// allocate SAB channels exactly like a compile-time module. The host bridges
+// these calls into the real ModuleHost on the plugin's thread.
+//
+// Also exposes the host-call bridge (spawnProp, setPhysics, etc.) for game
+// mutation. These are gated by permissions and forwarded to the game's
+// PluginHostCalls implementation.
+
+export interface NativePluginContext extends ScriptPluginContext {
+  registerComponent<T>(name: string, schema: T): ComponentId;
+  registerSystem(stage: Stage, system: SystemFn): void;
+  allocateSABChannel(name: string, size: number): SABChannel;
+  provide<T>(token: ResourceToken<T>, value: T): void;
+  inject<T>(token: ResourceToken<T>): T;
+  injectOptional<T>(token: ResourceToken<T>): T | undefined;
+  readonly devtools: ModuleDevToolsAPI;
+  // ── Host-call bridge (game mutation) ──
+  spawnProp(desc: SpawnPropDesc): Promise<SpawnedProp>;
+  removeProp(entityId: number): Promise<void>;
+  setPhysics(entityId: number, desc: Partial<PhysicsDesc>): Promise<void>;
+  getPhysics(entityId: number): Promise<PhysicsDesc>;
+  applyImpulse(entityId: number, impulse: [number, number, number]): Promise<void>;
+  applyTorque(entityId: number, torque: [number, number, number]): Promise<void>;
+  getAssetRef(assetId: string): Promise<number>;
+}
+
+// ── Plugin definition (the shape a plugin's entry module exports) ──
+
+export type PluginRegisterFn<C extends ScriptPluginContext = ScriptPluginContext> = (
+  ctx: C,
+) => void | Promise<void>;
+
+/**
+ * A plugin's entry module default-exports this (or the module itself is the
+ * function). The host calls `register(ctx)` after sandboxing + context setup.
+ *
+ * For `native` tier the host passes a `NativePluginContext`; for `script`
+ * tier a `ScriptPluginContext`. The plugin author types its entry against the
+ * tier it declared.
+ */
+export interface PluginEntry<C extends ScriptPluginContext = ScriptPluginContext> {
+  register: PluginRegisterFn<C>;
+  /** Optional: declare resources this plugin provides/requires at the typed
+   *  token level (in addition to the stringly-typed manifest provides/requires). */
+  provides?: ResourceToken<unknown>[];
+  requires?: ResourceToken<unknown>[];
+}
+
+// ── Tiered facade factory ──
+//
+// The host builds the appropriate context object. These factory signatures
+// let the host code stay type-safe while returning the narrower type for
+// script-tier plugins.
+
+export interface PluginContextBacking {
+  id: string;
+  events: PluginEventBus;
+  state: PluginStateStore;
+  tick: PluginTickApi;
+  log: PluginLogger;
+  // native-only backing (undefined for script tier):
+  registerComponent?: <T>(name: string, schema: T) => ComponentId;
+  registerSystem?: (stage: Stage, system: SystemFn) => void;
+  allocateSABChannel?: (name: string, size: number) => SABChannel;
+  provide?: <T>(token: ResourceToken<T>, value: T) => void;
+  inject?: <T>(token: ResourceToken<T>) => T;
+  injectOptional?: <T>(token: ResourceToken<T>) => T | undefined;
+  devtools?: ModuleDevToolsAPI;
+  // host-call bridge (game mutation). Undefined when the game didn't inject
+  // a PluginHostCalls impl; calling a host-call method then throws.
+  hostCalls?: PluginHostCalls;
+  onDispose: (fn: () => void) => void;
+}
+
+// ── Permission gating ──
+//
+// When the host passes a `granted` permission set, context APIs the plugin
+// didn't request are replaced with throwing stubs (matching the sandbox
+// shim's trap style: clear error naming the missing permission). When
+// `granted` is undefined the context is ungated — used by tests and by
+// first-party in-process callers that bypass the permission system.
+
+function permError(apiName: string, perm: PluginPermission, pluginId: string): Error {
+  return new Error(
+    `[downdraft:plugin] "${apiName}" requires the "${perm}" permission, which plugin "${pluginId}" was not granted ` +
+      `(check permissions[] in the manifest — requested ∩ tier-allowed ∩ game-allowlist).`,
+  );
+}
+
+function deniedEvents(perm: PluginPermission, id: string): PluginEventBus {
+  return {
+    subscribe: () => { throw permError("events.subscribe", perm, id); },
+    publish: () => { throw permError("events.publish", perm, id); },
+  };
+}
+
+function deniedState(perm: PluginPermission, id: string): PluginStateStore {
+  return {
+    get: () => { throw permError("state.get", perm, id); },
+    set: () => { throw permError("state.set", perm, id); },
+    delete: () => { throw permError("state.delete", perm, id); },
+    keys: () => { throw permError("state.keys", perm, id); },
+    save: () => Promise.reject(permError("state.save", perm, id)),
+    load: () => Promise.reject(permError("state.load", perm, id)),
+  };
+}
+
+function deniedTick(perm: PluginPermission, id: string): PluginTickApi {
+  return {
+    onTick: () => { throw permError("tick.onTick", perm, id); },
+  };
+}
+
+/** Gate the state store: `state` perm gates KV access; `storage` gates persistence. */
+function gateState(state: PluginStateStore, granted: ReadonlySet<PluginPermission> | undefined, id: string): PluginStateStore {
+  if (!granted) return state;
+  if (!granted.has("state")) return deniedState("state", id);
+  if (!granted.has("storage")) {
+    return {
+      ...state,
+      save: () => Promise.reject(permError("state.save", "storage", id)),
+      load: () => Promise.reject(permError("state.load", "storage", id)),
+    };
+  }
+  return state;
+}
+
+/** Build a ScriptPluginContext facade from the backing object. */
+export function makeScriptContext(
+  b: PluginContextBacking,
+  granted?: ReadonlySet<PluginPermission>,
+): ScriptPluginContext {
+  return {
+    id: b.id,
+    events: granted && !granted.has("events") ? deniedEvents("events", b.id) : b.events,
+    state: gateState(b.state, granted, b.id),
+    tick: granted && !granted.has("tick") ? deniedTick("tick", b.id) : b.tick,
+    log: b.log,
+    onDispose: b.onDispose,
+  };
+}
+
+/** Host-call method → permission(s) required to invoke it. */
+const HOST_CALL_PERMS: Record<string, PluginPermission[]> = {
+  spawnProp: ["assets", "ecs"],
+  removeProp: ["ecs"],
+  setPhysics: ["physics"],
+  getPhysics: ["physics"],
+  applyImpulse: ["physics"],
+  applyTorque: ["physics"],
+  getAssetRef: ["assets"],
+};
+
+/** Build a NativePluginContext facade. Throws if native backing is missing. */
+export function makeNativeContext(
+  b: PluginContextBacking,
+  granted?: ReadonlySet<PluginPermission>,
+): NativePluginContext {
+  if (
+    !b.registerComponent ||
+    !b.registerSystem ||
+    !b.allocateSABChannel ||
+    !b.provide ||
+    !b.inject ||
+    !b.injectOptional ||
+    !b.devtools
+  ) {
+    throw new Error(
+      `makeNativeContext: backing is missing native APIs (plugin "${b.id}" declared native tier but host didn't wire them).`,
+    );
+  }
+  // Gate a host-call method: check the declared permission(s) first (a clear
+  // permission error beats a missing-bridge error), then forward to the
+  // game's PluginHostCalls impl.
+  const hostCall = <A extends unknown[], R>(
+    name: keyof PluginHostCalls,
+  ): ((...args: A) => Promise<R>) => {
+    return (...args: A) => {
+      if (granted) {
+        for (let _i = 0, _it = HOST_CALL_PERMS[name] ?? [], _n = _it.length; _i < _n; _i++) { const perm = _it[_i];
+          if (!granted.has(perm)) {
+            return Promise.reject(permError(name as string, perm, b.id));
+          }
+        }
+      }
+      const hostCalls = b.hostCalls;
+      return hostCalls?.[name]
+        ? (hostCalls[name] as unknown as (...a: A) => Promise<R>).apply(hostCalls, args)
+        : Promise.reject(new Error(`${name as string}: no host-call bridge wired (plugin "${b.id}")`));
+    };
+  };
+  return {
+    id: b.id,
+    events: granted && !granted.has("events") ? deniedEvents("events", b.id) : b.events,
+    state: gateState(b.state, granted, b.id),
+    tick: granted && !granted.has("tick") ? deniedTick("tick", b.id) : b.tick,
+    log: b.log,
+    onDispose: b.onDispose,
+    registerComponent: b.registerComponent,
+    registerSystem: b.registerSystem,
+    allocateSABChannel: granted && !granted.has("sab")
+      ? () => { throw permError("allocateSABChannel", "sab", b.id); }
+      : b.allocateSABChannel,
+    provide: b.provide,
+    inject: b.inject,
+    injectOptional: b.injectOptional,
+    devtools: b.devtools,
+    // Host-call bridge: permission-gated, then forwarded to the game's impl.
+    spawnProp: hostCall<[SpawnPropDesc], SpawnedProp>("spawnProp"),
+    removeProp: hostCall<[number], void>("removeProp"),
+    setPhysics: hostCall<[number, Partial<PhysicsDesc>], void>("setPhysics"),
+    getPhysics: hostCall<[number], PhysicsDesc>("getPhysics"),
+    applyImpulse: hostCall<[number, [number, number, number]], void>("applyImpulse"),
+    applyTorque: hostCall<[number, [number, number, number]], void>("applyTorque"),
+    getAssetRef: hostCall<[string], number>("getAssetRef"),
+  };
+}

package/core/src/plugin/diagnostics.ts

@@ -0,0 +1,61 @@
+// ============================================================================
+// Plugin diagnostics — snapshot type for the doctor panel + cross-thread report.
+// ============================================================================
+
+import type { PluginFormat, PluginPermission, PluginTier, PluginThread } from "./manifest";
+
+export type PluginStatus = "pending" | "loading" | "active" | "error" | "disabled";
+
+/** Per-plugin info returned by `PluginHost.snapshot()`. */
+export interface PluginInfo {
+  id: string;
+  name: string;
+  version: string;
+  format: PluginFormat;
+  tier: PluginTier;
+  thread: PluginThread;
+  permissions: PluginPermission[];
+  provides: string[];
+  requires: string[];
+  dependencies: string[];
+  status: PluginStatus;
+  /** Present when status === "error". */
+  error?: string;
+  /** Permissions requested but denied (with reasons). */
+  deniedPermissions?: Array<{ permission: PluginPermission; reason: string }>;
+  /** Source: "local" | "workshop". */
+  source?: string;
+}
+
+/** Build a PluginInfo from a manifest + runtime status. */
+export function pluginInfoFromManifest(
+  m: {
+    id: string;
+    name: string;
+    version: string;
+    format: PluginFormat;
+    tier: PluginTier;
+    thread: PluginThread;
+    permissions?: PluginPermission[];
+    provides?: string[];
+    requires?: string[];
+    dependencies?: string[];
+  },
+  status: PluginStatus,
+  extra?: Partial<PluginInfo>,
+): PluginInfo {
+  return {
+    id: m.id,
+    name: m.name,
+    version: m.version,
+    format: m.format,
+    tier: m.tier,
+    thread: m.thread,
+    permissions: m.permissions ?? [],
+    provides: m.provides ?? [],
+    requires: m.requires ?? [],
+    dependencies: m.dependencies ?? [],
+    status,
+    ...extra,
+  };
+}

package/core/src/plugin/discovery.ts

@@ -0,0 +1,186 @@
+// ============================================================================
+// Plugin discovery helpers — generalized from andrews-sandbox's main.tsx +
+// plugin-host-bridge.ts.
+//
+// Games collect manifests via import.meta.glob (the glob call MUST stay in
+// game code — Vite analyzes the literal pattern relative to the importing
+// file), then hand the results to collectPluginManifests + discoverPlugins:
+//
+//   const found = collectPluginManifests({
+//     "mod.json":     import.meta.glob("../plugins/*\/mod.json",     { eager: true, query: "?json", import: "default" }),
+//     "plugin.json":  import.meta.glob("../plugins/*\/plugin.json",  { eager: true, query: "?json", import: "default" }),
+//   });
+//   const host = new PluginHost({ gameId, engineVersion });
+//   const result = await discoverPlugins(host, found);
+//   const getBaseUrl = pluginBaseUrlLookup(found);
+// ============================================================================
+
+import { createLogger } from "../util/logger";
+import type { AssetRegistry, MapRegistry, PhysicsRegistry } from "./extension-loaders";
+import type { PluginHost } from "./host";
+import type { PluginManifest } from "./manifest";
+
+const log = createLogger();
+
+function tagFromPrefix(logPrefix: string): string {
+  return logPrefix.replace(/^\[|\]$/g, "");
+}
+
+export interface DiscoveredPlugin {
+  manifest: PluginManifest;
+  /** Absolute base URL of the plugin directory (for asset resolution). */
+  baseUrl: string;
+}
+
+/**
+ * Collect plugin manifests from import.meta.glob results.
+ * `globResults` maps the manifest filename ("mod.json", "plugin.json") to
+ * the eager-glob result object (`{ "../plugins/foo/mod.json": manifest }`).
+ */
+export function collectPluginManifests(
+  globResults: Record<string, Record<string, unknown>>,
+): DiscoveredPlugin[] {
+  const out: DiscoveredPlugin[] = [];
+  for (const [fileName, modules] of Object.entries(globResults)) {
+    for (const [path, manifest] of Object.entries(modules)) {
+      // Convert glob path (e.g. "../plugins/acid-postfx/mod.json") to a URL
+      // relative to the Vite dev server root (the game directory).
+      const pluginDir = path.replace(`/${fileName}`, "");
+      const absDir = pluginDir.replace(/^\.\.\//, "/");
+      out.push({ manifest: manifest as PluginManifest, baseUrl: absDir });
+    }
+  }
+  return out;
+}
+
+/**
+ * Discover all collected manifests on the host, then load them.
+ * Returns the count of active plugins + any rejected manifests.
+ */
+export async function discoverPlugins(
+  host: PluginHost,
+  manifests: DiscoveredPlugin[],
+): Promise<{ active: number; rejected: Array<{ id: string; errors: string[] }> }> {
+  const rejected: Array<{ id: string; errors: string[] }> = [];
+  manifests.forEach(({ manifest, baseUrl }) => {
+    const r = host.discover(manifest, baseUrl);
+    if (!r.ok) {
+      rejected.push({ id: manifest.id, errors: r.errors });
+      log.warn("PluginHost", `Rejected manifest "${manifest.id}": ${r.errors.join("; ")}`);
+    }
+  });
+  await host.loadAll();
+  const active = host.snapshot().filter((p) => p.status === "active").length;
+  return { active, rejected };
+}
+
+/** Build a manifestId → baseUrl lookup for asset resolution. */
+export function pluginBaseUrlLookup(
+  manifests: DiscoveredPlugin[],
+): (manifestId: string) => string {
+  const map = new Map<string, string>();
+  manifests.forEach(({ manifest, baseUrl }) => {
+    map.set(manifest.id, baseUrl);
+  });
+  return (manifestId) => map.get(manifestId) ?? "";
+}
+
+/** Derive a display name from an asset path ("textures/stone.png" → "stone"). */
+export function deriveAssetName(path: string): string {
+  const parts = path.split("/");
+  return parts[parts.length - 1].replace(/\.[^.]+$/, "");
+}
+
+/** Resolve a plugin-relative asset path against the manifest's base URL. */
+export function resolvePluginAssetUrl(baseUrl: string, path: string): string {
+  const clean = path.replace(/^\.\//, "");
+  return baseUrl ? `${baseUrl}/${clean}` : clean;
+}
+
+// --- Generic asset registry bridge ---
+
+export type PluginAssetKind = "mesh" | "texture" | "pbrMaterial" | "texturePipeline";
+
+export interface PluginAssetEntry {
+  id: string;
+  kind: PluginAssetKind;
+  /** Derived display name (from meta.name or the filename). */
+  name: string;
+  /** Original path from the manifest. */
+  path: string;
+  /** Resolved absolute URL (empty string when the manifest gave no path). */
+  url: string;
+  manifestId: string;
+  /** Raw meta/props from the manifest extension. */
+  meta?: Record<string, unknown>;
+}
+
+export interface AssetRegistryBridgeHooks {
+  /** Register a discovered asset into the game's content/asset registry. */
+  register(entry: PluginAssetEntry): void;
+  /** Remove a previously-registered asset. */
+  unregister(id: string): void;
+  /** Resolve a manifest's base URL. */
+  getBaseUrl(manifestId: string): string;
+}
+
+/**
+ * Generic AssetRegistry implementation — handles name derivation + URL
+ * resolution and delegates the actual registration to the game's hooks.
+ */
+export function createAssetRegistryBridge(hooks: AssetRegistryBridgeHooks): AssetRegistry {
+  const entry = (
+    id: string,
+    kind: PluginAssetKind,
+    path: string,
+    manifestId: string,
+    meta?: Record<string, unknown>,
+  ): PluginAssetEntry => ({
+    id,
+    kind,
+    name: (meta?.name as string) ?? deriveAssetName(path || id),
+    path,
+    url: path ? resolvePluginAssetUrl(hooks.getBaseUrl(manifestId), path) : "",
+    manifestId,
+    meta,
+  });
+
+  return {
+    async registerMesh(id, path, manifestId, meta) {
+      hooks.register(entry(id, "mesh", path, manifestId, meta));
+    },
+    async unregisterMesh(id) { hooks.unregister(id); },
+    async registerTexture(id, path, manifestId, meta) {
+      hooks.register(entry(id, "texture", path, manifestId, meta));
+    },
+    async unregisterTexture(id) { hooks.unregister(id); },
+    async registerPBRMaterial(id, path, manifestId, props) {
+      hooks.register(entry(id, "pbrMaterial", path, manifestId, props));
+    },
+    async unregisterPBRMaterial(id) { hooks.unregister(id); },
+    async registerTexturePipeline(id, path, manifestId, props) {
+      hooks.register(entry(id, "texturePipeline", path, manifestId, props));
+    },
+    async unregisterTexturePipeline(id) { hooks.unregister(id); },
+  };
+}
+
+// --- No-op registries (for games that don't support a category yet) ---
+
+export function createNoopMapRegistry(logPrefix = "[PluginHost]"): MapRegistry {
+  return {
+    async registerMap(id, _path, manifestId) {
+      log.info(tagFromPrefix(logPrefix), `Map "${id}" from mod "${manifestId}" registered (noop)`);
+    },
+    async unregisterMap() { /* noop */ },
+  };
+}
+
+export function createNoopPhysicsRegistry(logPrefix = "[PluginHost]"): PhysicsRegistry {
+  return {
+    async registerPhysicsOverride(id, _path, manifestId) {
+      log.info(tagFromPrefix(logPrefix), `Physics override "${id}" from mod "${manifestId}" registered (noop)`);
+    },
+    async unregisterPhysicsOverride() { /* noop */ },
+  };
+}