@oxy.so/bloom 7.1.4 → 7.1.5

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

@@ -1,28 +1,19 @@
 // Adapter for the recovered renderer's prepared vertex layout. Packaged meshes,
 // resource manifests, the WASM binary, and the appearance record stay untouched.
-const decoder = new TextDecoder(),
-  encoder = new TextEncoder();
-const BODY = ":body:no-shadow:studio-fur-v6:";
+const decoder = new TextDecoder(), encoder = new TextEncoder();
+const BODY = ':body:no-shadow:studio-fur-v6:';
 // Highlights are separate non-shadow-casting meshes in the original renderer.
-const SURFACES = [":surface:shadow", ":surface:no-shadow"];
+const SURFACES = [':surface:shadow', ':surface:no-shadow'];
 const SURFACE_KEY = /^[a-f0-9]{64}:surface:(?:shadow|no-shadow)$/;
 const FUR_SURFACE_KEY = /^[a-f0-9]{64}:surface:shadow:studio-fur-v6:/;
-const STRIDE = 96,
-  TAU = Math.PI * 2;
-function invalid(message) {
-  throw new Error(`Unsupported prepared avatar geometry: ${message}`);
-}
-function finite(value) {
-  if (!Number.isFinite(value)) invalid("non-finite coordinate");
-  return value;
-}
+const STRIDE = 96, TAU = Math.PI * 2;
+function invalid(message) { throw new Error(`Unsupported prepared avatar geometry: ${message}`); }
+function finite(value) { if (!Number.isFinite(value)) invalid('non-finite coordinate'); return value; }
 function findAll(bytes, text) {
-  const needle = encoder.encode(text),
-    result = [];
+  const needle = encoder.encode(text), result = [];
   outer: for (let i = 0; i <= bytes.length - needle.length; i++) {
     if (bytes[i] !== needle[0]) continue;
-    for (let j = 1; j < needle.length; j++)
-      if (bytes[i + j] !== needle[j]) continue outer;
+    for (let j = 1; j < needle.length; j++) if (bytes[i + j] !== needle[j]) continue outer;
     result.push(i);
   }
   return result;
@@ -30,187 +21,82 @@ function findAll(bytes, text) {
 
 /** Inspect the bounded, length-prefixed mesh records; reject unknown layouts. */
 export function inspectLegacyAssembly(bytes) {
-  if (!(bytes instanceof Uint8Array) || bytes.length < 400)
-    invalid("truncated assembly");
+  if (!(bytes instanceof Uint8Array) || bytes.length < 400) invalid('truncated assembly');
   const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  const uint = (at) => {
-    if (at < 0 || at + 4 > bytes.length) invalid("truncated count");
-    return view.getUint32(at, true);
-  };
+  const uint = at => { if (at < 0 || at + 4 > bytes.length) invalid('truncated count'); return view.getUint32(at, true); };
   const bodies = findAll(bytes, BODY);
-  if (bodies.length !== 1) invalid("expected one furry body");
+  if (bodies.length !== 1) invalid('expected one furry body');
   const bodyStart = bodies[0] - 64;
-  const starts = [
-    bodyStart,
-    ...SURFACES.flatMap((kind) =>
-      findAll(bytes, kind)
-        .map((i) => i - 64)
-        .filter((i) => {
-          if (i <= bodyStart || i < 4) return false;
-          const length = uint(i - 4);
-          if (length < 79 || length > 8192 || i + length > bytes.length)
-            return false;
-          const name = decoder.decode(bytes.subarray(i, i + length));
-          return SURFACE_KEY.test(name) || FUR_SURFACE_KEY.test(name);
-        }),
-    ).sort((a, b) => a - b),
-  ];
+  const starts = [bodyStart, ...SURFACES.flatMap(kind => findAll(bytes, kind)
+    .map(i => i - 64)
+    .filter(i => {
+      if (i <= bodyStart || i < 4) return false;
+      const length = uint(i - 4);
+      if (length < 79 || length > 8192 || i + length > bytes.length) return false;
+      const name = decoder.decode(bytes.subarray(i, i + length));
+      return SURFACE_KEY.test(name) || FUR_SURFACE_KEY.test(name);
+    }))
+    .sort((a, b) => a - b)];
   const meshCount = uint(0);
-  if (meshCount !== starts.length || meshCount > 40)
-    invalid("mesh count/key mismatch");
+  if (meshCount !== starts.length || meshCount > 40) invalid('mesh count/key mismatch');
   const parts = starts.map((nameOffset, part) => {
-    const nameLength = uint(nameOffset - 4),
-      name = decoder.decode(
-        bytes.subarray(nameOffset, nameOffset + nameLength),
-      );
-    if (
-      nameLength < 79 ||
-      nameLength > 8192 ||
-      nameOffset + nameLength > bytes.length ||
-      !/^[a-f0-9]{64}:/.test(name)
-    )
-      invalid("mesh identity");
-    if (
-      part === 0
-        ? !name.includes(BODY)
-        : !SURFACE_KEY.test(name) && !FUR_SURFACE_KEY.test(name)
-    )
-      invalid("mesh kind");
-    const vertexCount = uint(nameOffset + nameLength),
-      vertexOffset = nameOffset + nameLength + 4;
-    if (vertexCount < 3 || vertexCount > 1000000) invalid("vertex count");
+    const nameLength = uint(nameOffset - 4), name = decoder.decode(bytes.subarray(nameOffset, nameOffset + nameLength));
+    if (nameLength < 79 || nameLength > 8192 || nameOffset + nameLength > bytes.length || !/^[a-f0-9]{64}:/.test(name)) invalid('mesh identity');
+    if (part === 0 ? !name.includes(BODY) : !SURFACE_KEY.test(name) && !FUR_SURFACE_KEY.test(name)) invalid('mesh kind');
+    const vertexCount = uint(nameOffset + nameLength), vertexOffset = nameOffset + nameLength + 4;
+    if (vertexCount < 3 || vertexCount > 1000000) invalid('vertex count');
     let at = vertexOffset + vertexCount * STRIDE;
-    const count32 = uint(at);
-    at += 4;
-    if (count32 > 6000000 || at + count32 * 4 > bytes.length)
-      invalid("32-bit indices");
-    for (let i = 0; i < count32; i++)
-      if (uint(at + i * 4) >= vertexCount) invalid("index outside mesh");
+    const count32 = uint(at); at += 4;
+    if (count32 > 6000000 || at + count32 * 4 > bytes.length) invalid('32-bit indices');
+    for (let i = 0; i < count32; i++) if (uint(at + i * 4) >= vertexCount) invalid('index outside mesh');
     at += count32 * 4;
-    const count16 = uint(at);
-    at += 4;
-    if (count16 > 6000000 || at + count16 * 2 > bytes.length)
-      invalid("16-bit indices");
-    for (let i = 0; i < count16; i++)
-      if (view.getUint16(at + i * 2, true) >= vertexCount)
-        invalid("index outside mesh");
+    const count16 = uint(at); at += 4;
+    if (count16 > 6000000 || at + count16 * 2 > bytes.length) invalid('16-bit indices');
+    for (let i = 0; i < count16; i++) if (view.getUint16(at + i * 2, true) >= vertexCount) invalid('index outside mesh');
     at += count16 * 2;
     // Empty supplemental vertex buffer followed by three boolean mesh flags.
-    if (
-      at + 7 > bytes.length ||
-      uint(at) !== 0 ||
-      bytes[at + 4] > 1 ||
-      bytes[at + 5] > 1 ||
-      bytes[at + 6] > 1
-    )
-      invalid("mesh flags");
-    const hasFur = bytes[at + 6] === 1;
-    at += 7;
-    const furCount = hasFur ? uint(at) : 0,
-      furOffset = hasFur ? at + 4 : 0;
-    if (
-      furCount > 1000000 ||
-      (hasFur && furOffset + furCount * 64 > bytes.length)
-    )
-      invalid("fur records");
+    if (at + 7 > bytes.length || uint(at) !== 0 || bytes[at + 4] > 1 || bytes[at + 5] > 1 || bytes[at + 6] > 1) invalid('mesh flags');
+    const hasFur = bytes[at + 6] === 1; at += 7;
+    const furCount = hasFur ? uint(at) : 0, furOffset = hasFur ? at + 4 : 0;
+    if (furCount > 1000000 || hasFur && furOffset + furCount * 64 > bytes.length) invalid('fur records');
     const geometryEnd = hasFur ? furOffset + furCount * 64 : at;
-    if (
-      geometryEnd >
-      (starts[part + 1] === undefined ? bytes.length : starts[part + 1] - 4)
-    )
-      invalid("overlapping meshes");
-    if (part === 0 && !hasFur) invalid("body lacks fur layout");
-    if (FUR_SURFACE_KEY.test(name) && !hasFur)
-      invalid("accessory lacks fur layout");
-    const min = [Infinity, Infinity, Infinity],
-      max = [-Infinity, -Infinity, -Infinity];
-    for (let i = 0; i < vertexCount; i++)
-      for (let k = 0; k < 24; k++) {
-        const value = finite(
-          view.getFloat32(vertexOffset + i * STRIDE + k * 4, true),
-        );
-        if (k < 3) {
-          min[k] = Math.min(min[k], value);
-          max[k] = Math.max(max[k], value);
-        }
-      }
-    return {
-      part,
-      name,
-      nameOffset,
-      nameLength,
-      vertexCount,
-      vertexOffset,
-      furCount,
-      furOffset,
-      geometryEnd,
-      bounds: { min, max },
-    };
+    if (geometryEnd > (starts[part + 1] === undefined ? bytes.length : starts[part + 1] - 4)) invalid('overlapping meshes');
+    if (part === 0 && !hasFur) invalid('body lacks fur layout');
+    if (FUR_SURFACE_KEY.test(name) && !hasFur) invalid('accessory lacks fur layout');
+    const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];
+    for (let i = 0; i < vertexCount; i++) for (let k = 0; k < 24; k++) {
+      const value = finite(view.getFloat32(vertexOffset + i * STRIDE + k * 4, true));
+      if (k < 3) { min[k] = Math.min(min[k], value); max[k] = Math.max(max[k], value); }
+    }
+    return { part, name, nameOffset, nameLength, vertexCount, vertexOffset, furCount, furOffset, bounds: { min, max } };
   });
   return { body: parts[0], parts };
 }
 
 function mapper({ points, radii, depthScale = 1 }) {
-  if (!Number.isFinite(depthScale) || depthScale <= 0 || depthScale > 4)
-    invalid("depth scale");
-  if ((points && radii) || (!points && !radii))
-    invalid("provide points or radii");
+  if (!Number.isFinite(depthScale) || depthScale <= 0 || depthScale > 4) invalid('depth scale');
+  if (points && radii || !points && !radii) invalid('provide points or radii');
   const count = (points || radii).length;
-  if (count < 16 || count > 65536) invalid("contour resolution");
-  if (points)
-    for (const p of points) {
-      if (p.length !== 2) invalid("contour point");
-      p.forEach(finite);
-    }
-  else
-    for (const radius of radii)
-      if (!(finite(radius) > 0)) invalid("contour radius");
+  if (count < 16 || count > 65536) invalid('contour resolution');
+  if (points) for (const p of points) { if (p.length !== 2) invalid('contour point'); p.forEach(finite); }
+  else for (const radius of radii) if (!(finite(radius) > 0)) invalid('contour radius');
   return (x, y, z) => {
-    const radius = Math.hypot(x, y),
-      angle = (Math.atan2(y, x) + TAU) % TAU;
-    const slot = (angle / TAU) * count,
-      index = Math.floor(slot),
-      t = slot - index,
-      next = (index + 1) % count;
-    if (points)
-      return [
-        radius * (points[index][0] * (1 - t) + points[next][0] * t),
-        radius * (points[index][1] * (1 - t) + points[next][1] * t),
-        z * depthScale,
-      ];
+    const radius = Math.hypot(x, y), angle = (Math.atan2(y, x) + TAU) % TAU;
+    const slot = angle / TAU * count, index = Math.floor(slot), t = slot - index, next = (index + 1) % count;
+    if (points) return [radius * (points[index][0] * (1 - t) + points[next][0] * t), radius * (points[index][1] * (1 - t) + points[next][1] * t), z * depthScale];
     const scale = radii[index] * (1 - t) + radii[next] * t;
     return [x * scale, y * scale, z * depthScale];
   };
 }
 function derivative(map, p) {
-  const epsilon = 0.00005,
-    base = map(...p);
-  const columns = [0, 1, 2].map((k) => {
-    const q = [...p];
-    q[k] += epsilon;
-    return map(...q).map((v, i) => (v - base[i]) / epsilon);
-  });
+  const epsilon = .00005, base = map(...p);
+  const columns = [0, 1, 2].map(k => { const q = [...p]; q[k] += epsilon; return map(...q).map((v, i) => (v - base[i]) / epsilon); });
   const [a, b, c] = columns;
-  const cross = (u, v) => [
-    u[1] * v[2] - u[2] * v[1],
-    u[2] * v[0] - u[0] * v[2],
-    u[0] * v[1] - u[1] * v[0],
-  ];
+  const cross = (u, v) => [u[1] * v[2] - u[2] * v[1], u[2] * v[0] - u[0] * v[2], u[0] * v[1] - u[1] * v[0]];
   const inverse = [cross(b, c), cross(c, a), cross(a, b)];
   const determinant = a.reduce((sum, v, i) => sum + v * inverse[0][i], 0);
-  if (Math.abs(determinant) < 0.000001) invalid("singular contour");
-  return {
-    base,
-    vector: (v) =>
-      [0, 1, 2].map((i) =>
-        columns.reduce((sum, col, j) => sum + col[i] * v[j], 0),
-      ),
-    normal: (v) =>
-      [0, 1, 2].map(
-        (i) =>
-          inverse.reduce((sum, col, j) => sum + col[i] * v[j], 0) / determinant,
-      ),
-  };
+  if (Math.abs(determinant) < .000001) invalid('singular contour');
+  return { base, vector: v => [0, 1, 2].map(i => columns.reduce((sum, col, j) => sum + col[i] * v[j], 0)), normal: v => [0, 1, 2].map(i => inverse.reduce((sum, col, j) => sum + col[i] * v[j], 0) / determinant) };
 }
 
 /** Rigid attachment anchors on the source circle, in the engine's XY units.
@@ -219,10 +105,9 @@ function derivative(map, p) {
  */
 export function legacyAttachmentOffset(points, accessory) {
   let anchor;
-  if (accessory === "bow") anchor = [0, -1, 0];
-  else if (accessory === "three_lobe") anchor = [-0.5, Math.sqrt(0.75), 0];
-  else if (["beanie", "hat", "beret", "orb", "crown"].includes(accessory))
-    anchor = [0, 1, 0];
+  if (accessory === 'bow') anchor = [0, -1, 0];
+  else if (accessory === 'three_lobe') anchor = [-.5, Math.sqrt(.75), 0];
+  else if (['beanie', 'hat', 'beret', 'orb', 'crown'].includes(accessory)) anchor = [0, 1, 0];
   else return undefined;
   return mapper({ points })(...anchor).map((value, i) => value - anchor[i]);
 }
@@ -235,89 +120,47 @@ export function legacyAttachmentOffset(points, accessory) {
  * Attachments may explicitly transform a numbered part around an origin.
  */
 export function deformLegacyAssembly(bytes, options) {
-  const info = inspectLegacyAssembly(bytes),
-    result = bytes.slice();
-  if (!/^[a-f0-9]{64}$/.test(options.geometryKey || ""))
-    invalid("missing geometry cache key");
-  const view = new DataView(result.buffer),
-    map = mapper(options);
-  const read = (at) => [0, 1, 2].map((i) => view.getFloat32(at + i * 4, true));
-  const write = (at, values) =>
-    values.forEach((v, i) => view.setFloat32(at + i * 4, finite(v), true));
-  const unit = (v) => {
-    const n = Math.hypot(...v);
-    return n > 1e-9 ? v.map((x) => x / n) : v;
-  };
+  const info = inspectLegacyAssembly(bytes), result = bytes.slice();
+  if (!/^[a-f0-9]{64}$/.test(options.geometryKey || '')) invalid('missing geometry cache key');
+  const view = new DataView(result.buffer), map = mapper(options);
+  const read = at => [0, 1, 2].map(i => view.getFloat32(at + i * 4, true));
+  const write = (at, values) => values.forEach((v, i) => view.setFloat32(at + i * 4, finite(v), true));
+  const unit = v => { const n = Math.hypot(...v); return n > 1e-9 ? v.map(x => x / n) : v; };
   function transform(part, mapping) {
     for (let i = 0; i < part.vertexCount; i++) {
-      const at = part.vertexOffset + i * STRIDE,
-        p = read(at),
-        d = derivative(mapping, p);
+      const at = part.vertexOffset + i * STRIDE, p = read(at), d = derivative(mapping, p);
       // The two pose positions are DELTAS: preserve zero as zero and deform the
       // target position before subtracting the newly transformed base.
-      for (const offset of [24, 48]) {
-        const delta = read(at + offset),
-          target = mapping(...p.map((v, k) => v + delta[k]));
-        write(
-          at + offset,
-          target.map((v, k) => v - d.base[k]),
-        );
-      }
-      for (const offset of [12, 36, 60, 84])
-        write(at + offset, unit(d.normal(read(at + offset))));
+      for (const offset of [24, 48]) { const delta = read(at + offset), target = mapping(...p.map((v, k) => v + delta[k])); write(at + offset, target.map((v, k) => v - d.base[k])); }
+      for (const offset of [12, 36, 60, 84]) write(at + offset, unit(d.normal(read(at + offset))));
       write(at, d.base);
     }
     for (let i = 0; i < part.furCount; i++) {
-      const at = part.furOffset + i * 64,
-        d = derivative(mapping, read(at));
-      write(at, d.base);
-      write(at + 12, unit(d.normal(read(at + 12))));
-      write(at + 24, unit(d.vector(read(at + 24))));
+      const at = part.furOffset + i * 64, d = derivative(mapping, read(at));
+      write(at, d.base); write(at + 12, unit(d.normal(read(at + 12)))); write(at + 24, unit(d.vector(read(at + 24))));
     }
     result.set(encoder.encode(options.geometryKey), part.nameOffset);
   }
   transform(info.body, map);
   for (const attachment of options.attachments || []) {
     const part = info.parts[attachment.part];
-    if (!part || part.part === 0) invalid("attachment index");
-    const scale = attachment.scale || [1, 1, 1],
-      origin = attachment.origin || [0, 0, 0],
-      translate = attachment.translate || [0, 0, 0];
-    if (
-      [scale, origin, translate].some(
-        (v) => v.length !== 3 || v.some((x) => !Number.isFinite(x)),
-      ) ||
-      scale.some((x) => x <= 0)
-    )
-      invalid("attachment transform");
-    transform(part, (...p) =>
-      p.map((v, k) => (v - origin[k]) * scale[k] + origin[k] + translate[k]),
-    );
+    if (!part || part.part === 0) invalid('attachment index');
+    const scale = attachment.scale || [1, 1, 1], origin = attachment.origin || [0, 0, 0], translate = attachment.translate || [0, 0, 0];
+    if ([scale, origin, translate].some(v => v.length !== 3 || v.some(x => !Number.isFinite(x))) || scale.some(x => x <= 0)) invalid('attachment transform');
+    transform(part, (...p) => p.map((v, k) => (v - origin[k]) * scale[k] + origin[k] + translate[k]));
     // Independent transformed parts must not alias the body's cache identity.
     const key = options.attachmentKeys?.[attachment.part];
-    if (!/^[a-f0-9]{64}$/.test(key || "")) invalid("attachment cache key");
+    if (!/^[a-f0-9]{64}$/.test(key || '')) invalid('attachment cache key');
     result.set(encoder.encode(key), part.nameOffset);
   }
   // Keep original extents while admitting moved accessories and the new body.
-  const transformed = [
-    info.body,
-    ...(options.attachments || []).map((a) => info.parts[a.part]),
-  ];
-  for (const part of transformed)
-    for (let i = 0; i < part.vertexCount; i++) {
-      const p = read(part.vertexOffset + i * STRIDE);
-      for (let k = 0; k < 3; k++) {
-        view.setFloat32(
-          4 + k * 4,
-          Math.min(view.getFloat32(4 + k * 4, true), p[k]),
-          true,
-        );
-        view.setFloat32(
-          16 + k * 4,
-          Math.max(view.getFloat32(16 + k * 4, true), p[k]),
-          true,
-        );
-      }
+  const transformed = [info.body, ...(options.attachments || []).map(a => info.parts[a.part])];
+  for (const part of transformed) for (let i = 0; i < part.vertexCount; i++) {
+    const p = read(part.vertexOffset + i * STRIDE);
+    for (let k = 0; k < 3; k++) {
+      view.setFloat32(4 + k * 4, Math.min(view.getFloat32(4 + k * 4, true), p[k]), true);
+      view.setFloat32(16 + k * 4, Math.max(view.getFloat32(16 + k * 4, true), p[k]), true);
     }
+  }
   return result;
 }

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

@@ -2,14 +2,6 @@
 // the recovered engine, packaged meshes and native manifests remain intact.
 import createModule from './orbit-characters.mjs';
 import { decodeAppearance, encodeAppearance } from './appearance-codec.mjs';
-import { composePresetBody, composeCatalogParts } from './catalog-parts.mjs';
-import {
-  fitAuthoredEyeSpacing,
-  fitAuthoredHeadwear,
-  shapeFaceLayout,
-  authoredAssemblyRecords,
-} from './authored-parts.mjs';
-import { sha256 } from './sha256.mjs';
 import {
   deformLegacyAssembly,
   inspectLegacyAssembly,
@@ -18,8 +10,13 @@ import {
 const engine = createModule({
   locateFile: (file) => new URL(file, import.meta.url).href,
 });
-const digest = (value) =>
-  sha256(typeof value === 'string' ? new TextEncoder().encode(value) : value);
+const digest = async (value) =>
+  Array.from(
+    new Uint8Array(
+      await crypto.subtle.digest('SHA-256', typeof value === 'string' ? new TextEncoder().encode(value) : value),
+    ),
+    (byte) => byte.toString(16).padStart(2, '0'),
+  ).join('');
 // Cache only identities, never the large prepared buffers. The same face with
 // no accessories tells us exactly which meshes belong to eyes and eyewear.
 const faceIdentities = new Map();
@@ -28,12 +25,8 @@ async function accessoryTransforms(module, data, source) {
   // The editor selects one accessory. Preserve any unknown multi-accessory
   // state rather than guessing which of its pieces should move together.
   if (appearance.accessories.length !== 1) return {};
-  const translate = legacyAttachmentOffset(
-    data.points,
-    appearance.accessories[0],
-  );
-  if (!translate || translate.every((value) => Math.abs(value) < 1e-6))
-    return {};
+  const translate = legacyAttachmentOffset(data.points, appearance.accessories[0]);
+  if (!translate || translate.every(value => Math.abs(value) < 1e-6)) return {};
   appearance.accessories = [];
   appearance.accessoryColors = {};
   if (appearance.model) appearance.model.accessories = {};
@@ -41,35 +34,22 @@ async function accessoryTransforms(module, data, source) {
   const key = `${await digest(bytes)}:${data.quality}:${data.activities}`;
   let names = faceIdentities.get(key);
   if (!names) {
-    const base = module.orbitPrepareAssembly(
-      bytes,
-      data.quality,
-      `${data.key}:attachment-base`,
-      data.activities,
-    );
-    if (!base.bytes)
-      throw new Error(base.error || 'Accessory reference preparation failed');
-    names = new Set(
-      inspectLegacyAssembly(base.bytes)
-        .parts.slice(1)
-        .map((part) => part.name),
-    );
+    const base = module.orbitPrepareAssembly(bytes, data.quality, `${data.key}:attachment-base`, data.activities);
+    if (!base.bytes) throw new Error(base.error || 'Accessory reference preparation failed');
+    names = new Set(inspectLegacyAssembly(base.bytes).parts.slice(1).map(part => part.name));
     faceIdentities.set(key, names);
-    if (faceIdentities.size > 32)
-      faceIdentities.delete(faceIdentities.keys().next().value);
+    if (faceIdentities.size > 32) faceIdentities.delete(faceIdentities.keys().next().value);
   }
   // Do not move anything unless every original face mesh survives unchanged.
-  const current = new Set(source.parts.slice(1).map((part) => part.name));
-  if ([...names].some((name) => !current.has(name))) return {};
-  const attachments = source.parts
-    .slice(1)
-    .filter((part) => !names.has(part.name))
-    .map((part) => ({ part: part.part, translate }));
+  const current = new Set(source.parts.slice(1).map(part => part.name));
+  if ([...names].some(name => !current.has(name))) return {};
+  const attachments = source.parts.slice(1)
+    .filter(part => !names.has(part.name))
+    .map(part => ({ part: part.part, translate }));
   const attachmentKeys = {};
-  for (const attachment of attachments)
-    attachmentKeys[attachment.part] = await digest(
-      JSON.stringify([source.parts[attachment.part].name, translate]),
-    );
+  for (const attachment of attachments) attachmentKeys[attachment.part] = await digest(
+    JSON.stringify([source.parts[attachment.part].name, translate]),
+  );
   return { attachments, attachmentKeys };
 }
 let queue = Promise.resolve();
@@ -83,12 +63,7 @@ self.onmessage = ({ data }) => {
         data.key,
         data.activities,
       );
-      // Native preparation may return a view of temporary storage. Subsequent
-      // face/donor reference calls must never overwrite the target scene.
-      if (result.bytes) result.bytes = result.bytes.slice();
-      if (result.bytes && data.authoredParts?.bodyPreset)
-        result.bytes = await composePresetBody(module, result.bytes, data);
-      if (result.bytes && data.points) {
+      if (result.bytes) {
         const source = inspectLegacyAssembly(result.bytes);
         const geometryKey = await digest(
           JSON.stringify([source.body.name, data.points]),
@@ -96,43 +71,9 @@ self.onmessage = ({ data }) => {
         result.bytes = deformLegacyAssembly(result.bytes, {
           points: data.points,
           geometryKey,
-          ...(await accessoryTransforms(module, data, source)),
+          ...await accessoryTransforms(module, data, source),
         });
       }
-      if (result.bytes && data.authoredParts)
-        data.faceLayout = shapeFaceLayout(
-          authoredAssemblyRecords(result.bytes),
-          data,
-          module,
-        );
-      if (
-        result.bytes &&
-        (data.authoredParts?.shape === 'clippo' ||
-          data.authoredParts?.eyes === 'clippo')
-      ) {
-        const { composeClippoAssembly } = await import('./clippo-geometry.mjs');
-        result.bytes = await composeClippoAssembly(module, result.bytes, data);
-      }
-      if (result.bytes && data.authoredParts) {
-        result.bytes = await composeCatalogParts(module, result.bytes, data, [
-          'eyes',
-          'accessory',
-        ]);
-        if (data.authoredParts.eyes === 'cyclops') {
-          const { composeCyclopsAssembly } =
-            await import('./cyclops-geometry.mjs');
-          result.bytes = await composeCyclopsAssembly(
-            module,
-            result.bytes,
-            data,
-          );
-        }
-        result.bytes = await composeCatalogParts(module, result.bytes, data, [
-          'eyewear',
-        ]);
-        result.bytes = await fitAuthoredEyeSpacing(result.bytes, data);
-        result.bytes = await fitAuthoredHeadwear(result.bytes, data);
-      }
       self.postMessage(
         { id: data.id, ...result },
         result.bytes ? [result.bytes.buffer] : [],

package/assets/character-runtime/managed-avatar.mjs

@@ -1,10 +1,21 @@
 import { renderBudget } from './render-budget.mjs';
-import { characterPixels } from './resolution.mjs';
 
 const snapshots = new Map();
 const waiting = new Map();
-// Presentation lifetime is independent of the rendering lease. Offscreen and
-// paused avatars retain real engine pixels until they need rendering again.
+const pixelsFor = (canvas) =>
+  Math.max(
+    64,
+    Math.min(
+      512,
+      Math.round(
+        Math.min(canvas.clientWidth, canvas.clientHeight) *
+          Math.min(devicePixelRatio || 1, 2),
+      ),
+    ),
+  );
+
+// Presentation lifetime is independent of the GPU lease. Overflow avatars keep
+// their real engine pixels and can reclaim a lease through pointer/command input.
 export function createManagedAvatar(canvas, initial, callbacks, factory) {
   let props = initial,
     controller,
@@ -31,7 +42,7 @@ export function createManagedAvatar(canvas, initial, callbacks, factory) {
       props.config.character,
       props.legacy,
       props.config.lookAt,
-      characterPixels(canvas),
+      pixelsFor(canvas),
     ]);
   const priority = () =>
     pendingWork || pendingReaction || performance.now() < urgentUntil
@@ -46,6 +57,7 @@ export function createManagedAvatar(canvas, initial, callbacks, factory) {
       visible: (visible || props.portrait) && !document.hidden,
       still: still(),
       priority: still() ? 0 : priority(),
+      interactive: !!props.interactive,
       needsPaint: !ready,
     });
   function promote(duration = 5000) {
@@ -56,8 +68,7 @@ export function createManagedAvatar(canvas, initial, callbacks, factory) {
     refresh();
   }
   function commands() {
-    const state = controller?.diagnostics?.();
-    if (disposed || still() || !ready || !state?.ready || state.pending) return;
+    if (!controller?.diagnostics?.()?.ready) return;
     if (pendingWork)
       promote(
         2500 * Math.max(1, Math.min(10, props.workingCycles || 1)) + 1000,
@@ -108,13 +119,9 @@ export function createManagedAvatar(canvas, initial, callbacks, factory) {
               for (const receive of waiting.get(cacheKey) ?? []) receive();
             }
             callbacks.onPaint?.();
-            // Scope replacements and in-place edits may settle without another
-            // onReady event. Deliver retained commands only after their paint.
-            if (pendingWork || pendingReaction) queueMicrotask(commands);
           },
         });
         controller = created;
-        if (!disposed) callbacks.onPreparationStart?.();
         created.update(props, true);
         return created;
       } finally {
@@ -172,8 +179,7 @@ export function createManagedAvatar(canvas, initial, callbacks, factory) {
       pendingReaction = false;
     }
     appearance();
-    const state = controller?.diagnostics?.();
-    const queueCommands = !ready || !state?.ready || !!state.pending;
+    const queueCommands = !controller?.diagnostics?.()?.ready;
     if (!still() && (work || reaction)) {
       if (queueCommands) {
         pendingWork ||= work;