@siduri-x/body 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+import { BodyOrgan, ExperienceAdapter, ExperienceEvent, ExperienceAdapterResult } from '@siduri-x/core';
+export type BodyState = 'idle' | 'speaking' | 'acting';
+export interface BodySnapshot {
+    state: BodyState;
+    currentExpression: string;
+    lastSpeechId: string | null;
+    lastAction: string | null;
+    lastText?: string;
+    lastLanguage?: string;
+    updatedAt: number;
+}
+export interface NeutralBodyOrganConfig {
+    initialExpression?: string;
+    [key: string]: unknown;
+}
+export type Live2DAdapterConfig = NeutralBodyOrganConfig;
+export declare class NeutralBodyOrgan implements BodyOrgan, ExperienceAdapter {
+    readonly kind: "avatar";
+    currentExpression: string;
+    lastSpeechId: string | null;
+    lastAction: string | null;
+    lastText?: string;
+    lastLanguage?: string;
+    state: BodyState;
+    lastEvent: ExperienceEvent | null;
+    updatedAt: number;
+    constructor(config?: NeutralBodyOrganConfig);
+    setExpression(expression: string): void;
+    speak(speechId: string, text?: string, language?: string): void;
+    act(action: string): void;
+    completeAction(): void;
+    getSnapshot(): BodySnapshot;
+    handleEvent(event: ExperienceEvent): Promise<ExperienceAdapterResult>;
+    cleanup(): void;
+}
+export declare const Live2DAdapter: typeof NeutralBodyOrgan;

package/dist/index.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Live2DAdapter = exports.NeutralBodyOrgan = void 0;
+const core_1 = require("@siduri-x/core");
+class NeutralBodyOrgan {
+    kind = 'avatar';
+    currentExpression = 'neutral';
+    lastSpeechId = null;
+    lastAction = null;
+    lastText;
+    lastLanguage;
+    state = 'idle';
+    lastEvent = null;
+    updatedAt = Date.now();
+    constructor(config = {}) {
+        if (config.initialExpression) {
+            this.currentExpression = config.initialExpression;
+        }
+    }
+    setExpression(expression) {
+        this.currentExpression = expression;
+        this.updatedAt = Date.now();
+    }
+    speak(speechId, text, language) {
+        this.lastSpeechId = speechId;
+        this.lastText = text;
+        this.lastLanguage = language;
+        this.state = 'speaking';
+        this.updatedAt = Date.now();
+    }
+    act(action) {
+        this.lastAction = action;
+        this.state = 'acting';
+        this.updatedAt = Date.now();
+    }
+    completeAction() {
+        this.state = 'idle';
+        this.updatedAt = Date.now();
+    }
+    getSnapshot() {
+        return {
+            state: this.state,
+            currentExpression: this.currentExpression,
+            lastSpeechId: this.lastSpeechId,
+            lastAction: this.lastAction,
+            lastText: this.lastText,
+            lastLanguage: this.lastLanguage,
+            updatedAt: this.updatedAt,
+        };
+    }
+    async handleEvent(event) {
+        const validation = (0, core_1.validateExperienceEvent)(event);
+        if (!validation.valid) {
+            return {
+                accepted: false,
+                eventId: event?.eventId || '',
+                lifecycle: 'FAILED',
+                error: validation.error,
+                reason: 'INVALID_EVENT_ENVELOPE',
+            };
+        }
+        if (event.kind !== 'avatar') {
+            return {
+                accepted: false,
+                eventId: event.eventId,
+                lifecycle: 'FAILED',
+                error: `Body adapter received incompatible event kind: ${event.kind}`,
+                reason: 'INCOMPATIBLE_EVENT_KIND',
+            };
+        }
+        if (event.approval !== 'APPROVED') {
+            return {
+                accepted: false,
+                eventId: event.eventId,
+                lifecycle: 'FAILED',
+                error: 'Event is not APPROVED',
+                reason: 'APPROVAL_REQUIRED',
+            };
+        }
+        this.lastEvent = event;
+        if (event.expression) {
+            this.setExpression(event.expression);
+        }
+        if (event.action) {
+            this.act(event.action);
+        }
+        if (event.text) {
+            this.lastText = event.text;
+            this.lastLanguage = event.language;
+        }
+        return {
+            accepted: true,
+            eventId: event.eventId,
+            lifecycle: 'STARTED',
+            metadata: {
+                expression: this.currentExpression,
+                action: this.lastAction,
+                state: this.state,
+                companionId: event.companionId,
+                correlationId: event.correlationId,
+            },
+        };
+    }
+    cleanup() {
+        this.state = 'idle';
+        this.lastEvent = null;
+        this.updatedAt = Date.now();
+    }
+}
+exports.NeutralBodyOrgan = NeutralBodyOrgan;
+// Backward-compatible alias
+exports.Live2DAdapter = NeutralBodyOrgan;

package/dist/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.test.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+describe('NeutralBodyOrgan', () => {
+    let organ;
+    beforeEach(() => {
+        organ = new index_1.NeutralBodyOrgan();
+    });
+    afterEach(() => {
+        organ.cleanup();
+    });
+    test('constructs with default or custom initial expression with zero external config', () => {
+        expect(organ.currentExpression).toBe('neutral');
+        expect(organ.state).toBe('idle');
+        expect(organ.lastSpeechId).toBeNull();
+        expect(organ.lastAction).toBeNull();
+        const customOrgan = new index_1.NeutralBodyOrgan({ initialExpression: 'happy' });
+        expect(customOrgan.currentExpression).toBe('happy');
+        customOrgan.cleanup();
+    });
+    test('Live2DAdapter is exported as a compatible alias', () => {
+        const adapter = new index_1.Live2DAdapter();
+        expect(adapter).toBeInstanceOf(index_1.NeutralBodyOrgan);
+        adapter.cleanup();
+    });
+    test('tracks body state machine transitions locally', () => {
+        organ.setExpression('smile');
+        expect(organ.currentExpression).toBe('smile');
+        organ.speak('speech_101', 'Hello world', 'en');
+        expect(organ.lastSpeechId).toBe('speech_101');
+        expect(organ.lastText).toBe('Hello world');
+        expect(organ.lastLanguage).toBe('en');
+        expect(organ.state).toBe('speaking');
+        organ.act('wave_hand');
+        expect(organ.lastAction).toBe('wave_hand');
+        expect(organ.state).toBe('acting');
+        organ.completeAction();
+        expect(organ.state).toBe('idle');
+        const snapshot = organ.getSnapshot();
+        expect(snapshot.state).toBe('idle');
+        expect(snapshot.currentExpression).toBe('smile');
+        expect(snapshot.lastSpeechId).toBe('speech_101');
+        expect(snapshot.lastAction).toBe('wave_hand');
+        expect(snapshot.lastText).toBe('Hello world');
+        expect(snapshot.lastLanguage).toBe('en');
+    });
+    test('handleEvent processes valid approved avatar event', async () => {
+        const res = await organ.handleEvent({
+            eventId: 'evt-avatar-1',
+            companionId: 'companion-test',
+            responseId: 'resp-100',
+            correlationId: 'corr-100',
+            channel: 'public',
+            audienceId: 'audience-public',
+            approval: 'APPROVED',
+            kind: 'avatar',
+            lifecycle: 'STARTED',
+            evidenceIds: [],
+            expression: 'surprised',
+            action: 'nod',
+            text: 'Affirmative.',
+            language: 'en',
+            createdAt: new Date().toISOString(),
+        });
+        expect(res.accepted).toBe(true);
+        expect(res.lifecycle).toBe('STARTED');
+        expect(res.metadata).toMatchObject({
+            expression: 'surprised',
+            action: 'nod',
+            state: 'acting',
+            companionId: 'companion-test',
+            correlationId: 'corr-100',
+        });
+        expect(organ.currentExpression).toBe('surprised');
+        expect(organ.lastAction).toBe('nod');
+        expect(organ.lastText).toBe('Affirmative.');
+    });
+    test('handleEvent rejects unapproved events or incompatible kinds', async () => {
+        const unapprovedRes = await organ.handleEvent({
+            eventId: 'evt-avatar-2',
+            companionId: 'companion-test',
+            responseId: 'resp-100',
+            correlationId: 'corr-100',
+            channel: 'public',
+            audienceId: 'audience-public',
+            approval: 'STAGED',
+            kind: 'avatar',
+            lifecycle: 'STARTED',
+            evidenceIds: [],
+            createdAt: new Date().toISOString(),
+        });
+        expect(unapprovedRes.accepted).toBe(false);
+        expect(unapprovedRes.error).toContain('APPROVED');
+        const incompatibleRes = await organ.handleEvent({
+            eventId: 'evt-avatar-3',
+            companionId: 'companion-test',
+            responseId: 'resp-100',
+            correlationId: 'corr-100',
+            channel: 'public',
+            audienceId: 'audience-public',
+            approval: 'APPROVED',
+            kind: 'voice',
+            lifecycle: 'STARTED',
+            evidenceIds: [],
+            createdAt: new Date().toISOString(),
+        });
+        expect(incompatibleRes.accepted).toBe(false);
+        expect(incompatibleRes.reason).toBe('INCOMPATIBLE_EVENT_KIND');
+    });
+    test('handleEvent rejects invalid envelope', async () => {
+        const invalidRes = await organ.handleEvent({});
+        expect(invalidRes.accepted).toBe(false);
+        expect(invalidRes.reason).toBe('INVALID_EVENT_ENVELOPE');
+    });
+    test('requires no open network sockets or transport listeners', () => {
+        // Verifies the object has no transport handles
+        expect(organ.wss).toBeUndefined();
+        expect(organ.vts).toBeUndefined();
+        expect(organ.clients).toBeUndefined();
+    });
+    test('handles sequential avatar events where latest valid event updates active state', async () => {
+        await organ.handleEvent({
+            eventId: 'evt-avatar-10',
+            companionId: 'companion-test',
+            responseId: 'resp-101',
+            correlationId: 'corr-101',
+            channel: 'public',
+            audienceId: 'audience-public',
+            approval: 'APPROVED',
+            kind: 'avatar',
+            lifecycle: 'STARTED',
+            evidenceIds: [],
+            expression: 'happy',
+            action: 'wave',
+            createdAt: new Date().toISOString(),
+        });
+        expect(organ.currentExpression).toBe('happy');
+        expect(organ.lastAction).toBe('wave');
+        // Newer event arrives
+        await organ.handleEvent({
+            eventId: 'evt-avatar-11',
+            companionId: 'companion-test',
+            responseId: 'resp-102',
+            correlationId: 'corr-102',
+            channel: 'public',
+            audienceId: 'audience-public',
+            approval: 'APPROVED',
+            kind: 'avatar',
+            lifecycle: 'STARTED',
+            evidenceIds: [],
+            expression: 'surprised',
+            action: 'nod',
+            createdAt: new Date().toISOString(),
+        });
+        expect(organ.currentExpression).toBe('surprised');
+        expect(organ.lastAction).toBe('nod');
+    });
+    test('speech synchronization sets speaking state and reset returns to idle', () => {
+        organ.speak('speech_v1', 'Konnichiwa', 'ja');
+        expect(organ.state).toBe('speaking');
+        expect(organ.lastSpeechId).toBe('speech_v1');
+        organ.completeAction();
+        expect(organ.state).toBe('idle');
+    });
+    test('handles unknown expressions and actions with graceful baseline fallbacks', () => {
+        organ.setExpression('unknown_custom_expression');
+        expect(organ.currentExpression).toBe('unknown_custom_expression');
+        organ.act('unknown_action');
+        expect(organ.lastAction).toBe('unknown_action');
+        expect(organ.state).toBe('acting');
+        organ.completeAction();
+        expect(organ.state).toBe('idle');
+    });
+});

package/organ-manifest.json

@@ -0,0 +1,33 @@
+{
+  "name": "@siduri-x/body",
+  "organType": "body",
+  "version": "1.0.0",
+  "displayName": "Body (Live2D & Avatar State)",
+  "description": "Renderer-agnostic avatar expression and embodiment event adapter",
+  "entrypoint": "./dist/index.js",
+  "factory": "NeutralBodyOrgan",
+  "configKey": "body",
+  "configSchema": {
+    "type": "object",
+    "required": [
+      "provider"
+    ],
+    "properties": {
+      "provider": {
+        "type": "string",
+        "enum": [
+          "live2d",
+          "none"
+        ]
+      },
+      "initialExpression": {
+        "type": "string",
+        "default": "neutral"
+      }
+    }
+  },
+  "environment": [],
+  "services": [],
+  "database": null,
+  "healthCheck": null
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@siduri-x/body",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w",
+    "test": "jest --config jest.config.json"
+  },
+  "dependencies": {
+    "@siduri-x/core": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/node": "^26.2.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.4.12",
+    "typescript": "^5.3.3"
+  },
+  "description": "Body organ for embodiment, avatar expression state machine, and physical animation",
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vxnuslabs/siduri-y",
+    "directory": "packages/organs/body"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "dist",
+    "organ-manifest.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./organ-manifest.json": "./organ-manifest.json"
+  }
+}