@hraness/slopcamera 3.2.7 → 3.3.1

package/apps/desktop/application/operations/spatial-behavior.ts

@@ -0,0 +1,151 @@
+import { z } from "zod";
+import { createBoundedJsonValueSnapshot } from "../../../../src/code/json-snapshot";
+import {
+  SpatialDigestSchema,
+  SpatialSceneV1Schema,
+  SpatialTimeUsSchema,
+} from "../../../../src/spatial-scene/contracts";
+import {
+  checkSpatialBehavior,
+  SpatialBehaviorCheckReportSchema,
+  SpatialBehaviorSchema,
+} from "../../../../src/spatial-scene/behavior";
+import {
+  auditSpatialBehaviorTrace,
+  SpatialBehaviorAuditOptionsSchema,
+  SpatialBehaviorAuditReportSchema,
+} from "../../../../src/spatial-scene/behavior-audit";
+import { bakeSpatialBehavior } from "../../../../src/spatial-scene/behavior-bake";
+import { spatialBehaviorFnSignatures } from "../../../../src/spatial-scene/behavior-fns";
+import {
+  planSpatialBehaviorGallery,
+  SpatialBehaviorGalleryPlanSchema,
+} from "../../../../src/spatial-scene/behavior-gallery";
+import {
+  SpatialBehaviorBakeSchema,
+  SpatialBehaviorChannelMapSchema,
+  SpatialBehaviorEmittedSchema,
+} from "../../../../src/spatial-scene/behavior-trace";
+import type { OperationDefinition, OperationPolicy } from "../operation";
+import { throwIfAborted } from "./shared";
+
+const capture = (value: unknown) => createBoundedJsonValueSnapshot(
+  value,
+  8 * 1024 * 1024,
+  "behavior operation",
+  { maximumDepth: 36, maximumValues: 400_000 },
+).value;
+
+export const SpatialBehaviorCheckInputSchema = z.preprocess(capture, z.strictObject({
+  behavior: SpatialBehaviorSchema,
+  scene: SpatialSceneV1Schema,
+}));
+export const SpatialBehaviorBakeInputSchema = z.preprocess(capture, z.strictObject({
+  behavior: SpatialBehaviorSchema,
+  channelMap: SpatialBehaviorChannelMapSchema.optional(),
+  scene: SpatialSceneV1Schema,
+}));
+export const SpatialBehaviorGalleryInputSchema = z.preprocess(capture, z.strictObject({
+  behavior: SpatialBehaviorSchema,
+  channelMap: SpatialBehaviorChannelMapSchema.optional(),
+  scene: SpatialSceneV1Schema,
+}));
+
+export const SpatialBehaviorAuditInputSchema = z.preprocess(capture, z.strictObject({
+  emitted: z.array(SpatialBehaviorEmittedSchema).max(16_384),
+  behaviorSha256: SpatialDigestSchema,
+  emittedSha256: SpatialDigestSchema,
+  rangeUs: z.strictObject({ startUs: SpatialTimeUsSchema, endUs: SpatialTimeUsSchema }),
+  options: SpatialBehaviorAuditOptionsSchema.optional(),
+}));
+
+export type SpatialBehaviorCheckInput = z.infer<typeof SpatialBehaviorCheckInputSchema>;
+export type SpatialBehaviorBakeInput = z.infer<typeof SpatialBehaviorBakeInputSchema>;
+export type SpatialBehaviorGalleryInput = z.infer<typeof SpatialBehaviorGalleryInputSchema>;
+export type SpatialBehaviorAuditInput = z.infer<typeof SpatialBehaviorAuditInputSchema>;
+export type SpatialBehaviorCheckOutput = z.infer<typeof SpatialBehaviorCheckReportSchema>;
+export type SpatialBehaviorBakeOutput = z.infer<typeof SpatialBehaviorBakeSchema>;
+export type SpatialBehaviorGalleryOutput = z.infer<typeof SpatialBehaviorGalleryPlanSchema>;
+export type SpatialBehaviorAuditOutput = z.infer<typeof SpatialBehaviorAuditReportSchema>;
+
+const purePolicy = Object.freeze({
+  cache: "content-addressed", cancellable: true, effect: "pure", maxDurationMs: 10_000,
+  maxFanOut: 0, maxInputBytes: 8 * 1024 * 1024, maxOutputBytes: 16 * 1024 * 1024,
+  preparation: [], resources: [{ amount: 1, resource: "cpu" }], resume: "deterministic",
+} as const) satisfies OperationPolicy;
+
+export const spatialBehaviorCheckOperationDefinition = {
+  kind: "scene.behavior.check", version: 1,
+  inputSchema: SpatialBehaviorCheckInputSchema,
+  inputSchemaId: "slopcamera.operation.scene.behavior.check.input/v1",
+  outputSchema: SpatialBehaviorCheckReportSchema,
+  outputSchemaId: "slopcamera.operation.scene.behavior.check.output/v1",
+  policy: purePolicy,
+  lifecycle: { kind: "pure", execute: (context, input) => {
+    throwIfAborted(context.abortSignal);
+    return Promise.resolve(SpatialBehaviorCheckReportSchema.parse(
+      checkSpatialBehavior({ behavior: input.behavior, scene: input.scene }, spatialBehaviorFnSignatures()),
+    ));
+  } },
+  summarize: output => ({ kind: "scene.behavior.check", fields: {
+    behaviorSha256: output.behaviorSha256, errors: output.counts.errors, warnings: output.counts.warnings,
+  } }),
+} satisfies OperationDefinition<"scene.behavior.check", SpatialBehaviorCheckInput, SpatialBehaviorCheckOutput>;
+
+export const spatialBehaviorBakeOperationDefinition = {
+  kind: "scene.behavior.bake", version: 1,
+  inputSchema: SpatialBehaviorBakeInputSchema,
+  inputSchemaId: "slopcamera.operation.scene.behavior.bake.input/v1",
+  outputSchema: SpatialBehaviorBakeSchema,
+  outputSchemaId: "slopcamera.operation.scene.behavior.bake.output/v1",
+  policy: purePolicy,
+  lifecycle: { kind: "pure", execute: async (context, input) => {
+    throwIfAborted(context.abortSignal);
+    const { bake } = await bakeSpatialBehavior({
+      behavior: input.behavior, scene: input.scene,
+      ...(input.channelMap === undefined ? {} : { channelMap: input.channelMap }),
+    });
+    return SpatialBehaviorBakeSchema.parse(bake);
+  } },
+  summarize: output => ({ kind: "scene.behavior.bake", fields: {
+    behaviorSha256: output.behaviorSha256, emitted: output.emitted.length,
+    directives: output.directives.length, unresolved: output.unresolvedIntents.length,
+    runDigest: output.receipt.runDigest,
+  } }),
+} satisfies OperationDefinition<"scene.behavior.bake", SpatialBehaviorBakeInput, SpatialBehaviorBakeOutput>;
+
+export const spatialBehaviorGalleryOperationDefinition = {
+  kind: "scene.behavior.gallery", version: 1,
+  inputSchema: SpatialBehaviorGalleryInputSchema,
+  inputSchemaId: "slopcamera.operation.scene.behavior.gallery.input/v1",
+  outputSchema: SpatialBehaviorGalleryPlanSchema,
+  outputSchemaId: "slopcamera.operation.scene.behavior.gallery.output/v1",
+  policy: purePolicy,
+  lifecycle: { kind: "pure", execute: async (context, input) => {
+    throwIfAborted(context.abortSignal);
+    return SpatialBehaviorGalleryPlanSchema.parse(await planSpatialBehaviorGallery({
+      behavior: input.behavior, scene: input.scene,
+      ...(input.channelMap === undefined ? {} : { channelMap: input.channelMap }),
+    }));
+  } },
+  summarize: output => ({ kind: "scene.behavior.gallery", fields: {
+    behaviorSha256: output.behaviorSha256, candidates: output.candidates.length,
+  } }),
+} satisfies OperationDefinition<"scene.behavior.gallery", SpatialBehaviorGalleryInput, SpatialBehaviorGalleryOutput>;
+
+export const spatialBehaviorAuditOperationDefinition = {
+  kind: "scene.behavior.audit", version: 1,
+  inputSchema: SpatialBehaviorAuditInputSchema,
+  inputSchemaId: "slopcamera.operation.scene.behavior.audit.input/v1",
+  outputSchema: SpatialBehaviorAuditReportSchema,
+  outputSchemaId: "slopcamera.operation.scene.behavior.audit.output/v1",
+  policy: purePolicy,
+  lifecycle: { kind: "pure", execute: (context, input) => {
+    throwIfAborted(context.abortSignal);
+    return Promise.resolve(SpatialBehaviorAuditReportSchema.parse(auditSpatialBehaviorTrace(input)));
+  } },
+  summarize: output => ({ kind: "scene.behavior.audit", fields: {
+    behaviorSha256: output.behaviorSha256, findings: output.findings.length,
+    channels: output.channelCount, emitted: output.emittedCount,
+  } }),
+} satisfies OperationDefinition<"scene.behavior.audit", SpatialBehaviorAuditInput, SpatialBehaviorAuditOutput>;

package/apps/desktop/application/operations/spatial-direction.ts

@@ -0,0 +1,222 @@
+import { z } from "zod";
+import { createBoundedJsonValueSnapshot } from "../../../../src/code/json-snapshot";
+import {
+  SpatialCameraIdSchema,
+  SpatialSceneV1Schema,
+  SpatialTimeUsSchema,
+} from "../../../../src/spatial-scene/contracts";
+import { SpatialDirectionSchema } from "../../../../src/spatial-scene/direction";
+import {
+  checkSpatialDirection,
+  compileSpatialDirection,
+  SpatialDirectionCheckReportSchema,
+  SpatialDirectionCompilationSchema,
+} from "../../../../src/spatial-scene/direction-compile";
+import {
+  createSpatialEvaluationContext,
+  evaluateSpatialSceneInContext,
+} from "../../../../src/spatial-scene/evaluate";
+import {
+  planSpatialDirectionGallery,
+  SpatialGalleryAxisSchema,
+  SpatialGalleryPlanSchema,
+} from "../../../../src/spatial-scene/gallery";
+import { SpatialParticleSystemSchema } from "../../../../src/spatial-scene/particle";
+import { SpatialRenderPlanSchema } from "../../../../src/spatial-scene/effects";
+import {
+  checkSpatialRenderEffects,
+  planSpatialRenderEffects,
+  SPATIAL_RENDER_EFFECTS_LIMITS,
+  SpatialEffectsCheckReportSchema,
+  SpatialRenderEffectsBindingSchema,
+  SpatialRenderEffectsDocumentSchema,
+} from "../../../../src/spatial-scene/render-effects";
+import { SpatialSimulationBakeReceiptSchema } from "../../../../src/spatial-scene/simulation";
+import {
+  auditSpatialTemporalEvidence,
+  SpatialTemporalAuditOptionsSchema,
+  SpatialTemporalAuditReportSchema,
+} from "../../../../src/spatial-scene/temporal-audit";
+import type { OperationDefinition, OperationPolicy } from "../operation";
+import { throwIfAborted } from "./shared";
+
+const capture = (value: unknown) => createBoundedJsonValueSnapshot(
+  value,
+  8 * 1024 * 1024,
+  "scene planning operation",
+  { maximumDepth: 36, maximumValues: 400_000 },
+).value;
+
+export const SpatialDirectionCheckInputSchema = z.preprocess(capture, z.strictObject({
+  direction: SpatialDirectionSchema,
+  scene: SpatialSceneV1Schema,
+}));
+export const SpatialDirectionCompileInputSchema = z.preprocess(capture, z.strictObject({
+  cameraId: SpatialCameraIdSchema.optional(),
+  direction: SpatialDirectionSchema,
+  scene: SpatialSceneV1Schema,
+}));
+export const SpatialDirectionGalleryInputSchema = z.preprocess(capture, z.strictObject({
+  axis: SpatialGalleryAxisSchema,
+  cameraId: SpatialCameraIdSchema.optional(),
+  direction: SpatialDirectionSchema,
+  scene: SpatialSceneV1Schema,
+}));
+export const SpatialEffectsCheckInputSchema = z.preprocess(capture, z.strictObject({
+  effects: z.union([SpatialRenderEffectsBindingSchema, SpatialRenderEffectsDocumentSchema]),
+  scene: SpatialSceneV1Schema,
+}));
+export const SpatialEffectsPlanInputSchema = z.preprocess(capture, z.strictObject({
+  particleSystems: z.array(SpatialParticleSystemSchema).max(SPATIAL_RENDER_EFFECTS_LIMITS.particleSystems).default([]),
+  renderPlan: SpatialRenderPlanSchema,
+  scene: SpatialSceneV1Schema,
+  simulationBakes: z.array(SpatialSimulationBakeReceiptSchema).max(SPATIAL_RENDER_EFFECTS_LIMITS.simulationBakes).default([]),
+}));
+export const SpatialTemporalAuditInputSchema = z.preprocess(capture, z.strictObject({
+  cameraId: SpatialCameraIdSchema,
+  options: SpatialTemporalAuditOptionsSchema.optional(),
+  scene: SpatialSceneV1Schema,
+  timesUs: z.array(SpatialTimeUsSchema).min(2).max(64).optional(),
+}));
+export type SpatialDirectionCheckInput = z.infer<typeof SpatialDirectionCheckInputSchema>;
+export type SpatialDirectionCompileInput = z.infer<typeof SpatialDirectionCompileInputSchema>;
+export type SpatialDirectionGalleryInput = z.infer<typeof SpatialDirectionGalleryInputSchema>;
+export type SpatialEffectsCheckInput = z.infer<typeof SpatialEffectsCheckInputSchema>;
+export type SpatialEffectsPlanInput = z.infer<typeof SpatialEffectsPlanInputSchema>;
+export type SpatialTemporalAuditInput = z.infer<typeof SpatialTemporalAuditInputSchema>;
+export type SpatialDirectionCheckOutput = z.infer<typeof SpatialDirectionCheckReportSchema>;
+export type SpatialDirectionCompileOutput = z.infer<typeof SpatialDirectionCompilationSchema>;
+export type SpatialDirectionGalleryOutput = z.infer<typeof SpatialGalleryPlanSchema>;
+export type SpatialEffectsCheckOutput = z.infer<typeof SpatialEffectsCheckReportSchema>;
+export type SpatialEffectsPlanOutput = z.infer<typeof SpatialRenderEffectsBindingSchema>;
+export type SpatialTemporalAuditOutput = z.infer<typeof SpatialTemporalAuditReportSchema>;
+
+const purePolicy = Object.freeze({
+  cache: "content-addressed", cancellable: true, effect: "pure", maxDurationMs: 10_000,
+  maxFanOut: 0, maxInputBytes: 8 * 1024 * 1024, maxOutputBytes: 16 * 1024 * 1024,
+  preparation: [], resources: [{ amount: 1, resource: "cpu" }], resume: "deterministic",
+} as const) satisfies OperationPolicy;
+
+const compileTimesUs = (input: SpatialTemporalAuditInput): readonly number[] => {
+  if (input.timesUs !== undefined) return [...input.timesUs].sort((left, right) => left - right);
+  const count = Math.min(17, Math.max(2, Math.ceil(input.scene.durationUs / 1_000_000) + 1));
+  return Array.from({ length: count }, (_, index) => Math.floor((input.scene.durationUs * index) / (count - 1)));
+};
+
+export const spatialDirectionCheckOperationDefinition = {
+  kind: "scene.direction.check", version: 1,
+  inputSchema: SpatialDirectionCheckInputSchema,
+  inputSchemaId: "slopcamera.operation.scene.direction.check.input/v1",
+  outputSchema: SpatialDirectionCheckReportSchema,
+  outputSchemaId: "slopcamera.operation.scene.direction.check.output/v1",
+  policy: purePolicy,
+  lifecycle: { kind: "pure", execute: (context, input) => {
+    throwIfAborted(context.abortSignal);
+    return Promise.resolve(SpatialDirectionCheckReportSchema.parse(
+      checkSpatialDirection({ direction: input.direction, scene: input.scene }),
+    ));
+  } },
+  summarize: output => ({ kind: "scene.direction.check", fields: {
+    directionSha256: output.directionSha256, errors: output.counts.errors, warnings: output.counts.warnings,
+  } }),
+} satisfies OperationDefinition<"scene.direction.check", SpatialDirectionCheckInput, SpatialDirectionCheckOutput>;
+
+export const spatialDirectionCompileOperationDefinition = {
+  kind: "scene.direction.compile", version: 1,
+  inputSchema: SpatialDirectionCompileInputSchema,
+  inputSchemaId: "slopcamera.operation.scene.direction.compile.input/v1",
+  outputSchema: SpatialDirectionCompilationSchema,
+  outputSchemaId: "slopcamera.operation.scene.direction.compile.output/v1",
+  policy: purePolicy,
+  lifecycle: { kind: "pure", execute: (context, input) => {
+    throwIfAborted(context.abortSignal);
+    return Promise.resolve(SpatialDirectionCompilationSchema.parse(compileSpatialDirection({
+      direction: input.direction, scene: input.scene,
+      ...(input.cameraId === undefined ? {} : { cameraId: input.cameraId }),
+    })));
+  } },
+  summarize: output => ({ kind: "scene.direction.compile", fields: {
+    sceneSha256: output.sceneSha256, shots: output.proposals.shots.length,
+    unresolved: output.unresolvedIntents.length, advisories: output.advisories.length,
+  } }),
+} satisfies OperationDefinition<"scene.direction.compile", SpatialDirectionCompileInput, SpatialDirectionCompileOutput>;
+
+export const spatialDirectionGalleryOperationDefinition = {
+  kind: "scene.direction.gallery", version: 1,
+  inputSchema: SpatialDirectionGalleryInputSchema,
+  inputSchemaId: "slopcamera.operation.scene.direction.gallery.input/v1",
+  outputSchema: SpatialGalleryPlanSchema,
+  outputSchemaId: "slopcamera.operation.scene.direction.gallery.output/v1",
+  policy: purePolicy,
+  lifecycle: { kind: "pure", execute: (context, input) => {
+    throwIfAborted(context.abortSignal);
+    return Promise.resolve(SpatialGalleryPlanSchema.parse(planSpatialDirectionGallery({
+      axis: input.axis, direction: input.direction, scene: input.scene,
+      ...(input.cameraId === undefined ? {} : { cameraId: input.cameraId }),
+    })));
+  } },
+  summarize: output => ({ kind: "scene.direction.gallery", fields: {
+    axis: output.axis, candidates: output.candidates.length, sourceSha256: output.sourceSha256,
+  } }),
+} satisfies OperationDefinition<"scene.direction.gallery", SpatialDirectionGalleryInput, SpatialDirectionGalleryOutput>;
+
+export const spatialEffectsCheckOperationDefinition = {
+  kind: "scene.effects.check", version: 1,
+  inputSchema: SpatialEffectsCheckInputSchema,
+  inputSchemaId: "slopcamera.operation.scene.effects.check.input/v1",
+  outputSchema: SpatialEffectsCheckReportSchema,
+  outputSchemaId: "slopcamera.operation.scene.effects.check.output/v1",
+  policy: purePolicy,
+  lifecycle: { kind: "pure", execute: (context, input) => {
+    throwIfAborted(context.abortSignal);
+    return Promise.resolve(SpatialEffectsCheckReportSchema.parse(
+      checkSpatialRenderEffects({ effects: input.effects, scene: input.scene }),
+    ));
+  } },
+  summarize: output => ({ kind: "scene.effects.check", fields: {
+    errors: output.counts.errors, warnings: output.counts.warnings, sceneSha256: output.sceneSha256,
+  } }),
+} satisfies OperationDefinition<"scene.effects.check", SpatialEffectsCheckInput, SpatialEffectsCheckOutput>;
+
+export const spatialEffectsPlanOperationDefinition = {
+  kind: "scene.effects.plan", version: 1,
+  inputSchema: SpatialEffectsPlanInputSchema,
+  inputSchemaId: "slopcamera.operation.scene.effects.plan.input/v1",
+  outputSchema: SpatialRenderEffectsBindingSchema,
+  outputSchemaId: "slopcamera.operation.scene.effects.plan.output/v1",
+  policy: purePolicy,
+  lifecycle: { kind: "pure", execute: (context, input) => {
+    throwIfAborted(context.abortSignal);
+    return Promise.resolve(SpatialRenderEffectsBindingSchema.parse(planSpatialRenderEffects({
+      particleSystems: input.particleSystems, renderPlan: input.renderPlan, scene: input.scene,
+      simulationBakes: input.simulationBakes,
+    })));
+  } },
+  summarize: output => ({ kind: "scene.effects.plan", fields: {
+    documentSha256: output.documentSha256, renderPlanSha256: output.document.renderPlanSha256,
+  } }),
+} satisfies OperationDefinition<"scene.effects.plan", SpatialEffectsPlanInput, SpatialEffectsPlanOutput>;
+
+export const spatialTemporalAuditOperationDefinition = {
+  kind: "scene.temporal-audit", version: 1,
+  inputSchema: SpatialTemporalAuditInputSchema,
+  inputSchemaId: "slopcamera.operation.scene.temporal-audit.input/v1",
+  outputSchema: SpatialTemporalAuditReportSchema,
+  outputSchemaId: "slopcamera.operation.scene.temporal-audit.output/v1",
+  policy: purePolicy,
+  lifecycle: { kind: "pure", execute: (context, input) => {
+    throwIfAborted(context.abortSignal);
+    const evaluationContext = createSpatialEvaluationContext(input.scene);
+    const snapshots = compileTimesUs(input).map(timeUs =>
+      evaluateSpatialSceneInContext(evaluationContext, { cameraId: input.cameraId, timeUs }));
+    return Promise.resolve(SpatialTemporalAuditReportSchema.parse(
+      auditSpatialTemporalEvidence({
+        snapshots,
+        ...(input.options === undefined ? {} : { options: input.options }),
+      }),
+    ));
+  } },
+  summarize: output => ({ kind: "scene.temporal-audit", fields: {
+    findings: output.findings.length, samples: output.sampleCount, sceneSha256: output.sceneSha256,
+  } }),
+} satisfies OperationDefinition<"scene.temporal-audit", SpatialTemporalAuditInput, SpatialTemporalAuditOutput>;

package/apps/desktop/application/operations/spatial-rendered-audit.ts

@@ -0,0 +1,174 @@
+import { constants } from "node:fs";
+import { mkdtemp, open, rm } from "node:fs/promises";
+import { dirname, join, posix } from "node:path";
+
+import { z } from "zod";
+
+import { createBoundedJsonValueSnapshot } from "../../../../src/code/json-snapshot";
+import { SPATIAL_SCENE_LIMITS, SpatialAssetIdSchema, SpatialDigestSchema } from "../../../../src/spatial-scene/contracts";
+import { parseSpatialScene, spatialSceneSha256 } from "../../../../src/spatial-scene/identity";
+import { SpatialRenderedAuditReportSchema } from "../../../../src/spatial-scene/audit-rendered";
+import { ensurePhysicalPrivateDirectoryWithin } from "../../cli/paths";
+import { canonicalJson } from "../../core/canonical-json";
+import { exactCapabilityByName } from "../capability-binding";
+import type { ApplicationContext } from "../context";
+import { ApplicationError } from "../errors";
+import { bindHtmlOverlayBrowserRuntime, HtmlOverlayBrowserRuntimeBindingSchema } from "../html-overlay-browser-runtime";
+import type { OperationDefinition, OperationExecutionContext } from "../operation";
+import {
+  auditSpatialSceneRenderedHost, planSpatialRenderedAudit, spatialRenderedAuditCapabilityNames,
+  SpatialRenderedAuditRequestSchema, type SpatialRenderedAuditDependencies,
+} from "../spatial-rendered-audit";
+import { MediaCapabilityBindingsSchema, bindExpectedMediaCapabilities } from "./media/capabilities";
+import {
+  MediaArtifactReferenceSchema, MediaArtifactRequestSchema, bindRepositoryMedia, loadRepositoryMedia,
+  createMediaOperationWorkspace,
+} from "./media/shared";
+
+const MAXIMUM_ASSET_BYTES = 256 * 1024 * 1024;
+const AssetBindingSchema = z.strictObject({ assetId: SpatialAssetIdSchema, artifact: MediaArtifactReferenceSchema });
+const requestShape = z.strictObject({
+  source: MediaArtifactRequestSchema,
+  assets: z.array(AssetBindingSchema).max(SPATIAL_SCENE_LIMITS.assets).optional(),
+  request: SpatialRenderedAuditRequestSchema,
+  sceneSha256: SpatialDigestSchema.optional(),
+  capabilityBindings: MediaCapabilityBindingsSchema.optional(),
+  browserRuntime: HtmlOverlayBrowserRuntimeBindingSchema.optional(),
+});
+const captured = (input: unknown) => createBoundedJsonValueSnapshot(input, 16 * 1024 * 1024, "spatial rendered audit request", { maximumDepth: 48, maximumValues: 500_000 }).value;
+export const SpatialRenderedAuditInputSchema = z.preprocess(captured, requestShape);
+export const BoundSpatialRenderedAuditInputSchema = z.preprocess(captured, requestShape.extend({
+  source: MediaArtifactReferenceSchema,
+  assets: z.array(AssetBindingSchema).max(SPATIAL_SCENE_LIMITS.assets),
+  sceneSha256: SpatialDigestSchema,
+  capabilityBindings: MediaCapabilityBindingsSchema,
+  browserRuntime: HtmlOverlayBrowserRuntimeBindingSchema,
+}));
+/** The output is the report itself, matching scene.audit; nothing is published. */
+export const SpatialRenderedAuditOutputSchema = SpatialRenderedAuditReportSchema;
+export type SpatialRenderedAuditInput = z.infer<typeof SpatialRenderedAuditInputSchema>;
+export type BoundSpatialRenderedAuditInput = z.infer<typeof BoundSpatialRenderedAuditInputSchema>;
+export type SpatialRenderedAuditOutput = z.infer<typeof SpatialRenderedAuditOutputSchema>;
+
+function sourceDocument(data: Uint8Array) {
+  try { return parseSpatialScene(JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(data))); }
+  catch (error) { throw new ApplicationError("invalid-data", `Invalid spatial source: ${error instanceof Error ? error.message : String(error)}`); }
+}
+
+/**
+ * The source grants access only to its bounded, root-contained declared
+ * closure. Capability and browser-runtime identity are bound at admission and
+ * re-verified inside the host service, exactly like scene.render.
+ */
+export async function bindSpatialRenderedAuditInput(
+  application: ApplicationContext,
+  input: unknown,
+  signal = new AbortController().signal,
+  bindRuntime: typeof bindHtmlOverlayBrowserRuntime = bindHtmlOverlayBrowserRuntime,
+): Promise<BoundSpatialRenderedAuditInput> {
+  const parsed = SpatialRenderedAuditInputSchema.parse(input);
+  const source = await loadRepositoryMedia(application, parsed.source, signal, SPATIAL_SCENE_LIMITS.sourceBytes);
+  const scene = sourceDocument(source.data);
+  planSpatialRenderedAudit(scene, parsed.request);
+  const sceneSha256 = spatialSceneSha256(scene);
+  if (parsed.sceneSha256 !== undefined && parsed.sceneSha256 !== sceneSha256) throw new ApplicationError("conflict", "Scene source changed after planning.");
+  if (scene.assets.reduce((sum, asset) => sum + asset.payload.bytes, 0) > MAXIMUM_ASSET_BYTES) throw new ApplicationError("invalid-data", "Scene asset closure exceeds 256 MiB.");
+  const supplied = parsed.assets === undefined ? undefined : new Map(parsed.assets.map(item => [item.assetId, item.artifact]));
+  if (supplied !== undefined && (supplied.size !== parsed.assets!.length || supplied.size !== scene.assets.length || scene.assets.some(asset => !supplied.has(asset.assetId)))) throw new ApplicationError("invalid-data", "Asset bindings must name every declared asset exactly once.");
+  const assets: z.infer<typeof AssetBindingSchema>[] = [];
+  for (const asset of scene.assets) {
+    const request = supplied?.get(asset.assetId) ?? {
+      ...asset.payload, path: posix.join(posix.dirname(source.artifact.path), asset.payload.path),
+    };
+    if (request.sha256 !== asset.payload.sha256 || request.bytes !== asset.payload.bytes) throw new ApplicationError("conflict", `Asset ${asset.assetId} does not match its source manifest.`);
+    const bound = await bindRepositoryMedia(application, request, signal, asset.payload.bytes);
+    assets.push({ assetId: asset.assetId, artifact: bound.artifact });
+  }
+  const capabilityBindings = await bindExpectedMediaCapabilities(application, spatialRenderedAuditCapabilityNames(scene), parsed.capabilityBindings);
+  const browserRuntime = await bindRuntime(exactCapabilityByName(capabilityBindings, "html-browser"), signal);
+  if (parsed.browserRuntime !== undefined && canonicalJson(parsed.browserRuntime) !== canonicalJson(browserRuntime)) throw new ApplicationError("conflict", "Browser runtime changed after rendered audit planning.");
+  return BoundSpatialRenderedAuditInputSchema.parse({ ...parsed, source: source.artifact, assets, sceneSha256, capabilityBindings, browserRuntime });
+}
+
+async function writePrivateFile(path: string, bytes: Uint8Array): Promise<void> {
+  const handle = await open(path, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | constants.O_NOFOLLOW, 0o600);
+  try { await handle.writeFile(bytes); await handle.sync(); } finally { await handle.close(); }
+}
+
+/** Trusted test ports are never part of a serialized audit request. */
+export interface SpatialRenderedAuditOperationDependencies extends SpatialRenderedAuditDependencies {
+  readonly createWorkspace?: typeof createMediaOperationWorkspace;
+  readonly createDirectory?: typeof mkdtemp;
+  readonly removeDirectory?: (path: string) => Promise<void>;
+}
+
+export async function executeSpatialRenderedAudit(
+  context: OperationExecutionContext,
+  input: SpatialRenderedAuditInput,
+  dependencies: SpatialRenderedAuditOperationDependencies = {},
+): Promise<SpatialRenderedAuditOutput> {
+  if (context.workflow !== undefined) BoundSpatialRenderedAuditInputSchema.parse(input);
+  const bound = await bindSpatialRenderedAuditInput(context.application, input, context.abortSignal, dependencies.bindBrowserRuntime);
+  const source = await loadRepositoryMedia(context.application, bound.source, context.abortSignal, SPATIAL_SCENE_LIMITS.sourceBytes);
+  const scene = sourceDocument(source.data);
+  const workspace = await (dependencies.createWorkspace ?? createMediaOperationWorkspace)(context);
+  let directory: string | undefined;
+  const cleanupErrors: unknown[] = [];
+  let completed: SpatialRenderedAuditOutput | undefined, failure: unknown, failed = false;
+  try {
+    directory = await (dependencies.createDirectory ?? mkdtemp)(join(workspace.path, "spatial-audit-source-"));
+    const assetRoot = await ensurePhysicalPrivateDirectoryWithin(directory, "assets");
+    const writtenPaths = new Map<string, string>();
+    for (const asset of scene.assets) {
+      const artifact = bound.assets.find(item => item.assetId === asset.assetId)!.artifact;
+      const loaded = await loadRepositoryMedia(context.application, artifact, context.abortSignal, asset.payload.bytes);
+      const previous = writtenPaths.get(asset.payload.path);
+      if (previous !== undefined) {
+        if (previous !== artifact.sha256) throw new ApplicationError("conflict", "Two scene assets declare different bytes at one path.");
+        continue;
+      }
+      const parent = dirname(asset.payload.path);
+      if (parent !== ".") await ensurePhysicalPrivateDirectoryWithin(assetRoot, parent);
+      await writePrivateFile(join(assetRoot, asset.payload.path), loaded.data);
+      writtenPaths.set(asset.payload.path, artifact.sha256);
+    }
+    const report = await auditSpatialSceneRenderedHost(context, {
+      scene, assetRoot, request: bound.request,
+      capabilityBindings: bound.capabilityBindings, browserRuntime: bound.browserRuntime,
+    }, dependencies);
+    completed = SpatialRenderedAuditOutputSchema.parse(report);
+  } catch (error) { failure = error; failed = true; }
+  finally {
+    if (directory !== undefined) try { await (dependencies.removeDirectory ?? (async path => { await rm(path, { recursive: true, force: true }); }))(directory); } catch (error) { cleanupErrors.push(error); }
+    try { await workspace.dispose(); } catch (error) { cleanupErrors.push(error); }
+  }
+  if (failed || cleanupErrors.length > 0) {
+    const cause = cleanupErrors.length === 0 ? failure : new AggregateError([...(failed ? [failure] : []), ...cleanupErrors], "Rendered scene audit failed during execution or cleanup.");
+    const error = new ApplicationError(failure instanceof ApplicationError ? failure.code : "internal",
+      cause instanceof Error ? cause.message : "Rendered scene audit failed.",
+      { cleanupErrors: cleanupErrors.map(error => error instanceof Error ? error.message : String(error)) });
+    error.cause = cause;
+    throw error;
+  }
+  if (completed === undefined) throw new ApplicationError("internal", "Rendered scene audit completed without a report.");
+  return completed;
+}
+
+export const spatialRenderedAuditOperationDefinition = {
+  kind: "scene.render-audit", version: 1,
+  inputSchema: SpatialRenderedAuditInputSchema, inputSchemaId: "slopcamera.operation.scene.render-audit.input/v1",
+  outputSchema: SpatialRenderedAuditOutputSchema, outputSchemaId: "slopcamera.operation.scene.render-audit.output/v1",
+  lifecycle: { kind: "local-artifact", execute: executeSpatialRenderedAudit },
+  policy: {
+    cache: "none", cancellable: true, effect: "local-derived-write", maxDurationMs: 300_000,
+    maxFanOut: 0, maxInputBytes: 16 * 1024 * 1024, maxOutputBytes: 34 * 1024 * 1024,
+    preparation: ["local-media"], resources: [
+      { amount: 1, resource: "cpu" }, { amount: 1, resource: "local-io" }, { amount: 1, resource: "browser" },
+      { amount: 1, resource: "ffmpeg" },
+    ], resume: "deterministic",
+  },
+  summarize: output => ({ kind: "scene.render-audit", fields: {
+    sceneSha256: output.sceneSha256, cameraId: output.cameraId, samples: output.timesUs.length,
+    entities: output.summary.entities.total, neverRendered: output.summary.entitiesNeverRendered.length, findings: output.findings.length,
+  } }),
+} satisfies OperationDefinition<"scene.render-audit", SpatialRenderedAuditInput, SpatialRenderedAuditOutput>;