@aura3d/engine 4.0.3 → 4.0.4

package/dist/engine/agent-api/nodes/types.d.ts

@@ -27,7 +27,7 @@ export interface AuraProceduralTextureSpec {
     readonly colorA?: AuraColor;
     readonly colorB?: AuraColor;
 }
-export type AuraMaterialTextureInput = AuraAssetRef<"texture"> | AuraProceduralTextureSpec;
+export type AuraMaterialTextureInput = AuraAssetRef<"texture"> | AuraProceduralTextureSpec | AuraTextureRef;
 /**
  * Per-map UV transform for the C1 textured-PBR slots (muse3jsparity-PRD C1).
  * Offset/scale apply in UV units, rotation in radians, matching the native
@@ -102,6 +102,14 @@ export interface AuraTransformSpec {
     readonly rotationOrder?: import("../../contracts/sceneGraph.js").AuraEulerOrder;
     /** C-06 (PR 0a): wins over `rotation` when set. */
     readonly quaternion?: import("../../contracts/sceneGraph.js").AuraQuat;
+    /** Draw-order override; higher renders later (three's Object3D.renderOrder). */
+    readonly renderOrder?: number;
+    /** Opt out of frustum culling for this node (three's Object3D.frustumCulled). */
+    readonly frustumCulled?: boolean;
+    /** Camera/raycast layer membership as a bitmask (three's Layers.mask). */
+    readonly layers?: number;
+    /** Free-form author metadata carried on the node (three's Object3D.userData). */
+    readonly userData?: Record<string, unknown>;
 }
 export interface AuraMaterialSpec {
     readonly name?: string;
@@ -141,6 +149,14 @@ export interface AuraMaterialSpec {
     /** P3 physical-extension bounded warnings, stamped by `material.physical` (muse3jsparity-PRD): surfaced by capability diagnostics, never silent. */
     readonly physicalWarnings?: readonly string[];
     readonly envMapIntensity?: number;
+    /**
+     * threejs-parity L7/SC-01: bind a `cameras.cube` capture as this material's
+     * environment map (three's `material.envMap = cubeRenderTarget.texture`).
+     * `cubeCamera` names the authored `cameras.cube` node.
+     */
+    readonly envMap?: {
+        readonly cubeCamera: string;
+    };
     readonly normal?: AuraMaterialTextureInput;
     readonly normalScale?: number;
     readonly roughnessMap?: AuraMaterialTextureInput;
@@ -220,6 +236,12 @@ export interface AuraMaterialSpec {
     readonly slotSampling?: Partial<Record<import("../../contracts/materials.js").AuraMaterialTextureSlot, import("../../../rendering/contracts/index.js").AuraTextureSampling>>;
     /** PRD 10: emissive practical light scale. */
     readonly practical?: boolean;
+    /** Per-material fog opt-out (SR-02): `false` excludes the material from scene fog (three's Material.fog). */
+    readonly fog?: boolean;
+    /** SH-02 discriminator: `material.custom` emits `kind: "custom"` so the compiler routes to the portable-shader path. */
+    readonly kind?: "custom";
+    /** SH-02 payload: the portable custom-shader spec (see AuraCustomMaterialSpec). */
+    readonly custom?: AuraCustomMaterialSpec;
 }
 export interface AuraEditableMaterialParameters {
     readonly kind: "aura-material-parameters";
@@ -338,8 +360,73 @@ export interface AuraPrimitiveOptions extends AuraTransformSpec {
     readonly geometry?: AuraCustomGeometrySpec;
     readonly text3D?: Omit<AuraText3DGeometry, "geometry">;
     readonly lod?: AuraRootLodSpec;
+    /** threejs-parity SG-03: per-kind generator params for the widened primitive union. */
+    readonly params?: AuraPrimitiveParams;
+}
+/**
+ * threejs-parity SG-03 (docs/workflows/threejs-parity-gaps.md §5.0): union
+ * widened at B. Kinds past `"torus"` compile to a `parity-not-implemented`
+ * (A3D_PARITY_GEOMETRY) validate error until lane L2 lands the generators.
+ */
+export type AuraBuiltinPrimitive = "box" | "sphere" | "plane" | "cylinder" | "capsule" | "torus" | "cone" | "circle" | "ring" | "tube" | "lathe" | "extrude" | "shape" | "torusKnot" | "polyhedron" | "roundedBox";
+/**
+ * threejs-parity SG-03: per-kind generator parameters for the widened
+ * `AuraBuiltinPrimitive` union (three's constructor args, mapped to named
+ * fields). Frozen at B; lane L2 consumes them in `R/geometry/*` generators.
+ */
+export interface AuraPrimitiveParams {
+    readonly radius?: number;
+    readonly radiusTop?: number;
+    readonly radiusBottom?: number;
+    readonly height?: number;
+    readonly radialSegments?: number;
+    readonly heightSegments?: number;
+    readonly widthSegments?: number;
+    /** box depth tessellation. */
+    readonly depthSegments?: number;
+    /** capsule hemisphere ring count. */
+    readonly capSegments?: number;
+    /** cylinder / cone: omit the end caps. */
+    readonly openEnded?: boolean;
+    /** torus tube radius ratio (the torusKnot tube is `tubeRadius`). */
+    readonly tube?: number;
+    readonly innerRadius?: number;
+    readonly outerRadius?: number;
+    readonly thetaStart?: number;
+    readonly thetaLength?: number;
+    readonly thetaSegments?: number;
+    readonly phiStart?: number;
+    readonly phiLength?: number;
+    readonly phiSegments?: number;
+    readonly tubularSegments?: number;
+    /** torusKnot tube radius (three's `tube` arg — renamed to avoid colliding with the `"tube"` kind). */
+    readonly tubeRadius?: number;
+    /** torusKnot winding parameters. */
+    readonly p?: number;
+    readonly q?: number;
+    /** polyhedron subdivision detail. */
+    readonly detail?: number;
+    /** polyhedron variant (covers tetra/octa/icosa/dodecahedron). */
+    readonly variant?: "tetrahedron" | "octahedron" | "icosahedron" | "dodecahedron";
+    /** tube/extrude path — a frozen `Curve` (M/Curves.ts) or an explicit point list. */
+    readonly path?: unknown;
+    /** extrude path override (three's `extrudePath`). */
+    readonly extrudePath?: unknown;
+    /** lathe profile / shape outline points. */
+    readonly points?: readonly AuraVec3[];
+    /** `shape` kind outline — a frozen `Shape` (L3) or point list. */
+    readonly shape?: unknown;
+    /** extrude settings. */
+    readonly depth?: number;
+    readonly steps?: number;
+    readonly bevelEnabled?: boolean;
+    readonly bevelThickness?: number;
+    readonly bevelSize?: number;
+    readonly bevelOffset?: number;
+    readonly bevelSegments?: number;
+    /** closed loop for `tube`. */
+    readonly closed?: boolean;
 }
-export type AuraBuiltinPrimitive = "box" | "sphere" | "plane" | "cylinder" | "capsule" | "torus";
 export interface AuraRootLodLevelSpec {
     readonly name: string;
     readonly maxDistance?: number;
@@ -351,6 +438,22 @@ export interface AuraRootLodSpec {
     readonly levels: readonly AuraRootLodLevelSpec[];
     readonly hysteresis?: number;
 }
+/**
+ * threejs-parity L7/SG-11: mixed-child LOD — each level is an arbitrary node
+ * subtree (primitives, models, nested groups), not just a primitive swap.
+ * Consumed by `groups.lod`; visibility switches per frame in the production
+ * render input (see `lodMarkers.ts`).
+ */
+export interface AuraLodLevelSpec {
+    readonly name?: string;
+    readonly maxDistance?: number;
+    readonly children: readonly AuraNodeInput[];
+}
+export interface AuraLodGroupSpec extends AuraTransformSpec {
+    readonly name?: string;
+    readonly levels: readonly AuraLodLevelSpec[];
+    readonly hysteresis?: number;
+}
 export interface AuraAnimationSpec {
     readonly clip?: string;
     readonly loop?: boolean;
@@ -486,7 +589,7 @@ export interface AuraHelperPerformanceBudget {
     readonly maxBundleBytes?: number;
     readonly evidence: string;
 }
-export type AuraSceneNode = AuraModelNode | AuraPrimitiveNode | AuraGroupNode | AuraLightNode | AuraEffectNode | AuraInteractionNode | AuraLabelNode | AuraEnvironmentNode;
+export type AuraSceneNode = AuraModelNode | AuraPrimitiveNode | AuraGroupNode | AuraLightNode | AuraEffectNode | AuraInteractionNode | AuraLabelNode | AuraEnvironmentNode | AuraLineNode | AuraPointsNode | AuraSpriteNode | AuraBatchedNode | import("./cameras.js").AuraCubeCameraNode | import("./surfaces.js").AuraMirrorSurfaceNode | import("./lensFlare.js").AuraLensFlareNode;
 export interface AuraModelNode extends AuraTransformSpec {
     readonly kind: "model";
     readonly name?: string;
@@ -545,6 +648,8 @@ export interface AuraPrimitiveNode extends AuraTransformSpec {
     readonly geometry?: AuraCustomGeometrySpec;
     readonly text3D?: Omit<AuraText3DGeometry, "geometry">;
     readonly lod?: AuraRootLodSpec;
+    /** threejs-parity SG-03: per-kind generator params for the widened primitive union. */
+    readonly params?: AuraPrimitiveParams;
 }
 export interface AuraGroupNode extends AuraTransformSpec {
     readonly kind: "group";
@@ -554,7 +659,7 @@ export interface AuraGroupNode extends AuraTransformSpec {
     readonly character?: AuraCharacterRigSpec;
     readonly runtime?: AuraRuntimeNodeSpec;
 }
-export type AuraLightType = "ambient" | "directional" | "point" | "studio" | "rect" | "softbox" | "spot" | "hemisphere";
+export type AuraLightType = "ambient" | "directional" | "point" | "studio" | "rect" | "softbox" | "spot" | "hemisphere" | "probe";
 export interface AuraLightNode extends AuraTransformSpec {
     readonly kind: "light";
     readonly light: AuraLightType;
@@ -570,6 +675,13 @@ export interface AuraLightNode extends AuraTransformSpec {
     readonly decay?: number;
     /** C-10 (PR 0a): source power in lumens (point/spot). */
     readonly power?: number;
+    /**
+     * threejs-parity AD-16 (LightProbe): 27 SH9 radiance coefficients,
+     * band-major packing (three's `Vector3[9]` flattened: `sh[band*3+ch]`).
+     * Evaluated along `position`/`target` into a
+     * hemisphere-irradiance contribution by the lighting collector.
+     */
+    readonly sh?: readonly number[];
     /** C-10 (PR 0a): shadow options; boolean stays accepted. */
     readonly shadow?: boolean | import("../../contracts/lighting.js").AuraLocalShadowOptions | import("../../contracts/lighting.js").AuraDirectionalShadowOptions;
 }
@@ -1132,6 +1244,12 @@ export interface AuraCameraSpec {
     readonly near?: number;
     /** Far clipping distance in world units, greater than near; defaults to 100. */
     readonly far?: number;
+    /**
+     * SR-04: three's `camera.layers` as a bitmask. Nodes whose `layers` mask does
+     * not intersect it (runtime handle `.layers`) are absent from the frame.
+     * Unset = no layer filtering.
+     */
+    readonly layers?: number;
     readonly distance?: number;
     readonly from?: AuraVec3;
     readonly to?: AuraVec3;
@@ -1277,15 +1395,44 @@ export interface AuraRendererRuntimeObservation {
         readonly warnings: readonly string[];
     }[];
 }
+/**
+ * threejs-parity L7/SG-10: `scene().background({ texture | cube })` — three's
+ * `scene.background = Texture | CubeTexture`. Painted by the renderer's
+ * environment-background pass; never enables IBL (unlike `scene.environment`).
+ */
+export type AuraSceneBackgroundImage = {
+    /** Equirect 2D texture background — url string or texture asset ref. */
+    readonly texture: AuraMaterialTextureInput | string;
+    readonly intensity?: number;
+    /** Background rotation in radians (three's `backgroundRotation`). */
+    readonly rotation?: number;
+} | {
+    /** Cubemap background — exactly six faces, px nx py ny pz nz order. */
+    readonly cube: {
+        readonly faces: readonly (AuraAssetRef<"texture"> | string)[];
+        readonly intensity?: number;
+        readonly rotation?: number;
+    };
+};
 export interface AuraSceneSnapshot {
     readonly schema: "aura3d-scene-snapshot/1.0";
     readonly background: AuraColor;
+    /**
+     * threejs-parity L7/SG-10: texture/cube background (three's `scene.background`).
+     * Wins over the `background` clear colour once its bitmaps decode.
+     */
+    readonly backgroundImage?: AuraSceneBackgroundImage;
     /**
      * PRD-01 C-05: `scene().background(color, { toneMapped: false })` opt-out —
      * the background shows the authored sRGB colour exactly instead of being
      * tone-mapped with the scene (the default). Omitted unless `false`.
      */
     readonly backgroundToneMapped?: false;
+    /**
+     * threejs-parity SG-10: `scene().overrideMaterial(spec)`. Informational —
+     * `nodes` already carry the override on every mesh-like node.
+     */
+    readonly overrideMaterial?: AuraMaterialSpec;
     readonly camera: AuraCameraSpec;
     readonly timeline?: AuraTimelineSpec;
     readonly physics?: AuraPhysicsSceneSummary;
@@ -2046,6 +2193,242 @@ export interface AuraAssetLoadState {
     readonly provenance?: AuraAssetProvenance;
     readonly message?: string;
 }
+/** ST-01/ST-02 (L4): live texture handle returned by `texture.*`. Field writes apply on the next upload; `needsUpdate` bumps the device revision exactly once. */
+export type AuraTextureWrapMode = "clamp" | "repeat" | "mirror";
+export type AuraTextureMinFilter = "nearest" | "linear" | "nearest-mipmap-nearest" | "linear-mipmap-nearest" | "nearest-mipmap-linear" | "linear-mipmap-linear";
+export type AuraTextureMagFilter = "nearest" | "linear";
+export type AuraTextureColorSpace = "srgb" | "linear";
+export interface AuraTextureRef {
+    readonly kind: "aura-texture-ref";
+    /** Stable handle id — also usable anywhere an `AuraAssetRef<"texture">` id is accepted. */
+    readonly id: string;
+    wrapS: AuraTextureWrapMode;
+    wrapT: AuraTextureWrapMode;
+    repeat: readonly [number, number];
+    offset: readonly [number, number];
+    /** UV rotation in radians around `center`. */
+    rotation: number;
+    center: readonly [number, number];
+    anisotropy: number;
+    minFilter: AuraTextureMinFilter;
+    magFilter: AuraTextureMagFilter;
+    generateMipmaps: boolean;
+    colorSpace: AuraTextureColorSpace;
+    flipY: boolean;
+    /** Set true after mutating pixels/source; cleared by the device once the revision uploads. */
+    needsUpdate: boolean;
+    dispose(): void;
+}
+/** ST-03 (L4): create opts per `texture.*` factory; `source` is the live canvas/video/image. */
+export interface AuraTextureDataOptions {
+    readonly width: number;
+    readonly height: number;
+    readonly data: Uint8Array | Uint8ClampedArray | Float32Array | Uint16Array | Uint32Array;
+    readonly format?: "rgba8" | "rgb8" | "r8" | "rgba16f" | "rgba32f" | "depth24";
+    readonly colorSpace?: AuraTextureColorSpace;
+}
+export interface AuraTextureCanvasOptions {
+    readonly canvas: unknown;
+    readonly colorSpace?: AuraTextureColorSpace;
+    readonly flipY?: boolean;
+}
+export interface AuraTextureVideoOptions {
+    readonly video: unknown;
+    readonly colorSpace?: AuraTextureColorSpace;
+}
+export interface AuraTextureCompressedOptions {
+    readonly mipmaps: readonly {
+        readonly data: Uint8Array;
+        readonly width: number;
+        readonly height: number;
+    }[];
+    readonly format: string;
+}
+export interface AuraTextureDepthOptions {
+    readonly width: number;
+    readonly height: number;
+}
+export interface AuraTextureCubeOptions {
+    readonly faces: readonly unknown[];
+    readonly colorSpace?: AuraTextureColorSpace;
+}
+export interface AuraTextureDataArrayOptions extends Omit<AuraTextureDataOptions, "width" | "height" | "data"> {
+    readonly width: number;
+    readonly height: number;
+    readonly depth: number;
+    readonly data: Uint8Array | Float32Array | Uint16Array;
+}
+export interface AuraTextureLoadOptions {
+    readonly colorSpace?: AuraTextureColorSpace;
+    readonly flipY?: boolean;
+    readonly anisotropy?: number;
+}
+export type AuraCustomUniformType = "f32" | "i32" | "bool" | "vec2" | "vec3" | "vec4" | "color3" | "mat3" | "mat4" | "texture2d";
+/** Uniform spec: bare type name, or `{ type, value }` for an initial value. */
+export type AuraCustomUniformSpec = AuraCustomUniformType | {
+    readonly type: AuraCustomUniformType;
+    readonly value?: unknown;
+};
+/** Runtime uniform write (handle.setUniform / setPassUniform). */
+export type AuraUniformValue = number | boolean | readonly number[] | AuraVec3 | readonly AuraVec3[] | readonly [number, number] | readonly [number, number, number, number] | Float32Array | Int32Array | AuraTextureRef;
+/**
+ * SH-02 (L1): `material.custom(spec)` payload. GLSL is required —
+ * `createAuraApp` mounts WebGL2 (PRD C2); `wgsl` is optional and runs only on
+ * the WebGPU backend. A WGSL-only spec must fail `validate` (binding rule
+ * 1.4.2). `patch` (SH-09) replaces named shader chunks and salts the cache key.
+ */
+export interface AuraCustomMaterialSpec {
+    readonly glsl: {
+        readonly vertex?: string;
+        readonly fragment: string;
+    };
+    readonly wgsl?: {
+        readonly vertex?: string;
+        readonly fragment?: string;
+    };
+    readonly uniforms?: Readonly<Record<string, AuraCustomUniformSpec>>;
+    readonly defines?: Readonly<Record<string, string | number | boolean>>;
+    readonly transparent?: boolean;
+    readonly depthWrite?: boolean;
+    readonly depthTest?: boolean;
+    readonly side?: "front" | "back" | "double";
+    readonly blending?: "normal" | "additive" | "subtractive" | "multiply" | "custom";
+    readonly fog?: boolean;
+    /** SH-09: `#include <name>` chunk replacement map; salts the program cache key. */
+    readonly patch?: Readonly<Record<string, string>>;
+}
+export type AuraIndexArray = Uint16Array | Uint32Array | readonly number[];
+export type AuraAttributeArray = Float32Array | readonly number[] | readonly AuraVec3[] | readonly (readonly [number, number])[];
+/** SG-05 (L2): `geometry.dynamic(spec)` / `handle.setGeometry(spec)` — accepts typed arrays or tuples. */
+export interface AuraDynamicGeometrySpec {
+    readonly positions: Float32Array | readonly number[] | readonly AuraVec3[];
+    readonly normals?: Float32Array | readonly number[] | readonly AuraVec3[];
+    readonly uvs?: Float32Array | readonly (readonly [number, number])[];
+    readonly colors?: Float32Array | readonly AuraColor[];
+    readonly indices?: AuraIndexArray;
+    /** R-23: author-named per-vertex attributes (three `setAttribute(name, BufferAttribute)`), bound by name in `material.custom` GLSL. */
+    readonly attributes?: Readonly<Record<string, {
+        readonly itemSize: 1 | 2 | 3 | 4;
+        readonly data: Float32Array | readonly number[];
+    }>>;
+    /** R-23: `"points"` draws one point per vertex (three `Points`); the vertex shader sets gl_PointSize. */
+    readonly topology?: "triangles" | "points";
+    readonly groups?: readonly {
+        readonly start: number;
+        readonly count: number;
+        readonly materialIndex?: number;
+    }[];
+    readonly drawRange?: {
+        readonly start: number;
+        readonly count: number;
+    };
+    readonly morphTargets?: readonly {
+        readonly name?: string;
+        readonly positions: Float32Array | readonly number[];
+    }[];
+}
+/** SG-05: per-frame partial attribute write; never reallocates when length is unchanged. */
+export interface AuraAttributeUpdate {
+    readonly array: Float32Array | Uint16Array | Uint32Array | Int32Array | readonly number[];
+    /** Element offset into the attribute (default 0). */
+    readonly offset?: number;
+}
+/** three's `Layers` shape, frozen for the node handle (SR-04). */
+export interface AuraLayerMask {
+    mask: number;
+    set(channel: number): void;
+    enable(channel: number): void;
+    enableAll(): void;
+    disable(channel: number): void;
+    disableAll(): void;
+    toggle(channel: number): void;
+    test(layers: AuraLayerMask | {
+        mask: number;
+    }): boolean;
+    isEnabled(channel: number): boolean;
+}
+/** SG-06/AD-08 (L6): `lines.line/loop/segments/fat`. Compile → `parity-not-implemented` until L6 lands. */
+export interface AuraLineNode extends AuraTransformSpec {
+    readonly kind: "line";
+    readonly line: "line" | "loop" | "segments" | "fat";
+    readonly name?: string;
+    readonly positions: readonly AuraVec3[] | readonly number[] | Float32Array;
+    /** Per-point colors; presence enables vertex coloring. */
+    readonly colors?: readonly AuraColor[];
+    readonly material?: AuraMaterialSpec;
+    /** `fat` only: pixel width (worldUnits:false) or world width (true). */
+    readonly width?: number;
+    readonly worldUnits?: boolean;
+    readonly dashed?: boolean;
+    readonly dashSize?: number;
+    readonly gapSize?: number;
+    readonly dashOffset?: number;
+    readonly visible?: boolean;
+    readonly runtime?: AuraRuntimeNodeSpec;
+}
+/** SG-07 (L6): `points({...})`. Compile → `parity-not-implemented` until L6 lands. */
+export interface AuraPointsNode extends AuraTransformSpec {
+    readonly kind: "points";
+    readonly name?: string;
+    readonly positions: readonly AuraVec3[] | readonly number[] | Float32Array;
+    readonly colors?: readonly AuraColor[];
+    readonly size?: number;
+    readonly sizeAttenuation?: boolean;
+    readonly map?: AuraMaterialTextureInput;
+    readonly alphaTest?: number;
+    readonly transparent?: boolean;
+    readonly material?: AuraMaterialSpec;
+    readonly visible?: boolean;
+    readonly runtime?: AuraRuntimeNodeSpec;
+}
+/** SG-08 (L6): `sprites.sprite({...})`. Compile → `parity-not-implemented` until L6 lands. */
+export interface AuraSpriteNode extends AuraTransformSpec {
+    readonly kind: "sprite";
+    readonly name?: string;
+    readonly map?: AuraMaterialTextureInput;
+    /** Anchor point in [0,1]² (three's Sprite.center; default [0.5, 0.5]). */
+    readonly center?: readonly [number, number];
+    /** Screen-plane rotation in radians (three's SpriteMaterial.rotation). */
+    readonly spriteRotation?: number;
+    readonly sizeAttenuation?: boolean;
+    readonly color?: AuraColor;
+    readonly material?: AuraMaterialSpec;
+    readonly visible?: boolean;
+    readonly runtime?: AuraRuntimeNodeSpec;
+}
+/**
+ * SG-02 (L5): `batched.mesh({...})` — multi-geometry instancing. Rendered by
+ * `batchedNodeHandler` under `A3D_PARITY_BATCHING` (flag off → the flag-off
+ * `parityPending` default keeps the `parity-not-implemented` validate error).
+ */
+export interface AuraBatchedNode extends AuraTransformSpec {
+    readonly kind: "batched";
+    readonly name?: string;
+    /**
+     * Stable id binding the node to its `BatchedMeshState` (builder clones
+     * spread-copy the node, so the id — not object identity — is the key).
+     * `batched.mesh` generates one; authored nodes may omit it (then
+     * `runtime.id` binds, else a fresh id materializes at compile).
+     */
+    readonly batchedId?: string;
+    readonly maxInstances: number;
+    readonly maxVertices?: number;
+    readonly maxIndices?: number;
+    readonly material?: AuraMaterialSpec;
+    /**
+     * Draw route: "auto" = packed multi-draw on the generated-program path,
+     * per-geometry instancing elsewhere; "multi-draw"/"loop" request the packed
+     * route explicitly (degrading to "instanced" when unavailable); "instanced"
+     * forces one draw per geometry.
+     */
+    readonly multiDraw?: "auto" | "multi-draw" | "loop" | "instanced";
+    /** Initial geometry pool entries (primitives by name, or custom geometry). */
+    readonly geometries?: readonly (AuraBuiltinPrimitive | AuraCustomGeometrySpec)[];
+    readonly instances?: readonly AuraTransformSpec[];
+    readonly instanceColors?: readonly AuraColor[];
+    readonly visible?: boolean;
+    readonly runtime?: AuraRuntimeNodeSpec;
+}
 import type { AuraCreateAppOptions, AuraSceneEvidence } from "./types/runtime.js";
 export type { AuraSceneEvidence, AuraFrameInfo, AuraFrameCallback, AuraRuntimeNodeSnapshot, AuraRuntimeNodeHandle, AuraRuntimeNodeImportedAssetEvidence, AuraRuntimeNodeImportedAssetDiagnostic, AuraRuntimeNodeImportedAssetEvidenceInput, AuraRuntimeNodeRegistry, AuraRuntimeState, AuraApp, AuraCreateAppOptions, AuraCreateGameAppOptions, AuraDiagnosticsOptions, AuraScreenshot, AuraAppTarget, AuraAppRegistry, WebGLRenderController, ProductionRuntimeActorEntry, ProductionRuntimePrimitiveEntry, ProductionRuntimePrimitiveResource, ProductionRuntimePrimitiveState, ProductionRuntimeLightDescriptor, AuraFountainParticleLayer, WebGLSceneRenderer, WebGLModel } from "./types/runtime.js";
 //# sourceMappingURL=types.d.ts.map