@forgeax/engine-render 0.1.4 → 0.1.7

package/src/record/typed-frame-graph.ts

@@ -4,7 +4,6 @@ import {
   RenderGraphBuilder,
 } from '@forgeax/engine-render-graph';
 import type {
-  BindGroup,
   BindGroupLayout,
   CommandBuffer,
   RenderPipeline,
@@ -12,47 +11,138 @@ import type {
   Texture,
   TextureFormat,
 } from '@forgeax/engine-rhi';
-import { RhiError } from '@forgeax/engine-rhi';
-import { err, ok } from '@forgeax/engine-types';
-import { type EnvironmentGpuBundle, isEnvironmentGpuBundle } from '../environment/gpu-bundle';
+import { err, ok, type Result } from '@forgeax/engine-types';
+import { type RenderError, RenderFeatureStageFailedError } from '../errors/render';
 import {
-  type EnvironmentTransactionAttempt,
-  importEnvironmentGraphTargets,
-} from '../environment/graph';
-import { TemporalUnsupportedError } from '../errors/render';
-import { directionalCascadeAtlasSize } from '../extract/directional-csm';
-import { projectRenderFeatureContributions } from '../features/render-graph-contribution';
-import type { RenderFeatureGraphTargetResolver } from '../features/render-graph-raster';
-import { addTaaResolvePass, ensureTaaResolveParamsBuffer } from '../features/taa-resolve';
+  getRenderFeaturePlanExecutionProjection,
+  type RenderFeaturePlanExecution,
+} from '../features/host';
+import { type RenderFeaturePlannedFrame, renderFeaturePlanSignature } from '../features/plan';
+import { projectRenderFeaturePlans as projectPlanExecutions } from '../features/render-graph-contribution';
+import type {
+  RenderFeatureGraphBindingsResolution,
+  RenderFeatureGraphTargetResolver,
+} from '../features/render-graph-raster';
 import { isRenderFeatureTargetHandle } from '../features/targets';
 import type { PreparedGpuDrivenFrame } from '../gpu-driven/production-raster';
+import { STANDARD_PIPELINE_ID } from '../pipeline/standard-profile';
+import type { CameraSnapshot } from '../render-contract';
 import type {
   RenderPipelineFeatureTarget,
   RenderPipelineFrame,
   RenderPipelineTopology,
 } from '../render-pipeline';
-import { createRenderPipelineTemporalContract } from '../render-pipeline';
-import type { PipelineState, RenderSystemInternals } from '../render-system';
-import { getRenderFeatureGraphState, reportRenderFeatureGraphError } from '../render-system';
-import type { CameraSnapshot, ExtractedLights } from '../render-system-extract';
-import { resolveSurfaceFormatPair } from '../surface-format';
-import type { TemporalFrameAttempt, TemporalFrameTransaction } from '../temporal-frame-transaction';
-import { temporalViewId } from '../temporal-view';
+import type { ExtractedLights } from '../render-system-extract';
 import { buildPerFrameBindGroups } from './frame-lighting';
 import type { RenderFrameState } from './frame-snapshot';
-import { commandBufferPlanForFrame, createShadowSubmitModeState } from './shadow-submit-mode';
-import { VIEW_UNIFORM_BYTES } from './view-ubo';
+import type { PipelineState, RenderSystemInternals } from './render-context';
+import { resolveSurfaceFormatPair } from './render-context';
+
+export interface RenderFeatureGraphRuntimeState {
+  plans: readonly RenderFeaturePlannedFrame[];
+  fullscreenEffects: ReadonlyMap<
+    string,
+    import('../fullscreen-post-process-pass').PostProcessShaderEntry
+  >;
+}
+
+/** A frame-local graph candidate that is committed only after compilation. */
+export interface RenderFeatureGraphCandidate {
+  readonly plans: readonly RenderFeaturePlannedFrame[];
+  readonly fullscreenEffects: ReadonlyMap<
+    string,
+    import('../fullscreen-post-process-pass').PostProcessShaderEntry
+  >;
+  /**
+   * Physical prepared resources are imported into the compiled graph. A new
+   * prepared batch therefore needs a new graph even when the declarative plan
+   * signature is unchanged; otherwise queue retirement can destroy the buffer
+   * still referenced by the memoized graph.
+   */
+  readonly preparedResourceKey?: string;
+  /** Release candidate-owned prepared resources when graph promotion fails. */
+  readonly onRejected?: () => void;
+}
+
+const featureGraphStates = new WeakMap<RenderSystemInternals, RenderFeatureGraphRuntimeState>();
+
+export function getRenderFeatureGraphState(
+  internals: RenderSystemInternals,
+): RenderFeatureGraphRuntimeState {
+  const existing = featureGraphStates.get(internals);
+  if (existing !== undefined) return existing;
+  const created: RenderFeatureGraphRuntimeState = {
+    plans: [],
+    fullscreenEffects: new Map(),
+  };
+  featureGraphStates.set(internals, created);
+  return created;
+}
 
-function featureSignature(internals: RenderSystemInternals): string {
+export function resetRenderFeatureGraphState(internals: RenderSystemInternals): void {
+  const state = getRenderFeatureGraphState(internals);
+  state.plans = [];
+  state.fullscreenEffects = new Map();
+}
+
+export function reportRenderFeatureGraphError(
+  internals: RenderSystemInternals,
+  error: RenderError,
+): void {
+  if (internals.featureHost !== undefined && 'detail' in error) {
+    const detail = error.detail;
+    if (detail !== undefined && 'featureIdentity' in detail && 'order' in detail) {
+      const owned = internals.featureHost.recordError(detail.featureIdentity, error);
+      internals.errorRegistry.fire(owned);
+      return;
+    }
+  }
+  internals.errorRegistry.fire(error);
+}
+
+export function renderFeatureGraphPlanSignature(
+  plans: readonly RenderFeaturePlannedFrame[],
+): string {
   return JSON.stringify(
-    getRenderFeatureGraphState(internals).contributions.map((contribution) => [
-      contribution.featureIdentity,
-      contribution.order,
-      contribution.topologySignature,
-    ]),
+    plans.map((planned) => [planned.featureIdentity, planned.generation, planned.signature]),
   );
 }
 
+function validateRenderFeaturePlans(
+  plans: readonly RenderFeaturePlannedFrame[],
+): Result<readonly RenderFeaturePlanExecution[], RenderError> {
+  const identities = new Set<string>();
+  const projected: RenderFeaturePlanExecution[] = [];
+  let previousOrder = -1;
+  for (const [order, planned] of plans.entries()) {
+    const execution = getRenderFeaturePlanExecutionProjection(planned);
+    if (
+      identities.has(planned.featureIdentity) ||
+      planned.signature !== renderFeaturePlanSignature(planned.plan) ||
+      execution === undefined ||
+      execution.featureIdentity !== planned.featureIdentity ||
+      execution.order <= previousOrder
+    ) {
+      return err(
+        new RenderFeatureStageFailedError(planned.featureIdentity, order, 'plan', 'next-frame'),
+      );
+    }
+    identities.add(planned.featureIdentity);
+    previousOrder = execution.order;
+    projected.push(execution);
+  }
+  return ok(Object.freeze(projected));
+}
+
+function commitFeatureCandidate(
+  internals: RenderSystemInternals,
+  candidate: RenderFeatureGraphCandidate,
+): void {
+  const state = getRenderFeatureGraphState(internals);
+  state.plans = candidate.plans;
+  state.fullscreenEffects = candidate.fullscreenEffects;
+}
+
 function topologyOf(
   internals: RenderSystemInternals,
   frameState: RenderFrameState,
@@ -63,6 +153,7 @@ function topologyOf(
   height: number,
   shadowMapSize: number | undefined,
   gpuDriven: PreparedGpuDrivenFrame | undefined,
+  featureGraphCandidate: RenderFeatureGraphCandidate | undefined,
 ): RenderPipelineTopology {
   const cascadeCount = Math.max(1, Math.min(4, Math.round(lights.cascadeCount ?? 1))) as
     | 1
@@ -74,9 +165,26 @@ function topologyOf(
     pipelineState.format as GPUTextureFormat,
     pipelineState.colorAttachmentFormat as GPUTextureFormat,
   );
+  const featurePostEffects = [
+    ...(featureGraphCandidate?.fullscreenEffects ??
+      getRenderFeatureGraphState(internals).fullscreenEffects),
+  ].map(([id]) => id);
+  const config =
+    featurePostEffects.length === 0
+      ? frameState.installedPipelineConfig
+      : {
+          ...(frameState.installedPipelineConfig ?? {}),
+          postEffects: [
+            ...new Set([
+              ...(frameState.installedPipelineConfig?.postEffects ?? []),
+              ...featurePostEffects,
+            ]),
+          ],
+        };
   return {
-    pipelineId: frameState.activePipelineId,
-    config: frameState.installedPipelineConfig,
+    pipelineId: STANDARD_PIPELINE_ID,
+    standardProfile: internals.standardProfile,
+    config,
     surface: {
       width,
       height,
@@ -106,27 +214,17 @@ function topologyOf(
       multisample: internals.device.caps.backendKind !== 'wgpu-webgl2',
       maxColorAttachments: internals.device.caps.maxColorAttachments,
     },
-    featureTopologySignature: featureSignature(internals),
+    featureTopologySignature: JSON.stringify({
+      plans: renderFeatureGraphPlanSignature(
+        featureGraphCandidate?.plans ?? getRenderFeatureGraphState(internals).plans,
+      ),
+      fullscreenEffects: featurePostEffects,
+      preparedResourceKey: featureGraphCandidate?.preparedResourceKey ?? '',
+    }),
     gpuDrivenTopologySignature: gpuDriven?.topologySignature ?? '',
-    environment: {
-      enabled:
-        frameState.environmentGeneration.active !== undefined ||
-        frameState.environmentGeneration.candidate !== undefined,
-      dirty: frameState.environmentGeneration.candidate !== undefined,
-    },
   };
 }
 
-function environmentBundle(frameState: RenderFrameState): EnvironmentGpuBundle | undefined {
-  const record =
-    frameState.environmentGeneration.candidate ?? frameState.environmentGeneration.active;
-  return record !== undefined && isEnvironmentGpuBundle(record.handle) ? record.handle : undefined;
-}
-
-function topologyKey(topology: RenderPipelineTopology): string {
-  return JSON.stringify(topology);
-}
-
 function targetResolver(
   targets: readonly RenderPipelineFeatureTarget[],
 ): RenderFeatureGraphTargetResolver {
@@ -155,33 +253,67 @@ function resolveTargetBindings(input: {
   };
   readonly resources: GraphResourceResolver;
   readonly resolveTarget: RenderFeatureGraphTargetResolver;
-}): BindGroup | undefined {
+}): RenderFeatureGraphBindingsResolution | undefined {
+  const frame = input.frame as import('./render-context')._InternalRenderPipelineContext;
   const descriptor = input.binding.descriptor;
   const pipeline = input.binding.pipeline as
     | (RenderPipeline & { getBindGroupLayout?: (index: number) => BindGroupLayout })
     | undefined;
   const sceneDepth = descriptor?.values.sceneDepth;
+  const sceneDepthBinding = descriptor?.values.sceneDepthBinding;
   if (pipeline === undefined) return undefined;
-  if (sceneDepth === undefined) {
-    return (
-      buildPerFrameBindGroups(
-        input.frame.runtime as RenderSystemInternals,
-        input.frame.frameState,
-        input.frame.pipelineState,
-        true,
-        input.frame.bindGroupCounts,
+  if (sceneDepthBinding === 1) {
+    const target = sceneDepth === undefined ? undefined : input.resolveTarget(sceneDepth);
+    const depthView =
+      target === undefined
+        ? frame.pipelineState.shadowFallbackTextureView
+        : (() => {
+            const texture = input.resources.texture(target.texture);
+            if (!texture.ok) throw texture.error;
+            const created = frame.runtime.device.createTextureView(texture.value as Texture, {
+              aspect: 'depth-only',
+              dimension: '2d',
+            });
+            if (!created.ok) throw created.error;
+            return created.value;
+          })();
+    const layout = pipeline.getBindGroupLayout?.(0);
+    if (layout === undefined) return undefined;
+    const created = frame.runtime.device.createBindGroup({
+      layout,
+      entries: [
         {
-          directionalShadow: input.frame.frameState.currentDirectionalShadowView ?? undefined,
-          spotShadow: input.frame.frameState.currentSpotShadowView ?? undefined,
+          binding: 0,
+          resource: {
+            kind: 'buffer',
+            value: { buffer: frame.pipelineState.viewUniformBuffer },
+          },
         },
-      ).viewBindGroup ?? undefined
-    );
+        { binding: 1, resource: { kind: 'textureView', value: depthView } },
+      ],
+    });
+    if (!created.ok) throw created.error;
+    return created.value;
+  }
+  if (sceneDepth === undefined) {
+    const viewBindGroup = buildPerFrameBindGroups(
+      frame.runtime as RenderSystemInternals,
+      frame.frameState,
+      frame.pipelineState,
+      frame.validated.length > 0,
+      frame.bindGroupCounts,
+      {
+        directionalShadow: frame.frameState.currentDirectionalShadowView ?? undefined,
+        spotShadow: frame.frameState.currentSpotShadowView ?? undefined,
+      },
+    ).viewBindGroup;
+    return viewBindGroup === null ? undefined : { handle: viewBindGroup, dynamicOffsets: [0] };
   }
   const target = input.resolveTarget(sceneDepth);
   if (target === undefined) return undefined;
   const texture = input.resources.texture(target.texture);
   if (!texture.ok) throw texture.error;
-  const depthView = input.frame.runtime.device.createTextureView(texture.value as Texture, {
+  const depthView = frame.runtime.device.createTextureView(texture.value as Texture, {
     aspect: 'depth-only',
     dimension: '2d',
   });
@@ -189,29 +321,9 @@ function resolveTargetBindings(input: {
   const group = descriptor?.values.group === 1 ? 1 : 0;
   const layout = pipeline.getBindGroupLayout?.(group);
   if (layout === undefined) return undefined;
-  const shader = descriptor?.values.shader;
-  const viewWithResource =
-    typeof shader === 'string' &&
-    (input.frame.runtime as RenderSystemInternals).getMaterialShaderBindingContract?.(shader) ===
-      'view-with-resource';
-  const entries = viewWithResource
-    ? [
-        {
-          binding: 0,
-          resource: {
-            kind: 'buffer' as const,
-            value: {
-              buffer: input.frame.pipelineState.viewUniformBuffer,
-              size: VIEW_UNIFORM_BYTES,
-            },
-          },
-        },
-        { binding: 1, resource: { kind: 'textureView' as const, value: depthView.value } },
-      ]
-    : [{ binding: 0, resource: { kind: 'textureView' as const, value: depthView.value } }];
-  const created = input.frame.runtime.device.createBindGroup({
+  const created = frame.runtime.device.createBindGroup({
     layout,
-    entries,
+    entries: [{ binding: 0, resource: { kind: 'textureView', value: depthView.value } }],
   });
   if (!created.ok) throw created.error;
   return created.value;
@@ -220,10 +332,10 @@ function resolveTargetBindings(input: {
 function retire(
   frameState: RenderFrameState,
   graph: CompiledRenderGraph<RenderPipelineFrame>,
-  historyStore?: TemporalFrameTransaction['historyStore'],
 ): void {
   frameState.retiredCompiledFrameGraphs.add(graph);
-  (historyStore?.retireGraph(graph) ?? graph.retire())
+  graph
+    .retire()
     .finally(() => frameState.retiredCompiledFrameGraphs.delete(graph))
     .catch(() => undefined);
 }
@@ -238,11 +350,17 @@ export function ensureCompiledFrameGraph(
   height: number,
   shadowMapSize: number | undefined,
   gpuDriven?: PreparedGpuDrivenFrame,
-  temporalTransaction?: TemporalFrameTransaction,
+  featureGraphCandidate?: RenderFeatureGraphCandidate,
 ): CompiledRenderGraph<RenderPipelineFrame> | null {
-  const historyStore = temporalTransaction?.historyStore;
   const surfaceWidth = Math.max(1, width);
   const surfaceHeight = Math.max(1, height);
+  const featurePlans = featureGraphCandidate?.plans ?? getRenderFeatureGraphState(internals).plans;
+  const projectedFeaturePlans = validateRenderFeaturePlans(featurePlans);
+  if (!projectedFeaturePlans.ok) {
+    reportRenderFeatureGraphError(internals, projectedFeaturePlans.error);
+    featureGraphCandidate?.onRejected?.();
+    return frameState.compiledFrameGraph;
+  }
   const topology = topologyOf(
     internals,
     frameState,
@@ -253,105 +371,22 @@ export function ensureCompiledFrameGraph(
     surfaceHeight,
     shadowMapSize,
     gpuDriven,
+    featureGraphCandidate,
   );
-  const atlasSize = directionalCascadeAtlasSize(
-    topology.shadow.cascadeCount,
-    topology.shadow.mapSize,
-  );
-  pipelineState.perPassResources.shadowAtlasWidth = atlasSize.width;
-  pipelineState.perPassResources.shadowAtlasHeight = atlasSize.height;
-  const preparedHistory = historyStore?.prepare({
-    enabled: camera.antialias === 'taa',
-    width: surfaceWidth,
-    height: surfaceHeight,
-    viewId: temporalViewId(camera.worldId, camera.entityKey),
-    pipelineOwnerGeneration: frameState.installedPipelineHandle,
-    surfaceFormat: topology.surface.storageFormat,
-  });
-  if (preparedHistory !== undefined && !preparedHistory.ok) {
-    temporalTransaction?.notePipelineFailure('capability');
-    internals.errorRegistry.fire(preparedHistory.error);
-    return null;
-  }
-  const history = preparedHistory?.value;
-  const temporalEnabled = topology.camera.antialias === 'taa';
-  const key = `${topologyKey(topology)}|taa-history:${history?.ownerGeneration ?? 0}`;
+  const key = JSON.stringify(topology);
   if (frameState.compiledFrameGraph !== null && frameState.compiledFrameGraphTopologyKey === key) {
-    if (history !== undefined) historyStore?.abort(history);
+    if (featureGraphCandidate !== undefined) {
+      commitFeatureCandidate(internals, featureGraphCandidate);
+    }
     return frameState.compiledFrameGraph;
   }
 
   const builder = new RenderGraphBuilder<RenderPipelineFrame>();
-  const bundle = environmentBundle(frameState);
-  let environmentTargets: import('../environment/graph').EnvironmentGraphTargets | undefined;
-  if (topology.environment?.enabled === true && bundle !== undefined) {
-    const imported = importEnvironmentGraphTargets(builder, {
-      descriptors: bundle.descriptors,
-      generation:
-        frameState.environmentGeneration.candidate?.generation ??
-        frameState.environmentGeneration.active?.generation ??
-        0,
-      resolve: (kind) =>
-        kind === 'sky' ? bundle.sky : kind === 'irradiance' ? bundle.irradiance : bundle.prefilter,
-    });
-    if (!imported.ok) {
-      if (history !== undefined) historyStore?.abort(history);
-      internals.errorRegistry.fire(imported.error);
-      return null;
-    }
-    environmentTargets = imported.value;
-  }
-  const importedHistory = history?.importResources(builder);
-  if (importedHistory !== undefined && !importedHistory.ok) {
-    if (temporalEnabled) temporalTransaction?.notePipelineFailure('pipeline');
-    if (history !== undefined) historyStore?.abort(history);
-    internals.errorRegistry.fire(importedHistory.error);
-    return null;
-  }
   let projectedFeatures = false;
   let projectedGpuDriven = false;
-  const temporalContract = createRenderPipelineTemporalContract({
-    enabled: temporalEnabled,
-    rgba16floatRenderable: internals.device.caps.rgba16floatRenderable,
-    maxColorAttachments: internals.device.caps.maxColorAttachments,
-    project: (targets) => {
-      const temporal = targets.sceneTemporal;
-      if (temporal === undefined) {
-        return err(
-          new TemporalUnsupportedError(
-            'temporal-attachment-missing',
-            'validated scene-temporal attachment',
-            'missing',
-          ),
-        );
-      }
-      const paramsBuffer = ensureTaaResolveParamsBuffer(
-        internals.device,
-        pipelineState.perPassResources,
-      );
-      if (!paramsBuffer.ok) return paramsBuffer;
-      return addTaaResolvePass(builder, {
-        sceneColor: targets.sceneColor,
-        sceneTemporal: temporal,
-        history: importedHistory?.value,
-        available: pipelineState.perPassResources.taaResolvePipeline !== null,
-      });
-    },
-  });
   const built = frameState.activePipeline.build(
     {
       graph: builder,
-      environment:
-        topology.environment?.enabled === true
-          ? {
-              enabled: true,
-              dirty: topology.environment.dirty,
-              ...(environmentTargets === undefined ? {} : { targets: environmentTargets }),
-              ...(environmentTargets?.skyCube === undefined
-                ? {}
-                : { sampledSky: environmentTargets.skyCube }),
-            }
-          : undefined,
       projectGpuDriven: (target) => {
         if (projectedGpuDriven || gpuDriven === undefined) return ok(undefined);
         projectedGpuDriven = true;
@@ -360,140 +395,67 @@ export function ensureCompiledFrameGraph(
       contributeFeatures: (targets) => {
         if (projectedFeatures) return ok(undefined);
         projectedFeatures = true;
-        const contributions = getRenderFeatureGraphState(internals).contributions;
-        if (contributions.length === 0) return ok(undefined);
+        if (projectedFeaturePlans.value.length === 0) return ok(undefined);
         const resolveTarget = targetResolver(targets);
-        const projected = projectRenderFeatureContributions(builder, contributions, {
+        const projected = projectPlanExecutions(builder, projectedFeaturePlans.value, {
           resolveTarget,
           resolveBindings: resolveTargetBindings,
           reportError: (error) => reportRenderFeatureGraphError(internals, error),
         });
         return projected.ok ? ok(undefined) : projected;
       },
-      resolveTemporal: temporalContract.resolve,
     },
     topology,
   );
   if (!built.ok) {
-    if (temporalEnabled) {
-      temporalTransaction?.notePipelineFailure(
-        built.error.code === 'taa-caps-insufficient' ? 'capability' : 'pipeline',
-        built.error.code === 'temporal-unsupported' ? 'temporal-unsupported' : 'graph-build-failed',
-      );
-    }
-    if (history !== undefined) historyStore?.abort(history);
     internals.errorRegistry.fire(built.error);
-    return null;
-  }
-  const temporalTopology = temporalContract.finish();
-  if (!temporalTopology.ok) {
-    if (temporalEnabled) {
-      temporalTransaction?.notePipelineFailure('pipeline', 'temporal-unsupported');
-    }
-    if (history !== undefined) historyStore?.abort(history);
-    internals.errorRegistry.fire(temporalTopology.error);
-    return null;
+    featureGraphCandidate?.onRejected?.();
+    return frameState.compiledFrameGraph;
   }
   const compiled = builder.compile({
     device: internals.device,
     surfaceSize: { width: surfaceWidth, height: surfaceHeight },
   });
   if (!compiled.ok) {
-    if (temporalEnabled) temporalTransaction?.notePipelineFailure('pipeline');
-    if (history !== undefined) historyStore?.abort(history);
     internals.errorRegistry.fire(compiled.error);
-    return null;
+    featureGraphCandidate?.onRejected?.();
+    return frameState.compiledFrameGraph;
   }
   const previous = frameState.compiledFrameGraph;
   frameState.compiledFrameGraph = compiled.value;
   frameState.compiledFrameGraphTopologyKey = key;
-  if (history !== undefined) historyStore?.commitGraph(compiled.value, history);
-  if (previous !== null) retire(frameState, previous, historyStore);
+  gpuDriven?._commitResourceReplacement();
+  if (featureGraphCandidate !== undefined) {
+    commitFeatureCandidate(internals, featureGraphCandidate);
+  }
+  if (previous !== null) retire(frameState, previous);
   return compiled.value;
 }
 
-export function retireCompiledFrameGraph(
-  frameState: RenderFrameState,
-  historyStore?: TemporalFrameTransaction['historyStore'],
-): void {
-  const graph = frameState.compiledFrameGraph;
-  if (graph === null) return;
-  frameState.compiledFrameGraph = null;
-  frameState.compiledFrameGraphTopologyKey = null;
-  retire(frameState, graph, historyStore);
-}
-
 export function executeCompiledFrameGraph(
   internals: RenderSystemInternals,
   frameState: RenderFrameState,
   frame: RenderPipelineFrame,
   encoder: RhiCommandEncoder,
   runPass?: import('@forgeax/engine-render-graph').RenderGraphPassRunner,
-  temporalFrame?: TemporalFrameAttempt,
-  environmentAttempt?: EnvironmentTransactionAttempt,
 ): boolean {
   const graph = frameState.compiledFrameGraph;
-  if (graph === null) {
-    temporalFrame?.abort('graph-unavailable');
-    environmentAttempt?.abort('execute');
-    return false;
-  }
+  if (graph === null) return false;
   const executed = graph.execute(frame, runPass);
   if (!executed.ok) {
     internals.errorRegistry.fire(executed.error);
-    temporalFrame?.abort('graph-execute');
-    environmentAttempt?.abort('execute');
     return false;
   }
   const finished = encoder.finish();
   if (!finished.ok) {
-    internals.membershipTiming?.markEncodeFailed(finished.error.hint);
     internals.errorRegistry.fire(finished.error);
-    temporalFrame?.abort('encoder-finish');
-    environmentAttempt?.abort('finish');
     return false;
   }
   const command: CommandBuffer = finished.value;
-  internals.membershipTiming?.markEncodeFinished();
-  internals.membershipTiming?.markSubmitStarted();
-  // RenderFrameState is created with an owner-admission state in production,
-  // but direct record-stage callers can provide an older partial state. Keep
-  // the submission boundary fail-closed to the historical independent mode
-  // instead of dereferencing an absent owner state after a successful encode.
-  const shadowSubmitModeState = frameState.shadowSubmitModeState ?? createShadowSubmitModeState();
-  frameState.shadowSubmitModeState = shadowSubmitModeState;
-  const pendingShadowCommandBuffers = frameState.pendingShadowCommandBuffers ?? [];
-  const plan = commandBufferPlanForFrame(
-    shadowSubmitModeState,
-    pendingShadowCommandBuffers,
-    command,
-  );
-  frameState.pendingShadowCommandBuffers = [];
-  if (!plan.ok) {
-    internals.membershipTiming?.markSubmitFailed();
-    internals.errorRegistry.fire(
-      new RhiError({
-        code: 'webgpu-runtime-error',
-        expected: 'renderer owner submission plan is valid',
-        hint: plan.error.hint,
-      }),
-    );
-    temporalFrame?.abort('submission-plan');
-    environmentAttempt?.abort('submit');
+  const submitted = internals.device.queue.submit([command]);
+  if (!submitted.ok) {
+    internals.errorRegistry.fire(submitted.error);
     return false;
   }
-  for (const submission of plan.value.rawSubmissions) {
-    const submitted = internals.device.queue.submit([...submission.commandBuffers]);
-    if (!submitted.ok) {
-      internals.membershipTiming?.markSubmitFailed();
-      internals.errorRegistry.fire(submitted.error);
-      temporalFrame?.abort('queue-submit');
-      environmentAttempt?.abort('submit');
-      return false;
-    }
-  }
-  internals.membershipTiming?.markSubmitted(command);
-  environmentAttempt?.publish();
-  temporalFrame?.commit();
   return true;
 }