@dreamerbird/camera-studio 0.0.0-stage → 0.1.0

package/dist/agent/commands/animations.js

@@ -0,0 +1,245 @@
+/**
+ * animations 命令(2026-10-17,Task 9):apply / clear / getStatus。
+ *
+ * apply:验证 AnimationEntry 存在且与模型骨架族兼容(库模型条目 rig 优先——
+ * GLB 导出洗骨骼名,实例重算可能不一致;本地 FBX 回退实例 rigIdOf;静态骨架
+ * INVALID_STATE),再按静态语义写 props.animation(propAccess 形状 + 建轨
+ * 校验;已建轨 INVALID_STATE,打帧走 keyframes.*)。clear 写空值。
+ *
+ * getStatus(会话域查询):loaded/error 只读 PlacementManager 的运行时登记
+ * (agent/runtime/animationStatus,加载 effect 登记、cleanup 删除),绝不从
+ * props 猜测——props 有值但无登记 = 加载中;登记的 assetId 与当前 props
+ * 不符 = 陈旧登记,按加载中报。
+ */
+import { val } from '@dreamerbird/core';
+import { AgentApiError } from '../errors';
+import { resolveSceneSheetObject } from '../objectResolver';
+import { parseSceneObjectId } from '../objectIds';
+import { assertStaticPropsWritable, setStaticProps } from '../propAccess';
+import { getAnimationLoadStatus } from '../runtime/animationStatus';
+import { requireFiniteNumber, requireObject, requireString } from '../validation';
+import { rigIdOf } from '../../assetLibrary/rig';
+const objectIdProperty = {
+    type: 'string',
+    description: '带类型场景对象 ID(模型),如 model:Y Bot',
+};
+const expectedRevisionProperty = {
+    type: 'number',
+    description: '乐观并发:读取场景时的 revision',
+};
+const revisionOutput = {
+    type: 'object',
+    properties: { revision: { type: 'number' } },
+    required: ['revision'],
+};
+const statusOutput = {
+    type: 'object',
+    properties: {
+        assetId: { type: 'string' },
+        loaded: { type: 'boolean' },
+        error: {
+            type: 'object',
+            properties: {
+                code: { type: 'string' },
+                message: { type: 'string' },
+                retryable: { type: 'boolean' },
+            },
+            required: ['code', 'message', 'retryable'],
+        },
+    },
+    required: ['loaded'],
+};
+function optionalExpectedRevision(value) {
+    if (value === undefined)
+        return undefined;
+    return requireFiniteNumber(value, 'expectedRevision');
+}
+function resolveMountedModel(runtime, objectId) {
+    const sheetObject = resolveSceneSheetObject(runtime.sheet, objectId, 'model');
+    if (!sheetObject) {
+        throw new AgentApiError('INVALID_STATE', `对象未挂载,无法操作: ${objectId}`, { details: { objectId } });
+    }
+    return sheetObject;
+}
+/**
+ * 模型骨架族:库模型条目 rig 优先,回退实例 rigIdOf。
+ * handler 未绑定 SCENE_UNAVAILABLE;实例未挂载 INVALID_STATE;
+ * 静态骨架(null)由调用方拒绝。
+ */
+async function resolveModelRig(runtime, objectId) {
+    const getModelPlacement = runtime.handlers.getModelPlacement;
+    if (!getModelPlacement) {
+        throw new AgentApiError('SCENE_UNAVAILABLE', 'Scene Runtime 未绑定 getModelPlacement,无法验证骨架兼容性');
+    }
+    const { key } = parseSceneObjectId(objectId);
+    const placement = getModelPlacement({ key });
+    if (!placement) {
+        throw new AgentApiError('INVALID_STATE', `模型实例未挂载: ${objectId}`, {
+            details: { objectId },
+        });
+    }
+    if (placement.entry.libraryEntryId) {
+        const libEntry = await runtime.library.getEntry(placement.entry.libraryEntryId);
+        if (libEntry?.kind === 'model')
+            return libEntry.rig;
+    }
+    const rig = rigIdOf(placement.instance);
+    return rig === 'static' ? null : rig;
+}
+export function registerAnimationCommands(registry, runtime) {
+    registry.register({
+        name: 'animations.apply',
+        kind: 'mutation',
+        stateDomain: 'project',
+        undoable: 'single-step',
+        completion: 'committed',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                objectId: objectIdProperty,
+                assetId: { type: 'string', description: '动画资产条目 id' },
+                expectedRevision: expectedRevisionProperty,
+            },
+            required: ['objectId', 'assetId'],
+            additionalProperties: false,
+        },
+        outputSchema: revisionOutput,
+        errorCodes: [
+            'API_DISPOSED',
+            'INVALID_ARGUMENT',
+            'INVALID_ID_KIND',
+            'OBJECT_NOT_FOUND',
+            'INVALID_STATE',
+            'ASSET_NOT_FOUND',
+            'REVISION_CONFLICT',
+            'SCENE_UNAVAILABLE',
+        ],
+        validate: (value) => {
+            const args = requireObject(value);
+            return {
+                objectId: requireString(args, 'objectId'),
+                assetId: requireString(args, 'assetId'),
+                expectedRevision: optionalExpectedRevision(args.expectedRevision),
+            };
+        },
+        execute: async (args) => {
+            runtime.assertActive();
+            const sheetObject = resolveMountedModel(runtime, args.objectId);
+            const entry = await runtime.library.getEntry(args.assetId);
+            if (!entry) {
+                throw new AgentApiError('ASSET_NOT_FOUND', `资产不存在: ${args.assetId}`, {
+                    details: { assetId: args.assetId },
+                });
+            }
+            if (entry.kind !== 'animation') {
+                throw new AgentApiError('INVALID_ARGUMENT', `资产 ${args.assetId} 不是动画(kind: ${entry.kind})`, { details: { assetId: args.assetId, kind: entry.kind } });
+            }
+            // 骨架族兼容校验(UI 选择框对异族条目置灰,同一规则)
+            const modelRig = await resolveModelRig(runtime, args.objectId);
+            if (modelRig === null) {
+                throw new AgentApiError('INVALID_STATE', `静态骨架模型不能应用动画: ${args.objectId}`, { details: { objectId: args.objectId } });
+            }
+            if (entry.rig !== modelRig) {
+                throw new AgentApiError('INVALID_ARGUMENT', `动画 ${args.assetId} 的骨架族(${entry.rig})与模型(${modelRig})不兼容`, {
+                    details: {
+                        assetId: args.assetId,
+                        assetRig: entry.rig,
+                        modelRig,
+                    },
+                });
+            }
+            // 建轨预检先于乐观并发与事务(同 objects.update)
+            assertStaticPropsWritable(sheetObject, { animation: args.assetId });
+            if (args.expectedRevision !== undefined) {
+                runtime.assertRevision(args.expectedRevision);
+            }
+            setStaticProps(sheetObject, { animation: args.assetId });
+            return { revision: await runtime.nextRevision() };
+        },
+    });
+    registry.register({
+        name: 'animations.clear',
+        kind: 'mutation',
+        stateDomain: 'project',
+        undoable: 'single-step',
+        completion: 'committed',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                objectId: objectIdProperty,
+                expectedRevision: expectedRevisionProperty,
+            },
+            required: ['objectId'],
+            additionalProperties: false,
+        },
+        outputSchema: revisionOutput,
+        errorCodes: [
+            'API_DISPOSED',
+            'INVALID_ARGUMENT',
+            'INVALID_ID_KIND',
+            'OBJECT_NOT_FOUND',
+            'INVALID_STATE',
+            'REVISION_CONFLICT',
+            'SCENE_UNAVAILABLE',
+        ],
+        validate: (value) => {
+            const args = requireObject(value);
+            return {
+                objectId: requireString(args, 'objectId'),
+                expectedRevision: optionalExpectedRevision(args.expectedRevision),
+            };
+        },
+        execute: async (args) => {
+            runtime.assertActive();
+            const sheetObject = resolveMountedModel(runtime, args.objectId);
+            assertStaticPropsWritable(sheetObject, { animation: '' });
+            if (args.expectedRevision !== undefined) {
+                runtime.assertRevision(args.expectedRevision);
+            }
+            setStaticProps(sheetObject, { animation: '' });
+            return { revision: await runtime.nextRevision() };
+        },
+    });
+    registry.register({
+        name: 'animations.getStatus',
+        kind: 'query',
+        stateDomain: 'session',
+        undoable: 'none',
+        inputSchema: {
+            type: 'object',
+            properties: { objectId: objectIdProperty },
+            required: ['objectId'],
+            additionalProperties: false,
+        },
+        outputSchema: statusOutput,
+        errorCodes: [
+            'API_DISPOSED',
+            'INVALID_ARGUMENT',
+            'INVALID_ID_KIND',
+            'OBJECT_NOT_FOUND',
+            'INVALID_STATE',
+        ],
+        validate: (value) => ({
+            objectId: requireString(requireObject(value), 'objectId'),
+        }),
+        execute: async (args) => {
+            runtime.assertActive();
+            const sheetObject = resolveMountedModel(runtime, args.objectId);
+            const current = val(sheetObject.props.animation) ?? '';
+            // 未设置
+            if (!current)
+                return { loaded: false };
+            const { key } = parseSceneObjectId(args.objectId);
+            const status = getAnimationLoadStatus(key);
+            // 无登记(加载中)或登记陈旧(assetId 对不上):如实报加载中
+            if (!status || status.assetId !== current) {
+                return { assetId: current, loaded: false };
+            }
+            return {
+                assetId: current,
+                loaded: status.loaded,
+                ...(status.error ? { error: status.error } : {}),
+            };
+        },
+    });
+}

package/dist/agent/commands/animations.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=animations.test.d.ts.map

package/dist/agent/commands/animations.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animations.test.d.ts","sourceRoot":"","sources":["../../../src/agent/commands/animations.test.ts"],"names":[],"mappings":""}

package/dist/agent/commands/animations.test.js

@@ -0,0 +1,426 @@
+let projectSeq = 0;
+/** 晚绑定:doMock 工厂只跑一次,getStudioSync 读取当前 setup 的 studio */
+let activeFakeStudio;
+jest.doMock('@dreamerbird/core', () => ({
+    ...jest.requireActual('@dreamerbird/core'),
+    getStudioSync: () => activeFakeStudio,
+}));
+const cleanups = [];
+afterEach(() => {
+    while (cleanups.length)
+        cleanups.pop()();
+});
+const ctx = () => ({
+    requestId: 'test',
+    signal: new AbortController().signal,
+});
+function setup(options = {}) {
+    const { getPointerParts } = require('@dreamerbird/dataverse');
+    const core = require('@dreamerbird/core');
+    const { globals } = require('@dreamerbird/core/globals');
+    const { AgentCommandRegistry } = require('../registry');
+    const { createAgentRuntime } = require('../runtime');
+    const objectRuntime = require('../runtime/objectRuntime');
+    const animationStatus = require('../runtime/animationStatus');
+    const { registerAnimationCommands } = require('./animations');
+    const { PLACEMENTS_REGISTRY_KEY } = require('../../PlacementManager');
+    const { rigIdOf } = require('../../assetLibrary/rig');
+    const three = require('three');
+    const calls = [];
+    const fakeStudio = {
+        transaction: jest.fn((fn) => fn({
+            set: (pointer, value) => {
+                const { path } = getPointerParts(pointer);
+                calls.push({ op: 'set', path: path.join('.'), value });
+            },
+        })),
+    };
+    activeFakeStudio = fakeStudio;
+    cleanups.push(() => {
+        activeFakeStudio = undefined;
+    });
+    const state = {
+        definitionVersion: globals.currentProjectStateDefinitionVersion,
+        sheetsById: {
+            Scene: {
+                staticOverrides: { byObject: {} },
+                sequence: {
+                    type: 'PositionalSequence',
+                    length: 10,
+                    subUnitsPerUnit: 30,
+                    tracksByObject: options.tracks
+                        ? {
+                            Foo: {
+                                trackIdByPropPath: { '["animation"]': 'track-anim' },
+                                trackData: {
+                                    'track-anim': {
+                                        type: 'BasicKeyframedTrack',
+                                        keyframes: {
+                                            byId: {
+                                                kf1: {
+                                                    id: 'kf1',
+                                                    position: 0,
+                                                    connectedRight: true,
+                                                    handles: [0.5, 0.5, 0.5, 0.5],
+                                                    value: '',
+                                                },
+                                            },
+                                            allIds: { kf1: true },
+                                        },
+                                    },
+                                },
+                            },
+                        }
+                        : {},
+                },
+            },
+        },
+    };
+    const project = core.getProject(`agent-anims-${++projectSeq}`, {
+        state: state,
+    });
+    const sheet = project.sheet('Scene');
+    const animEntry = {
+        id: 'anim-1',
+        kind: 'animation',
+        name: '走路',
+        rig: 'mixamo',
+        blobId: 'blob-a1',
+        contentHash: 'hash-a1',
+        duration: 1.5,
+        createdAt: 10,
+    };
+    const animOtherRig = { ...animEntry, id: 'anim-2', name: '异族', rig: 'other' };
+    const modelEntry = {
+        id: 'model-1',
+        kind: 'model',
+        name: 'Y Bot',
+        rig: 'mixamo',
+        blobId: 'blob-1',
+        contentHash: 'hash-1',
+        boneCount: 65,
+        vertexCount: 1000,
+        createdAt: 0,
+    };
+    const poseEntry = {
+        id: 'pose-1',
+        kind: 'pose',
+        name: '坐姿',
+        rig: 'mixamo',
+        bones: {},
+        createdAt: 1,
+    };
+    const entries = new Map([animEntry, animOtherRig, modelEntry, poseEntry].map((entry) => [
+        entry.id,
+        entry,
+    ]));
+    const library = {
+        getEntry: jest.fn(async (id) => entries.get(id)),
+    };
+    let notifyHistoric = () => { };
+    const runtime = createAgentRuntime({
+        project,
+        sheet,
+        library: library,
+        getStudio: () => fakeStudio,
+        subscribeHistoric: (listener) => {
+            notifyHistoric = listener;
+            return () => { };
+        },
+    });
+    const registry = new AgentCommandRegistry();
+    registerAnimationCommands(registry, runtime);
+    /** Scene Runtime handler:当前 Foo 的放置条目 + Three 实例(逐用例可换) */
+    let placementForFoo;
+    const getModelPlacement = jest.fn(({ key }) => key === 'Foo' ? placementForFoo : undefined);
+    cleanups.push(runtime.bindHandlers({ getModelPlacement }));
+    function registerMounted(id, obj) {
+        objectRuntime.registerSceneSheetObject(id, obj);
+        cleanups.push(() => objectRuntime.unregisterSceneSheetObject(id, obj));
+    }
+    /** 布景:注册表写 'Foo' 条目并把 SheetObject 登记为 model:Foo */
+    function mountFoo() {
+        const t = core.types;
+        const registryObj = sheet.object(PLACEMENTS_REGISTRY_KEY, { list: t.string('[]') }, { hideFromOutline: true });
+        registryObj.initialValue = {
+            list: JSON.stringify([
+                { key: 'Foo', libraryEntryId: 'model-1', position: { x: 0, y: 0, z: 0 } },
+            ]),
+        };
+        const obj = sheet.object('Foo', {
+            position: t.compound({
+                x: t.number(0),
+                y: t.number(0),
+                z: t.number(0),
+            }),
+            pose: t.string(''),
+            animation: t.string(''),
+        });
+        registerMounted('model:Foo', obj);
+        return obj;
+    }
+    /** 带骨骼的 Three 实例(rigIdOf 回退路径用) */
+    function boneInstance() {
+        const group = new three.Group();
+        const hips = new three.Bone();
+        hips.name = 'mixamorigHips';
+        group.add(hips);
+        return group;
+    }
+    return {
+        core,
+        project,
+        sheet,
+        registry,
+        runtime,
+        fakeStudio,
+        calls,
+        library,
+        mountFoo,
+        boneInstance,
+        rigIdOf,
+        animationStatus,
+        setPlacementForFoo: (p) => {
+            placementForFoo = p;
+        },
+        getModelPlacement,
+        notifyHistoric: () => notifyHistoric(),
+    };
+}
+const COMMAND_NAMES = [
+    'animations.apply',
+    'animations.clear',
+    'animations.getStatus',
+];
+describe('animations 命令注册', () => {
+    test('三个命令全部注册', () => {
+        const { registry } = setup();
+        for (const name of COMMAND_NAMES) {
+            expect(registry.has(name)).toBe(true);
+        }
+    });
+    test('元数据:apply/clear 为项目单步命令且接受 expectedRevision;getStatus 为会话域查询', () => {
+        const { registry } = setup();
+        const described = new Map(registry.describe().commands.map((c) => [c.name, c]));
+        for (const name of ['animations.apply', 'animations.clear']) {
+            expect(described.get(name)).toMatchObject({
+                kind: 'mutation',
+                stateDomain: 'project',
+                undoable: 'single-step',
+                completion: 'committed',
+                acceptsExpectedRevision: true,
+            });
+        }
+        expect(described.get('animations.getStatus')).toMatchObject({
+            kind: 'query',
+            acceptsExpectedRevision: false,
+        });
+    });
+});
+describe('animations.apply', () => {
+    test('动画条目与模型兼容:单事务写 props.animation 静态值', async () => {
+        const { registry, fakeStudio, calls, mountFoo, boneInstance, setPlacementForFoo, } = setup();
+        mountFoo();
+        setPlacementForFoo({
+            entry: {
+                key: 'Foo',
+                libraryEntryId: 'model-1',
+                position: { x: 0, y: 0, z: 0 },
+            },
+            instance: boneInstance(),
+        });
+        const result = await registry.execute('animations.apply', { objectId: 'model:Foo', assetId: 'anim-1' }, ctx());
+        expect(fakeStudio.transaction).toHaveBeenCalledTimes(1);
+        expect(calls).toEqual([{ op: 'set', path: 'animation', value: 'anim-1' }]);
+        expect(result).toEqual({ revision: 1 });
+    });
+    test('资产不存在 ASSET_NOT_FOUND;非动画条目 INVALID_ARGUMENT', async () => {
+        const { registry, fakeStudio, mountFoo, boneInstance, setPlacementForFoo } = setup();
+        mountFoo();
+        setPlacementForFoo({
+            entry: {
+                key: 'Foo',
+                libraryEntryId: 'model-1',
+                position: { x: 0, y: 0, z: 0 },
+            },
+            instance: boneInstance(),
+        });
+        await expect(registry.execute('animations.apply', { objectId: 'model:Foo', assetId: 'nope' }, ctx())).rejects.toMatchObject({ code: 'ASSET_NOT_FOUND' });
+        await expect(registry.execute('animations.apply', { objectId: 'model:Foo', assetId: 'pose-1' }, ctx())).rejects.toMatchObject({ code: 'INVALID_ARGUMENT' });
+        expect(fakeStudio.transaction).not.toHaveBeenCalled();
+    });
+    test('骨架族不符 INVALID_ARGUMENT,不写', async () => {
+        const { registry, fakeStudio, mountFoo, boneInstance, setPlacementForFoo } = setup();
+        mountFoo();
+        setPlacementForFoo({
+            entry: {
+                key: 'Foo',
+                libraryEntryId: 'model-1',
+                position: { x: 0, y: 0, z: 0 },
+            },
+            instance: boneInstance(),
+        });
+        await expect(registry.execute('animations.apply', { objectId: 'model:Foo', assetId: 'anim-2' }, ctx())).rejects.toMatchObject({ code: 'INVALID_ARGUMENT' });
+        expect(fakeStudio.transaction).not.toHaveBeenCalled();
+    });
+    test('无库条目时回退实例 rigIdOf;静态骨架 INVALID_STATE', async () => {
+        // 回退路径:放置条目无 libraryEntryId,模型 rig 由实例骨骼计算
+        const s2 = setup();
+        s2.mountFoo();
+        const instance2 = s2.boneInstance();
+        s2.setPlacementForFoo({
+            entry: { key: 'Foo', position: { x: 0, y: 0, z: 0 } },
+            instance: instance2,
+        });
+        const fallbackEntry = {
+            id: 'anim-rig',
+            kind: 'animation',
+            name: '实例族',
+            rig: s2.rigIdOf(instance2),
+            blobId: 'b',
+            contentHash: 'h',
+            duration: 1,
+            createdAt: 11,
+        };
+        s2.library.getEntry.mockImplementation(async (id) => id === 'anim-rig' ? fallbackEntry : undefined);
+        await s2.registry.execute('animations.apply', { objectId: 'model:Foo', assetId: 'anim-rig' }, ctx());
+        expect(s2.calls).toEqual([
+            { op: 'set', path: 'animation', value: 'anim-rig' },
+        ]);
+        // 静态骨架:无骨骼实例且无库 rig → INVALID_STATE
+        const s3 = setup();
+        s3.mountFoo();
+        s3.setPlacementForFoo({
+            entry: { key: 'Foo', position: { x: 0, y: 0, z: 0 } },
+            instance: new (require('three').Group)(),
+        });
+        s3.library.getEntry.mockImplementation(async (id) => id === 'anim-1'
+            ? {
+                id: 'anim-1',
+                kind: 'animation',
+                name: '走路',
+                rig: 'mixamo',
+                blobId: 'blob-a1',
+                contentHash: 'hash-a1',
+                duration: 1.5,
+                createdAt: 10,
+            }
+            : undefined);
+        await expect(s3.registry.execute('animations.apply', { objectId: 'model:Foo', assetId: 'anim-1' }, ctx())).rejects.toMatchObject({ code: 'INVALID_STATE' });
+    });
+    test('animation 已建轨返回 INVALID_STATE,不写', async () => {
+        const { registry, fakeStudio, mountFoo, boneInstance, setPlacementForFoo } = setup({ tracks: true });
+        mountFoo();
+        setPlacementForFoo({
+            entry: {
+                key: 'Foo',
+                libraryEntryId: 'model-1',
+                position: { x: 0, y: 0, z: 0 },
+            },
+            instance: boneInstance(),
+        });
+        await expect(registry.execute('animations.apply', { objectId: 'model:Foo', assetId: 'anim-1' }, ctx())).rejects.toMatchObject({ code: 'INVALID_STATE' });
+        expect(fakeStudio.transaction).not.toHaveBeenCalled();
+    });
+    test('expectedRevision 冲突 REVISION_CONFLICT;Scene Runtime 未绑定 SCENE_UNAVAILABLE', async () => {
+        const { registry, fakeStudio, mountFoo, boneInstance, setPlacementForFoo, notifyHistoric, } = setup();
+        mountFoo();
+        setPlacementForFoo({
+            entry: {
+                key: 'Foo',
+                libraryEntryId: 'model-1',
+                position: { x: 0, y: 0, z: 0 },
+            },
+            instance: boneInstance(),
+        });
+        notifyHistoric();
+        await expect(registry.execute('animations.apply', { objectId: 'model:Foo', assetId: 'anim-1', expectedRevision: 1 }, ctx())).rejects.toMatchObject({ code: 'REVISION_CONFLICT' });
+        expect(fakeStudio.transaction).not.toHaveBeenCalled();
+    });
+});
+describe('animations.clear', () => {
+    test('写空值(单事务),返回 revision', async () => {
+        const { registry, calls, mountFoo } = setup();
+        mountFoo();
+        const result = await registry.execute('animations.clear', { objectId: 'model:Foo' }, ctx());
+        expect(calls).toEqual([{ op: 'set', path: 'animation', value: '' }]);
+        expect(result).toEqual({ revision: 1 });
+    });
+    test('已建轨 INVALID_STATE;expectedRevision 冲突 REVISION_CONFLICT', async () => {
+        const { registry, fakeStudio, mountFoo } = setup({ tracks: true });
+        mountFoo();
+        await expect(registry.execute('animations.clear', { objectId: 'model:Foo' }, ctx())).rejects.toMatchObject({ code: 'INVALID_STATE' });
+        expect(fakeStudio.transaction).not.toHaveBeenCalled();
+    });
+});
+describe('animations.getStatus', () => {
+    test('未设置动画:{loaded:false} 且无 assetId', async () => {
+        const { registry, mountFoo } = setup();
+        mountFoo();
+        await expect(registry.execute('animations.getStatus', { objectId: 'model:Foo' }, ctx())).resolves.toEqual({ loaded: false });
+    });
+    test('已设置但未登记:加载中 {assetId, loaded:false}', async () => {
+        const { registry, mountFoo } = setup();
+        const obj = mountFoo();
+        obj.initialValue = { animation: 'anim-1' };
+        await expect(registry.execute('animations.getStatus', { objectId: 'model:Foo' }, ctx())).resolves.toEqual({ assetId: 'anim-1', loaded: false });
+    });
+    test('运行时登记 loaded:true → 已加载;登记 error → 加载失败', async () => {
+        const { registry, mountFoo, animationStatus } = setup();
+        const obj = mountFoo();
+        obj.initialValue = { animation: 'anim-1' };
+        animationStatus.setAnimationLoadStatus('Foo', {
+            assetId: 'anim-1',
+            loaded: true,
+        });
+        cleanups.push(() => animationStatus.clearAnimationLoadStatus('Foo'));
+        await expect(registry.execute('animations.getStatus', { objectId: 'model:Foo' }, ctx())).resolves.toEqual({ assetId: 'anim-1', loaded: true });
+        animationStatus.setAnimationLoadStatus('Foo', {
+            assetId: 'anim-1',
+            loaded: false,
+            error: {
+                code: 'RESOURCE_LOAD_FAILED',
+                message: 'GLB 解析失败',
+                retryable: true,
+            },
+        });
+        await expect(registry.execute('animations.getStatus', { objectId: 'model:Foo' }, ctx())).resolves.toEqual({
+            assetId: 'anim-1',
+            loaded: false,
+            error: {
+                code: 'RESOURCE_LOAD_FAILED',
+                message: 'GLB 解析失败',
+                retryable: true,
+            },
+        });
+    });
+    test('登记的是旧 assetId(props 已换):按加载中报,不读陈旧 loaded', async () => {
+        const { registry, mountFoo, animationStatus } = setup();
+        const obj = mountFoo();
+        obj.initialValue = { animation: 'anim-2' };
+        animationStatus.setAnimationLoadStatus('Foo', {
+            assetId: 'anim-1',
+            loaded: true,
+        });
+        cleanups.push(() => animationStatus.clearAnimationLoadStatus('Foo'));
+        await expect(registry.execute('animations.getStatus', { objectId: 'model:Foo' }, ctx())).resolves.toEqual({ assetId: 'anim-2', loaded: false });
+    });
+    test('对象不存在 OBJECT_NOT_FOUND;未挂载 INVALID_STATE', async () => {
+        const { registry, mountFoo } = setup();
+        await expect(registry.execute('animations.getStatus', { objectId: 'model:Nope' }, ctx())).rejects.toMatchObject({ code: 'OBJECT_NOT_FOUND' });
+        const obj = mountFoo();
+        const objectRuntime = require('../runtime/objectRuntime');
+        objectRuntime.unregisterSceneSheetObject('model:Foo', obj);
+        await expect(registry.execute('animations.getStatus', { objectId: 'model:Foo' }, ctx())).rejects.toMatchObject({ code: 'INVALID_STATE' });
+    });
+});
+describe('会话生命周期', () => {
+    test('dispose 后命令拒绝 API_DISPOSED', async () => {
+        const { registry, runtime, mountFoo } = setup();
+        mountFoo();
+        runtime.dispose();
+        await expect(registry.execute('animations.getStatus', { objectId: 'model:Foo' }, ctx())).rejects.toMatchObject({ code: 'API_DISPOSED' });
+        await expect(registry.execute('animations.apply', { objectId: 'model:Foo', assetId: 'anim-1' }, ctx())).rejects.toMatchObject({ code: 'API_DISPOSED' });
+    });
+});
+export {};