@hraness/slopcamera 3.2.8 → 3.3.2

package/README.md

@@ -33,15 +33,14 @@ project database.
 
 ## Install Slopcamera
 
-The source tree prepares v3.2.8 with optional support in the CLI, agent skill, native menu, and public footer.
-The install below stays on the verified v3.2.6 release until publication completes.
+Slopcamera v3.3.1 adds [parametric architectural designs](docs/how-to/parametric-design.md): editable dimensions, constraints, four starters, and galleries of retained 3D scenes. The Three renderer fits shadows to the casting geometry.
 
 Install [Bun 1.3.14 or newer](https://bun.sh), then install the verified
-[Slopcamera v3.2.6 release](https://github.com/hraness/slopcamera/releases/tag/v3.2.6)
+[Slopcamera v3.3.1 release](https://github.com/hraness/slopcamera/releases/tag/v3.3.1)
 from its canonical archive:
 
 ```sh
-bun add --global https://github.com/hraness/slopcamera/releases/download/v3.2.6/hraness-slopcamera-3.2.6.tgz
+bun add --global https://github.com/hraness/slopcamera/releases/download/v3.3.1/hraness-slopcamera-3.3.1.tgz
 slopcamera skill install --target agents
 ```
 
@@ -135,10 +134,30 @@ GPU path. Spark admits saved splat worlds for local camera direction.
 > mount the product diagram on a screen in the scene, and show me contact frames
 > before rendering the video.
 
-The portable GLB profile has a defined geometry and material subset. Saved splats
+The portable GLB profile has a defined geometry and material subset; the
+additive rigged profile admits bounded skins and morph targets. Saved splats
 capture appearance; they do not establish collision geometry or editable native
 meshes. See [Directed scenes](docs/spatial-scenes.md).
 
+Current source adds the cinematic planning loop: a `slopcamera.spatial-direction`
+document describes beats, actions, camera coverage, and look intents, compiles
+into proposed performance/camera/cinema/material-lighting/shot documents, and
+fans out into bounded galleries per axis. Declared effects bind into renders,
+and a temporal audit samples evidence at explicit times — all deterministic,
+all reviewable before anything is selected.
+
+```sh
+slopcamera scene direction check direction.json --scene world.json --json
+slopcamera scene direction gallery direction.json --scene world.json --axis camera --output gallery.json --json
+slopcamera workflows plan cinematic-world --input pack-input.json --json
+```
+
+The `cinematic-world` workflow consumes one inert recipe pack — a bounded,
+content-addressed JSON document an agent can author — and stops before
+selection. Registration and selection stay explicit `scene project` operations.
+See [Direct a cinematic world](docs/how-to/direct-cinematic-worlds.md) and the
+[extension architecture](docs/extension-architecture.md).
+
 ### Film native worlds and educational animation
 
 The current source build can direct Blender for detailed sets, materials,
@@ -255,8 +274,9 @@ declarative graphs, approvals, and resuming work.
 - **Trusted code is not sandboxed.** Native Python and caller-authored Bun
   workflows run with the current user's access. Hashes and receipts identify
   observed inputs and outputs; they do not make arbitrary code hermetic.
-- **MCP is a subset.** Its fixed tools check and render diagrams, vectorize
-  images, and generate images. It does not expose every local CLI operation.
+- **MCP is a subset.** Its fixed tools check and render diagrams, plan and audit
+  scenes, and run the bounded portable operations. It does not expose every
+  local CLI operation and never mutates project state.
 
 ## Design and trust
 
@@ -280,9 +300,9 @@ See [Architecture](docs/architecture.md), [`SECURITY.md`](SECURITY.md),
 ## Documentation
 
 - **Learn:** [Your first diagram](docs/tutorials/first-diagram.md) · [Your first native film](docs/tutorials/first-native-film.md).
-- **Make a result:** [Edit video](docs/how-to/edit-video.md) · [Generate media](docs/how-to/generate-media.md) · [Run workflows](docs/how-to/run-workflows.md) · [Educational video](docs/how-to/educational-video.md).
+- **Make a result:** [Edit video](docs/how-to/edit-video.md) · [Generate media](docs/how-to/generate-media.md) · [Run workflows](docs/how-to/run-workflows.md) · [Educational video](docs/how-to/educational-video.md) · [Direct a cinematic world](docs/how-to/direct-cinematic-worlds.md).
 - **Look up support:** [Capabilities and release availability](docs/reference/capabilities.md) · [SDK entrypoints](docs/reference/sdk.md) · [Creative tools](docs/html-overlay-creative-toolkit.md).
-- **Understand the system:** [Architecture](docs/architecture.md) · [Native studio](docs/studio.md) · [Directed scenes](docs/spatial-scenes.md).
+- **Understand the system:** [Architecture](docs/architecture.md) · [Native studio](docs/studio.md) · [Directed scenes](docs/spatial-scenes.md) · [Extension architecture](docs/extension-architecture.md).
 
 The [documentation index](docs/README.md) connects these paths.
 

package/apps/desktop/application/context.ts

@@ -1,8 +1,10 @@
 import type { HostResourceLease } from "@hraness/slopcamera/host-resources";
 
+import type { SpatialReviewProvider } from "../../../src/spatial-scene/review";
 import type { ApplicationStudioAuthorization, ApplicationStudioPort } from "./studio-port";
 import type { ApplicationGatewayPort } from "./gateway-port";
 import type { HtmlOverlayRenderer } from "./html-overlay-renderer";
+import type { ApplicationSpatialReviewAuthorization } from "./spatial-review";
 
 export interface ApplicationPaths {
   readonly artifactRoot: string;
@@ -79,6 +81,10 @@ export interface ApplicationContext {
   readonly gatewayPort?: ApplicationGatewayPort;
   readonly studioPort?: ApplicationStudioPort;
   readonly studioAuthorization?: ApplicationStudioAuthorization;
+  /** Bounded beauty-frame critique seam; absent means scene.review fails closed. */
+  readonly spatialReviewProvider?: SpatialReviewProvider;
+  /** Invocation-scoped cloud-upload consent envelope for scene.review. */
+  readonly spatialReviewAuthorization?: ApplicationSpatialReviewAuthorization;
   readonly hostResourceLease?: ApplicationHostResourceLease;
   readonly htmlOverlayRenderer?: HtmlOverlayRenderer;
   /** Per-user host state shared by repository worktrees for mutation leases. */

package/apps/desktop/application/default-registry.ts

@@ -45,7 +45,20 @@ import {
   spatialInspectOperationDefinition,
   spatialPatchOperationDefinition,
   spatialEvaluateOperationDefinition,
+  spatialAuditOperationDefinition,
+  spatialDirectionCheckOperationDefinition,
+  spatialDirectionCompileOperationDefinition,
+  spatialDirectionGalleryOperationDefinition,
+  spatialEffectsCheckOperationDefinition,
+  spatialEffectsPlanOperationDefinition,
+  spatialBehaviorCheckOperationDefinition,
+  spatialBehaviorBakeOperationDefinition,
+  spatialBehaviorGalleryOperationDefinition,
+  spatialBehaviorAuditOperationDefinition,
+  spatialTemporalAuditOperationDefinition,
   spatialRenderOperationDefinition,
+  spatialRenderedAuditOperationDefinition,
+  spatialReviewOperationDefinition,
   studioRunOperationDefinition,
   spatialProjectSnapshotOperationDefinition,
   spatialProjectMigrateOperationDefinition,
@@ -75,7 +88,20 @@ export function createApplicationOperationRegistry(
   registry.register(spatialInspectOperationDefinition);
   registry.register(spatialPatchOperationDefinition);
   registry.register(spatialEvaluateOperationDefinition);
+  registry.register(spatialAuditOperationDefinition);
+  registry.register(spatialDirectionCheckOperationDefinition);
+  registry.register(spatialDirectionCompileOperationDefinition);
+  registry.register(spatialDirectionGalleryOperationDefinition);
+  registry.register(spatialEffectsCheckOperationDefinition);
+  registry.register(spatialEffectsPlanOperationDefinition);
+  registry.register(spatialBehaviorCheckOperationDefinition);
+  registry.register(spatialBehaviorBakeOperationDefinition);
+  registry.register(spatialBehaviorGalleryOperationDefinition);
+  registry.register(spatialBehaviorAuditOperationDefinition);
+  registry.register(spatialTemporalAuditOperationDefinition);
   registry.register(spatialRenderOperationDefinition);
+  registry.register(spatialRenderedAuditOperationDefinition);
+  registry.register(spatialReviewOperationDefinition);
   registry.register(studioRunOperationDefinition);
   registry.register(spatialProjectSnapshotOperationDefinition);
   registry.register(spatialProjectMigrateOperationDefinition);

package/apps/desktop/application/operation.ts

@@ -4,13 +4,26 @@ import type { z } from "zod";
 
 import type { ApplicationContext } from "./context";
 
-export const SLOPCAMERA_APPLICATION_TOOL_VERSION = "slopcamera-3.2.8" as const;
+export const SLOPCAMERA_APPLICATION_TOOL_VERSION = "slopcamera-3.3.2" as const;
 
 export const OPERATION_KINDS = [
+  "scene.audit",
   "scene.inspect",
   "scene.patch",
   "scene.evaluate",
   "scene.render",
+  "scene.render-audit",
+  "scene.review",
+  "scene.direction.check",
+  "scene.direction.compile",
+  "scene.direction.gallery",
+  "scene.effects.check",
+  "scene.effects.plan",
+  "scene.behavior.check",
+  "scene.behavior.bake",
+  "scene.behavior.gallery",
+  "scene.behavior.audit",
+  "scene.temporal-audit",
   "slopcamera.studio.run",
   "spatial.project.snapshot",
   "spatial.project.migrate",

package/apps/desktop/application/operations/index.ts

@@ -23,8 +23,12 @@ export * from "./render/project-plan";
 export * from "./render/project";
 export * from "./render/materialize-selection";
 export * from "./slopcamera-visuals";
+export * from "./spatial-behavior";
+export * from "./spatial-direction";
 export * from "./spatial-scene";
 export * from "./spatial-project";
 export * from "./spatial-render";
+export * from "./spatial-rendered-audit";
+export * from "./spatial-review";
 
 export * from "./studio";

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>;