@unibridge/sdk 0.5.0 → 0.9.0

package/dist/commands/registry.d.ts

@@ -0,0 +1,303 @@
+export declare const allCommands: readonly [import("./define.ts").CommandDef<"componentsList", [query: {
+    path?: string | undefined;
+    instanceId?: number | undefined;
+    type?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}], {
+    components: {
+        instanceId: number;
+        type: string;
+        index: number;
+        enabled?: boolean | null | undefined;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}>, import("./define.ts").CommandDef<"componentsAdd", [input: {
+    path?: string | undefined;
+    instanceId?: number | undefined;
+    type: string;
+    initialValues?: {
+        [x: string]: unknown;
+    } | undefined;
+    strict?: boolean | undefined;
+}], {
+    instanceId: number;
+    type: string;
+    appliedFields: string[];
+    ignoredFields: string[];
+}>, import("./define.ts").CommandDef<"componentsGet", [query: {
+    path?: string | undefined;
+    instanceId?: number | undefined;
+    componentInstanceId?: number | undefined;
+    index?: number | undefined;
+    type?: string | undefined;
+}], {
+    component: {
+        instanceId: number;
+        type: string;
+        index: number;
+        enabled?: boolean | null | undefined;
+        serialized: {
+            [x: string]: unknown;
+        };
+    };
+}>, import("./define.ts").CommandDef<"componentsRemove", [input: {
+    path?: string | undefined;
+    instanceId?: number | undefined;
+    componentInstanceId?: number | undefined;
+    index?: number | undefined;
+    type?: string | undefined;
+}], {
+    removed: boolean;
+    instanceId: number;
+    type: string;
+    index: number;
+}>, import("./define.ts").CommandDef<"componentsUpdate", [input: {
+    path?: string | undefined;
+    instanceId?: number | undefined;
+    componentInstanceId?: number | undefined;
+    index?: number | undefined;
+    type?: string | undefined;
+    values: {
+        [x: string]: unknown;
+    };
+    strict?: boolean | undefined;
+}], {
+    instanceId: number;
+    type: string;
+    index: number;
+    appliedFields: string[];
+    ignoredFields: string[];
+}>, import("./define.ts").CommandDef<"domainReload", [], {
+    triggered: boolean;
+}>, import("./define.ts").CommandDef<"execute", [code: string], unknown>, import("./define.ts").CommandDef<"gameObjectCreate", [input: {
+    name: string;
+    parent?: string | undefined;
+    parentInstanceId?: number | undefined;
+    dimension?: "2d" | "3d" | undefined;
+    primitive?: "cube" | "sphere" | "capsule" | "cylinder" | "plane" | "quad" | undefined;
+    transform?: {
+        space?: "local" | "world" | undefined;
+        position?: {
+            x: number;
+            y: number;
+            z: number;
+        } | undefined;
+        rotation?: {
+            x: number;
+            y: number;
+            z: number;
+        } | undefined;
+        scale?: {
+            x: number;
+            y: number;
+            z: number;
+        } | undefined;
+    } | undefined;
+}], {
+    name: string;
+    path: string;
+    isActive: boolean;
+    siblingIndex: number;
+    instanceId: number;
+}>, import("./define.ts").CommandDef<"gameObjectDestroy", [input: {
+    path?: string | undefined;
+    instanceId?: number | undefined;
+}], {
+    destroyed: boolean;
+    name: string;
+    path: string;
+    instanceId: number;
+}>, import("./define.ts").CommandDef<"gameObjectUpdate", [input: {
+    path?: string | undefined;
+    instanceId?: number | undefined;
+    name?: string | undefined;
+    tag?: string | undefined;
+    layer?: string | undefined;
+    isStatic?: boolean | undefined;
+    transform?: {
+        space?: "local" | "world" | undefined;
+        position?: {
+            x: number;
+            y: number;
+            z: number;
+        } | undefined;
+        rotation?: {
+            x: number;
+            y: number;
+            z: number;
+        } | undefined;
+        scale?: {
+            x: number;
+            y: number;
+            z: number;
+        } | undefined;
+    } | undefined;
+}], {
+    name: string;
+    path: string;
+    instanceId: number;
+    tag: string;
+    layer: string;
+    isStatic: boolean;
+    transform: {
+        position: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        rotation: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        scale: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
+}>, import("./define.ts").CommandDef<"gameObjectReparent", [input: {
+    path?: string | undefined;
+    instanceId?: number | undefined;
+    parentPath?: string | undefined;
+    parentInstanceId?: number | undefined;
+    toRoot?: boolean | undefined;
+    worldPositionStays?: boolean | undefined;
+}], {
+    name: string;
+    path: string;
+    instanceId: number;
+    parentPath: string | null;
+    siblingIndex: number;
+}>, import("./define.ts").CommandDef<"gameObjectGet", [input: {
+    path?: string | undefined;
+    instanceId?: number | undefined;
+}], {
+    name: string;
+    path: string;
+    instanceId: number;
+    isActive: boolean;
+    tag: string;
+    layer: string;
+    isStatic: boolean;
+    parentPath: string | null;
+    siblingIndex: number;
+    transform: {
+        position: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        rotation: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        scale: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
+}>, import("./define.ts").CommandDef<"logs", [query?: {
+    severity?: "info" | "warn" | "error" | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+} | undefined], {
+    logs: {
+        timestamp: string;
+        severity: "info" | "warn" | "error";
+        message: string;
+        stackTrace?: string | undefined;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}>, import("./define.ts").CommandDef<"status", [], {
+    projectPath: string;
+    unityVersion: string;
+    pluginVersion: string;
+    activeScene: string;
+    playMode: string;
+}>, import("./define.ts").CommandDef<"sceneList", [query?: import("./scene/contract.ts").SceneListQuery | undefined], {
+    scenes: {
+        name: string;
+        path: string;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}>, import("./define.ts").CommandDef<"sceneHierarchy", [query?: import("./scene/contract.ts").SceneHierarchyQuery | undefined], {
+    nodes: {
+        name: string;
+        path: string;
+        isActive: boolean;
+        depth: number;
+        parentIndex: number;
+        siblingIndex: number;
+        instanceId: number;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}>, import("./define.ts").CommandDef<"sceneActive", [], {
+    scene: {
+        name: string;
+        path: string;
+        isDirty: boolean;
+    };
+}>, import("./define.ts").CommandDef<"sceneCreate", [path: string], {
+    scene: {
+        name: string;
+        path: string;
+        isDirty: boolean;
+    };
+}>, import("./define.ts").CommandDef<"sceneOpen", [path: string], {
+    scene: {
+        name: string;
+        path: string;
+        isDirty: boolean;
+    };
+}>, import("./define.ts").CommandDef<"testList", [query?: {
+    mode?: "edit" | "play" | undefined;
+    filter?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+} | undefined], {
+    tests: {
+        name: string;
+        fullName: string;
+        mode: "edit" | "play";
+        assembly: string;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}>, import("./define.ts").CommandDef<"testRun", [query?: {
+    mode?: "edit" | "play" | undefined;
+    filter?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+} | undefined], {
+    tests: {
+        name: string;
+        fullName: string;
+        mode: "edit" | "play";
+        status: "passed" | "failed" | "skipped" | "inconclusive";
+        durationMs: number;
+        message?: string | null | undefined;
+        stackTrace?: string | null | undefined;
+    }[];
+    passed: number;
+    failed: number;
+    skipped: number;
+    inconclusive: number;
+    durationMs: number;
+    total: number;
+    limit: number;
+    offset: number;
+}>];
+//# sourceMappingURL=registry.d.ts.map

package/dist/commands/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/commands/registry.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAmc,CAAA"}

package/dist/commands/registry.js

@@ -0,0 +1,10 @@
+import { componentsAddCommand, componentsGetCommand, componentsListCommand, componentsRemoveCommand, componentsUpdateCommand } from "./component/contract.js";
+import { domainReloadCommand } from "./domain/contract.js";
+import { executeCommand } from "./execute/contract.js";
+import { gameObjectCreateCommand, gameObjectDestroyCommand, gameObjectGetCommand, gameObjectReparentCommand, gameObjectUpdateCommand } from "./gameobject/contract.js";
+import { logsCommand } from "./log/contract.js";
+import { sceneActiveCommand, sceneCreateCommand, sceneHierarchyCommand, sceneListCommand, sceneOpenCommand } from "./scene/contract.js";
+import { statusCommand } from "./status/contract.js";
+import { testListCommand, testRunCommand } from "./test/contract.js";
+export const allCommands = [componentsListCommand, componentsAddCommand, componentsGetCommand, componentsRemoveCommand, componentsUpdateCommand, domainReloadCommand, executeCommand, gameObjectCreateCommand, gameObjectDestroyCommand, gameObjectUpdateCommand, gameObjectReparentCommand, gameObjectGetCommand, logsCommand, statusCommand, sceneListCommand, sceneHierarchyCommand, sceneActiveCommand, sceneCreateCommand, sceneOpenCommand, testListCommand, testRunCommand];
+//# sourceMappingURL=registry.js.map

package/dist/commands/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/commands/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAA;AAC7J,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AACtD,OAAO,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAA;AACtK,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AACvI,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACpD,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AAEpE,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,qBAAqB,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,mBAAmB,EAAE,cAAc,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,yBAAyB,EAAE,oBAAoB,EAAE,WAAW,EAAE,aAAa,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,eAAe,EAAE,cAAc,CAAU,CAAA"}

package/dist/commands/runtime.d.ts

@@ -0,0 +1,7 @@
+export interface CommandRuntime {
+    send(command: string, params: Record<string, unknown>): Promise<unknown>;
+}
+export interface ExecuteGuard {
+    ensureExecuteEnabled(): void;
+}
+//# sourceMappingURL=runtime.d.ts.map

package/dist/commands/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/commands/runtime.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;CACzE;AAED,MAAM,WAAW,YAAY;IAC3B,oBAAoB,IAAI,IAAI,CAAA;CAC7B"}

package/dist/commands/runtime.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=runtime.js.map

package/dist/commands/runtime.js.map

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

package/dist/commands/scene/contract.d.ts

@@ -0,0 +1,127 @@
+import * as v from 'valibot';
+import { type InferResult } from '../define.ts';
+declare const SceneInfoSchema: v.ObjectSchema<{
+    readonly name: v.StringSchema<undefined>;
+    readonly path: v.StringSchema<undefined>;
+    readonly isDirty: v.BooleanSchema<undefined>;
+}, undefined>;
+declare const SceneListItemSchema: v.ObjectSchema<{
+    readonly name: v.StringSchema<undefined>;
+    readonly path: v.StringSchema<undefined>;
+}, undefined>;
+declare const SceneHierarchyNodeSchema: v.ObjectSchema<{
+    readonly name: v.StringSchema<undefined>;
+    readonly path: v.StringSchema<undefined>;
+    readonly isActive: v.BooleanSchema<undefined>;
+    readonly depth: v.NumberSchema<undefined>;
+    readonly parentIndex: v.NumberSchema<undefined>;
+    readonly siblingIndex: v.NumberSchema<undefined>;
+    readonly instanceId: v.NumberSchema<undefined>;
+}, undefined>;
+export declare const SceneListResultSchema: v.ObjectSchema<{
+    readonly scenes: v.ArraySchema<v.ObjectSchema<{
+        readonly name: v.StringSchema<undefined>;
+        readonly path: v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly total: v.NumberSchema<undefined>;
+    readonly limit: v.NumberSchema<undefined>;
+    readonly offset: v.NumberSchema<undefined>;
+}, undefined>;
+export declare const SceneHierarchyResultSchema: v.ObjectSchema<{
+    readonly nodes: v.ArraySchema<v.ObjectSchema<{
+        readonly name: v.StringSchema<undefined>;
+        readonly path: v.StringSchema<undefined>;
+        readonly isActive: v.BooleanSchema<undefined>;
+        readonly depth: v.NumberSchema<undefined>;
+        readonly parentIndex: v.NumberSchema<undefined>;
+        readonly siblingIndex: v.NumberSchema<undefined>;
+        readonly instanceId: v.NumberSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly total: v.NumberSchema<undefined>;
+    readonly limit: v.NumberSchema<undefined>;
+    readonly offset: v.NumberSchema<undefined>;
+}, undefined>;
+export declare const sceneListCommand: import("../define.ts").CommandDef<"sceneList", [query?: SceneListQuery | undefined], {
+    scenes: {
+        name: string;
+        path: string;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}>;
+export declare const sceneHierarchyCommand: import("../define.ts").CommandDef<"sceneHierarchy", [query?: SceneHierarchyQuery | undefined], {
+    nodes: {
+        name: string;
+        path: string;
+        isActive: boolean;
+        depth: number;
+        parentIndex: number;
+        siblingIndex: number;
+        instanceId: number;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}>;
+export declare const SceneActiveResultSchema: v.ObjectSchema<{
+    readonly scene: v.ObjectSchema<{
+        readonly name: v.StringSchema<undefined>;
+        readonly path: v.StringSchema<undefined>;
+        readonly isDirty: v.BooleanSchema<undefined>;
+    }, undefined>;
+}, undefined>;
+export declare const sceneActiveCommand: import("../define.ts").CommandDef<"sceneActive", [], {
+    scene: {
+        name: string;
+        path: string;
+        isDirty: boolean;
+    };
+}>;
+export declare const SceneOpenResultSchema: v.ObjectSchema<{
+    readonly scene: v.ObjectSchema<{
+        readonly name: v.StringSchema<undefined>;
+        readonly path: v.StringSchema<undefined>;
+        readonly isDirty: v.BooleanSchema<undefined>;
+    }, undefined>;
+}, undefined>;
+export declare const sceneOpenCommand: import("../define.ts").CommandDef<"sceneOpen", [path: string], {
+    scene: {
+        name: string;
+        path: string;
+        isDirty: boolean;
+    };
+}>;
+export declare const SceneCreateResultSchema: v.ObjectSchema<{
+    readonly scene: v.ObjectSchema<{
+        readonly name: v.StringSchema<undefined>;
+        readonly path: v.StringSchema<undefined>;
+        readonly isDirty: v.BooleanSchema<undefined>;
+    }, undefined>;
+}, undefined>;
+export declare const sceneCreateCommand: import("../define.ts").CommandDef<"sceneCreate", [path: string], {
+    scene: {
+        name: string;
+        path: string;
+        isDirty: boolean;
+    };
+}>;
+export type SceneInfo = v.InferOutput<typeof SceneInfoSchema>;
+export type SceneListItem = v.InferOutput<typeof SceneListItemSchema>;
+export type SceneHierarchyNode = v.InferOutput<typeof SceneHierarchyNodeSchema>;
+export interface SceneListQuery {
+    filter?: string;
+    limit?: number;
+    offset?: number;
+}
+export interface SceneHierarchyQuery {
+    limit?: number;
+    offset?: number;
+}
+export type SceneListResult = InferResult<typeof sceneListCommand>;
+export type SceneHierarchyResult = InferResult<typeof sceneHierarchyCommand>;
+export type SceneActiveResult = InferResult<typeof sceneActiveCommand>;
+export type SceneOpenResult = InferResult<typeof sceneOpenCommand>;
+export type SceneCreateResult = InferResult<typeof sceneCreateCommand>;
+export {};
+//# sourceMappingURL=contract.d.ts.map

package/dist/commands/scene/contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../../src/commands/scene/contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAC5B,OAAO,EAAiB,KAAK,WAAW,EAAE,MAAM,cAAc,CAAA;AAE9D,QAAA,MAAM,eAAe;;;;aAInB,CAAA;AAEF,QAAA,MAAM,mBAAmB;;;aAGvB,CAAA;AAEF,QAAA,MAAM,wBAAwB;;;;;;;;aAQ5B,CAAA;AAEF,eAAO,MAAM,qBAAqB;;;;;;;;aAKhC,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;aAKrC,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;EAS3B,CAAA;AAEF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;EAQhC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;;aAElC,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;EAK7B,CAAA;AAEF,eAAO,MAAM,qBAAqB;;;;;;aAEhC,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;;;;EAK3B,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;;aAElC,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;EAK7B,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,eAAe,CAAC,CAAA;AAC7D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,mBAAmB,CAAC,CAAA;AACrE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAC/E,MAAM,WAAW,cAAc;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AACD,MAAM,WAAW,mBAAmB;IAClC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AACD,MAAM,MAAM,eAAe,GAAG,WAAW,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAClE,MAAM,MAAM,oBAAoB,GAAG,WAAW,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAC5E,MAAM,MAAM,iBAAiB,GAAG,WAAW,CAAC,OAAO,kBAAkB,CAAC,CAAA;AACtE,MAAM,MAAM,eAAe,GAAG,WAAW,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAClE,MAAM,MAAM,iBAAiB,GAAG,WAAW,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

package/dist/commands/scene/contract.js

@@ -0,0 +1,79 @@
+import * as v from 'valibot';
+import { defineCommand } from "../define.js";
+const SceneInfoSchema = v.object({
+    name: v.string(),
+    path: v.string(),
+    isDirty: v.boolean(),
+});
+const SceneListItemSchema = v.object({
+    name: v.string(),
+    path: v.string(),
+});
+const SceneHierarchyNodeSchema = v.object({
+    name: v.string(),
+    path: v.string(),
+    isActive: v.boolean(),
+    depth: v.number(),
+    parentIndex: v.number(),
+    siblingIndex: v.number(),
+    instanceId: v.number(),
+});
+export const SceneListResultSchema = v.object({
+    scenes: v.array(SceneListItemSchema),
+    total: v.number(),
+    limit: v.number(),
+    offset: v.number(),
+});
+export const SceneHierarchyResultSchema = v.object({
+    nodes: v.array(SceneHierarchyNodeSchema),
+    total: v.number(),
+    limit: v.number(),
+    offset: v.number(),
+});
+export const sceneListCommand = defineCommand({
+    method: 'sceneList',
+    wire: 'scene.list',
+    params: (query) => ({
+        filter: query?.filter,
+        limit: query?.limit,
+        offset: query?.offset,
+    }),
+    result: SceneListResultSchema,
+});
+export const sceneHierarchyCommand = defineCommand({
+    method: 'sceneHierarchy',
+    wire: 'scene.hierarchy',
+    params: (query) => ({
+        limit: query?.limit,
+        offset: query?.offset,
+    }),
+    result: SceneHierarchyResultSchema,
+});
+export const SceneActiveResultSchema = v.object({
+    scene: SceneInfoSchema,
+});
+export const sceneActiveCommand = defineCommand({
+    method: 'sceneActive',
+    wire: 'scene.active',
+    params: () => ({}),
+    result: SceneActiveResultSchema,
+});
+export const SceneOpenResultSchema = v.object({
+    scene: SceneInfoSchema,
+});
+export const sceneOpenCommand = defineCommand({
+    method: 'sceneOpen',
+    wire: 'scene.open',
+    params: (path) => ({ path }),
+    result: SceneOpenResultSchema,
+});
+export const SceneCreateResultSchema = v.object({
+    scene: SceneInfoSchema,
+});
+export const sceneCreateCommand = defineCommand({
+    method: 'sceneCreate',
+    wire: 'scene.create',
+    params: (path) => ({ path }),
+    result: SceneCreateResultSchema,
+});
+//# sourceMappingURL=contract.js.map

package/dist/commands/scene/contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.js","sourceRoot":"","sources":["../../../src/commands/scene/contract.ts"],"names":[],"mappings":"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"}

package/dist/commands/status/contract.d.ts

@@ -0,0 +1,18 @@
+import * as v from 'valibot';
+import { type InferResult } from '../define.ts';
+export declare const StatusResultSchema: v.ObjectSchema<{
+    readonly projectPath: v.StringSchema<undefined>;
+    readonly unityVersion: v.StringSchema<undefined>;
+    readonly pluginVersion: v.StringSchema<undefined>;
+    readonly activeScene: v.StringSchema<undefined>;
+    readonly playMode: v.StringSchema<undefined>;
+}, undefined>;
+export declare const statusCommand: import("../define.ts").CommandDef<"status", [], {
+    projectPath: string;
+    unityVersion: string;
+    pluginVersion: string;
+    activeScene: string;
+    playMode: string;
+}>;
+export type StatusResult = InferResult<typeof statusCommand>;
+//# sourceMappingURL=contract.d.ts.map

package/dist/commands/status/contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../../src/commands/status/contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAC5B,OAAO,EAAiB,KAAK,WAAW,EAAE,MAAM,cAAc,CAAA;AAE9D,eAAO,MAAM,kBAAkB;;;;;;aAM7B,CAAA;AAEF,eAAO,MAAM,aAAa;;;;;;EAKxB,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,WAAW,CAAC,OAAO,aAAa,CAAC,CAAA"}

package/dist/commands/status/contract.js

@@ -0,0 +1,16 @@
+import * as v from 'valibot';
+import { defineCommand } from "../define.js";
+export const StatusResultSchema = v.object({
+    projectPath: v.string(),
+    unityVersion: v.string(),
+    pluginVersion: v.string(),
+    activeScene: v.string(),
+    playMode: v.string(),
+});
+export const statusCommand = defineCommand({
+    method: 'status',
+    wire: 'status',
+    params: () => ({}),
+    result: StatusResultSchema,
+});
+//# sourceMappingURL=contract.js.map

package/dist/commands/status/contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.js","sourceRoot":"","sources":["../../../src/commands/status/contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAC5B,OAAO,EAAE,aAAa,EAAoB,MAAM,cAAc,CAAA;AAE9D,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IACzC,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;IACvB,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE;IACxB,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE;IACzB,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;IACvB,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;CACrB,CAAC,CAAA;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG,aAAa,CAAC;IACzC,MAAM,EAAE,QAAQ;IAChB,IAAI,EAAE,QAAQ;IACd,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC;IAClB,MAAM,EAAE,kBAAkB;CAC3B,CAAC,CAAA"}