@hraness/slopcamera 3.3.1 → 3.3.3

package/dist/index.js

@@ -1,2 +1,2 @@
 // @bun
-import{SLOPCAMERA_CAPABILITY_MANIFEST_LIMITS,SLOPCAMERA_PORTABLE_CAPABILITY_VERSION,SLOPCAMERA_VERSION,STUDIO_LIMITS,SlopcameraCapabilityCommandSchema,SlopcameraCapabilityEffectSchema,SlopcameraCapabilityManifestSchema,SlopcameraCapabilityModuleDeclarationSchema,SlopcameraCapabilityModuleSchema,SlopcameraCapabilityOperationSchema,SlopcameraCapabilityPreparationSchema,SlopcameraCapabilityProfileSchema,SlopcameraCapabilityQualificationSchema,SlopcameraCapabilityResourceSchema,SlopcameraCapabilityResumeSchema,SlopcameraCapabilityToolSchema,SlopcameraCapabilityWorkflowSchema,SlopcameraMcpToolRuntime,SlopcameraSceneVariantsSchema,StudioCapabilityNameSchema,StudioDigestSchema,StudioEngineOptionsSchema,StudioEngineSchema,StudioExecutionProfileSchema,StudioJobSchema,StudioOutputArtifactSchema,StudioOutputFormatSchema,StudioOutputInterpretationSchema,StudioOutputRoleSchema,StudioOutputSpecSchema,StudioPathSchema,StudioPlanSchema,StudioReceiptSchema,StudioRenderSchema,StudioRuntimeIdentitySchema,StudioSourceBundleSchema,StudioSourceSpaceSchema,WorkspaceBoundary,WorkspaceBoundaryError,artifactSummary,checkDiagramFile,compileSlopcameraCapabilityManifest,createPortableSlopcameraCapabilityManifest,defineSlopcameraCapabilityModule,diagramApi,inspectStudioBundle,inspectStudioPlan,mcpMaximumRenderedPixels,mcpMaximumScale,mcpSourceByteLimit,parseSlopcameraCapabilityManifest,parseSlopcameraSceneVariants,parseStudioJob,parseStudioPlan,parseStudioReceipt,parseStudioRuntimeIdentity,parseStudioSourceBundle,planSlopcameraSceneGallery,planStudioJob,readDiagramFile,renderDiagramFile,runMcpServer,slopcameraApi,slopcameraMcpProtocolVersion,slopcameraMcpServerName,slopcameraMcpTools,slopcameraPortableCapabilityManifest,slopcameraSceneGalleryLimits,studioJobSha256,studioOutputPath,studioRuntimeSha256,studioSourceBundleSha256,summarizeSceneVariantPatch,validateStudioReceipt}from"./index-f0ptv8dm.js";import{bundledSkillPath,installSkill}from"./index-grk47tgs.js";import"./index-cgpkyjqa.js";import"./index-3cxf2c58.js";import{SlopcameraWorkflowError,defineSlopcameraWorkflow,runSlopcameraWorkflow}from"./index-296qhpf2.js";import{DiagramValidationError,SlopcameraOperationError,StackLayoutError,builtInIcons,composeSlopcameraImageGallery,critiqueIconRaster,executeSlopcameraOperation,executeSlopcameraOperationWithLease,extractIconLineArt,galleryCandidateId,galleryPromptFor,generateSlopcameraIcon,generateSlopcameraImageGallery,iconPromptFor,iconVisualGateProblems,isSlopcameraOperationCode,lintDiagram,parseDiagramSource,parseDiagramSpec,parseSlopcameraGalleryVary,parseSlopcameraOperationInput,planSlopcameraGallery,renderPng,renderSvg,resolveDiagramSource,resolveEdge,resolveStackLayout,searchSlopcameraOperations,serializeTldr,slopcameraGalleryAxes,slopcameraGalleryKinds,slopcameraGalleryLimits,slopcameraIconCritiqueDefaultModel,slopcameraIconCritiqueTimeoutMs,slopcameraIconDefaultInk,slopcameraIconDefaultRounds,slopcameraIconMaximumRounds,slopcameraIconPanel,slopcameraIconSubjectMaximumBytes,slopcameraOperationCodes,slopcameraOperationHostResourceClaims,slopcameraOperationRegistry,stackLayoutDefaults,withSlopcameraOperationHostAdmission}from"./index-0bbesn4m.js";import{VTRACER_VERSION,VectorizeError,vectorizeDefaultLimits,vectorizeHardLimits,vectorizeImage,vectorizeProfileNames,vtracerReleases}from"./index-qry58nj2.js";import{SlopcameraCloudError,createFixedGatewayFetch,generateSlopcameraImage,generateSlopcameraImageFile,resolveSlopcameraGatewayCredential,slopcameraGatewayApiBaseUrl,slopcameraGatewayCredentialStatus,slopcameraImageModels,slopcameraMaximumPromptBytes,slopcameraMaximumRawImageBytes,slopcameraResponseMediaTypes}from"./index-77fjfg9f.js";import{HOST_RESOURCE_MAX_WAIT_MILLISECONDS,HostResourceError,createDefaultHostResourceCoordinator,createHostResourceCoordinator,createProcessLocalHostResourceCoordinator,defaultSlopcameraHostResourceProfile,defaultSlopcameraHostResourceStateRoot,normalizeHostResourceClaims,normalizeHostResourceProfile,slopcameraHostResourceNames}from"./index-b3geqczn.js";import"./index-80a36bc0.js";export{withSlopcameraOperationHostAdmission,vtracerReleases,vectorizeProfileNames,vectorizeImage,vectorizeHardLimits,vectorizeDefaultLimits,validateStudioReceipt,summarizeSceneVariantPatch,studioSourceBundleSha256,studioRuntimeSha256,studioOutputPath,studioJobSha256,stackLayoutDefaults,slopcameraSceneGalleryLimits,slopcameraResponseMediaTypes,slopcameraPortableCapabilityManifest,slopcameraOperationRegistry,slopcameraOperationHostResourceClaims,slopcameraOperationCodes,slopcameraMcpTools,slopcameraMcpServerName,slopcameraMcpProtocolVersion,slopcameraMaximumRawImageBytes,slopcameraMaximumPromptBytes,slopcameraImageModels,slopcameraIconSubjectMaximumBytes,slopcameraIconPanel,slopcameraIconMaximumRounds,slopcameraIconDefaultRounds,slopcameraIconDefaultInk,slopcameraIconCritiqueTimeoutMs,slopcameraIconCritiqueDefaultModel,slopcameraHostResourceNames,slopcameraGatewayCredentialStatus,slopcameraGatewayApiBaseUrl,slopcameraGalleryLimits,slopcameraGalleryKinds,slopcameraGalleryAxes,slopcameraApi,serializeTldr,searchSlopcameraOperations,runSlopcameraWorkflow,runMcpServer,resolveStackLayout,resolveSlopcameraGatewayCredential,resolveEdge,resolveDiagramSource,renderSvg,renderPng,renderDiagramFile,readDiagramFile,planStudioJob,planSlopcameraSceneGallery,planSlopcameraGallery,parseStudioSourceBundle,parseStudioRuntimeIdentity,parseStudioReceipt,parseStudioPlan,parseStudioJob,parseSlopcameraSceneVariants,parseSlopcameraOperationInput,parseSlopcameraGalleryVary,parseSlopcameraCapabilityManifest,parseDiagramSpec,parseDiagramSource,normalizeHostResourceProfile,normalizeHostResourceClaims,mcpSourceByteLimit,mcpMaximumScale,mcpMaximumRenderedPixels,lintDiagram,isSlopcameraOperationCode,installSkill,inspectStudioPlan,inspectStudioBundle,iconVisualGateProblems,iconPromptFor,generateSlopcameraImageGallery,generateSlopcameraImageFile,generateSlopcameraImage,generateSlopcameraIcon,galleryPromptFor,galleryCandidateId,extractIconLineArt,executeSlopcameraOperationWithLease,executeSlopcameraOperation,diagramApi,defineSlopcameraWorkflow,defineSlopcameraCapabilityModule,defaultSlopcameraHostResourceStateRoot,defaultSlopcameraHostResourceProfile,critiqueIconRaster,createProcessLocalHostResourceCoordinator,createPortableSlopcameraCapabilityManifest,createHostResourceCoordinator,createFixedGatewayFetch,createDefaultHostResourceCoordinator,composeSlopcameraImageGallery,compileSlopcameraCapabilityManifest,checkDiagramFile,bundledSkillPath,builtInIcons,artifactSummary,WorkspaceBoundaryError,WorkspaceBoundary,VectorizeError,VTRACER_VERSION,StudioSourceSpaceSchema,StudioSourceBundleSchema,StudioRuntimeIdentitySchema,StudioRenderSchema,StudioReceiptSchema,StudioPlanSchema,StudioPathSchema,StudioOutputSpecSchema,StudioOutputRoleSchema,StudioOutputInterpretationSchema,StudioOutputFormatSchema,StudioOutputArtifactSchema,StudioJobSchema,StudioExecutionProfileSchema,StudioEngineSchema,StudioEngineOptionsSchema,StudioDigestSchema,StudioCapabilityNameSchema,StackLayoutError,SlopcameraWorkflowError,SlopcameraSceneVariantsSchema,SlopcameraOperationError,SlopcameraMcpToolRuntime,SlopcameraCloudError,SlopcameraCapabilityWorkflowSchema,SlopcameraCapabilityToolSchema,SlopcameraCapabilityResumeSchema,SlopcameraCapabilityResourceSchema,SlopcameraCapabilityQualificationSchema,SlopcameraCapabilityProfileSchema,SlopcameraCapabilityPreparationSchema,SlopcameraCapabilityOperationSchema,SlopcameraCapabilityModuleSchema,SlopcameraCapabilityModuleDeclarationSchema,SlopcameraCapabilityManifestSchema,SlopcameraCapabilityEffectSchema,SlopcameraCapabilityCommandSchema,STUDIO_LIMITS,SLOPCAMERA_VERSION,SLOPCAMERA_PORTABLE_CAPABILITY_VERSION,SLOPCAMERA_CAPABILITY_MANIFEST_LIMITS,HostResourceError,HOST_RESOURCE_MAX_WAIT_MILLISECONDS,DiagramValidationError};
+import{SLOPCAMERA_CAPABILITY_MANIFEST_LIMITS,SLOPCAMERA_PORTABLE_CAPABILITY_VERSION,SLOPCAMERA_VERSION,STUDIO_LIMITS,SlopcameraCapabilityCommandSchema,SlopcameraCapabilityEffectSchema,SlopcameraCapabilityManifestSchema,SlopcameraCapabilityModuleDeclarationSchema,SlopcameraCapabilityModuleSchema,SlopcameraCapabilityOperationSchema,SlopcameraCapabilityPreparationSchema,SlopcameraCapabilityProfileSchema,SlopcameraCapabilityQualificationSchema,SlopcameraCapabilityResourceSchema,SlopcameraCapabilityResumeSchema,SlopcameraCapabilityToolSchema,SlopcameraCapabilityWorkflowSchema,SlopcameraMcpToolRuntime,SlopcameraSceneVariantsSchema,StudioCapabilityNameSchema,StudioDigestSchema,StudioEngineOptionsSchema,StudioEngineSchema,StudioExecutionProfileSchema,StudioJobSchema,StudioOutputArtifactSchema,StudioOutputFormatSchema,StudioOutputInterpretationSchema,StudioOutputRoleSchema,StudioOutputSpecSchema,StudioPathSchema,StudioPlanSchema,StudioReceiptSchema,StudioRenderSchema,StudioRuntimeIdentitySchema,StudioSourceBundleSchema,StudioSourceSpaceSchema,WorkspaceBoundary,WorkspaceBoundaryError,artifactSummary,checkDiagramFile,compileSlopcameraCapabilityManifest,createPortableSlopcameraCapabilityManifest,defineSlopcameraCapabilityModule,diagramApi,inspectStudioBundle,inspectStudioPlan,mcpMaximumRenderedPixels,mcpMaximumScale,mcpSourceByteLimit,parseSlopcameraCapabilityManifest,parseSlopcameraSceneVariants,parseStudioJob,parseStudioPlan,parseStudioReceipt,parseStudioRuntimeIdentity,parseStudioSourceBundle,planSlopcameraSceneGallery,planStudioJob,readDiagramFile,renderDiagramFile,runMcpServer,slopcameraApi,slopcameraMcpProtocolVersion,slopcameraMcpServerName,slopcameraMcpTools,slopcameraPortableCapabilityManifest,slopcameraSceneGalleryLimits,studioJobSha256,studioOutputPath,studioRuntimeSha256,studioSourceBundleSha256,summarizeSceneVariantPatch,validateStudioReceipt}from"./index-3e1pcxb5.js";import{bundledSkillPath,installSkill}from"./index-grk47tgs.js";import"./index-z1kd1x8j.js";import"./index-3cxf2c58.js";import{SlopcameraWorkflowError,defineSlopcameraWorkflow,runSlopcameraWorkflow}from"./index-296qhpf2.js";import{DiagramValidationError,SlopcameraOperationError,StackLayoutError,builtInIcons,composeSlopcameraImageGallery,critiqueIconRaster,executeSlopcameraOperation,executeSlopcameraOperationWithLease,extractIconLineArt,galleryCandidateId,galleryPromptFor,generateSlopcameraIcon,generateSlopcameraImageGallery,iconPromptFor,iconVisualGateProblems,isSlopcameraOperationCode,lintDiagram,parseDiagramSource,parseDiagramSpec,parseSlopcameraGalleryVary,parseSlopcameraOperationInput,planSlopcameraGallery,renderPng,renderSvg,resolveDiagramSource,resolveEdge,resolveStackLayout,searchSlopcameraOperations,serializeTldr,slopcameraGalleryAxes,slopcameraGalleryKinds,slopcameraGalleryLimits,slopcameraIconCritiqueDefaultModel,slopcameraIconCritiqueTimeoutMs,slopcameraIconDefaultInk,slopcameraIconDefaultRounds,slopcameraIconMaximumRounds,slopcameraIconPanel,slopcameraIconSubjectMaximumBytes,slopcameraOperationCodes,slopcameraOperationHostResourceClaims,slopcameraOperationRegistry,stackLayoutDefaults,withSlopcameraOperationHostAdmission}from"./index-0bbesn4m.js";import{VTRACER_VERSION,VectorizeError,vectorizeDefaultLimits,vectorizeHardLimits,vectorizeImage,vectorizeProfileNames,vtracerReleases}from"./index-qry58nj2.js";import{SlopcameraCloudError,createFixedGatewayFetch,generateSlopcameraImage,generateSlopcameraImageFile,resolveSlopcameraGatewayCredential,slopcameraGatewayApiBaseUrl,slopcameraGatewayCredentialStatus,slopcameraImageModels,slopcameraMaximumPromptBytes,slopcameraMaximumRawImageBytes,slopcameraResponseMediaTypes}from"./index-77fjfg9f.js";import{HOST_RESOURCE_MAX_WAIT_MILLISECONDS,HostResourceError,createDefaultHostResourceCoordinator,createHostResourceCoordinator,createProcessLocalHostResourceCoordinator,defaultSlopcameraHostResourceProfile,defaultSlopcameraHostResourceStateRoot,normalizeHostResourceClaims,normalizeHostResourceProfile,slopcameraHostResourceNames}from"./index-b3geqczn.js";import"./index-80a36bc0.js";export{withSlopcameraOperationHostAdmission,vtracerReleases,vectorizeProfileNames,vectorizeImage,vectorizeHardLimits,vectorizeDefaultLimits,validateStudioReceipt,summarizeSceneVariantPatch,studioSourceBundleSha256,studioRuntimeSha256,studioOutputPath,studioJobSha256,stackLayoutDefaults,slopcameraSceneGalleryLimits,slopcameraResponseMediaTypes,slopcameraPortableCapabilityManifest,slopcameraOperationRegistry,slopcameraOperationHostResourceClaims,slopcameraOperationCodes,slopcameraMcpTools,slopcameraMcpServerName,slopcameraMcpProtocolVersion,slopcameraMaximumRawImageBytes,slopcameraMaximumPromptBytes,slopcameraImageModels,slopcameraIconSubjectMaximumBytes,slopcameraIconPanel,slopcameraIconMaximumRounds,slopcameraIconDefaultRounds,slopcameraIconDefaultInk,slopcameraIconCritiqueTimeoutMs,slopcameraIconCritiqueDefaultModel,slopcameraHostResourceNames,slopcameraGatewayCredentialStatus,slopcameraGatewayApiBaseUrl,slopcameraGalleryLimits,slopcameraGalleryKinds,slopcameraGalleryAxes,slopcameraApi,serializeTldr,searchSlopcameraOperations,runSlopcameraWorkflow,runMcpServer,resolveStackLayout,resolveSlopcameraGatewayCredential,resolveEdge,resolveDiagramSource,renderSvg,renderPng,renderDiagramFile,readDiagramFile,planStudioJob,planSlopcameraSceneGallery,planSlopcameraGallery,parseStudioSourceBundle,parseStudioRuntimeIdentity,parseStudioReceipt,parseStudioPlan,parseStudioJob,parseSlopcameraSceneVariants,parseSlopcameraOperationInput,parseSlopcameraGalleryVary,parseSlopcameraCapabilityManifest,parseDiagramSpec,parseDiagramSource,normalizeHostResourceProfile,normalizeHostResourceClaims,mcpSourceByteLimit,mcpMaximumScale,mcpMaximumRenderedPixels,lintDiagram,isSlopcameraOperationCode,installSkill,inspectStudioPlan,inspectStudioBundle,iconVisualGateProblems,iconPromptFor,generateSlopcameraImageGallery,generateSlopcameraImageFile,generateSlopcameraImage,generateSlopcameraIcon,galleryPromptFor,galleryCandidateId,extractIconLineArt,executeSlopcameraOperationWithLease,executeSlopcameraOperation,diagramApi,defineSlopcameraWorkflow,defineSlopcameraCapabilityModule,defaultSlopcameraHostResourceStateRoot,defaultSlopcameraHostResourceProfile,critiqueIconRaster,createProcessLocalHostResourceCoordinator,createPortableSlopcameraCapabilityManifest,createHostResourceCoordinator,createFixedGatewayFetch,createDefaultHostResourceCoordinator,composeSlopcameraImageGallery,compileSlopcameraCapabilityManifest,checkDiagramFile,bundledSkillPath,builtInIcons,artifactSummary,WorkspaceBoundaryError,WorkspaceBoundary,VectorizeError,VTRACER_VERSION,StudioSourceSpaceSchema,StudioSourceBundleSchema,StudioRuntimeIdentitySchema,StudioRenderSchema,StudioReceiptSchema,StudioPlanSchema,StudioPathSchema,StudioOutputSpecSchema,StudioOutputRoleSchema,StudioOutputInterpretationSchema,StudioOutputFormatSchema,StudioOutputArtifactSchema,StudioJobSchema,StudioExecutionProfileSchema,StudioEngineSchema,StudioEngineOptionsSchema,StudioDigestSchema,StudioCapabilityNameSchema,StackLayoutError,SlopcameraWorkflowError,SlopcameraSceneVariantsSchema,SlopcameraOperationError,SlopcameraMcpToolRuntime,SlopcameraCloudError,SlopcameraCapabilityWorkflowSchema,SlopcameraCapabilityToolSchema,SlopcameraCapabilityResumeSchema,SlopcameraCapabilityResourceSchema,SlopcameraCapabilityQualificationSchema,SlopcameraCapabilityProfileSchema,SlopcameraCapabilityPreparationSchema,SlopcameraCapabilityOperationSchema,SlopcameraCapabilityModuleSchema,SlopcameraCapabilityModuleDeclarationSchema,SlopcameraCapabilityManifestSchema,SlopcameraCapabilityEffectSchema,SlopcameraCapabilityCommandSchema,STUDIO_LIMITS,SLOPCAMERA_VERSION,SLOPCAMERA_PORTABLE_CAPABILITY_VERSION,SLOPCAMERA_CAPABILITY_MANIFEST_LIMITS,HostResourceError,HOST_RESOURCE_MAX_WAIT_MILLISECONDS,DiagramValidationError};

package/docs/studio.md

@@ -22,6 +22,10 @@ The scaffold creates `scene.py`, any explicit helpers, `source.json` and `job.js
 
 The default Blender product job requests Cycles GPU rendering. An unavailable GPU fails clearly. Select `device: "cpu"` in a new job when CPU rendering is intended; no fallback is implicit. Initial Metal shader compilation can make the first render substantially slower than later frames.
 
+`studio probe` discovers devices without rendering a frame. A successful probe
+does not qualify shader compilation or the scene's render. Use a bounded render
+with the selected engine and device before committing to a long job.
+
 Other starters:
 
 ```sh
@@ -210,6 +214,14 @@ slopcamera studio reconcile <studio-id> --json
 
 Inspection rechecks source and physical output hashes. Reconciliation can restore a missing receipt only when a closed successful process completion and an unchanged output-validation checkpoint exist. Earlier interrupted execution remains ambiguous and is never automatically resubmitted. Choose a new job ID for an explicitly revised attempt after custody is settled.
 
+For an unexpected Blender exit, correlate that attempt's retained logs with the
+operating system's crash report before changing settings. A macOS report in
+`MetalKernelPipeline::compile` while the main thread waits in
+`BlenderSession::render` identifies a render failure; it does not prove an
+out-of-memory condition or a specific shader-cache defect. A bounded CPU or EEVEE
+comparison needs a new, explicitly configured job after custody is settled. Its
+success does not qualify Cycles/Metal, and its frames need separate visual review.
+
 The supervisor bounds combined logs, the job deadline and termination/pipe-drain grace. It monitors output and scratch budgets, retains failure evidence and tracks native process groups. Live scans tolerate bounded disappearance of temporary cache entries; final output, source and scratch scans remain strict. Budget-monitor and validation failures retain a safe failed host stage separately from authored-process logs, without storing foreign exception text. A machine-wide durable activity marker survives CLI death; unresolved custody blocks later native dispatch. Detached sessions from authored source are unsupported. Do not delete an unresolved marker to bypass admission; inspect and resolve the actual process ownership first.
 
 The native profile is trusted current-user execution without an OS sandbox. Private roots, clean environment variables, hashes and process supervision provide operational control and provenance. They do not confine arbitrary Python, installed plugins or native libraries. Keep unreviewed downloaded source inert until execution is explicitly authorized.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hraness/slopcamera",
-  "version": "3.3.1",
+  "version": "3.3.3",
   "description": "A local visual studio for coding agents: author scenes, combine generated and recorded media, and export images, diagrams, animation, and video from retained sources.",
   "license": "MIT",
   "type": "module",

package/skills/slopcamera/SKILL.md

@@ -30,6 +30,7 @@ Slopcamera installs from its verified release archive or from source. Historical
 | Editable Three/Spark scene, saved world, named-part edits or shared camera | [Directed scenes](references/directed-scenes.md) |
 | Semantic direction, galleries, bounded effects, temporal audit or the cinematic-world recipe pack | [Directed scenes](references/directed-scenes.md#direct-cinematic-worlds) |
 | Author a scene from code, generate procedural entities, or audit framing | [Scene building](references/scene-building.md) |
+| Refine an existing scene, organic interactions, contact, staging, or final movie quality | [Scene refinement](references/scene-building.md#refine-an-existing-scene) |
 | Parametric architecture, furniture, dimensions, repeated structures or editable design variants | [Parametric design](references/parametric-design.md) |
 | Blender, rigs, bakes, CAD, shared native assets or production frames | [Native studio](references/native-studio.md) |
 | Manim lesson, narrated explanation or mathematical animation | [Educational video](references/educational-video.md) |

package/skills/slopcamera/references/directed-scenes.md

@@ -2,6 +2,9 @@
 
 Use `slopcamera scene --help` to check that the installed CLI includes the directed-scene foundation. The initial renderer uses Three.js and supports explicit scene JSON, semantic edits, calibrated cameras, native media surfaces, contact sheets, and transparent video.
 
+Use [scene refinement](scene-building.md#refine-an-existing-scene) for a shot-by-shot craft pass, subtle
+behavior design, actual-rig contact checks, and final encoded-frame review.
+
 To author a scene from code — builder helpers, procedural generator modules, glTF admission, or geometric audit — read [scene building](scene-building.md) first. Start interactive work with `slopcamera scene init scene.json --json`, then `slopcamera scene inspect scene.json --json`. Retain the original source. Use its stable entity IDs and exact `sceneSha256` in typed patches; save each edit with `--output` to a new file. Inspect `editableControls` before changing generated parts or imported materials. Do not replace named scene parts with opaque regenerated source merely to change one color or camera.
 
 Use `slopcamera scene plan scene.json --request request.json --json` before rendering. A frame request is:
@@ -49,6 +52,29 @@ Four standard-library organisms are available for composition: locomotion FSM (`
 
 The authoring loop: (1) assemble a behavior doc from stdlib organisms with scene-bound args, (2) check it with `scene behavior check`, (3) bake it with `scene behavior bake`, (4) audit the trace with `scene behavior audit`, (5) plan gallery variants and review. Identical behavior doc + seed + scene produce byte-identical bakes. The `seed` interface input auto-binds from `behavior.seed` for gallery diversity. A channel map (`--channel-map`) binds emitted channels to clip runs, attach/release pairs, or trajectory waypoints for performance directives. Behaviors never execute source, contact providers, or access the filesystem; organisms are data.
 
+For SDK authoring, normalize the scene with `parseSpatialScene` and bind the
+behavior using `spatialSceneSha256`. These public helpers validate references and
+normalize entity order so saved SDK scenes and the CLI share the same identity.
+Check, bake, and gallery use that canonical identity. A behavior bound to a raw,
+noncanonical scene hash remains stale: explicitly rebind it to the inspected
+scene and bake again, preserving the earlier documents and receipts.
+
+The CLI check and bake still wait for host CPU and local-I/O admission. A concurrent
+render can reserve the CPU pool. A timeout with no output does not establish that
+the behavior program failed; preserve the attempt's outcome and distinguish
+resource waiting from a returned validation error before retrying.
+
+When compiling mapped directives with `compileSpatialPerformance`, use the
+exported `SPATIAL_PERFORMANCE_COMPILER_ID` for the plan's `compilerVersion`.
+Compiler `slopcamera.spatial-performance-compiler@v3` resolves prop ownership in
+time order. A later attach can take ownership after a release. At the same
+timestamp, releases precede attaches, so an immediate handoff keeps the new
+attachment; among simultaneous attaches, the last authored attach wins. When the
+latest attachment's interval ends, an older overlapping attachment does not
+resume. Retained `@v2` plans require an explicit version update and a new compile
+and audit. Preserve old takes and receipts as evidence rather than relabeling
+them with the new compiler identity.
+
 The `cinematic-world` built-in workflow composes exactly these operations for one admitted scene. Its input is an inert `slopcamera.spatial-recipe-pack` — one scene digest, one direction document, bounded gallery axes, up to 4 named preview render requests, optional declared effects, and optional temporal-audit inputs — wrapped with the scene document and its repository path. Plan it with `slopcamera workflows plan cinematic-world --input input.json --json`; run it with `workflows run`. The workflow never selects or promotes a candidate: registration uses `scene project add-candidate <project-id> --input <request.json>`, and selection uses `scene project select-candidate <project-id> --input <request.json>`, both after review. A recipe pack is data — it cannot register executors, source paths beyond the declared render source, permissions, secrets, or URLs.
 
 ## Direct short generated clips

package/skills/slopcamera/references/install.md

@@ -14,7 +14,7 @@ command -v slopcamera
 
 A restricted shell can omit package-manager paths. Check known host installation paths before declaring a tool unavailable. If Bun is genuinely absent, follow its official [installation guide](https://bun.sh/docs/installation) within the user’s authorized setup scope. Do not switch package managers or pipe an unreviewed installer into a shell.
 
-Slopcamera installs from its verified release archive: `bun add --global https://github.com/hraness/slopcamera/releases/download/v3.2.8/hraness-slopcamera-3.2.8.tgz`, then `slopcamera doctor --json`. Building from source is the contributor path. Historical Atet archives do not install the renamed CLI; never substitute `slopcamera` into an old archive URL.
+Slopcamera installs from its verified release archive: `bun add --global https://github.com/hraness/slopcamera/releases/download/v3.3.2/hraness-slopcamera-3.3.2.tgz`, then `slopcamera doctor --json`. Building from source is the contributor path. Historical Atet archives do not install the renamed CLI; never substitute `slopcamera` into an old archive URL.
 
 Use an existing compatible source build when available. Otherwise follow the [complete source-install guide](https://github.com/hraness/slopcamera/blob/main/docs/how-to/use-current-source.md): clone into a new directory, record its exact commit, install locked dependencies without lifecycle scripts, build the SDK and source CLI, then define the shell command against that checkout. A clone or skill installation alone does not install the executable. Do not alter an existing active checkout to satisfy this path.
 

package/skills/slopcamera/references/music-video.md

@@ -5,6 +5,10 @@ including dancing characters, changing landscapes, and musical light accents.
 The export retains the source and creates an ordinary editable project with
 separate scene video and original music.
 
+For an existing composition, use [scene refinement](scene-building.md#refine-an-existing-scene) to review
+each shot, author subtle interactions, check contact, and inspect the encoded
+delivery. Keep the scene's deliberate style and original media intact.
+
 ## Confirm the input and local capability
 
 Use the user's selected track and supplied tempo. Establish an explicit duration,

package/skills/slopcamera/references/native-studio.md

@@ -20,6 +20,25 @@ A failed or interrupted job is never automatically rerun. `studio inspect` reche
 
 See the shipped `docs/studio.md` and checked `examples/studio/` for source conventions, color/alpha rules, native caveats and the local `.studio.run()` workflow operation. Source/runtime identities are observed provenance, not a complete hash of every plugin, font, library or ambient read.
 
+### Diagnose a Blender render crash
+
+`studio probe` discovers devices and checks runtime capabilities; it does not
+render a frame or prove that Cycles shader compilation succeeds. Qualify the
+selected engine and device with a bounded render before a long job.
+
+When Blender quits unexpectedly, inspect the exact studio attempt and its retained
+logs, then correlate the process and time with the operating system's crash
+report. On macOS, a `MetalKernelPipeline::compile` stack and a main thread waiting
+in `BlenderSession::render` identify failure during rendering. They do not establish
+an out-of-memory condition, a harmless shutdown, or a particular cache defect.
+A successful Chrome/Three.js render supplies no evidence about Blender's recovery.
+
+After custody is settled, test a revised engine or device in a new, explicitly
+configured job if needed. CPU or EEVEE success can narrow the failing path but
+does not fix or qualify Cycles/Metal. Keep the original failure and inspect the
+new frames before adopting that configuration. Do not clear shared caches, alter
+another task's render, or repeatedly launch the failing job as a generic recovery.
+
 ## Share a native output without re-executing it
 
 `studio asset <studio-id> --output-id <id> --asset-id <id> --representation native|encoded-video [--frame <index>] --json` rechecks one successful output and returns its spatial asset, binding and receipt. It never rerenders or silently transcodes. Preserve all three together. A frame selection uses the native job’s explicit frame index; an encoded-video selection requires a previously retained unambiguous encode. Unsupported GLB materials, skins or morphs fail before rendering. Keep the original native rig and export a deliberate compatible static derivative.

package/skills/slopcamera/references/parametric-design.md

@@ -1,6 +1,6 @@
 # Build a revisable parametric design
 
-Use current source and `slopcamera scene design` for dimensions, repeated architectural parts, furniture, pavilions and façades that must regenerate from retained rules. This is a local mesh-design workflow; Rhino, Grasshopper and native engine execution are separate tools.
+Use Slopcamera v3.3.1 or newer and `slopcamera scene design` for dimensions, repeated architectural parts, furniture, pavilions and façades that must regenerate from retained rules. This workflow uses Slopcamera's local mesh geometry and needs no additional modeling application.
 
 1. Discover original studies with `slopcamera scene design catalog --json`. Start with `scene design init <new-directory> --template crescent-pavilion|spiral-stair|ribbed-tower|modular-bookshelf`.
 2. Read the emitted `design.json` and inspect it with `scene design inspect`. Describe the user's intended shape in named parameters, derived scalar values, constraints and semantic geometry stages. Keep references to engineering knowledge separate from visual references. Do not infer structural validation from appearance.
@@ -12,3 +12,7 @@ Use current source and `slopcamera scene design` for dimensions, repeated archit
 Place generated bundles below `artifacts/slopcamera/generated/`. Existing files conflict. An interrupted bundle without its final receipt is incomplete; inspect it and choose a fresh destination. The design compiler never executes source text. For native CAD operations or Blender/Cycles production shading, retain a native-studio source and use the explicit trusted-code workflow in [native studio](native-studio.md).
 
 Detailed contracts and checked commands: [design reference](https://github.com/hraness/slopcamera/blob/main/docs/parametric-design.md) and [design guide](https://github.com/hraness/slopcamera/blob/main/docs/how-to/parametric-design.md). The portable SDK exports the design compiler and starter catalog from `@hraness/slopcamera/code`; file publication and rendering belong to the CLI.
+
+For an existing film, compile and decode assets before playback, retain exact bytes and receipts, and preserve the host's camera and interaction timing. A custom renderer must apply primitive and entity transforms once and preserve the SDK's linear material colors. Cache geometry but clone it before changing UVs; use world-scale texture coordinates for consistent finishes. Review actual camera paths for obstructing members, supported roof details, aperture depth, prop contacts and coplanar floor flicker. Verify repeated seeks and inspect the final encoded movie, not only hero stills. See the [film integration guide](https://github.com/hraness/slopcamera/blob/main/docs/how-to/parametric-design.md#integrate-a-design-into-an-existing-film).
+
+For wall openings, `center[1]` is sill height from the wall base; arch height includes its semicircular crown. Use v3.3.3 or newer for corrected openings and boolean surfaces. Boolean inputs must be closed and satisfy hull convexity; conservative geometry budgets can reject opening counts below the schema maximum. Split a complex façade into wall segments. Distant wall LOD and collision proxies remain solid boxes; do not use them as aperture-accurate interaction geometry.

package/skills/slopcamera/references/scene-building.md

@@ -1,4 +1,7 @@
-# Build scenes from code
+# Build and refine authored scenes
+
+For an existing composition, go to [Refine an existing scene](#refine-an-existing-scene)
+for staging, interaction, contact, and final delivery review.
 
 Prefer helpers over hand-written scene JSON. The `@hraness/slopcamera/code` export ships pure builders in `spatial-scene/build` that return validated v1 scene data; feed their output into entities, transforms, and animation channels, then parse the whole scene before writing it. Helpers never read files, execute source, or touch a renderer, and every result already satisfies the contract schemas. Use [directed scenes](directed-scenes.md) for rendering, patching, and project commands.
 
@@ -30,3 +33,142 @@ Prefer helpers over hand-written scene JSON. The `@hraness/slopcamera/code` expo
 ## Admit a local glTF asset
 
 `slopcamera scene asset admit model.glb --source-root <dir> --output manifest.json --json` validates a local GLB 2.0 against the closed profile, stores it content-addressed, derives model-space and scene-space bounds into a sibling facts manifest, and emits the mesh entity plus ready `add-asset`/`add-entity` patch operations. The source path must stay inside `--source-root`; unsupported GLB features reject rather than degrade. Apply the returned operations through `scene patch`, then feed the admission document itself to `scene audit --asset-bounds`.
+
+Downloaded props use this same workflow. Require a self-contained GLB; any textures must be embedded PNG/JPEG. Loose glTF bundles, external textures, compressed meshes, and unsupported attributes or extensions reject. Admission defaults to a gray entity material. To preserve the model's materials and textures, set `geometry.materialMode: "source"` on the returned mesh in its `add-entity` operation before applying the patch, then inspect a rendered frame. Check each model's license and admission result; see the [local asset guide](https://github.com/hraness/slopcamera/blob/main/docs/spatial-scenes.md#admit-a-local-gltf-asset).
+
+## Refine an existing scene
+
+Use this pass when an existing HTML, Three.js, or native scene needs better
+staging, character interaction, materials, and motion. Start with its retained
+source and a playable baseline. Finish with reviewed frames from the new encoded
+movie, the source that produced it, and specific remaining limitations.
+
+### Establish the version and shot list
+
+Check `slopcamera --version` and the relevant command help against the executable
+you will use. A source checkout, installed CLI, and installed skill can differ.
+Inspect the matching package or release before concluding that a feature is
+missing. Native ALGAL behavior authoring uses `scene behavior check|bake|audit`;
+read [directed scenes](directed-scenes.md#author-character-behaviors) for its
+contracts.
+
+Record each shot's time range, intended action, camera, principal objects, and
+visible defects. Preserve deliberate stylistic choices and identity constraints.
+Capture comparable baseline and revised frames at the same scene times. When
+adding a shot, update duration, cuts, captions, end fades, frame count, and review
+sample lists together.
+
+Assign independent scene or object groups to separate workers when useful. Keep
+one owner for shared rigs, camera conventions, render settings, generated source,
+and the final browser session. Join the changes before the aggregate review.
+
+### Repair what the camera reveals
+
+Review the whole shot before adding detail. Use this order to make each pass
+address the remaining visible problem:
+
+| Area | Review and repair |
+| --- | --- |
+| Staging | Make the principal action readable at delivery size. Check silhouettes, feet, faces, sight lines, and foreground occlusion throughout the camera move. Extend sets far enough to cover every intended view. |
+| Contact | Check soles against the floor, fingers against handles, carried objects against hands, and tools against their target surfaces. An object origin is rarely its contact point. |
+| Construction | Give prominent objects plausible thickness, supports, seams, and connections. Inspect stairs, railings, glazing, roofs, furniture, and machine housings for floating or intersecting parts. |
+| Materials | Distinguish metal, glass, painted surfaces, fabric, and foliage through their response to light. Keep roughness and small variations consistent with scale; uniform gloss and repeated bright windows can flatten a scene. |
+| Lighting | Establish a readable key light, restrained fill, and motivated practical lights. Check contact shadows, highlight clipping, bloom, depth-of-field focus, and dark detail in the encoded result. |
+| Motion | Give actions a cause, preparation, contact, follow-through, and rest. Review full motion when a pose depends on a preceding event. |
+
+Fix a contact or camera defect before covering it with bloom, grain, motion, or
+extra props. Concentrate detail where the camera can resolve it. Numerical
+geometry checks can catch penetration; they cannot establish that a face is
+visible, a gesture reads well, or a material looks convincing.
+
+### Make behavior serve an observable action
+
+Choose a few useful reactions: a commuter notices a sign, a listener looks toward
+the speaker, or two characters pass an object. Define the event sequence before
+varying timing. A handoff might use notice, pause, reach, contact, shared grip,
+release, and acknowledgment. Assign explicit prop ownership intervals and
+document which actor controls the shared phase.
+
+Use the native ALGAL interaction organism for phase sequencing, then bind its
+emitted channels to clips, attach/release events, or trajectory waypoints through
+a channel map. Retain the behavior document, scene binding, channel map, bake,
+and audit. Repeat the bake with identical inputs to check determinism. Change
+the seed deliberately when reviewing variants. Inspect advisory findings in the
+context of the channel's meaning; repeated event payloads can be intentional.
+
+The behavior trace establishes event timing. Its mapped performance still needs
+the right rig, clip sources, transforms, and contact solution. Measure gaze toward
+the actual target in the character's coordinate frame. Preserve a resting arm
+when only the other arm participates. Use small delays and bounded pose changes
+to separate reactions without giving every object continuous motion.
+
+Direct within the visible asset's limits. A mathematically exact gaze can turn a
+photographic face map into an unreadable profile. Review face visibility during
+the gesture and use a restrained glance or nod when that better communicates the
+intended acknowledgment.
+
+When adapting a procedural rig, document any proxy skeleton and the conversion
+between local and world transforms. Test the visible rig separately. An audit of
+a proxy does not establish the visible character's foot placement, grip, or
+whole-body physical validity.
+
+### Verify contact and time before the full render
+
+Evaluate each frame from its absolute timestamp. Reset transforms and state that
+can otherwise survive a seek. Keep behavior baking outside the frame callback;
+sample the retained result during playback. Test a timestamp, a later timestamp,
+and the original timestamp again, including ownership and pose endpoints.
+
+For each important contact, declare the measured surfaces or anchors and a
+tolerance in scene units. Sample the actual loaded rig through the interaction,
+including frames immediately before and after attach, release, impact, and
+planting events. Check finite transforms, grip error, floor clearance, ownership,
+and prop orientation. For moving crowds or vehicles, check geometry extents and
+intermediate times as well as center distances. Report sampling density and
+tolerances; sampled clearance is not continuous collision proof.
+
+Require finite measurements and actual samples for every required contact state.
+Missing contact data must fail validation rather than default to zero error.
+Ensure each reported contact and replay check contributes to the final pass/fail
+result.
+
+Render a short preview containing the entire difficult action. For an HTML scene,
+author a bounded preview request and map its local clock to the intended source
+time in the authored scene; preserve the full-scene request. For a directed scene,
+use the supported explicit render range. Do not assume a project-specific capture
+flag is a Slopcamera CLI option.
+
+Review every shot at its start, middle, and end, then inspect event boundaries,
+cuts, and changed camera coverage. A contact sheet reveals composition and
+continuity; a motion preview reveals timing, sliding, snapping, and occlusion.
+Use both when the change affects interaction. Record defects by shot, object,
+time, and visible consequence so another pass can reproduce them.
+
+### Verify the encoded movie
+
+Run the supported [HTML music-video](music-video.md), [directed-scene](directed-scenes.md),
+or [native studio](native-studio.md) render workflow from the converged source.
+Retain its source and runtime receipts. A completed frame loop does not establish
+successful encoding or browser cleanup; resolve any reported lifecycle failure
+before calling the render successful.
+
+Probe the delivery for dimensions, rational frame rate, decoded frame count,
+duration, color metadata, and expected audio streams. Derive expected frames from
+the selected workflow's timing rules. Decode review frames from this movie,
+including cuts, the final frame, and the contact phases. If an authored event
+falls between frame times, record the selected frame index and its actual time.
+Review color against the source frames; metadata alone does not prove the correct
+RGB-to-YUV conversion. Distinguish intentional fades from missing or black frames.
+
+Keep the previous delivery and hash both files when verifying replacement. A
+different hash proves different bytes, so also compare the intended visible
+changes. Deliver the new movie with a compact scene review, retained evidence,
+and the limitations that remain visible. Avoid a quality or physics claim that
+the review did not establish.
+
+For a custom capture optimization, compare decoded pixels against the supported
+capture path at representative lit frames, including transparent edges and
+post-processing. An opening black frame is insufficient evidence. Keep the
+ordinary capture path when equality is required and the comparison differs.
+Never bypass browser signature checks, disable its sandbox, or signal unrelated
+processes to make a render finish.

package/src/mcp/tools.ts

@@ -45,6 +45,7 @@ import {
 import {
   spatialBehaviorFnSignatures,
 } from "../spatial-scene/behavior-fns.js"
+import { SpatialBehaviorBakeSchema } from "../spatial-scene/behavior-trace.js"
 import {
   SPATIAL_SCENE_LIMITS,
   type SpatialSceneV1,
@@ -2410,7 +2411,11 @@ export class SlopcameraMcpToolRuntime {
     options: ParsedSceneBehaviorAuditArguments,
   ): Promise<McpToolResult> {
     const bake = await loadJson(this.boundary, options.bake, "Behavior bake source")
-    const report = auditSpatialBehaviorTrace(bake.value)
+    const document = parseSpatialValue(SpatialBehaviorBakeSchema, bake.value, "behavior bake")
+    const report = auditSpatialBehaviorTrace({
+      behaviorSha256: document.behaviorSha256, emittedSha256: document.receipt.emittedSha256,
+      emitted: document.emitted, rangeUs: document.rangeUs,
+    })
     const findings = boundedSlice(report.findings, mcpMaximumReturnedFindings)
     const summary = {
       findingCount: report.findings.length,

package/src/spatial-scene/behavior-bake.ts

@@ -27,8 +27,7 @@ import {
   type SpatialBehaviorChannelMap,
   type SpatialBehaviorEmitted,
 } from "./behavior-trace.js"
-import { SpatialSceneV1Schema } from "./contracts.js"
-import { parseSpatialValue, spatialValueSha256, SpatialSceneError } from "./identity.js"
+import { parseSpatialScene, parseSpatialValue, spatialValueSha256, SpatialSceneError } from "./identity.js"
 
 /**
  * Deterministic behavior bake: an admitted `slopcamera.spatial-behavior`
@@ -105,7 +104,7 @@ const entryRunArgs = (behavior: SpatialBehavior, manifest: OrganismManifest): Re
 export async function bakeSpatialBehavior(input: unknown): Promise<SpatialBehaviorBakeResult> {
   const options = parseSpatialValue(bakeOptionsSchema, input, "behavior bake")
   const behavior = parseSpatialBehavior(options.behavior)
-  const scene = parseSpatialValue(SpatialSceneV1Schema, options.scene, "scene")
+  const scene = parseSpatialScene(options.scene)
   const sceneSha256 = spatialValueSha256(scene)
   const signatures = spatialBehaviorFnSignatures()
   const check = checkSpatialBehavior({ behavior, scene }, signatures)

package/src/spatial-scene/behavior-gallery.ts

@@ -13,9 +13,8 @@ import {
 } from "./behavior-trace.js"
 import {
   SpatialDigestSchema,
-  SpatialSceneV1Schema,
 } from "./contracts.js"
-import { parseSpatialValue, spatialValueSha256 } from "./identity.js"
+import { parseSpatialScene, parseSpatialValue, spatialValueSha256 } from "./identity.js"
 
 /**
  * Seeded behavior galleries: one admitted behavior document baked under
@@ -69,7 +68,7 @@ const candidateId = (parameter: string, behaviorSha256: string): string =>
 export async function planSpatialBehaviorGallery(input: unknown): Promise<SpatialBehaviorGalleryPlan> {
   const options = parseSpatialValue(galleryOptionsSchema, input, "behavior gallery")
   const behavior = parseSpatialBehavior(options.behavior)
-  const scene = parseSpatialValue(SpatialSceneV1Schema, options.scene, "scene")
+  const scene = parseSpatialScene(options.scene)
   const channelMap = options.channelMap === undefined ? undefined : parseSpatialBehaviorChannelMap(options.channelMap)
 
   const seen = new Set<string>()

package/src/spatial-scene/behavior.ts

@@ -4,11 +4,10 @@ import { boundedCanonicalJsonSha256 } from "../code/canonical-json.js"
 import { deepFreezeJson } from "../code/json-snapshot.js"
 import {
   SpatialDigestSchema,
-  SpatialSceneV1Schema,
   SpatialTimeUsSchema,
   type SpatialSceneV1,
 } from "./contracts.js"
-import { parseSpatialValue, spatialValueSha256 } from "./identity.js"
+import { parseSpatialScene, parseSpatialValue, spatialValueSha256 } from "./identity.js"
 
 /**
  * Behavior documents bind an ALGAL organism closure to one scene entity.
@@ -392,7 +391,7 @@ export function checkSpatialBehavior(
 ): SpatialBehaviorCheckReport {
   const options = parseSpatialValue(checkOptionsSchema, input, "behavior check")
   const behavior = parseSpatialBehavior(options.behavior)
-  const scene = parseSpatialValue(SpatialSceneV1Schema, options.scene, "scene")
+  const scene = parseSpatialScene(options.scene)
   const sceneSha256 = spatialValueSha256(scene)
   const findings: SpatialBehaviorCheckFinding[] = []
   const finding = (code: SpatialBehaviorFindingCode, severity: "error" | "warning", detail: string, referenceId?: string): void => {

package/src/spatial-scene/geometry.ts

@@ -44,6 +44,8 @@ export const SPATIAL_GEOMETRY_LIMITS = Object.freeze({
 
 export const SPATIAL_GEOMETRY_GRAPH_KIND = "slopcamera.spatial-geometry-graph" as const
 export const SPATIAL_GEOMETRY_PROFILE = "slopcamera.parametric-geometry-v1" as const
+/** CSG algorithm identity is separate from the retained GLB/facts format. */
+export const SPATIAL_GEOMETRY_BOOLEAN_COMPILER = "slopcamera.geometry-boolean-v2" as const
 
 const finite = z.number().finite().min(-SPATIAL_GEOMETRY_LIMITS.coordinate).max(SPATIAL_GEOMETRY_LIMITS.coordinate)
 const positive = z.number().finite().min(1e-9).max(SPATIAL_GEOMETRY_LIMITS.coordinate)
@@ -120,6 +122,7 @@ export interface SpatialGeometryEvaluation {
   readonly mesh: SpatialGeometryMesh
   readonly estimate: SpatialGeometryEstimate
   readonly graphSha256: string
+  readonly booleanCompiler?: typeof SPATIAL_GEOMETRY_BOOLEAN_COMPILER
 }
 
 function fail(message: string, path = "geometry"): never {
@@ -747,6 +750,13 @@ function partitionTriangles(input: Builder, planes: readonly Plane[]): Fragment[
     for (const plane of planes) {
       const next: Fragment[] = []
       for (const fragment of fragments) {
+        const signed = fragment.positions.map(point => plane.normal[0] * point[0] + plane.normal[1] * point[1] + plane.normal[2] * point[2] - plane.d)
+        // A one-sided or coplanar polygon is already a single cell. Clipping
+        // it into both inclusive half-spaces duplicates coplanar surfaces.
+        if (!signed.some(value => value < -PLANE_EPS) || !signed.some(value => value > PLANE_EPS)) {
+          next.push(fragment)
+          continue
+        }
         const inner = clipFragment(fragment, plane, true)
         const outer = clipFragment(fragment, plane, false)
         if (inner !== null) next.push(inner)
@@ -759,25 +769,59 @@ function partitionTriangles(input: Builder, planes: readonly Plane[]): Fragment[
   return result
 }
 
-/** Hull-solid membership: the fragment centroid must satisfy every support plane. */
-function fragmentInside(planes: readonly Plane[], fragment: Fragment): boolean {
+function fragmentCentroid(fragment: Fragment): Vec3 {
   const count = fragment.positions.length
-  const centroid: Vec3 = [
+  return [
     fragment.positions.reduce((sum, p) => sum + p[0], 0) / count,
     fragment.positions.reduce((sum, p) => sum + p[1], 0) / count,
     fragment.positions.reduce((sum, p) => sum + p[2], 0) / count,
   ]
-  return planes.every(plane => plane.normal[0] * centroid[0] + plane.normal[1] * centroid[1] + plane.normal[2] * centroid[2] - plane.d <= PLANE_EPS)
+}
+
+function fragmentNormal(fragment: Fragment): Vec3 | null {
+  const origin = fragment.positions[0]!, normal = [0, 0, 0]
+  for (let index = 1; index + 1 < fragment.positions.length; index++) {
+    const a = fragment.positions[index]!, b = fragment.positions[index + 1]!
+    const u = [a[0] - origin[0], a[1] - origin[1], a[2] - origin[2]], v = [b[0] - origin[0], b[1] - origin[1], b[2] - origin[2]]
+    normal[0] = normal[0]! + u[1]! * v[2]! - u[2]! * v[1]!
+    normal[1] = normal[1]! + u[2]! * v[0]! - u[0]! * v[2]!
+    normal[2] = normal[2]! + u[0]! * v[1]! - u[1]! * v[0]!
+  }
+  const length = Math.hypot(...normal)
+  return length < 1e-12 ? null : [normal[0]! / length, normal[1]! / length, normal[2]! / length]
+}
+
+function planeDistance(plane: Plane, point: Vec3): number {
+  return plane.normal[0] * point[0] + plane.normal[1] * point[1] + plane.normal[2] * point[2] - plane.d
+}
+
+/** Symbolic infinitesimal occupancy on each side avoids scale-dependent probe distances. */
+function insideHullSide(planes: readonly Plane[], point: Vec3, normal: Vec3, side: number): boolean {
+  return planes.every(plane => {
+    const signed = planeDistance(plane, point)
+    if (signed > PLANE_EPS) return false
+    if (signed < -PLANE_EPS) return true
+    return side * (plane.normal[0] * normal[0] + plane.normal[1] * normal[1] + plane.normal[2] * normal[2]) <= PLANE_EPS
+  })
+}
+
+function boundsTouch(a: Bounds, b: Bounds): boolean {
+  return [0, 1, 2].every(axis => a.min[axis]! <= b.max[axis]! + PLANE_EPS && b.min[axis]! <= a.max[axis]! + PLANE_EPS)
+}
+
+function builderBounds(input: Builder): Bounds {
+  const low: number[] = [Infinity, Infinity, Infinity], high: number[] = [-Infinity, -Infinity, -Infinity]
+  for (let i = 0; i < input.positions.length; i++) {
+    const axis = i % 3, value = input.positions[i]!
+    low[axis] = Math.min(low[axis]!, value); high[axis] = Math.max(high[axis]!, value)
+  }
+  return { min: low as unknown as Vec3, max: high as unknown as Vec3 }
 }
 
 function emitFragments(b: Builder, fragments: readonly Fragment[], flip: boolean): void {
   for (const fragment of fragments) {
-    let z = 0
-    for (let index = 0; index < fragment.positions.length; index++) {
-      const a = fragment.positions[index]!, c = fragment.positions[(index + 1) % fragment.positions.length]!
-      z += a[0] * c[1] - a[1] * c[0]
-    }
-    const unit: Vec3 = z < 0 ? [0, 0, -1] : [0, 0, 1]
+    const unit = fragmentNormal(fragment)
+    if (unit === null) continue
     const oriented: Vec3 = flip ? [-unit[0], -unit[1], -unit[2]] : unit
     const indices = fragment.positions.map((position, index) => vertex(b, position, oriented, fragment.uvs[index]!))
     for (let index = 1; index + 1 < indices.length; index++) {
@@ -801,30 +845,31 @@ function booleanMesh(input: Extract<SpatialGeometryNode, { kind: "boolean" }>, m
       fail("Boolean inputs exceed the bounded simple-input triangle budget.", `${path}.${index}`)
     }
   }
-  const planesA = uniquePlanes(a, path)
-  const planesC = cutters.map(cutter => uniquePlanes(cutter, path))
-  assertHull(a, planesA, path)
-  cutters.forEach((cutter, index) => assertHull(cutter, planesC[index]!, path))
+  const inputs = [a, ...cutters], hulls = inputs.map(mesh => uniquePlanes(mesh, path)), bounds = inputs.map(builderBounds)
+  inputs.forEach((mesh, index) => assertHull(mesh, hulls[index]!, path))
   const output = builder()
-  if (input.operation === "difference") {
-    const allCutterPlanes = planesC.flat()
-    const kept = partitionTriangles(a, allCutterPlanes).filter(piece => !planesC.some(planes => fragmentInside(planes, piece)))
-    emitFragments(output, kept, false)
-    for (const [index, cutter] of cutters.entries()) {
-      const caps = partitionTriangles(cutter, planesA).filter(piece =>
-        fragmentInside(planesA, piece) && !planesC.some((other, otherIndex) => otherIndex !== index && fragmentInside(other, piece)))
-      emitFragments(output, caps, true)
-    }
-  } else {
-    const planesB = planesC[0]!, b = cutters[0]!
-    const piecesA = partitionTriangles(a, planesB), piecesB = partitionTriangles(b, planesA)
-    if (input.operation === "intersection") {
-      emitFragments(output, piecesA.filter(piece => fragmentInside(planesB, piece)), false)
-      emitFragments(output, piecesB.filter(piece => fragmentInside(planesA, piece)), false)
-    } else {
-      emitFragments(output, piecesA.filter(piece => !fragmentInside(planesB, piece)), false)
-      emitFragments(output, piecesB.filter(piece => !fragmentInside(planesA, piece)), false)
+  for (const [owner, mesh] of inputs.entries()) {
+    const planes = hulls.flatMap((hull, index) => index !== owner && boundsTouch(bounds[owner]!, bounds[index]!) ? hull : [])
+    const outward: Fragment[] = [], reversed: Fragment[] = []
+    for (const fragment of partitionTriangles(mesh, planes)) {
+      const normal = fragmentNormal(fragment)
+      if (normal === null) continue
+      const point = fragmentCentroid(fragment)
+      const occupied = (side: number): boolean => {
+        const inside = hulls.map(hull => insideHullSide(hull, point, normal, side))
+        return input.operation === "difference" ? inside[0]! && !inside.slice(1).some(Boolean)
+          : input.operation === "intersection" ? inside.every(Boolean) : inside.some(Boolean)
+      }
+      const positive = occupied(1), negative = occupied(-1)
+      if (positive === negative) continue
+      // Coincident boundary faces belong to the earliest source hull. Their
+      // occupancy is shared; retaining both would double area and cause z-fighting.
+      const duplicate = hulls.slice(0, owner).some(hull => hull.every(plane => planeDistance(plane, point) <= PLANE_EPS)
+        && hull.some(plane => Math.abs(planeDistance(plane, point)) <= PLANE_EPS
+          && Math.abs(plane.normal[0] * normal[0] + plane.normal[1] * normal[1] + plane.normal[2] * normal[2]) > 1 - 1e-7))
+      if (!duplicate) (positive ? reversed : outward).push(fragment)
     }
+    emitFragments(output, outward, false); emitFragments(output, reversed, true)
   }
   output.uvsSet = [a, ...cutters].some(mesh => mesh.uvsSet)
   if (output.indices.length === 0) fail("Boolean result is empty; the inputs do not overlap as the operation requires.", path)
@@ -1010,8 +1055,15 @@ function estimateNode(node: SpatialGeometryNode, meshEstimates: ReadonlyMap<stri
     case "boolean": {
       const a = mesh(node.a)
       const cutters = node.operation === "difference" ? node.cutters.map(mesh) : [mesh(node.b)]
-      const triangles = a.triangles * (1 + cutters.reduce((sum, cutter) => sum + cutter.planes, 0))
-        + cutters.reduce((sum, cutter) => sum + cutter.triangles * (a.planes + 1), 0)
+      const inputs = [a, ...cutters]
+      // In one source triangle, n plane intersections form at most
+      // 1+n(n+1)/2 cells. Each proper split adds at most two fan triangles,
+      // hence 1+n(n+1) triangles per input triangle, including all cap faces.
+      // Disjoint input bounds cannot cut each other's source triangles.
+      const triangles = inputs.reduce((total, source, index) => {
+        const planes = inputs.reduce((sum, other, otherIndex) => sum + (otherIndex !== index && boundsTouch(source.bounds, other.bounds) ? other.planes : 0), 0)
+        return total + source.triangles * (1 + planes * (planes + 1))
+      }, 0)
       const other = cutters[0]!
       const bounds = node.operation === "intersection"
         ? { min: [Math.max(a.bounds.min[0], other.bounds.min[0]), Math.max(a.bounds.min[1], other.bounds.min[1]), Math.max(a.bounds.min[2], other.bounds.min[2])] as unknown as Vec3,
@@ -1099,7 +1151,8 @@ export function evaluateSpatialGeometry(input: unknown): SpatialGeometryEvaluati
   if (mesh.vertices > estimate.vertices || mesh.triangles > estimate.triangles) {
     fail("Evaluated mesh exceeded its static budget estimate.", "geometry.output")
   }
-  return deepFreezeJson({ mesh, estimate, graphSha256: spatialValueSha256({ domain: "slopcamera.spatial-geometry-graph.v1", graph }) })
+  return deepFreezeJson({ mesh, estimate, graphSha256: spatialValueSha256({ domain: "slopcamera.spatial-geometry-graph.v1", graph }),
+    ...(graph.nodes.some(node => node.kind === "boolean") ? { booleanCompiler: SPATIAL_GEOMETRY_BOOLEAN_COMPILER } : {}) })
 }
 
 // ---------------------------------------------------------------------------