@oxy.so/bloom 7.1.4 → 7.2.0

package/assets/character-runtime/README.md

@@ -2,9 +2,7 @@
 
 Serve this directory unchanged from a static URL and pass runtime.mjs's URL to
 AgentAvatarProvider. The runtime loads lazily when an avatar becomes visible.
-Serve .mjs as JavaScript and .wasm as application/wasm. Version the static
-directory as a unit: changing only the runtime.mjs query does not invalidate
-its relative imports under immutable HTTP caching.
+Serve .mjs as JavaScript and .wasm as application/wasm.
 
 The four generated engine files are preserved byte for byte from the supplied
 local beta. integrity.json records their SHA-256 hashes. The complete supplied
@@ -16,97 +14,18 @@ runtime.mjs is an adapter for the original engine, retaining its appearance,
 materials and animations. It owns loading, selection, input, display scaling and
 resource lifetime. There is no replacement mesh renderer in the product.
 
-All visible moving characters share one physical WebGL2 context, a packed canvas,
-and one animation clock with a 30fps per-character target. Each character retains its own state and private
-render targets. shared-surface.mjs maps its default framebuffer into a tile,
-resolves MSAA before translation, and clips output copies to that tile. Only the
-last lease destroys the physical context. shared-programs.mjs pools shaders and
-linked programs, preserving independent uniforms and Emscripten object metadata.
-Identical uniform values are not resent when changing logical program owners.
-shared-textures.mjs shares the exact bytes and parameters of the two 512px
-mipmapped RGBA8 assets and the 576×960 RGBA8 atlas. Mutation or framebuffer
-attachment first gives that logical texture independent storage. Other textures,
-mutable buffers and private render targets are not deduplicated. Small avatars
-use compact meshes independent of device pixel ratio. Fur and original materials
-remain intact. resolution.mjs selects backing size by CSS size and DPR, activating
-the original engine's existing size-dependent fur LOD.
+Beta characters share one engine per document and all avatars share a 30fps
+clock. Legacy contours isolate rendering modules to keep native geometry caches
+from returning another silhouette; one worker prepares their scenes. Unused
+modules are released. Static portrait preparation is serialized, cached (up to 64 images), and
+releases its graphics surfaces after painting. Offscreen/background characters
+stop rendering; pause and reduced motion freeze a complete visible frame. The
+binary's initial reduced-motion flag can produce transparent frames; the adapter
+freezes its own clock after painting instead.
 
-Physical Pixel 8a measurements and exact asset fingerprints are recorded in
-docs/benchmarks/avatar-continuous-renderer.json (same-character controllers and
-pose transitions, before shared authored parts). All 24/48 avatars move with
-one context and no graphics errors. Median paint rates are 4.42/2.29 Hz per avatar;
-all-ready latency is 14.85/24.80 seconds with warm HTTP caches. The 30 fps target
-is not achieved. Earlier snapshots are retained for comparison; see
-docs/agent-avatar.mdx for workload and measurement limitations.
-
-Original and migrated contours share a rendering WASM module and one preparation
-worker, which owns a separate WASM instance. Geometry identities include contour and attachment transforms. The adapter
-scopes the recovered engine's deferred preparation dispatcher to its character;
-that boundary is specific to the integrity-pinned glue. Its native global batch
-can combine jobs from different characters, so wrapping callbacks alone is not
-sufficient: the preparation lease spans mutation, deferred jobs and first paint. Cold preparation is
-serialized; painted moving neighbours remain resident. Static portraits are
-cached (up to 64 images), and release graphics surfaces after painting. Exact contour preparations use an independent 8 MiB/16-entry LRU cache, including appearance, quality, activity and contour and authored-part identity; returned buffers are copied. The preparation owner receives a render turn every batch until its first complete paint. Recent interactions receive alternate-batch priority without starving the remaining round-robin queue.
-Offscreen/background characters release their leases. Pause and reduced motion
-freeze a complete visible frame. The binary's initial reduced-motion flag can
-produce transparent frames; the adapter freezes its clock after painting instead.
-
-Shared submissions contain at most eight avatars and an 8 ms CPU allowance. A WebGL fence is polled asynchronously before error checks and presentation, allowing the page to process input while the GPU works. Lifecycle and native input operations wait for this boundary; DOM pointer capture remains synchronous. Diagnostics separate CPU submission/presentation from elapsed GPU waiting and task dispatch. This improves responsiveness without claiming faster GPU throughput.
-
-React and Work retain one native Character, its prepared meshes and animation
-clock. controller-mode.mjs verifies the original WASM SHA-256 before capturing
-its memory through the supported instantiateWasm hook. A JS hash fallback keeps
-this check working on insecure HTTP WebView origins. The adapter validates the
-Embind handle, native type marker, live instance, bounds and boolean controller
-field on every access; memory growth never leaves a stale typed view. Its ABI
-layout is specific to the pinned WASM and must be re-proved for another binary.
-Activity support prepares the original props up front. A constructor without
-activity support rejects Restore/Start; incremental preparation is not assumed.
-Stop completion reads the original current phase/activity/episode, since both
-copyActivityRestore and hasPendingUpdate can misrepresent outro completion.
-Appearance changes retain any simultaneous Work/React request until the new
-scene is painted; pausing or disposal cancels those requests.
-Queued reactions retain the original Busy semantics until the suspended reaction
-finishes. verify-avatar-controller-continuity.mjs checks the complete runtime
-switches, native identity, unchanged geometry, original outro and real pixels.
-pose-transition.mjs interpolates reflected transform/skin uniform blocks and
-camera for 180 ms from the last presented pose. It preserves material/discrete
-bytes and original animation of newly added props. No bitmap crossfade or
-replacement mesh renderer is involved.
-
-authored-parts.mjs exposes eyes:todd and accessory:felipe_beret across all 21
-shapes. The worker copies complete native records from lime_frog and blue_beret,
-retaining materials and animation deltas, fits them after contour deformation,
-and removes the generic fitting references. Original activity data remains intact; the aggregate scene bounds expand to
-include the fitted parts. Virtual IDs never reach native catalog selection. Cache keys include
-these parts; verify-avatar-authored-parts.mjs checks all 21 real rendered shapes,
-original/migrated Work and React, generic selections and cleanup.
-
-clippo-geometry.mjs adds a smooth open tube and an independently selectable
-Clippo eye/brow set as native prepared records. It generates capped tube meshes,
-retains the original eye deformation fields and uses the recovered smooth
-material in the same renderer. No raster cutout or additional WebGL context is
-used. character-recipe.mjs resolves the clippo preset to its virtual shape/eyes
-and grey paint; explicit selections override those defaults. Runtime capabilities
-retain the caller's raw saved key, including when an explicit default selection
-leaves the prepared appearance unchanged. Editor chips are static SVG artwork.
-
-catalog-parts.mjs fits actual original eye, eyewear and accessory meshes across
-all bodies. Named presets supply editable defaults; changing a part retains the
-original body. Opaque sunglasses recover their hidden-eye fitting references
-without replacing the body. Donor records have an 8 MiB/24-entry bounded cache.
-verify-avatar-catalog-parts.mjs checks 312 combinations, exact requested mesh
-labels, preserved body vertices and the cache bound.
-
-cyclops-geometry.mjs adds one native white eyeball, a teal iris, pupil and glint;
-its layered meshes retain native blink/look deformation. Each shape owns eye
-positions and size, shared by every eye style; historical character.eyeSpacing
-values are ignored. Todd's actual body is also independently selectable
-as shape:todd. verify-avatar-cyclops.mjs checks actual eye colors, movement and
-cleanup; verify-avatar-customization.mjs exercises all eye styles on Todd in the
-real editor, shape changes and accessories. appearance-codec.mjs
-validates explicit RGB through the original engine. Untouched presets keep their
-bytes; unnamed original paint is reported from its actual material.
+Current editing supports the beta's original catalog combinations and actual
+availability constraints. appearance-codec.mjs validates explicit RGB and optional eye
+transform edits through the original engine. Untouched presets keep their bytes.
 
 legacy-geometry.mjs transforms copies of prepared scene assemblies: existing
 Bloom contours deform the body, pose deltas, normals and fur roots. The packaged
@@ -120,31 +39,17 @@ diamond and heart recipes reuse the original beta shapes instead of duplicates.
 Alien avatars are removed from the visible catalog, with saved-data compatibility. The
 migrated bodies use the original catalog eyes at their authored proportions and
 animations; old expression/eye transform fields no longer alter the 3D face.
-All visible bodies accept native catalog eyes, eyewear and accessories through
-original donor assemblies. Fitting uses the actual target face/crown anchors;
-Clippo headwear is scaled to its narrow crown. A bounded reference cache retains
-original material/animation data, and spacing moves the eye groups without
-stretching lenses. `verify-avatar-catalog-parts.mjs` checks all 312 native
-body/part combinations, exact requested labels, unchanged body vertices and
-cache bounds without creating a WebGL context. Intact presets retain authored
-signature reactions. Independent piece edits retain the body's original
-signature. Native shapes use their corresponding authored signature; distinct
-migrated contours and Clippo use Todd's signature as the common default.
-The adapter never substitutes the original Wave/maracas reaction. A pinned,
-validated controller scope borrows only the reaction identity during the original
-native dispatch and restores it immediately; saved appearance and materials
-remain independent. Named bodies also retain their original fitted Work payload.
+Migrated bodies support original eyewear and accessories. Headwear, Bulb, bow
+and Tuft receive rigid contour-relative translations; eyewear and headphones
+keep original placement. A bounded reference cache identifies attachment meshes
+without changing eyes, materials or fur vectors. Intact presets retain authored
+signature reactions; edited and migrated bodies fall back to the original Wave.
 Mascots and hidden faces still use SVG.
 Original material/grain effects become the beta's 3D surface.
 
 Browser gates (with Storybook running) are scripts/verify-character-avatars.mjs
-and scripts/verify-legacy-avatars.mjs, plus verify-avatar-render-budget.mjs and
-verify-avatar-shared-renderer.mjs for crowd lifetime and actual 24/48-avatar motion.
-verify-avatar-shared-surface.mjs checks atlas pixels, MSAA and failed allocation;
-verify-avatar-shared-programs.mjs and verify-avatar-shared-textures.mjs compare
-actual frame pixels against the original commands and verify independent changes.
-verify-avatar-runtime-errors.mjs injects a GL failure before publication. verify-avatar-deferred-input.mjs forces a delayed GPU fence and checks real mouse capture, reactions, appearance edits, resizing and disposal during that wait. They inspect painted pixels, interaction,
+and scripts/verify-legacy-avatars.mjs. They inspect painted pixels, interaction,
 activity, transitions and resource cleanup, not just preparation callbacks.
 
 The optional native bridge uses separate WebViews, which cannot share the web
-engine/context caches. A physical Android WebView is checked separately from the native multi-WebView bridge.
+engine/context caches. Physical-device validation remains pending.

package/assets/character-runtime/legacy-engine.mjs

@@ -1,429 +1,76 @@
-import {
-  NATIVE_PARTS,
-  ORIGINAL_PRESETS,
-  MIGRATED_SHAPE_IDS,
-} from './character-recipe.mjs';
 import createModule from './orbit-characters.mjs';
-import { createControllerModeAdapter } from './controller-mode.mjs';
-import {
-  createPreparationCache,
-  preparationKey,
-} from './preparation-cache.mjs';
-import { waitForSharedRender } from './shared-surface.mjs';
 
-let controller;
 const pool = new Map();
-const authoredFacades = new Map();
 const pending = new Map();
-const prepared = createPreparationCache();
-const originalScope = Object.freeze({ points: undefined });
-let modulePromise,
-  originalFacade,
-  currentScope,
-  worker,
+let worker,
   idleTimer,
-  characters = 0,
   sequence = 0;
-
-const dispatchTimers = new Map();
-const preparationQueue = [];
-let activePreparation;
-
-function pumpPreparationQueue() {
-  if (pending.size || dispatchTimers.size) return;
-  if (activePreparation && !activePreparation.released) return;
-  activePreparation = undefined;
-  const next = preparationQueue.shift();
-  if (!next) return;
-  next.signal?.removeEventListener('abort', next.abort);
-  const lease = { released: false };
-  activePreparation = lease;
-  next.resolve(() => {
-    if (lease.released) return;
-    lease.released = true;
-    pumpPreparationQueue();
-  });
-}
-
-function scoped(scope, operation) {
-  const previous = currentScope;
-  const schedule = globalThis.setTimeout;
-  const cancel = globalThis.clearTimeout;
-  currentScope = scope;
-  // Emscripten dispatches preparation asynchronously. Keep the owning scope
-  // through its timer, but preserve the engine's timing and callback ordering.
-  // The preparation lease prevents other characters from joining that global
-  // native queue until this owner's preparation has settled.
-  globalThis.setTimeout = function (callback, delay, ...args) {
-    const nativeDispatcher =
-      typeof callback === 'function' &&
-      Number(delay) === 0 &&
-      Function.prototype.toString
-        .call(callback)
-        .includes(
-          'safeSetTimeout.mapping[id]=undefined;callUserCallback(func)',
-        );
-    let handle;
-    handle = schedule.call(
-      globalThis,
-      typeof callback === 'function'
-        ? (...values) => {
-            if (nativeDispatcher) dispatchTimers.delete(handle);
-            try {
-              return scoped(scope, () => callback(...values));
-            } finally {
-              pumpPreparationQueue();
-            }
-          }
-        : callback,
-      delay,
-      ...args,
-    );
-    if (nativeDispatcher) dispatchTimers.set(handle, scope);
-    return handle;
-  };
-  globalThis.clearTimeout = function (handle) {
-    dispatchTimers.delete(handle);
-    return cancel.call(globalThis, handle);
-  };
-  try {
-    return operation();
-  } finally {
-    globalThis.setTimeout = schedule;
-    globalThis.clearTimeout = cancel;
-    currentScope = previous;
-    pumpPreparationQueue();
-  }
-}
-
-/** Fair, cancelable setup lease for the native engine's global prepare queue.
- * Acquire before constructing or changing a Character's geometry. Release
- * after preparation/paint, or dispose/error. A released owner with a pending
- * native callback retains its turn until that callback has completed.
- */
-export function acquireCharacterPreparation(signal) {
-  return new Promise((resolve, reject) => {
-    const abort = () => {
-      const index = preparationQueue.indexOf(entry);
-      if (index >= 0) preparationQueue.splice(index, 1);
-      reject(new DOMException('Character preparation aborted', 'AbortError'));
-      pumpPreparationQueue();
-    };
-    const entry = { resolve, reject, signal, abort };
-    if (signal?.aborted) {
-      abort();
-      return;
-    }
-    signal?.addEventListener('abort', abort, { once: true });
-    preparationQueue.push(entry);
-    pumpPreparationQueue();
-  });
-}
-
-function stopIdleWorker() {
-  clearTimeout(idleTimer);
-  if (characters || pool.size || pending.size || dispatchTimers.size) return;
-  idleTimer = setTimeout(() => {
-    if (!characters && !pool.size && !pending.size && !dispatchTimers.size) {
-      worker?.terminate();
-      worker = undefined;
-    }
-  }, 0);
-}
-
-async function finishRequest(id, result, reused = false) {
-  const entry = pending.get(id);
-  if (!entry || entry.delivering) return;
-  entry.delivering = true;
-  try {
-    await entry.complete(result, reused);
-  } finally {
-    // Keep the owner's turn while the GPU boundary and native completion are
-    // still waiting, even if that owner has already been canceled or deleted.
-    pending.delete(id);
-    pumpPreparationQueue();
-    stopIdleWorker();
-  }
-}
-
 function preparationWorker() {
-  clearTimeout(idleTimer);
   if (worker) return worker;
   worker = new Worker(new URL('./legacy-worker.mjs', import.meta.url), {
     type: 'module',
   });
   worker.onmessage = ({ data }) => {
-    void finishRequest(data.id, data);
+    const entry = pending.get(data.id);
+    if (!entry) return;
+    pending.delete(data.id);
+    entry.complete(data);
   };
   worker.onerror = () => {
-    const failed = [...pending.keys()];
+    const failed = [...pending.values()];
+    pending.clear();
     worker?.terminate();
     worker = undefined;
-    for (const id of failed)
-      void finishRequest(id, {
-        error: 'Character preparation failed',
+    for (const entry of failed)
+      entry.complete({
+        error: 'Legacy character preparation failed',
         milliseconds: 0,
       });
   };
   return worker;
 }
 
-function sharedModule() {
-  if (!modulePromise) {
-    controller = createControllerModeAdapter(
-      () => new URL('./orbit-characters.wasm', import.meta.url),
-    );
-    modulePromise = Promise.race([
-      createModule({
-        locateFile: (file) => new URL(file, import.meta.url).href,
-        instantiateWasm: controller.instantiateWasm,
-      }),
-      controller.failure,
-    ])
-      .then((module) => {
-        module.orbitPrepare = (
-          id,
-          appearance,
-          quality,
-          cacheKey,
-          activities,
-        ) => {
-          const scope = currentScope;
-          if (!scope) {
+/** Separate geometry caches for different contours; one shared preparation worker.
+ * Unused rendering modules are released, never retained in an unbounded catalog.
+ */
+export async function acquireLegacyEngine(points) {
+  clearTimeout(idleTimer);
+  const key = JSON.stringify(points);
+  let entry = pool.get(key);
+  if (!entry) {
+    entry = { references: 0, module: null };
+    entry.module = createModule({
+      locateFile: (file) => new URL(file, import.meta.url).href,
+    }).then((module) => {
+      module.orbitPrepare = (id, appearance, quality, cacheKey, activities) => {
+        const request = ++sequence;
+        pending.set(request, {
+          owner: entry,
+          complete: (result) => {
             module.orbitCompletePreparation(
               id,
-              null,
-              'Character preparation requires a scoped call',
-              0,
+              result.bytes ?? null,
+              result.error || '',
+              result.milliseconds || 0,
             );
-            return;
-          }
-          const request = ++sequence;
-          const cacheKeyExact = preparationKey({
+          },
+        });
+        try {
+          preparationWorker().postMessage({
+            id: request,
             appearance,
             quality,
             key: cacheKey,
             activities,
-            points: scope.points,
-            authoredParts: scope.authoredParts,
-            eyeSpacing: scope.authoredParts?.eyeSpacing,
-          });
-          const complete = async (result, reused = false) => {
-            await waitForSharedRender();
-            return scoped(scope, () => {
-              if (result.bytes && !result.error && !reused)
-                prepared.set(cacheKeyExact, result.bytes);
-              module.orbitCompletePreparation(
-                id,
-                result.bytes ?? null,
-                result.error || '',
-                result.milliseconds || 0,
-              );
-            });
-          };
-          pending.set(request, { complete });
-          const cached = prepared.get(cacheKeyExact);
-          if (cached) {
-            // Preserve asynchronous completion and the owner's preparation
-            // turn. Completing inside orbitPrepare would re-enter native
-            // dispatch while its job is still being registered.
-            queueMicrotask(() => {
-              void finishRequest(
-                request,
-                { bytes: cached, milliseconds: 0 },
-                true,
-              );
-            });
-            return;
-          }
-          try {
-            preparationWorker().postMessage({
-              id: request,
-              appearance,
-              quality,
-              key: cacheKey,
-              activities,
-              points: scope.points,
-              authoredParts: scope.authoredParts,
-              eyeSpacing: scope.authoredParts?.eyeSpacing,
-            });
-          } catch (error) {
-            void finishRequest(request, {
-              error: String(error),
-              milliseconds: 0,
-            });
-          }
-        };
-        return module;
-      })
-      .catch((error) => {
-        modulePromise = undefined;
-        throw error;
-      });
-  }
-  return modulePromise;
-}
-
-function facade(module, scope) {
-  const result = Object.create(module);
-  const handles = new WeakMap();
-  function wrap(target, activities = false, source) {
-    controller.register(target, activities, source);
-    const methods = new Map();
-    let deleted = false;
-    characters++;
-    const proxy = new Proxy(target, {
-      get(instance, key) {
-        const value = Reflect.get(instance, key, instance);
-        if (typeof value !== 'function' || key === 'constructor') return value;
-        if (!methods.has(key))
-          methods.set(key, (...args) => {
-            const returned = scoped(scope, () => value.apply(instance, args));
-            if (key === 'applyActivity' && returned === 0 && activities)
-              controller.markBound(instance);
-            if (key === 'delete' && !deleted) {
-              controller.unregister(instance);
-              deleted = true;
-              characters--;
-              stopIdleWorker();
-            }
-            // Embind handle clones retain the same native character and scope.
-            if (returned !== instance && returned instanceof module.Character)
-              return wrap(returned, activities, instance);
-            return returned;
+            points,
           });
-        return methods.get(key);
-      },
+        } catch (error) {
+          pending.delete(request);
+          module.orbitCompletePreparation(id, null, String(error), 0);
+        }
+      };
+      return module;
     });
-    handles.set(proxy, target);
-    return proxy;
-  }
-  result.controllerMode = (character, enabled) => {
-    const instance = handles.get(character);
-    if (!instance)
-      throw new Error(
-        'Character controller belongs to a different engine scope',
-      );
-    return scoped(scope, () => controller.controllerMode(instance, enabled));
-  };
-  result.controllerState = (character) => {
-    const instance = handles.get(character);
-    if (!instance)
-      throw new Error(
-        'Character controller belongs to a different engine scope',
-      );
-    return scoped(scope, () => controller.controllerState(instance));
-  };
-  result.controllerSignature = (character, preset) => {
-    const instance = handles.get(character);
-    if (!instance)
-      throw new Error(
-        'Character controller belongs to a different engine scope',
-      );
-    return scoped(scope, () =>
-      controller.controllerSignature(instance, preset),
-    );
-  };
-  result.controllerWithSignature = (character, preset, operation) => {
-    const instance = handles.get(character);
-    if (!instance)
-      throw new Error(
-        'Character controller belongs to a different engine scope',
-      );
-    return scoped(scope, () =>
-      controller.controllerWithSignature(instance, preset, operation),
-    );
-  };
-  result.Character = function Character(...args) {
-    clearTimeout(idleTimer);
-    return wrap(
-      scoped(scope, () => new module.Character(...args)),
-      args[3]?.activities,
-    );
-  };
-  result.Character.prototype = module.Character.prototype;
-  return result;
-}
-
-/** Original and custom bodies share one WASM instance and preparation worker.
- * Prepared mesh identities distinguish contours inside the shared GPU cache.
- */
-function normalizeAuthoredParts(value) {
-  if (!value || !Object.keys(value).length) return undefined;
-  const keys = [
-    'bodyPreset',
-    'paintBody',
-    'shape',
-    'eyes',
-    'eyewear',
-    'accessory',
-    'eyeSpacing',
-    'faceShape',
-  ];
-  if (
-    Object.keys(value).some((key) => !keys.includes(key)) ||
-    (value.bodyPreset !== undefined &&
-      !ORIGINAL_PRESETS.includes(value.bodyPreset)) ||
-    (value.paintBody !== undefined && typeof value.paintBody !== 'boolean') ||
-    (value.shape !== undefined && value.shape !== 'clippo') ||
-    (value.faceShape !== undefined &&
-      ![...MIGRATED_SHAPE_IDS, ...NATIVE_PARTS.shape].includes(
-        value.faceShape,
-      )) ||
-    (value.eyes !== undefined &&
-      ![...NATIVE_PARTS.eyes, 'todd', 'clippo', 'cyclops'].includes(
-        value.eyes,
-      )) ||
-    (value.eyewear !== undefined &&
-      !NATIVE_PARTS.eyewear.includes(value.eyewear)) ||
-    (value.accessory !== undefined &&
-      ![...NATIVE_PARTS.accessory, 'felipe_beret'].includes(value.accessory))
-  )
-    throw new Error('Unsupported authored character part');
-  return Object.freeze(
-    Object.fromEntries(
-      keys
-        .filter((key) => value[key] !== undefined && key !== 'eyeSpacing')
-        .map((key) => [key, value[key]]),
-    ),
-  );
-}
-export async function getCharacterEngine(parts) {
-  const authoredParts = normalizeAuthoredParts(parts);
-  const module = await sharedModule();
-  if (!authoredParts) {
-    originalFacade ??= facade(module, originalScope);
-    return originalFacade;
-  }
-  // Retain a bounded set of recipe facades; live Characters own their scopes.
-  const key = JSON.stringify(authoredParts);
-  if (!authoredFacades.has(key))
-    authoredFacades.set(
-      key,
-      facade(module, { points: undefined, authoredParts }),
-    );
-  const result = authoredFacades.get(key);
-  authoredFacades.delete(key);
-  authoredFacades.set(key, result);
-  if (authoredFacades.size > 64)
-    authoredFacades.delete(authoredFacades.keys().next().value);
-  return result;
-}
-
-export async function acquireLegacyEngine(points, parts) {
-  clearTimeout(idleTimer);
-  const authoredParts = normalizeAuthoredParts(parts);
-  const key = JSON.stringify([points, authoredParts]);
-  let entry = pool.get(key);
-  if (!entry) {
-    const scope = {
-      points: points.map((point) => point.slice()),
-      authoredParts,
-    };
-    entry = {
-      references: 0,
-      facade: sharedModule().then((module) => facade(module, scope)),
-    };
     pool.set(key, entry);
   }
   entry.references++;
@@ -431,11 +78,20 @@ export async function acquireLegacyEngine(points, parts) {
   const release = () => {
     if (released) return;
     released = true;
-    if (--entry.references === 0) pool.delete(key);
-    stopIdleWorker();
+    if (--entry.references !== 0) return;
+    pool.delete(key);
+    for (const [id, request] of pending)
+      if (request.owner === entry) pending.delete(id);
+    if (!pool.size)
+      idleTimer = setTimeout(() => {
+        if (!pool.size) {
+          worker?.terminate();
+          worker = undefined;
+        }
+      }, 0);
   };
   try {
-    return { module: await entry.facade, release };
+    return { module: await entry.module, release };
   } catch (error) {
     release();
     throw error;
@@ -443,15 +99,7 @@ export async function acquireLegacyEngine(points, parts) {
 }
 
 export const legacyEngineStats = () => ({
-  // Historical field counts leased contour entries; sharedModules is the
-  // actual WASM count, including the instance used by original characters.
   modules: pool.size,
-  sharedModules: modulePromise ? 1 : 0,
-  characters,
-  preparationWaiters: preparationQueue.length,
-  preparationActive: !!activePreparation,
-  dispatchTimers: dispatchTimers.size,
   pending: pending.size,
   worker: !!worker,
-  preparationCache: prepared.stats(),
 });