@adobe/data-gpu 0.9.83 → 0.9.84

package/dist/graphics/picking/picking-plugin.d.ts

@@ -307,6 +307,47 @@ export declare const picking: {
                 weights: Float32Array;
             } | null;
         };
+    } & {
+        readonly animationClipTracks: {
+            readonly default: import("../animation/animation-track/public.js")[];
+        };
+        readonly animationClipDuration: {
+            readonly type: "number";
+            readonly precision: 2;
+            readonly default: number;
+        };
+        readonly animationClipRef: {
+            readonly type: "integer";
+            readonly minimum: -2147483648;
+            readonly maximum: 2147483647;
+            readonly default: number;
+        };
+        readonly animationTargets: {
+            readonly default: number[];
+        };
+        readonly animationTime: {
+            readonly type: "number";
+            readonly precision: 2;
+            readonly default: number;
+        };
+        readonly animationSpeed: {
+            readonly default: 1;
+            readonly type: "number";
+            readonly precision: 1;
+        };
+        readonly animationLoop: {
+            readonly type: "boolean";
+            readonly default: boolean;
+        };
+        readonly animationPlaying: {
+            readonly type: "boolean";
+            readonly default: boolean;
+        };
+        readonly animationObservable: {
+            readonly type: "boolean";
+            readonly const: true;
+            readonly default: true;
+        };
     } & {
         readonly _vertexBuffer: {
             readonly default: GPUBuffer | null;
@@ -372,47 +413,6 @@ export declare const picking: {
             readonly default: GPUBindGroup | null;
             readonly nonPersistent: true;
         };
-    } & {
-        readonly animationClipTracks: {
-            readonly default: import("../animation/animation-track/public.js")[];
-        };
-        readonly animationClipDuration: {
-            readonly type: "number";
-            readonly precision: 2;
-            readonly default: number;
-        };
-        readonly animationClipRef: {
-            readonly type: "integer";
-            readonly minimum: -2147483648;
-            readonly maximum: 2147483647;
-            readonly default: number;
-        };
-        readonly animationTargets: {
-            readonly default: number[];
-        };
-        readonly animationTime: {
-            readonly type: "number";
-            readonly precision: 2;
-            readonly default: number;
-        };
-        readonly animationSpeed: {
-            readonly default: 1;
-            readonly type: "number";
-            readonly precision: 1;
-        };
-        readonly animationLoop: {
-            readonly type: "boolean";
-            readonly default: boolean;
-        };
-        readonly animationPlaying: {
-            readonly type: "boolean";
-            readonly default: boolean;
-        };
-        readonly animationObservable: {
-            readonly type: "boolean";
-            readonly const: true;
-            readonly default: true;
-        };
     } & {
         readonly pickable: {
             readonly type: "boolean";
@@ -488,18 +488,18 @@ export declare const picking: {
         readonly SkinnedMesh: readonly ["localBounds", "skinJointTemplate", "skinInverseBindMatrices", "animationClipRefs"];
         readonly MeshInstance: readonly ["mesh", "position", "rotation", "scale", "visible", "material"];
         readonly Model: readonly ["mesh", "position", "rotation", "scale", "visible", "parent"];
-    } & {
-        readonly _VisibleMaterial: readonly ["nonPersistent", "_materialBindGroup", "_mesh"];
-        readonly _PbrPrimitive: readonly ["nonPersistent", "_vertexBuffer", "_skinVertexBuffer", "_indexBuffer", "_indexCount", "_indexFormat", "_material", "_mesh", "_nodeLocalMatrix"];
     } & {
         readonly AnimationClip: readonly ["animationClipTracks", "animationClipDuration"];
         readonly Animation: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying"];
         readonly AnimationObservable: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying", "animationObservable"];
-    } & {} & {} & {
+    } & {} & {
+        readonly _VisibleMaterial: readonly ["nonPersistent", "_materialBindGroup", "_mesh"];
+        readonly _PbrPrimitive: readonly ["nonPersistent", "_vertexBuffer", "_skinVertexBuffer", "_indexBuffer", "_indexCount", "_indexFormat", "_material", "_mesh", "_nodeLocalMatrix"];
+    } & {} & {
         readonly PickableModel: readonly ["mesh", "position", "rotation", "scale", "visible", "parent", "pickable"];
     } & {};
     readonly transactions: {} & {} & {
-        readonly setCanvas: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{}>, import("@adobe/data/schema").FromSchemas<{
+        readonly setCanvas: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{}>, import("@adobe/data/schema").FromSchemas<{
             readonly renderPassEncoder: {
                 readonly default: GPURenderPassEncoder | null;
                 readonly nonPersistent: true;
@@ -546,9 +546,9 @@ export declare const picking: {
                 readonly default: GPUCommandEncoder | null;
                 readonly nonPersistent: true;
             };
-        }>, {}, {}>, canvas: HTMLCanvasElement | null) => void;
+        }>, {}, {}, never>, canvas: HTMLCanvasElement | null) => void;
     } & {} & {} & {} & {
-        readonly insertMaterial: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{
+        readonly insertMaterial: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{
             readonly material: {
                 readonly type: "integer";
                 readonly minimum: -2147483648;
@@ -725,8 +725,8 @@ export declare const picking: {
                 readonly unique: true;
                 readonly archetype: "Material";
             };
-        }>, row: import("../../material/public.js")) => number;
-        readonly insertMaterialDefinition: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{
+        }, never>, row: import("../../material/public.js")) => number;
+        readonly insertMaterialDefinition: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{
             readonly material: {
                 readonly type: "integer";
                 readonly minimum: -2147483648;
@@ -903,11 +903,11 @@ export declare const picking: {
                 readonly unique: true;
                 readonly archetype: "Material";
             };
-        }>, args: {
+        }, never>, args: {
             name: string;
             definition: import("../../material/material-definition.js").MaterialDefinition;
         }) => number;
-        readonly insertMaterialDefinitions: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{
+        readonly insertMaterialDefinitions: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{
             readonly material: {
                 readonly type: "integer";
                 readonly minimum: -2147483648;
@@ -1084,8 +1084,8 @@ export declare const picking: {
                 readonly unique: true;
                 readonly archetype: "Material";
             };
-        }>, defs: Readonly<Record<string, import("../../material/material-definition.js").MaterialDefinition>>) => void;
-        readonly seedStandardMaterials: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{
+        }, never>, defs: Readonly<Record<string, import("../../material/material-definition.js").MaterialDefinition>>) => void;
+        readonly seedStandardMaterials: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{
             readonly material: {
                 readonly type: "integer";
                 readonly minimum: -2147483648;
@@ -1262,8 +1262,8 @@ export declare const picking: {
                 readonly unique: true;
                 readonly archetype: "Material";
             };
-        }>) => void;
-        readonly seedDefinitionMaterials: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{
+        }, never>) => void;
+        readonly seedDefinitionMaterials: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{
             readonly material: {
                 readonly type: "integer";
                 readonly minimum: -2147483648;
@@ -1440,9 +1440,9 @@ export declare const picking: {
                 readonly unique: true;
                 readonly archetype: "Material";
             };
-        }>) => void;
+        }, never>) => void;
     } & {
-        readonly insertGltfMesh: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{
+        readonly insertGltfMesh: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{
             readonly mesh: {
                 readonly type: "integer";
                 readonly minimum: -2147483648;
@@ -1773,10 +1773,10 @@ export declare const picking: {
                 readonly unique: true;
                 readonly archetype: "Material";
             };
-        }>, args: {
+        }, never>, args: {
             url: string;
         }) => number;
-        readonly insertShapeMesh: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{
+        readonly insertShapeMesh: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{
             readonly mesh: {
                 readonly type: "integer";
                 readonly minimum: -2147483648;
@@ -2107,10 +2107,10 @@ export declare const picking: {
                 readonly unique: true;
                 readonly archetype: "Material";
             };
-        }>, args: {
+        }, never>, args: {
             shapeSpec: import("../public.js").ShapeSpec;
         }) => number;
-        readonly insertMeshInstance: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{
+        readonly insertMeshInstance: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{
             readonly mesh: {
                 readonly type: "integer";
                 readonly minimum: -2147483648;
@@ -2441,14 +2441,14 @@ export declare const picking: {
                 readonly unique: true;
                 readonly archetype: "Material";
             };
-        }>, args: {
+        }, never>, args: {
             mesh: number;
             material: number;
             position?: import("@adobe/data/math").Vec3;
             rotation?: import("@adobe/data/math").Quat;
             scale?: import("@adobe/data/math").Vec3;
         }) => number;
-        readonly insertModel: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{
+        readonly insertModel: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{
             readonly mesh: {
                 readonly type: "integer";
                 readonly minimum: -2147483648;
@@ -2779,15 +2779,15 @@ export declare const picking: {
                 readonly unique: true;
                 readonly archetype: "Material";
             };
-        }>, args: {
+        }, never>, args: {
             mesh: number;
             position?: import("@adobe/data/math").Vec3;
             rotation?: import("@adobe/data/math").Quat;
             scale?: import("@adobe/data/math").Vec3;
             parent?: number;
         }) => number;
-    } & {} & {} & {
-        readonly insertAnimationClip: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{} & {
+    } & {} & {
+        readonly insertAnimationClip: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{} & {
             readonly animationClipTracks: {
                 readonly default: import("../animation/animation-track/public.js")[];
             };
@@ -2832,11 +2832,11 @@ export declare const picking: {
             readonly AnimationClip: readonly ["animationClipTracks", "animationClipDuration"];
             readonly Animation: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying"];
             readonly AnimationObservable: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying", "animationObservable"];
-        }, {} & {}>, args: {
+        }, {} & {}, never>, args: {
             tracks: import("../animation/animation-track/public.js")[];
             duration: number;
         }) => number;
-        readonly insertAnimation: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{} & {
+        readonly insertAnimation: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{} & {
             readonly animationClipTracks: {
                 readonly default: import("../animation/animation-track/public.js")[];
             };
@@ -2881,7 +2881,7 @@ export declare const picking: {
             readonly AnimationClip: readonly ["animationClipTracks", "animationClipDuration"];
             readonly Animation: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying"];
             readonly AnimationObservable: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying", "animationObservable"];
-        }, {} & {}>, args: {
+        }, {} & {}, never>, args: {
             animationClipRef: number;
             animationTargets: number[];
             animationTime?: number;
@@ -2935,12 +2935,12 @@ export declare const picking: {
             readonly AnimationClip: readonly ["animationClipTracks", "animationClipDuration"];
             readonly Animation: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying"];
             readonly AnimationObservable: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying", "animationObservable"];
-        }, {}>, args: {
+        }, {}, never>, args: {
             dt: number;
             observable: boolean;
         }) => void;
-    } & {} & {
-        readonly insertLoadedPrimitives: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{} & {
+    } & {} & {} & {
+        readonly insertLoadedPrimitives: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{} & {
             readonly visible: {
                 readonly type: "boolean";
                 readonly const: true;
@@ -3244,6 +3244,47 @@ export declare const picking: {
                     weights: Float32Array;
                 } | null;
             };
+        } & {
+            readonly animationClipTracks: {
+                readonly default: import("../animation/animation-track/public.js")[];
+            };
+            readonly animationClipDuration: {
+                readonly type: "number";
+                readonly precision: 2;
+                readonly default: number;
+            };
+            readonly animationClipRef: {
+                readonly type: "integer";
+                readonly minimum: -2147483648;
+                readonly maximum: 2147483647;
+                readonly default: number;
+            };
+            readonly animationTargets: {
+                readonly default: number[];
+            };
+            readonly animationTime: {
+                readonly type: "number";
+                readonly precision: 2;
+                readonly default: number;
+            };
+            readonly animationSpeed: {
+                readonly default: 1;
+                readonly type: "number";
+                readonly precision: 1;
+            };
+            readonly animationLoop: {
+                readonly type: "boolean";
+                readonly default: boolean;
+            };
+            readonly animationPlaying: {
+                readonly type: "boolean";
+                readonly default: boolean;
+            };
+            readonly animationObservable: {
+                readonly type: "boolean";
+                readonly const: true;
+                readonly default: true;
+            };
         } & {
             readonly _vertexBuffer: {
                 readonly default: GPUBuffer | null;
@@ -3309,47 +3350,6 @@ export declare const picking: {
                 readonly default: GPUBindGroup | null;
                 readonly nonPersistent: true;
             };
-        } & {
-            readonly animationClipTracks: {
-                readonly default: import("../animation/animation-track/public.js")[];
-            };
-            readonly animationClipDuration: {
-                readonly type: "number";
-                readonly precision: 2;
-                readonly default: number;
-            };
-            readonly animationClipRef: {
-                readonly type: "integer";
-                readonly minimum: -2147483648;
-                readonly maximum: 2147483647;
-                readonly default: number;
-            };
-            readonly animationTargets: {
-                readonly default: number[];
-            };
-            readonly animationTime: {
-                readonly type: "number";
-                readonly precision: 2;
-                readonly default: number;
-            };
-            readonly animationSpeed: {
-                readonly default: 1;
-                readonly type: "number";
-                readonly precision: 1;
-            };
-            readonly animationLoop: {
-                readonly type: "boolean";
-                readonly default: boolean;
-            };
-            readonly animationPlaying: {
-                readonly type: "boolean";
-                readonly default: boolean;
-            };
-            readonly animationObservable: {
-                readonly type: "boolean";
-                readonly const: true;
-                readonly default: true;
-            };
         }>, import("@adobe/data/schema").FromSchemas<{} & {
             readonly _gltfMeshByUrl: {
                 readonly default: Map<string, number> | null;
@@ -3384,14 +3384,14 @@ export declare const picking: {
             readonly SkinnedMesh: readonly ["localBounds", "skinJointTemplate", "skinInverseBindMatrices", "animationClipRefs"];
             readonly MeshInstance: readonly ["mesh", "position", "rotation", "scale", "visible", "material"];
             readonly Model: readonly ["mesh", "position", "rotation", "scale", "visible", "parent"];
-        } & {
-            readonly _VisibleMaterial: readonly ["nonPersistent", "_materialBindGroup", "_mesh"];
-            readonly _PbrPrimitive: readonly ["nonPersistent", "_vertexBuffer", "_skinVertexBuffer", "_indexBuffer", "_indexCount", "_indexFormat", "_material", "_mesh", "_nodeLocalMatrix"];
         } & {
             readonly AnimationClip: readonly ["animationClipTracks", "animationClipDuration"];
             readonly Animation: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying"];
             readonly AnimationObservable: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying", "animationObservable"];
-        } & {}, {} & {} & {
+        } & {} & {
+            readonly _VisibleMaterial: readonly ["nonPersistent", "_materialBindGroup", "_mesh"];
+            readonly _PbrPrimitive: readonly ["nonPersistent", "_vertexBuffer", "_skinVertexBuffer", "_indexBuffer", "_indexCount", "_indexFormat", "_material", "_mesh", "_nodeLocalMatrix"];
+        }, {} & {} & {
             readonly nodeChildrenOf: {
                 readonly key: "parent";
                 readonly archetype: "Node";
@@ -3402,9 +3402,9 @@ export declare const picking: {
                 readonly unique: true;
                 readonly archetype: "Material";
             };
-        } & {} & {} & {} & {} & {}>, args: import("../public.js").LoadedArgs) => void;
+        } & {} & {} & {} & {} & {}, never>, args: import("../public.js").LoadedArgs) => void;
     } & {} & {
-        readonly insertPickableModel: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{
+        readonly insertPickableModel: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{
             readonly pickable: {
                 readonly type: "boolean";
                 readonly const: true;
@@ -3714,6 +3714,47 @@ export declare const picking: {
                     weights: Float32Array;
                 } | null;
             };
+        } & {
+            readonly animationClipTracks: {
+                readonly default: import("../animation/animation-track/public.js")[];
+            };
+            readonly animationClipDuration: {
+                readonly type: "number";
+                readonly precision: 2;
+                readonly default: number;
+            };
+            readonly animationClipRef: {
+                readonly type: "integer";
+                readonly minimum: -2147483648;
+                readonly maximum: 2147483647;
+                readonly default: number;
+            };
+            readonly animationTargets: {
+                readonly default: number[];
+            };
+            readonly animationTime: {
+                readonly type: "number";
+                readonly precision: 2;
+                readonly default: number;
+            };
+            readonly animationSpeed: {
+                readonly default: 1;
+                readonly type: "number";
+                readonly precision: 1;
+            };
+            readonly animationLoop: {
+                readonly type: "boolean";
+                readonly default: boolean;
+            };
+            readonly animationPlaying: {
+                readonly type: "boolean";
+                readonly default: boolean;
+            };
+            readonly animationObservable: {
+                readonly type: "boolean";
+                readonly const: true;
+                readonly default: true;
+            };
         } & {
             readonly _vertexBuffer: {
                 readonly default: GPUBuffer | null;
@@ -3779,47 +3820,6 @@ export declare const picking: {
                 readonly default: GPUBindGroup | null;
                 readonly nonPersistent: true;
             };
-        } & {
-            readonly animationClipTracks: {
-                readonly default: import("../animation/animation-track/public.js")[];
-            };
-            readonly animationClipDuration: {
-                readonly type: "number";
-                readonly precision: 2;
-                readonly default: number;
-            };
-            readonly animationClipRef: {
-                readonly type: "integer";
-                readonly minimum: -2147483648;
-                readonly maximum: 2147483647;
-                readonly default: number;
-            };
-            readonly animationTargets: {
-                readonly default: number[];
-            };
-            readonly animationTime: {
-                readonly type: "number";
-                readonly precision: 2;
-                readonly default: number;
-            };
-            readonly animationSpeed: {
-                readonly default: 1;
-                readonly type: "number";
-                readonly precision: 1;
-            };
-            readonly animationLoop: {
-                readonly type: "boolean";
-                readonly default: boolean;
-            };
-            readonly animationPlaying: {
-                readonly type: "boolean";
-                readonly default: boolean;
-            };
-            readonly animationObservable: {
-                readonly type: "boolean";
-                readonly const: true;
-                readonly default: true;
-            };
         }>, import("@adobe/data/schema").FromSchemas<{} & {
             readonly frameTime: {
                 readonly default: import("../../core/frame-time/public.js");
@@ -3889,14 +3889,14 @@ export declare const picking: {
             readonly SkinnedMesh: readonly ["localBounds", "skinJointTemplate", "skinInverseBindMatrices", "animationClipRefs"];
             readonly MeshInstance: readonly ["mesh", "position", "rotation", "scale", "visible", "material"];
             readonly Model: readonly ["mesh", "position", "rotation", "scale", "visible", "parent"];
-        } & {
-            readonly _VisibleMaterial: readonly ["nonPersistent", "_materialBindGroup", "_mesh"];
-            readonly _PbrPrimitive: readonly ["nonPersistent", "_vertexBuffer", "_skinVertexBuffer", "_indexBuffer", "_indexCount", "_indexFormat", "_material", "_mesh", "_nodeLocalMatrix"];
         } & {
             readonly AnimationClip: readonly ["animationClipTracks", "animationClipDuration"];
             readonly Animation: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying"];
             readonly AnimationObservable: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying", "animationObservable"];
-        } & {} & {}, {} & {} & {
+        } & {} & {
+            readonly _VisibleMaterial: readonly ["nonPersistent", "_materialBindGroup", "_mesh"];
+            readonly _PbrPrimitive: readonly ["nonPersistent", "_vertexBuffer", "_skinVertexBuffer", "_indexBuffer", "_indexCount", "_indexFormat", "_material", "_mesh", "_nodeLocalMatrix"];
+        } & {}, {} & {} & {
             readonly nodeChildrenOf: {
                 readonly key: "parent";
                 readonly archetype: "Node";
@@ -3907,7 +3907,7 @@ export declare const picking: {
                 readonly unique: true;
                 readonly archetype: "Material";
             };
-        } & {} & {} & {} & {} & {} & {} & {}>, args: {
+        } & {} & {} & {} & {} & {} & {} & {}, never>, args: {
             mesh: number;
             position?: readonly [number, number, number];
             rotation?: readonly [number, number, number, number];
@@ -3915,7 +3915,7 @@ export declare const picking: {
             parent?: number;
         }) => number;
     } & {};
-    readonly systems: import("@adobe/data/ecs").SystemDeclarations<"transformCreateWorldMatrix" | "transformSystem" | "update" | "_frameTime" | "schedulerSystem" | "input" | "preUpdate" | "postUpdate" | "physics" | "preRender" | "render" | "postRender" | "configureCanvas" | "beginRenderPass" | "endRenderPass" | "updateCameraAspect" | "animationSampleSystem" | "modelLoadSystem" | "worldBoundsCreate" | "worldBoundsSystem">;
+    readonly systems: import("@adobe/data/ecs").SystemDeclarations<"_frameTime" | "update" | "schedulerSystem" | "input" | "preUpdate" | "postUpdate" | "physics" | "preRender" | "render" | "postRender" | "configureCanvas" | "beginRenderPass" | "endRenderPass" | "transformCreateWorldMatrix" | "transformSystem" | "updateCameraAspect" | "animationSampleSystem" | "modelLoadSystem" | "worldBoundsCreate" | "worldBoundsSystem">;
     readonly actions: {
         readonly pickRay: (db: Database<import("@adobe/data/schema").FromSchemas<{} & {
             readonly visible: {
@@ -4221,6 +4221,47 @@ export declare const picking: {
                     weights: Float32Array;
                 } | null;
             };
+        } & {
+            readonly animationClipTracks: {
+                readonly default: import("../animation/animation-track/public.js")[];
+            };
+            readonly animationClipDuration: {
+                readonly type: "number";
+                readonly precision: 2;
+                readonly default: number;
+            };
+            readonly animationClipRef: {
+                readonly type: "integer";
+                readonly minimum: -2147483648;
+                readonly maximum: 2147483647;
+                readonly default: number;
+            };
+            readonly animationTargets: {
+                readonly default: number[];
+            };
+            readonly animationTime: {
+                readonly type: "number";
+                readonly precision: 2;
+                readonly default: number;
+            };
+            readonly animationSpeed: {
+                readonly default: 1;
+                readonly type: "number";
+                readonly precision: 1;
+            };
+            readonly animationLoop: {
+                readonly type: "boolean";
+                readonly default: boolean;
+            };
+            readonly animationPlaying: {
+                readonly type: "boolean";
+                readonly default: boolean;
+            };
+            readonly animationObservable: {
+                readonly type: "boolean";
+                readonly const: true;
+                readonly default: true;
+            };
         } & {
             readonly _vertexBuffer: {
                 readonly default: GPUBuffer | null;
@@ -4275,57 +4316,16 @@ export declare const picking: {
                 readonly maxItems: 16;
                 readonly default: readonly [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
             };
-            readonly _skeletonModelRef: {
-                readonly nonPersistent: true;
-                readonly type: "integer";
-                readonly minimum: -2147483648;
-                readonly maximum: 2147483647;
-                readonly default: number;
-            };
-            readonly _skeletonJointMatrixBindGroup: {
-                readonly default: GPUBindGroup | null;
-                readonly nonPersistent: true;
-            };
-        } & {
-            readonly animationClipTracks: {
-                readonly default: import("../animation/animation-track/public.js")[];
-            };
-            readonly animationClipDuration: {
-                readonly type: "number";
-                readonly precision: 2;
-                readonly default: number;
-            };
-            readonly animationClipRef: {
+            readonly _skeletonModelRef: {
+                readonly nonPersistent: true;
                 readonly type: "integer";
                 readonly minimum: -2147483648;
                 readonly maximum: 2147483647;
                 readonly default: number;
             };
-            readonly animationTargets: {
-                readonly default: number[];
-            };
-            readonly animationTime: {
-                readonly type: "number";
-                readonly precision: 2;
-                readonly default: number;
-            };
-            readonly animationSpeed: {
-                readonly default: 1;
-                readonly type: "number";
-                readonly precision: 1;
-            };
-            readonly animationLoop: {
-                readonly type: "boolean";
-                readonly default: boolean;
-            };
-            readonly animationPlaying: {
-                readonly type: "boolean";
-                readonly default: boolean;
-            };
-            readonly animationObservable: {
-                readonly type: "boolean";
-                readonly const: true;
-                readonly default: true;
+            readonly _skeletonJointMatrixBindGroup: {
+                readonly default: GPUBindGroup | null;
+                readonly nonPersistent: true;
             };
         } & {
             readonly pickable: {
@@ -4400,17 +4400,17 @@ export declare const picking: {
             readonly SkinnedMesh: readonly ["localBounds", "skinJointTemplate", "skinInverseBindMatrices", "animationClipRefs"];
             readonly MeshInstance: readonly ["mesh", "position", "rotation", "scale", "visible", "material"];
             readonly Model: readonly ["mesh", "position", "rotation", "scale", "visible", "parent"];
-        } & {
-            readonly _VisibleMaterial: readonly ["nonPersistent", "_materialBindGroup", "_mesh"];
-            readonly _PbrPrimitive: readonly ["nonPersistent", "_vertexBuffer", "_skinVertexBuffer", "_indexBuffer", "_indexCount", "_indexFormat", "_material", "_mesh", "_nodeLocalMatrix"];
         } & {
             readonly AnimationClip: readonly ["animationClipTracks", "animationClipDuration"];
             readonly Animation: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying"];
             readonly AnimationObservable: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying", "animationObservable"];
-        } & {} & {} & {
+        } & {} & {
+            readonly _VisibleMaterial: readonly ["nonPersistent", "_materialBindGroup", "_mesh"];
+            readonly _PbrPrimitive: readonly ["nonPersistent", "_vertexBuffer", "_skinVertexBuffer", "_indexBuffer", "_indexCount", "_indexFormat", "_material", "_mesh", "_nodeLocalMatrix"];
+        } & {} & {
             readonly PickableModel: readonly ["mesh", "position", "rotation", "scale", "visible", "parent", "pickable"];
         }, import("@adobe/data/ecs").ToTransactionFunctions<{} & {} & {} & {
-            readonly setCanvas: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{}>, import("@adobe/data/schema").FromSchemas<{
+            readonly setCanvas: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{}>, import("@adobe/data/schema").FromSchemas<{
                 readonly renderPassEncoder: {
                     readonly default: GPURenderPassEncoder | null;
                     readonly nonPersistent: true;
@@ -4457,9 +4457,9 @@ export declare const picking: {
                     readonly default: GPUCommandEncoder | null;
                     readonly nonPersistent: true;
                 };
-            }>, {}, {}>, canvas: HTMLCanvasElement | null) => void;
+            }>, {}, {}, never>, canvas: HTMLCanvasElement | null) => void;
         } & {} & {} & {} & {
-            readonly insertMaterial: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{
+            readonly insertMaterial: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{
                 readonly material: {
                     readonly type: "integer";
                     readonly minimum: -2147483648;
@@ -4636,8 +4636,8 @@ export declare const picking: {
                     readonly unique: true;
                     readonly archetype: "Material";
                 };
-            }>, row: import("../../material/public.js")) => number;
-            readonly insertMaterialDefinition: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{
+            }, never>, row: import("../../material/public.js")) => number;
+            readonly insertMaterialDefinition: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{
                 readonly material: {
                     readonly type: "integer";
                     readonly minimum: -2147483648;
@@ -4814,11 +4814,11 @@ export declare const picking: {
                     readonly unique: true;
                     readonly archetype: "Material";
                 };
-            }>, args: {
+            }, never>, args: {
                 name: string;
                 definition: import("../../material/material-definition.js").MaterialDefinition;
             }) => number;
-            readonly insertMaterialDefinitions: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{
+            readonly insertMaterialDefinitions: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{
                 readonly material: {
                     readonly type: "integer";
                     readonly minimum: -2147483648;
@@ -4995,8 +4995,8 @@ export declare const picking: {
                     readonly unique: true;
                     readonly archetype: "Material";
                 };
-            }>, defs: Readonly<Record<string, import("../../material/material-definition.js").MaterialDefinition>>) => void;
-            readonly seedStandardMaterials: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{
+            }, never>, defs: Readonly<Record<string, import("../../material/material-definition.js").MaterialDefinition>>) => void;
+            readonly seedStandardMaterials: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{
                 readonly material: {
                     readonly type: "integer";
                     readonly minimum: -2147483648;
@@ -5173,8 +5173,8 @@ export declare const picking: {
                     readonly unique: true;
                     readonly archetype: "Material";
                 };
-            }>) => void;
-            readonly seedDefinitionMaterials: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{
+            }, never>) => void;
+            readonly seedDefinitionMaterials: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{
                 readonly material: {
                     readonly type: "integer";
                     readonly minimum: -2147483648;
@@ -5351,9 +5351,9 @@ export declare const picking: {
                     readonly unique: true;
                     readonly archetype: "Material";
                 };
-            }>) => void;
+            }, never>) => void;
         } & {
-            readonly insertGltfMesh: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{
+            readonly insertGltfMesh: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{
                 readonly mesh: {
                     readonly type: "integer";
                     readonly minimum: -2147483648;
@@ -5684,10 +5684,10 @@ export declare const picking: {
                     readonly unique: true;
                     readonly archetype: "Material";
                 };
-            }>, args: {
+            }, never>, args: {
                 url: string;
             }) => number;
-            readonly insertShapeMesh: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{
+            readonly insertShapeMesh: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{
                 readonly mesh: {
                     readonly type: "integer";
                     readonly minimum: -2147483648;
@@ -6018,10 +6018,10 @@ export declare const picking: {
                     readonly unique: true;
                     readonly archetype: "Material";
                 };
-            }>, args: {
+            }, never>, args: {
                 shapeSpec: import("../public.js").ShapeSpec;
             }) => number;
-            readonly insertMeshInstance: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{
+            readonly insertMeshInstance: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{
                 readonly mesh: {
                     readonly type: "integer";
                     readonly minimum: -2147483648;
@@ -6352,14 +6352,14 @@ export declare const picking: {
                     readonly unique: true;
                     readonly archetype: "Material";
                 };
-            }>, args: {
+            }, never>, args: {
                 mesh: number;
                 material: number;
                 position?: import("@adobe/data/math").Vec3;
                 rotation?: import("@adobe/data/math").Quat;
                 scale?: import("@adobe/data/math").Vec3;
             }) => number;
-            readonly insertModel: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{
+            readonly insertModel: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{
                 readonly mesh: {
                     readonly type: "integer";
                     readonly minimum: -2147483648;
@@ -6690,15 +6690,15 @@ export declare const picking: {
                     readonly unique: true;
                     readonly archetype: "Material";
                 };
-            }>, args: {
+            }, never>, args: {
                 mesh: number;
                 position?: import("@adobe/data/math").Vec3;
                 rotation?: import("@adobe/data/math").Quat;
                 scale?: import("@adobe/data/math").Vec3;
                 parent?: number;
             }) => number;
-        } & {} & {} & {
-            readonly insertAnimationClip: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{} & {
+        } & {} & {
+            readonly insertAnimationClip: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{} & {
                 readonly animationClipTracks: {
                     readonly default: import("../animation/animation-track/public.js")[];
                 };
@@ -6743,11 +6743,11 @@ export declare const picking: {
                 readonly AnimationClip: readonly ["animationClipTracks", "animationClipDuration"];
                 readonly Animation: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying"];
                 readonly AnimationObservable: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying", "animationObservable"];
-            }, {} & {}>, args: {
+            }, {} & {}, never>, args: {
                 tracks: import("../animation/animation-track/public.js")[];
                 duration: number;
             }) => number;
-            readonly insertAnimation: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{} & {
+            readonly insertAnimation: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{} & {
                 readonly animationClipTracks: {
                     readonly default: import("../animation/animation-track/public.js")[];
                 };
@@ -6792,7 +6792,7 @@ export declare const picking: {
                 readonly AnimationClip: readonly ["animationClipTracks", "animationClipDuration"];
                 readonly Animation: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying"];
                 readonly AnimationObservable: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying", "animationObservable"];
-            }, {} & {}>, args: {
+            }, {} & {}, never>, args: {
                 animationClipRef: number;
                 animationTargets: number[];
                 animationTime?: number;
@@ -6846,12 +6846,12 @@ export declare const picking: {
                 readonly AnimationClip: readonly ["animationClipTracks", "animationClipDuration"];
                 readonly Animation: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying"];
                 readonly AnimationObservable: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying", "animationObservable"];
-            }, {}>, args: {
+            }, {}, never>, args: {
                 dt: number;
                 observable: boolean;
             }) => void;
-        } & {} & {
-            readonly insertLoadedPrimitives: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{} & {
+        } & {} & {} & {
+            readonly insertLoadedPrimitives: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{} & {
                 readonly visible: {
                     readonly type: "boolean";
                     readonly const: true;
@@ -7155,6 +7155,47 @@ export declare const picking: {
                         weights: Float32Array;
                     } | null;
                 };
+            } & {
+                readonly animationClipTracks: {
+                    readonly default: import("../animation/animation-track/public.js")[];
+                };
+                readonly animationClipDuration: {
+                    readonly type: "number";
+                    readonly precision: 2;
+                    readonly default: number;
+                };
+                readonly animationClipRef: {
+                    readonly type: "integer";
+                    readonly minimum: -2147483648;
+                    readonly maximum: 2147483647;
+                    readonly default: number;
+                };
+                readonly animationTargets: {
+                    readonly default: number[];
+                };
+                readonly animationTime: {
+                    readonly type: "number";
+                    readonly precision: 2;
+                    readonly default: number;
+                };
+                readonly animationSpeed: {
+                    readonly default: 1;
+                    readonly type: "number";
+                    readonly precision: 1;
+                };
+                readonly animationLoop: {
+                    readonly type: "boolean";
+                    readonly default: boolean;
+                };
+                readonly animationPlaying: {
+                    readonly type: "boolean";
+                    readonly default: boolean;
+                };
+                readonly animationObservable: {
+                    readonly type: "boolean";
+                    readonly const: true;
+                    readonly default: true;
+                };
             } & {
                 readonly _vertexBuffer: {
                     readonly default: GPUBuffer | null;
@@ -7220,47 +7261,6 @@ export declare const picking: {
                     readonly default: GPUBindGroup | null;
                     readonly nonPersistent: true;
                 };
-            } & {
-                readonly animationClipTracks: {
-                    readonly default: import("../animation/animation-track/public.js")[];
-                };
-                readonly animationClipDuration: {
-                    readonly type: "number";
-                    readonly precision: 2;
-                    readonly default: number;
-                };
-                readonly animationClipRef: {
-                    readonly type: "integer";
-                    readonly minimum: -2147483648;
-                    readonly maximum: 2147483647;
-                    readonly default: number;
-                };
-                readonly animationTargets: {
-                    readonly default: number[];
-                };
-                readonly animationTime: {
-                    readonly type: "number";
-                    readonly precision: 2;
-                    readonly default: number;
-                };
-                readonly animationSpeed: {
-                    readonly default: 1;
-                    readonly type: "number";
-                    readonly precision: 1;
-                };
-                readonly animationLoop: {
-                    readonly type: "boolean";
-                    readonly default: boolean;
-                };
-                readonly animationPlaying: {
-                    readonly type: "boolean";
-                    readonly default: boolean;
-                };
-                readonly animationObservable: {
-                    readonly type: "boolean";
-                    readonly const: true;
-                    readonly default: true;
-                };
             }>, import("@adobe/data/schema").FromSchemas<{} & {
                 readonly _gltfMeshByUrl: {
                     readonly default: Map<string, number> | null;
@@ -7295,14 +7295,14 @@ export declare const picking: {
                 readonly SkinnedMesh: readonly ["localBounds", "skinJointTemplate", "skinInverseBindMatrices", "animationClipRefs"];
                 readonly MeshInstance: readonly ["mesh", "position", "rotation", "scale", "visible", "material"];
                 readonly Model: readonly ["mesh", "position", "rotation", "scale", "visible", "parent"];
-            } & {
-                readonly _VisibleMaterial: readonly ["nonPersistent", "_materialBindGroup", "_mesh"];
-                readonly _PbrPrimitive: readonly ["nonPersistent", "_vertexBuffer", "_skinVertexBuffer", "_indexBuffer", "_indexCount", "_indexFormat", "_material", "_mesh", "_nodeLocalMatrix"];
             } & {
                 readonly AnimationClip: readonly ["animationClipTracks", "animationClipDuration"];
                 readonly Animation: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying"];
                 readonly AnimationObservable: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying", "animationObservable"];
-            } & {}, {} & {} & {
+            } & {} & {
+                readonly _VisibleMaterial: readonly ["nonPersistent", "_materialBindGroup", "_mesh"];
+                readonly _PbrPrimitive: readonly ["nonPersistent", "_vertexBuffer", "_skinVertexBuffer", "_indexBuffer", "_indexCount", "_indexFormat", "_material", "_mesh", "_nodeLocalMatrix"];
+            }, {} & {} & {
                 readonly nodeChildrenOf: {
                     readonly key: "parent";
                     readonly archetype: "Node";
@@ -7313,9 +7313,9 @@ export declare const picking: {
                     readonly unique: true;
                     readonly archetype: "Material";
                 };
-            } & {} & {} & {} & {} & {}>, args: import("../public.js").LoadedArgs) => void;
+            } & {} & {} & {} & {} & {}, never>, args: import("../public.js").LoadedArgs) => void;
         } & {} & {
-            readonly insertPickableModel: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{
+            readonly insertPickableModel: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{
                 readonly pickable: {
                     readonly type: "boolean";
                     readonly const: true;
@@ -7625,6 +7625,47 @@ export declare const picking: {
                         weights: Float32Array;
                     } | null;
                 };
+            } & {
+                readonly animationClipTracks: {
+                    readonly default: import("../animation/animation-track/public.js")[];
+                };
+                readonly animationClipDuration: {
+                    readonly type: "number";
+                    readonly precision: 2;
+                    readonly default: number;
+                };
+                readonly animationClipRef: {
+                    readonly type: "integer";
+                    readonly minimum: -2147483648;
+                    readonly maximum: 2147483647;
+                    readonly default: number;
+                };
+                readonly animationTargets: {
+                    readonly default: number[];
+                };
+                readonly animationTime: {
+                    readonly type: "number";
+                    readonly precision: 2;
+                    readonly default: number;
+                };
+                readonly animationSpeed: {
+                    readonly default: 1;
+                    readonly type: "number";
+                    readonly precision: 1;
+                };
+                readonly animationLoop: {
+                    readonly type: "boolean";
+                    readonly default: boolean;
+                };
+                readonly animationPlaying: {
+                    readonly type: "boolean";
+                    readonly default: boolean;
+                };
+                readonly animationObservable: {
+                    readonly type: "boolean";
+                    readonly const: true;
+                    readonly default: true;
+                };
             } & {
                 readonly _vertexBuffer: {
                     readonly default: GPUBuffer | null;
@@ -7690,47 +7731,6 @@ export declare const picking: {
                     readonly default: GPUBindGroup | null;
                     readonly nonPersistent: true;
                 };
-            } & {
-                readonly animationClipTracks: {
-                    readonly default: import("../animation/animation-track/public.js")[];
-                };
-                readonly animationClipDuration: {
-                    readonly type: "number";
-                    readonly precision: 2;
-                    readonly default: number;
-                };
-                readonly animationClipRef: {
-                    readonly type: "integer";
-                    readonly minimum: -2147483648;
-                    readonly maximum: 2147483647;
-                    readonly default: number;
-                };
-                readonly animationTargets: {
-                    readonly default: number[];
-                };
-                readonly animationTime: {
-                    readonly type: "number";
-                    readonly precision: 2;
-                    readonly default: number;
-                };
-                readonly animationSpeed: {
-                    readonly default: 1;
-                    readonly type: "number";
-                    readonly precision: 1;
-                };
-                readonly animationLoop: {
-                    readonly type: "boolean";
-                    readonly default: boolean;
-                };
-                readonly animationPlaying: {
-                    readonly type: "boolean";
-                    readonly default: boolean;
-                };
-                readonly animationObservable: {
-                    readonly type: "boolean";
-                    readonly const: true;
-                    readonly default: true;
-                };
             }>, import("@adobe/data/schema").FromSchemas<{} & {
                 readonly frameTime: {
                     readonly default: import("../../core/frame-time/public.js");
@@ -7800,14 +7800,14 @@ export declare const picking: {
                 readonly SkinnedMesh: readonly ["localBounds", "skinJointTemplate", "skinInverseBindMatrices", "animationClipRefs"];
                 readonly MeshInstance: readonly ["mesh", "position", "rotation", "scale", "visible", "material"];
                 readonly Model: readonly ["mesh", "position", "rotation", "scale", "visible", "parent"];
-            } & {
-                readonly _VisibleMaterial: readonly ["nonPersistent", "_materialBindGroup", "_mesh"];
-                readonly _PbrPrimitive: readonly ["nonPersistent", "_vertexBuffer", "_skinVertexBuffer", "_indexBuffer", "_indexCount", "_indexFormat", "_material", "_mesh", "_nodeLocalMatrix"];
             } & {
                 readonly AnimationClip: readonly ["animationClipTracks", "animationClipDuration"];
                 readonly Animation: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying"];
                 readonly AnimationObservable: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying", "animationObservable"];
-            } & {} & {}, {} & {} & {
+            } & {} & {
+                readonly _VisibleMaterial: readonly ["nonPersistent", "_materialBindGroup", "_mesh"];
+                readonly _PbrPrimitive: readonly ["nonPersistent", "_vertexBuffer", "_skinVertexBuffer", "_indexBuffer", "_indexCount", "_indexFormat", "_material", "_mesh", "_nodeLocalMatrix"];
+            } & {}, {} & {} & {
                 readonly nodeChildrenOf: {
                     readonly key: "parent";
                     readonly archetype: "Node";
@@ -7818,14 +7818,14 @@ export declare const picking: {
                     readonly unique: true;
                     readonly archetype: "Material";
                 };
-            } & {} & {} & {} & {} & {} & {} & {}>, args: {
+            } & {} & {} & {} & {} & {} & {} & {}, never>, args: {
                 mesh: number;
                 position?: readonly [number, number, number];
                 rotation?: readonly [number, number, number, number];
                 scale?: readonly [number, number, number];
                 parent?: number;
             }) => number;
-        }>, "transformCreateWorldMatrix" | "transformSystem" | "update" | "_frameTime" | "schedulerSystem" | "input" | "preUpdate" | "postUpdate" | "physics" | "preRender" | "render" | "postRender" | "configureCanvas" | "beginRenderPass" | "endRenderPass" | "updateCameraAspect" | "animationSampleSystem" | "modelLoadSystem" | "worldBoundsCreate" | "worldBoundsSystem", import("@adobe/data/ecs").ToActionFunctions<{}>, import("@adobe/data/ecs").FromServiceFactories<{}>, import("@adobe/data/ecs").FromComputedFactories<{}>, {} & {} & {
+        }>, "_frameTime" | "update" | "schedulerSystem" | "input" | "preUpdate" | "postUpdate" | "physics" | "preRender" | "render" | "postRender" | "configureCanvas" | "beginRenderPass" | "endRenderPass" | "transformCreateWorldMatrix" | "transformSystem" | "updateCameraAspect" | "animationSampleSystem" | "modelLoadSystem" | "worldBoundsCreate" | "worldBoundsSystem", import("@adobe/data/ecs").ToActionFunctions<{}>, import("@adobe/data/ecs").FromServiceFactories<{}>, import("@adobe/data/ecs").FromComputedFactories<{}>, {} & {} & {
             readonly nodeChildrenOf: {
                 readonly key: "parent";
                 readonly archetype: "Node";
@@ -7836,7 +7836,7 @@ export declare const picking: {
                 readonly unique: true;
                 readonly archetype: "Material";
             };
-        } & {} & {} & {} & {} & {} & {} & {} & {}>, ray: Line3) => PickHit | null;
+        } & {} & {} & {} & {} & {} & {} & {} & {}, never>, ray: Line3) => PickHit | null;
         readonly pickFromScreen: (db: Database<import("@adobe/data/schema").FromSchemas<{} & {
             readonly visible: {
                 readonly type: "boolean";
@@ -8128,18 +8128,59 @@ export declare const picking: {
             readonly animationClipRefs: {
                 readonly default: number[];
             };
-            readonly cpuCollisionPositions: {
-                readonly default: Float32Array | null;
+            readonly cpuCollisionPositions: {
+                readonly default: Float32Array | null;
+            };
+            readonly cpuCollisionIndices: {
+                readonly default: Uint32Array | null;
+            };
+            readonly cpuSkin: {
+                readonly default: {
+                    positions: Float32Array;
+                    joints: Uint32Array;
+                    weights: Float32Array;
+                } | null;
+            };
+        } & {
+            readonly animationClipTracks: {
+                readonly default: import("../animation/animation-track/public.js")[];
+            };
+            readonly animationClipDuration: {
+                readonly type: "number";
+                readonly precision: 2;
+                readonly default: number;
+            };
+            readonly animationClipRef: {
+                readonly type: "integer";
+                readonly minimum: -2147483648;
+                readonly maximum: 2147483647;
+                readonly default: number;
+            };
+            readonly animationTargets: {
+                readonly default: number[];
+            };
+            readonly animationTime: {
+                readonly type: "number";
+                readonly precision: 2;
+                readonly default: number;
+            };
+            readonly animationSpeed: {
+                readonly default: 1;
+                readonly type: "number";
+                readonly precision: 1;
             };
-            readonly cpuCollisionIndices: {
-                readonly default: Uint32Array | null;
+            readonly animationLoop: {
+                readonly type: "boolean";
+                readonly default: boolean;
             };
-            readonly cpuSkin: {
-                readonly default: {
-                    positions: Float32Array;
-                    joints: Uint32Array;
-                    weights: Float32Array;
-                } | null;
+            readonly animationPlaying: {
+                readonly type: "boolean";
+                readonly default: boolean;
+            };
+            readonly animationObservable: {
+                readonly type: "boolean";
+                readonly const: true;
+                readonly default: true;
             };
         } & {
             readonly _vertexBuffer: {
@@ -8206,47 +8247,6 @@ export declare const picking: {
                 readonly default: GPUBindGroup | null;
                 readonly nonPersistent: true;
             };
-        } & {
-            readonly animationClipTracks: {
-                readonly default: import("../animation/animation-track/public.js")[];
-            };
-            readonly animationClipDuration: {
-                readonly type: "number";
-                readonly precision: 2;
-                readonly default: number;
-            };
-            readonly animationClipRef: {
-                readonly type: "integer";
-                readonly minimum: -2147483648;
-                readonly maximum: 2147483647;
-                readonly default: number;
-            };
-            readonly animationTargets: {
-                readonly default: number[];
-            };
-            readonly animationTime: {
-                readonly type: "number";
-                readonly precision: 2;
-                readonly default: number;
-            };
-            readonly animationSpeed: {
-                readonly default: 1;
-                readonly type: "number";
-                readonly precision: 1;
-            };
-            readonly animationLoop: {
-                readonly type: "boolean";
-                readonly default: boolean;
-            };
-            readonly animationPlaying: {
-                readonly type: "boolean";
-                readonly default: boolean;
-            };
-            readonly animationObservable: {
-                readonly type: "boolean";
-                readonly const: true;
-                readonly default: true;
-            };
         } & {
             readonly pickable: {
                 readonly type: "boolean";
@@ -8320,17 +8320,17 @@ export declare const picking: {
             readonly SkinnedMesh: readonly ["localBounds", "skinJointTemplate", "skinInverseBindMatrices", "animationClipRefs"];
             readonly MeshInstance: readonly ["mesh", "position", "rotation", "scale", "visible", "material"];
             readonly Model: readonly ["mesh", "position", "rotation", "scale", "visible", "parent"];
-        } & {
-            readonly _VisibleMaterial: readonly ["nonPersistent", "_materialBindGroup", "_mesh"];
-            readonly _PbrPrimitive: readonly ["nonPersistent", "_vertexBuffer", "_skinVertexBuffer", "_indexBuffer", "_indexCount", "_indexFormat", "_material", "_mesh", "_nodeLocalMatrix"];
         } & {
             readonly AnimationClip: readonly ["animationClipTracks", "animationClipDuration"];
             readonly Animation: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying"];
             readonly AnimationObservable: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying", "animationObservable"];
-        } & {} & {} & {
+        } & {} & {
+            readonly _VisibleMaterial: readonly ["nonPersistent", "_materialBindGroup", "_mesh"];
+            readonly _PbrPrimitive: readonly ["nonPersistent", "_vertexBuffer", "_skinVertexBuffer", "_indexBuffer", "_indexCount", "_indexFormat", "_material", "_mesh", "_nodeLocalMatrix"];
+        } & {} & {
             readonly PickableModel: readonly ["mesh", "position", "rotation", "scale", "visible", "parent", "pickable"];
         }, import("@adobe/data/ecs").ToTransactionFunctions<{} & {} & {} & {
-            readonly setCanvas: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{}>, import("@adobe/data/schema").FromSchemas<{
+            readonly setCanvas: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{}>, import("@adobe/data/schema").FromSchemas<{
                 readonly renderPassEncoder: {
                     readonly default: GPURenderPassEncoder | null;
                     readonly nonPersistent: true;
@@ -8377,9 +8377,9 @@ export declare const picking: {
                     readonly default: GPUCommandEncoder | null;
                     readonly nonPersistent: true;
                 };
-            }>, {}, {}>, canvas: HTMLCanvasElement | null) => void;
+            }>, {}, {}, never>, canvas: HTMLCanvasElement | null) => void;
         } & {} & {} & {} & {
-            readonly insertMaterial: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{
+            readonly insertMaterial: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{
                 readonly material: {
                     readonly type: "integer";
                     readonly minimum: -2147483648;
@@ -8556,8 +8556,8 @@ export declare const picking: {
                     readonly unique: true;
                     readonly archetype: "Material";
                 };
-            }>, row: import("../../material/public.js")) => number;
-            readonly insertMaterialDefinition: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{
+            }, never>, row: import("../../material/public.js")) => number;
+            readonly insertMaterialDefinition: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{
                 readonly material: {
                     readonly type: "integer";
                     readonly minimum: -2147483648;
@@ -8734,11 +8734,11 @@ export declare const picking: {
                     readonly unique: true;
                     readonly archetype: "Material";
                 };
-            }>, args: {
+            }, never>, args: {
                 name: string;
                 definition: import("../../material/material-definition.js").MaterialDefinition;
             }) => number;
-            readonly insertMaterialDefinitions: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{
+            readonly insertMaterialDefinitions: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{
                 readonly material: {
                     readonly type: "integer";
                     readonly minimum: -2147483648;
@@ -8915,8 +8915,8 @@ export declare const picking: {
                     readonly unique: true;
                     readonly archetype: "Material";
                 };
-            }>, defs: Readonly<Record<string, import("../../material/material-definition.js").MaterialDefinition>>) => void;
-            readonly seedStandardMaterials: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{
+            }, never>, defs: Readonly<Record<string, import("../../material/material-definition.js").MaterialDefinition>>) => void;
+            readonly seedStandardMaterials: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{
                 readonly material: {
                     readonly type: "integer";
                     readonly minimum: -2147483648;
@@ -9093,8 +9093,8 @@ export declare const picking: {
                     readonly unique: true;
                     readonly archetype: "Material";
                 };
-            }>) => void;
-            readonly seedDefinitionMaterials: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{
+            }, never>) => void;
+            readonly seedDefinitionMaterials: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{
                 readonly material: {
                     readonly type: "integer";
                     readonly minimum: -2147483648;
@@ -9271,9 +9271,9 @@ export declare const picking: {
                     readonly unique: true;
                     readonly archetype: "Material";
                 };
-            }>) => void;
+            }, never>) => void;
         } & {
-            readonly insertGltfMesh: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{
+            readonly insertGltfMesh: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{
                 readonly mesh: {
                     readonly type: "integer";
                     readonly minimum: -2147483648;
@@ -9604,10 +9604,10 @@ export declare const picking: {
                     readonly unique: true;
                     readonly archetype: "Material";
                 };
-            }>, args: {
+            }, never>, args: {
                 url: string;
             }) => number;
-            readonly insertShapeMesh: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{
+            readonly insertShapeMesh: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{
                 readonly mesh: {
                     readonly type: "integer";
                     readonly minimum: -2147483648;
@@ -9938,10 +9938,10 @@ export declare const picking: {
                     readonly unique: true;
                     readonly archetype: "Material";
                 };
-            }>, args: {
+            }, never>, args: {
                 shapeSpec: import("../public.js").ShapeSpec;
             }) => number;
-            readonly insertMeshInstance: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{
+            readonly insertMeshInstance: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{
                 readonly mesh: {
                     readonly type: "integer";
                     readonly minimum: -2147483648;
@@ -10272,14 +10272,14 @@ export declare const picking: {
                     readonly unique: true;
                     readonly archetype: "Material";
                 };
-            }>, args: {
+            }, never>, args: {
                 mesh: number;
                 material: number;
                 position?: import("@adobe/data/math").Vec3;
                 rotation?: import("@adobe/data/math").Quat;
                 scale?: import("@adobe/data/math").Vec3;
             }) => number;
-            readonly insertModel: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{
+            readonly insertModel: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{
                 readonly mesh: {
                     readonly type: "integer";
                     readonly minimum: -2147483648;
@@ -10610,15 +10610,15 @@ export declare const picking: {
                     readonly unique: true;
                     readonly archetype: "Material";
                 };
-            }>, args: {
+            }, never>, args: {
                 mesh: number;
                 position?: import("@adobe/data/math").Vec3;
                 rotation?: import("@adobe/data/math").Quat;
                 scale?: import("@adobe/data/math").Vec3;
                 parent?: number;
             }) => number;
-        } & {} & {} & {
-            readonly insertAnimationClip: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{} & {
+        } & {} & {
+            readonly insertAnimationClip: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{} & {
                 readonly animationClipTracks: {
                     readonly default: import("../animation/animation-track/public.js")[];
                 };
@@ -10663,11 +10663,11 @@ export declare const picking: {
                 readonly AnimationClip: readonly ["animationClipTracks", "animationClipDuration"];
                 readonly Animation: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying"];
                 readonly AnimationObservable: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying", "animationObservable"];
-            }, {} & {}>, args: {
+            }, {} & {}, never>, args: {
                 tracks: import("../animation/animation-track/public.js")[];
                 duration: number;
             }) => number;
-            readonly insertAnimation: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{} & {
+            readonly insertAnimation: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{} & {
                 readonly animationClipTracks: {
                     readonly default: import("../animation/animation-track/public.js")[];
                 };
@@ -10712,7 +10712,7 @@ export declare const picking: {
                 readonly AnimationClip: readonly ["animationClipTracks", "animationClipDuration"];
                 readonly Animation: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying"];
                 readonly AnimationObservable: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying", "animationObservable"];
-            }, {} & {}>, args: {
+            }, {} & {}, never>, args: {
                 animationClipRef: number;
                 animationTargets: number[];
                 animationTime?: number;
@@ -10766,12 +10766,12 @@ export declare const picking: {
                 readonly AnimationClip: readonly ["animationClipTracks", "animationClipDuration"];
                 readonly Animation: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying"];
                 readonly AnimationObservable: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying", "animationObservable"];
-            }, {}>, args: {
+            }, {}, never>, args: {
                 dt: number;
                 observable: boolean;
             }) => void;
-        } & {} & {
-            readonly insertLoadedPrimitives: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{} & {
+        } & {} & {} & {
+            readonly insertLoadedPrimitives: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{} & {
                 readonly visible: {
                     readonly type: "boolean";
                     readonly const: true;
@@ -11075,6 +11075,47 @@ export declare const picking: {
                         weights: Float32Array;
                     } | null;
                 };
+            } & {
+                readonly animationClipTracks: {
+                    readonly default: import("../animation/animation-track/public.js")[];
+                };
+                readonly animationClipDuration: {
+                    readonly type: "number";
+                    readonly precision: 2;
+                    readonly default: number;
+                };
+                readonly animationClipRef: {
+                    readonly type: "integer";
+                    readonly minimum: -2147483648;
+                    readonly maximum: 2147483647;
+                    readonly default: number;
+                };
+                readonly animationTargets: {
+                    readonly default: number[];
+                };
+                readonly animationTime: {
+                    readonly type: "number";
+                    readonly precision: 2;
+                    readonly default: number;
+                };
+                readonly animationSpeed: {
+                    readonly default: 1;
+                    readonly type: "number";
+                    readonly precision: 1;
+                };
+                readonly animationLoop: {
+                    readonly type: "boolean";
+                    readonly default: boolean;
+                };
+                readonly animationPlaying: {
+                    readonly type: "boolean";
+                    readonly default: boolean;
+                };
+                readonly animationObservable: {
+                    readonly type: "boolean";
+                    readonly const: true;
+                    readonly default: true;
+                };
             } & {
                 readonly _vertexBuffer: {
                     readonly default: GPUBuffer | null;
@@ -11140,47 +11181,6 @@ export declare const picking: {
                     readonly default: GPUBindGroup | null;
                     readonly nonPersistent: true;
                 };
-            } & {
-                readonly animationClipTracks: {
-                    readonly default: import("../animation/animation-track/public.js")[];
-                };
-                readonly animationClipDuration: {
-                    readonly type: "number";
-                    readonly precision: 2;
-                    readonly default: number;
-                };
-                readonly animationClipRef: {
-                    readonly type: "integer";
-                    readonly minimum: -2147483648;
-                    readonly maximum: 2147483647;
-                    readonly default: number;
-                };
-                readonly animationTargets: {
-                    readonly default: number[];
-                };
-                readonly animationTime: {
-                    readonly type: "number";
-                    readonly precision: 2;
-                    readonly default: number;
-                };
-                readonly animationSpeed: {
-                    readonly default: 1;
-                    readonly type: "number";
-                    readonly precision: 1;
-                };
-                readonly animationLoop: {
-                    readonly type: "boolean";
-                    readonly default: boolean;
-                };
-                readonly animationPlaying: {
-                    readonly type: "boolean";
-                    readonly default: boolean;
-                };
-                readonly animationObservable: {
-                    readonly type: "boolean";
-                    readonly const: true;
-                    readonly default: true;
-                };
             }>, import("@adobe/data/schema").FromSchemas<{} & {
                 readonly _gltfMeshByUrl: {
                     readonly default: Map<string, number> | null;
@@ -11215,14 +11215,14 @@ export declare const picking: {
                 readonly SkinnedMesh: readonly ["localBounds", "skinJointTemplate", "skinInverseBindMatrices", "animationClipRefs"];
                 readonly MeshInstance: readonly ["mesh", "position", "rotation", "scale", "visible", "material"];
                 readonly Model: readonly ["mesh", "position", "rotation", "scale", "visible", "parent"];
-            } & {
-                readonly _VisibleMaterial: readonly ["nonPersistent", "_materialBindGroup", "_mesh"];
-                readonly _PbrPrimitive: readonly ["nonPersistent", "_vertexBuffer", "_skinVertexBuffer", "_indexBuffer", "_indexCount", "_indexFormat", "_material", "_mesh", "_nodeLocalMatrix"];
             } & {
                 readonly AnimationClip: readonly ["animationClipTracks", "animationClipDuration"];
                 readonly Animation: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying"];
                 readonly AnimationObservable: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying", "animationObservable"];
-            } & {}, {} & {} & {
+            } & {} & {
+                readonly _VisibleMaterial: readonly ["nonPersistent", "_materialBindGroup", "_mesh"];
+                readonly _PbrPrimitive: readonly ["nonPersistent", "_vertexBuffer", "_skinVertexBuffer", "_indexBuffer", "_indexCount", "_indexFormat", "_material", "_mesh", "_nodeLocalMatrix"];
+            }, {} & {} & {
                 readonly nodeChildrenOf: {
                     readonly key: "parent";
                     readonly archetype: "Node";
@@ -11233,9 +11233,9 @@ export declare const picking: {
                     readonly unique: true;
                     readonly archetype: "Material";
                 };
-            } & {} & {} & {} & {} & {}>, args: import("../public.js").LoadedArgs) => void;
+            } & {} & {} & {} & {} & {}, never>, args: import("../public.js").LoadedArgs) => void;
         } & {} & {
-            readonly insertPickableModel: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{
+            readonly insertPickableModel: (t: import("@adobe/data/ecs").Store<import("@adobe/data/schema").FromSchemas<{
                 readonly pickable: {
                     readonly type: "boolean";
                     readonly const: true;
@@ -11545,6 +11545,47 @@ export declare const picking: {
                         weights: Float32Array;
                     } | null;
                 };
+            } & {
+                readonly animationClipTracks: {
+                    readonly default: import("../animation/animation-track/public.js")[];
+                };
+                readonly animationClipDuration: {
+                    readonly type: "number";
+                    readonly precision: 2;
+                    readonly default: number;
+                };
+                readonly animationClipRef: {
+                    readonly type: "integer";
+                    readonly minimum: -2147483648;
+                    readonly maximum: 2147483647;
+                    readonly default: number;
+                };
+                readonly animationTargets: {
+                    readonly default: number[];
+                };
+                readonly animationTime: {
+                    readonly type: "number";
+                    readonly precision: 2;
+                    readonly default: number;
+                };
+                readonly animationSpeed: {
+                    readonly default: 1;
+                    readonly type: "number";
+                    readonly precision: 1;
+                };
+                readonly animationLoop: {
+                    readonly type: "boolean";
+                    readonly default: boolean;
+                };
+                readonly animationPlaying: {
+                    readonly type: "boolean";
+                    readonly default: boolean;
+                };
+                readonly animationObservable: {
+                    readonly type: "boolean";
+                    readonly const: true;
+                    readonly default: true;
+                };
             } & {
                 readonly _vertexBuffer: {
                     readonly default: GPUBuffer | null;
@@ -11610,47 +11651,6 @@ export declare const picking: {
                     readonly default: GPUBindGroup | null;
                     readonly nonPersistent: true;
                 };
-            } & {
-                readonly animationClipTracks: {
-                    readonly default: import("../animation/animation-track/public.js")[];
-                };
-                readonly animationClipDuration: {
-                    readonly type: "number";
-                    readonly precision: 2;
-                    readonly default: number;
-                };
-                readonly animationClipRef: {
-                    readonly type: "integer";
-                    readonly minimum: -2147483648;
-                    readonly maximum: 2147483647;
-                    readonly default: number;
-                };
-                readonly animationTargets: {
-                    readonly default: number[];
-                };
-                readonly animationTime: {
-                    readonly type: "number";
-                    readonly precision: 2;
-                    readonly default: number;
-                };
-                readonly animationSpeed: {
-                    readonly default: 1;
-                    readonly type: "number";
-                    readonly precision: 1;
-                };
-                readonly animationLoop: {
-                    readonly type: "boolean";
-                    readonly default: boolean;
-                };
-                readonly animationPlaying: {
-                    readonly type: "boolean";
-                    readonly default: boolean;
-                };
-                readonly animationObservable: {
-                    readonly type: "boolean";
-                    readonly const: true;
-                    readonly default: true;
-                };
             }>, import("@adobe/data/schema").FromSchemas<{} & {
                 readonly frameTime: {
                     readonly default: import("../../core/frame-time/public.js");
@@ -11720,14 +11720,14 @@ export declare const picking: {
                 readonly SkinnedMesh: readonly ["localBounds", "skinJointTemplate", "skinInverseBindMatrices", "animationClipRefs"];
                 readonly MeshInstance: readonly ["mesh", "position", "rotation", "scale", "visible", "material"];
                 readonly Model: readonly ["mesh", "position", "rotation", "scale", "visible", "parent"];
-            } & {
-                readonly _VisibleMaterial: readonly ["nonPersistent", "_materialBindGroup", "_mesh"];
-                readonly _PbrPrimitive: readonly ["nonPersistent", "_vertexBuffer", "_skinVertexBuffer", "_indexBuffer", "_indexCount", "_indexFormat", "_material", "_mesh", "_nodeLocalMatrix"];
             } & {
                 readonly AnimationClip: readonly ["animationClipTracks", "animationClipDuration"];
                 readonly Animation: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying"];
                 readonly AnimationObservable: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying", "animationObservable"];
-            } & {} & {}, {} & {} & {
+            } & {} & {
+                readonly _VisibleMaterial: readonly ["nonPersistent", "_materialBindGroup", "_mesh"];
+                readonly _PbrPrimitive: readonly ["nonPersistent", "_vertexBuffer", "_skinVertexBuffer", "_indexBuffer", "_indexCount", "_indexFormat", "_material", "_mesh", "_nodeLocalMatrix"];
+            } & {}, {} & {} & {
                 readonly nodeChildrenOf: {
                     readonly key: "parent";
                     readonly archetype: "Node";
@@ -11738,14 +11738,14 @@ export declare const picking: {
                     readonly unique: true;
                     readonly archetype: "Material";
                 };
-            } & {} & {} & {} & {} & {} & {} & {}>, args: {
+            } & {} & {} & {} & {} & {} & {} & {}, never>, args: {
                 mesh: number;
                 position?: readonly [number, number, number];
                 rotation?: readonly [number, number, number, number];
                 scale?: readonly [number, number, number];
                 parent?: number;
             }) => number;
-        }>, "transformCreateWorldMatrix" | "transformSystem" | "update" | "_frameTime" | "schedulerSystem" | "input" | "preUpdate" | "postUpdate" | "physics" | "preRender" | "render" | "postRender" | "configureCanvas" | "beginRenderPass" | "endRenderPass" | "updateCameraAspect" | "animationSampleSystem" | "modelLoadSystem" | "worldBoundsCreate" | "worldBoundsSystem", import("@adobe/data/ecs").ToActionFunctions<{}>, import("@adobe/data/ecs").FromServiceFactories<{}>, import("@adobe/data/ecs").FromComputedFactories<{}>, {} & {} & {
+        }>, "_frameTime" | "update" | "schedulerSystem" | "input" | "preUpdate" | "postUpdate" | "physics" | "preRender" | "render" | "postRender" | "configureCanvas" | "beginRenderPass" | "endRenderPass" | "transformCreateWorldMatrix" | "transformSystem" | "updateCameraAspect" | "animationSampleSystem" | "modelLoadSystem" | "worldBoundsCreate" | "worldBoundsSystem", import("@adobe/data/ecs").ToActionFunctions<{}>, import("@adobe/data/ecs").FromServiceFactories<{}>, import("@adobe/data/ecs").FromComputedFactories<{}>, {} & {} & {
             readonly nodeChildrenOf: {
                 readonly key: "parent";
                 readonly archetype: "Node";
@@ -11756,7 +11756,7 @@ export declare const picking: {
                 readonly unique: true;
                 readonly archetype: "Material";
             };
-        } & {} & {} & {} & {} & {} & {} & {} & {}>, args: {
+        } & {} & {} & {} & {} & {} & {} & {} & {}, never>, args: {
             x: number;
             y: number;
         }) => PickHit | null;