@forgeax/engine-render 0.1.28 → 0.1.30

package/src/features/plan.ts

@@ -23,8 +23,22 @@ export type RenderFeatureMaterialShaderBindingContract =
   | 'group-0-resource'
   | 'view-only'
   | 'view-and-scene-depth'
+  | 'render-material-with-scene-depth'
+  | 'render-material-and-scene-depth'
   | 'render-material';
 
+/**
+ * Renderer-owned prepared resources that a closed RenderFeature data
+ * interface may consume for the current generation. The feature receives
+ * opaque references only; device creation and lifetime remain in Render.
+ */
+export interface RenderFeaturePreparedDataInterfaceResource {
+  readonly kind: 'buffer' | 'texture-view' | 'sampler';
+  readonly value: unknown;
+  readonly size?: number;
+  readonly usage?: 'uniform' | 'storage';
+}
+
 export type RenderFeatureFullscreenRead =
   | string
   | { readonly key: string; readonly sampleType?: 'depth' };
@@ -73,6 +87,22 @@ export type RenderFeatureResourceDeclaration =
       readonly usage: readonly RenderFeatureGpuBufferUsage[];
       readonly data?: ArrayBufferView;
     }
+  | {
+      /** A resident generation-owned resource supplied by a render-owned provider. */
+      readonly kind: 'prepared-gpu-resource';
+      readonly name: string;
+      readonly resource:
+        | {
+            readonly kind: 'buffer';
+            readonly value: unknown;
+            readonly size: number;
+            readonly usage?: readonly RenderFeatureGpuBufferUsage[];
+          }
+        | { readonly kind: 'texture-view'; readonly value: unknown }
+        | { readonly kind: 'sampler'; readonly value: unknown };
+      /** Optional graph target that backs a resident sampled resource. */
+      readonly logicalTarget?: string;
+    }
   | {
       readonly kind: 'compute-bindings';
       readonly name: string;
@@ -166,6 +196,11 @@ export interface RenderFeatureDrawDeclaration {
 }
 
 export type RenderFeaturePassDeclaration =
+  | {
+      readonly kind: 'shadow-caster';
+      readonly name: string;
+      readonly draws: readonly RenderFeatureDrawDeclaration[];
+    }
   | {
       readonly kind: 'compute';
       readonly name: string;
@@ -218,6 +253,15 @@ export interface RenderFeaturePlanContext {
   readonly materialShaderBindingContract?: (
     materialShaderId: string,
   ) => RenderFeatureMaterialShaderBindingContract;
+  /** Renderer-owned camera/depth/noise resources for the current generation; undefined means unavailable this frame. */
+  readonly preparedDataInterfaces?: Readonly<
+    Partial<
+      Record<
+        'camera' | 'scene-depth' | 'noise',
+        RenderFeaturePreparedDataInterfaceResource | undefined
+      >
+    >
+  >;
 }
 
 /** Frozen declaration produced for one feature in one frame. */
@@ -251,34 +295,494 @@ function validName(name: string): boolean {
   return /^[a-z][a-z0-9.-]{0,127}$/.test(name);
 }
 
-function stable(value: unknown): string {
+/** Detached accounting for the canonical plan signature path. */
+export interface RenderFeaturePlanSignatureMetrics {
+  calls: number;
+  typedArrayBytes: number;
+  outputChars: number;
+}
+
+const BYTE_HEX = '0123456789abcdef';
+const BYTE_HEX_CHUNK_SIZE = 2048;
+
+/**
+ * Append an exact byte spelling without Array#join's per-byte number/string
+ * conversion. Inline vertex/index payloads remain part of the canonical
+ * signature; this only changes their private textual representation from a
+ * comma-separated decimal list to bounded hex chunks.
+ */
+function appendByteHex(value: ArrayBufferView, parts: string[]): void {
+  const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  parts.push('[bytes-hex:');
+  for (let start = 0; start < bytes.length; start += BYTE_HEX_CHUNK_SIZE) {
+    const end = Math.min(bytes.length, start + BYTE_HEX_CHUNK_SIZE);
+    let encoded = '';
+    for (let index = start; index < end; index += 1) {
+      const byte = bytes[index] as number;
+      encoded += BYTE_HEX[byte >>> 4] as string;
+      encoded += BYTE_HEX[byte & 0x0f] as string;
+    }
+    parts.push(encoded);
+  }
+  parts.push(']');
+}
+
+/**
+ * Detached structural evidence for one plan signature.
+ *
+ * The renderer validates a plan twice: once while the feature host records
+ * the candidate signature and again while the typed graph admits that
+ * candidate. Keeping a detached structural snapshot lets the second check
+ * avoid rebuilding a large string while still detecting mutations to the
+ * shallow-frozen plan. This is intentionally a structural cache, not an
+ * object-identity shortcut.
+ */
+export type RenderFeaturePlanSignatureNode =
+  | { readonly kind: 'bytes'; readonly bytes: Uint8Array }
+  | {
+      readonly kind: 'array';
+      readonly values: readonly (RenderFeaturePlanSignatureNode | undefined)[];
+    }
+  | {
+      readonly kind: 'object';
+      readonly keys: readonly string[];
+      readonly values: readonly RenderFeaturePlanSignatureNode[];
+    }
+  | { readonly kind: 'primitive'; readonly token: string };
+
+export interface RenderFeaturePlanSignatureSnapshot {
+  readonly resources: readonly RenderFeaturePlanSignatureNode[];
+  readonly passes: RenderFeaturePlanSignatureNode;
+}
+
+const signatureEvidenceByPlan = new WeakMap<
+  object,
+  {
+    readonly signature: string;
+    readonly snapshot: RenderFeaturePlanSignatureSnapshot;
+  }
+>();
+
+// The detached evidence is deliberately checked again by graph admission.
+// Host and graph therefore share one exact structural proof without trusting
+// a producer-owned boolean or object identity if a plan is mutated between
+// the two stages.
+function compareStableKeys(left: string, right: string): number {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+function stablePrimitiveToken(value: unknown): string {
+  return JSON.stringify(value) ?? 'undefined';
+}
+
+/**
+ * Clone a signature node while reusing an unchanged subtree from the prior
+ * detached snapshot.  The prior node is never mutated: a changed parent gets
+ * a new frozen container and only equal children are shared.  This keeps the
+ * graph-admission evidence immutable while avoiding a full tree allocation
+ * when one VFX resource/pass changes.
+ */
+function cloneSignatureNode(
+  value: unknown,
+  previous?: RenderFeaturePlanSignatureNode,
+): RenderFeaturePlanSignatureNode {
+  if (ArrayBuffer.isView(value)) {
+    const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    if (previous?.kind === 'bytes' && previous.bytes.byteLength === bytes.byteLength) {
+      let equal = true;
+      for (let index = 0; index < bytes.length; index += 1) {
+        if (bytes[index] !== previous.bytes[index]) {
+          equal = false;
+          break;
+        }
+      }
+      if (equal) return previous;
+    }
+    return { kind: 'bytes', bytes: new Uint8Array(bytes) };
+  }
+  if (Array.isArray(value)) {
+    const values: (RenderFeaturePlanSignatureNode | undefined)[] = new Array(value.length);
+    const previousValues = previous?.kind === 'array' ? previous.values : undefined;
+    let changed = previousValues === undefined || previousValues.length !== value.length;
+    for (let index = 0; index < value.length; index += 1) {
+      const child = value[index];
+      const prior = previousValues?.[index];
+      const next = child === undefined ? undefined : cloneSignatureNode(child, prior);
+      values[index] = next;
+      if (next !== prior) changed = true;
+    }
+    if (!changed && previous?.kind === 'array') return previous;
+    return Object.freeze({ kind: 'array', values: Object.freeze(values) });
+  }
+  if (value !== null && typeof value === 'object') {
+    const source = value as Readonly<Record<string, unknown>>;
+    const previousObject = previous?.kind === 'object' ? previous : undefined;
+    let keys: readonly string[] | undefined;
+    let changed = previousObject === undefined;
+    if (previousObject !== undefined) {
+      // Descriptor object shapes are stable across VFX revisions.  Reuse the
+      // detached canonical key order after an allocation-free own-key check;
+      // only an actual add/remove falls back to Object.keys().sort().
+      let ownKeyCount = 0;
+      for (const key in source) {
+        if (Object.hasOwn(source, key)) ownKeyCount += 1;
+      }
+      if (ownKeyCount === previousObject.keys.length) {
+        let sameKeySet = true;
+        for (const key of previousObject.keys) {
+          if (!Object.hasOwn(source, key)) {
+            sameKeySet = false;
+            break;
+          }
+        }
+        if (sameKeySet) {
+          keys = previousObject.keys;
+        } else {
+          changed = true;
+        }
+      } else {
+        changed = true;
+      }
+    }
+    if (keys === undefined) {
+      keys = Object.freeze(Object.keys(source).sort(compareStableKeys));
+    }
+    const values = Object.freeze(
+      keys.map((key) => {
+        const previousIndex = previousObject?.keys.indexOf(key) ?? -1;
+        const prior = previousIndex < 0 ? undefined : previousObject?.values[previousIndex];
+        const next = cloneSignatureNode(source[key], prior);
+        if (next !== prior) changed = true;
+        return next;
+      }),
+    );
+    if (!changed && previousObject !== undefined) return previousObject;
+    return Object.freeze({
+      kind: 'object',
+      keys,
+      values,
+    });
+  }
+  const token = stablePrimitiveToken(value);
+  return previous?.kind === 'primitive' && previous.token === token
+    ? previous
+    : { kind: 'primitive', token };
+}
+
+function signatureResourceValue(resource: RenderFeatureResourceDeclaration): unknown {
+  if (resource.kind !== 'buffer') return resource;
+  // Match resourceTopology exactly: buffer payloads are upload evidence, not
+  // topology identity, while usage order is canonicalized before comparison.
+  return { ...resource, usage: [...resource.usage].sort(compareStableKeys), data: undefined };
+}
+
+/** Build a detached, mutation-resistant topology snapshot for one plan. */
+export function cloneRenderFeaturePlanSignatureSnapshot(
+  plan: RenderFeaturePlan,
+  previous?: RenderFeaturePlanSignatureSnapshot,
+): RenderFeaturePlanSignatureSnapshot {
+  const resources: RenderFeaturePlanSignatureNode[] = new Array(plan.resources.length);
+  let resourcesChanged = previous === undefined || previous.resources.length !== resources.length;
+  for (let index = 0; index < plan.resources.length; index += 1) {
+    const resource = plan.resources[index] as RenderFeatureResourceDeclaration;
+    const prior = previous?.resources[index];
+    let next: RenderFeaturePlanSignatureNode;
+    if (
+      prior !== undefined &&
+      (resource.kind === 'buffer'
+        ? equalResourceNode(resource, prior)
+        : equalSignatureNode(resource, prior))
+    ) {
+      next = prior;
+    } else {
+      // Buffer `data` is deliberately outside topology identity, so avoid
+      // materialising its normalized spread object on the common upload-only
+      // update path.  Changed declarations still share equal descendants.
+      next = cloneSignatureNode(signatureResourceValue(resource), prior);
+    }
+    resources[index] = next;
+    if (next !== prior) resourcesChanged = true;
+  }
+  const nextResources =
+    previous !== undefined && !resourcesChanged ? previous.resources : Object.freeze(resources);
+  const nextPasses = cloneSignatureNode(plan.passes, previous?.passes);
+  if (previous !== undefined && !resourcesChanged && nextPasses === previous.passes) {
+    return previous;
+  }
+  return Object.freeze({ resources: nextResources, passes: nextPasses });
+}
+
+function equalSignatureNode(value: unknown, snapshot: RenderFeaturePlanSignatureNode): boolean {
+  if (snapshot.kind === 'bytes') {
+    if (!ArrayBuffer.isView(value) || value.byteLength !== snapshot.bytes.byteLength) return false;
+    const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    for (let index = 0; index < bytes.length; index += 1) {
+      if (bytes[index] !== snapshot.bytes[index]) return false;
+    }
+    return true;
+  }
+  if (snapshot.kind === 'primitive') return stablePrimitiveToken(value) === snapshot.token;
+  if (snapshot.kind === 'array') {
+    if (!Array.isArray(value) || value.length !== snapshot.values.length) return false;
+    for (let index = 0; index < snapshot.values.length; index += 1) {
+      const expected = snapshot.values[index];
+      const current = value[index];
+      if (expected === undefined) {
+        // stable() intentionally spells holes and explicit undefined alike.
+        if (current !== undefined) return false;
+      } else if (!equalSignatureNode(current, expected)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (
+    value === null ||
+    typeof value !== 'object' ||
+    Array.isArray(value) ||
+    ArrayBuffer.isView(value)
+  ) {
+    return false;
+  }
+  const source = value as Readonly<Record<string, unknown>>;
+  // Avoid allocating Object.keys(source) on every frame. The snapshot keeps
+  // the canonical key order, so an own-property count plus direct lookups is
+  // equivalent while leaving the hot validation path allocation-free.
+  let ownKeyCount = 0;
+  for (const key in source) {
+    if (Object.hasOwn(source, key)) ownKeyCount += 1;
+  }
+  if (ownKeyCount !== snapshot.keys.length) return false;
+  for (let index = 0; index < snapshot.keys.length; index += 1) {
+    const key = snapshot.keys[index] as string;
+    if (!Object.hasOwn(source, key)) return false;
+    if (
+      !equalSignatureNode(source[key], snapshot.values[index] as RenderFeaturePlanSignatureNode)
+    ) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function equalSortedUsage(usage: unknown, snapshot: RenderFeaturePlanSignatureNode): boolean {
+  if (
+    !Array.isArray(usage) ||
+    snapshot.kind !== 'array' ||
+    usage.length !== snapshot.values.length
+  ) {
+    return false;
+  }
+  // Usage is a short string union. Compare it as a multiset so the check
+  // mirrors [...usage].sort() without allocating a sorted copy per frame.
+  for (let index = 0; index < snapshot.values.length; index += 1) {
+    const expected = snapshot.values[index];
+    if (expected === undefined || expected.kind !== 'primitive') return false;
+    let expectedCount = 0;
+    let currentCount = 0;
+    for (let candidate = 0; candidate < snapshot.values.length; candidate += 1) {
+      const sibling = snapshot.values[candidate];
+      if (
+        sibling !== undefined &&
+        sibling.kind === 'primitive' &&
+        sibling.token === expected.token
+      ) {
+        expectedCount += 1;
+      }
+      if (stablePrimitiveToken(usage[candidate]) === expected.token) currentCount += 1;
+    }
+    if (expectedCount !== currentCount) return false;
+  }
+  return true;
+}
+
+function equalResourceNode(resource: unknown, snapshot: RenderFeaturePlanSignatureNode): boolean {
+  if (
+    resource === null ||
+    typeof resource !== 'object' ||
+    Array.isArray(resource) ||
+    ArrayBuffer.isView(resource) ||
+    snapshot.kind !== 'object'
+  ) {
+    return false;
+  }
+  const source = resource as Readonly<Record<string, unknown>>;
+  if (source.kind !== 'buffer') return equalSignatureNode(source, snapshot);
+
+  // resourceTopology injects data: undefined even when no upload payload was
+  // authored. The live declaration may contain a typed array or omit it; both
+  // must compare equal because the payload is deliberately outside identity.
+  let comparableKeys = 0;
+  // Keep this branch allocation-free as well. Buffer declarations are among
+  // the most frequently validated resources in a frame.
+  for (const key in source) {
+    if (!Object.hasOwn(source, key)) continue;
+    if (key === 'data') continue;
+    const snapshotIndex = snapshot.keys.indexOf(key);
+    if (snapshotIndex < 0) return false;
+    comparableKeys += 1;
+    if (key === 'usage') {
+      if (
+        !equalSortedUsage(
+          source[key],
+          snapshot.values[snapshotIndex] as RenderFeaturePlanSignatureNode,
+        )
+      ) {
+        return false;
+      }
+    } else if (
+      !equalSignatureNode(
+        source[key],
+        snapshot.values[snapshotIndex] as RenderFeaturePlanSignatureNode,
+      )
+    ) {
+      return false;
+    }
+  }
+  let expectedComparableKeys = 0;
+  for (const key of snapshot.keys) {
+    if (key === 'data') continue;
+    expectedComparableKeys += 1;
+    if (!Object.hasOwn(source, key)) return false;
+  }
+  if (comparableKeys !== expectedComparableKeys) return false;
+  return true;
+}
+
+/** Exact structural equality against a detached signature snapshot. */
+export function renderFeaturePlanSignatureSnapshotEquals(
+  plan: RenderFeaturePlan,
+  snapshot: RenderFeaturePlanSignatureSnapshot,
+): boolean {
+  if (plan.resources.length !== snapshot.resources.length) return false;
+  for (let index = 0; index < plan.resources.length; index += 1) {
+    if (
+      !equalResourceNode(
+        plan.resources[index],
+        snapshot.resources[index] as RenderFeaturePlanSignatureNode,
+      )
+    ) {
+      return false;
+    }
+  }
+  return equalSignatureNode(plan.passes, snapshot.passes);
+}
+
+/** Associate a freshly produced plan with detached evidence for later validation. */
+export function rememberRenderFeaturePlanSignature(
+  plan: RenderFeaturePlan,
+  signature: string,
+  snapshot: RenderFeaturePlanSignatureSnapshot,
+): void {
+  signatureEvidenceByPlan.set(plan as object, { signature, snapshot });
+}
+
+/**
+ * Validate an existing signature without serializing the plan again. A false
+ * result means the plan has no evidence or its nested data no longer matches;
+ * callers must then run the canonical serializer as the recovery path.
+ */
+export function renderFeaturePlanSignatureEvidenceMatches(
+  plan: RenderFeaturePlan,
+  signature: string,
+): boolean {
+  const evidence = signatureEvidenceByPlan.get(plan as object);
+  return (
+    evidence !== undefined &&
+    evidence.signature === signature &&
+    renderFeaturePlanSignatureSnapshotEquals(plan, evidence.snapshot)
+  );
+}
+
+function stable(value: unknown, metrics?: RenderFeaturePlanSignatureMetrics): string {
+  const parts: string[] = [];
+  appendStable(value, parts, metrics);
+  return parts.join('');
+}
+
+function appendStable(
+  value: unknown,
+  parts: string[],
+  metrics?: RenderFeaturePlanSignatureMetrics,
+): void {
   if (ArrayBuffer.isView(value)) {
     const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
-    return `[bytes:${Array.from(bytes).join(',')}]`;
+    if (metrics !== undefined) metrics.typedArrayBytes += bytes.byteLength;
+    // Keep every byte in the canonical identity. Decimal Array#join creates
+    // a number/string conversion and a separator for every byte; bounded hex
+    // chunks cut that allocation footprint while remaining deterministic.
+    appendByteHex(value, parts);
+    return;
+  }
+  if (Array.isArray(value)) {
+    parts.push('[');
+    for (let index = 0; index < value.length; index += 1) {
+      if (index > 0) parts.push(',');
+      // Array#join renders holes and an explicit undefined child as an empty
+      // field; retain that canonical spelling instead of writing "undefined".
+      if (value[index] !== undefined) appendStable(value[index], parts, metrics);
+    }
+    parts.push(']');
+    return;
   }
-  if (Array.isArray(value)) return `[${value.map(stable).join(',')}]`;
   if (value !== null && typeof value === 'object') {
-    return `{${Object.entries(value as Readonly<Record<string, unknown>>)
-      .sort(([left], [right]) => left.localeCompare(right))
-      .map(([key, child]) => `${JSON.stringify(key)}:${stable(child)}`)
-      .join(',')}}`;
+    const keys = Object.keys(value as Readonly<Record<string, unknown>>).sort((left, right) =>
+      left < right ? -1 : left > right ? 1 : 0,
+    );
+    parts.push('{');
+    for (let index = 0; index < keys.length; index += 1) {
+      const key = keys[index] as string;
+      if (index > 0) parts.push(',');
+      parts.push(JSON.stringify(key), ':');
+      appendStable((value as Readonly<Record<string, unknown>>)[key], parts, metrics);
+    }
+    parts.push('}');
+    return;
   }
-  return JSON.stringify(value);
+  parts.push(JSON.stringify(value) ?? 'undefined');
 }
 
-function resourceTopology(resource: RenderFeatureResourceDeclaration): unknown {
+function resourceTopology(
+  resource: RenderFeatureResourceDeclaration,
+  metrics?: RenderFeaturePlanSignatureMetrics,
+): unknown {
   if (resource.kind === 'buffer') {
+    if (metrics !== undefined && resource.data !== undefined) {
+      metrics.typedArrayBytes += resource.data.byteLength;
+    }
     return { ...resource, usage: [...resource.usage].sort(), data: undefined };
   }
+  if (resource.kind === 'prepared-gpu-resource') {
+    return {
+      ...resource,
+      resource:
+        resource.resource.kind === 'buffer'
+          ? {
+              kind: 'buffer',
+              size: resource.resource.size,
+              usage: [...(resource.resource.usage ?? [])].sort(),
+            }
+          : { kind: resource.resource.kind },
+    };
+  }
   return resource;
 }
 
 /** Canonical signature used by typed-graph topology and last-known-good swap. */
-export function renderFeaturePlanSignature(plan: RenderFeaturePlan): string {
-  return stable({
-    resources: plan.resources.map(resourceTopology),
-    passes: plan.passes,
-  });
+export function renderFeaturePlanSignature(
+  plan: RenderFeaturePlan,
+  metrics?: RenderFeaturePlanSignatureMetrics,
+): string {
+  if (metrics !== undefined) metrics.calls += 1;
+  const signature = stable(
+    {
+      resources: plan.resources.map((resource) => resourceTopology(resource, metrics)),
+      passes: plan.passes,
+    },
+    metrics,
+  );
+  if (metrics !== undefined) metrics.outputChars += signature.length;
+  return signature;
 }
 
 function bindingAccess(type: GPUBufferBindingType | undefined): GraphBufferAccess | undefined {
@@ -312,6 +816,13 @@ export function deriveRenderFeaturePassAccess(
           layoutEntries.find((candidate) => candidate.binding === entry.binding)?.buffer?.type,
         );
         if (usage !== undefined) accesses.push({ resource: entry.resource, usage });
+        const declaration = resources.get(entry.resource);
+        if (
+          declaration?.kind === 'prepared-gpu-resource' &&
+          declaration.logicalTarget !== undefined
+        ) {
+          accesses.push({ resource: declaration.logicalTarget, usage: 'sampled-read' });
+        }
       }
     }
     for (const dispatch of pass.dispatches) {
@@ -322,10 +833,10 @@ export function deriveRenderFeaturePassAccess(
     return Object.freeze(accesses);
   }
 
-  for (const attachment of pass.colorAttachments) {
+  for (const attachment of pass.kind === 'raster' ? pass.colorAttachments : []) {
     accesses.push({ resource: attachment.target, usage: 'color-attachment' });
   }
-  if (pass.depthStencilAttachment !== undefined) {
+  if (pass.kind === 'raster' && pass.depthStencilAttachment !== undefined) {
     accesses.push({
       resource: pass.depthStencilAttachment.target,
       usage: pass.sampledTargets?.some(
@@ -335,7 +846,7 @@ export function deriveRenderFeaturePassAccess(
         : 'depth-stencil-write',
     });
   }
-  for (const target of pass.sampledTargets ?? []) {
+  for (const target of pass.kind === 'raster' ? (pass.sampledTargets ?? []) : []) {
     if (typeof target !== 'string') continue;
     accesses.push({ resource: target, usage: 'sampled-read' });
   }
@@ -381,6 +892,13 @@ export function freezeRenderFeaturePlan(
   for (const resource of plan.resources) {
     if (!validName(resource.name) || resources.has(resource.name))
       return err(stageFailure(identity));
+    if (
+      resource.kind === 'prepared-gpu-resource' &&
+      resource.logicalTarget !== undefined &&
+      !targets.has(resource.logicalTarget)
+    ) {
+      return err(stageFailure(identity));
+    }
     resources.set(resource.name, resource);
   }
   const passes = new Set<string>();
@@ -400,11 +918,17 @@ export function freezeRenderFeaturePlan(
       }
       const entryPoints = new Set(program.program.entryPoints);
       for (const entry of bindings.entries) {
-        const buffer = resources.get(entry.resource);
         const layout = program.program.bindings?.[0]?.entries.find(
           (candidate) => candidate.binding === entry.binding,
         );
-        if (buffer?.kind !== 'buffer' || layout?.buffer === undefined) {
+        const resource = resources.get(entry.resource);
+        const validBuffer = resource?.kind === 'buffer' && layout?.buffer !== undefined;
+        const validPrepared =
+          resource?.kind === 'prepared-gpu-resource' &&
+          ((resource.resource.kind === 'buffer' && layout?.buffer !== undefined) ||
+            (resource.resource.kind === 'texture-view' && layout?.texture !== undefined) ||
+            (resource.resource.kind === 'sampler' && layout?.sampler !== undefined));
+        if (!validBuffer && !validPrepared) {
           return err(stageFailure(identity));
         }
       }
@@ -436,11 +960,13 @@ export function freezeRenderFeaturePlan(
 
     if (
       pass.draws.length === 0 ||
-      pass.colorAttachments.some((attachment) => !targets.has(attachment.target)) ||
-      (pass.depthStencilAttachment !== undefined &&
-        !targets.has(pass.depthStencilAttachment.target)) ||
-      pass.sampledTargets?.some((target) => typeof target === 'string' && !targets.has(target)) ===
-        true
+      (pass.kind === 'raster' &&
+        (pass.colorAttachments.some((attachment) => !targets.has(attachment.target)) ||
+          (pass.depthStencilAttachment !== undefined &&
+            !targets.has(pass.depthStencilAttachment.target)) ||
+          pass.sampledTargets?.some(
+            (target) => typeof target === 'string' && !targets.has(target),
+          ) === true))
     ) {
       return err(stageFailure(identity));
     }
@@ -448,6 +974,9 @@ export function freezeRenderFeaturePlan(
       const program = resources.get(draw.program);
       if (
         program?.kind !== 'graphics-program' ||
+        (pass.kind === 'shadow-caster' &&
+          (program.program.colorFormats.length !== 0 ||
+            program.program.depthFormat !== 'depth32float')) ||
         draw.bindings.some((name) => {
           const binding = resources.get(name);
           return binding?.kind !== 'graphics-bindings' || binding.program !== draw.program;