@deckflow/deckuse 1.1.0 → 1.2.0

package/dist/bin.js

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 import { access, readFile } from 'node:fs/promises';
 import { dirname, extname, join, resolve } from 'node:path';
-import { PROTOCOL_VERSION, revisionAsNumber, } from '@deckflow/deckuse-core';
+import { PROTOCOL_VERSION, commandJsonSchema, measureText, parseLength, revisionAsNumber, } from '@deckflow/deckuse-core';
+import { resolveCliText } from './cli-text.js';
 import { helpTopicFromArgs, resolveHelp } from './help.js';
 import { runCommand } from './index.js';
-import { startMonitor } from './monitor.js';
+import { monitorStart, monitorStatus, monitorStop, runMonitorForeground, } from './monitor-daemon.js';
 import { renderPage } from './render.js';
 import { EDITION } from './edition.js';
 import { version } from './version.js';
@@ -84,6 +85,11 @@ const toEnvelope = (commandLabel, result, extras = {}) => {
                 message: result.error.message,
                 ...(result.error.target ? { target: result.error.target } : {}),
                 ...(result.error.hint ? { hint: result.error.hint } : {}),
+                ...(result.error.diagnostics?.length
+                    ? { diagnostics: result.error.diagnostics }
+                    : result.diagnostics.length
+                        ? { diagnostics: result.diagnostics }
+                        : {}),
             },
             ...extras,
         };
@@ -124,6 +130,13 @@ const outputEnvelope = (envelope) => {
         process.stderr.write(`deckuse: ${envelope.error?.code ?? 'ERROR'}: ${envelope.error?.message ?? 'failed'}\n`);
         if (envelope.error?.hint)
             process.stderr.write(`hint: ${envelope.error.hint}\n`);
+        const diagnostics = envelope.error?.diagnostics;
+        if (Array.isArray(diagnostics)) {
+            for (const d of diagnostics) {
+                const path = Array.isArray(d.path) && d.path.length > 0 ? `${d.path.map(String).join('.')}: ` : '';
+                process.stderr.write(`  - ${path}${d.message}\n`);
+            }
+        }
         return;
     }
     process.stdout.write(`${JSON.stringify(envelope, null, 2)}\n`);
@@ -199,6 +212,63 @@ const optionFrom = (list, name) => {
     const i = list.indexOf(name);
     return i >= 0 ? list[i + 1] : undefined;
 };
+/** Pass through bare numbers as number; keep unit strings for protocol parseLength. */
+const lengthArg = (raw) => {
+    if (raw === undefined)
+        return undefined;
+    if (raw === 'auto')
+        return 'auto';
+    if (/^-?\d+(\.\d+)?$/.test(raw))
+        return Number(raw);
+    return raw;
+};
+const APPLY_WRITE_TYPES = new Set([
+    'setText',
+    'replaceText',
+    'setTransform',
+    'setProperties',
+    'set',
+    'xfrmSet',
+    'zMove',
+    'add',
+    'addSlide',
+    'addShape',
+    'remove',
+    'replacePicture',
+    'duplicate',
+    'alignElements',
+    'batch',
+]);
+const isRecord = (value) => typeof value === 'object' && value !== null;
+const isTransactionOp = (value) => isRecord(value) && 'op' in value;
+const isHighLevelWrite = (value) => isRecord(value) && APPLY_WRITE_TYPES.has(String(value['type']));
+/** Classify apply payload items: high-level batch vs low-level transaction. */
+const classifyApplyOps = (ops) => {
+    if (ops.length === 0)
+        return { kind: 'invalid', message: 'apply input operations array is empty' };
+    if (ops.every(isTransactionOp))
+        return { kind: 'transaction' };
+    if (ops.every(isHighLevelWrite))
+        return { kind: 'batch' };
+    if (ops.some(isHighLevelWrite) && ops.some(isTransactionOp)) {
+        return {
+            kind: 'invalid',
+            message: 'apply input mixes high-level write commands (type) with transaction ops (op); use one format',
+        };
+    }
+    if (ops.some(isHighLevelWrite))
+        return { kind: 'batch' };
+    if (ops.some(isTransactionOp)) {
+        return {
+            kind: 'invalid',
+            message: 'apply transaction operations must all include "op"; high-level writes must use "type"',
+        };
+    }
+    return {
+        kind: 'invalid',
+        message: 'apply input must be high-level write commands ({ "type": "addShape"|... }) or transaction ops ({ "op": ... })',
+    };
+};
 const main = async () => {
     try {
         if (clean.length === 0) {
@@ -219,6 +289,89 @@ const main = async () => {
             }
             const action = clean[0];
             let ok = true;
+            if (action === 'schema') {
+                const typeOpt = optionFrom(clean, '--type') ??
+                    (clean[1] && !clean[1].startsWith('--') ? clean[1] : undefined);
+                const full = commandJsonSchema;
+                const defs = full.$defs ?? {};
+                const resolveRef = (entry) => {
+                    if (!entry || typeof entry !== 'object')
+                        return undefined;
+                    const record = entry;
+                    if (typeof record['$ref'] === 'string') {
+                        const ref = record['$ref'];
+                        const name = ref.replace(/^#\/\$defs\//, '');
+                        const resolved = defs[name];
+                        return resolved && typeof resolved === 'object'
+                            ? resolved
+                            : undefined;
+                    }
+                    return record;
+                };
+                const typeOf = (entry) => {
+                    const resolved = resolveRef(entry);
+                    const typeProp = resolved?.['properties']
+                        ? resolved['properties']['type']
+                        : undefined;
+                    if (!typeProp || typeof typeProp !== 'object')
+                        return undefined;
+                    const typeRecord = typeProp;
+                    if (typeof typeRecord['const'] === 'string')
+                        return typeRecord['const'];
+                    const nested = resolveRef(typeProp);
+                    return typeof nested?.['const'] === 'string' ? nested['const'] : undefined;
+                };
+                let schema = full;
+                if (typeOpt) {
+                    const variants = full.oneOf ?? full.anyOf ?? [];
+                    const match = variants.find((entry) => typeOf(entry) === typeOpt);
+                    if (!match) {
+                        const known = variants.map(typeOf).filter(Boolean).join(', ');
+                        throw new Error(`Unknown command type for schema: ${typeOpt}. Known: ${known || '(none)'}`);
+                    }
+                    schema = { ...(resolveRef(match) ?? match), $defs: defs };
+                }
+                const payload = {
+                    ok: true,
+                    command: 'deckuse schema',
+                    data: {
+                        cliVersion: version,
+                        protocolVersion: PROTOCOL_VERSION,
+                        edition: EDITION,
+                        ...(typeOpt ? { type: typeOpt } : {}),
+                        schema,
+                    },
+                };
+                process.stdout.write(`${JSON.stringify(payload, null, json ? undefined : 2)}\n`);
+                return;
+            }
+            if (action === 'measure') {
+                const text = optionFrom(clean, '--text');
+                if (text === undefined)
+                    throw new Error('Usage: deckuse measure --text <string> --font-size <pt>');
+                const fontSize = Number(optionFrom(clean, '--font-size') ?? optionFrom(clean, '--fontSize') ?? 12);
+                if (!(fontSize > 0))
+                    throw new Error('--font-size must be a positive number (pt)');
+                const bold = clean.includes('--bold');
+                const fontFamily = optionFrom(clean, '--font-family') ?? optionFrom(clean, '--fontFamily');
+                const maxWidthRaw = optionFrom(clean, '--max-width') ?? optionFrom(clean, '--maxWidth');
+                const maxWidthEmu = maxWidthRaw !== undefined
+                    ? parseLength(lengthArg(maxWidthRaw) ?? maxWidthRaw, { axis: 'x' })
+                    : undefined;
+                const measured = measureText({
+                    text,
+                    fontSize,
+                    ...(bold ? { bold: true } : {}),
+                    ...(fontFamily ? { fontFamily } : {}),
+                    ...(maxWidthEmu !== undefined ? { maxWidthEmu } : {}),
+                });
+                outputEnvelope({
+                    ok: true,
+                    command: 'deckuse measure',
+                    data: measured,
+                });
+                return;
+            }
             if (action === 'init') {
                 const source = clean[1];
                 const workspace = workspaceOpt ?? clean[2];
@@ -316,7 +469,7 @@ const main = async () => {
                     const slide = optionFrom(clean, '--slide');
                     const shapeType = optionFrom(clean, '--type');
                     if (!slide || !shapeType)
-                        throw new Error('Usage: deckuse add shape --slide <n> --type <text|rect|rounded-rect|ellipse|line|image|group|table|chart|video|audio>');
+                        throw new Error('Usage: deckuse add shape --slide <n> --type <text|rect|rounded-rect|ellipse|line|connector|elbow|arrow|chevron|circular-arrow|image|group|table|chart|…>');
                     const rowsRaw = optionFrom(clean, '--rows');
                     let rows;
                     if (rowsRaw !== undefined) {
@@ -343,6 +496,25 @@ const main = async () => {
                         }
                     }
                     const chartType = optionFrom(clean, '--chart-type');
+                    const textRaw = takeFlag(clean, '--text-raw');
+                    const textFile = optionFrom(clean, '--text-file');
+                    const textOpt = optionFrom(clean, '--text');
+                    const initialText = await resolveCliText({
+                        ...(textOpt !== undefined ? { value: textOpt } : {}),
+                        ...(textFile !== undefined ? { textFile } : {}),
+                        raw: textRaw,
+                    });
+                    const theme = optionFrom(clean, '--theme');
+                    const alignColumnsRaw = optionFrom(clean, '--align-columns');
+                    let alignColumns;
+                    if (alignColumnsRaw) {
+                        try {
+                            alignColumns = JSON.parse(alignColumnsRaw);
+                        }
+                        catch {
+                            alignColumns = alignColumnsRaw.split(',').map((s) => s.trim());
+                        }
+                    }
                     ok = await execute('deckuse add shape', {
                         ...base,
                         type: 'addShape',
@@ -350,19 +522,26 @@ const main = async () => {
                         shapeType,
                         ...(optionFrom(clean, '--name') ? { name: optionFrom(clean, '--name') } : {}),
                         ...(optionFrom(clean, '--role') ? { role: optionFrom(clean, '--role') } : {}),
-                        ...(optionFrom(clean, '--x') ? { x: Number(optionFrom(clean, '--x')) } : {}),
-                        ...(optionFrom(clean, '--y') ? { y: Number(optionFrom(clean, '--y')) } : {}),
-                        ...(optionFrom(clean, '--width') ? { width: Number(optionFrom(clean, '--width')) } : {}),
-                        ...(optionFrom(clean, '--height')
-                            ? { height: Number(optionFrom(clean, '--height')) }
+                        ...(lengthArg(optionFrom(clean, '--x')) !== undefined
+                            ? { x: lengthArg(optionFrom(clean, '--x')) }
                             : {}),
-                        ...(optionFrom(clean, '--file') ? { file: optionFrom(clean, '--file') } : {}),
-                        ...(optionFrom(clean, '--text') !== undefined
-                            ? { text: optionFrom(clean, '--text') }
+                        ...(lengthArg(optionFrom(clean, '--y')) !== undefined
+                            ? { y: lengthArg(optionFrom(clean, '--y')) }
+                            : {}),
+                        ...(lengthArg(optionFrom(clean, '--width')) !== undefined
+                            ? { width: lengthArg(optionFrom(clean, '--width')) }
                             : {}),
+                        ...(lengthArg(optionFrom(clean, '--height')) !== undefined
+                            ? { height: lengthArg(optionFrom(clean, '--height')) }
+                            : {}),
+                        ...(optionFrom(clean, '--file') ? { file: optionFrom(clean, '--file') } : {}),
+                        ...(initialText !== undefined ? { text: initialText } : {}),
                         ...(rows !== undefined ? { rows } : {}),
+                        ...(theme ? { theme } : {}),
+                        ...(alignColumns ? { alignColumns } : {}),
                         ...(chartType ? { chartType } : {}),
                         ...(data !== undefined ? { data } : {}),
+                        ...(takeFlag(clean, '--show-data-labels') ? { showDataLabels: true } : {}),
                     });
                 }
                 else
@@ -384,15 +563,42 @@ const main = async () => {
                 const base = await mutationExtras(workspace);
                 if (clean[1] === 'text') {
                     const target = clean[2];
-                    const value = optionFrom(clean, '--value');
-                    if (!target || value === undefined)
-                        throw new Error('Usage: deckuse set text <target> --value <text>');
-                    ok = await execute('deckuse set text', {
-                        ...base,
-                        type: 'setText',
-                        target,
-                        value,
-                    });
+                    const textRaw = takeFlag(clean, '--text-raw');
+                    const textFile = optionFrom(clean, '--text-file');
+                    const valueOpt = optionFrom(clean, '--value');
+                    const blocksRaw = optionFrom(clean, '--blocks');
+                    if (!target)
+                        throw new Error('Usage: deckuse set text <target> --value <text> | --text-file <path> | --blocks <json>');
+                    if (blocksRaw !== undefined) {
+                        let blocks;
+                        try {
+                            blocks = JSON.parse(blocksRaw);
+                        }
+                        catch {
+                            throw new Error('--blocks must be JSON array of {text, fontSize?, textColor?, ...}');
+                        }
+                        ok = await execute('deckuse set text', {
+                            ...base,
+                            type: 'setText',
+                            target,
+                            blocks,
+                        });
+                    }
+                    else {
+                        const value = await resolveCliText({
+                            ...(valueOpt !== undefined ? { value: valueOpt } : {}),
+                            ...(textFile !== undefined ? { textFile } : {}),
+                            raw: textRaw,
+                        });
+                        if (value === undefined)
+                            throw new Error('Usage: deckuse set text <target> --value <text> | --text-file <path> | --blocks <json>');
+                        ok = await execute('deckuse set text', {
+                            ...base,
+                            type: 'setText',
+                            target,
+                            value,
+                        });
+                    }
                 }
                 else {
                     const target = clean[1];
@@ -451,19 +657,42 @@ const main = async () => {
                     ...(await mutationExtras(workspace)),
                     type: 'xfrmSet',
                     target,
-                    ...(optionFrom(clean, '--x') ? { x: Number(optionFrom(clean, '--x')) } : {}),
-                    ...(optionFrom(clean, '--y') ? { y: Number(optionFrom(clean, '--y')) } : {}),
-                    ...(optionFrom(clean, '--width') || optionFrom(clean, '--cx')
-                        ? { width: Number(optionFrom(clean, '--width') ?? optionFrom(clean, '--cx')) }
+                    ...(lengthArg(optionFrom(clean, '--x')) !== undefined
+                        ? { x: lengthArg(optionFrom(clean, '--x')) }
+                        : {}),
+                    ...(lengthArg(optionFrom(clean, '--y')) !== undefined
+                        ? { y: lengthArg(optionFrom(clean, '--y')) }
+                        : {}),
+                    ...(lengthArg(optionFrom(clean, '--width') ?? optionFrom(clean, '--cx')) !== undefined
+                        ? { width: lengthArg(optionFrom(clean, '--width') ?? optionFrom(clean, '--cx')) }
                         : {}),
-                    ...(optionFrom(clean, '--height') || optionFrom(clean, '--cy')
-                        ? { height: Number(optionFrom(clean, '--height') ?? optionFrom(clean, '--cy')) }
+                    ...(lengthArg(optionFrom(clean, '--height') ?? optionFrom(clean, '--cy')) !== undefined
+                        ? { height: lengthArg(optionFrom(clean, '--height') ?? optionFrom(clean, '--cy')) }
                         : {}),
                     ...(optionFrom(clean, '--rotation')
                         ? { rotation: Number(optionFrom(clean, '--rotation')) }
                         : {}),
                 });
             }
+            else if (action === 'align') {
+                const workspace = await findWorkspace(workspaceOpt);
+                const slide = optionFrom(clean, '--slide');
+                const targetsRaw = optionFrom(clean, '--targets');
+                const mode = optionFrom(clean, '--mode');
+                if (!slide || !targetsRaw || !mode)
+                    throw new Error('Usage: deckuse align --slide <n> --targets <t1,t2,...> --mode <left|right|top|bottom|center-h|center-v|distribute-h|distribute-v> [--gap <length>]');
+                const targets = targetsRaw.split(',').map((t) => t.trim()).filter(Boolean);
+                ok = await execute('deckuse align', {
+                    ...(await mutationExtras(workspace)),
+                    type: 'alignElements',
+                    slide: Number(slide),
+                    targets,
+                    mode,
+                    ...(lengthArg(optionFrom(clean, '--gap')) !== undefined
+                        ? { gap: lengthArg(optionFrom(clean, '--gap')) }
+                        : {}),
+                });
+            }
             else if (action === 'z') {
                 if (clean[1] !== 'move')
                     throw new Error('Usage: deckuse z move <target> --above <target>');
@@ -486,13 +715,13 @@ const main = async () => {
                 const workspace = await findWorkspace(workspaceOpt ?? clean[1]);
                 const raw = input === '-' ? await readStdin() : await readFile(resolve(input), 'utf8');
                 let values;
-                let transactionOps;
+                let wrappedOperations;
                 try {
                     const parsed = JSON.parse(raw);
                     if (typeof parsed === 'object' &&
                         parsed !== null &&
                         Array.isArray(parsed.operations)) {
-                        transactionOps = parsed.operations;
+                        wrappedOperations = parsed.operations;
                     }
                     else {
                         values = Array.isArray(parsed) ? parsed : [parsed];
@@ -504,36 +733,50 @@ const main = async () => {
                         .filter(Boolean)
                         .map((line) => JSON.parse(line));
                 }
-                if (transactionOps) {
-                    ok = await execute('deckuse apply', {
-                        ...(await mutationExtras(workspace)),
-                        type: 'applyTransaction',
-                        operations: transactionOps,
+                const extras = await mutationExtras(workspace);
+                const runHighLevelBatch = async (list) => {
+                    const commands = list.map((value) => {
+                        if (!isRecord(value))
+                            throw new Error('apply input must contain command objects');
+                        if (value['type'] === 'batch')
+                            return value;
+                        if (!APPLY_WRITE_TYPES.has(String(value['type'])))
+                            throw new Error(`apply input contains non-write command: ${String(value['type'])}`);
+                        return { ...extras, ...value };
                     });
+                    const payload = commands.length === 1 && commands[0]?.['type'] !== 'batch'
+                        ? commands[0]
+                        : {
+                            ...extras,
+                            type: 'batch',
+                            atomic: true,
+                            commands: commands.flatMap((command) => command['type'] === 'batch'
+                                ? (command.commands ?? [])
+                                : [command]),
+                        };
+                    return execute('deckuse apply', payload);
+                };
+                if (wrappedOperations) {
+                    const classified = classifyApplyOps(wrappedOperations);
+                    if (classified.kind === 'invalid')
+                        throw new Error(classified.message);
+                    if (classified.kind === 'transaction') {
+                        ok = await execute('deckuse apply', {
+                            ...extras,
+                            type: 'applyTransaction',
+                            operations: wrappedOperations,
+                        });
+                    }
+                    else {
+                        ok = await runHighLevelBatch(wrappedOperations);
+                    }
                 }
                 else {
-                    const extras = await mutationExtras(workspace);
-                    const WRITE = new Set([
-                        'setText',
-                        'replaceText',
-                        'setTransform',
-                        'setProperties',
-                        'set',
-                        'xfrmSet',
-                        'zMove',
-                        'add',
-                        'addSlide',
-                        'addShape',
-                        'remove',
-                        'replacePicture',
-                        'duplicate',
-                        'batch',
-                    ]);
                     const list = values ?? [];
-                    if (list.length > 0 &&
-                        list.every((value) => typeof value === 'object' &&
-                            value !== null &&
-                            'op' in value)) {
+                    const classified = classifyApplyOps(list);
+                    if (classified.kind === 'invalid')
+                        throw new Error(classified.message);
+                    if (classified.kind === 'transaction') {
                         ok = await execute('deckuse apply', {
                             ...extras,
                             type: 'applyTransaction',
@@ -541,27 +784,7 @@ const main = async () => {
                         });
                     }
                     else {
-                        const commands = list.map((value) => {
-                            if (typeof value !== 'object' || value === null)
-                                throw new Error('apply input must contain command objects');
-                            const record = value;
-                            if (record['type'] === 'batch')
-                                return record;
-                            if (!WRITE.has(String(record['type'])))
-                                throw new Error(`apply input contains non-write command: ${String(record['type'])}`);
-                            return { ...extras, ...record };
-                        });
-                        const payload = commands.length === 1 && commands[0]?.['type'] !== 'batch'
-                            ? commands[0]
-                            : {
-                                ...extras,
-                                type: 'batch',
-                                atomic: true,
-                                commands: commands.flatMap((command) => command['type'] === 'batch'
-                                    ? command.commands
-                                    : [command]),
-                            };
-                        ok = await execute('deckuse apply', payload);
+                        ok = await runHighLevelBatch(list);
                     }
                 }
             }
@@ -602,24 +825,78 @@ const main = async () => {
                 if (!output)
                     throw new Error('Usage: deckuse export <output.pptx>');
                 const workspace = await findWorkspace(workspaceOpt);
+                const fromPackage = takeFlag(clean, '--from-package');
                 ok = await execute('deckuse export', {
                     version: PROTOCOL_VERSION,
                     type: 'export',
                     workspaceId: workspace,
                     output: resolve(output),
                     ...(revisionOpt ? { revision: revisionOpt } : {}),
+                    ...(fromPackage ? { fromPackage: true } : {}),
                 });
             }
             else if (action === 'monitor') {
-                const workspace = await findWorkspace(workspaceOpt ?? clean[1]);
+                const sub = clean[1] === 'start' || clean[1] === 'stop' || clean[1] === 'status' ? clean[1] : undefined;
+                const daemonWorker = takeFlag(clean, '--daemon-worker');
+                const positionalWorkspace = sub
+                    ? clean[2] && !clean[2].startsWith('--')
+                        ? clean[2]
+                        : undefined
+                    : clean[1] && !clean[1].startsWith('--')
+                        ? clean[1]
+                        : undefined;
+                const workspace = await findWorkspace(workspaceOpt ?? positionalWorkspace);
                 const port = Number(optionFrom(clean, '--port') ?? 4173);
                 if (!Number.isInteger(port) || port < 0 || port > 65535)
                     throw new Error('--port must be an integer between 0 and 65535');
-                const monitor = await startMonitor(workspace, {
-                    host: optionFrom(clean, '--host') ?? '0.0.0.0',
+                const host = optionFrom(clean, '--host') ?? '0.0.0.0';
+                if (sub === 'start') {
+                    try {
+                        const meta = await monitorStart(workspace, { host, port });
+                        outputEnvelope({
+                            ok: true,
+                            command: 'deckuse monitor start',
+                            data: meta,
+                        });
+                    }
+                    catch (error) {
+                        outputEnvelope({
+                            ok: false,
+                            command: 'deckuse monitor start',
+                            error: {
+                                code: 'IO_ERROR',
+                                message: error instanceof Error ? error.message : 'Monitor start failed',
+                            },
+                        });
+                        process.exitCode = 1;
+                    }
+                    return;
+                }
+                if (sub === 'stop') {
+                    const result = await monitorStop(workspace);
+                    outputEnvelope({
+                        ok: true,
+                        command: 'deckuse monitor stop',
+                        data: result,
+                    });
+                    return;
+                }
+                if (sub === 'status') {
+                    const result = await monitorStatus(workspace);
+                    outputEnvelope({
+                        ok: true,
+                        command: 'deckuse monitor status',
+                        data: result,
+                    });
+                    return;
+                }
+                const monitor = await runMonitorForeground(workspace, {
+                    host,
                     port,
+                    asDaemonWorker: daemonWorker,
                 });
-                process.stdout.write(`Deckuse monitor: ${monitor.url}\n`);
+                if (!daemonWorker)
+                    process.stdout.write(`Deckuse monitor: ${monitor.url}\n`);
                 const shutdown = async (signal) => {
                     process.stderr.write(`deckuse monitor: received ${signal}, shutting down\n`);
                     await monitor.close();
@@ -632,23 +909,29 @@ const main = async () => {
             else if (action === 'render') {
                 const pageRaw = optionFrom(clean, '--page');
                 if (!pageRaw)
-                    throw new Error('Usage: deckuse render --page <n> [--output <file.png>]');
+                    throw new Error('Usage: deckuse render --page <n> [--output <file.png>] [--scale <n>]');
                 if (/\s|,|-/.test(pageRaw))
                     throw new Error('--page accepts exactly one positive integer (not a range or list)');
                 const page = Number(pageRaw);
                 if (!Number.isInteger(page) || page < 1)
                     throw new Error('--page must be a positive integer');
+                const scaleRaw = optionFrom(clean, '--scale');
+                const scale = scaleRaw !== undefined ? Number(scaleRaw) : undefined;
+                if (scale !== undefined && !(scale > 0))
+                    throw new Error('--scale must be a positive number');
                 const workspace = await findWorkspace(workspaceOpt ?? clean[1]);
                 const outputOpt = optionFrom(clean, '--output');
                 try {
                     const rendered = await renderPage(workspace, {
                         page,
                         ...(outputOpt ? { output: resolve(outputOpt) } : {}),
+                        ...(scale !== undefined ? { scale } : {}),
                     });
                     outputEnvelope({
                         ok: true,
                         command: 'deckuse render',
-                        data: { page: rendered.page, output: rendered.output },
+                        warnings: [...rendered.warnings],
+                        data: { page: rendered.page, output: rendered.output, warnings: rendered.warnings },
                     });
                 }
                 catch (error) {