@wji.ai/cli 0.7.0 → 0.7.1

package/dist/commands/canvas.js

@@ -1,1706 +0,0 @@
-import { Command } from 'commander';
-import { WjiClient } from '../core/client.js';
-import { confirm, parseKeyValues, readValue } from '../core/prompt.js';
-import { clipText, color, detail, detailLevel, info, isJsonMode, printJson, relativeTime, render, success, table, truncate, warn } from '../core/output.js';
-import { pollHistory, reportHistory, resolveAssets } from './gen.js';
-import { loadMembers, memberLabel, resolveMember } from '../core/members.js';
-import { fetchModels } from './model.js';
-/**
- * Infinite Canvas over the plain fsnode API.
- *
- * A canvas is a folder (`workspace-v2/canvas`). Each node is a child file with
- * mimetype `canvas/node/<kind>`, and each connection is a child file with
- * mimetype `canvas/edge` whose content is `{fromNodeId, toNodeId, …}`. Edges
- * into a media generate node are its references, numbered per kind in edge
- * order (`@image1`, `@image2`, …).
- *
- * The browser can "link" a canvas (link button in the canvas top bar). That
- * stores the open workspace, canvas and selection on the user for 5 minutes,
- * so these commands default to the linked canvas and can read what is
- * selected. Writes go straight to the API; an open canvas picks them up
- * through its normal live sync.
- */
-const NODE_PREFIX = 'canvas/node/';
-const EDGE_MIMETYPE = 'canvas/edge';
-export const CANVAS_MIMETYPE = 'workspace-v2/canvas';
-const CANVASES_MIMETYPE = 'workspace-v2/canvases';
-const DATASET_MIMETYPE = 'workspace/dataset';
-const CREATABLE_KINDS = ['text', 'title', 'comment', 'image', 'video', 'audio', 'dataset'];
-const MEDIA_KINDS = new Set(['image', 'video', 'audio']);
-const TEXT_KINDS = new Set(['text', 'title', 'comment']);
-/** Default names the canvas UI shows localized. */
-const DEFAULT_NAMES = {
-    text: '文本',
-    title: '标题',
-    comment: '备注',
-    image: '图片',
-    video: '视频',
-    audio: '音频',
-    dataset: '数据集',
-};
-/** What the web writes into a brand-new canvas folder (CanvasAppFileSystem.createCanvas). */
-export const INITIAL_CANVAS_CONTENT = {
-    data: { viewport: { x: 0, y: 0, zoom: 1 }, backgroundMode: 'dots' },
-    metadata: {},
-};
-/** The canvas lays media out on a 250px short side; text nodes are wider. */
-const MEDIA_BASE = 250;
-const PLACE_GAP = 80;
-const PENDING = 0;
-/**
- * The canvas's color tags (nodeColorTags.ts on the web). A node stores only
- * `content.colorTag {colorId}`; the label is shared per color on the canvas
- * folder as `content.colorTagNames {<colorId>: label}`. `alias` is the plain
- * color name the tag reads as, so `--tag red` finds `rose`.
- */
-export const COLOR_TAGS = [
-    { id: 'rose', alias: 'red', hex: '#f43f5e' },
-    { id: 'orange', alias: 'orange', hex: '#f97316' },
-    { id: 'amber', alias: 'yellow', hex: '#eab308' },
-    { id: 'lime', alias: 'green', hex: '#84cc16' },
-    { id: 'teal', alias: 'teal', hex: '#14b8a6' },
-    { id: 'sky', alias: 'blue', hex: '#0ea5e9' },
-    { id: 'violet', alias: 'purple', hex: '#8b5cf6' },
-    { id: 'fuchsia', alias: 'pink', hex: '#d946ef' },
-];
-export const idOf = (value) => value == null ? undefined : typeof value === 'string' ? value : value.id;
-function toList(result) {
-    return Array.isArray(result) ? result : result?.data || [];
-}
-// ── loading ─────────────────────────────────────────────────────────────────
-export async function linkedState(client) {
-    const res = await client.get('/canvas-link');
-    return res?.linked ? res.state : null;
-}
-/** `--canvas` wins; otherwise the canvas linked from the browser. */
-export async function resolveCanvasId(client, explicit) {
-    if (explicit)
-        return explicit;
-    const state = await linkedState(client);
-    if (state?.canvasId)
-        return String(state.canvasId);
-    throw new Error('No canvas. Pass --canvas <id>, or open the canvas in the browser and press the link button in its top bar.');
-}
-export async function loadCanvas(client, canvasId) {
-    // getFresh: read-merge-write must not see the 10s server cache
-    const folder = await client.getFresh(`/fsnode/list/${canvasId}`);
-    if (folder?.mimetype !== CANVAS_MIMETYPE) {
-        throw new Error(`${canvasId} is not a canvas (mimetype ${folder?.mimetype || 'none'})`);
-    }
-    const children = toList(await client.getFresh(`/fsnode/list/${canvasId}/children`, { limit: -1 }));
-    const nodes = [];
-    const edges = [];
-    for (const raw of children) {
-        const mimetype = String(raw.mimetype || '');
-        if (mimetype === EDGE_MIMETYPE) {
-            edges.push({
-                id: raw.id,
-                sort: Number(raw.sort || 0),
-                fromNodeId: String(raw.content?.fromNodeId || ''),
-                toNodeId: String(raw.content?.toNodeId || ''),
-                content: raw.content || {},
-            });
-        }
-        else if (mimetype.startsWith(NODE_PREFIX)) {
-            nodes.push({
-                id: raw.id,
-                kind: mimetype.slice(NODE_PREFIX.length),
-                name: raw.name || '',
-                sort: Number(raw.sort || 0),
-                file: idOf(raw.file),
-                content: raw.content || {},
-                raw,
-            });
-        }
-    }
-    const assetIds = [...new Set(nodes.map((n) => n.file).filter(Boolean))];
-    const assets = new Map();
-    if (assetIds.length) {
-        for (const asset of await client.checkAssetStatus(assetIds))
-            assets.set(asset.id, asset);
-    }
-    return {
-        id: folder.id,
-        name: folder.name,
-        workspaceId: idOf(folder.workspace) || idOf(folder.root) || '',
-        folder,
-        access: canvasAccessOf(folder.content),
-        nodes,
-        edges,
-        byId: new Map(nodes.map((n) => [n.id, n])),
-        assets,
-        tagNames: parseTagNames(canvasEnvelope(folder.content).data.colorTagNames),
-    };
-}
-// ── canvas folder: content envelope and ownership ──────────────────────────
-/**
- * A canvas folder stores `content {data, metadata}`: `data` is the board
- * (viewport, colorTagNames, generateDefaults…), `metadata` its access
- * `{ownerUserId, visibility}`. Legacy canvases hold `data` flat in `content`
- * (the backend then reads access from the top level too).
- */
-export function canvasEnvelope(content) {
-    const c = content && typeof content === 'object' ? content : {};
-    const hasEnvelope = c.data && typeof c.data === 'object' && !Array.isArray(c.data);
-    if (hasEnvelope) {
-        return { data: c.data, metadata: c.metadata && typeof c.metadata === 'object' ? c.metadata : {}, legacy: false };
-    }
-    const { metadata, ownerUserId, visibility, ...data } = c;
-    const meta = metadata && typeof metadata === 'object' ? metadata : { ...(ownerUserId ? { ownerUserId } : {}), ...(visibility ? { visibility } : {}) };
-    return { data, metadata: meta, legacy: true };
-}
-/** Same reading as the backend's readCanvasFolderAccess: only exactly 'owner' hides a canvas. */
-export function canvasAccessOf(content) {
-    const meta = canvasEnvelope(content).metadata;
-    return {
-        ownerUserId: typeof meta.ownerUserId === 'string' ? meta.ownerUserId : '',
-        visibility: meta.visibility === 'owner' ? 'owner' : 'members',
-    };
-}
-/**
- * Write a canvas folder's `data` and/or `metadata`, always as the whole
- * envelope (dropping `metadata` would reset the owner). Versioned with
- * `baseUpdatedAt` and retried on a conflict so a browser saving the board at
- * the same moment is not overwritten.
- */
-export async function updateCanvasFolder(client, canvasId, change) {
-    for (let attempt = 0;; attempt++) {
-        const folder = await client.getFresh(`/fsnode/list/${canvasId}`);
-        if (folder?.mimetype !== CANVAS_MIMETYPE)
-            throw new Error(`${canvasId} is not a canvas`);
-        const env = canvasEnvelope(folder.content);
-        const next = { data: { ...env.data }, metadata: { ...env.metadata } };
-        change(next);
-        try {
-            return await client.patch(`/fsnode/list/${canvasId}`, {
-                content: next,
-                ...(folder.updatedAt ? { baseUpdatedAt: folder.updatedAt } : {}),
-            });
-        }
-        catch (err) {
-            if (err?.status === 409 && attempt < 3)
-                continue;
-            if (err?.status === 403) {
-                throw new Error(`${err.message} — only the workspace owner can change who owns a canvas`);
-            }
-            throw err;
-        }
-    }
-}
-/** Every canvas in the workspace you can see (owner-only canvases of others are hidden unless you own the workspace). */
-export async function listCanvases(client, wsId) {
-    const rows = [];
-    for (const { appId, folderId } of await canvasesFolders(client, wsId)) {
-        const canvases = toList(await client.getFresh(`/fsnode/list/${folderId}/children`, { limit: -1 }));
-        for (const it of canvases.filter((n) => n.mimetype === CANVAS_MIMETYPE)) {
-            rows.push({ id: it.id, name: it.name, appId, ...canvasAccessOf(it.content), updatedAt: it.updatedAt, folder: it });
-        }
-    }
-    return rows;
-}
-// ── color tags ──────────────────────────────────────────────────────────────
-function parseTagNames(raw) {
-    const out = {};
-    if (!raw || typeof raw !== 'object')
-        return out;
-    for (const { id } of COLOR_TAGS) {
-        const value = raw[id];
-        if (typeof value === 'string' && value.trim())
-            out[id] = value.trim();
-    }
-    return out;
-}
-/** The node's tag with the canvas label (never the node's own legacy `name`, as on the web). */
-export function tagOf(canvas, node) {
-    const colorId = node.content.colorTag?.colorId;
-    const tag = COLOR_TAGS.find((t) => t.id === colorId);
-    if (!tag)
-        return undefined;
-    return { color: tag.id, alias: tag.alias, hex: tag.hex, label: canvas.tagNames[tag.id] };
-}
-/**
- * Colors a `--tag` value means: a color id (`rose`), its plain name (`red`),
- * or a label (`C01`, case-insensitive), so several colors can match one label.
- */
-export function resolveTagFilter(canvas, values) {
-    const colors = new Set();
-    for (const value of values) {
-        const v = value.trim().toLowerCase();
-        const matched = COLOR_TAGS.filter((t) => t.id === v || t.alias === v || canvas.tagNames[t.id]?.toLowerCase() === v);
-        if (!matched.length) {
-            const known = COLOR_TAGS.map((t) => (canvas.tagNames[t.id] ? `${t.alias} "${canvas.tagNames[t.id]}"` : t.alias));
-            throw new Error(`No color tag "${value}" on canvas "${canvas.name}". Tags: ${known.join(', ')}`);
-        }
-        for (const t of matched)
-            colors.add(t.id);
-    }
-    return colors;
-}
-/** `C0[1-3]` is case-insensitive; `/C0[1-3]$/` keeps exactly the flags given. */
-export function parseRegex(value, flag) {
-    const slashed = /^\/(.*)\/([a-z]*)$/s.exec(value);
-    try {
-        return slashed ? new RegExp(slashed[1], slashed[2].replace(/[gy]/g, '')) : new RegExp(value, 'i');
-    }
-    catch (err) {
-        throw new Error(`${flag}: invalid regex ${value} — ${err.message}`);
-    }
-}
-export function tagText(tag) {
-    if (!tag)
-        return '';
-    return tag.label ? `${tag.alias} "${tag.label}"` : tag.alias;
-}
-/** The `canvases` folder of every InfiniteCanvas app in a workspace. */
-export async function canvasesFolders(client, wsId) {
-    const ws = await client.get(`/workspace/list/${wsId}`);
-    const apps = (ws.apps || []).filter((a) => a.app === 'InfiniteCanvas' || a.type === 'INFINITE_CANVAS');
-    const out = [];
-    for (const app of apps) {
-        const tree = await client.get(`/workspace/list/${wsId}/fs/${app.id}`);
-        const folder = (tree?.children || []).find((n) => n.mimetype === CANVASES_MIMETYPE);
-        if (folder)
-            out.push({ appId: String(app.id), folderId: String(folder.id) });
-    }
-    return out;
-}
-export function requireNode(canvas, id) {
-    const node = canvas.byId.get(id);
-    if (!node)
-        throw new Error(`Node ${id} is not on canvas "${canvas.name}" (${canvas.id})`);
-    return node;
-}
-/** Incoming edges in the order the canvas numbers them: sort, then id. */
-function referencesOf(canvas, node) {
-    const refs = canvas.edges
-        .filter((e) => e.toNodeId === node.id && canvas.byId.has(e.fromNodeId))
-        .sort((a, b) => a.sort - b.sort || a.id.localeCompare(b.id));
-    const counts = {};
-    return refs.map((edge) => {
-        const from = canvas.byId.get(edge.fromNodeId);
-        counts[from.kind] = (counts[from.kind] || 0) + 1;
-        return {
-            edgeId: edge.id,
-            nodeId: from.id,
-            kind: from.kind,
-            name: from.name,
-            label: edge.content.referenceLabel || `@${from.kind}${counts[from.kind]}`,
-            frameSlot: edge.content.videoFrameSlot,
-        };
-    });
-}
-export function describe(canvas, node) {
-    const asset = node.file ? canvas.assets.get(node.file) : undefined;
-    const generate = node.content.generate;
-    const pending = asset && asset.status === PENDING && !asset.error;
-    return {
-        id: node.id,
-        kind: node.kind,
-        name: node.name,
-        tag: tagOf(canvas, node),
-        position: node.content.position,
-        size: Number(node.content.width) > 0 && Number(node.content.height) > 0 ? { width: Number(node.content.width), height: Number(node.content.height) } : undefined,
-        mode: MEDIA_KINDS.has(node.kind) ? node.content.mode || 'display' : undefined,
-        text: TEXT_KINDS.has(node.kind) ? node.content.text ?? '' : undefined,
-        assetId: node.file,
-        url: asset?.url || undefined,
-        assetType: asset?.type,
-        dataset: node.kind === 'dataset' && node.content.datasetId
-            ? { id: String(node.content.datasetId), name: node.content.datasetName, type: node.content.datasetType, folder: node.content.datasetParentName }
-            : undefined,
-        status: generate?.historyId ? (pending ? 'generating' : asset?.error ? 'failed' : asset?.url ? 'done' : 'pending') : undefined,
-        error: asset?.error?.message || asset?.error || undefined,
-        generate,
-        references: referencesOf(canvas, node),
-        outgoing: canvas.edges.filter((e) => e.fromNodeId === node.id).map((e) => e.toNodeId),
-    };
-}
-/**
- * The canvas commands always load the full canvas (edits and generation need
- * every field), so --detail is applied here, to the JSON they print. Mirrors
- * the backend's canvas_list_nodes levels.
- */
-export function trimDescribed(row, level = detailLevel()) {
-    if (!level || level === 'full')
-        return row;
-    if (level === 'brief') {
-        return compactRow({
-            id: row.id,
-            kind: row.kind,
-            name: row.name,
-            tag: row.tag,
-            mode: row.mode,
-            status: row.status,
-            assetId: row.assetId,
-            position: row.position,
-            references: row.references.map((r) => ({ nodeId: r.nodeId, label: r.label })),
-            outgoing: row.outgoing,
-        });
-    }
-    const g = row.generate;
-    return compactRow({
-        ...row,
-        text: row.text === undefined ? undefined : clipText(row.text) ?? '',
-        error: typeof row.error === 'string' ? clipText(row.error) : row.error,
-        generate: g
-            ? compactRow({
-                prompt: clipText(g.prompt),
-                model: g.model,
-                ratio: g.ratio,
-                resolution: g.resolution,
-                duration: g.duration,
-                historyId: g.historyId,
-                pendingAssetId: g.pendingAssetId,
-            })
-            : undefined,
-    });
-}
-function compactRow(value) {
-    const out = {};
-    for (const key of Object.keys(value))
-        if (value[key] !== undefined)
-            out[key] = value[key];
-    return out;
-}
-// ── models ──────────────────────────────────────────────────────────────────
-/** An audio node is fed by either an `audio` or a `tts` model — the backend tags voice models `tts`. */
-const KIND_FEATURES = { audio: ['audio', 'tts'] };
-async function findModel(client, kind, name, workspaceId) {
-    const features = KIND_FEATURES[kind] ?? [kind];
-    const rows = (await Promise.all(features.map((f) => fetchModels(client, { features: [f], workspace: workspaceId })))).flat();
-    const usable = rows.filter((m) => m.enabled !== false);
-    const model = usable.find((m) => m.nickname === name) ?? usable.find((m) => m.name === name);
-    if (!model) {
-        const hint = features.map((f) => `--feature ${f}`).join(' / ');
-        throw new Error(`No ${kind} model "${name}". See \`wji models list ${hint}\`.`);
-    }
-    return model;
-}
-/**
- * Fill and validate generate settings the way the canvas generate panel does
- * (shared/generate/formDefaults.ts): ratio from the model's list, resolution
- * from `form.other.resolution`, other params from their defaults, and unknown
- * params dropped.
- */
-function applyModelDefaults(model, kind, generate, opts) {
-    const form = model.form || {};
-    const other = form.other || {};
-    const next = { ...generate, model: model.nickname || model.name };
-    const ratios = form.aspectRatio || [];
-    if (kind !== 'audio' && ratios.length) {
-        if (next.ratio && !ratios.includes(next.ratio)) {
-            if (opts.explicit.has('ratio')) {
-                throw new Error(`${next.model} does not support ratio ${next.ratio}. Use one of: ${ratios.join(' ')}`);
-            }
-            next.ratio = undefined;
-        }
-        if (!next.ratio) {
-            next.ratio = opts.workspaceRatio && ratios.includes(opts.workspaceRatio) ? opts.workspaceRatio : ratios[0];
-        }
-    }
-    const resField = other.resolution;
-    if (resField?.options?.length) {
-        const valid = resField.options.map((o) => String(o.value));
-        if (next.resolution && !valid.includes(String(next.resolution))) {
-            if (opts.explicit.has('resolution')) {
-                throw new Error(`${next.model} resolution must be one of: ${valid.join(' ')}`);
-            }
-            next.resolution = undefined;
-        }
-        if (!next.resolution)
-            next.resolution = String(resField.default ?? valid[0]);
-    }
-    const durationForm = form.video?.duration;
-    if (kind === 'video' && durationForm?.enable) {
-        if (next.duration != null) {
-            const d = Number(next.duration);
-            if (d < durationForm.min || d > durationForm.max) {
-                throw new Error(`${next.model} duration must be ${durationForm.min}–${durationForm.max}s`);
-            }
-        }
-        else {
-            next.duration = durationForm.default;
-        }
-    }
-    const values = {};
-    for (const [key, value] of Object.entries(next.values || {})) {
-        if (key in other && key !== 'resolution')
-            values[key] = value;
-        else if (opts.explicit.has(`values.${key}`))
-            warn(`${next.model} has no parameter "${key}" — ignored`);
-    }
-    for (const [key, field] of Object.entries(other)) {
-        if (key === 'resolution')
-            continue;
-        const current = values[key];
-        const empty = current === undefined || current === null || current === '';
-        if (empty && field.default !== undefined)
-            values[key] = field.default;
-        if (field.type === 'select' && field.options?.length) {
-            const valid = field.options.map((o) => o.value);
-            if (!empty && !valid.includes(current)) {
-                if (opts.explicit.has(`values.${key}`)) {
-                    throw new Error(`${next.model} parameter ${key} must be one of: ${valid.join(' ')}`);
-                }
-                values[key] = field.default ?? valid[0];
-            }
-        }
-    }
-    // An explicit duration is ignored while auto-duration is on, so turn it off.
-    if (kind === 'video' && opts.explicit.has('duration') && 'autoDuration' in other && !opts.explicit.has('values.autoDuration')) {
-        values.autoDuration = false;
-    }
-    next.values = values;
-    if (next.improvePromptEnabled === undefined)
-        next.improvePromptEnabled = false;
-    return next;
-}
-// ── writes ──────────────────────────────────────────────────────────────────
-/** Short side 250, like the canvas; text-ish nodes use a typical card size. */
-export function estimateSize(canvas, node) {
-    const w = Number(node.content.width);
-    const h = Number(node.content.height);
-    if (w > 0 && h > 0)
-        return { width: w, height: h };
-    if (node.kind === 'dataset')
-        return { width: 480, height: 220 };
-    if (!MEDIA_KINDS.has(node.kind))
-        return { width: 320, height: 200 };
-    const ratioText = node.content.mode === 'generate' ? node.content.generate?.ratio : undefined;
-    const asset = node.file ? canvas.assets.get(node.file) : undefined;
-    let ratio = node.kind === 'video' ? 16 / 9 : 1;
-    if (asset?.width && asset?.height)
-        ratio = asset.width / asset.height;
-    else if (ratioText && /^\d+(\.\d+)?:\d+(\.\d+)?$/.test(ratioText)) {
-        const [w, h] = ratioText.split(':').map(Number);
-        ratio = w / h;
-    }
-    if (node.kind === 'audio')
-        ratio = 1;
-    return ratio >= 1
-        ? { width: Math.round(MEDIA_BASE * ratio), height: MEDIA_BASE }
-        : { width: MEDIA_BASE, height: Math.round(MEDIA_BASE / ratio) };
-}
-/**
- * Right of the anchor nodes, top-aligned (else right of everything), then
- * pushed down past any node already sitting there.
- */
-function placeNear(canvas, anchors, size) {
-    const pool = anchors.length ? anchors : canvas.nodes;
-    if (!pool.length)
-        return { x: 0, y: 0 };
-    let right = -Infinity;
-    let top = Infinity;
-    for (const node of pool) {
-        const p = node.content.position || { x: 0, y: 0 };
-        right = Math.max(right, Number(p.x) + estimateSize(canvas, node).width);
-        top = Math.min(top, Number(p.y));
-    }
-    const x = Math.round(right + PLACE_GAP);
-    let y = Math.round(top);
-    for (let guard = 0; guard < 200; guard++) {
-        const hit = canvas.nodes.find((node) => {
-            const p = node.content.position || { x: 0, y: 0 };
-            const s = estimateSize(canvas, node);
-            return x < p.x + s.width && x + size.width > p.x && y < p.y + s.height && y + size.height > p.y;
-        });
-        if (!hit)
-            break;
-        y = Math.round(Number(hit.content.position?.y || 0) + estimateSize(canvas, hit).height + PLACE_GAP);
-    }
-    return { x, y };
-}
-function usesFrameSlots(model) {
-    const support = model?.form?.video?.support || [];
-    return { start: support.includes('start'), end: support.includes('end') };
-}
-async function createEdge(client, canvas, fromId, toId, opts = {}) {
-    const from = requireNode(canvas, fromId);
-    const to = requireNode(canvas, toId);
-    if (from.id === to.id)
-        throw new Error('A node cannot reference itself');
-    if (canvas.edges.some((e) => e.fromNodeId === from.id && e.toNodeId === to.id)) {
-        throw new Error(`${from.id} is already connected to ${to.id}`);
-    }
-    const content = {
-        fromNodeId: from.id,
-        toNodeId: to.id,
-        sourceHandle: 'right',
-        targetHandle: 'left',
-        ...(opts.content || {}),
-    };
-    // First/last-frame video models take connected images as frame slots, in order.
-    if (opts.frameModel && to.kind === 'video' && from.kind === 'image') {
-        const support = usesFrameSlots(opts.frameModel);
-        const taken = new Set(referencesOf(canvas, to).map((r) => r.frameSlot).filter(Boolean));
-        if (support.start && !taken.has('start'))
-            content.videoFrameSlot = 'start';
-        else if (support.end && !taken.has('end'))
-            content.videoFrameSlot = 'end';
-    }
-    const raw = await client.post('/fsnode/create', {
-        name: '连线',
-        type: 'file',
-        mimetype: EDGE_MIMETYPE,
-        parent: canvas.id,
-        content,
-        sort: 0,
-    });
-    const edge = { id: raw.id, sort: 0, fromNodeId: from.id, toNodeId: to.id, content };
-    canvas.edges.push(edge);
-    return edge;
-}
-/**
- * Write only the top-level content keys that changed (`contentPatch`), so an
- * edit here does not overwrite what someone else changed in another key at
- * the same moment in the browser. A backend without `contentPatch` strips it
- * silently; the response then lacks the change and we write the whole content.
- */
-async function patchNode(client, node, change) {
-    const { content, ...rest } = change;
-    const contentPatch = {};
-    const contentUnset = [];
-    if (content) {
-        for (const key of new Set([...Object.keys(node.content), ...Object.keys(content)])) {
-            if (!(key in content))
-                contentUnset.push(key);
-            else if (JSON.stringify(content[key]) !== JSON.stringify(node.content[key]))
-                contentPatch[key] = content[key];
-        }
-    }
-    const body = { ...rest };
-    if (Object.keys(contentPatch).length)
-        body.contentPatch = contentPatch;
-    if (contentUnset.length)
-        body.contentUnset = contentUnset;
-    if (!Object.keys(body).length)
-        return node.raw;
-    const res = await client.patch(`/fsnode/list/${node.id}`, body);
-    const landed = Object.entries(contentPatch).every(([k, v]) => JSON.stringify(res?.content?.[k]) === JSON.stringify(v)) &&
-        contentUnset.every((k) => !(k in (res?.content || {})));
-    if (content && !landed)
-        return client.patch(`/fsnode/list/${node.id}`, { ...rest, content });
-    return res;
-}
-// ── output ──────────────────────────────────────────────────────────────────
-function summary(n) {
-    if (n.text !== undefined)
-        return String(n.text).replace(/\s+/g, ' ');
-    if (n.dataset)
-        return [n.dataset.type, n.dataset.name, color.dim(n.dataset.id)].filter(Boolean).join(' ');
-    if (n.mode === 'generate') {
-        const g = n.generate || {};
-        const state = n.status === 'done' ? color.green('done') : n.status === 'failed' ? color.red('failed') : n.status ? color.yellow(n.status) : '';
-        return [state, [g.model, g.ratio, g.duration && `${g.duration}s`].filter(Boolean).join(' '), g.prompt && `"${g.prompt}"`]
-            .filter(Boolean)
-            .join(' · ');
-    }
-    return n.url || n.assetId || '';
-}
-export function nodeTable(rows) {
-    table(rows, [
-        { header: 'id', value: (n) => n.id },
-        { header: 'kind', value: (n) => (n.mode === 'generate' ? `${n.kind}*` : n.kind) },
-        { header: 'name', value: (n) => truncate(n.name, 20) },
-        { header: 'tag', value: (n) => truncate(tagText(n.tag), 16) },
-        { header: 'refs', value: (n) => n.references.map((r) => r.label).join(',') },
-        { header: 'summary', value: (n) => truncate(summary(n), 64) },
-    ]);
-}
-function printNode(n) {
-    const g = n.generate || {};
-    detail([
-        ['id', n.id],
-        ['kind', n.mode ? `${n.kind} (${n.mode})` : n.kind],
-        ['name', n.name],
-        ['tag', n.tag && `${tagText(n.tag)} ${color.dim(n.tag.color)}`],
-        ['position', n.position && `${Math.round(n.position.x)},${Math.round(n.position.y)}`],
-        ['size', n.size && `${n.size.width}×${n.size.height}`],
-        ['text', n.text],
-        ['dataset', n.dataset && `${n.dataset.type || 'dataset'} "${n.dataset.name || ''}" ${color.dim(n.dataset.id)}${n.dataset.folder ? ` in ${n.dataset.folder}` : ''}`],
-        ['asset', n.assetId],
-        ['url', n.url],
-        ['status', n.status],
-        ['error', n.error],
-        ['prompt', g.prompt],
-        ['model', g.model],
-        ['ratio', g.ratio],
-        ['resolution', g.resolution],
-        ['duration', g.duration],
-        ['params', g.values && Object.keys(g.values).length ? JSON.stringify(g.values) : undefined],
-        ['history', g.historyId],
-        [
-            'references',
-            n.references.length
-                ? n.references.map((r) => `${r.label}${r.frameSlot ? `(${r.frameSlot})` : ''} ← ${r.nodeId}`).join(', ')
-                : undefined,
-        ],
-    ]);
-}
-/** Prompts start with `@image1`, so a leading `@` is text here, not a file. */
-async function literalOrFile(value, file) {
-    if (file !== undefined)
-        return readValue(`@${file}`);
-    if (value === undefined)
-        return undefined;
-    return value === '-' ? readValue('-') : value;
-}
-/**
- * Text, title and comment nodes are Markdown on the web (a single line break joins the lines into
- * one paragraph). `--plain` keeps plain text as written: a line break becomes a Markdown hard break
- * ("  \n"); blank lines stay paragraph breaks and fenced code blocks are left alone.
- */
-export function plainToMarkdown(text) {
-    let fenced = false;
-    const lines = text.replace(/\r\n?/g, '\n').split('\n');
-    return lines
-        .map((line, i) => {
-        const fence = /^\s*(```|~~~)/.test(line);
-        if (fence)
-            fenced = !fenced;
-        const next = lines[i + 1];
-        const hard = !fence && !fenced && i < lines.length - 1 && line.trim() !== '' && next !== undefined && next.trim() !== '' && !/^\s*(```|~~~)/.test(next);
-        return hard ? `${line.replace(/\s+$/, '')}  ` : line;
-    })
-        .join('\n');
-}
-/** True when a single line break would be joined away by the web's Markdown rendering. */
-export function hasSoftBreaks(text) {
-    return /[^\s\n][ \t]?\n(?![ \t]*\n)[ \t]*\S/.test(text.replace(/\r\n?/g, '\n').replace(/ {2,}\n/g, '\n\n'));
-}
-async function nodeText(kind, opts) {
-    const text = await literalOrFile(opts.text, opts.textFile);
-    if (text === undefined)
-        return undefined;
-    if (opts.plain)
-        return plainToMarkdown(text);
-    if (TEXT_KINDS.has(kind) && hasSoftBreaks(text) && !isJsonMode()) {
-        warn('text nodes render as Markdown on the web — single line breaks join into one paragraph; pass --plain to keep them');
-    }
-    return text;
-}
-function parseSize(value) {
-    const [width, height] = value.split(/[,x×]/i).map((v) => Number(v.trim()));
-    if (!(width > 0 && height > 0))
-        throw new Error('--size must look like width,height (e.g. 600,900)');
-    return { width: Math.round(width), height: Math.round(height) };
-}
-function parsePoint(value, label) {
-    const [x, y] = value.split(',').map((v) => Number(v.trim()));
-    if (!Number.isFinite(x) || !Number.isFinite(y))
-        throw new Error(`${label} must look like x,y`);
-    return { x, y };
-}
-/** Collect generate options; `explicit` records what the user actually passed. */
-async function generateOptions(opts) {
-    const patch = {};
-    const explicit = new Set();
-    const prompt = await literalOrFile(opts.prompt, opts.promptFile);
-    if (prompt !== undefined)
-        (patch.prompt = prompt), explicit.add('prompt');
-    if (opts.model !== undefined)
-        (patch.model = opts.model), explicit.add('model');
-    if (opts.ratio !== undefined)
-        (patch.ratio = opts.ratio), explicit.add('ratio');
-    if (opts.resolution !== undefined)
-        (patch.resolution = opts.resolution), explicit.add('resolution');
-    if (opts.duration !== undefined) {
-        const d = Number(opts.duration);
-        if (!Number.isFinite(d))
-            throw new Error('--duration must be seconds');
-        patch.duration = d;
-        explicit.add('duration');
-    }
-    if (opts.set?.length) {
-        patch.values = parseKeyValues(opts.set);
-        for (const key of Object.keys(patch.values))
-            explicit.add(`values.${key}`);
-    }
-    return { patch, explicit };
-}
-function withGenerateOptions(cmd) {
-    return cmd
-        .option('-p, --prompt <text>', 'generation prompt; @image1 etc. are literal (- reads stdin)')
-        .option('--prompt-file <path>', 'read the prompt from a file')
-        .option('-m, --model <model>', 'model nickname (see `wji models list --feature <kind>`)')
-        .option('-r, --ratio <ratio>', 'aspect ratio, e.g. 16:9')
-        .option('--resolution <res>', 'e.g. 720p, 1K')
-        .option('-d, --duration <sec>', 'video duration (turns auto-duration off)')
-        .option('--set <key=value...>', 'model parameters from `wji models get`, merged into existing ones');
-}
-// ── generation ──────────────────────────────────────────────────────────────
-const UNSUPPORTED_REF_KINDS = new Set(['table', 'youtube', 'dataset', 'bundle', 'sprite', 'layer', 'panorama']);
-// Seedance 2.5 draft mode (frontend shared/func/seedanceDraft.ts): 2.5 + 480p is a draft, and a draft
-// becomes the finished 1080p clip only through its BytePlus task id (draftTaskId), within 7 days.
-const SEEDANCE_25_MODELS = new Set(['seedance-2.5', 'seedance-2.5-uncensored', 'seedance-2.5-ref', 'seedance-2.5-ref-uncensored']);
-const SEEDANCE_DRAFT_TTL_MS = 7 * 24 * 60 * 60 * 1000;
-function isSeedance25(model) {
-    return !!model && SEEDANCE_25_MODELS.has(model);
-}
-/** The flag the web form sets before submitting (syncSeedanceDraftFlag) — every 2.5 + 480p generation is a draft. */
-function syncSeedanceDraftFlag(model, values) {
-    if (isSeedance25(model) && String(values.resolution || '') === '480p')
-        values.draft = true;
-    else
-        delete values.draft;
-    return values;
-}
-function draftTaskIdOf(values) {
-    const raw = values?.draftTaskId;
-    return typeof raw === 'string' ? raw.trim() : '';
-}
-/**
- * What a finished clip can be upscaled from — like the web's canSeedanceDraftUpscale: flagged as a
- * draft (config.values.draft), carrying its BytePlus task id (the draft id), and not past 7 days.
- */
-function seedanceDraftSource(asset) {
-    const taskId = String(asset?.extra?.byteplus?.taskId || '').trim();
-    const model = String(asset?.config?.model || '');
-    const created = asset?.createdAt ? Date.parse(asset.createdAt) : Number.NaN;
-    const expiresAt = Number.isFinite(created) ? new Date(created + SEEDANCE_DRAFT_TTL_MS) : undefined;
-    return {
-        taskId,
-        model,
-        flagged: asset?.config?.values?.draft === true,
-        resolution: String(asset?.config?.values?.resolution || ''),
-        expiresAt,
-        expired: !expiresAt || Date.now() > expiresAt.getTime(),
-    };
-}
-/**
- * Build the same request the canvas generate button sends
- * (shared/generate/buildSubmitPayload.ts): references in edge order, text
- * references prefixed to the prompt, first/last frames from frame slots.
- */
-function buildSubmit(canvas, node, model) {
-    const kind = node.kind;
-    const g = node.content.generate || {};
-    // Draft → 1080p upscale (buildCanvasVideoSubmitPayload): only the draft task id counts — no
-    // prompt, no references; the edge from the draft clip is there for people reading the canvas.
-    const draftTaskId = kind === 'video' ? draftTaskIdOf(g.values) : '';
-    if (draftTaskId) {
-        const duration = typeof g.duration === 'number' && Number.isFinite(g.duration) ? g.duration : undefined;
-        return {
-            originalPrompt: g.prompt || 'N/A',
-            prompt: g.prompt || 'N/A',
-            model: g.model,
-            aspectRatio: g.ratio,
-            n: 1,
-            workspace: canvas.workspaceId,
-            fsnode: node.id,
-            scope: 'canvas',
-            scopeId: canvas.id,
-            duration,
-            values: {
-                ...(g.values || {}),
-                mode: 'video',
-                resolution: '1080p',
-                draft: false,
-                draftTaskId,
-                ...(duration !== undefined ? { duration } : {}),
-            },
-        };
-    }
-    const userPrompt = String(g.prompt || '').trim();
-    const form = model.form || {};
-    const frames = usesFrameSlots(model);
-    const firstLast = frames.start && frames.end;
-    const texts = [];
-    const images = [];
-    const videos = [];
-    const audios = [];
-    let startImage;
-    let endImage;
-    for (const ref of referencesOf(canvas, node)) {
-        const from = canvas.byId.get(ref.nodeId);
-        if (from.kind === 'text') {
-            const body = String(from.content.text || '').trim();
-            if (body)
-                texts.push(from.name ? `[${from.name}]\n${body}` : body);
-            continue;
-        }
-        if (TEXT_KINDS.has(from.kind))
-            continue;
-        if (UNSUPPORTED_REF_KINDS.has(from.kind)) {
-            throw new Error(`Reference ${ref.label} is a ${from.kind} node, which only the canvas UI can submit. Generate this node from the browser.`);
-        }
-        const asset = from.file ? canvas.assets.get(from.file) : undefined;
-        if (!asset?.url) {
-            throw new Error(`Reference ${ref.label} (${from.id}) has no finished asset yet`);
-        }
-        const item = { assetId: asset.id };
-        const category = String(asset.category || asset.type || from.kind);
-        if (category.startsWith('image')) {
-            if (kind === 'video' && (frames.start || frames.end) && ref.frameSlot) {
-                if (ref.frameSlot === 'start' && frames.start && !startImage)
-                    startImage = item;
-                if (ref.frameSlot === 'end' && frames.end && !endImage)
-                    endImage = item;
-                continue;
-            }
-            images.push(item);
-        }
-        else if (category.startsWith('video'))
-            videos.push({ ...item, duration: asset.duration });
-        else if (category.startsWith('audio'))
-            audios.push(item);
-    }
-    const refMax = form.reference?.enable ? Number(form.reference.max || 0) : 0;
-    const imageRefs = kind === 'video' && firstLast ? [] : images;
-    if (imageRefs.length > refMax) {
-        throw new Error(`${g.model} accepts ${refMax} reference image(s); this node has ${imageRefs.length}. Disconnect some first.`);
-    }
-    if (videos.length && kind === 'video' && !form.referenceVideos) {
-        throw new Error(`${g.model} does not take reference videos`);
-    }
-    if (audios.length && !form.referenceAudios) {
-        throw new Error(`${g.model} does not take reference audio`);
-    }
-    const prompt = texts.length ? `${texts.join('\n\n')}${userPrompt ? `\n\n${userPrompt}` : ''}` : userPrompt;
-    if (!prompt)
-        throw new Error(`Node ${node.id} has no prompt. Set one with \`wji canvas set ${node.id} -p "…"\`.`);
-    const values = { ...(g.values || {}) };
-    const other = form.other || {};
-    let aspectRatio = g.ratio;
-    let duration = g.duration;
-    if (kind === 'video') {
-        const seedanceRef = !!other.taskMode;
-        const taskMode = values.taskMode === 'edit' || values.taskMode === 'extend' ? values.taskMode : 'generate';
-        if (seedanceRef && taskMode !== 'generate')
-            aspectRatio = 'adaptive';
-        const autoDuration = 'autoDuration' in other && !(seedanceRef && taskMode === 'edit') && values.autoDuration !== false;
-        if ((seedanceRef && taskMode === 'edit') || autoDuration)
-            duration = -1;
-        if (seedanceRef && taskMode === 'edit')
-            values.outputFormat = 'mov';
-    }
-    const body = {
-        originalPrompt: userPrompt,
-        prompt,
-        model: g.model,
-        aspectRatio,
-        n: kind === 'image' ? Math.max(1, Number(values.n) || 1) : 1,
-        workspace: canvas.workspaceId,
-        fsnode: node.id,
-        scope: 'canvas',
-        scopeId: canvas.id,
-        values: {
-            mode: kind === 'audio' ? 'text-to-audio' : kind,
-            ...values,
-            ...(kind !== 'audio' && g.resolution ? { resolution: g.resolution } : {}),
-        },
-    };
-    if (kind === 'video')
-        syncSeedanceDraftFlag(g.model, body.values);
-    if (imageRefs.length)
-        body.referenceImages = imageRefs;
-    if (kind === 'video') {
-        body.duration = duration ?? 5;
-        if (startImage)
-            body.startImage = startImage;
-        if (endImage)
-            body.endImage = endImage;
-        if (videos.length)
-            body.referenceVideos = videos.map(({ assetId }) => ({ assetId }));
-    }
-    if (audios.length)
-        body.referenceAudios = audios;
-    return body;
-}
-// ── ownership, tags and copy helpers ───────────────────────────────────────
-export function parseVisibility(value) {
-    const v = value.toLowerCase();
-    if (v === 'owner' || v === 'private')
-        return 'owner';
-    if (v === 'members' || v === 'member' || v === 'workspace')
-        return 'members';
-    throw new Error(`--visibility must be owner or members (got ${value})`);
-}
-/** A new canvas folder the way the web creates one, with its access in the metadata envelope. */
-export async function createCanvasFolder(client, canvasesFolderId, name, access) {
-    const metadata = {};
-    if (access?.ownerUserId)
-        metadata.ownerUserId = access.ownerUserId;
-    if (access?.visibility)
-        metadata.visibility = access.visibility;
-    return client.post('/fsnode/create', {
-        name,
-        type: 'folder',
-        mimetype: CANVAS_MIMETYPE,
-        parent: canvasesFolderId,
-        content: { ...INITIAL_CANVAS_CONTENT, metadata },
-    });
-}
-/** One color id from a color name, id or this canvas's label. */
-export function colorOfTag(canvas, tag) {
-    const colors = [...resolveTagFilter(canvas, [tag])];
-    if (colors.length > 1)
-        throw new Error(`Label "${tag}" is on several colors (${colors.join(', ')}) — name the color`);
-    return colors[0];
-}
-/** The source canvas and the nodes to copy: ids given, and/or the linked selection. */
-export async function copySource(c, ids, opts) {
-    const linked = opts.selected || !ids.length ? await linkedState(c) : null;
-    const useSelection = opts.selected || !ids.length;
-    if (useSelection && !linked?.selectedNodeIds?.length) {
-        throw new Error('Nothing to copy: pass node ids, or select nodes in the browser canvas and press link');
-    }
-    const sourceId = opts.canvas || (useSelection ? linked.canvasId : await resolveCanvasId(c));
-    if (useSelection && opts.canvas && opts.canvas !== linked.canvasId) {
-        throw new Error(`The selection is on canvas ${linked.canvasId}, not ${opts.canvas}`);
-    }
-    const source = await loadCanvas(c, sourceId);
-    const nodeIds = [...new Set([...ids, ...(useSelection ? linked.selectedNodeIds : [])])];
-    return { source, nodes: nodeIds.map((id) => requireNode(source, id)) };
-}
-export function copyPlacement(opts) {
-    return { at: opts.at ? parsePoint(opts.at, '--at') : undefined, samePosition: !!opts.samePosition };
-}
-/** The canvas's own copy rule (cloneContentForDuplicate): no position, no generation run, finished media shared. */
-function copyableFile(canvas, node) {
-    const asset = node.file ? canvas.assets.get(node.file) : undefined;
-    return asset?.url && asset.status !== PENDING && !asset.error ? node.file : undefined;
-}
-/**
- * Copy nodes from one canvas into another, like the canvas's copy-paste:
- * new nodes, connections among them re-created in reference order, color
- * tags kept (and their label carried over when the target has none).
- */
-export async function copyNodes(c, source, nodes, target, placement = {}) {
-    const pos = (n) => ({ x: Number(n.content.position?.x) || 0, y: Number(n.content.position?.y) || 0 });
-    const minX = Math.min(...nodes.map((n) => pos(n).x));
-    const minY = Math.min(...nodes.map((n) => pos(n).y));
-    let origin = placement.at;
-    if (!origin && !placement.samePosition && target.nodes.length) {
-        const right = Math.max(...target.nodes.map((n) => pos(n).x + estimateSize(target, n).width));
-        const top = Math.min(...target.nodes.map((n) => pos(n).y));
-        origin = { x: Math.round(right + PLACE_GAP * 2), y: Math.round(top) };
-    }
-    if (!origin)
-        origin = { x: minX, y: minY };
-    // Labels travel with the tag when the target has no label for that color yet.
-    const labels = {};
-    for (const n of nodes) {
-        const colorId = n.content.colorTag?.colorId;
-        const label = colorId && source.tagNames[colorId];
-        if (!label)
-            continue;
-        if (!target.tagNames[colorId])
-            labels[colorId] = label;
-        else if (target.tagNames[colorId] !== label) {
-            warn(`${target.name}: ${colorId} is labelled "${target.tagNames[colorId]}" there, not "${label}" — kept theirs`);
-        }
-    }
-    if (Object.keys(labels).length) {
-        await updateCanvasFolder(c, target.id, (env) => {
-            env.data.colorTagNames = { ...labels, ...(env.data.colorTagNames || {}) };
-        });
-        Object.assign(target.tagNames, labels);
-    }
-    const idMap = new Map();
-    const created = [];
-    for (const n of nodes) {
-        const content = JSON.parse(JSON.stringify(n.content || {}));
-        if (content.generate) {
-            delete content.generate.historyId;
-            delete content.generate.pendingAssetId;
-        }
-        const p = pos(n);
-        content.position = { x: Math.round(origin.x + p.x - minX), y: Math.round(origin.y + p.y - minY) };
-        const file = copyableFile(source, n);
-        const raw = await c.post('/fsnode/create', {
-            name: n.name || DEFAULT_NAMES[n.kind] || n.kind,
-            type: 'file',
-            mimetype: `${NODE_PREFIX}${n.kind}`,
-            parent: target.id,
-            sort: 0,
-            content,
-            ...(file ? { file } : {}),
-        });
-        idMap.set(n.id, raw.id);
-        const node = { id: raw.id, kind: n.kind, name: raw.name, sort: 0, file, content, raw };
-        created.push(node);
-        target.nodes.push(node);
-        target.byId.set(node.id, node);
-        if (file && source.assets.has(file))
-            target.assets.set(file, source.assets.get(file));
-    }
-    // Oldest edge first, so the new ids keep the same @image1/@image2 numbering.
-    const inside = source.edges
-        .filter((e) => idMap.has(e.fromNodeId) && idMap.has(e.toNodeId))
-        .sort((a, b) => a.sort - b.sort || a.id.localeCompare(b.id));
-    const skippedEdges = source.edges.filter((e) => idMap.has(e.toNodeId) && !idMap.has(e.fromNodeId)).length;
-    for (const e of inside) {
-        const { fromNodeId, toNodeId, ...rest } = e.content;
-        await createEdge(c, target, idMap.get(e.fromNodeId), idMap.get(e.toNodeId), { content: rest });
-    }
-    return {
-        canvasId: target.id,
-        canvasName: target.name,
-        nodes: created.map((n) => ({ id: n.id, from: [...idMap].find(([, v]) => v === n.id)?.[0], kind: n.kind, name: n.name })),
-        edges: inside.length,
-        skippedEdges,
-    };
-}
-// ── commands ────────────────────────────────────────────────────────────────
-export function canvasCommand(globals) {
-    const canvas = new Command('canvas').description('Read and edit Infinite Canvas nodes (defaults to the canvas linked from the browser)');
-    const client = () => new WjiClient(globals());
-    canvas
-        .command('status')
-        .alias('link')
-        .description('The canvas linked from the browser and the nodes selected there')
-        .action(async () => {
-        const c = client();
-        const res = await c.get('/canvas-link');
-        if (!res?.linked) {
-            if (isJsonMode())
-                return printJson(res);
-            return info('Not linked. Open a canvas in the browser and press the link button in its top bar.');
-        }
-        const state = res.state;
-        // The link carries ids; read the selected nodes fresh so prompts and assets are current.
-        let selected = [];
-        let canvasName = state.canvasName;
-        if (state.selectedNodeIds?.length) {
-            const loaded = await loadCanvas(c, state.canvasId);
-            canvasName = loaded.name;
-            selected = state.selectedNodeIds
-                .filter((id) => loaded.byId.has(id))
-                .map((id) => describe(loaded, loaded.byId.get(id)));
-        }
-        const out = { ...res, state: { ...state, canvasName }, selected: selected.map((n) => trimDescribed(n)) };
-        render(out, () => {
-            const seconds = Math.max(0, Math.round((new Date(state.expiresAt).getTime() - Date.now()) / 1000));
-            detail([
-                ['workspace', `${state.workspaceName || ''} ${color.dim(state.workspaceId)}`],
-                ['canvas', `${canvasName || ''} ${color.dim(state.canvasId)}`],
-                ['selected', `${state.selectedNodeIds?.length || 0} node(s)`],
-                ['expires', seconds ? `in ${Math.floor(seconds / 60)}m ${seconds % 60}s` : color.red('expired')],
-                ['url', state.url],
-            ]);
-            if (selected.length) {
-                info('');
-                nodeTable(selected);
-            }
-        });
-    });
-    canvas
-        .command('unlink')
-        .description('Drop the browser link (the tab switches its link button off within a minute)')
-        .action(async () => {
-        const res = await client().delete('/canvas-link');
-        render(res, (r) => (r.released ? success('Unlinked') : info('Nothing was linked')));
-    });
-    canvas
-        .command('list')
-        .description('Canvases in a workspace, with owner and visibility')
-        .option('-w, --workspace <id>', 'workspace (defaults to the linked one, then the profile default)')
-        .option('-o, --owner <member>', 'only canvases this member owns (name, email or user id; "none" = unowned)')
-        .action(async (opts) => {
-        const c = client();
-        const linked = opts.workspace ? null : await linkedState(c);
-        const wsId = opts.workspace || linked?.workspaceId || c.requireWorkspace();
-        const [canvases, { members }] = await Promise.all([listCanvases(c, wsId), loadMembers(c, wsId)]);
-        const byUser = new Map(members.map((m) => [m.userId, m]));
-        let filtered = canvases;
-        if (opts.owner !== undefined) {
-            const ownerId = opts.owner === 'none' ? '' : resolveMember(members, opts.owner).userId;
-            filtered = canvases.filter((r) => r.ownerUserId === ownerId);
-        }
-        const rows = filtered.map(({ folder, ...r }) => ({
-            ...r,
-            ownerName: r.ownerUserId ? (byUser.get(r.ownerUserId) ? memberLabel(byUser.get(r.ownerUserId)) : '(not a member)') : '',
-            linked: r.id === linked?.canvasId,
-        }));
-        render(rows, () => table(rows, [
-            { header: '', value: (r) => (r.linked ? color.green('●') : '') },
-            { header: 'id', value: (r) => r.id },
-            { header: 'name', value: (r) => r.name },
-            { header: 'owner', value: (r) => r.ownerName },
-            { header: 'visibility', value: (r) => (r.visibility === 'owner' ? 'owner only' : 'members') },
-            { header: 'updated', value: (r) => relativeTime(r.updatedAt) },
-        ]));
-    });
-    canvas
-        .command('create <name>')
-        .description('Create an empty canvas in a workspace (its InfiniteCanvas app)')
-        .option('-w, --workspace <id>', 'workspace (defaults to the linked one, then the profile default)')
-        .option('--app <appId>', 'InfiniteCanvas app when the workspace has several')
-        .option('-o, --owner <member>', 'owner (name, email or user id); only the workspace owner can set it')
-        .option('--visibility <v>', 'owner (only the owner and the workspace owner see it) | members', 'members')
-        .action(async (name, opts) => {
-        const c = client();
-        const linked = opts.workspace ? null : await linkedState(c);
-        const wsId = opts.workspace || linked?.workspaceId || c.requireWorkspace();
-        const folders = await canvasesFolders(c, wsId);
-        if (!folders.length)
-            throw new Error(`Workspace ${wsId} has no InfiniteCanvas app. Add one with \`wji ws app add canvas\`.`);
-        const target = opts.app ? folders.find((f) => f.appId === opts.app) : folders[0];
-        if (!target)
-            throw new Error(`No InfiniteCanvas app ${opts.app} in workspace ${wsId}`);
-        if (!opts.app && folders.length > 1)
-            warn(`Several InfiniteCanvas apps — using ${target.appId}; pass --app to choose`);
-        const visibility = parseVisibility(opts.visibility);
-        const ownerUserId = opts.owner ? resolveMember((await loadMembers(c, wsId)).members, opts.owner).userId : '';
-        const raw = await createCanvasFolder(c, target.folderId, name, { ownerUserId, visibility });
-        const out = { id: raw.id, name: raw.name, app: target.appId, workspaceId: wsId, ownerUserId, visibility };
-        render(out, () => {
-            success(`Created canvas "${out.name}" ${color.dim(out.id)}`);
-            info(color.dim(`Target it with --canvas ${out.id}, or open it in the browser and press link.`));
-        });
-    });
-    canvas
-        .command('owner <canvasId> [member]')
-        .description('Show or set who owns a canvas and who can see it (setting needs the workspace owner)')
-        .option('--visibility <v>', 'owner (only the owner and the workspace owner see it) | members (everyone in the workspace)')
-        .option('--none', 'clear the owner')
-        .action(async (canvasId, token, opts) => {
-        const c = client();
-        const folder = await c.getFresh(`/fsnode/list/${canvasId}`);
-        if (folder?.mimetype !== CANVAS_MIMETYPE)
-            throw new Error(`${canvasId} is not a canvas`);
-        const wsId = idOf(folder.workspace) || idOf(folder.root) || '';
-        const { members } = await loadMembers(c, wsId);
-        if (token && opts.none)
-            throw new Error('Pass a member or --none, not both');
-        const show = (access) => {
-            const owner = members.find((m) => m.userId === access.ownerUserId);
-            const out = { id: canvasId, name: folder.name, ...access, ownerName: owner ? memberLabel(owner) : undefined };
-            render(out, () => detail([
-                ['canvas', `${folder.name} ${color.dim(canvasId)}`],
-                ['owner', access.ownerUserId ? `${owner ? memberLabel(owner) : '(not a member)'} ${color.dim(access.ownerUserId)}` : '(none)'],
-                ['visibility', access.visibility === 'owner' ? 'owner only' : 'all members'],
-            ]));
-        };
-        if (!token && !opts.none && !opts.visibility)
-            return show(canvasAccessOf(folder.content));
-        const ownerUserId = opts.none ? '' : token ? resolveMember(members, token).userId : undefined;
-        const visibility = opts.visibility ? parseVisibility(opts.visibility) : undefined;
-        const res = await updateCanvasFolder(c, canvasId, (env) => {
-            if (ownerUserId !== undefined)
-                env.metadata.ownerUserId = ownerUserId;
-            if (visibility)
-                env.metadata.visibility = visibility;
-            else if (!env.metadata.visibility)
-                env.metadata.visibility = 'members';
-        });
-        if (!isJsonMode())
-            success('Updated');
-        show(canvasAccessOf(res?.content));
-    });
-    canvas
-        .command('tag <tag> [nodeIds...]')
-        .description('Color-tag nodes: a color (red, rose…) or an existing label; "none" removes the tag. ' +
-        '--label names that color on this canvas (one label per color, shared by its nodes).')
-        .option('-c, --canvas <id>', 'canvas id (defaults to the linked canvas)')
-        .option('-l, --label <text>', 'set the label of this color on the canvas ("" clears it)')
-        .option('--selected', 'tag the nodes selected in the linked browser canvas')
-        .action(async (tag, ids, opts) => {
-        const c = client();
-        const linked = opts.selected ? await linkedState(c) : null;
-        if (opts.selected && !linked)
-            throw new Error('--selected needs a linked canvas (press link in the browser)');
-        const cv = await loadCanvas(c, opts.canvas || linked?.canvasId || (await resolveCanvasId(c)));
-        const nodeIds = [...ids, ...(opts.selected ? linked.selectedNodeIds || [] : [])];
-        const nodes = nodeIds.map((id) => requireNode(cv, id));
-        const clear = tag.toLowerCase() === 'none';
-        if (clear && opts.label !== undefined)
-            throw new Error('--label needs a color, not "none"');
-        const colorId = clear ? undefined : colorOfTag(cv, tag);
-        if (!nodes.length && opts.label === undefined)
-            throw new Error('Pass node ids (or --selected), and/or --label');
-        if (opts.label !== undefined) {
-            const label = opts.label.trim();
-            await updateCanvasFolder(c, cv.id, (env) => {
-                const names = { ...(env.data.colorTagNames || {}) };
-                if (label)
-                    names[colorId] = label;
-                else
-                    delete names[colorId];
-                env.data.colorTagNames = Object.keys(names).length ? names : null;
-            });
-            if (label)
-                cv.tagNames[colorId] = label;
-            else
-                delete cv.tagNames[colorId];
-        }
-        for (const node of nodes) {
-            const content = { ...node.content };
-            if (clear)
-                delete content.colorTag;
-            else
-                content.colorTag = { colorId };
-            await patchNode(c, node, { content });
-            node.content = content;
-        }
-        const out = { canvas: cv.id, tag: clear ? null : { color: colorId, label: cv.tagNames[colorId] }, nodes: nodes.map((n) => n.id) };
-        render(out, () => {
-            const what = clear ? 'untagged' : `tagged ${tagText(tagOf(cv, { ...nodes[0], content: { colorTag: { colorId } } }))}`;
-            if (nodes.length)
-                success(`${nodes.length} node(s) ${what}`);
-            if (opts.label !== undefined)
-                success(`Label of ${colorId}: ${cv.tagNames[colorId] || '(none)'}`);
-        });
-    });
-    canvas
-        .command('copy [nodeIds...]')
-        .description('Copy nodes (with the connections between them) into other canvases. Finished media is shared, not re-generated; ' +
-        'generate nodes keep their prompt and settings.')
-        .option('-c, --canvas <id>', 'source canvas (defaults to the linked canvas)')
-        .option('--selected', 'copy the nodes selected in the linked browser canvas')
-        .requiredOption('--to <canvasIds...>', 'target canvases')
-        .option('--at <x,y>', 'top-left of the copied group; default is right of what is already there')
-        .option('--same-position', 'keep the original coordinates')
-        .option('-y, --yes', 'skip confirmation')
-        .action(async (ids, opts) => {
-        const c = client();
-        const { source, nodes } = await copySource(c, ids, opts);
-        const targets = opts.to.filter((id) => id !== source.id);
-        if (!targets.length)
-            throw new Error('--to must name at least one canvas other than the source');
-        const names = await Promise.all(targets.map(async (id) => (await c.getFresh(`/fsnode/list/${id}`))?.name ?? id));
-        const question = `Copy ${nodes.length} node(s) from "${source.name}" into ${targets.length} canvas(es): ${names.join(', ')}?`;
-        if (!(await confirm(question, opts.yes)))
-            return info('Aborted');
-        const results = [];
-        for (const id of targets) {
-            const target = await loadCanvas(c, id);
-            results.push(await copyNodes(c, source, nodes, target, copyPlacement(opts)));
-        }
-        render(results, () => {
-            for (const r of results)
-                success(`${r.canvasName}: ${r.nodes.length} node(s), ${r.edges} connection(s)`);
-            const skipped = results[0]?.skippedEdges ?? 0;
-            if (skipped)
-                info(color.dim(`${skipped} connection(s) from nodes outside the copy were left out`));
-        });
-    });
-    canvas
-        .command('nodes')
-        .description('Nodes with references and a content summary (* = generate node)')
-        .option('-c, --canvas <id>', 'canvas id (defaults to the linked canvas)')
-        .option('-k, --kind <kind>', 'only this kind')
-        .option('--tag <tags...>', 'only nodes with one of these color tags: label (C01), color (red) or id (rose)')
-        .option('--untagged', 'only nodes without a color tag')
-        .option('-n, --name <regex>', 'only nodes whose name matches this regex (case-insensitive; /re/flags for your own flags)')
-        .action(async (opts) => {
-        if (opts.tag && opts.untagged)
-            throw new Error('Pass --tag or --untagged, not both');
-        const nameRe = opts.name !== undefined ? parseRegex(opts.name, '--name') : undefined;
-        const c = client();
-        const cv = await loadCanvas(c, await resolveCanvasId(c, opts.canvas));
-        const colors = opts.tag ? resolveTagFilter(cv, opts.tag) : undefined;
-        const rows = cv.nodes
-            .filter((n) => !opts.kind || n.kind === opts.kind)
-            .filter((n) => !nameRe || nameRe.test(n.name))
-            .map((n) => describe(cv, n))
-            .filter((n) => (colors ? !!n.tag && colors.has(n.tag.color) : opts.untagged ? !n.tag : true));
-        render({ canvas: { id: cv.id, name: cv.name, workspaceId: cv.workspaceId }, nodes: rows.map((n) => trimDescribed(n)) }, () => {
-            info(color.dim(`${cv.name} (${cv.id}) · ${rows.length} node(s) · ${cv.edges.length} edge(s)`));
-            nodeTable(rows);
-        });
-    });
-    canvas
-        .command('tags')
-        .description('The canvas color tags: color, label and how many nodes carry each')
-        .option('-c, --canvas <id>', 'canvas id (defaults to the linked canvas)')
-        .option('-a, --all', 'also colors no node uses and that have no label')
-        .action(async (opts) => {
-        const c = client();
-        const cv = await loadCanvas(c, await resolveCanvasId(c, opts.canvas));
-        const rows = COLOR_TAGS.map((t) => ({
-            color: t.id,
-            alias: t.alias,
-            hex: t.hex,
-            label: cv.tagNames[t.id],
-            nodes: cv.nodes.filter((n) => n.content.colorTag?.colorId === t.id).length,
-        })).filter((r) => opts.all || r.nodes || r.label);
-        render({ canvas: { id: cv.id, name: cv.name }, tags: rows }, () => {
-            info(color.dim(`${cv.name} (${cv.id})`));
-            if (!rows.length)
-                return info('No color tags on this canvas (--all lists the colors)');
-            table(rows, [
-                { header: 'color', value: (r) => r.alias },
-                { header: 'id', value: (r) => color.dim(r.color) },
-                { header: 'label', value: (r) => r.label || '' },
-                { header: 'nodes', value: (r) => String(r.nodes) },
-            ]);
-        });
-    });
-    canvas
-        .command('get <nodeId>')
-        .description('One node with its references (--detail full for the whole generate / text)')
-        .option('-c, --canvas <id>', 'canvas id (defaults to the linked canvas)')
-        .action(async (id, opts) => {
-        const c = client();
-        const cv = await loadCanvas(c, await resolveCanvasId(c, opts.canvas));
-        const n = describe(cv, requireNode(cv, id));
-        render(trimDescribed(n), () => printNode(n));
-    });
-    canvas
-        .command('edges')
-        .description('Connections')
-        .option('-c, --canvas <id>', 'canvas id (defaults to the linked canvas)')
-        .option('--node <id>', 'only edges touching this node')
-        .action(async (opts) => {
-        const c = client();
-        const cv = await loadCanvas(c, await resolveCanvasId(c, opts.canvas));
-        const rows = cv.edges.filter((e) => !opts.node || e.fromNodeId === opts.node || e.toNodeId === opts.node);
-        render(rows, () => table(rows, [
-            { header: 'edge', value: (e) => e.id },
-            { header: 'from', value: (e) => `${e.fromNodeId} ${color.dim(cv.byId.get(e.fromNodeId)?.kind || '?')}` },
-            { header: 'to', value: (e) => `${e.toNodeId} ${color.dim(cv.byId.get(e.toNodeId)?.kind || '?')}` },
-            { header: 'slot', value: (e) => e.content.videoFrameSlot || '' },
-        ]));
-    });
-    withGenerateOptions(canvas
-        .command('add <kind>')
-        .description(`Create a node: ${CREATABLE_KINDS.join(' | ')}. Media with -p/-m becomes a generate node.`)
-        .option('-c, --canvas <id>', 'canvas id (defaults to the linked canvas)')
-        .option('-n, --name <name>', 'node name')
-        .option('-t, --text <text>', 'text for text/title/comment (- reads stdin)')
-        .option('--text-file <path>', 'read the text from a file')
-        .option('--plain', 'text is plain, not Markdown: keep every line break (the web renders text nodes as Markdown)')
-        .option('--size <w,h>', 'node width and height in canvas pixels (e.g. 600,900)')
-        .option('--asset <assetId>', 'show an existing asset (display node)')
-        .option('--dataset <fsnodeId>', 'for `add dataset`: the workspace dataset node to show on the canvas')
-        .option('--from <nodeIds...>', 'connect these nodes in as references, in order (@image1, @image2…)')
-        .option('--at <x,y>', 'position; default is right of the --from nodes')).action(async (kind, opts) => {
-        if (!CREATABLE_KINDS.includes(kind)) {
-            throw new Error(`Unknown kind "${kind}". Use one of: ${CREATABLE_KINDS.join(', ')}`);
-        }
-        const c = client();
-        const cv = await loadCanvas(c, await resolveCanvasId(c, opts.canvas));
-        const from = (opts.from || []).map((id) => requireNode(cv, id));
-        const content = {};
-        const body = {
-            name: opts.name || DEFAULT_NAMES[kind],
-            type: 'file',
-            mimetype: `${NODE_PREFIX}${kind}`,
-            parent: cv.id,
-            sort: 0,
-        };
-        let model;
-        if (TEXT_KINDS.has(kind)) {
-            const text = await nodeText(kind, opts);
-            if (text === undefined)
-                throw new Error(`${kind} nodes need --text`);
-            content.text = text;
-        }
-        else if (kind === 'dataset') {
-            // A dataset node is a card bound to a workspace dataset (CanvasAppFileSystem.createDatasetNodeFromDataset).
-            if (!opts.dataset)
-                throw new Error('dataset nodes need --dataset <fsnodeId>');
-            if (from.length)
-                throw new Error('dataset nodes take no references; connect them out to a generate node instead');
-            const ds = await c.getFresh(`/fsnode/list/${opts.dataset}`);
-            if (ds?.mimetype !== DATASET_MIMETYPE) {
-                throw new Error(`${opts.dataset} is not a dataset (mimetype ${ds?.mimetype || 'none'})`);
-            }
-            const parent = ds.parent ? await c.get(`/fsnode/list/${idOf(ds.parent)}`).catch(() => null) : null;
-            const dsName = ds.nickname || ds.name || DEFAULT_NAMES.dataset;
-            if (!opts.name)
-                body.name = dsName;
-            Object.assign(content, {
-                datasetId: String(ds.id),
-                datasetName: dsName,
-                datasetType: String(ds.content?.type || ''),
-                datasetParentName: parent ? parent.nickname || parent.name || '' : '',
-                description: String(ds.content?.description || ''),
-            });
-        }
-        else {
-            const { patch, explicit } = await generateOptions(opts);
-            const wantsGenerate = Object.keys(patch).length > 0;
-            if (opts.asset && wantsGenerate)
-                throw new Error('Use --asset for a display node, or -p/-m for a generate node, not both');
-            if (opts.asset) {
-                content.mode = 'display';
-                body.file = opts.asset;
-            }
-            else {
-                const ws = await c.get(`/workspace/list/${cv.workspaceId}`);
-                const modelName = patch.model || ws.settings?.defaultModels?.[kind];
-                if (!modelName)
-                    throw new Error(`Pass -m <model>; the workspace has no default ${kind} model`);
-                model = await findModel(c, kind, modelName, cv.workspaceId);
-                content.mode = 'generate';
-                content.generate = applyModelDefaults(model, kind, patch, { workspaceRatio: ws.aspectRatio, explicit });
-            }
-        }
-        if (opts.size)
-            Object.assign(content, parseSize(opts.size));
-        if (opts.at)
-            content.position = parsePoint(opts.at, '--at');
-        else {
-            const draft = { id: '', kind, name: '', sort: 0, file: body.file, content, raw: null };
-            content.position = placeNear(cv, from, estimateSize(cv, draft));
-        }
-        const raw = await c.post('/fsnode/create', { ...body, content });
-        const node = { id: raw.id, kind, name: raw.name, sort: 0, file: idOf(raw.file), content, raw };
-        cv.nodes.push(node);
-        cv.byId.set(node.id, node);
-        if (node.file) {
-            for (const asset of await c.checkAssetStatus([node.file]))
-                cv.assets.set(asset.id, asset);
-        }
-        for (const src of from) {
-            await createEdge(c, cv, src.id, node.id, { frameModel: kind === 'video' ? model : undefined });
-        }
-        const out = describe(cv, node);
-        render(out, () => {
-            success(`Created ${kind} node ${node.id}`);
-            printNode(out);
-        });
-    });
-    withGenerateOptions(canvas
-        .command('set <nodeId>')
-        .description('Update a node; only what you pass changes (content is merged, not replaced)')
-        .option('-c, --canvas <id>', 'canvas id (defaults to the linked canvas)')
-        .option('-n, --name <name>', 'rename')
-        .option('-t, --text <text>', 'replace the text of a text/title/comment node (- reads stdin)')
-        .option('--text-file <path>', 'read the text from a file')
-        .option('--plain', 'text is plain, not Markdown: keep every line break')
-        .option('--move <x,y>', 'move to this position')
-        .option('--size <w,h>', 'resize: width and height in canvas pixels')).action(async (id, opts) => {
-        const c = client();
-        const cv = await loadCanvas(c, await resolveCanvasId(c, opts.canvas));
-        const node = requireNode(cv, id);
-        const body = {};
-        const content = { ...node.content };
-        let changed = false;
-        if (opts.name !== undefined)
-            (body.name = opts.name), (changed = true);
-        const text = await nodeText(node.kind, opts);
-        if (text !== undefined) {
-            if (!TEXT_KINDS.has(node.kind))
-                throw new Error(`${node.kind} nodes have no text`);
-            content.text = text;
-            changed = true;
-        }
-        if (opts.move)
-            (content.position = parsePoint(opts.move, '--move')), (changed = true);
-        if (opts.size)
-            Object.assign(content, parseSize(opts.size)), (changed = true);
-        const { patch, explicit } = await generateOptions(opts);
-        if (Object.keys(patch).length) {
-            if (!MEDIA_KINDS.has(node.kind))
-                throw new Error(`${node.kind} nodes cannot generate`);
-            const current = content.generate || {};
-            const merged = {
-                ...current,
-                ...patch,
-                values: { ...(current.values || {}), ...(patch.values || {}) },
-            };
-            const modelName = merged.model;
-            if (!modelName)
-                throw new Error('This node has no model yet — pass -m');
-            const model = await findModel(c, node.kind, modelName, cv.workspaceId);
-            const ws = await c.get(`/workspace/list/${cv.workspaceId}`);
-            content.generate = applyModelDefaults(model, node.kind, merged, { workspaceRatio: ws.aspectRatio, explicit });
-            content.mode = 'generate';
-            changed = true;
-        }
-        if (!changed)
-            throw new Error('Nothing to update — pass at least one option');
-        body.content = content;
-        await patchNode(c, node, body);
-        node.content = content;
-        if (body.name)
-            node.name = body.name;
-        const out = describe(cv, node);
-        render(out, () => {
-            success(`Updated ${id}`);
-            printNode(out);
-        });
-    });
-    canvas
-        .command('connect <fromId> <toId>')
-        .description('Connect from → to; into a media node this adds a reference')
-        .option('-c, --canvas <id>', 'canvas id (defaults to the linked canvas)')
-        .action(async (fromId, toId, opts) => {
-        const c = client();
-        const cv = await loadCanvas(c, await resolveCanvasId(c, opts.canvas));
-        const to = requireNode(cv, toId);
-        const g = to.content.generate;
-        const model = to.kind === 'video' && g?.model ? await findModel(c, 'video', g.model, cv.workspaceId).catch(() => undefined) : undefined;
-        await createEdge(c, cv, fromId, toId, { frameModel: model });
-        const out = describe(cv, to);
-        render(out, () => {
-            const ref = out.references.find((r) => r.nodeId === fromId);
-            success(`Connected ${fromId} → ${toId}${ref ? ` as ${ref.label}${ref.frameSlot ? ` (${ref.frameSlot} frame)` : ''}` : ''}`);
-        });
-    });
-    canvas
-        .command('disconnect <fromId> <toId>')
-        .description('Remove the connection from → to')
-        .option('-c, --canvas <id>', 'canvas id (defaults to the linked canvas)')
-        .action(async (fromId, toId, opts) => {
-        const c = client();
-        const cv = await loadCanvas(c, await resolveCanvasId(c, opts.canvas));
-        const edges = cv.edges.filter((e) => e.fromNodeId === fromId && e.toNodeId === toId);
-        if (!edges.length)
-            throw new Error(`No connection ${fromId} → ${toId}`);
-        for (const edge of edges)
-            await c.delete(`/fsnode/list/${edge.id}`);
-        render({ removed: edges.map((e) => e.id) }, () => success(`Disconnected ${fromId} → ${toId}`));
-    });
-    canvas
-        .command('rm <nodeIds...>')
-        .description('Delete nodes and their connections')
-        .option('-c, --canvas <id>', 'canvas id (defaults to the linked canvas)')
-        .option('-y, --yes', 'skip confirmation')
-        .action(async (ids, opts) => {
-        const c = client();
-        const cv = await loadCanvas(c, await resolveCanvasId(c, opts.canvas));
-        const nodes = ids.map((id) => requireNode(cv, id));
-        const edges = cv.edges.filter((e) => ids.includes(e.fromNodeId) || ids.includes(e.toNodeId));
-        const busy = nodes.filter((n) => describe(cv, n).status === 'generating');
-        if (busy.length)
-            throw new Error(`Still generating, not deleted: ${busy.map((n) => n.id).join(', ')}`);
-        const lines = nodes.map((n) => `${n.kind} "${n.name}" (${n.id})`).join('\n  ');
-        const prompt = `Delete from canvas "${cv.name}":\n  ${lines}\nand ${edges.length} connection(s)?`;
-        if (!(await confirm(prompt, opts.yes)))
-            return info('Aborted');
-        for (const edge of edges)
-            await c.delete(`/fsnode/list/${edge.id}`);
-        for (const node of nodes)
-            await c.delete(`/fsnode/list/${node.id}`);
-        render({ deleted: ids, edges: edges.map((e) => e.id) }, () => success(`Deleted ${nodes.length} node(s) and ${edges.length} connection(s)`));
-    });
-    canvas
-        .command('gen <nodeId>')
-        .description('Submit a generate node with its references (costs credits)')
-        .option('-c, --canvas <id>', 'canvas id (defaults to the linked canvas)')
-        .option('-y, --yes', 'skip the cost confirmation')
-        .option('-w, --wait', 'wait for the result')
-        .option('--timeout <sec>', 'with --wait, give up after this many seconds', '600')
-        .option('--interval <sec>', 'with --wait, poll every N seconds', '5')
-        .action(async (id, opts) => {
-        const c = client();
-        const cv = await loadCanvas(c, await resolveCanvasId(c, opts.canvas));
-        await submitGenerate(c, cv, requireNode(cv, id), opts);
-    });
-    canvas
-        .command('upscale <nodeId>')
-        .description('Upscale a Seedance 2.5 draft clip (480p) to the finished 1080p video — adds an upscale node beside it and generates it (costs credits)')
-        .option('-c, --canvas <id>', 'canvas id (defaults to the linked canvas)')
-        .option('-n, --name <name>', 'name of the upscale node (default: "<source name>-1080p")')
-        .option('--at <x,y>', 'position of the upscale node; default is right of the draft clip')
-        .option('--no-gen', 'only create the upscale node; generate it later with `wji canvas gen`')
-        .option('-y, --yes', 'skip the cost confirmation')
-        .option('-w, --wait', 'wait for the result')
-        .option('--timeout <sec>', 'with --wait, give up after this many seconds', '1200')
-        .option('--interval <sec>', 'with --wait, poll every N seconds', '5')
-        .action(async (id, opts) => {
-        const c = client();
-        const cv = await loadCanvas(c, await resolveCanvasId(c, opts.canvas));
-        const source = requireNode(cv, id);
-        const asset = source.file ? cv.assets.get(source.file) : undefined;
-        if (source.kind !== 'video' || !asset?.url)
-            throw new Error(`${id} is not a video node with a finished clip`);
-        const draft = seedanceDraftSource(asset);
-        if (!isSeedance25(draft.model))
-            throw new Error(`${id} was generated with ${draft.model || 'an unknown model'} — only Seedance 2.5 drafts can be upscaled`);
-        if (!draft.taskId)
-            throw new Error(`${id} has no draft task id (asset ${asset.id} carries no BytePlus task) — it cannot be upscaled`);
-        if (draft.expired)
-            throw new Error(`The draft task of ${id} expired ${draft.expiresAt ? `on ${draft.expiresAt.toISOString().slice(0, 10)}` : ''} (drafts last 7 days) — regenerate the clip instead`);
-        if (!draft.flagged)
-            throw new Error(`${id} is not a Seedance draft (asset ${asset.id} has no config.values.draft) — only draft clips can be upscaled`);
-        const model = await findModel(c, 'video', draft.model, cv.workspaceId);
-        const configDuration = Number(asset.config?.duration);
-        const duration = configDuration > 0 ? configDuration : Number(asset.duration) > 0 ? Math.round(Number(asset.duration)) : undefined;
-        const ratio = String(asset.config?.aspectRatio || '').includes(':') ? asset.config.aspectRatio : asset.aspectRatio;
-        const content = {
-            mode: 'generate',
-            generate: {
-                prompt: 'N/A',
-                model: model.nickname || model.name,
-                resolution: '1080p',
-                ratio,
-                duration,
-                values: { mode: 'video', resolution: '1080p', draft: false, draftTaskId: draft.taskId },
-            },
-        };
-        const body = {
-            name: opts.name || `${source.name || 'video'}-1080p`,
-            type: 'file',
-            mimetype: `${NODE_PREFIX}video`,
-            parent: cv.id,
-            sort: 0,
-        };
-        if (source.content.width)
-            Object.assign(content, { width: source.content.width, height: source.content.height });
-        content.position = opts.at
-            ? parsePoint(opts.at, '--at')
-            : placeNear(cv, [source], estimateSize(cv, { id: '', kind: 'video', name: '', sort: 0, file: undefined, content, raw: null }));
-        const raw = await c.post('/fsnode/create', { ...body, content });
-        const node = { id: raw.id, kind: 'video', name: raw.name, sort: 0, file: idOf(raw.file), content, raw };
-        cv.nodes.push(node);
-        cv.byId.set(node.id, node);
-        // The web draws this edge so the panel shows the draft; the submit itself reads only draftTaskId.
-        await createEdge(c, cv, source.id, node.id, { content: { referenceRole: 'video', referenceLabel: 'video1' } });
-        success(`Created upscale node ${node.id} from ${id} (draft task ${draft.taskId})`);
-        if (!opts.gen)
-            return info(color.dim(`Generate it with: wji canvas gen ${node.id} -c ${cv.id}`));
-        await submitGenerate(c, cv, node, opts);
-    });
-    return canvas;
-}
-/** Price, confirm and submit one generate node — what the canvas Generate button does. */
-async function submitGenerate(c, cv, node, opts) {
-    const id = node.id;
-    if (!MEDIA_KINDS.has(node.kind) || node.content.mode !== 'generate') {
-        throw new Error(`${id} is not a generate node. Create one with \`wji canvas add ${MEDIA_KINDS.has(node.kind) ? node.kind : 'image'} -m … -p …\`.`);
-    }
-    if (describe(cv, node).status === 'generating')
-        throw new Error(`${id} is already generating`);
-    const g = node.content.generate || {};
-    if (!g.model)
-        throw new Error(`${id} has no model — set one with \`wji canvas set ${id} -m …\``);
-    const model = await findModel(c, node.kind, g.model, cv.workspaceId);
-    const body = buildSubmit(cv, node, model);
-    const cost = await c.post('/ai/assets/preComputeCost', {
-        type: node.kind,
-        model: body.model,
-        n: body.n,
-        prompt: body.prompt,
-        // Auto-duration submits -1; price the node's configured length instead.
-        duration: body.duration && body.duration > 0 ? body.duration : g.duration,
-        aspectRatio: body.aspectRatio,
-        referenceImageCount: body.referenceImages?.length,
-        values: body.values,
-    });
-    const credits = typeof cost === 'object' ? cost?.cost ?? cost?.credits ?? cost?.total : cost;
-    const refs = referencesOf(cv, node).map((r) => r.label).join(', ') || 'none';
-    const auto = body.duration === -1 ? ` (auto duration — estimated for ${g.duration ?? '?'}s, final cost follows the real length)` : '';
-    const question = `Generate ${node.kind} "${node.name}" with ${body.model} (refs: ${refs}) for ${credits ?? '?'} credits${auto}?`;
-    if (!(await confirm(question, opts.yes)))
-        return info('Aborted');
-    const history = await c.post(`/ai/assets/history/${node.kind}/generations`, body);
-    const assetId = idOf((history?.images || [])[0]);
-    const nextGenerate = { ...g, historyId: String(history.id), pendingAssetId: assetId };
-    await patchNode(c, node, {
-        ...(assetId ? { file: assetId } : {}),
-        content: { ...node.content, generate: nextGenerate },
-    });
-    if (!opts.wait) {
-        if (isJsonMode())
-            return printJson(history);
-        success(`Submitted ${node.kind} generation for node ${id}`);
-        reportHistory(history, await resolveAssets(c, history));
-        info(color.dim(`The canvas shows progress. Poll with: wji canvas get ${id}  or  wji history get ${history.id} --wait`));
-        return;
-    }
-    info(color.dim(`Submitted ${history.id}, waiting…`));
-    const done = await pollHistory(c, history.id, {
-        timeoutMs: Number(opts.timeout) * 1000,
-        intervalMs: Number(opts.interval) * 1000,
-    });
-    if (isJsonMode())
-        return printJson({ ...done.history, images: done.assets });
-    success(`Node ${id} generated`);
-    reportHistory(done.history, done.assets);
-}