@forgeax/engine-vfx-render 0.1.28 → 0.1.29

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import { frustum } from '@forgeax/engine-math';
 import { GlobalTransform } from '@forgeax/engine-scene';
 import { err, ok } from '@forgeax/engine-types';
-import { VFX_GPU_RUNTIME_RESOURCE_KEY, vfxGpuEffectContribution, vfxGpuEffectPackLoader, vfxGpuRuntimePlugin, resolveVfxDataInterfaces, ParticleEffectPlayer } from '@forgeax/engine-vfx';
+import { vfxGpuEffectContribution, vfxGpuEffectPackLoader, vfxGpuRuntimePlugin, VFX_GPU_RUNTIME_RESOURCE_KEY, resolveVfxDataInterfaces, VFX_PARTICLE_CORE_STRIDE, ParticleEffectPlayer } from '@forgeax/engine-vfx';
 import { getAssetRegistryResolver } from '@forgeax/engine-assets-runtime';
 import { createWorldContext } from '@forgeax/engine-ecs';
 
@@ -55,6 +55,13 @@ function encodeEventInputs(intent) {
   }
   return bytes;
 }
+function encodeEventBuffer(intent) {
+  const inputBytes = encodeEventInputs(intent);
+  const outputBytes = eventCapacity(intent.emitter) * VFX_EVENT_BYTES;
+  const data = new Uint8Array(inputBytes.byteLength + outputBytes);
+  data.set(inputBytes);
+  return data;
+}
 function eventCounterData() {
   return new Uint8Array(VFX_EVENT_COUNTER_BYTES);
 }
@@ -83,8 +90,11 @@ var RenderFeatureStageFailedError = class extends Error {
 var RENDER_FEATURE_VERTEX_LAYOUTS = Object.freeze({
   positionSizeColorInstance: "position-size-color-instance",
   billboardMaterialInstance: "billboard-material-instance",
+  billboardMaterialInputInstance: "billboard-material-input-instance",
   topologySegmentInstance: "topology-segment-instance",
-  meshGeometryMaterialInstance: "mesh-geometry-material-instance"
+  topologySegmentMaterialInputInstance: "topology-segment-material-input-instance",
+  meshGeometryMaterialInstance: "mesh-geometry-material-instance",
+  meshGeometryMaterialInputInstance: "mesh-geometry-material-input-instance"
 });
 var PARTICLE_SHADER_IDENTIFIERS = Object.freeze({
   billboard: "forgeax::vfx-render.particles.billboard",
@@ -93,6 +103,13 @@ var PARTICLE_SHADER_IDENTIFIERS = Object.freeze({
   trail: "forgeax::vfx-render.particles.trail",
   beam: "forgeax::vfx-render.particles.beam"
 });
+var PARTICLE_INPUT_SHADER_IDENTIFIERS = Object.freeze({
+  billboard: "forgeax::vfx-render.particles.billboard-inputs",
+  mesh: "forgeax::vfx-render.particles.mesh-inputs",
+  ribbon: "forgeax::vfx-render.particles.ribbon-inputs",
+  trail: "forgeax::vfx-render.particles.trail-inputs",
+  beam: "forgeax::vfx-render.particles.beam-inputs"
+});
 function createTopologyResourcePlan(renderer) {
   if (renderer === null || typeof renderer !== "object" || Array.isArray(renderer))
     return err({
@@ -172,13 +189,121 @@ var PARTICLE_ADDITIVE_BLEND = {
   color: { srcFactor: "one", dstFactor: "one", operation: "add" },
   alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" }
 };
-function particleMaterialPass(kind, material) {
+function particleMaterialPass(kind, material, hasParticleInputs = false) {
   const pass = material?.passes?.find((candidate) => candidate.name === `particle-${kind}`);
+  const renderState = pass?.renderState ?? (kind === "mesh" ? material?.passes?.find((candidate) => {
+    const tags = candidate.renderState?.tags;
+    return candidate.name === "forward" || typeof tags === "object" && tags !== null && "LightMode" in tags && tags.LightMode === "Forward";
+  })?.renderState : void 0);
   return {
-    shader: pass?.program.module ?? PARTICLE_SHADER_IDENTIFIERS[kind],
-    ...pass?.renderState === void 0 ? {} : { renderState: pass.renderState }
+    shader: pass?.program.module ?? (hasParticleInputs ? PARTICLE_INPUT_SHADER_IDENTIFIERS[kind] : PARTICLE_SHADER_IDENTIFIERS[kind]),
+    ...renderState === void 0 ? {} : { renderState }
   };
 }
+var EMPTY_PARTICLE_MATERIAL_INPUTS = Object.freeze({
+  definitions: Object.freeze([]),
+  lanes: 0,
+  stride: 0
+});
+function particleInputFailure(code, expected, hint, detail) {
+  return err({ code, expected, hint, detail });
+}
+function isParticleInputType(value) {
+  return value === "f32" || value === "vec2<f32>" || value === "vec3<f32>" || value === "vec4<f32>";
+}
+function isParticleInputVisibility(value) {
+  return value === "vertex" || value === "fragment" || value === "vertex-fragment";
+}
+function validParticleInput(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const input = value;
+  return typeof input.name === "string" && /^[A-Za-z_][A-Za-z0-9_]*$/.test(input.name) && isParticleInputType(input.type) && isParticleInputVisibility(input.visibility) && typeof input.lane === "number" && Number.isInteger(input.lane) && input.lane >= 0 && input.lane < 4;
+}
+function sameParticleInput(left, right) {
+  return left.name === right.name && left.type === right.type && left.visibility === right.visibility && left.lane === right.lane;
+}
+function prepareParticleMaterialInputs(renderer, material, reflected) {
+  const requested = renderer.materialInputs ?? [];
+  if (requested.length === 0) return ok(EMPTY_PARTICLE_MATERIAL_INPUTS);
+  if (new Set(requested).size !== requested.length) {
+    return particleInputFailure(
+      "vfx-material-input-duplicate",
+      "unique particle input names per renderer",
+      "remove the duplicate renderer material input and recook the effect",
+      { material: renderer.material, path: "renderer.materialInputs" }
+    );
+  }
+  const definitions = material?.particleInputs;
+  if (definitions === void 0) {
+    return particleInputFailure(
+      "vfx-material-input-missing",
+      `material ${renderer.material} to declare particleInputs`,
+      "add the requested typed input to MaterialAsset and recook the material before the VFX effect",
+      { material: renderer.material, path: "material.particleInputs" }
+    );
+  }
+  const names = /* @__PURE__ */ new Set();
+  const lanes = /* @__PURE__ */ new Set();
+  for (const [index, candidate] of definitions.entries()) {
+    if (!validParticleInput(candidate)) {
+      return particleInputFailure(
+        "vfx-material-input-wrong-type",
+        "particleInputs entries with a supported type, visibility, and lane",
+        "repair the material particleInputs declaration and recook it",
+        { material: renderer.material, path: `material.particleInputs[${index}]` }
+      );
+    }
+    if (names.has(candidate.name) || lanes.has(candidate.lane)) {
+      return particleInputFailure(
+        "vfx-material-input-duplicate",
+        "unique particle input names and lanes",
+        "assign one lane to one input name and recook the material",
+        { material: renderer.material, name: candidate.name, lane: candidate.lane }
+      );
+    }
+    names.add(candidate.name);
+    lanes.add(candidate.lane);
+  }
+  const selectedDefinitions = [];
+  for (const name of requested) {
+    const input = definitions.find((candidate) => candidate.name === name);
+    if (input === void 0) {
+      return particleInputFailure(
+        "vfx-material-input-missing",
+        `material ${renderer.material} to declare particle input ${name}`,
+        "add the requested input to MaterialAsset.particleInputs and recook both assets",
+        { material: renderer.material, name, path: "renderer.materialInputs" }
+      );
+    }
+    selectedDefinitions.push(input);
+  }
+  if (reflected === void 0) {
+    return particleInputFailure(
+      "vfx-material-input-stale",
+      "cooked renderer reflection to carry the material input declarations",
+      "recook the VFX effect with the current material artifact catalog",
+      { material: renderer.material, path: "effect.reflection.renderers.materialInputDefinitions" }
+    );
+  }
+  for (const input of selectedDefinitions) {
+    const cooked = reflected.find((candidate) => candidate.name === input.name);
+    if (cooked === void 0 || !sameParticleInput(input, cooked)) {
+      return particleInputFailure(
+        "vfx-material-input-stale",
+        `the cooked declaration for material input ${input.name} to match MaterialAsset`,
+        "recook the VFX effect and material together so names, types, visibility, and lanes agree",
+        { material: renderer.material, name: input.name, lane: input.lane }
+      );
+    }
+  }
+  const lanesUsed = selectedDefinitions.map((input) => input.lane);
+  const lanesCount = Math.max(...lanesUsed, -1) + 1;
+  return ok({
+    definitions: Object.freeze([...selectedDefinitions]),
+    lanes: lanesCount,
+    stride: lanesCount * 16
+  });
+}
 function particleRendererRenderState(kind, blend, authored) {
   if (authored !== void 0) return authored;
   const isTopology = kind === "ribbon" || kind === "trail" || kind === "beam";
@@ -202,8 +327,9 @@ function particleMaterialUsesBindings(material) {
   return (material?.parameters?.length ?? 0) > 0;
 }
 function particleMaterialSceneDepthBinding(contract) {
-  if (contract === "group-0-resource") return 0;
-  if (contract === "view-and-scene-depth") return 1;
+  if (contract === "group-0-resource" || contract === "render-material-with-scene-depth") return 0;
+  if (contract === "view-and-scene-depth" || contract === "render-material-and-scene-depth")
+    return 1;
   return void 0;
 }
 function floatAttribute(value) {
@@ -425,11 +551,10 @@ function stageRecoveryReadiness(plan, generation, recovery) {
 // src/feature/gpu-particle-feature.ts
 var IDENTITY = "forgeax.vfx-render.gpu-particles";
 var WORKGROUP_SIZE = 256;
-var PARTICLE_BYTES = 80;
 var BILLBOARD_INSTANCE_BYTES = 31 * 4;
-var MESH_INSTANCE_BYTES = 28 * 4;
+var MESH_INSTANCE_BYTES = 18 * 4;
 var COUNTERS_BYTES = 24;
-var RUNTIME_BYTES = 72 * 4;
+var RUNTIME_BYTES = 76 * 4;
 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 {
@@ -467,7 +592,7 @@ function resolveBillboardAdvancedState(renderer, sample) {
     frameIndex,
     pivot: renderer.pivot ?? [0, 0],
     softParticleFade,
-    sortingKey: renderer.sorting === "back-to-front" ? sample.particleDepth : 0
+    sortingKey: renderer.sorting === "view-depth" || renderer.sorting === "view-distance" ? sample.particleDepth : 0
   });
 }
 function topologyRecoveryHint(topology, reason) {
@@ -482,10 +607,25 @@ function topologyRecoveryHint(topology, reason) {
 function finite(value, fallback) {
   return typeof value === "number" && Number.isFinite(value) ? value : fallback;
 }
+function billboardSortingMode(renderer) {
+  if (renderer?.kind !== "billboard") return 0;
+  switch (renderer.sorting) {
+    case "view-depth":
+      return 2;
+    case "view-distance":
+      return 5;
+    case "custom-ascending":
+      return 3;
+    case "custom-descending":
+      return 4;
+    default:
+      return 0;
+  }
+}
 function vector(value, fallback, size) {
   return Array.isArray(value) ? Array.from({ length: size }, (_, index) => finite(value[index], fallback[index] ?? 0)) : fallback;
 }
-function runtimeData(intent, camera, material, localToWorld, renderer, rendererIndex = 0) {
+function runtimeData(intent, camera, material, localToWorld, renderer, rendererIndex = 0, particleInputLanes = renderer?.materialInputs?.length ?? 0, meshDraw) {
   const storage = new ArrayBuffer(RUNTIME_BYTES);
   const floats = new Float32Array(storage);
   const words = new Uint32Array(storage);
@@ -500,6 +640,7 @@ function runtimeData(intent, camera, material, localToWorld, renderer, rendererI
   floats.set(camera.viewProjection, 8);
   floats.set(camera.right, 24);
   floats.set(camera.up, 28);
+  floats.set(camera.position, 72);
   const values = material?.values ?? {};
   floats.set(vector(values.baseColor, [1, 1, 1, 1], 4), 32);
   const emissive = vector(values.emissive, [0, 0, 0], 3);
@@ -511,12 +652,13 @@ function runtimeData(intent, camera, material, localToWorld, renderer, rendererI
   floats[43] = finite(values.clearcoatRoughness, 0.5);
   floats.set(localToWorld, 44);
   words[60] = rendererIndex;
-  words[61] = renderer?.kind === "trail" ? renderer.historyLength : 0;
+  words[61] = renderer === void 0 && ((intent.emitter.reflection.resources ?? []).includes("eventBuffer") || (intent.emitter.reflection.entryPoints ?? []).includes("forgeax_vfx_event_main")) ? eventInputCapacity(intent.emitter) : renderer?.kind === "trail" ? renderer.historyLength : meshDraw?.count ?? 0;
   words[62] = renderer?.kind === "ribbon" || renderer?.kind === "trail" || renderer?.kind === "beam" ? renderer.capacity : intent.emitter.capacity;
-  words[63] = renderer?.kind === "billboard" && renderer.sorting === "back-to-front" ? 2 : renderer?.kind === "billboard" && renderer.sorting === "emitter" ? 1 : 0;
+  words[63] = meshDraw?.firstIndex ?? billboardSortingMode(renderer);
   floats[64] = renderer?.kind === "billboard" ? renderer.pivot?.[0] ?? 0 : renderer?.kind === "ribbon" || renderer?.kind === "trail" || renderer?.kind === "beam" ? renderer.width ?? 0.1 : 0.1;
   floats[65] = renderer?.kind === "billboard" ? renderer.pivot?.[1] ?? 0 : 0;
   floats[66] = renderer?.kind === "billboard" ? renderer.softParticle?.fadeDistance ?? 0 : 0;
+  floats[67] = particleInputLanes;
   const sheet = renderer?.kind === "billboard" ? renderer.textureSheet : void 0;
   floats[68] = sheet?.columns ?? 1;
   floats[69] = sheet?.rows ?? 1;
@@ -529,8 +671,8 @@ function emitterTransform(world, intent) {
   const transform = world.get(intent.player, GlobalTransform);
   return transform.ok ? transform.value.world : IDENTITY_MATRIX;
 }
-function emitterVisible(intent, camera, localToWorld) {
-  const bounds = intent.emitter.bounds;
+function emitterVisible(emitter, camera, localToWorld) {
+  const bounds = emitter.bounds;
   const center = bounds.kind === "sphere" ? bounds.center : [
     (bounds.min[0] + bounds.max[0]) * 0.5,
     (bounds.min[1] + bounds.max[1]) * 0.5,
@@ -563,6 +705,36 @@ function requiresSceneDepth(intent) {
     (requirement) => requirement.kind === "scene-depth"
   );
 }
+function dataInterfacesExecutable(intent, registry) {
+  const requirements = intent.emitter.reflection.dataInterfaces ?? [];
+  if (requirements.length === 0) return true;
+  const resolved = registry?.resolve(requirements, intent.instanceGeneration);
+  if (resolved === void 0) return true;
+  if (!resolved.ok) {
+    const error = resolved.error;
+    if (error === void 0) return false;
+    return error.code === "vfx-data-interface-missing" && (error.detail.providerId === void 0 || error.expected.includes("resident"));
+  }
+  if (resolved.value === void 0) return true;
+  return resolved.value.resources.every((resource) => resource.resource !== void 0);
+}
+function preparedDataInterfaceResources(requirements, generation, prepared) {
+  if (prepared === void 0) return void 0;
+  const resources = [];
+  for (const requirement of requirements) {
+    const value = prepared[requirement.kind];
+    if (value === void 0) return void 0;
+    resources.push({
+      token: requirement.token,
+      kind: requirement.kind,
+      bindingType: requirement.bindingType,
+      generation,
+      ...requirement.sampleCount === void 0 ? {} : { sampleCount: requirement.sampleCount },
+      resource: value
+    });
+  }
+  return resources;
+}
 function planFailure() {
   return new RenderFeatureStageFailedError(IDENTITY, -1, "plan", "next-frame");
 }
@@ -572,7 +744,9 @@ function planName(value, maxLength = 24) {
 }
 function computeBindingEntries(intent, resources) {
   const declared = new Set(
-    (intent.emitter.reflection.bindings[0]?.entries ?? []).filter((entry) => entry.buffer !== void 0).map((entry) => entry.binding)
+    (intent.emitter.reflection.bindings[0]?.entries ?? []).filter(
+      (entry) => entry.buffer !== void 0 || entry.texture !== void 0 || entry.sampler !== void 0 || entry.storageTexture !== void 0
+    ).map((entry) => entry.binding)
   );
   return Object.entries(resources).flatMap(
     ([binding, resource]) => declared.has(Number(binding)) ? [{ binding: Number(binding), resource }] : []
@@ -580,6 +754,12 @@ function computeBindingEntries(intent, resources) {
 }
 function simulationDispatches(intent, stages) {
   const groups = Math.max(1, Math.ceil(intent.emitter.capacity / WORKGROUP_SIZE));
+  const compact = [
+    { 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] }
+  ];
   return [
     { kind: "direct", entryPoint: "forgeax_vfx_spawn_main", workgroups: [groups] },
     { kind: "direct", entryPoint: "forgeax_vfx_update_main", workgroups: [groups] },
@@ -588,19 +768,40 @@ function simulationDispatches(intent, stages) {
       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))]
-    }
+    ...compact,
+    ...intent.emitter.reflection.entryPoints.includes("forgeax_vfx_event_main") ? [
+      {
+        kind: "direct",
+        entryPoint: "forgeax_vfx_event_main",
+        workgroups: [1]
+      },
+      ...compact
+    ] : []
   ];
 }
 function gpuParticleRenderFeature(options) {
-  return {
+  const pendingFrames = /* @__PURE__ */ new Map();
+  const worldIds = /* @__PURE__ */ new WeakMap();
+  const runtimeIds = /* @__PURE__ */ new WeakMap();
+  const resetEpochByEmitter = /* @__PURE__ */ new WeakMap();
+  const resetEpochByIntent = /* @__PURE__ */ new WeakMap();
+  let nextWorldId = 0;
+  let nextRuntimeId = 0;
+  const worldId = (world) => {
+    const prior = worldIds.get(world);
+    if (prior !== void 0) return prior;
+    const assigned = nextWorldId++;
+    worldIds.set(world, assigned);
+    return assigned;
+  };
+  const runtimeId = (runtime) => {
+    const prior = runtimeIds.get(runtime);
+    if (prior !== void 0) return prior;
+    const assigned = nextRuntimeId++;
+    runtimeIds.set(runtime, assigned);
+    return assigned;
+  };
+  const feature = {
     identity: IDENTITY,
     requiredCapabilities: ["compute", "indirectDrawing"],
     // Generated emitter programs are first-use assets. They must hand a
@@ -608,372 +809,806 @@ function gpuParticleRenderFeature(options) {
     // diagnostic-only getCompilationInfo() round trip; pipeline creation still
     // validates the module before the pass is submitted.
     shaderModuleMode: "immediate",
-    requiredMaterialShaders: Object.values(PARTICLE_SHADER_IDENTIFIERS),
+    requiredMaterialShaders: Object.freeze([
+      ...Object.values(PARTICLE_SHADER_IDENTIFIERS),
+      ...Object.values(PARTICLE_INPUT_SHADER_IDENTIFIERS)
+    ]),
     extract: (context) => {
+      for (const frameNumber of pendingFrames.keys()) {
+        if (frameNumber + 4 < context.frameNumber) pendingFrames.delete(frameNumber);
+      }
       const extracted = [];
       for (const world of context.worlds) {
         if (!world.hasResource(VFX_GPU_RUNTIME_RESOURCE_KEY)) continue;
         const camera = options.camera.read(world);
         if (camera === void 0) continue;
         const runtime = world.getResource(VFX_GPU_RUNTIME_RESOURCE_KEY);
-        const intents = runtime.snapshot().filter((intent) => {
-          if (options.playerConsumption?.isEnabled(world, intent.player) === false) return false;
-          const requirements = intent.emitter.reflection.dataInterfaces ?? [];
-          return requirements.length === 0 || options.dataInterfaces?.resolve(requirements, intent.instanceGeneration).ok === true;
+        const retained = [];
+        runtime.forEachEmitterSource(({ player, emitter }) => {
+          const sourceIntent = runtime.lastCommittedEmitter(player, emitter.id);
+          const localToWorld = sourceIntent === void 0 ? emitter.space === "world" ? IDENTITY_MATRIX : (() => {
+            const transform = world.get(player, GlobalTransform);
+            return transform.ok ? transform.value.world : IDENTITY_MATRIX;
+          })() : emitterTransform(world, sourceIntent);
+          const visible = emitterVisible(emitter, camera, localToWorld);
+          runtime.setEmitterCameraVisibility(player, emitter.id, visible);
+          const intent = runtime.lastCommittedEmitter(player, emitter.id);
+          if (intent !== void 0) {
+            retained.push({ player, emitter, intent, localToWorld, visible });
+          }
         });
-        extracted.push({ world, runtime, camera, intents });
+        const intents = runtime.snapshot();
+        extracted.push({ world, runtime, camera, intents, retained });
       }
       return ok({ worlds: extracted, frameNumber: context.frameNumber });
     },
     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");
+      const groups = /* @__PURE__ */ new Map();
+      const outcomesByEntry = /* @__PURE__ */ new Map();
       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 outcomes = [];
+        outcomesByEntry.set(entry, outcomes);
+        const effectiveEpochByEmitter = /* @__PURE__ */ new Map();
+        const renderGeneration = entry.runtime.renderGeneration ?? 0;
+        const attachmentId = runtimeId(entry.runtime);
+        let emitterEpochs = resetEpochByEmitter.get(entry.runtime);
+        if (emitterEpochs === void 0) {
+          emitterEpochs = /* @__PURE__ */ new Map();
+          resetEpochByEmitter.set(entry.runtime, emitterEpochs);
+        }
+        let reservations = resetEpochByIntent.get(entry.runtime);
+        if (reservations === void 0) {
+          reservations = /* @__PURE__ */ new Map();
+          resetEpochByIntent.set(entry.runtime, reservations);
+        }
+        const liveResetSequences = new Set(
+          (entry.runtime.snapshot?.() ?? entry.intents).filter((intent) => intent.reset).map((intent) => intent.sequence)
+        );
+        for (const [sequence, reservation] of reservations) {
+          if (reservation.generation !== renderGeneration || !liveResetSequences.has(sequence)) {
+            reservations.delete(sequence);
+          }
+        }
+        const blockedEmitters = /* @__PURE__ */ new Set();
+        for (const intent of entry.intents) {
+          const baseKey = `${worldId(entry.world)}:${renderGeneration}:${Number(intent.player)}:${intent.emitter.id}`;
+          let priorReservedEpoch;
+          let priorReservedSequence = -1;
+          let exactReservation;
+          for (const [sequence, reservation] of reservations) {
+            if (reservation.generation === renderGeneration && reservation.emitterKey === baseKey) {
+              if (sequence === intent.sequence) {
+                exactReservation = reservation;
+              } else if (sequence < intent.sequence && sequence > priorReservedSequence) {
+                priorReservedEpoch = reservation.epoch;
+                priorReservedSequence = sequence;
+              }
+            }
+          }
+          const committedEpoch = effectiveEpochByEmitter.get(baseKey) ?? Math.max(emitterEpochs.get(baseKey) ?? 0, priorReservedEpoch ?? 0);
+          let resetEpoch = committedEpoch;
+          if (intent.reset) {
+            resetEpoch = exactReservation?.generation === renderGeneration && exactReservation.emitterKey === baseKey ? exactReservation.epoch : committedEpoch + 1;
+            reservations.set(intent.sequence, {
+              generation: renderGeneration,
+              emitterKey: baseKey,
+              epoch: resetEpoch
+            });
+          }
+          if (blockedEmitters.has(baseKey)) {
+            outcomes.push({
+              intent,
+              state: "deferred",
+              ...intent.reset ? { resetEpoch } : {}
+            });
+            continue;
+          }
+          if (options.playerConsumption?.isEnabled(entry.world, intent.player) === false || !entry.runtime.isEmitterSessionEnabled(intent.player, intent.emitter.id)) {
+            const state = intent.reset ? "deferred" : "skipped";
+            outcomes.push({
+              intent,
+              state,
+              ...intent.reset ? { resetEpoch } : {}
+            });
+            if (intent.reset) blockedEmitters.add(baseKey);
+            continue;
+          }
           const localToWorld = emitterTransform(entry.world, intent);
-          const visible = emitterVisible(intent, entry.camera, localToWorld);
+          const visible = emitterVisible(intent.emitter, entry.camera, localToWorld);
           entry.runtime.setEmitterCameraVisibility(intent.player, intent.emitter.id, visible);
-          if (!visible) continue;
-          if (requiresSceneDepth(intent) && depthTarget === void 0) continue;
+          if (!visible && intent.emitter.simulationWhenCulled !== "continue") {
+            const state = intent.reset ? "deferred" : "skipped";
+            outcomes.push({
+              intent,
+              state,
+              ...intent.reset ? { resetEpoch } : {}
+            });
+            if (intent.reset) blockedEmitters.add(baseKey);
+            continue;
+          }
+          if (visible && requiresSceneDepth(intent) && (depthTarget === void 0 || depthTarget.sampleCount !== 1)) {
+            outcomes.push({
+              intent,
+              state: "deferred",
+              ...intent.reset ? { resetEpoch } : {}
+            });
+            blockedEmitters.add(baseKey);
+            continue;
+          }
+          const requirements = intent.emitter.reflection.dataInterfaces ?? [];
+          if (requirements.length > 0 && !dataInterfacesExecutable(intent, options.dataInterfaces)) {
+            outcomes.push({
+              intent,
+              state: "deferred",
+              ...intent.reset ? { resetEpoch } : {}
+            });
+            blockedEmitters.add(baseKey);
+            continue;
+          }
           const stagePlan = validatedStagePlan(
             intent.emitter.reflection.stages,
             intent.instanceGeneration
           );
           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
+          const entryPoints = new Set(intent.emitter.reflection.entryPoints);
+          const dispatches = simulationDispatches(intent, stagePlan.value).filter(
+            (dispatch) => entryPoints.has(dispatch.entryPoint)
           );
-          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());
-            }
-            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;
+          if (dispatches.length === 0 && intent.emitter.renderers.length === 0) {
+            outcomes.push({
+              intent,
+              state: "skipped",
+              ...intent.reset ? { resetEpoch } : {}
+            });
+            continue;
           }
-          const scratchBytes = (capacity * 2 + Math.ceil(capacity / WORKGROUP_SIZE)) * 4;
-          const eventInputBytes = Math.max(
-            4,
-            eventInputCapacity(intent.emitter) * VFX_EVENT_INPUT_BYTES
+          effectiveEpochByEmitter.set(baseKey, resetEpoch);
+          const key = `vfx.w-${planName(worldId(entry.world).toString(36), 8)}.a-${planName(attachmentId.toString(36), 8)}.r-${entry.runtime.renderGeneration}.p-${planName(Number(intent.player).toString(36), 16)}.${planName(intent.emitter.id)}.g-${resetEpoch}`;
+          let group = groups.get(key);
+          if (group === void 0) {
+            group = {
+              key,
+              worldIndex,
+              entry,
+              intents: [],
+              // Reset data is a per-frame boundary, not a property of the
+              // epoch.  Once a reset-created group is warm, later ticks in
+              // the same epoch must retain its particle state.
+              initialReset: intent.reset
+            };
+            groups.set(key, group);
+          } else if (group.entry !== entry || group.intents[0]?.intent.emitter.wgsl !== intent.emitter.wgsl || group.intents[0]?.intent.emitter.capacity !== intent.emitter.capacity) {
+            return err(planFailure());
+          }
+          group.intents.push({
+            intent,
+            localToWorld,
+            stagePlan: stagePlan.value,
+            visible,
+            retained: false
+          });
+          outcomes.push({
+            intent,
+            state: dispatches.length > 0 ? "dispatched" : "skipped",
+            ...intent.reset ? { resetEpoch } : {}
+          });
+          if (dispatches.length === 0) effectiveEpochByEmitter.delete(baseKey);
+        }
+      }
+      for (const [worldIndex, entry] of frame.worlds.entries()) {
+        const renderGeneration = entry.runtime.renderGeneration ?? 0;
+        const attachmentId = runtimeId(entry.runtime);
+        let emitterEpochs = resetEpochByEmitter.get(entry.runtime);
+        if (emitterEpochs === void 0) {
+          emitterEpochs = /* @__PURE__ */ new Map();
+          resetEpochByEmitter.set(entry.runtime, emitterEpochs);
+        }
+        for (const retained of entry.retained ?? []) {
+          const hasAdmittedGroup = [...groups.values()].some(
+            (group) => group.worldIndex === worldIndex && group.entry === entry && group.intents.some(
+              (planned) => planned.intent.player === retained.player && planned.intent.emitter.id === retained.emitter.id
+            )
           );
-          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
+          if (hasAdmittedGroup) continue;
+          const stagePlan = validatedStagePlan(
+            retained.intent.emitter.reflection.stages,
+            retained.intent.instanceGeneration
+          );
+          if (!stagePlan.ok) return err(planFailure());
+          const baseKey = `${worldId(entry.world)}:${renderGeneration}:${Number(retained.player)}:${retained.emitter.id}`;
+          const resetEpoch = emitterEpochs.get(baseKey) ?? 0;
+          const key = `vfx.w-${planName(worldId(entry.world).toString(36), 8)}.a-${planName(attachmentId.toString(36), 8)}.r-${renderGeneration}.p-${planName(Number(retained.player).toString(36), 16)}.${planName(retained.emitter.id)}.g-${resetEpoch}`;
+          const visible = retained.visible && (options.playerConsumption?.isEnabled(entry.world, retained.player) ?? true) && entry.runtime.isEmitterSessionEnabled(retained.player, retained.emitter.id);
+          groups.set(key, {
+            key,
+            worldIndex,
+            entry,
+            intents: [
+              {
+                intent: retained.intent,
+                localToWorld: retained.localToWorld,
+                stagePlan: stagePlan.value,
+                visible,
+                retained: true
               }
-            },
-            {
-              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) } : {}
-            },
-            {
-              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) } : {}
-            },
+            ],
+            initialReset: false
+          });
+        }
+      }
+      for (const group of groups.values()) {
+        const first = group.intents[0];
+        if (first === void 0) continue;
+        const firstIntent = first.intent;
+        const prefix = group.key;
+        const program = `${prefix}.compute-program`;
+        const particles = `${prefix}.particles`;
+        const aliveIndices = `${prefix}.alive-indices`;
+        const counters = `${prefix}.counters`;
+        const indirect = `${prefix}.indirect`;
+        const scratch = `${prefix}.scratch`;
+        const sharedInstances = `${prefix}.shared-instances`;
+        const projectionEventInputs = `${prefix}.projection-event-inputs`;
+        const capacity = firstIntent.emitter.capacity;
+        const renderers = firstIntent.emitter.renderers;
+        const layout = firstIntent.emitter.reflection.layout;
+        const parameterBytes = layout?.parameters.size ?? 0;
+        const customStride = layout?.customLayout?.stride ?? 0;
+        const hasEvents = (firstIntent.emitter.reflection.resources ?? []).includes("eventBuffer") || (firstIntent.emitter.reflection.entryPoints ?? []).includes("forgeax_vfx_event_main") || (firstIntent.emitter.reflection.bindings[0]?.entries ?? []).some(
+          (entry) => entry.binding === 8
+        );
+        const diBindings = {};
+        const diResources = [];
+        const reflectedBindings = new Set(
+          firstIntent.emitter.reflection.bindings.flatMap(
+            (group2) => group2.entries.map((entry) => entry.binding)
+          )
+        );
+        const requirements = (firstIntent.emitter.reflection.dataInterfaces ?? []).filter(
+          (requirement) => reflectedBindings.has(requirement.binding)
+        );
+        if (requirements.length > 0) {
+          let resolved = options.dataInterfaces?.resolve(
+            requirements,
+            firstIntent.instanceGeneration
+          );
+          if ((resolved === void 0 || !resolved.ok && resolved.error.code === "vfx-data-interface-missing" && (resolved.error.detail.providerId === void 0 || resolved.error.expected.includes("resident"))) && context.preparedDataInterfaces !== void 0) {
+            const fallback = preparedDataInterfaceResources(
+              requirements,
+              firstIntent.instanceGeneration,
+              context.preparedDataInterfaces
+            );
+            if (fallback !== void 0) {
+              resolved = ok({
+                generation: firstIntent.instanceGeneration,
+                readiness: "ready",
+                resources: fallback
+              });
+            }
+          }
+          if (resolved === void 0 || !resolved.ok) return err(planFailure());
+          for (const requirement of requirements) {
+            const resource = resolved.value.resources.find(
+              (candidate) => candidate.token === requirement.token
+            );
+            const prepared = resource?.resource;
+            if (resource === void 0 || prepared === void 0) return err(planFailure());
+            const name = `${prefix}.di-${planName(requirement.kind)}`;
+            if (prepared.kind === "buffer") {
+              if (prepared.size === void 0 || prepared.size <= 0) return err(planFailure());
+              diResources.push({
+                kind: "prepared-gpu-resource",
+                name,
+                resource: {
+                  kind: "buffer",
+                  value: prepared.value,
+                  size: prepared.size,
+                  usage: prepared.usage === "storage" ? ["storage"] : ["uniform"]
+                }
+              });
+            } else {
+              const external = prepared.kind === "texture-view" ? { kind: "texture-view", value: prepared.value } : { kind: "sampler", value: prepared.value };
+              diResources.push({
+                kind: "prepared-gpu-resource",
+                name,
+                resource: external,
+                ...requirement.kind === "scene-depth" && depthTarget !== void 0 ? { logicalTarget: depthTarget.name } : {}
+              });
+            }
+            diBindings[requirement.binding] = name;
+          }
+        }
+        const meshes = renderers.map(
+          (renderer) => renderer.kind === "mesh" ? options.mesh?.read(group.entry.world, renderer.mesh) : void 0
+        );
+        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());
+          }
+          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;
+        }
+        const scratchBytes = (capacity * 2 + Math.ceil(capacity / WORKGROUP_SIZE)) * 4;
+        const eventBufferBytes = Math.max(
+          4,
+          eventInputCapacity(firstIntent.emitter) * VFX_EVENT_INPUT_BYTES + eventCapacity(firstIntent.emitter) * VFX_EVENT_BYTES
+        );
+        const particleBytes = VFX_PARTICLE_CORE_STRIDE;
+        const maxParticleInputBytes = Math.max(
+          0,
+          ...renderers.map((renderer) => (renderer.materialInputs?.length ?? 0) * 16)
+        );
+        resources.push(
+          ...diResources,
+          {
+            kind: "compute-program",
+            name: program,
+            program: {
+              wgsl: firstIntent.emitter.wgsl,
+              entryPoints: firstIntent.emitter.reflection.entryPoints,
+              bindings: firstIntent.emitter.reflection.bindings
+            }
+          },
+          {
+            kind: "buffer",
+            name: particles,
+            size: capacity * particleBytes,
+            usage: ["storage"],
+            ...group.initialReset ? { data: resetData(capacity * particleBytes) } : {}
+          },
+          ...parameterBytes === 0 ? [] : [
             {
               kind: "buffer",
-              name: sharedInstances,
-              size: capacity * Math.max(BILLBOARD_INSTANCE_BYTES, MESH_INSTANCE_BYTES),
-              usage: ["storage", "vertex"]
-            },
+              name: `${prefix}.parameters`,
+              size: parameterBytes,
+              usage: ["uniform"],
+              data: firstIntent.parameterBlock
+            }
+          ],
+          ...customStride === 0 ? [] : [
             {
               kind: "buffer",
-              name: eventInputs,
-              size: eventInputBytes,
+              name: `${prefix}.custom`,
+              size: capacity * customStride,
               usage: ["storage"],
-              data: encodeEventInputs(intent)
-            },
+              ...group.initialReset ? { data: resetData(capacity * customStride) } : {}
+            }
+          ],
+          { kind: "buffer", name: aliveIndices, size: capacity * 4, usage: ["storage"] },
+          {
+            kind: "buffer",
+            name: counters,
+            size: COUNTERS_BYTES,
+            usage: ["storage"],
+            ...group.initialReset ? { data: resetData(COUNTERS_BYTES) } : {}
+          },
+          {
+            kind: "buffer",
+            name: indirect,
+            size: indirectWords.byteLength,
+            usage: ["storage", "indirect"],
+            ...group.initialReset ? { data: indirectWords } : {}
+          },
+          {
+            kind: "buffer",
+            name: scratch,
+            size: scratchBytes,
+            usage: ["storage"],
+            ...group.initialReset ? { data: resetData(scratchBytes) } : {}
+          },
+          {
+            kind: "buffer",
+            name: sharedInstances,
+            size: capacity * (Math.max(BILLBOARD_INSTANCE_BYTES, MESH_INSTANCE_BYTES) + maxParticleInputBytes),
+            usage: ["storage", "vertex"]
+          },
+          ...hasEvents ? [
             {
               kind: "buffer",
-              name: events,
-              size: eventBytes,
+              name: projectionEventInputs,
+              size: eventBufferBytes,
               usage: ["storage"],
-              ...intent.reset ? { data: resetData(eventBytes) } : {}
-            },
+              data: encodeEventBuffer(firstIntent)
+            }
+          ] : []
+        );
+        const entryPoints = new Set(firstIntent.emitter.reflection.entryPoints);
+        for (const [tickIndex, planned] of group.intents.entries()) {
+          if (planned.retained) continue;
+          const tickPrefix = `${prefix}.tick-${tickIndex}`;
+          const tickRuntime = `${tickPrefix}.runtime`;
+          const tickEventInputs = `${tickPrefix}.event-inputs`;
+          const tickBindings = `${tickPrefix}.simulation-bindings`;
+          resources.push(
             {
               kind: "buffer",
-              name: runtime,
+              name: tickRuntime,
               size: RUNTIME_BYTES,
               usage: ["uniform"],
-              data: runtimeData(intent, entry.camera, void 0, localToWorld)
+              data: runtimeData(
+                planned.intent,
+                group.entry.camera,
+                void 0,
+                planned.localToWorld
+              )
             },
+            ...hasEvents ? [
+              {
+                kind: "buffer",
+                name: tickEventInputs,
+                size: eventBufferBytes,
+                usage: ["storage"],
+                data: encodeEventBuffer(planned.intent)
+              }
+            ] : [],
+            ...parameterBytes === 0 ? [] : [
+              {
+                kind: "buffer",
+                name: `${tickPrefix}.parameters`,
+                size: parameterBytes,
+                usage: ["uniform"],
+                data: planned.intent.parameterBlock
+              }
+            ],
             {
               kind: "compute-bindings",
-              name: bindings,
+              name: tickBindings,
               program,
-              entries: computeBindingEntries(intent, {
+              entries: computeBindingEntries(planned.intent, {
                 0: particles,
-                1: runtime,
+                1: tickRuntime,
                 2: aliveIndices,
                 3: counters,
                 4: indirect,
                 5: scratch,
                 6: sharedInstances,
-                8: eventInputs,
-                9: events
+                ...hasEvents ? { 8: tickEventInputs } : {},
+                ...parameterBytes === 0 ? {} : { 10: `${tickPrefix}.parameters` },
+                ...customStride === 0 ? {} : { 11: `${prefix}.custom` },
+                ...diBindings
               })
             }
           );
-          const entryPoints = new Set(intent.emitter.reflection.entryPoints);
-          const dispatches = simulationDispatches(intent, stagePlan.value).filter(
+          const dispatches = simulationDispatches(planned.intent, planned.stagePlan).filter(
             (dispatch) => entryPoints.has(dispatch.entryPoint)
           );
-          if (dispatches.length > 0) {
-            passes.push({
-              kind: "compute",
-              name: `${prefix}.simulate`,
-              program,
-              bindings,
-              dispatches
-            });
-            dispatchedIntents.add(intent);
-          }
+          if (dispatches.length === 0) continue;
+          passes.push({
+            kind: "compute",
+            name: `${tickPrefix}.simulate`,
+            program,
+            bindings: tickBindings,
+            dispatches
+          });
           for (const [rendererIndex, renderer] of renderers.entries()) {
+            if (renderer.enabled === false) continue;
+            if (renderer.kind !== "trail") continue;
+            if (!entryPoints.has("forgeax_vfx_trail_history_main")) continue;
             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 sceneDepthBinding = isBillboard ? particleMaterialSceneDepthBinding(
-              context.materialShaderBindingContract?.(materialPass.shader) ?? (materialPass.shader === PARTICLE_SHADER_IDENTIFIERS.billboard ? "view-and-scene-depth" : void 0)
-            ) : void 0;
-            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;
+            const historyRuntime = `${tickPrefix}.renderer-${rendererIndex}.history-runtime`;
+            const historyBindings = `${tickPrefix}.renderer-${rendererIndex}.history-bindings`;
             resources.push(
               {
                 kind: "buffer",
-                name: instances,
-                size: instanceBytes,
-                usage: ["storage", "vertex"]
-              },
-              {
-                kind: "buffer",
-                name: history,
-                size: historyBytes,
-                usage: ["storage"],
-                ...intent.reset ? { data: resetData(historyBytes) } : {}
-              },
-              {
-                kind: "buffer",
-                name: projectionRuntime,
+                name: historyRuntime,
                 size: RUNTIME_BYTES,
                 usage: ["uniform"],
                 data: runtimeData(
-                  { ...intent, fixedDelta: 0, spawnCount: 0 },
-                  entry.camera,
-                  material,
-                  localToWorld,
+                  planned.intent,
+                  group.entry.camera,
+                  void 0,
+                  planned.localToWorld,
                   renderer,
                   rendererIndex
                 )
               },
               {
                 kind: "compute-bindings",
-                name: projectionBindings,
+                name: historyBindings,
                 program,
-                entries: computeBindingEntries(intent, {
+                entries: computeBindingEntries(planned.intent, {
                   0: particles,
-                  1: projectionRuntime,
+                  1: historyRuntime,
                   2: aliveIndices,
                   3: counters,
                   4: indirect,
                   5: history,
-                  6: instances,
-                  8: eventInputs,
-                  9: events
+                  6: sharedInstances,
+                  ...hasEvents ? { 8: tickEventInputs } : {},
+                  ...parameterBytes === 0 ? {} : { 10: `${tickPrefix}.parameters` },
+                  ...customStride === 0 ? {} : { 11: `${prefix}.custom` },
+                  ...diBindings
                 })
               }
             );
-            const projectionDispatches = [];
-            const pushProjection = (entryPoint, workgroups) => {
-              if (!entryPoints.has(entryPoint)) return;
-              projectionDispatches.push({
-                kind: "direct",
-                entryPoint,
-                workgroups: [Math.max(1, workgroups)]
-              });
-            };
-            if (isBillboard && renderer.sorting === "back-to-front") {
-              pushProjection("forgeax_vfx_sort_main", 1);
+            passes.push({
+              kind: "compute",
+              name: `${historyBindings}.write`,
+              program,
+              bindings: historyBindings,
+              dispatches: [
+                {
+                  kind: "direct",
+                  entryPoint: "forgeax_vfx_trail_history_main",
+                  workgroups: [Math.max(1, Math.ceil(renderer.capacity / WORKGROUP_SIZE))]
+                }
+              ]
+            });
+          }
+        }
+        const latest = group.intents.at(-1) ?? first;
+        for (const [rendererIndex, renderer] of renderers.entries()) {
+          if (renderer.enabled === false) continue;
+          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(group.entry.world, renderer.material);
+          const reflectedRenderer = firstIntent.emitter.reflection.renderers?.[rendererIndex];
+          const preparedInputs = prepareParticleMaterialInputs(
+            renderer,
+            material,
+            reflectedRenderer?.materialInputDefinitions
+          );
+          if (!preparedInputs.ok) return err(planFailure());
+          const hasParticleInputs = preparedInputs.value.lanes > 0;
+          const materialPass = particleMaterialPass(renderer.kind, material, hasParticleInputs);
+          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 sceneDepthBinding = particleMaterialSceneDepthBinding(
+            context.materialShaderBindingContract?.(materialPass.shader) ?? (materialPass.shader === PARTICLE_SHADER_IDENTIFIERS.billboard ? "view-and-scene-depth" : void 0)
+          );
+          const instances = `${rendererPrefix}.instances`;
+          const history = `${rendererPrefix}.history`;
+          const projectionRuntime = `${rendererPrefix}.runtime`;
+          const projectionBindings = `${rendererPrefix}.compute-bindings`;
+          const vertexLayout = isBillboard ? hasParticleInputs ? RENDER_FEATURE_VERTEX_LAYOUTS.billboardMaterialInputInstance : RENDER_FEATURE_VERTEX_LAYOUTS.billboardMaterialInstance : isTopology ? hasParticleInputs ? RENDER_FEATURE_VERTEX_LAYOUTS.topologySegmentMaterialInputInstance : RENDER_FEATURE_VERTEX_LAYOUTS.topologySegmentInstance : hasParticleInputs ? RENDER_FEATURE_VERTEX_LAYOUTS.meshGeometryMaterialInputInstance : RENDER_FEATURE_VERTEX_LAYOUTS.meshGeometryMaterialInstance;
+          const inputBytes = preparedInputs.value.stride;
+          const instanceBytes = isTopology ? (() => {
+            const vertexCount = Math.max(
+              1,
+              Math.floor((topologyPlan?.value.vertexBytes ?? 16) / 48)
+            );
+            return vertexCount * (48 + inputBytes);
+          })() : capacity * ((isBillboard ? BILLBOARD_INSTANCE_BYTES : MESH_INSTANCE_BYTES) + inputBytes);
+          const historyBytes = renderer.kind === "trail" ? capacity * (Math.max(2, renderer.historyLength) + 1) * 16 : 16;
+          resources.push(
+            {
+              kind: "buffer",
+              name: instances,
+              size: instanceBytes,
+              usage: ["storage", "vertex"]
+            },
+            {
+              kind: "buffer",
+              name: history,
+              size: historyBytes,
+              usage: ["storage"],
+              ...group.initialReset ? { data: resetData(historyBytes) } : {}
             }
-            if (renderer.kind === "trail") {
-              pushProjection(
-                "forgeax_vfx_trail_history_main",
-                Math.ceil(renderer.capacity / WORKGROUP_SIZE)
-              );
+          );
+          const castsShadow = renderer.kind === "mesh" && renderer.castShadows;
+          if (!latest.visible && !castsShadow) continue;
+          resources.push(
+            {
+              kind: "buffer",
+              name: projectionRuntime,
+              size: RUNTIME_BYTES,
+              usage: ["uniform"],
+              data: runtimeData(
+                { ...latest.intent, fixedDelta: 0, spawnCount: 0 },
+                group.entry.camera,
+                material,
+                latest.localToWorld,
+                renderer,
+                rendererIndex,
+                preparedInputs.value.lanes,
+                renderer.kind === "mesh" && submesh !== void 0 ? {
+                  count: mesh?.indices === void 0 ? submesh.vertexCount : submesh.indexCount,
+                  firstIndex: mesh?.indices === void 0 ? 0 : submesh.indexOffset
+                } : void 0
+              )
+            },
+            {
+              kind: "compute-bindings",
+              name: projectionBindings,
+              program,
+              entries: computeBindingEntries(latest.intent, {
+                0: particles,
+                1: projectionRuntime,
+                2: aliveIndices,
+                3: counters,
+                4: indirect,
+                5: history,
+                6: instances,
+                ...hasEvents ? { 8: projectionEventInputs } : {},
+                ...parameterBytes === 0 ? {} : { 10: `${prefix}.parameters` },
+                ...customStride === 0 ? {} : { 11: `${prefix}.custom` },
+                ...diBindings
+              })
             }
-            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)
+          );
+          const projectionDispatches = [];
+          const pushProjection = (entryPoint, workgroups) => {
+            if (!entryPoints.has(entryPoint)) return;
+            projectionDispatches.push({
+              kind: "direct",
+              entryPoint,
+              workgroups: [Math.max(1, workgroups)]
+            });
+          };
+          if (isBillboard && (renderer.sorting === "view-depth" || renderer.sorting === "view-distance" || renderer.sorting === "custom-ascending" || renderer.sorting === "custom-descending")) {
+            pushProjection("forgeax_vfx_sort_main", 1);
+          }
+          if (renderer.kind === "trail") pushProjection("forgeax_vfx_trail_offsets_main", 1);
+          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
+            });
+          }
+          const graphicsProgram = `${rendererPrefix}.graphics-program`;
+          const graphicsBindings = `${rendererPrefix}.graphics-bindings`;
+          const vertexData = `${rendererPrefix}.vertex-data`;
+          const defaultRenderState = particleRendererRenderState(
+            renderer.kind,
+            renderer.kind === "billboard" ? renderer.blend : void 0,
+            materialPass.renderState
+          );
+          const renderState = isBillboard && depthTarget !== void 0 ? { ...defaultRenderState ?? {}, depthWriteEnabled: false } : defaultRenderState;
+          resources.push(
+            {
+              kind: "graphics-program",
+              name: graphicsProgram,
+              program: {
+                shader: materialPass.shader,
+                vertexLayout,
+                ...hasParticleInputs ? { particleInputLanes: preparedInputs.value.lanes } : {},
+                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 }
+              }
+            },
+            {
+              kind: "graphics-bindings",
+              name: graphicsBindings,
+              program: graphicsProgram,
+              values: {
+                group: 0,
+                runtime: projectionRuntime,
+                instances,
+                ...sceneDepthBinding === void 0 ? {} : { sceneDepthBinding }
+              },
+              ...sceneDepthBinding !== void 0 && depthTarget !== void 0 ? { logicalTargets: { sceneDepth: depthTarget.name } } : {}
+            },
+            { kind: "vertex-data", name: vertexData, layout: vertexLayout, buffer: instances }
+          );
+          const drawBindings = [graphicsBindings];
+          if (particleMaterialUsesBindings(material) || materialPass.shader === PARTICLE_SHADER_IDENTIFIERS.mesh || materialPass.shader === PARTICLE_INPUT_SHADER_IDENTIFIERS.mesh) {
+            const materialBindings = `${rendererPrefix}.material-bindings.w-${group.worldIndex}`;
+            resources.push({
+              kind: "graphics-bindings",
+              name: materialBindings,
+              program: graphicsProgram,
+              values: {
+                group: 1,
+                material: { world: group.worldIndex, guid: renderer.material }
+              }
+            });
+            drawBindings.push(materialBindings);
+          }
+          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
+              }
             );
-            if (projectionDispatches.length > 0) {
-              passes.push({
-                kind: "compute",
-                name: `${rendererPrefix}.project`,
-                program,
-                bindings: projectionBindings,
-                dispatches: projectionDispatches
-              });
+            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(
+                {
+                  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 };
             }
-            const graphicsProgram = `${rendererPrefix}.graphics-program`;
-            const graphicsBindings = `${rendererPrefix}.graphics-bindings`;
-            const vertexData = `${rendererPrefix}.vertex-data`;
-            const defaultRenderState = particleRendererRenderState(
-              renderer.kind,
-              renderer.kind === "billboard" ? renderer.blend : void 0,
-              materialPass.renderState
-            );
-            const renderState = isBillboard && depthTarget !== void 0 ? { ...defaultRenderState ?? {}, depthWriteEnabled: false } : defaultRenderState;
+          } else {
+            vertexBindings.push({ slot: 0, resource: vertexData });
+          }
+          if (castsShadow) {
+            const shadowProgram = `${rendererPrefix}.shadow-program`;
+            const shadowBindings = `${rendererPrefix}.shadow-bindings`;
             resources.push(
               {
                 kind: "graphics-program",
-                name: graphicsProgram,
+                name: shadowProgram,
                 program: {
-                  shader: materialPass.shader,
+                  shader: "forgeax::vfx-render.particles.mesh-shadow",
                   vertexLayout,
-                  colorFormats: [colorTarget?.format ?? "rgba8unorm-srgb"],
-                  ...depthTarget === void 0 ? {} : { depthFormat: depthTarget.format },
-                  sampleCount: colorTarget?.sampleCount ?? 1,
+                  ...hasParticleInputs ? { particleInputLanes: preparedInputs.value.lanes } : {},
+                  colorFormats: [],
+                  depthFormat: "depth32float",
                   topology: submesh?.topology ?? "triangle-list",
                   ...mesh?.indices === void 0 ? {} : { indexFormat },
-                  ...renderState === void 0 ? {} : { renderState }
+                  renderState: { depthWriteEnabled: true, cullMode: "none" }
                 }
               },
               {
                 kind: "graphics-bindings",
-                name: graphicsBindings,
-                program: graphicsProgram,
-                values: {
-                  group: 0,
-                  runtime: projectionRuntime,
-                  instances,
-                  ...sceneDepthBinding === void 0 ? {} : { sceneDepthBinding }
-                },
-                ...sceneDepthBinding !== void 0 && depthTarget !== void 0 ? { logicalTargets: { sceneDepth: depthTarget.name } } : {}
-              },
-              { kind: "vertex-data", name: vertexData, layout: vertexLayout, buffer: instances }
+                name: shadowBindings,
+                program: shadowProgram,
+                values: { group: 0, runtime: projectionRuntime, 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);
-            }
-            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
-                },
+            passes.push({
+              kind: "shadow-caster",
+              name: `${rendererPrefix}.shadow`,
+              draws: [
                 {
-                  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(
-                  {
-                    kind: "buffer",
-                    name: indexBuffer,
-                    size: mesh.indices.byteLength,
-                    usage: ["index"],
-                    data: mesh.indices
-                  },
-                  {
-                    kind: "index-data",
-                    name: indices,
-                    format: indexFormat,
-                    buffer: indexBuffer
+                  program: shadowProgram,
+                  bindings: [shadowBindings],
+                  vertexData: vertexBindings,
+                  ...indexData === void 0 ? {} : { indexData },
+                  draw: {
+                    kind: indexData === void 0 ? "draw-indirect" : "draw-indexed-indirect",
+                    resource: indirect,
+                    offset: rendererIndex * 20
                   }
-                );
-                indexData = { resource: indices, format: indexFormat };
-              }
-            } else {
-              vertexBindings.push({ slot: 0, resource: vertexData });
-            }
+                }
+              ]
+            });
+          }
+          if (latest.visible)
             passes.push({
               kind: "raster",
               name: `${rendererPrefix}.raster`,
@@ -1006,21 +1641,50 @@ function gpuParticleRenderFeature(options) {
                 }
               ]
             });
-          }
         }
       }
-      for (const entry of frame.worlds) {
-        for (const intent of entry.intents) {
-          if (dispatchedIntents.has(intent)) {
-            entry.runtime.markEventDispatched(intent.player, intent.eventCounters);
+      pendingFrames.set(
+        frame.frameNumber,
+        frame.worlds.map((entry) => ({
+          world: entry.world,
+          runtime: entry.runtime,
+          outcomes: outcomesByEntry.get(entry) ?? entry.intents.map((intent) => ({ intent, state: "deferred" }))
+        }))
+      );
+      return ok({ resources, passes });
+    },
+    onFrameSubmitted: (frame) => {
+      const pending = pendingFrames.get(frame.frameNumber);
+      if (pending === void 0) return;
+      pendingFrames.delete(frame.frameNumber);
+      for (const entry of pending) {
+        const acknowledgedSequences = [];
+        const publishedSequences = [];
+        for (const outcome of entry.outcomes) {
+          if (outcome.state === "deferred") continue;
+          acknowledgedSequences.push(outcome.intent.sequence);
+          if (outcome.state === "dispatched") {
+            publishedSequences.push(outcome.intent.sequence);
+            entry.runtime.markEventDispatched(outcome.intent.player, outcome.intent.eventCounters);
+            if (outcome.resetEpoch !== void 0) {
+              const baseKey = `${worldId(entry.world)}:${entry.runtime.renderGeneration ?? 0}:${Number(outcome.intent.player)}:${outcome.intent.emitter.id}`;
+              resetEpochByEmitter.get(entry.runtime)?.set(baseKey, outcome.resetEpoch);
+              resetEpochByIntent.get(entry.runtime)?.delete(outcome.intent.sequence);
+            }
+          } else if (outcome.state === "skipped" && outcome.resetEpoch !== void 0) {
+            resetEpochByIntent.get(entry.runtime)?.delete(outcome.intent.sequence);
           }
         }
-        const lastIntent = entry.intents.at(-1);
-        if (lastIntent !== void 0) entry.runtime.commit(lastIntent.sequence);
+        if (acknowledgedSequences.length > 0) {
+          entry.runtime.commit(acknowledgedSequences, publishedSequences);
+        }
       }
-      return ok({ resources, passes });
+    },
+    onFrameAborted: (frame) => {
+      pendingFrames.delete(frame.frameNumber);
     }
   };
+  return feature;
 }
 function duplicate(token, providerId) {
   return {
@@ -1045,11 +1709,22 @@ function availableProvider(token, kind, bindingType, source) {
           detail: { token, providerId: `${token}-provider` }
         });
       }
+      const prepared = source.resource?.(generation);
+      if (prepared === void 0) {
+        return err({
+          code: "vfx-data-interface-missing",
+          expected: `a resident ${kind} resource for ${token}`,
+          hint: `provide the generation-owned ${kind} resource before rendering`,
+          detail: { token, providerId: `${token}-provider` }
+        });
+      }
       const resource = {
         token,
         kind,
         bindingType,
-        generation
+        generation,
+        ...source.sampleCount === void 0 ? {} : { sampleCount: source.sampleCount },
+        resource: prepared
       };
       return ok(resource);
     }
@@ -1061,6 +1736,9 @@ function createCameraProvider(source) {
 function createSceneDepthProvider(source) {
   return availableProvider("vfx:scene-depth", "scene-depth", "sampled-depth", source);
 }
+function createNoiseProvider(source) {
+  return availableProvider("vfx:noise", "noise", "sampled-float", source);
+}
 function createVfxDataInterfaceRegistry(initialProviders = []) {
   const entries = /* @__PURE__ */ new Map();
   let registrationError;
@@ -1221,6 +1899,33 @@ function createVfxRuntimeHost(options) {
         }
         return ok(action(world.getResource(VFX_GPU_RUNTIME_RESOURCE_KEY)));
       };
+      const withInstance = (player, action) => {
+        const result = withRuntime(player, (runtime) => {
+          const instance = runtime.getInstance(player);
+          if (instance === void 0) {
+            return { kind: "error", causeCode: "vfx-instance-unavailable" };
+          }
+          const outcome = action(instance);
+          return outcome.ok ? { kind: "value", value: outcome.value } : { kind: "error", causeCode: outcome.error.code };
+        });
+        if (!result.ok) return result;
+        if (result.value.kind === "error") {
+          return err(
+            controlFailure(
+              "vfx-host-control-instance-rejected",
+              "the live typed VFX instance to accept this control input",
+              "run one fixed tick or repair the reflected instance contract before retrying",
+              {
+                requestedGeneration,
+                currentGeneration: requestedGeneration,
+                player,
+                causeCode: result.value.causeCode
+              }
+            )
+          );
+        }
+        return ok(result.value.value);
+      };
       const control = {
         generation: requestedGeneration,
         replay: ({ player, replayInput }) => withRuntime(player, (runtime) => {
@@ -1248,6 +1953,21 @@ function createVfxRuntimeHost(options) {
             state: enabled ? "enabled" : "paused",
             generation: requestedGeneration
           });
+        }),
+        patchPlayerParameters: ({ player, values }) => withInstance(player, (instance) => {
+          const patched = instance.patch(values);
+          if (!patched.ok) return patched;
+          return ok({
+            state: "queued",
+            generation: requestedGeneration,
+            parameterGeneration: instance.generation,
+            pendingPatchCount: instance.pendingPatchCount
+          });
+        }),
+        submitChannel: ({ player, channel, payload, sequence }) => withInstance(player, (instance) => {
+          const submitted = instance.submit({ channel, payload, sequence });
+          if (!submitted.ok) return submitted;
+          return ok({ state: "queued", generation: requestedGeneration });
         })
       };
       return ok(Object.freeze(control));
@@ -1269,7 +1989,7 @@ function createVfxRuntimeHost(options) {
           return err(
             failure2(
               "vfx-host-loader-install-failed",
-              "the v2 VFX loader to be registered once",
+              "the Program v3 VFX loader to be registered once",
               "remove a conflicting particle-effect loader and retry attachWorld",
               cause
             )
@@ -1348,6 +2068,6 @@ function createVfxRuntimeHost(options) {
   };
 }
 
-export { PARTICLE_SHADER_IDENTIFIERS, VFX_EVENT_BYTES, VFX_EVENT_COUNTER_BYTES, VFX_EVENT_INPUT_BYTES, createCameraProvider, createSceneDepthProvider, createTopologyResourcePlan, createVfxDataInterfaceRegistry, createVfxRenderInspectSnapshot, createVfxRuntimeHost, encodeEventInputs, eventCapacity, eventCounterData, eventInputCapacity, gpuParticleRenderFeature, installVfxRuntimeDecoder, observeStagePlan, resolveBillboardAdvancedState, stageDispatches, stageRecoveryReadiness, topologyCapacitySnapshot, topologyRecoveryHint, validatedStagePlan };
+export { PARTICLE_INPUT_SHADER_IDENTIFIERS, PARTICLE_SHADER_IDENTIFIERS, VFX_EVENT_BYTES, VFX_EVENT_COUNTER_BYTES, VFX_EVENT_INPUT_BYTES, createCameraProvider, createNoiseProvider, createSceneDepthProvider, createTopologyResourcePlan, createVfxDataInterfaceRegistry, createVfxRenderInspectSnapshot, createVfxRuntimeHost, encodeEventBuffer, encodeEventInputs, eventCapacity, eventCounterData, eventInputCapacity, gpuParticleRenderFeature, installVfxRuntimeDecoder, observeStagePlan, prepareParticleMaterialInputs, resolveBillboardAdvancedState, stageDispatches, stageRecoveryReadiness, topologyCapacitySnapshot, topologyRecoveryHint, validatedStagePlan };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map