import type { ErrorReport } from "./error";
import type { ProgressEvent } from "./progress";
import type { NonMeshCurveSplineType, NonMeshFontCharacterIR, NonMeshFontLinksIR, NonMeshFontPropertiesIR, NonMeshFontTextBoxIR, SceneSnapshotIR } from "./scene-ir";
import type { SceneDelta } from "./scene-delta";
import type { SimplifyProfile } from "./simplify";
import type { SimplifyResult } from "./simplify";
import type { LODGenerationRequest } from "./lod";
import type { LODManifest } from "./simplify";
import type { DepsgraphEvaluationIR } from "./depsgraph";
import type { SculptMeshAttributesIR, SculptStrokeIR } from "./sculpt";
import type { GeometryNodeGraphIR } from "./geometry-nodes";
import type {
  PhysicsClothSettings,
  PhysicsFluidSettings,
  PhysicsParticleCacheSettings,
  PhysicsRigidBodySettings,
  PhysicsSimulationManifestIR,
  PhysicsSimulationPlaybackSettings,
  PhysicsSoftBodySettings,
} from "./physics-simulation";
import type { ShaderGraphIR } from "./shader-graph";
import type { ShaderCompileReport } from "./shader-compiler";
import type { NlaMoveStripCommand, NlaTrackIR } from "./nla";
import type { RenderCapabilityRequest } from "./render-capabilities";
import type { RenderRoutingRequestIR } from "./render-routing";
import type { CapabilityGateResult } from "./capability-gates";
import type { NonMeshGeometryChunk } from "./nonmesh-binary";
import type {
  PaintStrokeSessionBeginIR,
  PaintStrokeSessionCancelIR,
  PaintStrokeSessionChunkIR,
  PaintStrokeSessionCommitIR,
  PaintStrokeSessionReceiptIR,
} from "./paint-stroke-session";
import type { PaintPBVHCapabilityRequest } from "./paint-pbvh-capability";
import type { LibraryMainAppendReceiptIR, LibraryMainAppendRequestIR } from "./library-main-append";
import type { BlenderOperatorDescriptor, BlenderOperatorPropertySpec, BlenderOperatorInvocation, BlenderOperatorPropertyValue } from "./blender-operator";
import type { SequencerTimelineIR } from "./sequencer";
import type { CompositorGraphIR } from "./compositor";

export interface MeshGeometryBuffer {
  schemaVersion: 1;
  meshId: string;
  byteLength: number;
  positions: ArrayBuffer;
  indices: ArrayBuffer;
  normals?: ArrayBuffer;
  triangleCornerIndices?: ArrayBuffer;
  uvs?: ArrayBuffer;
  colors?: ArrayBuffer;
  triangleMaterialIndices?: ArrayBuffer;
  triangleFaceIndices?: ArrayBuffer;
  edgeVertexIndices?: ArrayBuffer;
  tangents?: ArrayBuffer;
  splitNormals?: ArrayBuffer;
  sculptMask?: ArrayBuffer;
  faceSets?: ArrayBuffer;
}

export type MeshGeometryBufferField =
  | "positions"
  | "indices"
  | "normals"
  | "triangleCornerIndices"
  | "uvs"
  | "colors"
  | "triangleMaterialIndices"
  | "triangleFaceIndices"
  | "edgeVertexIndices"
  | "tangents"
  | "splitNormals"
  | "sculptMask"
  | "faceSets";

export interface MeshGeometryRangePatch {
  meshId: string;
  field: MeshGeometryBufferField;
  byteOffset: number;
  data: ArrayBuffer;
}

export interface MeshGeometryDelta {
  schemaVersion: 1;
  patches: MeshGeometryRangePatch[];
  replaced: MeshGeometryBuffer[];
  removed: string[];
}

export type MeshElementMode = "VERT" | "EDGE" | "FACE";
export type MeshPrimitive = "CUBE" | "PLANE" | "UV_SPHERE" | "ICO_SPHERE" | "CYLINDER" | "CONE" | "TORUS";
export type MeshEditOperation = "MERGE" | "DISSOLVE" | "EXTRUDE" | "INSET" | "BEVEL" | "LOOP_CUT" | "SUBDIVIDE" | "FILL" | "TRIANGULATE" | "RECALCULATE_NORMALS" | "BRIDGE_LOOPS" | "DELETE";
export type FCurveInterpolation = "CONSTANT" | "LINEAR" | "BEZIER";
export type KeyframeHandle = [number, number];
export interface FCurvePoint {
  frame: number;
  value: number;
  handleLeft?: KeyframeHandle;
  handleRight?: KeyframeHandle;
  interpolation?: FCurveInterpolation;
}
export interface ActionGroupDefinition {
  name: string;
  paths: string[];
}
export interface KeyingSetPathDefinition {
  path: string;
  arrayIndex?: number;
}
export type ArmatureEditOperation =
  | { operation: "ADD"; name: string; parentName?: string | null; head: [number, number, number]; tail: [number, number, number]; roll?: number; connected?: boolean }
  | { operation: "DELETE"; boneName: string }
  | { operation: "RENAME"; boneName: string; name: string }
  | { operation: "EXTRUDE"; boneName: string; name: string; tail: [number, number, number] }
  | { operation: "DUPLICATE"; boneName: string; name: string; offset?: [number, number, number] };
export type PoseConstraintType = "COPY_LOCATION" | "COPY_ROTATION" | "COPY_SCALE" | "IK" | "TRACK_TO";

export type WebEngineEditCommand =
  | { type: "setFrame"; frame: number }
  | { type: "setObjectVisibility"; objectId: string; visible: boolean }
  | { type: "setModifierEnabled"; meshId: string; modifierUuid: string; enabled: boolean }
  | { type: "setModifierVisibility"; meshId: string; modifierUuid: string; showViewport: boolean; showRender: boolean; showEditMode: boolean; showOnCage: boolean }
  | { type: "addModifier"; meshId: string; modifierType: string; name?: string }
  | { type: "removeModifier"; meshId: string; modifierUuid: string }
  | { type: "moveModifier"; meshId: string; modifierUuid: string; direction?: "UP" | "DOWN"; index?: number }
  | { type: "setModifierParameters"; meshId: string; modifierUuid: string; parameters: Record<string, unknown> }
  | { type: "decimateMesh"; meshId: string; profile: SimplifyProfile }
  | { type: "previewDecimateMesh"; meshId: string; profile: SimplifyProfile }
  | { type: "createPrimitive"; primitive: MeshPrimitive; name?: string; location: [number, number, number] }
  | { type: "duplicateObject"; objectId: string; offset?: [number, number, number]; linked?: boolean }
  | { type: "deleteObject"; objectId: string }
  | { type: "setObjectTransform"; objectId: string; translation: [number, number, number]; rotationEuler: [number, number, number]; scale: [number, number, number] }
  | { type: "setArmatureBones"; objectId: string; bones: Array<{ name: string; parentName: string | null; head: [number, number, number]; tail: [number, number, number]; roll: number; connected?: boolean }> }
  | { type: "setPoseBoneTransform"; objectId: string; boneName: string; translation: [number, number, number]; rotationEuler: [number, number, number]; scale: [number, number, number] }
  | { type: "armatureEditOperations"; objectId: string; operations: ArmatureEditOperation[] }
  | { type: "setBoneRoll"; objectId: string; boneName: string; roll: number }
  | { type: "setBoneSymmetry"; objectId: string; enabled: boolean }
  | { type: "setBoneParenting"; objectId: string; boneName: string; parentName: string | null; connected: boolean }
  | { type: "setPoseConstraint"; objectId: string; boneName: string; constraintName: string; constraintType: PoseConstraintType | null; targetObjectId?: string | null; targetBoneName?: string; influence?: number; enabled?: boolean }
  | { type: "translateMeshVertices"; meshId: string; vertexIndices: number[]; offset: [number, number, number] }
  | { type: "meshEdit"; meshId: string; operation: MeshEditOperation; selectionMode: MeshElementMode; elementIndices: number[]; offset?: [number, number, number]; amount?: number; segments?: number }
  | { type: "meshSubdivide"; meshId: string; selectionMode: MeshElementMode; elementIndices: number[]; segments?: number }
  | { type: "meshTriangulate"; meshId: string; faceIndices: number[] }
  | { type: "meshRecalculateNormals"; meshId: string; faceIndices: number[] }
  | { type: "meshBridgeLoops"; meshId: string; edgeIndices: number[] }
  | { type: "meshDeleteElements"; meshId: string; selectionMode: MeshElementMode; elementIndices: number[] }
  | { type: "meshUVProject"; meshId: string; faceIndices: number[]; method: "PLANAR" | "CUBE" | "CYLINDER" | "SPHERE"; seamEdgeIndices?: number[] }
  | { type: "createUVMap"; meshId: string; name: string }
  | { type: "setActiveUVMap"; meshId: string; name: string }
  | { type: "unwrapUV"; meshId: string; faceIndices: number[]; method: "PLANAR" | "CUBE" }
  | { type: "addMaterialSlot"; objectId: string; name?: string }
  | { type: "removeMaterialSlot"; objectId: string; slotIndex: number }
  | { type: "assignMaterialFaces"; meshId: string; faceIndices: number[]; slotIndex: number }
  | { type: "setMaterialPrincipled"; materialId: string; baseColor: [number, number, number, number]; roughness: number; metallic: number; emissionColor?: [number, number, number, number]; alpha?: number; ior?: number; specularIORLevel?: number; transmissionWeight?: number; coatWeight?: number; coatRoughness?: number; emissionStrength?: number }
  | { type: "importImage"; name: string; mimeType: "image/png" | "image/jpeg"; width: number; height: number; base64: string }
  | { type: "setMaterialImageNode"; materialId: string; imageId: string; usage: "BASE_COLOR" | "NORMAL"; uvMap?: string }
  | { type: "insertObjectKeyframe"; objectId: string; frame: number; property: "LOCATION" | "ROTATION_EULER" | "SCALE"; interpolation?: FCurveInterpolation }
  | { type: "deleteObjectKeyframe"; objectId: string; frame: number; property?: "LOCATION" | "ROTATION_EULER" | "SCALE" }
  | { type: "createAction"; name: string; objectId?: string }
  | { type: "removeAction"; actionId: string }
  | { type: "setKeyframe"; animationId: string; path: string; frame: number; value?: number[]; handleLeft?: KeyframeHandle; handleRight?: KeyframeHandle; interpolation?: FCurveInterpolation }
  | { type: "setFCurveKeyframes"; animationId: string; path: string; points: FCurvePoint[] }
  | { type: "setDriverExpression"; animationId: string; path: string; expression: string }
  | { type: "setActionGroups"; animationId: string; groups: ActionGroupDefinition[] }
  | { type: "setKeyingSet"; sceneId: string; name: string; paths: KeyingSetPathDefinition[]; active?: boolean }
  | { type: "bakeAnimation"; objectId: string; frameStart: number; frameEnd: number; step?: number }
  | { type: "setTimelineMarkers"; dataId: string; markers: Array<{ frame: number; name: string }> }
  | { type: "setFCurveInterpolation"; animationId: string; path: string; interpolation: FCurveInterpolation }
  | { type: "setActiveAction"; objectId: string; actionId: string | null }
  | { type: "setConstraint"; objectId: string; constraintName: string; enabled: boolean; influence: number }
  | { type: "setParent"; objectId: string; parentId: string | null; keepTransform?: boolean }
  | { type: "createCollection"; name: string; parentCollectionId?: string | null }
  | { type: "moveObjectToCollection"; objectId: string; collectionId: string }
  | { type: "renameId"; id: string; name: string }
  | { type: "joinObjects"; activeObjectId: string; objectIds: string[] }
  | { type: "separateMeshFaces"; objectId: string; faceIndices: number[]; name?: string }
  | { type: "applyObjectTransform"; objectId: string }
  | { type: "setObjectOrigin"; objectId: string; mode: "GEOMETRY" | "WORLD" }
  | { type: "createCurve"; curveType: "CURVE"; name?: string; controlPoints: number[]; cyclic?: boolean; resolution?: number }
  | { type: "deleteNonMeshData"; dataId: string }
  | { type: "setCurveControlPoints"; dataId: string; controlPoints: number[]; splineOffsets?: number[]; resolution?: number }
  | { type: "setCurveBevel"; dataId: string; bevelDepth?: number; bevelResolution?: number; bevelFactorStart?: number; bevelFactorEnd?: number }
  | { type: "setCurveTaper"; dataId: string; taperObjectId: string | null; taperRadiusMode?: number }
  | { type: "convertCurveType"; dataId: string; targetType: "CURVE" | "SURFACE" }
  | { type: "setCurveHandle"; dataId: string; pointIndex: number; side: "LEFT" | "RIGHT"; position: [number, number, number] }
  | { type: "setCurveTopology"; dataId: string; baseRevision?: number; splineTypes?: NonMeshCurveSplineType[]; cyclicU?: boolean[]; cyclicV?: boolean[]; handleTypes?: number[]; handlePoints?: number[] }
  | { type: "setCurveSplines"; dataId: string; splineTypes: NonMeshCurveSplineType[]; splineOffsets: number[]; ordersU: number[]; controlPoints: number[]; pointWeights: number[]; cyclicU: boolean[]; handleTypes: number[]; handlePoints: number[] }
  | { type: "setSurfaceTopology"; dataId: string; splineDimensions: Array<{ u: number; v: number; orderU: number; orderV: number }>; controlPoints: number[]; pointWeights: number[]; cyclicU: boolean[]; cyclicV: boolean[] }
  | { type: "setSurfaceResolution"; dataId: string; resolutionU: number; resolutionV?: number }
  | { type: "setFontBody"; dataId: string; body: string }
  | { type: "setFontProperties"; dataId: string; properties: Partial<NonMeshFontPropertiesIR> }
  | { type: "setFontAdvanced"; dataId: string; characters: NonMeshFontCharacterIR[]; textBoxes: NonMeshFontTextBoxIR[]; activeTextBox: number }
  | { type: "importVFont"; schemaVersion: 1; projectId: string; assetId: string; assetPath: string; sourcePath: string; name: string; format: "TTF" | "OTF" | "PFB"; mimeType: string; byteLength: number; sha256: string; base64: string }
  | { type: "setFontLinks"; dataId: string; links: NonMeshFontLinksIR }
  | { type: "setTextSource"; dataId: string; source: string }
  | { type: "setSoundProperties"; dataId: string; properties: { volume?: number; attenuation?: number; pitch?: number; minGain?: number; maxGain?: number; distance?: number; offsetTime?: number } }
  | { type: "setSpeakerProperties"; dataId: string; properties: { volumeMax?: number; volumeMin?: number; distanceMax?: number; distanceReference?: number; attenuation?: number; coneAngleOuter?: number; coneAngleInner?: number; coneVolumeOuter?: number; volume?: number; pitch?: number } }
  | { type: "setParticleSettings"; dataId: string; properties: { type?: number; from?: number; distribution?: number; physicsType?: number; totalParticles?: number; start?: number; end?: number; lifetime?: number; size?: number; drawSize?: number } }
  | { type: "setTextureProperties"; dataId: string; properties: { noiseScale?: number; noiseDepth?: number; intensity?: number; contrast?: number; saturation?: number } }
  | { type: "setVolumeProperties"; dataId: string; sourcePath: string; displayDensity: number; interpolation: "NEAREST" | "LINEAR"; stepSize: number; velocityGrid?: string; velocityScale?: number }
  | { type: "createGreasePencilLayer"; dataId: string; name: string }
  | { type: "removeGreasePencilLayer"; dataId: string; layerId: string }
  | { type: "moveGreasePencilLayer"; dataId: string; layerId: string; direction: "UP" | "DOWN" | "TOP" | "BOTTOM"; baseRevision?: number }
  | { type: "moveGreasePencilFrame"; dataId: string; layerId: string; frame: number; targetFrame: number; drawingId: string; baseRevision: number }
  | { type: "insertGreasePencilFrame"; dataId: string; layerId: string; frame: number; duration?: number }
  | { type: "removeGreasePencilFrame"; dataId: string; layerId: string; frame: number }
  | { type: "setGreasePencilStrokes"; dataId: string; layerId: string; frame: number; baseRevision?: number; strokes: Array<{ cyclic?: boolean; materialIndex?: number; points: Array<{ position: [number, number, number]; radius?: number; opacity?: number; vertexColor?: [number, number, number, number] }> }> }
  | { type: "setGreasePencilDrawing"; dataId: string; layerId: string; frame: number; drawingId?: string; baseRevision?: number; strokes: Array<{ cyclic?: boolean; materialIndex?: number; points: Array<{ position: [number, number, number]; radius?: number; opacity?: number; vertexColor?: [number, number, number, number] }> }> }
  | { type: "setGreasePencilMaterial"; dataId: string; layerId: string; frame: number; materialIndex: number; strokeIndices?: number[]; baseRevision?: number }
  | { type: "setGreasePencilSelection"; dataId: string; layerId: string; frame: number; pointIndices?: number[]; strokeIndices?: number[]; mode?: "REPLACE" | "ADD" | "SUBTRACT" | "TOGGLE"; baseRevision?: number }
  | { type: "setGreasePencilInterpolate"; dataId: string; layerId: string; sourceFrame: number; targetFrame: number; factor: number; baseRevision?: number }
  | { type: "setVertexColors"; meshId: string; attributeName: string; domain: "POINT" | "CORNER"; indices: number[]; colors: number[] }
  | { type: "setVertexWeights"; objectId: string; vertexGroup: string; indices: number[]; values: number[]; normalize?: boolean; limit?: number; mirror?: boolean; mirrorAxis?: 0 | 1 | 2; mirrorTolerance?: number }
  | { type: "setLightProperties"; dataId: string; properties: { type?: "POINT" | "SUN" | "SPOT" | "AREA"; areaShape?: 0 | 1 | 4 | 5; diffuseFactor?: number; specularFactor?: number; transmissionFactor?: number; volumeFactor?: number; attenuationDistance?: number; shadowFilterRadius?: number; shadowMaximumResolution?: number; shadowJitterOverblur?: number; cascadeMaxDistance?: number; cascadeExponent?: number; cascadeFade?: number; cascadeCount?: number; areaSizeZ?: number; clipStart?: number; color?: [number, number, number]; energy?: number; exposure?: number; temperature?: number; useTemperature?: boolean; castsShadow?: boolean; radius?: number; spotAngle?: number; spotBlend?: number; areaSize?: number; areaSizeY?: number; areaSpread?: number; sunAngle?: number } }
  | { type: "setCameraProperties"; dataId: string; properties: { projection?: "PERSPECTIVE" | "ORTHOGRAPHIC" | "PANORAMIC"; panoramaType?: 0 | 1 | 2 | 3 | 4 | 5 | 6; fisheyeFov?: number; lensMm?: number; sensorWidthMm?: number; sensorHeightMm?: number; sensorFit?: 0 | 1 | 2; shift?: [number, number]; near?: number; far?: number; orthoScale?: number; depthOfField?: { enabled?: boolean; focusObjectId?: string | null; focusDistance?: number; apertureFStop?: number; apertureBlades?: number; apertureRotation?: number; apertureRatio?: number } } }
  | { type: "setWorldProperties"; dataId: string; properties: { color?: [number, number, number]; exposure?: number; environmentStrength?: number; ambientOcclusionDistance?: number; ambientOcclusionEnergy?: number; sunThreshold?: number; sunAngle?: number; sunShadowMaximumResolution?: number; sunShadowJitterOverblur?: number; sunShadowFilterRadius?: number; probeResolution?: 7 | 8 | 9 | 10 | 11 | 12; useSunShadow?: boolean; useSunShadowJitter?: boolean; mist?: { enabled?: boolean; type?: "QUADRATIC" | "LINEAR" | "INVERSE_QUADRATIC"; start?: number; depth?: number; intensity?: number; height?: number } } }
  | { type: "setSceneProperties"; dataId: string; properties: { renderEngine?: string; viewTransform?: string; look?: string; exposure?: number; gamma?: number } }
  | { type: "setSceneRenderSettings"; dataId: string; properties: { resolutionX?: number; resolutionY?: number; resolutionPercentage?: number; frameStart?: number; frameEnd?: number; outputPath?: string } }
  | { type: "setSceneAudioSettings"; dataId: string; properties: { volume?: number; speedOfSound?: number; dopplerFactor?: number; distanceModel?: number; muted?: boolean; sync?: boolean } }
  | { type: "setSceneUnitSettings"; dataId: string; properties: { system?: number; scaleLength?: number; rotationSystem?: number; lengthUnit?: number; massUnit?: number; timeUnit?: number; temperatureUnit?: number } }
  | { type: "setSceneTimelineSettings"; dataId: string; properties: { fps?: number; fpsBase?: number; frameStep?: number; usePreviewRange?: boolean; previewStart?: number; previewEnd?: number } }
  | { type: "setScenePipelineSettings"; dataId: string; properties: { useCompositor?: boolean; useSequencer?: boolean; noOverwrite?: boolean; saveOutput?: boolean; alphaPremultiplied?: boolean } }
  | { type: "renderFrame"; dataId: string; frame?: number; route?: RenderRoutingRequestIR }
  | { type: "renderAnimation"; dataId: string; frameStart?: number; frameEnd?: number; step?: number; route?: RenderRoutingRequestIR }
  | { type: "setRenderPasses"; dataId: string; layerName: string; passes: { passMask?: number; cryptomatteMask?: number; cryptomatteLevels?: number; alphaThreshold?: number } }
  | { type: "setCameraView"; dataId: string; cameraObjectId: string | null }
  | { type: "setLightLinking"; dataId: string; target?: "OBJECT" | "WORLD"; lightgroup: string | null }
  | { type: "setSequencerStrips"; sceneId: string; timeline: SequencerTimelineIR }
  | { type: "setSequencerStripModifiers"; sceneId: string; stripId: string; modifiers: Array<{ id: string; type: string; enabled?: boolean; properties?: Record<string, unknown> }> }
  | { type: "setSequencerTransitions"; sceneId: string; timeline: SequencerTimelineIR }
  | { type: "setSequencerColorBalance"; sceneId: string; stripId: string; colorBalance: { lift: [number, number, number]; gamma: [number, number, number]; gain: [number, number, number]; exposure?: number; contrast?: number; saturation?: number } }
  | { type: "setCompositorNodeGraph"; sceneId: string; graph: CompositorGraphIR }
  | { type: "setSceneBindings"; dataId: string; properties: { cameraObjectId?: string | null; worldId?: string | null } }
  | { type: "setSceneViewLayerSettings"; dataId: string; layerName: string; properties: { useRender?: boolean; useFreestyle?: boolean; samples?: number } }
  | { type: "setSceneCollectionSettings"; dataId: string; layerName: string; collectionId: string; properties: { exclude?: boolean; holdout?: boolean; indirectOnly?: boolean; hide?: boolean } }
  | { type: "setSceneBorderSettings"; dataId: string; properties: { enabled?: boolean; minX?: number; maxX?: number; minY?: number; maxY?: number } }
  | { type: "setSceneSimplifySettings"; dataId: string; properties: { subsurfViewport?: number; subsurfRender?: number; particlesViewport?: number; particlesRender?: number; volumes?: number } }
  | { type: "setSceneColorManagement"; dataId: string; properties: { displayDevice?: string; temperature?: number; tint?: number } }
  | { type: "setSceneImageFormat"; dataId: string; properties: { fileType?: "PNG" | "JPEG" | "OPEN_EXR" | "TIFF" | "WEBP"; colorMode?: number; depth?: number; quality?: number; compression?: number; exrCodec?: number } }
  | { type: "setSceneMotionBlur"; dataId: string; properties: { enabled?: boolean; shutter?: number; position?: 0 | 1 | 2 } }
  | { type: "setSceneHairSettings"; dataId: string; properties: { type?: 0 | 1 | 2; subdivisions?: number } }
  | { type: "setSceneCompositorSettings"; dataId: string; properties: { device?: 0 | 1; precision?: 0 | 1; denoiseDevice?: 0 | 1 | 2; previewQuality?: 0 | 1 | 2; finalQuality?: 0 | 1 | 2 } }
  | { type: "setScenePerformanceSettings"; dataId: string; properties: { fixedThreads?: boolean; threads?: number; persistentData?: boolean; highQualityNormals?: boolean } }
  | { type: "setSceneSamplingSettings"; dataId: string; properties: { pixelAspectX?: number; pixelAspectY?: number; filterSize?: number; dither?: number } }
  | { type: "setSceneMultiviewSettings"; dataId: string; properties: { enabled?: boolean; viewsFormat?: 0 | 1; imageViewsFormat?: 0 | 1 | 2; stereoDisplayMode?: 0 | 1 | 2 | 3 | 4; interlaceSwap?: boolean; sideBySideCrossed?: boolean; squeezedFrame?: boolean } }
  | { type: "setSceneStampSettings"; dataId: string; properties: { stampMask?: number; fontId?: number; userText?: string; foreground?: [number, number, number, number]; background?: [number, number, number, number] } }
  | { type: "setTrackingMarkers"; clipId: string; trackId: string; markers: TrackingMarkerIR[]; sourceSha256?: string }
  | { type: "setTrackingSolve"; clipId: string; solve: CameraSolveIR; sourceSha256?: string }
  | { type: "setMaskSpline"; maskId: string; layerId: string; spline: MaskSplineIR }
  | { type: "setMaskPoint"; maskId: string; layerId: string; splineId: string; point: MaskPointIR }
  | { type: "setSceneLineSettings"; dataId: string; properties: { mode?: 1 | 2; thickness?: number } }
  | { type: "setSceneViewLayerPassSettings"; dataId: string; layerName: string; properties: { passMask?: number; cryptomatteMask?: number; cryptomatteLevels?: number; alphaThreshold?: number } }
  | { type: "setSceneViewLayerAOVs"; dataId: string; layerName: string; aovs: Array<{ name: string; type: 0 | 1 }> }
  | { type: "setSceneViewLayerLightgroups"; dataId: string; layerName: string; lightgroups: string[] }
  | { type: "clearObjectTransform"; objectId: string; channels: Array<"LOCATION" | "ROTATION" | "SCALE"> }
  | { type: "createObjectData"; objectType: "CAMERA" | "LIGHT" | "EMPTY" | "ARMATURE"; name?: string }
  | { type: "setObjectSelection"; objectId: string; selected: boolean; active?: boolean }
  | { type: "setCollectionVisibility"; collectionId: string; viewportVisible?: boolean; renderVisible?: boolean }
  | { type: "setObjectLightgroup"; objectId: string; lightgroup: string | null }
  | { type: "setWorldLightgroup"; dataId: string; lightgroup: string | null }
  | { type: "setMetaballElements"; dataId: string; elements: Array<{ type: number; position: [number, number, number]; radius: number; scale: [number, number, number] }> }
  | { type: "sculptStroke"; stroke: SculptStrokeIR }
  | { type: "setSculptMeshAttributes"; attributes: SculptMeshAttributesIR }
  | { type: "setGeometryNodeGraph"; meshId: string; graph: GeometryNodeGraphIR }
  | { type: "setPhysicsSimulation"; manifest: PhysicsSimulationManifestIR }
  | { type: "setRigidBodySettings"; objectId: string; family?: "RIGID_BODY" | "SOFT_BODY"; settings: PhysicsRigidBodySettings | PhysicsSoftBodySettings }
  | { type: "setClothSettings"; objectId: string; settings: PhysicsClothSettings }
  | { type: "setFluidSettings"; objectId: string; settings: PhysicsFluidSettings }
  | { type: "setParticleCache"; objectId: string; settings: PhysicsParticleCacheSettings }
  | { type: "setSimulationPlayback"; settings: PhysicsSimulationPlaybackSettings }
  | { type: "setShaderGraph"; materialId: string; graph: ShaderGraphIR }
  | { type: "setNLAStack"; objectId: string; tracks: NlaTrackIR[]; baseRevision?: number }
  | NlaMoveStripCommand
  | { type: "undo" }
  | { type: "redo" };

/** JSON values accepted by the allowlisted native operator bridge. */
export type WebEngineOperatorProperty = BlenderOperatorPropertyValue | null | WebEngineOperatorProperty[] | { [key: string]: WebEngineOperatorProperty };
export type WebEngineOperatorPropertySpec = BlenderOperatorPropertySpec;
export type WebEngineOperatorDescriptor = BlenderOperatorDescriptor;
export type WebEngineOperatorInvocation = BlenderOperatorInvocation;

export type RNAPropertyValue = boolean | number | string | null;
export interface RNADataBlockDescriptor {
  type: string;
  name: string;
  libraryLinked: boolean;
  editable: boolean;
}
export interface RNAPropertyDescriptor {
  identifier: string;
  name: string;
  description?: string;
  type: "BOOLEAN" | "INT" | "FLOAT" | "STRING" | "ENUM" | "COLLECTION";
  subtype?: number;
  arrayLength: number;
  readonly: boolean;
  value?: RNAPropertyValue | RNAPropertyValue[];
  enumItems?: Array<{ identifier: string; name: string; value: number }>;
  collection?: { itemType?: string; nestedPath?: string };
}
export interface RNACollectionDescriptor {
  identifier: string;
  name: string;
  itemType?: string;
  path?: string;
  items: Array<{ name?: string; index?: number; type?: string; items?: Array<unknown> }>;
}

/** Read-only commands supported by the stable Worker-to-WASM JSON facade. */
export type WebEngineJsonCommand =
  | "snapshot"
  | "delta"
  | "depsgraph"
  | "memoryStats"
  | "applyCommand"
  | "undo"
  | "redo"
  | "listBlenderOperators"
  | "invokeBlenderOperator"
  | "listBlenderMacros"
  | "invokeBlenderMacro"
  | "listFeatureRoutes"
  | "invokeFeatureRoute"
  | "assetMark"
  | "assetCatalog"
  | "libraryLink"
  | "libraryOverride"
  | "libraryReload"
  | "listRNADataBlocks"
  | "readRNAProperties"
  | "setRNAProperty"
  | "listRNACollections"
  | "readRNAPropertySchema"
  | "setRNAArrayProperty"
  | "setRNAEnumProperty"
  | "readRNACollection"
  | "importScene"
  | "exportScene";

export type WebEngineRequest =
  | { requestId: string; command: { type: "init" } }
  | { requestId: string; command: { type: "loadWasmModule"; id: string } }
  | { requestId: string; command: { type: "crashForTest" } }
  | { requestId: string; command: { type: "openBlend"; buffer: ArrayBuffer }; }
  | { requestId: string; command: { type: "cancelOpen"; targetRequestId: string } }
  | { requestId: string; command: { type: "openResourceStatus" } }
  | { requestId: string; command: { type: "snapshot" } }
  | { requestId: string; command: { type: "jsonCommand"; cmd: WebEngineJsonCommand; params?: Record<string, unknown> } }
  | { requestId: string; command: { type: "applyCommand"; payload: WebEngineEditCommand } }
  | { requestId: string; command: { type: "appendLibraryObject"; request: LibraryMainAppendRequestIR; source: ArrayBuffer } }
  | { requestId: string; command: { type: "beginPaintStroke"; session: PaintStrokeSessionBeginIR } }
  | { requestId: string; command: { type: "appendPaintStrokeChunk"; chunk: PaintStrokeSessionChunkIR } }
  | { requestId: string; command: { type: "commitPaintStroke"; session: PaintStrokeSessionCommitIR } }
  | { requestId: string; command: { type: "cancelPaintStroke"; session: PaintStrokeSessionCancelIR } }
  | { requestId: string; command: { type: "queryPaintPBVHCapability"; request: PaintPBVHCapabilityRequest } }
  | { requestId: string; command: { type: "generateLOD"; payload: LODGenerationRequest } }
  | { requestId: string; command: { type: "delta" } }
  | { requestId: string; command: { type: "requestAsset"; assetId: string } }
  | { requestId: string; command: { type: "queryRenderCapability"; request: RenderCapabilityRequest } }
  | { requestId: string; command: { type: "queryNonMeshCapability"; dataId: string } }
  | { requestId: string; command: { type: "evaluateDepsgraph" } }
  | { requestId: string; command: { type: "saveBlend" } }
  | { requestId: string; command: { type: "shutdown" } };

export interface WebEngineStatus {
  ready: boolean;
  liveHandles: number;
  allocatedBytes: number;
}

export interface WebEngineOpenResourceStatus {
  activeRequests: number;
  liveInputBytes: number;
  liveNativeHandles: number;
  liveStagingFiles: number;
}

export interface AssetRequestResult {
  assetId: string;
  status: "external" | "packed" | "packed-unavailable" | "missing" | "blocked";
  sourcePath?: string;
  safeSourcePath?: string;
  pathStatus?: "safe" | "blocked";
  errorCode?: "ASSET_PATH_OUTSIDE_PROJECT";
  mimeType?: string;
  width?: number;
  height?: number;
  data?: ArrayBuffer;
}

export interface WebEngineLODLevelResult {
  level: number;
  meshId: string;
  triangleBudget: number;
  outputTriangleCount: number;
  outputVertexCount: number;
  simplify?: SimplifyResult;
  geometryBuffers: MeshGeometryBuffer[];
}

export interface WebEngineLODResult {
  manifest: LODManifest;
  levels: WebEngineLODLevelResult[];
  errors?: WebEngineLODError[];
}

export interface WebEngineLODError {
  requestedLevel: number;
  triangleBudget: number;
  message: string;
}

export interface WebEngineResult {
  status: WebEngineStatus;
  snapshot?: SceneSnapshotIR;
  geometryBuffers?: MeshGeometryBuffer[];
  nonMeshGeometryBuffers?: NonMeshGeometryChunk[];
  geometryDelta?: MeshGeometryDelta;
  delta?: SceneDelta;
  simplify?: SimplifyResult;
  lod?: WebEngineLODResult;
  asset?: AssetRequestResult;
  capabilityGate?: CapabilityGateResult;
  json?: unknown;
  shaderCompile?: ShaderCompileReport;
  depsgraph?: DepsgraphEvaluationIR;
  blend?: ArrayBuffer;
  openResources?: WebEngineOpenResourceStatus;
  paintStrokeSession?: PaintStrokeSessionReceiptIR;
  libraryAppend?: LibraryMainAppendReceiptIR;
  wasmModules?: Array<{ id: string; lifecycle: "complete" | "debug"; status: "pending" | "loaded" | "failed"; byteLength: number; error?: string }>;
}

export type WebEngineResponse =
  | { kind: "progress"; requestId: string; progress: ProgressEvent }
  | { kind: "result"; requestId: string; ok: true; result: WebEngineResult }
  | { kind: "result"; requestId: string; ok: false; error: ErrorReport };
import type { CameraSolveIR, MaskPointIR, MaskSplineIR, TrackingMarkerIR } from "./tracking-mask";