@lumenkey/cli 0.3.1 → 0.4.0-rc.1

package/dist/studio/web/controller.js

@@ -0,0 +1,401 @@
+import { modelsFor, parseFields, validateModels } from './model.js';
+import { createSaveController } from './save-controller.js';
+import { messageForCode } from './messages.js';
+import { createSaveQueue } from './save-queue.js';
+import { createAssetController } from './asset-controller.js';
+import { parseLocalAssetReceipt } from './asset-model.js';
+// Keep HTTP classification and known durable-capture facts across the UI port.
+// Dropping them would turn a recoverable 202/409 into an unclassified retry.
+export function createLocalApi(fetcher = fetch, onUnauthorized) {
+    let expired = false;
+    // Retain one lifetime signal: fetch may have returned headers while its JSON
+    // or binary body is still streaming. A per-request headers-only registry misses it.
+    const sessionCancellation = new AbortController();
+    const sessionError = () => Object.assign(new Error('请从 CLI 重新打开 Studio'), { code: 'STUDIO_SESSION_REQUIRED', status: 401 });
+    const request = async (input, init) => {
+        if (expired)
+            throw sessionError();
+        const response = await fetcher(input, { ...init, signal: AbortSignal.any([sessionCancellation.signal, ...(init?.signal ? [init.signal] : [])]) });
+        if (response.status === 401) {
+            expired = true;
+            sessionCancellation.abort();
+            onUnauthorized?.();
+            throw sessionError();
+        }
+        if (expired)
+            throw sessionError();
+        return response;
+    };
+    const api = async (route, body) => {
+        const response = await request('/studio/api/' + route, { method: body === undefined ? 'GET' : 'POST',
+            headers: body === undefined ? {} : { 'Content-Type': 'application/json' },
+            ...(body === undefined ? {} : { body: JSON.stringify(body) }), signal: AbortSignal.timeout(40_000) });
+        let result;
+        try {
+            result = await response.json();
+        }
+        catch (error) {
+            if (expired)
+                throw sessionError();
+            if (error instanceof TypeError || error instanceof Error && ['AbortError', 'TimeoutError'].includes(error.name)) {
+                throw Object.assign(new Error('本机回复传输中断，请核对原保存状态。'), { code: 'STUDIO_REQUEST_FAILED', transportFailure: true });
+            }
+            throw Object.assign(new Error('本机服务没有返回可读取的数据。'), { code: 'STUDIO_RESPONSE_INVALID', status: response.status });
+        }
+        if (expired)
+            throw sessionError();
+        if (!response.ok) {
+            const diagnostic = uiError(result);
+            throw Object.assign(new Error(diagnostic.message), diagnostic, { status: response.status,
+                ...(result?.capture ? { capture: result.capture } : {}),
+            });
+        }
+        if (result && typeof result === 'object' && result.ok === false)
+            throw Object.assign(new Error('本机服务返回了不符合页面契约的数据，请核对平台记录。'), { code: 'STUDIO_RESPONSE_INVALID', status: response.status });
+        return result;
+    };
+    return Object.assign(api, { request });
+}
+export function uiError(error) {
+    const outer = error && typeof error === 'object' ? error : undefined;
+    const e = outer?.error && typeof outer.error === 'object' && !Array.isArray(outer.error) ? outer.error : outer;
+    const code = typeof e?.code === 'string' ? e.code : 'STUDIO_REQUEST_FAILED';
+    return { code, message: messageForCode(code, typeof e?.message === 'string' ? e.message : '请求未成功，请重试或检查本机服务。'),
+        ...(typeof e?.type === 'string' ? { type: e.type } : {}),
+        ...(typeof e?.httpStatus === 'number' && Number.isInteger(e.httpStatus) && e.httpStatus >= 400 && e.httpStatus <= 599 ? { httpStatus: e.httpStatus } : {}),
+        ...(e?.submission === 'none' || e?.submission === 'unknown' || e?.submission === 'created' ? { submission: e.submission } : {}),
+        ...(e?.recovery === 'rerun' || e?.recovery === 'resume-command' || e?.recovery === 'expired' || e?.recovery === 'ledger' ? { recovery: e.recovery } : {}),
+        ...(typeof e?.resumeDeadline === 'string' ? { resumeDeadline: e.resumeDeadline } : {}),
+    };
+}
+export function createStudioController(options) {
+    const now = options.now ?? Date.now, uuid = options.uuid ?? (() => crypto.randomUUID());
+    const state = { local: { status: 'idle' }, catalog: { status: 'idle' }, balance: { status: 'idle' }, runs: { status: 'idle' }, assets: { status: 'idle' }, drafts: { status: 'idle' }, mode: 'image', edits: { image: { modelId: '', fields: {} }, video: { modelId: '', fields: {} } }, dirty: { image: false, video: false }, connected: false, connecting: false, quoteBusy: false, submitBusy: false, saving: false, refreshing: false, notice: '', sessionExpired: false, saves: { binding: { status: 'idle' }, outputs: {}, operations: {}, targets: {} }, assetChecks: {} };
+    const saveQueue = createSaveQueue();
+    let cloudEpoch = 0, editEpoch = 0;
+    let assetsRead;
+    let assetsVersion = 0;
+    const emit = () => options.onChange?.(state);
+    const api = async (route, body) => {
+        if (state.sessionExpired)
+            throw Object.assign(new Error('请从 CLI 重新打开 Studio'), { code: 'STUDIO_SESSION_REQUIRED', status: 401 });
+        try {
+            const result = await (route === 'assets' && body === undefined ? saveQueue.run('asset-list', 2, () => options.api(route, body)) : options.api(route, body));
+            if (state.sessionExpired)
+                throw { code: 'STUDIO_SESSION_REQUIRED', message: '请从 CLI 重新打开 Studio', status: 401 };
+            return result;
+        }
+        catch (error) {
+            if (error?.status === 401 || uiError(error).code === 'STUDIO_SESSION_REQUIRED')
+                expireSession();
+            throw error;
+        }
+    };
+    const saves = createSaveController({ api, queue: saveQueue, onChange: () => { state.saves = saves.state; emit(); } });
+    state.saves = saves.state;
+    const assetChecks = createAssetController({ api, queue: saveQueue, onChange: () => { state.assetChecks = assetChecks.state; emit(); } });
+    state.assetChecks = assetChecks.state;
+    function expireSession() {
+        if (state.sessionExpired)
+            return;
+        state.sessionExpired = true;
+        resetCloud();
+        assetChecks.dispose();
+        assetsVersion++;
+        state.error = uiError({ code: 'STUDIO_SESSION_REQUIRED', message: '请从 CLI 重新打开 Studio' });
+        state.local = { ...state.local, status: 'error', error: state.error };
+        emit();
+    }
+    const failure = (error) => { state.error = uiError(error); emit(); };
+    function invalidate() { editEpoch++; state.quote = undefined; state.error = undefined; state.notice = ''; }
+    function resetCloud() { cloudEpoch++; state.connected = false; state.gateway = undefined; state.catalog = { status: 'idle' }; state.balance = { status: 'idle' }; state.runs = { status: 'idle' }; state.quote = undefined; saves.invalidate(); }
+    function mergeCleanDrafts(snapshot) {
+        for (const mode of ['image', 'video'])
+            if (!state.dirty[mode])
+                state.edits[mode] = structuredClone(snapshot.drafts[mode] ?? { modelId: '', fields: {} });
+    }
+    async function load(key, route, project = (v) => v, epoch, current = () => true) {
+        if (state.sessionExpired)
+            return;
+        const previous = state[key].value;
+        Object.assign(state, { [key]: { status: 'loading', ...(previous !== undefined ? { value: previous } : {}) } });
+        emit();
+        try {
+            const value = project(await api(route));
+            if ((epoch === undefined || epoch === cloudEpoch) && current())
+                Object.assign(state, { [key]: { status: 'ready', value } });
+        }
+        catch (error) {
+            if ((epoch === undefined || epoch === cloudEpoch) && current())
+                Object.assign(state, { [key]: { status: 'error', ...(previous !== undefined ? { value: previous } : {}), error: uiError(error) } });
+        }
+        emit();
+    }
+    async function refreshCloud() {
+        if (!state.connected || state.refreshing)
+            return;
+        state.refreshing = true;
+        const epoch = cloudEpoch;
+        try {
+            await Promise.all([load('catalog', 'cloud/models', v => validateModels(v.items), epoch), load('balance', 'cloud/balance', undefined, epoch), load('runs', 'runs', v => v.items, epoch)]);
+        }
+        finally {
+            state.refreshing = false;
+            emit();
+        }
+    }
+    function mergeRun(run) { state.runs = { status: 'ready', value: [run, ...(state.runs.value ?? []).filter(r => r.runId !== run.runId)] }; }
+    function refreshAssets(options = {}) {
+        if (options.afterWrite)
+            assetsVersion++;
+        if (!assetsRead)
+            assetsRead = (async () => {
+                let version;
+                do {
+                    version = assetsVersion;
+                    const ticket = assetChecks.beginList();
+                    await load('assets', 'assets', value => parseLocalAssetReceipt({ status: 'ready', value }), undefined, () => version === assetsVersion);
+                    if (version === assetsVersion && state.assets.status === 'ready' && state.assets.value && !state.sessionExpired)
+                        assetChecks.rememberList(state.assets.value.assets, ticket);
+                } while (version !== assetsVersion && !state.sessionExpired);
+            })().finally(() => { assetsRead = undefined; });
+        return assetsRead;
+    }
+    return {
+        state,
+        expireSession,
+        readOutputs: saves.readOutputs,
+        saveOutput: saves.saveOutput, checkOutput: saves.checkOutput, readSave: saves.readOperation, retrySave: saves.retryOperation, markSaveVisible: saves.markVisible,
+        readAsset: assetChecks.read, markAssetVisible: assetChecks.markVisible,
+        setSavePageVisible(value) { saves.setPageVisible(value); assetChecks.setPageVisible(value); },
+        disposeSaves() { saves.dispose(); assetChecks.dispose(); },
+        async bindSaves() { if (state.local.status === 'ready' && !state.sessionExpired)
+            await saves.bind(); },
+        async init() {
+            await load('local', 'session');
+            if (state.local.status !== 'ready')
+                return;
+            await saves.bind();
+            if (state.sessionExpired)
+                return;
+            await Promise.all([refreshAssets(), state.local.value.storage.configured ? load('drafts', 'drafts') : Promise.resolve()]);
+            if (state.drafts.value)
+                mergeCleanDrafts(state.drafts.value);
+            // Reuse an already explicit connection on browser reload, never create one here.
+            if (state.local.value.cloud.connected) {
+                state.connected = true;
+                state.gateway = state.local.value.cloud.gateway;
+                await refreshCloud();
+            }
+            emit();
+        },
+        setMode(mode) { if (mode !== state.mode) {
+            invalidate();
+            state.mode = mode;
+            emit();
+        } },
+        selectModel(id) {
+            const model = modelsFor(state.catalog.value ?? [], state.mode).find(m => m.id === id);
+            if (!model)
+                return;
+            invalidate();
+            const before = state.edits[state.mode];
+            const prompt = before.fields.prompt;
+            state.edits[state.mode] = { modelId: id, fields: prompt && Object.hasOwn(model.inputSchema.properties, 'prompt') ? { prompt } : {} };
+            state.dirty[state.mode] = true;
+            emit();
+        },
+        setField(key, value) { if (['__proto__', 'constructor', 'prototype'].includes(key))
+            return; invalidate(); state.edits[state.mode].fields[key] = value; state.dirty[state.mode] = true; emit(); },
+        async saveDraft() {
+            if (state.saving || state.drafts.status !== 'ready')
+                return;
+            state.saving = true;
+            state.error = undefined;
+            emit();
+            const mode = state.mode, draft = structuredClone(state.edits[mode]), revision = state.drafts.value.revision;
+            try {
+                const saved = await api('drafts', { revision, mode, modelId: draft.modelId, fields: draft.fields });
+                state.drafts = { status: 'ready', value: saved };
+                if (JSON.stringify(state.edits[mode]) === JSON.stringify(draft))
+                    state.dirty[mode] = false;
+                mergeCleanDrafts(saved);
+                state.notice = '草稿已写入本机目录；本次保存不会提交任务。';
+            }
+            catch (error) {
+                failure(error);
+            }
+            finally {
+                state.saving = false;
+                emit();
+            }
+        },
+        async rereadDrafts() {
+            if (state.saving || state.drafts.status === 'loading')
+                return;
+            state.notice = '';
+            state.error = undefined;
+            await load('drafts', 'drafts');
+            if (state.drafts.status === 'ready' && state.drafts.value) {
+                mergeCleanDrafts(state.drafts.value);
+                state.notice = '已读取最新草稿版本；未保存编辑已保留，再保存将写入当前编辑。';
+            }
+            emit();
+        },
+        async connect() {
+            if (state.sessionExpired || state.connecting || state.submitBusy)
+                return;
+            state.connecting = true;
+            state.error = undefined;
+            resetCloud();
+            const epoch = cloudEpoch;
+            emit();
+            try {
+                const r = await api('cloud/connect', {});
+                if (epoch === cloudEpoch) {
+                    state.connected = r.connected === true;
+                    state.gateway = r.gateway;
+                    await saves.bind();
+                    await refreshCloud();
+                }
+            }
+            catch (error) {
+                if (epoch === cloudEpoch)
+                    failure(error);
+            }
+            finally {
+                state.connecting = false;
+                emit();
+            }
+        },
+        async disconnect() {
+            if (state.sessionExpired)
+                return;
+            resetCloud();
+            const epoch = cloudEpoch;
+            emit();
+            try {
+                await api('cloud/disconnect', {});
+                if (epoch === cloudEpoch)
+                    await saves.bind();
+            }
+            catch (error) {
+                if (epoch === cloudEpoch)
+                    failure(error);
+            } // No cancellation promise.
+        },
+        refreshCloud,
+        async quote() {
+            if (state.quoteBusy || state.submitBusy)
+                return;
+            state.error = undefined;
+            state.quote = undefined;
+            if (!state.connected || !state.local.value?.storage.configured || state.catalog.status !== 'ready') {
+                failure({ code: 'STUDIO_NOT_READY', message: '请先设置保存目录并连接云端目录。' });
+                return;
+            }
+            const edit = state.edits[state.mode];
+            const model = modelsFor(state.catalog.value, state.mode).find(m => m.id === edit.modelId);
+            if (!model) {
+                failure({ code: 'STUDIO_MODEL_NOT_AVAILABLE', message: '请选择当前目录中的模型。' });
+                return;
+            }
+            let input;
+            try {
+                input = parseFields(model, edit.fields);
+            }
+            catch (error) {
+                failure(error);
+                return;
+            }
+            const epoch = cloudEpoch, version = editEpoch;
+            state.quoteBusy = true;
+            emit();
+            try {
+                const run = await api('quotes', { requestId: uuid(), modelId: model.id, input });
+                if (epoch === cloudEpoch && state.connected) {
+                    mergeRun(run);
+                    if (version === editEpoch)
+                        state.quote = run;
+                }
+            }
+            catch (error) {
+                if (epoch === cloudEpoch && version === editEpoch)
+                    failure(error);
+            }
+            finally {
+                state.quoteBusy = false;
+                emit();
+            }
+        },
+        async confirm() {
+            if (state.submitBusy)
+                return;
+            const run = state.quote;
+            if (!state.connected || !run || run.state !== 'QUOTED')
+                return;
+            if (Date.parse(run.quote.expiresAt) <= now() || !Number.isFinite(Date.parse(run.quote.expiresAt))) {
+                failure({ code: 'STUDIO_QUOTE_EXPIRED', message: '报价已过期，请重新报价。' });
+                return;
+            }
+            if (state.runs.value?.some(r => ['SUBMISSION_UNKNOWN', 'SUBMITTING'].includes(r.state))) {
+                failure({ code: 'STUDIO_SUBMISSION_UNRESOLVED', message: '此前提交待确认，不能新建任务。' });
+                return;
+            }
+            const epoch = cloudEpoch, version = editEpoch;
+            state.submitBusy = true;
+            state.error = undefined;
+            emit();
+            try {
+                const result = await api(`runs/${run.runId}/confirm`, { confirm: true });
+                if (epoch === cloudEpoch) {
+                    mergeRun(result);
+                    if (version === editEpoch)
+                        state.quote = result;
+                }
+            }
+            catch (error) {
+                if (epoch === cloudEpoch) {
+                    failure(error);
+                    state.quote = undefined;
+                    await load('runs', 'runs', v => v.items, epoch);
+                }
+            }
+            finally {
+                if (epoch === cloudEpoch && state.connected)
+                    await load('balance', 'cloud/balance', undefined, epoch);
+                state.submitBusy = false;
+                emit();
+            }
+        },
+        async refreshRun(id) {
+            if (!state.connected || state.refreshing)
+                return;
+            state.refreshing = true;
+            const epoch = cloudEpoch;
+            emit();
+            try {
+                const run = await api(`runs/${id}/refresh`, {});
+                if (epoch === cloudEpoch) {
+                    mergeRun(run);
+                    if (state.quote?.runId === id)
+                        state.quote = run;
+                    await saves.readOutputs(id);
+                }
+            }
+            catch (error) {
+                if (epoch === cloudEpoch)
+                    failure(error);
+            }
+            finally {
+                if (epoch === cloudEpoch && state.connected)
+                    await load('balance', 'cloud/balance', undefined, epoch);
+                state.refreshing = false;
+                emit();
+            }
+        },
+        refreshAssets,
+        reportError: failure,
+    };
+}
+//# sourceMappingURL=controller.js.map

package/dist/studio/web/messages.d.ts

@@ -0,0 +1,2 @@
+export declare function messageForCode(code: string, fallback: string, locale?: string): string;
+//# sourceMappingURL=messages.d.ts.map

package/dist/studio/web/messages.js

@@ -0,0 +1,74 @@
+// Page-owned zh-CN copy. Unknown codes retain the safe server diagnostic.
+const messages = {
+    'zh-CN': {
+        STUDIO_SESSION_REQUIRED: '请从 CLI 重新打开 Studio',
+        STUDIO_STORAGE_FAILED: '本机文件操作失败；尚未确认保存成功。',
+        STUDIO_STORAGE_BUSY: '保存目录正在使用，或尚未确认上一次写入已结束。',
+        STUDIO_STORAGE_CLOSED: '本机存储已关闭，请从 CLI 重新打开 Studio。',
+        STUDIO_PATH_UNSAFE: '保存路径包含链接或已发生变化，请在 CLI 中核对目录。',
+        STUDIO_OUTPUT_ROOT_REQUIRED: '请通过 CLI 指定绝对保存目录。',
+        STUDIO_INPUT_INVALID: '输入格式不符合要求，请检查当前填写的内容。',
+        STUDIO_RESPONSE_INVALID: '本机回复不符合页面契约，当前结果尚未确认。',
+        STUDIO_REQUEST_FAILED: '请求未成功，请重试或检查本机服务。',
+        STUDIO_REQUEST_FORBIDDEN: '请求来源未获准，请从 CLI 重新打开 Studio。',
+        STUDIO_ROUTE_NOT_FOUND: '本机接口不存在，请核对 Studio 版本。',
+        STUDIO_CLOUD_CONFIG_INVALID: '本机云连接尚未配置，请先在 CLI 中配置。',
+        STUDIO_CLOUD_DISCONNECTED: '云端尚未连接；本机编辑仍然保留。',
+        STUDIO_CLOUD_RESPONSE_INVALID: '云端回复不符合契约，已停止当前操作。',
+        STUDIO_CLOUD_FAILED: '云端请求未成功，请检查连接后再试。',
+        STUDIO_RUN_NOT_FOUND: '当前连接下未找到这条任务记录。',
+        STUDIO_RUN_CONFLICT: '任务标识与已有记录冲突，未新建任务。',
+        STUDIO_JOURNAL_INVALID: '本机任务记录无法核对，请保留文件并检查记录。',
+        STUDIO_DRAFT_INVALID: '草稿文件已损坏或被外部修改，未覆盖原文件。',
+        STUDIO_DRAFT_CONFLICT: '草稿在另一窗口发生变化，请保留编辑并读取最新版本。',
+        STUDIO_CATALOG_INVALID: '素材清单无法读取；原文件保留。',
+        STUDIO_MEDIA_TYPE_INVALID: '文件格式不受支持，请选择图片或视频文件。',
+        STUDIO_MEDIA_TOO_LARGE: '文件超过本机保存大小上限。',
+        STUDIO_ASSET_ID_INVALID: '素材标识无效，请重新读取素材列表。',
+        STUDIO_ASSET_NOT_FOUND: '未找到这份本机素材。',
+        STUDIO_ASSET_CORRUPT: '素材缺失或校验未通过，请核对本机文件。',
+        STUDIO_MODEL_NOT_AVAILABLE: '当前目录没有这款可用模型，请重新选择。',
+        STUDIO_NOT_READY: '请先设置保存目录并连接云端目录。',
+        STUDIO_CONFIRM_REQUIRED: '请先核对报价，再明确确认生成。',
+        STUDIO_QUOTE_EXPIRED: '报价已过期，请重新查看报价。',
+        STUDIO_SUBMISSION_UNRESOLVED: '此前提交结果待确认，请核对平台任务与账单记录，不要重复提交。',
+        SAVE_CLOUD_CONFIG_REQUIRED: '请先按 CLI 方式配置本机连接。',
+        SAVE_OUTPUT_ROOT_REQUIRED: '尚未设置可用保存目录，请通过 CLI 指定目录后重新打开 Studio。',
+        SAVE_ROOT_NOT_ALLOWED: '本机保存目录未获准，请在 CLI 中核对批准的目录范围。',
+        SAVE_BINDING_REQUIRED: '本机保存连接需要重新绑定，请重读输出列表。',
+        SAVE_BINDING_MISMATCH: '这条记录不属于当前保存连接，请核对 CLI 使用的连接。',
+        SAVE_AUTHORITY_INVALID: '本机保存记录损坏，保存区域暂不可用；其他功能仍可使用。请保留原文件并联系支持。',
+        SAVE_AUTHORITY_UNAVAILABLE: '暂时无法核对本机保存记录，请稍后重读。',
+        SAVE_OUTPUT_IDENTITY_UNVERIFIED: '输出身份尚未核实，不能确认本机保存资格。',
+        SAVE_OUTPUT_IDENTITY_CONFLICT: '输出身份存在冲突，已停止本机保存。',
+        SAVE_JOB_NOT_TERMINAL: '云端任务仍在运行，尚不能保存输出。',
+        SAVE_MEDIA_UNSUPPORTED: '这个输出的格式或来源暂不支持本机保存。',
+        SAVE_SOURCE_UNAVAILABLE: '暂未取得可用输出来源，不能据此认定文件永久丢失。',
+        SAVE_OPERATION_EXISTS: '这份输出已有保存记录，请核对原操作的状态。',
+        SAVE_MEDIA_TOO_LARGE: '文件超过本机保存大小上限，未保存成功。',
+        SAVE_LENGTH_MISMATCH: '收到的文件长度与来源声明不符，请核对输出来源。',
+        SAVE_DIGEST_MISMATCH: '文件校验不一致，请核对输出来源。',
+        SAVE_NETWORK_ERROR: '文件传输中断，请核对原保存记录。',
+        SAVE_DOWNLOAD_TIMEOUT: '文件传输超时，请核对原保存记录。',
+        SAVE_SERVICE_BUSY: '本机服务暂忙，请稍后核对保存状态。',
+        SAVE_DISK_FULL: '磁盘空间不足，请释放空间后核对原保存记录。',
+        SAVE_PERMISSION_DENIED: '保存目录没有写入权限，请核对目录权限。',
+        SAVE_WRITE_FAILED: '本机文件写入未完成，请核对原保存记录。',
+        SAVE_PATH_UNSAFE: '文件路径不安全或发生变化，请保留文件并人工核对。',
+        SAVE_TARGET_CONFLICT: '目标文件与原保存记录不一致，请保留文件并人工核对。',
+        SAVE_REVISION_CONFLICT: '保存记录已更新，正在重新核对；不会自动重试保存。',
+        SAVE_RETRY_NOT_ALLOWED: '当前记录不允许安全重试，请先核对保存状态。',
+        SAVE_OPERATION_NOT_FOUND: '未找到原保存记录；这不能证明此前未受理。',
+        SAVE_ROOT_MISMATCH: '保存根与原记录不一致，请核对 CLI 中的保存位置。',
+        SAVE_REGISTRATION_PENDING: '原文件已写入，素材登记尚未完成；可按原保存恢复登记。',
+        SAVE_RELATION_PENDING: '素材已登记，输出关联尚未完成；可按原保存恢复关联。',
+        SAVE_URL_EXPIRED_RENEWABLE: '输出来源需要更新，请核对原保存记录。',
+        SAVE_FILE_MISSING: '曾保存的文件现已缺失，不会自动重新下载。',
+        SAVE_FILE_MODIFIED: '曾保存的文件已被修改，不会覆盖用户文件。',
+        SAVE_FILE_UNSAFE: '曾保存的文件不再满足安全条件，请人工核对。',
+    },
+};
+export function messageForCode(code, fallback, locale = 'zh-CN') {
+    return Object.hasOwn(messages[locale] ?? {}, code) ? messages[locale][code] : fallback;
+}
+//# sourceMappingURL=messages.js.map

package/dist/studio/web/model.d.ts

@@ -0,0 +1,75 @@
+export type Mode = 'image' | 'video';
+export interface MediaModel {
+    id: string;
+    displayName?: string;
+    name?: string;
+    type?: string;
+    capabilities?: string[];
+    inputSchema: {
+        properties: Record<string, Record<string, unknown>>;
+        required?: string[];
+        'x-lumenkey-ui'?: unknown;
+    };
+}
+export interface PublicFailure {
+    code: string;
+    message: string;
+    type: string;
+    httpStatus?: number;
+    submission?: 'none' | 'unknown' | 'created';
+    recovery?: 'rerun' | 'resume-command' | 'expired' | 'ledger';
+    resumeDeadline?: string;
+}
+export interface PublicRun {
+    runId: string;
+    modelId: string;
+    state: string;
+    quote: {
+        credits: number;
+        expiresAt: string;
+        quoteId: string;
+        modelId: string;
+    };
+    job?: {
+        jobId: string;
+        status: string;
+        outputs: {
+            url: string;
+            type?: string;
+        }[];
+        error?: {
+            code: string;
+            message?: string;
+        };
+    };
+    lastErrorCode?: string;
+    failure?: PublicFailure;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface Field {
+    key: string;
+    title: string;
+    kind: 'text' | 'number' | 'boolean' | 'json' | 'enum';
+    spec: Record<string, unknown>;
+    options?: {
+        value: string;
+        label: string;
+    }[];
+    defaultHint?: string;
+    required: boolean;
+    placement?: 'input' | 'common' | 'advanced';
+    labelKnown?: boolean;
+}
+export declare function modelsFor(models: MediaModel[], mode: Mode): MediaModel[];
+export declare function validateModels(value: unknown): MediaModel[];
+export declare function describeFields(model: MediaModel): Field[];
+export declare function parseFields(model: MediaModel, fields: Record<string, string>): Record<string, unknown>;
+export declare function runLabel(run: PublicRun): string;
+export declare function runDiagnosticText(run: PublicRun): string | undefined;
+export declare function runRecoveryText(run: PublicRun): string | undefined;
+export declare function safeOutputUrl(value: string): string | undefined;
+export declare function fieldPlacement(field: Pick<Field, 'kind' | 'placement'>): 'input' | 'common' | 'advanced';
+export declare function fieldDisplayLabel(field: Pick<Field, 'title' | 'required'>): string;
+export declare function compactLocation(path: string): string;
+//# sourceMappingURL=model.d.ts.map