@helix3/helix-cli 0.1.14-helix3.155 → 0.1.14-helix3.157

package/README.md

@@ -46,6 +46,9 @@ The token is stored in `~/.helix/credentials.json` (mode `600`). It's sent as
 | `helix item list-slots [--json]` | Print the Character-Creator vocabulary a wearable declares: the cosmetic slot tags, and the genders. |
 | `helix item publish <mesh.glb> --title <t> [--collectible-supply <n>] [initial distribution flags] [--dry-run\|--quote]` | Publish a Standard item by default, or one fixed-supply Collectible. The item definition is separate from acquisition routes. |
 | `helix item distribution create\|list\|update\|disable …` | Manage Marketplace/World Claim or Buy routes without republishing the item or paying another publish fee. |
+| `helix device create <dir> --id <slug> --title <t> --model <mesh.glb> --template standing-desk\|clock` | Scaffold a GLB-backed `helix.device/1` definition. There is intentionally no website Device editor. |
+| `helix device validate [dir] [--json]` | Validate the definition, GLB bytes and named-node bindings, typed state/controls, capabilities, and Home+World compatibility. |
+| `helix device test [dir] [--mode single\|multiplayer\|both] [--json]` | Exercise every interaction, persistence remount, and deterministic one-/two-client authority convergence. |
 | `helix preview-video <slug> <youtube-url>` | Set or clear a published world's YouTube preview. |
 | `helix thumbnail set <slug> <file>` | Upload a thumbnail or preview image through the CLI-owned media path. |
 | `helix assets search\|get\|versions\|track\|install\|update` | Search the typed Vault with explainable ranking; inspect/manage annotations and immutable versions; install by durable ID with verified SHA-256 receipts. Material installs default to lean runtime KTX2 maps; use `--material-renditions source` for source PNGs or `all` for both families. |

package/dist/device.d.ts

@@ -0,0 +1,38 @@
+export declare const DEVICE_FILENAME = "device.json";
+type Scalar = number | string | boolean;
+type JsonObject = Record<string, unknown>;
+export interface DeviceValidationReport {
+    ok: boolean;
+    directory: string;
+    definitionPath: string;
+    modelPath: string | null;
+    nodeNames: string[];
+    errors: string[];
+    warnings: string[];
+    definition?: JsonObject;
+}
+export interface DeviceTestReport {
+    ok: boolean;
+    mode: 'single' | 'multiplayer';
+    clients: number;
+    actionsExercised: string[];
+    finalState: Record<string, Scalar>;
+    persistentState: Record<string, Scalar>;
+    errors: string[];
+}
+export declare function readDeviceGlbNodeNames(file: string): string[];
+export declare function validateDeviceProject(input: string): DeviceValidationReport;
+export declare function testDeviceProject(input: string, mode: 'single' | 'multiplayer'): DeviceTestReport;
+export declare function createDeviceProject(input: {
+    directory: string;
+    id: string;
+    title: string;
+    modelPath: string;
+    template: 'clock' | 'standing-desk';
+}): {
+    directory: string;
+    definitionPath: string;
+    modelPath: string;
+    nodeNames: string[];
+};
+export {};

package/dist/device.js

@@ -0,0 +1,644 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEVICE_FILENAME = void 0;
+exports.readDeviceGlbNodeNames = readDeviceGlbNodeNames;
+exports.validateDeviceProject = validateDeviceProject;
+exports.testDeviceProject = testDeviceProject;
+exports.createDeviceProject = createDeviceProject;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+exports.DEVICE_FILENAME = 'device.json';
+function object(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+function scalar(value) {
+    return (typeof value === 'number' ||
+        typeof value === 'string' ||
+        typeof value === 'boolean');
+}
+function readDefinitionPath(input) {
+    const target = (0, node_path_1.resolve)(input);
+    if (target.endsWith('.json')) {
+        return { directory: (0, node_path_1.dirname)(target), path: target };
+    }
+    return { directory: target, path: (0, node_path_1.join)(target, exports.DEVICE_FILENAME) };
+}
+function glbJson(file) {
+    const bytes = (0, node_fs_1.readFileSync)(file);
+    if (bytes.length < 20 || bytes.readUInt32LE(0) !== 0x46546c67) {
+        throw new Error(`${(0, node_path_1.basename)(file)} is not a binary glTF (.glb)`);
+    }
+    if (bytes.readUInt32LE(4) !== 2) {
+        throw new Error(`${(0, node_path_1.basename)(file)} must use glTF 2`);
+    }
+    const declaredLength = bytes.readUInt32LE(8);
+    if (declaredLength !== bytes.length) {
+        throw new Error(`${(0, node_path_1.basename)(file)} length header is ${declaredLength}, actual ${bytes.length}`);
+    }
+    const jsonLength = bytes.readUInt32LE(12);
+    if (bytes.readUInt32LE(16) !== 0x4e4f534a || 20 + jsonLength > bytes.length) {
+        throw new Error(`${(0, node_path_1.basename)(file)} has no valid JSON chunk`);
+    }
+    return JSON.parse(bytes.subarray(20, 20 + jsonLength).toString('utf8'));
+}
+function readDeviceGlbNodeNames(file) {
+    const parsed = glbJson(file);
+    return [
+        ...new Set((Array.isArray(parsed.nodes) ? parsed.nodes : [])
+            .map((node) => String(object(node).name ?? '').trim())
+            .filter(Boolean)),
+    ].sort();
+}
+function stateDefault(spec) {
+    if (scalar(spec.default))
+        return spec.default;
+    const type = String(spec.type ?? '');
+    if (type === 'boolean')
+        return false;
+    if (type === 'enum')
+        return String((Array.isArray(spec.values) ? spec.values : [])[0] ?? '');
+    if (type === 'string')
+        return '';
+    return typeof spec.min === 'number' ? spec.min : 0;
+}
+function coerce(spec, value) {
+    const type = String(spec.type ?? '');
+    if (type === 'boolean')
+        return value === true;
+    if (type === 'string')
+        return String(value ?? '');
+    if (type === 'enum') {
+        const next = String(value ?? '');
+        const values = Array.isArray(spec.values) ? spec.values.map(String) : [];
+        return values.includes(next) ? next : String(values[0] ?? '');
+    }
+    let number = Number(value);
+    if (!Number.isFinite(number))
+        number = Number(stateDefault(spec));
+    if (type === 'integer')
+        number = Math.round(number);
+    if (typeof spec.min === 'number')
+        number = Math.max(spec.min, number);
+    if (typeof spec.max === 'number')
+        number = Math.min(spec.max, number);
+    return number;
+}
+function initialState(definition) {
+    return Object.fromEntries(Object.entries(object(definition.state)).map(([key, raw]) => [
+        key,
+        stateDefault(object(raw)),
+    ]));
+}
+function expr(value, state) {
+    const node = object(value);
+    if (node.kind === 'lit' && scalar(node.value))
+        return node.value;
+    if (node.kind === 'state')
+        return state[String(node.key)] ?? 0;
+    const args = Array.isArray(node.args)
+        ? node.args.map((part) => Number(expr(part, state)))
+        : [];
+    if (node.kind === 'add')
+        return args.reduce((a, b) => a + b, 0);
+    if (node.kind === 'sub')
+        return args.slice(1).reduce((a, b) => a - b, args[0] ?? 0);
+    if (node.kind === 'mul')
+        return args.reduce((a, b) => a * b, 1);
+    if (node.kind === 'min')
+        return Math.min(...args);
+    if (node.kind === 'max')
+        return Math.max(...args);
+    return 0;
+}
+function condition(value, state) {
+    const node = object(value);
+    if (node.op === 'true')
+        return true;
+    if (node.op === 'false')
+        return false;
+    if (node.op === 'not')
+        return !condition(node.of, state);
+    const list = Array.isArray(node.of) ? node.of : [];
+    if (node.op === 'and')
+        return list.every((part) => condition(part, state));
+    if (node.op === 'or')
+        return list.some((part) => condition(part, state));
+    const left = expr(node.left, state);
+    const right = expr(node.right, state);
+    if (node.op === 'eq')
+        return left === right;
+    if (node.op === 'ne')
+        return left !== right;
+    if (node.op === 'gt')
+        return left > right;
+    if (node.op === 'lt')
+        return left < right;
+    if (node.op === 'gte')
+        return left >= right;
+    if (node.op === 'lte')
+        return left <= right;
+    if (node.op === 'inRange') {
+        const number = Number(expr(node.value, state));
+        return (number >= Number(expr(node.min, state)) &&
+            number <= Number(expr(node.max, state)));
+    }
+    return false;
+}
+function applySteps(steps, definition, state, budget) {
+    if (!Array.isArray(steps))
+        return;
+    for (const raw of steps) {
+        if (--budget.remaining < 0)
+            throw new Error('behavior graph exceeded 2048 simulated steps');
+        const step = object(raw);
+        const kind = String(step.step ?? '');
+        if (kind === 'setState') {
+            const key = String(step.key ?? '');
+            const spec = object(object(definition.state)[key]);
+            if (!Object.keys(spec).length)
+                continue;
+            const value = step.value !== undefined
+                ? expr(step.value, state)
+                : Number(state[key] ?? 0) + Number(expr(step.delta, state));
+            state[key] = coerce(spec, value);
+        }
+        else if (kind === 'toggleState') {
+            const key = String(step.key ?? '');
+            state[key] = !Boolean(state[key]);
+        }
+        else if (kind === 'branch') {
+            applySteps(condition(step.when, state) ? step.then : step.else, definition, state, budget);
+        }
+        else if (kind === 'sequence') {
+            applySteps(step.do, definition, state, budget);
+        }
+        else if (kind === 'repeat') {
+            const times = Math.max(0, Math.min(64, Number(step.times) || 0));
+            for (let index = 0; index < times; index += 1) {
+                applySteps(step.do, definition, state, budget);
+            }
+        }
+        else if (kind === 'delay') {
+            applySteps(step.then, definition, state, budget);
+        }
+    }
+}
+function invoke(definition, state, interaction, value) {
+    const control = object(interaction.control);
+    if (control.stateKey && value !== undefined) {
+        const key = String(control.stateKey);
+        state[key] = coerce(object(object(definition.state)[key]), value);
+    }
+    const triggers = Array.isArray(object(definition.graph).triggers)
+        ? object(definition.graph).triggers
+        : [];
+    for (const raw of triggers) {
+        const trigger = object(raw);
+        if (trigger.on === 'interact' && trigger.interaction === interaction.id) {
+            applySteps(trigger.do, definition, state, { remaining: 2048 });
+        }
+    }
+}
+function exerciseValue(interaction, state) {
+    const control = object(interaction.control);
+    if (control.kind === 'number')
+        return Number(control.max ?? control.min ?? 1);
+    if (control.kind === 'choice') {
+        const options = Array.isArray(control.options)
+            ? control.options.map(object)
+            : [];
+        const current = state[String(control.stateKey)];
+        return String(options.find((option) => !option.disabled && option.value !== current)
+            ?.value ??
+            options.find((option) => !option.disabled)?.value ??
+            '');
+    }
+    return undefined;
+}
+function validateDeviceProject(input) {
+    const target = readDefinitionPath(input);
+    const errors = [];
+    const warnings = [];
+    let definition = {};
+    if (!(0, node_fs_1.existsSync)(target.path)) {
+        return {
+            ok: false,
+            directory: target.directory,
+            definitionPath: target.path,
+            modelPath: null,
+            nodeNames: [],
+            errors: [`Missing ${target.path}`],
+            warnings,
+        };
+    }
+    try {
+        definition = object(JSON.parse((0, node_fs_1.readFileSync)(target.path, 'utf8')));
+    }
+    catch (error) {
+        errors.push(error instanceof Error ? error.message : String(error));
+    }
+    if (definition.format !== 'helix.device' || definition.formatVersion !== 1) {
+        errors.push('format must be helix.device/1');
+    }
+    if (!/^[a-z0-9][a-z0-9-]{1,48}[a-z0-9]$/.test(String(definition.id ?? ''))) {
+        errors.push('id must be a 3-50 character lowercase slug');
+    }
+    if (!/^\d+\.\d+\.\d+$/.test(String(definition.version ?? ''))) {
+        errors.push('version must be semver (for example 1.0.0)');
+    }
+    if (!String(definition.title ?? '').trim())
+        errors.push('title is required');
+    if (definition.script !== null)
+        errors.push('script must be null; Devices are declarative');
+    const authorityModes = [
+        'presentationOnly',
+        'clientPredicted',
+        'clientAuthoritative',
+        'serverValidated',
+        'serverAuthoritative',
+    ];
+    if (!authorityModes.includes(String(definition.authority))) {
+        errors.push(`authority "${String(definition.authority)}" is unsupported`);
+    }
+    if (!['tiny', 'room', 'nearby', 'building', 'world'].includes(String(definition.activationPreset))) {
+        errors.push(`activationPreset "${String(definition.activationPreset)}" is unsupported`);
+    }
+    const model = object(definition.model);
+    let modelPath = null;
+    let nodeNames = [];
+    if (model.kind !== 'glb' || !String(model.url ?? '').trim()) {
+        errors.push('model.kind must be glb with a project-relative url');
+    }
+    else if (/^https?:\/\//.test(String(model.url))) {
+        warnings.push('remote model URL cannot be byte-verified locally; prefer a project GLB');
+    }
+    else {
+        modelPath = (0, node_path_1.resolve)(target.directory, String(model.url));
+        if (!(0, node_fs_1.existsSync)(modelPath))
+            errors.push(`model GLB does not exist: ${modelPath}`);
+        else {
+            try {
+                nodeNames = readDeviceGlbNodeNames(modelPath);
+            }
+            catch (error) {
+                errors.push(error instanceof Error ? error.message : String(error));
+            }
+        }
+    }
+    const nodes = new Set(nodeNames);
+    for (const [semantic, authored] of Object.entries(object(model.nodeBindings))) {
+        if (!nodes.has(String(authored))) {
+            errors.push(`model.nodeBindings.${semantic} references missing GLB node "${String(authored)}"`);
+        }
+    }
+    const state = object(definition.state);
+    if (Object.keys(state).length > 64)
+        errors.push('state exceeds the 64-variable Device budget');
+    for (const [key, raw] of Object.entries(state)) {
+        const spec = object(raw);
+        if (!['boolean', 'integer', 'float', 'string', 'enum'].includes(String(spec.type))) {
+            errors.push(`state.${key}.type "${String(spec.type)}" is unsupported`);
+        }
+        if (typeof spec.min === 'number' &&
+            typeof spec.max === 'number' &&
+            spec.max < spec.min) {
+            errors.push(`state.${key} has min > max`);
+        }
+        if (spec.type === 'enum' &&
+            (!Array.isArray(spec.values) || spec.values.length === 0)) {
+            errors.push(`state.${key} enum requires values`);
+        }
+    }
+    const interactions = Array.isArray(definition.interactions)
+        ? definition.interactions.map(object)
+        : [];
+    if (interactions.length > 16)
+        errors.push('interactions exceed the 16-action Device budget');
+    const interactionIds = new Set();
+    for (const interaction of interactions) {
+        const id = String(interaction.id ?? '');
+        if (!id || interactionIds.has(id))
+            errors.push(`interaction id "${id}" is missing or duplicated`);
+        interactionIds.add(id);
+        const control = object(interaction.control);
+        if (!control.kind)
+            continue;
+        const key = String(control.stateKey ?? '');
+        const spec = object(state[key]);
+        if (!Object.keys(spec).length)
+            errors.push(`interaction ${id} references unknown state "${key}"`);
+        if (control.kind === 'number') {
+            if (!['float', 'integer'].includes(String(spec.type)))
+                errors.push(`interaction ${id} number control must target numeric state`);
+            const min = Number(control.min ?? spec.min);
+            const max = Number(control.max ?? spec.max);
+            if (!Number.isFinite(min) || !Number.isFinite(max) || max <= min)
+                errors.push(`interaction ${id} requires finite max > min`);
+        }
+        else if (control.kind === 'choice') {
+            const options = Array.isArray(control.options)
+                ? control.options.map(object)
+                : [];
+            if (!options.length)
+                errors.push(`interaction ${id} choice requires options`);
+            for (const option of options)
+                if (option.disabled && !String(option.reason ?? '').trim())
+                    errors.push(`interaction ${id} disabled choice "${String(option.value)}" needs a reason`);
+        }
+        else
+            errors.push(`interaction ${id} uses unsupported control kind "${String(control.kind)}"`);
+    }
+    const components = Array.isArray(definition.components)
+        ? definition.components.map(object)
+        : [];
+    if (components.length > 32)
+        errors.push('components exceed the 32-component Device budget');
+    const bindings = object(model.nodeBindings);
+    for (const component of components) {
+        const semanticNodes = [
+            'node',
+            'hourNode',
+            'minuteNode',
+            'secondNode',
+            'secondCounterweightNode',
+        ];
+        for (const field of semanticNodes) {
+            if (!component[field])
+                continue;
+            const semantic = String(component[field]);
+            const authored = String(bindings[semantic] ?? semantic);
+            if (nodeNames.length && !nodes.has(authored))
+                errors.push(`component ${String(component.id)} ${field} resolves to missing GLB node "${authored}"`);
+        }
+    }
+    const triggers = Array.isArray(object(definition.graph).triggers)
+        ? object(definition.graph).triggers
+        : [];
+    if (triggers.length > 64)
+        errors.push('graph exceeds the 64-trigger Device budget');
+    for (const raw of triggers) {
+        const trigger = object(raw);
+        if (trigger.on === 'interact' &&
+            !interactionIds.has(String(trigger.interaction)))
+            errors.push(`graph references undeclared interaction "${String(trigger.interaction)}"`);
+    }
+    const hosts = Array.isArray(object(definition.compatibility).hosts)
+        ? object(definition.compatibility).hosts
+        : [];
+    if (!hosts.includes('home') || !hosts.includes('world')) {
+        errors.push('compatibility.hosts must include both home and world for a universal Device');
+    }
+    const capabilities = new Set(Array.isArray(definition.capabilities)
+        ? definition.capabilities.map(String)
+        : []);
+    const allowedCapabilities = new Set([
+        'model.glb',
+        'presentation.nodeMotion',
+        'clock.serverTime',
+        'state.typed',
+        'state.durable',
+        'room.authority',
+        'audio.playback',
+        'signals.local',
+    ]);
+    for (const capability of capabilities) {
+        if (!allowedCapabilities.has(capability)) {
+            errors.push(`capability "${capability}" is unsupported`);
+        }
+    }
+    for (const required of ['model.glb', 'state.typed']) {
+        if (!capabilities.has(required))
+            errors.push(`capabilities must declare ${required}`);
+    }
+    if (['serverValidated', 'serverAuthoritative'].includes(String(definition.authority)) &&
+        !capabilities.has('room.authority')) {
+        errors.push('server authority requires capability room.authority');
+    }
+    for (const required of Array.isArray(object(definition.compatibility).requiredCapabilities)
+        ? object(definition.compatibility).requiredCapabilities
+        : []) {
+        if (!capabilities.has(String(required))) {
+            errors.push(`compatibility requires undeclared capability "${String(required)}"`);
+        }
+    }
+    const migrationStarts = new Set();
+    for (const raw of Array.isArray(definition.stateMigrations)
+        ? definition.stateMigrations
+        : []) {
+        const migration = object(raw);
+        const from = Number(migration.from);
+        const to = Number(migration.to);
+        if (!Number.isInteger(from) || to !== from + 1) {
+            errors.push(`state migration ${from}->${to} must advance by one`);
+        }
+        if (migrationStarts.has(from)) {
+            errors.push(`state migrations duplicate from=${from}`);
+        }
+        migrationStarts.add(from);
+    }
+    for (const key of Array.isArray(object(definition.thumbnail).stateKeys)
+        ? object(definition.thumbnail).stateKeys
+        : []) {
+        if (!state[String(key)]) {
+            errors.push(`thumbnail references unknown state "${String(key)}"`);
+        }
+    }
+    return {
+        ok: errors.length === 0,
+        directory: target.directory,
+        definitionPath: target.path,
+        modelPath,
+        nodeNames,
+        errors,
+        warnings,
+        definition: errors.length === 0 ? definition : undefined,
+    };
+}
+function testDeviceProject(input, mode) {
+    const validation = validateDeviceProject(input);
+    if (!validation.ok || !validation.definition) {
+        return {
+            ok: false,
+            mode,
+            clients: mode === 'multiplayer' ? 2 : 1,
+            actionsExercised: [],
+            finalState: {},
+            persistentState: {},
+            errors: validation.errors,
+        };
+    }
+    const definition = validation.definition;
+    const authority = initialState(definition);
+    const clientA = { ...authority };
+    const clientB = { ...authority };
+    const actions = Array.isArray(definition.interactions)
+        ? definition.interactions.map(object)
+        : [];
+    const exercised = [];
+    const errors = [];
+    for (const interaction of actions) {
+        const value = exerciseValue(interaction, authority);
+        invoke(definition, authority, interaction, value);
+        Object.assign(clientA, authority);
+        if (mode === 'multiplayer')
+            Object.assign(clientB, authority);
+        exercised.push(String(interaction.id));
+        if (JSON.stringify(clientA) !== JSON.stringify(authority))
+            errors.push(`client A diverged after ${String(interaction.id)}`);
+        if (mode === 'multiplayer' &&
+            JSON.stringify(clientB) !== JSON.stringify(authority))
+            errors.push(`client B diverged after ${String(interaction.id)}`);
+    }
+    const stateSchema = object(definition.state);
+    const persistentState = Object.fromEntries(Object.entries(authority).filter(([key]) => object(stateSchema[key]).persist === true));
+    const remounted = initialState(definition);
+    for (const [key, value] of Object.entries(persistentState))
+        remounted[key] = coerce(object(stateSchema[key]), value);
+    for (const [key, value] of Object.entries(persistentState)) {
+        if (remounted[key] !== value)
+            errors.push(`persistent state ${key} did not round-trip`);
+    }
+    return {
+        ok: errors.length === 0,
+        mode,
+        clients: mode === 'multiplayer' ? 2 : 1,
+        actionsExercised: exercised,
+        finalState: authority,
+        persistentState,
+        errors,
+    };
+}
+function clockDefinition(id, title) {
+    return {
+        format: 'helix.device',
+        formatVersion: 1,
+        id,
+        version: '1.0.0',
+        title,
+        model: {
+            kind: 'glb',
+            url: './model.glb',
+            nodeBindings: {
+                hourHand: 'hourHand',
+                minuteHand: 'minuteHand',
+                secondHand: 'secondHand',
+                secondCounterweight: 'secondCounterweight',
+            },
+        },
+        state: {},
+        interactions: [],
+        components: [
+            {
+                id: 'hands',
+                type: 'clockHands',
+                hourNode: 'hourHand',
+                minuteNode: 'minuteHand',
+                secondNode: 'secondHand',
+                secondCounterweightNode: 'secondCounterweight',
+                timeZone: 'local',
+            },
+        ],
+        graph: { triggers: [] },
+        script: null,
+        activationPreset: 'room',
+        authority: 'presentationOnly',
+        capabilities: ['model.glb', 'state.typed', 'clock.serverTime'],
+        stateVersion: 1,
+        compatibility: {
+            hosts: ['home', 'world'],
+            requiredCapabilities: ['model.glb', 'clock.serverTime'],
+        },
+        thumbnail: { policy: 'never' },
+    };
+}
+function deskDefinition(id, title) {
+    return {
+        format: 'helix.device',
+        formatVersion: 1,
+        id,
+        version: '1.0.0',
+        title,
+        model: { kind: 'glb', url: './model.glb', nodeBindings: { top: 'top' } },
+        state: {
+            height: {
+                type: 'float',
+                min: 0.62,
+                max: 1.25,
+                default: 0.74,
+                persist: true,
+            },
+        },
+        interactions: [
+            {
+                id: 'setHeight',
+                label: 'Adjust height',
+                verb: 'use',
+                control: {
+                    kind: 'number',
+                    stateKey: 'height',
+                    min: 0.62,
+                    max: 1.25,
+                    step: 0.01,
+                    unit: 'm',
+                },
+            },
+        ],
+        components: [
+            {
+                id: 'topLift',
+                type: 'slider',
+                node: 'top',
+                axis: 'y',
+                stateKey: 'height',
+                minOffsetM: 0.62,
+                maxOffsetM: 1.25,
+                durationMs: 900,
+                easing: 'easeOutCubic',
+            },
+        ],
+        graph: { triggers: [] },
+        script: null,
+        activationPreset: 'room',
+        authority: 'serverValidated',
+        capabilities: [
+            'model.glb',
+            'state.typed',
+            'state.durable',
+            'presentation.nodeMotion',
+            'room.authority',
+        ],
+        stateVersion: 1,
+        compatibility: {
+            hosts: ['home', 'world'],
+            requiredCapabilities: [
+                'model.glb',
+                'state.typed',
+                'presentation.nodeMotion',
+                'room.authority',
+            ],
+        },
+        thumbnail: { policy: 'discreteState', stateKeys: ['height'] },
+    };
+}
+function createDeviceProject(input) {
+    const directory = (0, node_path_1.resolve)(input.directory);
+    const sourceModel = (0, node_path_1.resolve)(input.modelPath);
+    if (!(0, node_fs_1.existsSync)(sourceModel))
+        throw new Error(`Model does not exist: ${sourceModel}`);
+    const nodeNames = readDeviceGlbNodeNames(sourceModel);
+    (0, node_fs_1.mkdirSync)(directory, { recursive: true });
+    const definitionPath = (0, node_path_1.join)(directory, exports.DEVICE_FILENAME);
+    const modelPath = (0, node_path_1.join)(directory, 'model.glb');
+    if ((0, node_fs_1.existsSync)(definitionPath) || (0, node_fs_1.existsSync)(modelPath)) {
+        throw new Error(`Refusing to overwrite an existing Device project in ${directory}`);
+    }
+    const definition = input.template === 'clock'
+        ? clockDefinition(input.id, input.title)
+        : deskDefinition(input.id, input.title);
+    (0, node_fs_1.copyFileSync)(sourceModel, modelPath);
+    (0, node_fs_1.writeFileSync)(definitionPath, `${JSON.stringify(definition, null, 2)}\n`);
+    return { directory, definitionPath, modelPath, nodeNames };
+}
+//# sourceMappingURL=device.js.map