@forgeax/engine-vfx-render 0.1.4 → 0.1.7

package/dist/index.mjs

@@ -1,9 +1,8 @@
 import { frustum } from '@forgeax/engine-math';
-import { RenderFeatureStageFailedError, RENDER_FEATURE_VERTEX_LAYOUTS, RenderFeaturePreparationFailedError } from '@forgeax/engine-render';
 import { Transform } from '@forgeax/engine-scene';
 import { err, ok } from '@forgeax/engine-types';
-import { VFX_GPU_RUNTIME_RESOURCE_KEY, vfxGpuEffectContribution, vfxGpuRuntimePlugin, resolveVfxDataInterfaces, ParticleEffectPlayer } from '@forgeax/engine-vfx';
-import { getAssetRegistryResolver } from '@forgeax/engine-assets-runtime/internal';
+import { VFX_GPU_RUNTIME_RESOURCE_KEY, vfxGpuEffectContribution, vfxGpuEffectPackLoader, vfxGpuRuntimePlugin, resolveVfxDataInterfaces, ParticleEffectPlayer } from '@forgeax/engine-vfx';
+import { getAssetRegistryResolver } from '@forgeax/engine-assets-runtime';
 import { createWorldContext } from '@forgeax/engine-ecs';
 
 // src/feature/event-resources.ts
@@ -59,6 +58,34 @@ function encodeEventInputs(intent) {
 function eventCounterData() {
   return new Uint8Array(VFX_EVENT_COUNTER_BYTES);
 }
+
+// ../render/src/errors/render.ts
+var renderFeatureRecoveryHintByRecovery = {
+  "next-frame": (featureIdentity, stage) => `correct '${featureIdentity}' ${stage} data and retry on the next frame`,
+  "renderer-recover": (featureIdentity, _stage) => `wait for renderer recovery before retrying '${featureIdentity}'`,
+  registration: (featureIdentity, _stage) => `correct '${featureIdentity}' registration before retrying`
+};
+var RenderFeatureStageFailedError = class extends Error {
+  code = "render-feature-stage-failed";
+  expected;
+  hint;
+  detail;
+  constructor(featureIdentity, order, stage, recovery) {
+    const expected = `feature '${featureIdentity}' completes its ${stage} stage without an error`;
+    const hint = renderFeatureRecoveryHintByRecovery[recovery](featureIdentity, stage);
+    super(`render feature '${featureIdentity}' failed during ${stage}`);
+    this.name = "RenderFeatureStageFailedError";
+    this.expected = expected;
+    this.hint = hint;
+    this.detail = { featureIdentity, order, stage, recovery };
+  }
+};
+var RENDER_FEATURE_VERTEX_LAYOUTS = Object.freeze({
+  positionSizeColorInstance: "position-size-color-instance",
+  billboardMaterialInstance: "billboard-material-instance",
+  topologySegmentInstance: "topology-segment-instance",
+  meshGeometryMaterialInstance: "mesh-geometry-material-instance"
+});
 var PARTICLE_SHADER_IDENTIFIERS = Object.freeze({
   billboard: "forgeax::vfx-render.particles.billboard",
   mesh: "forgeax::vfx-render.particles.mesh",
@@ -144,9 +171,6 @@ function particleMaterialPass(kind, material) {
     ...pass?.renderState === void 0 ? {} : { renderState: pass.renderState }
   };
 }
-function particleMaterialUsesSceneDepth(contract) {
-  return contract === "group-0-resource" || contract === "view-with-resource";
-}
 function particleMaterialUsesBindings(material) {
   return (material?.parameters?.length ?? 0) > 0;
 }
@@ -164,19 +188,19 @@ function canonicalMeshVertices(mesh) {
   const tangents = floatAttribute(mesh.attributes.tangent);
   const result = new Float32Array(vertexCount * 12);
   for (let index = 0; index < vertexCount; index += 1) {
-    const target2 = index * 12;
-    result.set(positions.subarray(index * 3, index * 3 + 3), target2);
+    const target = index * 12;
+    result.set(positions.subarray(index * 3, index * 3 + 3), target);
     result.set(
       normals.length >= index * 3 + 3 ? normals.subarray(index * 3, index * 3 + 3) : [0, 0, 1],
-      target2 + 3
+      target + 3
     );
     result.set(
       uvs.length >= index * 2 + 2 ? uvs.subarray(index * 2, index * 2 + 2) : [0, 0],
-      target2 + 6
+      target + 6
     );
     result.set(
       tangents.length >= index * 4 + 4 ? tangents.subarray(index * 4, index * 4 + 4) : [1, 0, 0, 1],
-      target2 + 8
+      target + 8
     );
   }
   return result;
@@ -374,13 +398,13 @@ var BILLBOARD_INSTANCE_BYTES = 31 * 4;
 var MESH_INSTANCE_BYTES = 28 * 4;
 var COUNTERS_BYTES = 24;
 var RUNTIME_BYTES = 72 * 4;
-var MAX_TICK_RINGS = 8;
 var IDENTITY_MATRIX = new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
 function createVfxRenderInspectSnapshot(input) {
   return {
     topology: input.topology,
     counters: { capacity: input.capacity, produced: input.produced, dropped: input.dropped },
     stageReadiness: input.stageReadiness,
+    stageOutput: input.stageOutput ?? "empty",
     providerReadiness: input.providerReadiness,
     gpuTiming: input.gpuTiming
   };
@@ -486,7 +510,7 @@ function emitterVisible(intent, camera, localToWorld) {
     (bounds.max[2] - bounds.min[2]) * 0.5
   );
   const matrix = (index) => localToWorld[index] ?? 0;
-  const worldPosition = new Float32Array([
+  const worldCenter = new Float32Array([
     matrix(0) * center[0] + matrix(4) * center[1] + matrix(8) * center[2] + matrix(12),
     matrix(1) * center[0] + matrix(5) * center[1] + matrix(9) * center[2] + matrix(13),
     matrix(2) * center[0] + matrix(6) * center[1] + matrix(10) * center[2] + matrix(14)
@@ -497,81 +521,53 @@ function emitterVisible(intent, camera, localToWorld) {
     Math.hypot(matrix(8), matrix(9), matrix(10))
   );
   const planes = frustum.fromViewProjection(frustum.create(), camera.viewProjection);
-  return frustum.intersectsSphere(planes, worldPosition, radius * scale);
+  return frustum.intersectsSphere(planes, worldCenter, radius * scale);
 }
 function resetData(size) {
   return new Uint8Array(size);
 }
-function target(targets, kind) {
-  return targets.find((entry) => entry.kind === kind);
-}
-function missingMeshPreparation(guid) {
-  return new RenderFeaturePreparationFailedError(
-    IDENTITY,
-    -1,
-    "asset-load",
-    "vertex-data",
-    `mesh:${guid}`,
-    "asset-not-ready",
-    "next-frame"
-  );
-}
-function materialResourceKey(shader) {
-  return shader.replaceAll(/[^a-zA-Z0-9_.:-]/g, "_");
-}
 function requiresSceneDepth(intent) {
   return (intent.emitter.reflection.dataInterfaces ?? []).some(
     (requirement) => requirement.kind === "scene-depth"
   );
 }
-function gpuParticleRenderFeature(options) {
-  const worldIds = /* @__PURE__ */ new WeakMap();
-  let nextWorldId = 0;
-  const states = /* @__PURE__ */ new Map();
-  let lastObservation = Object.freeze({
-    frameNumber: -1,
-    dispatches: 0,
-    indirectDraws: 0,
-    subjectOutputs: 0
-  });
-  const keyOf = (world, intent) => {
-    let worldId = worldIds.get(world);
-    if (worldId === void 0) {
-      worldId = nextWorldId++;
-      worldIds.set(world, worldId);
-    }
-    return `${worldId}:${intent.player}:${intent.emitter.id}`;
-  };
-  const stateFor = (world, intent) => {
-    const key = keyOf(world, intent);
-    let state = states.get(key);
-    if (state !== void 0 && state.fingerprint !== intent.programFingerprint) {
-      states.delete(key);
-      state = void 0;
+function planFailure() {
+  return new RenderFeatureStageFailedError(IDENTITY, -1, "plan", "next-frame");
+}
+function planName(value, maxLength = 24) {
+  const normalized = value.toLowerCase().replaceAll(/[^a-z0-9.-]/g, "-");
+  return (normalized.length === 0 ? "unnamed" : normalized).slice(0, maxLength);
+}
+function computeBindingEntries(intent, resources) {
+  const declared = new Set(
+    (intent.emitter.reflection.bindings[0]?.entries ?? []).filter((entry) => entry.buffer !== void 0).map((entry) => entry.binding)
+  );
+  return Object.entries(resources).flatMap(
+    ([binding, resource]) => declared.has(Number(binding)) ? [{ binding: Number(binding), resource }] : []
+  );
+}
+function simulationDispatches(intent, stages) {
+  const groups = Math.max(1, Math.ceil(intent.emitter.capacity / WORKGROUP_SIZE));
+  return [
+    { kind: "direct", entryPoint: "forgeax_vfx_spawn_main", workgroups: [groups] },
+    { kind: "direct", entryPoint: "forgeax_vfx_update_main", workgroups: [groups] },
+    ...stages.stages.map((stage) => ({
+      kind: "direct",
+      entryPoint: stage.entryPoint,
+      workgroups: [groups]
+    })),
+    { kind: "direct", entryPoint: "forgeax_vfx_scan_blocks_main", workgroups: [groups] },
+    { kind: "direct", entryPoint: "forgeax_vfx_scan_block_offsets_main", workgroups: [1] },
+    { kind: "direct", entryPoint: "forgeax_vfx_add_offsets_main", workgroups: [groups] },
+    { kind: "direct", entryPoint: "forgeax_vfx_compact_main", workgroups: [groups] },
+    {
+      kind: "direct",
+      entryPoint: "forgeax_vfx_event_main",
+      workgroups: [Math.max(1, Math.ceil(eventInputCapacity(intent.emitter) / 64))]
     }
-    if (state !== void 0) return state;
-    const fingerprint = intent.programFingerprint.slice(0, 12).replaceAll(":", "_");
-    state = {
-      world,
-      player: intent.player,
-      emitterId: intent.emitter.id,
-      fingerprint: intent.programFingerprint,
-      capacity: intent.emitter.capacity,
-      names: `gpu.${key.replaceAll(":", ".")}.${fingerprint}`,
-      rings: [],
-      projections: [],
-      draws: [],
-      depthSampledDraws: [],
-      colorTarget: void 0,
-      depthTarget: void 0,
-      indirectInitialized: false,
-      culled: false,
-      stageReadiness: [],
-      stageOutput: "empty"
-    };
-    states.set(key, state);
-    return state;
-  };
+  ];
+}
+function gpuParticleRenderFeature(options) {
   return {
     identity: IDENTITY,
     requiredCapabilities: ["compute", "indirectDrawing"],
@@ -586,676 +582,399 @@ function gpuParticleRenderFeature(options) {
         const intents = runtime.snapshot().filter((intent) => {
           if (options.playerConsumption?.isEnabled(world, intent.player) === false) return false;
           const requirements = intent.emitter.reflection.dataInterfaces ?? [];
-          if (requirements.length === 0) return true;
-          return options.dataInterfaces?.resolve(requirements, intent.instanceGeneration).ok === true;
+          return requirements.length === 0 || options.dataInterfaces?.resolve(requirements, intent.instanceGeneration).ok === true;
         });
         extracted.push({ world, runtime, camera, intents });
       }
       return ok({ worlds: extracted, frameNumber: context.frameNumber });
     },
-    prepare: (frame, context) => {
-      const gpu = context.gpu;
-      if (gpu === void 0) {
-        return err(new RenderFeatureStageFailedError(IDENTITY, -1, "prepare", "renderer-recover"));
-      }
-      let pendingProgramError;
-      const preparedIntents = [];
-      for (const entry of frame.worlds) {
-        for (const intent of entry.intents) {
-          const key = keyOf(entry.world, intent);
-          let state = states.get(key);
-          const candidate = validatedStagePlan(
+    plan: (frame, context) => {
+      const resources = [];
+      const passes = [];
+      const dispatchedIntents = /* @__PURE__ */ new Set();
+      const colorTarget = context.targets.find((candidate) => candidate.kind === "color") ?? context.targets.find((candidate) => candidate.kind === "swapchain");
+      const depthTarget = context.targets.find((candidate) => candidate.kind === "depth");
+      for (const [worldIndex, entry] of frame.worlds.entries()) {
+        for (const [intentIndex, intent] of entry.intents.entries()) {
+          if (!entry.runtime.isEmitterSessionEnabled(intent.player, intent.emitter.id)) continue;
+          const localToWorld = emitterTransform(entry.world, intent);
+          const visible = emitterVisible(intent, entry.camera, localToWorld);
+          entry.runtime.setEmitterCameraVisibility(intent.player, intent.emitter.id, visible);
+          if (!visible) continue;
+          if (requiresSceneDepth(intent) && depthTarget === void 0) continue;
+          const stagePlan = validatedStagePlan(
             intent.emitter.reflection.stages,
             intent.instanceGeneration
           );
-          if (!candidate.ok) {
-            if (state === void 0) {
-              return err(new RenderFeatureStageFailedError(IDENTITY, -1, "prepare", "next-frame"));
-            }
-            const observation2 = observeStagePlan(
-              candidate,
-              intent.instanceGeneration,
-              state.lastKnownGoodStage
-            );
-            state.stagePlan = observation2.validatedStagePlan;
-            state.stageReadiness = observation2.stageReadiness;
-            state.stageOutput = observation2.stageOutput;
-            continue;
-          }
-          if (state !== void 0 && state.fingerprint !== intent.programFingerprint) {
-            states.delete(key);
-            state = void 0;
-          }
-          state ??= stateFor(entry.world, intent);
-          const observation = observeStagePlan(
-            candidate,
-            intent.instanceGeneration,
-            state.lastKnownGoodStage
+          if (!stagePlan.ok) return err(planFailure());
+          const prefix = `vfx.w-${worldIndex}.i-${intentIndex}.${planName(intent.emitter.id)}`;
+          const program = `${prefix}.compute-program`;
+          const particles = `${prefix}.particles`;
+          const runtime = `${prefix}.runtime`;
+          const aliveIndices = `${prefix}.alive-indices`;
+          const counters = `${prefix}.counters`;
+          const indirect = `${prefix}.indirect`;
+          const scratch = `${prefix}.scratch`;
+          const sharedInstances = `${prefix}.shared-instances`;
+          const eventInputs = `${prefix}.event-inputs`;
+          const events = `${prefix}.events`;
+          const bindings = `${prefix}.simulation-bindings`;
+          const capacity = intent.emitter.capacity;
+          const renderers = intent.emitter.renderers;
+          const meshes = renderers.map(
+            (renderer) => renderer.kind === "mesh" ? options.mesh?.read(entry.world, renderer.mesh) : void 0
           );
-          state.stagePlan = observation.validatedStagePlan;
-          state.lastKnownGoodStage = candidate.value;
-          state.stageReadiness = observation.stageReadiness;
-          state.stageOutput = observation.stageOutput;
-          const program = gpu.prepareProgram(`${state.names}.program`, {
-            wgsl: intent.emitter.wgsl,
-            entryPoints: intent.emitter.reflection.entryPoints,
-            bindings: intent.emitter.reflection.bindings
-          });
-          if (!program.ok) {
-            if (program.error.code !== "render-feature-preparation-failed" || program.error.detail.recovery !== "next-frame") {
-              return program;
+          const indirectWords = new Uint32Array(Math.max(1, renderers.length) * 5);
+          for (const [rendererIndex, renderer] of renderers.entries()) {
+            const mesh = meshes[rendererIndex];
+            const submesh = renderer.kind === "mesh" ? mesh?.submeshes[renderer.submesh ?? 0] : void 0;
+            if (renderer.kind === "mesh" && submesh === void 0) return err(planFailure());
+            if ((renderer.kind === "ribbon" || renderer.kind === "trail" || renderer.kind === "beam") && !createTopologyResourcePlan(renderer).ok) {
+              return err(planFailure());
             }
-            pendingProgramError ??= program.error;
+            indirectWords[rendererIndex * 5] = renderer.kind === "mesh" ? mesh?.indices === void 0 ? submesh?.vertexCount ?? 0 : submesh?.indexCount ?? 0 : 6;
+            indirectWords[rendererIndex * 5 + 2] = renderer.kind === "mesh" && mesh?.indices !== void 0 ? submesh?.indexOffset ?? 0 : 0;
           }
-          preparedIntents.push({ entry, intent, state });
-        }
-      }
-      if (pendingProgramError !== void 0) return err(pendingProgramError);
-      let pendingGraphicsError;
-      for (const { entry, intent, state } of preparedIntents) {
-        if (intent.reset) state.indirectInitialized = false;
-        state.lastIntent = intent;
-        const base = state.names;
-        const program = gpu.prepareProgram(`${base}.program`, {
-          wgsl: intent.emitter.wgsl,
-          entryPoints: intent.emitter.reflection.entryPoints,
-          bindings: intent.emitter.reflection.bindings
-        });
-        if (!program.ok) return program;
-        const prepare = (name, size, usage, data) => gpu.prepareBuffer(`${base}.${name}`, {
-          size,
-          usage,
-          ...data === void 0 ? {} : { data }
-        });
-        const particles = prepare(
-          "particles",
-          state.capacity * PARTICLE_BYTES,
-          ["storage"],
-          intent.reset ? resetData(state.capacity * PARTICLE_BYTES) : void 0
-        );
-        if (!particles.ok) return particles;
-        const aliveIndices = prepare("alive-indices", state.capacity * 4, ["storage"]);
-        if (!aliveIndices.ok) return aliveIndices;
-        const counters = prepare(
-          "counters",
-          COUNTERS_BYTES,
-          ["storage"],
-          intent.reset ? resetData(COUNTERS_BYTES) : void 0
-        );
-        if (!counters.ok) return counters;
-        const indirect = prepare("indirect", Math.max(1, intent.emitter.renderers.length) * 20, [
-          "storage",
-          "indirect"
-        ]);
-        if (!indirect.ok) return indirect;
-        const scratchBytes = (state.capacity * 2 + Math.ceil(state.capacity / WORKGROUP_SIZE)) * 4;
-        const scratch = prepare(
-          "scratch",
-          scratchBytes,
-          ["storage"],
-          intent.reset ? resetData(scratchBytes) : void 0
-        );
-        if (!scratch.ok) return scratch;
-        const billboardInstances = prepare(
-          "billboard-instances",
-          state.capacity * Math.max(BILLBOARD_INSTANCE_BYTES, MESH_INSTANCE_BYTES),
-          ["storage", "vertex"]
-        );
-        if (!billboardInstances.ok) return billboardInstances;
-        const events = prepare(
-          "events",
-          eventCapacity(intent.emitter) * VFX_EVENT_BYTES,
-          ["storage"],
-          intent.reset ? resetData(eventCapacity(intent.emitter) * VFX_EVENT_BYTES) : void 0
-        );
-        if (!events.ok) return events;
-        const initialEventInputs = prepare(
-          "event-inputs",
-          eventInputCapacity(intent.emitter) * VFX_EVENT_INPUT_BYTES,
-          ["storage"],
-          encodeEventInputs(intent)
-        );
-        if (!initialEventInputs.ok) return initialEventInputs;
-        state.refs = {
-          program: program.value,
-          particles: particles.value,
-          aliveIndices: aliveIndices.value,
-          counters: counters.value,
-          indirect: indirect.value,
-          scratch: scratch.value,
-          billboardInstances: billboardInstances.value,
-          eventInputs: initialEventInputs.value,
-          events: events.value
-        };
-        const ringIndex = intent.tick % MAX_TICK_RINGS;
-        const runtime = gpu.prepareBuffer(`${base}.runtime.${ringIndex}`, {
-          size: RUNTIME_BYTES,
-          usage: ["uniform"],
-          data: runtimeData(intent, entry.camera, void 0, emitterTransform(entry.world, intent))
-        });
-        if (!runtime.ok) return runtime;
-        const refs = state.refs;
-        const updatedEventInputs = gpu.prepareBuffer(`${base}.event-inputs`, {
-          size: eventInputCapacity(intent.emitter) * VFX_EVENT_INPUT_BYTES,
-          usage: ["storage"],
-          data: encodeEventInputs(intent)
-        });
-        if (!updatedEventInputs.ok) return updatedEventInputs;
-        const bindings = gpu.prepareBindings(`${base}.bindings.${ringIndex}`, {
-          program: refs.program,
-          entries: [
-            { binding: 0, buffer: refs.particles },
-            { binding: 1, buffer: runtime.value },
-            { binding: 2, buffer: refs.aliveIndices },
-            { binding: 3, buffer: refs.counters },
-            { binding: 4, buffer: refs.indirect },
-            { binding: 5, buffer: refs.scratch },
-            { binding: 6, buffer: refs.billboardInstances },
-            { binding: 8, buffer: updatedEventInputs.value },
-            { binding: 9, buffer: refs.events }
-          ]
-        });
-        if (!bindings.ok) return bindings;
-        state.rings[ringIndex] = {
-          runtime: runtime.value,
-          bindings: bindings.value
-        };
-      }
-      for (const [key, state] of states) {
-        const extracted = frame.worlds.find((entry) => entry.world === state.world);
-        if (extracted === void 0 || !extracted.runtime.hasPlayer(state.player)) {
-          states.delete(key);
-          continue;
-        }
-        if (options.playerConsumption?.isEnabled(state.world, state.player) === false) {
-          state.projections = [];
-          state.draws = [];
-          state.depthSampledDraws = [];
-          state.colorTarget = void 0;
-          state.depthTarget = void 0;
-          continue;
-        }
-        const intent = state.lastIntent;
-        const refs = state.refs;
-        if (intent === void 0 || refs === void 0) continue;
-        const retained = gpu.retainBindings([
-          ...state.rings.flatMap((ring) => ring === void 0 ? [] : [ring.bindings]),
-          ...state.projections.map((projection) => projection.ring.bindings)
-        ]);
-        if (!retained.ok) return retained;
-        if (!extracted.runtime.isEmitterSessionEnabled(state.player, state.emitterId)) {
-          state.projections = [];
-          state.draws = [];
-          state.depthSampledDraws = [];
-          continue;
-        }
-        const renderers = intent.emitter.renderers;
-        if (renderers.length === 0) continue;
-        const localToWorld = emitterTransform(state.world, intent);
-        const visible = emitterVisible(intent, extracted.camera, localToWorld);
-        extracted.runtime.setEmitterCameraVisibility(state.player, state.emitterId, visible);
-        const currentIntents = extracted.intents.filter(
-          (candidate) => candidate.player === state.player && candidate.emitter.id === state.emitterId
-        );
-        if (!visible) {
-          state.culled = true;
-          state.projections = [];
-          state.draws = [];
-          state.depthSampledDraws = [];
-          continue;
-        }
-        if (state.culled && intent.emitter.simulationWhenCulled === "restart-on-visible" && !currentIntents.some((candidate) => candidate.reset)) {
-          state.projections = [];
-          state.draws = [];
-          state.depthSampledDraws = [];
-          continue;
-        }
-        state.culled = false;
-        const colorTarget = target(context.targets, "scene-color");
-        const depthTarget = target(context.targets, "scene-depth");
-        const softParticle = requiresSceneDepth(intent);
-        if (softParticle && depthTarget === void 0) continue;
-        const eventRing = state.rings[intent.tick % MAX_TICK_RINGS];
-        if (eventRing === void 0) continue;
-        const meshes = renderers.map(
-          (renderer) => renderer.kind === "mesh" ? options.mesh?.read(state.world, renderer.mesh) : void 0
-        );
-        const missingMesh = renderers.find(
-          (renderer, index) => renderer.kind === "mesh" && meshes[index]?.submeshes[renderer.submesh ?? 0] === void 0
-        );
-        if (missingMesh?.kind === "mesh") {
-          pendingGraphicsError ??= missingMeshPreparation(missingMesh.mesh);
-          continue;
-        }
-        const indirectWords = new Uint32Array(renderers.length * 5);
-        for (const [index, renderer] of renderers.entries()) {
-          const mesh = meshes[index];
-          const submesh = renderer.kind === "mesh" ? mesh?.submeshes[renderer.submesh ?? 0] : void 0;
-          const topologyPlan = renderer.kind === "ribbon" || renderer.kind === "trail" || renderer.kind === "beam" ? createTopologyResourcePlan(renderer) : void 0;
-          if (topologyPlan !== void 0 && !topologyPlan.ok)
-            return err(new RenderFeatureStageFailedError(IDENTITY, -1, "prepare", "next-frame"));
-          indirectWords[index * 5] = renderer.kind === "billboard" ? 6 : renderer.kind === "ribbon" || renderer.kind === "trail" || renderer.kind === "beam" ? 6 : mesh?.indices === void 0 ? submesh?.vertexCount ?? 0 : submesh?.indexCount ?? 0;
-          indirectWords[index * 5 + 2] = renderer.kind === "mesh" && mesh?.indices !== void 0 ? submesh?.indexOffset ?? 0 : 0;
-        }
-        const indirectInit = gpu.prepareBuffer(`${state.names}.indirect`, {
-          size: Math.max(1, renderers.length) * 20,
-          usage: ["storage", "indirect"],
-          ...state.indirectInitialized ? {} : { data: indirectWords }
-        });
-        if (!indirectInit.ok) return indirectInit;
-        state.indirectInitialized = true;
-        const draws = [];
-        const depthSampledDraws = [];
-        const projections = [];
-        for (const [rendererIndex, renderer] of renderers.entries()) {
-          const isBillboard = renderer.kind === "billboard";
-          const isTopology = renderer.kind === "ribbon" || renderer.kind === "trail" || renderer.kind === "beam";
-          const topologyPlan = isTopology ? createTopologyResourcePlan(renderer) : void 0;
-          if (topologyPlan !== void 0 && !topologyPlan.ok)
-            return err(new RenderFeatureStageFailedError(IDENTITY, -1, "prepare", "next-frame"));
-          const mesh = meshes[rendererIndex];
-          const submesh = renderer.kind === "mesh" ? mesh?.submeshes[renderer.submesh ?? 0] : void 0;
-          const indexFormat = mesh?.indices instanceof Uint32Array ? "uint32" : "uint16";
-          let material = options.material?.read(state.world, renderer.material);
-          if (material !== void 0) {
-            const resolvedMaterial = context.graphics.resolveMaterialAsset(material);
-            if (!resolvedMaterial.ok) {
-              pendingGraphicsError ??= resolvedMaterial.error;
-              continue;
-            }
-            material = resolvedMaterial.value;
-          }
-          const materialPass = particleMaterialPass(renderer.kind, material);
-          const materialKey = materialResourceKey(materialPass.shader);
-          const samplesSceneDepth = particleMaterialUsesSceneDepth(
-            context.graphics.getMaterialShaderBindingContract(materialPass.shader)
+          const scratchBytes = (capacity * 2 + Math.ceil(capacity / WORKGROUP_SIZE)) * 4;
+          const eventInputBytes = Math.max(
+            4,
+            eventInputCapacity(intent.emitter) * VFX_EVENT_INPUT_BYTES
           );
-          const particleBlend = renderer.kind === "billboard" ? renderer.blend : "alpha";
-          const projectionInstances = gpu.prepareBuffer(
-            `${state.names}.renderer.${rendererIndex}.instances`,
+          const eventBytes = Math.max(4, eventCapacity(intent.emitter) * VFX_EVENT_BYTES);
+          resources.push(
+            {
+              kind: "compute-program",
+              name: program,
+              program: {
+                wgsl: intent.emitter.wgsl,
+                entryPoints: intent.emitter.reflection.entryPoints,
+                bindings: intent.emitter.reflection.bindings
+              }
+            },
+            {
+              kind: "buffer",
+              name: particles,
+              size: capacity * PARTICLE_BYTES,
+              usage: ["storage"],
+              ...intent.reset ? { data: resetData(capacity * PARTICLE_BYTES) } : {}
+            },
+            { kind: "buffer", name: aliveIndices, size: capacity * 4, usage: ["storage"] },
+            {
+              kind: "buffer",
+              name: counters,
+              size: COUNTERS_BYTES,
+              usage: ["storage"],
+              ...intent.reset ? { data: resetData(COUNTERS_BYTES) } : {}
+            },
             {
-              size: isTopology ? topologyPlan?.ok ? topologyPlan.value.vertexBytes : 0 : state.capacity * (isBillboard ? BILLBOARD_INSTANCE_BYTES : MESH_INSTANCE_BYTES),
+              kind: "buffer",
+              name: indirect,
+              size: indirectWords.byteLength,
+              usage: ["storage", "indirect"],
+              data: indirectWords
+            },
+            {
+              kind: "buffer",
+              name: scratch,
+              size: scratchBytes,
+              usage: ["storage"],
+              ...intent.reset ? { data: resetData(scratchBytes) } : {}
+            },
+            {
+              kind: "buffer",
+              name: sharedInstances,
+              size: capacity * Math.max(BILLBOARD_INSTANCE_BYTES, MESH_INSTANCE_BYTES),
               usage: ["storage", "vertex"]
-            }
-          );
-          if (!projectionInstances.ok) return projectionInstances;
-          const projectionHistory = gpu.prepareBuffer(
-            `${state.names}.renderer.${rendererIndex}.history`,
+            },
             {
-              size: renderer.kind === "trail" ? Math.max(16, renderer.capacity * renderer.historyLength * 16) : 16,
+              kind: "buffer",
+              name: eventInputs,
+              size: eventInputBytes,
               usage: ["storage"],
-              ...intent.reset ? {
-                data: resetData(
-                  renderer.kind === "trail" ? Math.max(16, renderer.capacity * renderer.historyLength * 16) : 16
-                )
-              } : {}
-            }
-          );
-          if (!projectionHistory.ok) return projectionHistory;
-          const projectionRuntime = gpu.prepareBuffer(
-            `${state.names}.renderer.${rendererIndex}.runtime`,
+              data: encodeEventInputs(intent)
+            },
             {
+              kind: "buffer",
+              name: events,
+              size: eventBytes,
+              usage: ["storage"],
+              ...intent.reset ? { data: resetData(eventBytes) } : {}
+            },
+            {
+              kind: "buffer",
+              name: runtime,
               size: RUNTIME_BYTES,
               usage: ["uniform"],
-              data: runtimeData(
-                { ...intent, fixedDelta: 0, spawnCount: 0 },
-                extracted.camera,
-                material,
-                localToWorld,
-                renderer,
-                rendererIndex
-              )
-            }
-          );
-          if (!projectionRuntime.ok) return projectionRuntime;
-          const projectionBindings = gpu.prepareBindings(
-            `${state.names}.renderer.${rendererIndex}.bindings`,
-            {
-              program: refs.program,
-              entries: [
-                { binding: 0, buffer: refs.particles },
-                { binding: 1, buffer: projectionRuntime.value },
-                { binding: 2, buffer: refs.aliveIndices },
-                { binding: 3, buffer: refs.counters },
-                { binding: 4, buffer: refs.indirect },
-                { binding: 5, buffer: projectionHistory.value },
-                { binding: 6, buffer: projectionInstances.value },
-                { binding: 8, buffer: refs.eventInputs },
-                { binding: 9, buffer: refs.events }
-              ]
-            }
-          );
-          if (!projectionBindings.ok) return projectionBindings;
-          projections.push({
-            kind: renderer.kind,
-            instances: projectionInstances.value,
-            ring: {
-              runtime: projectionRuntime.value,
-              bindings: projectionBindings.value
+              data: runtimeData(intent, entry.camera, void 0, localToWorld)
             },
-            workgroups: Math.ceil(
-              (renderer.kind === "trail" ? renderer.capacity * Math.max(1, renderer.historyLength - 1) : renderer.kind === "ribbon" || renderer.kind === "beam" ? renderer.capacity : state.capacity) / WORKGROUP_SIZE
-            ),
-            ...renderer.kind === "trail" ? { historyWorkgroups: Math.ceil(renderer.capacity / WORKGROUP_SIZE) } : {},
-            ...renderer.kind === "billboard" ? { sorting: renderer.sorting ?? "none" } : {}
-          });
-          const pipeline = context.graphics.preparePipeline(
-            `${state.names}.renderer.${rendererIndex}.${renderer.kind}.pipeline.${materialKey}`,
             {
-              shader: materialPass.shader,
-              vertexLayout: isBillboard ? RENDER_FEATURE_VERTEX_LAYOUTS.billboardMaterialInstance : isTopology ? RENDER_FEATURE_VERTEX_LAYOUTS.topologySegmentInstance : RENDER_FEATURE_VERTEX_LAYOUTS.meshGeometryMaterialInstance,
-              colorFormats: [colorTarget?.format ?? "rgba8unorm-srgb"],
-              ...depthTarget === void 0 ? {} : { depthFormat: depthTarget.format },
-              sampleCount: colorTarget?.sampleCount ?? 1,
-              topology: submesh?.topology ?? "triangle-list",
-              ...mesh?.indices === void 0 ? {} : { indexFormat },
-              ...materialPass.renderState !== void 0 ? { renderState: materialPass.renderState } : isBillboard || isTopology ? {
-                renderState: {
-                  cullMode: "none",
-                  depthCompare: "less-equal",
-                  depthWriteEnabled: softParticle || isTopology ? false : particleBlend === "opaque-cutout",
-                  ...particleBlend === "opaque-cutout" ? {} : {
-                    blend: {
-                      color: {
-                        srcFactor: "one",
-                        dstFactor: particleBlend === "additive" ? "one" : "one-minus-src-alpha",
-                        operation: "add"
-                      },
-                      alpha: {
-                        srcFactor: "one",
-                        dstFactor: "one-minus-src-alpha",
-                        operation: "add"
-                      }
-                    }
-                  }
-                }
-              } : {}
-            }
-          );
-          if (!pipeline.ok) {
-            if (pipeline.error.code !== "render-feature-preparation-failed" || pipeline.error.detail.recovery !== "next-frame") {
-              return pipeline;
-            }
-            pendingGraphicsError ??= pipeline.error;
-            continue;
-          }
-          const graphicsBindings = context.graphics.prepareBindings(
-            `${state.names}.renderer.${rendererIndex}.${renderer.kind}.binding.${materialKey}`,
-            {
-              pipeline: pipeline.value,
-              values: {
-                group: 0,
-                shader: materialPass.shader,
-                ...samplesSceneDepth && depthTarget !== void 0 ? { sceneDepth: depthTarget } : {}
-              }
+              kind: "compute-bindings",
+              name: bindings,
+              program,
+              entries: computeBindingEntries(intent, {
+                0: particles,
+                1: runtime,
+                2: aliveIndices,
+                3: counters,
+                4: indirect,
+                5: scratch,
+                6: sharedInstances,
+                8: eventInputs,
+                9: events
+              })
             }
           );
-          if (!graphicsBindings.ok) return graphicsBindings;
-          const materialBindings = !particleMaterialUsesBindings(material) ? void 0 : context.graphics.prepareBindings(
-            `${state.names}.renderer.${rendererIndex}.${renderer.kind}.material-binding.${materialKey}`,
-            {
-              pipeline: pipeline.value,
-              values: {
-                group: 1,
-                material: {
-                  world: frame.worlds.findIndex((entry) => entry.world === state.world),
-                  guid: renderer.material
-                }
-              }
-            }
+          const entryPoints = new Set(intent.emitter.reflection.entryPoints);
+          const dispatches = simulationDispatches(intent, stagePlan.value).filter(
+            (dispatch) => entryPoints.has(dispatch.entryPoint)
           );
-          if (materialBindings !== void 0 && !materialBindings.ok) return materialBindings;
-          const drawBindings = [
-            graphicsBindings.value,
-            ...materialBindings === void 0 ? [] : [materialBindings.value]
-          ];
-          if (isBillboard || isTopology) {
-            const vertexData2 = context.graphics.prepareVertexData(
-              `${state.names}.${isTopology ? renderer.kind : "billboard"}.vertices`,
+          if (dispatches.length > 0) {
+            passes.push({
+              kind: "compute",
+              name: `${prefix}.simulate`,
+              program,
+              bindings,
+              dispatches
+            });
+            dispatchedIntents.add(intent);
+          }
+          for (const [rendererIndex, renderer] of renderers.entries()) {
+            const rendererPrefix = `${prefix}.renderer-${rendererIndex}`;
+            const isBillboard = renderer.kind === "billboard";
+            const isTopology = renderer.kind === "ribbon" || renderer.kind === "trail" || renderer.kind === "beam";
+            const topologyPlan = isTopology ? createTopologyResourcePlan(renderer) : void 0;
+            if (topologyPlan !== void 0 && !topologyPlan.ok) return err(planFailure());
+            const material = options.material?.read(entry.world, renderer.material);
+            const materialPass = particleMaterialPass(renderer.kind, material);
+            const mesh = meshes[rendererIndex];
+            const submesh = renderer.kind === "mesh" ? mesh?.submeshes[renderer.submesh ?? 0] : void 0;
+            const indexFormat = mesh?.indices instanceof Uint32Array ? "uint32" : "uint16";
+            const instances = `${rendererPrefix}.instances`;
+            const history = `${rendererPrefix}.history`;
+            const projectionRuntime = `${rendererPrefix}.runtime`;
+            const projectionBindings = `${rendererPrefix}.compute-bindings`;
+            const vertexLayout = isBillboard ? RENDER_FEATURE_VERTEX_LAYOUTS.billboardMaterialInstance : isTopology ? RENDER_FEATURE_VERTEX_LAYOUTS.topologySegmentInstance : RENDER_FEATURE_VERTEX_LAYOUTS.meshGeometryMaterialInstance;
+            const instanceBytes = isTopology ? topologyPlan?.value.vertexBytes ?? 16 : capacity * (isBillboard ? BILLBOARD_INSTANCE_BYTES : MESH_INSTANCE_BYTES);
+            const historyBytes = renderer.kind === "trail" ? Math.max(16, renderer.capacity * renderer.historyLength * 16) : 16;
+            resources.push(
+              {
+                kind: "buffer",
+                name: instances,
+                size: instanceBytes,
+                usage: ["storage", "vertex"]
+              },
               {
-                layout: isTopology ? RENDER_FEATURE_VERTEX_LAYOUTS.topologySegmentInstance : RENDER_FEATURE_VERTEX_LAYOUTS.billboardMaterialInstance,
-                buffer: projectionInstances.value
+                kind: "buffer",
+                name: history,
+                size: historyBytes,
+                usage: ["storage"],
+                ...intent.reset ? { data: resetData(historyBytes) } : {}
+              },
+              {
+                kind: "buffer",
+                name: projectionRuntime,
+                size: RUNTIME_BYTES,
+                usage: ["uniform"],
+                data: runtimeData(
+                  { ...intent, fixedDelta: 0, spawnCount: 0 },
+                  entry.camera,
+                  material,
+                  localToWorld,
+                  renderer,
+                  rendererIndex
+                )
+              },
+              {
+                kind: "compute-bindings",
+                name: projectionBindings,
+                program,
+                entries: computeBindingEntries(intent, {
+                  0: particles,
+                  1: projectionRuntime,
+                  2: aliveIndices,
+                  3: counters,
+                  4: indirect,
+                  5: history,
+                  6: instances,
+                  8: eventInputs,
+                  9: events
+                })
               }
             );
-            if (!vertexData2.ok) return vertexData2;
-            const draw = {
-              kind: "draw-indirect",
-              pipeline: pipeline.value,
-              bindings: drawBindings,
-              vertexData: [{ slot: 0, resource: vertexData2.value }],
-              command: { buffer: refs.indirect, offset: rendererIndex * 20 }
+            const projectionDispatches = [];
+            const pushProjection = (entryPoint, workgroups) => {
+              if (!entryPoints.has(entryPoint)) return;
+              projectionDispatches.push({
+                kind: "direct",
+                entryPoint,
+                workgroups: [Math.max(1, workgroups)]
+              });
             };
-            (samplesSceneDepth ? depthSampledDraws : draws).push(draw);
-            continue;
-          }
-          if (mesh === void 0) {
-            return err(new RenderFeatureStageFailedError(IDENTITY, -1, "prepare", "next-frame"));
-          }
-          const geometryData = canonicalMeshVertices(mesh);
-          const geometryBuffer = gpu.prepareBuffer(
-            `${state.names}.renderer.${rendererIndex}.mesh.geometry-buffer`,
-            {
-              size: geometryData.byteLength,
-              usage: ["vertex"],
-              data: geometryData
+            if (isBillboard && renderer.sorting === "back-to-front") {
+              pushProjection("forgeax_vfx_sort_main", 1);
             }
-          );
-          if (!geometryBuffer.ok) return geometryBuffer;
-          const geometry = context.graphics.prepareVertexData(
-            `${state.names}.renderer.${rendererIndex}.mesh.geometry`,
-            {
-              layout: RENDER_FEATURE_VERTEX_LAYOUTS.meshGeometryMaterialInstance,
-              buffer: geometryBuffer.value
-            }
-          );
-          if (!geometry.ok) return geometry;
-          const instances = context.graphics.prepareVertexData(
-            `${state.names}.renderer.${rendererIndex}.mesh.instances`,
-            {
-              layout: RENDER_FEATURE_VERTEX_LAYOUTS.meshGeometryMaterialInstance,
-              buffer: projectionInstances.value
-            }
-          );
-          if (!instances.ok) return instances;
-          const indexBuffer = mesh.indices === void 0 ? void 0 : gpu.prepareBuffer(`${state.names}.renderer.${rendererIndex}.mesh.index-buffer`, {
-            size: mesh.indices.byteLength,
-            usage: ["index"],
-            data: mesh.indices
-          });
-          if (indexBuffer !== void 0 && !indexBuffer.ok) return indexBuffer;
-          const indices = indexBuffer === void 0 ? void 0 : context.graphics.prepareIndexData(
-            `${state.names}.renderer.${rendererIndex}.mesh.indices`,
-            {
-              format: indexFormat,
-              buffer: indexBuffer.value
+            if (renderer.kind === "trail") {
+              pushProjection(
+                "forgeax_vfx_trail_history_main",
+                Math.ceil(renderer.capacity / WORKGROUP_SIZE)
+              );
             }
-          );
-          if (indices !== void 0 && !indices.ok) return indices;
-          const vertexData = [
-            { slot: 0, resource: geometry.value },
-            { slot: 1, resource: instances.value }
-          ];
-          draws.push(
-            indices === void 0 ? {
-              kind: "draw-indirect",
-              pipeline: pipeline.value,
-              bindings: drawBindings,
-              vertexData,
-              command: { buffer: refs.indirect, offset: rendererIndex * 20 }
-            } : {
-              kind: "draw-indexed-indirect",
-              pipeline: pipeline.value,
-              bindings: drawBindings,
-              vertexData,
-              indexData: { resource: indices.value, format: indexFormat },
-              command: { buffer: refs.indirect, offset: rendererIndex * 20 }
+            const projectionCount = renderer.kind === "trail" ? renderer.capacity * Math.max(1, renderer.historyLength - 1) : isTopology ? renderer.capacity : capacity;
+            pushProjection(
+              renderer.kind === "billboard" ? "forgeax_vfx_billboard_main" : renderer.kind === "mesh" ? "forgeax_vfx_mesh_main" : `forgeax_vfx_${renderer.kind}_main`,
+              Math.ceil(projectionCount / WORKGROUP_SIZE)
+            );
+            if (projectionDispatches.length > 0) {
+              passes.push({
+                kind: "compute",
+                name: `${rendererPrefix}.project`,
+                program,
+                bindings: projectionBindings,
+                dispatches: projectionDispatches
+              });
             }
-          );
-        }
-        state.projections = projections;
-        state.draws = draws;
-        state.depthSampledDraws = depthSampledDraws;
-        state.colorTarget = colorTarget;
-        state.depthTarget = depthTarget;
-      }
-      if (pendingGraphicsError !== void 0) return err(pendingGraphicsError);
-      return ok(void 0);
-    },
-    contribute: (frame, context) => {
-      let dispatchCount = 0;
-      let indirectDrawCount = 0;
-      let subjectOutputCount = 0;
-      for (const state of states.values()) {
-        const refs = state.refs;
-        const firstProjection = state.projections[0];
-        if (refs === void 0) continue;
-        const extracted = frame.worlds.find((entry) => entry.world === state.world);
-        if (extracted === void 0) continue;
-        if (options.playerConsumption?.isEnabled(state.world, state.player) === false) continue;
-        if (!extracted.runtime.isEmitterSessionEnabled(state.player, state.emitterId)) continue;
-        const currentIntents = extracted.intents.filter(
-          (intent) => intent.player === state.player && intent.emitter.id === state.emitterId
-        );
-        const intents = currentIntents.some(
-          (intent) => intent.programFingerprint === state.fingerprint
-        ) ? currentIntents.filter((intent) => intent.programFingerprint === state.fingerprint) : state.lastIntent === void 0 ? [] : [state.lastIntent];
-        const groups = Math.ceil(state.capacity / WORKGROUP_SIZE);
-        const dispatches = intents.flatMap((intent) => {
-          const bindings = state.rings[intent.tick % MAX_TICK_RINGS]?.bindings;
-          if (bindings === void 0) return [];
-          return [
-            { entryPoint: "forgeax_vfx_spawn_main", workgroups: [groups], bindings },
-            { entryPoint: "forgeax_vfx_update_main", workgroups: [groups], bindings },
-            ...stageDispatches(
-              state.stagePlan ?? {
-                stages: [],
-                generation: intent.instanceGeneration
+            const graphicsProgram = `${rendererPrefix}.graphics-program`;
+            const graphicsBindings = `${rendererPrefix}.graphics-bindings`;
+            const vertexData = `${rendererPrefix}.vertex-data`;
+            const renderState = isBillboard && depthTarget !== void 0 ? { ...materialPass.renderState ?? {}, depthWriteEnabled: false } : materialPass.renderState;
+            resources.push(
+              {
+                kind: "graphics-program",
+                name: graphicsProgram,
+                program: {
+                  shader: materialPass.shader,
+                  vertexLayout,
+                  colorFormats: [colorTarget?.format ?? "rgba8unorm-srgb"],
+                  ...depthTarget === void 0 ? {} : { depthFormat: depthTarget.format },
+                  sampleCount: colorTarget?.sampleCount ?? 1,
+                  topology: submesh?.topology ?? "triangle-list",
+                  ...mesh?.indices === void 0 ? {} : { indexFormat },
+                  ...renderState === void 0 ? {} : { renderState }
+                }
               },
-              groups,
-              bindings
-            ),
-            { entryPoint: "forgeax_vfx_scan_blocks_main", workgroups: [groups], bindings },
-            {
-              entryPoint: "forgeax_vfx_scan_block_offsets_main",
-              workgroups: [1],
-              bindings
-            },
-            { entryPoint: "forgeax_vfx_add_offsets_main", workgroups: [groups], bindings },
-            { entryPoint: "forgeax_vfx_compact_main", workgroups: [groups], bindings },
-            {
-              entryPoint: "forgeax_vfx_event_main",
-              workgroups: [Math.ceil(eventInputCapacity(intent.emitter) / 64)],
-              bindings
+              {
+                kind: "graphics-bindings",
+                name: graphicsBindings,
+                program: graphicsProgram,
+                values: {
+                  group: 0,
+                  runtime: projectionRuntime,
+                  instances,
+                  ...isBillboard ? { sceneDepthBinding: 1 } : {}
+                },
+                ...isBillboard && depthTarget !== void 0 ? { logicalTargets: { sceneDepth: depthTarget.name } } : {}
+              },
+              { kind: "vertex-data", name: vertexData, layout: vertexLayout, buffer: instances }
+            );
+            const drawBindings = [graphicsBindings];
+            if (particleMaterialUsesBindings(material)) {
+              const materialBindings = `${rendererPrefix}.material-bindings`;
+              resources.push({
+                kind: "graphics-bindings",
+                name: materialBindings,
+                program: graphicsProgram,
+                values: {
+                  group: 1,
+                  material: { world: worldIndex, guid: renderer.material }
+                }
+              });
+              drawBindings.push(materialBindings);
             }
-          ];
-        });
-        for (const projection of state.projections) {
-          if (projection.kind === "billboard" && projection.sorting === "back-to-front") {
-            dispatches.push({
-              entryPoint: "forgeax_vfx_sort_main",
-              workgroups: [1],
-              bindings: projection.ring.bindings
-            });
-          }
-          if (projection.kind === "trail") {
-            dispatches.push({
-              entryPoint: "forgeax_vfx_trail_history_main",
-              workgroups: [projection.historyWorkgroups ?? 1],
-              bindings: projection.ring.bindings
-            });
-          }
-          dispatches.push({
-            entryPoint: projection.kind === "billboard" ? "forgeax_vfx_billboard_main" : projection.kind === "mesh" ? "forgeax_vfx_mesh_main" : `forgeax_vfx_${projection.kind}_main`,
-            workgroups: [projection.workgroups],
-            bindings: projection.ring.bindings
-          });
-        }
-        const passBindings = firstProjection?.ring.bindings ?? intents.map((intent) => state.rings[intent.tick % MAX_TICK_RINGS]?.bindings).find((bindings) => bindings !== void 0);
-        if (passBindings === void 0 || dispatches.length === 0) continue;
-        const computePassIdentity = `${state.names}.simulate-and-project`;
-        const compute = context.staging.addComputePass(computePassIdentity, {
-          program: refs.program,
-          bindings: passBindings,
-          dispatches
-        });
-        if (!compute.ok) return compute;
-        dispatchCount += dispatches.length;
-        for (const intent of intents) {
-          extracted.runtime.markEventDispatched(state.player, intent.eventCounters);
-        }
-        for (const [drawKind, passDraws] of [
-          ["regular", state.draws],
-          ["depth-sampled", state.depthSampledDraws]
-        ]) {
-          if (passDraws.length === 0) continue;
-          const samplesDepth = drawKind === "depth-sampled";
-          const draw = context.staging.addGraphicsPass(
-            `${state.names}.draw.${drawKind}`,
-            {
-              attachments: {
-                colors: [
+            const vertexBindings = [];
+            let indexData;
+            if (renderer.kind === "mesh") {
+              if (mesh === void 0) return err(planFailure());
+              const geometryBuffer = `${rendererPrefix}.geometry-buffer`;
+              const geometry = `${rendererPrefix}.geometry`;
+              const geometryData = canonicalMeshVertices(mesh);
+              resources.push(
+                {
+                  kind: "buffer",
+                  name: geometryBuffer,
+                  size: geometryData.byteLength,
+                  usage: ["vertex"],
+                  data: geometryData
+                },
+                {
+                  kind: "vertex-data",
+                  name: geometry,
+                  layout: vertexLayout,
+                  buffer: geometryBuffer
+                }
+              );
+              vertexBindings.push(
+                { slot: 0, resource: geometry },
+                { slot: 1, resource: vertexData }
+              );
+              if (mesh.indices !== void 0) {
+                const indexBuffer = `${rendererPrefix}.index-buffer`;
+                const indices = `${rendererPrefix}.indices`;
+                resources.push(
                   {
-                    resource: state.colorTarget ?? "swapchain",
-                    format: state.colorTarget?.format ?? "rgba8unorm-srgb",
-                    loadOp: "load",
-                    storeOp: "store"
-                  }
-                ],
-                ...state.depthTarget === void 0 ? {} : {
-                  depthStencil: {
-                    resource: state.depthTarget,
-                    format: state.depthTarget.format,
-                    depthLoadOp: "load",
-                    depthStoreOp: "store"
+                    kind: "buffer",
+                    name: indexBuffer,
+                    size: mesh.indices.byteLength,
+                    usage: ["index"],
+                    data: mesh.indices
+                  },
+                  {
+                    kind: "index-data",
+                    name: indices,
+                    format: indexFormat,
+                    buffer: indexBuffer
                   }
+                );
+                indexData = { resource: indices, format: indexFormat };
+              }
+            } else {
+              vertexBindings.push({ slot: 0, resource: vertexData });
+            }
+            passes.push({
+              kind: "raster",
+              name: `${rendererPrefix}.raster`,
+              colorAttachments: [
+                {
+                  target: colorTarget?.name ?? "swapchain",
+                  loadOp: "load",
+                  storeOp: "store"
+                }
+              ],
+              ...depthTarget === void 0 ? {} : {
+                depthStencilAttachment: {
+                  target: depthTarget.name,
+                  depthLoadOp: "load",
+                  depthStoreOp: "store"
                 }
               },
-              ...state.depthTarget === void 0 || !samplesDepth ? {} : { sampledTargets: [state.depthTarget] },
-              temporalCoverage: "reactive",
-              draws: passDraws
-            },
-            { dependsOn: [{ featureIdentity: IDENTITY, passIdentity: computePassIdentity }] }
-          );
-          if (!draw.ok) return draw;
-          indirectDrawCount += passDraws.filter(
-            (record) => record.kind === "draw-indirect" || record.kind === "draw-indexed-indirect"
-          ).length;
-          subjectOutputCount += passDraws.length;
+              ...isBillboard && depthTarget !== void 0 ? { sampledTargets: [depthTarget.name] } : {},
+              draws: [
+                {
+                  program: graphicsProgram,
+                  bindings: drawBindings,
+                  vertexData: vertexBindings,
+                  ...indexData === void 0 ? {} : { indexData },
+                  draw: {
+                    kind: indexData === void 0 ? "draw-indirect" : "draw-indexed-indirect",
+                    resource: indirect,
+                    offset: rendererIndex * 20
+                  }
+                }
+              ]
+            });
+          }
         }
       }
       for (const entry of frame.worlds) {
-        const last = entry.intents.at(-1);
-        if (last !== void 0) entry.runtime.commit(last.sequence);
-      }
-      lastObservation = Object.freeze({
-        frameNumber: frame.frameNumber,
-        dispatches: dispatchCount,
-        indirectDraws: indirectDrawCount,
-        subjectOutputs: subjectOutputCount
-      });
-      return ok(void 0);
-    },
-    recover: () => {
-      const runtimes = /* @__PURE__ */ new Set();
-      for (const state of states.values()) {
-        if (!state.world.hasResource(VFX_GPU_RUNTIME_RESOURCE_KEY)) continue;
-        runtimes.add(state.world.getResource(VFX_GPU_RUNTIME_RESOURCE_KEY));
+        for (const intent of entry.intents) {
+          if (dispatchedIntents.has(intent)) {
+            entry.runtime.markEventDispatched(intent.player, intent.eventCounters);
+          }
+        }
+        const lastIntent = entry.intents.at(-1);
+        if (lastIntent !== void 0) entry.runtime.commit(lastIntent.sequence);
       }
-      for (const runtime of runtimes) runtime.recover();
-      states.clear();
-      return ok(void 0);
-    },
-    dispose: () => {
-      states.clear();
-      lastObservation = Object.freeze({
-        frameNumber: -1,
-        dispatches: 0,
-        indirectDraws: 0,
-        subjectOutputs: 0
-      });
-      return ok(void 0);
-    },
-    inspect: () => lastObservation
+      return ok({ resources, passes });
+    }
   };
 }
 function duplicate(token, providerId) {
@@ -1336,7 +1055,7 @@ function controlFailure(code, expected, hint, detail = {}) {
   return { code, expected, hint, detail };
 }
 function createVfxRuntimeHost(options) {
-  const decoderLeases = /* @__PURE__ */ new WeakMap();
+  const registries = /* @__PURE__ */ new WeakSet();
   const worlds = /* @__PURE__ */ new WeakMap();
   const pausedPlayers = /* @__PURE__ */ new WeakMap();
   let nextGeneration = 1;
@@ -1347,14 +1066,23 @@ function createVfxRuntimeHost(options) {
     const key = `${kind}:${guid.toLowerCase()}`;
     const cached = attached.renderAssets.get(key);
     if (cached?.kind === kind) return cached;
+    if ("lookup" in attached.assets) {
+      const lookup = attached.assets.lookup;
+      const legacy = lookup.call(attached.assets, guid);
+      if (legacy?.kind === kind) {
+        attached.renderAssets.set(key, legacy);
+        return legacy;
+      }
+    }
     const resolved = attached.resolver?.lookup(guid);
     if (resolved?.kind === kind) {
       attached.renderAssets.set(key, resolved);
       return resolved;
     }
-    if (!attached.pendingRenderAssets.has(key)) {
+    if ("load" in attached.assets && typeof attached.assets.load === "function" && !attached.pendingRenderAssets.has(key)) {
       const epoch = attached.catalogEpoch;
-      const request = attached.assets.load(guid, kind).then((result) => {
+      const load = attached.assets.load;
+      const request = load(guid, kind).then((result) => {
         if (!result.ok || worlds.get(world) !== attached || attached.catalogEpoch !== epoch)
           return;
         attached.renderAssets.set(key, result.value);
@@ -1482,15 +1210,22 @@ function createVfxRuntimeHost(options) {
     resolveDataInterfaces: ({ requirements, generation }) => dataInterfaces.resolve(requirements, generation),
     attachWorld: async ({ world, assets }) => {
       if (worlds.has(world)) return ok({ state: "already-attached" });
-      if (!decoderLeases.has(assets)) {
+      if (!registries.has(assets)) {
         try {
-          decoderLeases.set(assets, installVfxRuntimeDecoder(assets));
+          if ("loaders" in assets) {
+            assets.loaders.registerPackLoader(vfxGpuEffectPackLoader);
+          } else if ("installDecoder" in assets) {
+            assets.installDecoder(vfxGpuEffectContribution.kind, vfxGpuEffectContribution.decoder);
+          } else {
+            throw new TypeError("VFX assets registry exposes neither loaders nor installDecoder");
+          }
+          registries.add(assets);
         } catch (cause) {
           return err(
             failure2(
               "vfx-host-loader-install-failed",
-              "the VFX owner decoder to be installed once in the runtime core",
-              "remove a conflicting particle-effect decoder and retry attachWorld",
+              "the v2 VFX loader to be registered once",
+              "remove a conflicting particle-effect loader and retry attachWorld",
               cause
             )
           );
@@ -1514,10 +1249,12 @@ function createVfxRuntimeHost(options) {
         );
       }
       let resolver;
-      try {
-        resolver = getAssetRegistryResolver(assets);
-      } catch {
-        resolver = void 0;
+      if (!("loaders" in assets) && "installDecoder" in assets) {
+        try {
+          resolver = getAssetRegistryResolver(assets);
+        } catch {
+          resolver = void 0;
+        }
       }
       const attached = {
         assets,
@@ -1526,13 +1263,12 @@ function createVfxRuntimeHost(options) {
         generation: nextGeneration++,
         renderAssets: /* @__PURE__ */ new Map(),
         pendingRenderAssets: /* @__PURE__ */ new Map(),
-        catalogEpoch: typeof assets.snapshot === "function" ? assets.snapshot().epoch : 0,
+        catalogEpoch: "snapshot" in assets && typeof assets.snapshot === "function" ? assets.snapshot().epoch : 0,
         unsubscribeAssets: () => {
         }
       };
-      const subscribe = assets.subscribe;
-      if (subscribe !== void 0) {
-        attached.unsubscribeAssets = subscribe((snapshot) => {
+      if ("subscribe" in assets && typeof assets.subscribe === "function") {
+        attached.unsubscribeAssets = assets.subscribe((snapshot) => {
           if (snapshot.epoch === attached.catalogEpoch) return;
           attached.catalogEpoch = snapshot.epoch;
           attached.renderAssets.clear();