@lumenkey/cli 0.3.1 → 0.4.0-rc.1

package/dist/studio/web/asset-controller.d.ts

@@ -0,0 +1,37 @@
+import { type StudioApi, type Resource } from './controller.js';
+import { createSaveQueue } from './save-queue.js';
+import { type LocalAsset } from './asset-model.js';
+interface Clock {
+    now(): number;
+    setTimeout(fn: () => void, ms: number): unknown;
+    clearTimeout(handle: unknown): void;
+}
+type Observation = Resource<LocalAsset> & {
+    notice?: string;
+};
+export declare function createAssetController(options: {
+    api: StudioApi;
+    queue?: ReturnType<typeof createSaveQueue>;
+    clock?: Clock;
+    onChange?: () => void;
+}): {
+    state: Record<string, Observation>;
+    read: (id: string, opts?: {
+        manual?: boolean;
+        automatic?: boolean;
+        lazy?: boolean;
+    }) => Promise<void>;
+    markVisible: (id: string, on: boolean) => void;
+    setPageVisible: (value: boolean) => void;
+    beginList: () => {
+        serial: number;
+        inFlight: Set<string>;
+    };
+    rememberList: (assets: LocalAsset[], ticket: ReturnType<() => {
+        serial: number;
+        inFlight: Set<string>;
+    }>) => void;
+    dispose: () => void;
+};
+export {};
+//# sourceMappingURL=asset-controller.d.ts.map

package/dist/studio/web/asset-controller.js

@@ -0,0 +1,191 @@
+import { uiError } from './controller.js';
+import { createSaveQueue } from './save-queue.js';
+import { pendingDelay, backoffDelay } from './save-model.js';
+import { parseAssetMetadata } from './asset-model.js';
+export function createAssetController(options) {
+    const state = {}, queue = options.queue ?? createSaveQueue(), clock = options.clock ?? { now: Date.now, setTimeout: (fn, ms) => setTimeout(fn, ms), clearTimeout: (h) => clearTimeout(h) };
+    const follows = new Map(), visible = new Set(), lazy = new Set(), tickets = new Map();
+    let epoch = 0, serial = 0, pageVisible = true, timer;
+    const paused = Symbol('paused'), expired = Symbol('expired'), capped = Symbol('follow-limit'), emit = () => options.onChange?.();
+    const context = (id) => {
+        let f = follows.get(id);
+        if (!f) {
+            f = { count: 0, failures: 0 };
+            follows.set(id, f);
+        }
+        return f;
+    };
+    const key = (id) => `asset:${epoch}:${id}`;
+    function stopTimer() {
+        if (timer !== undefined)
+            clock.clearTimeout(timer);
+        timer = undefined;
+    }
+    function expire(id, f) {
+        if (f.start === undefined || clock.now() < f.start + 120000)
+            return false;
+        f.next = undefined;
+        if (state[id])
+            state[id].notice = f.failures ? '暂不可核对 · 核对文件状态' : '核验尚未完成 · 核对文件状态';
+        queue.cancel(key(id), expired);
+        return true;
+    }
+    function arm() {
+        stopTimer();
+        if (!pageVisible)
+            return;
+        const due = [];
+        for (const [id, f] of follows) {
+            if (expire(id, f))
+                continue;
+            if (f.busy) {
+                if (f.start !== undefined)
+                    due.push(f.start + 120000);
+            }
+            else if (f.next !== undefined)
+                due.push(f.start === undefined ? f.next : Math.min(f.next, f.start + 120000));
+        }
+        if (due.length)
+            timer = clock.setTimeout(tick, Math.max(0, Math.min(...due) - clock.now()));
+    }
+    function tick() {
+        timer = undefined;
+        if (!pageVisible)
+            return;
+        for (const [id, f] of follows)
+            if (!expire(id, f) && !f.busy && f.next !== undefined && f.next <= clock.now())
+                void read(id, { automatic: true });
+        arm();
+        emit();
+    }
+    function beginList() {
+        return { serial: ++serial, inFlight: new Set([...follows].filter(([, f]) => f.busy).map(([id]) => id)) };
+    }
+    function rememberList(assets, ticket) {
+        for (const a of assets) {
+            if (ticket.inFlight.has(a.assetId) || (tickets.get(a.assetId) ?? 0) > ticket.serial)
+                continue;
+            tickets.set(a.assetId, ticket.serial);
+            state[a.assetId] = { status: 'ready', value: a };
+            if (a.integrity?.integrityCheck === 'IDLE') {
+                const f = context(a.assetId);
+                f.start = undefined;
+                f.next = undefined;
+            }
+        }
+        arm();
+        emit();
+    }
+    function read(id, opts = {}) {
+        const f = context(id);
+        if (f.busy)
+            return f.busy;
+        const before = state[id];
+        if (!before?.value)
+            return Promise.resolve();
+        const started = epoch, oldNext = f.next, ticket = ++serial;
+        f.next = undefined;
+        if (opts.manual) {
+            f.start = undefined;
+            f.count = 0;
+            f.failures = 0;
+        }
+        tickets.set(id, ticket);
+        const loading = { ...before, status: 'loading' };
+        state[id] = loading;
+        emit();
+        const pending = (async () => {
+            try {
+                const reply = await queue.run(key(id), opts.manual ? 1 : 2, () => {
+                    if (started !== epoch || !pageVisible || opts.lazy && !visible.has(id))
+                        return Promise.resolve(paused);
+                    if (expire(id, f))
+                        return Promise.resolve(expired);
+                    if (opts.automatic && f.start !== undefined && f.count >= 13)
+                        return Promise.resolve(capped);
+                    if (opts.lazy)
+                        lazy.add(id);
+                    if (opts.automatic)
+                        f.count++;
+                    return options.api(`assets/${id}`);
+                });
+                if (started !== epoch)
+                    return;
+                if (reply === paused || reply === expired || reply === capped) {
+                    if (reply === paused)
+                        f.next = oldNext;
+                    if (reply === capped)
+                        f.next = f.start + 120000;
+                    if (state[id] === loading)
+                        state[id] = { ...before, ...(state[id].notice ? { notice: state[id].notice } : {}) };
+                    return;
+                }
+                const asset = parseAssetMetadata(reply, id);
+                if ((tickets.get(id) ?? 0) > ticket)
+                    return;
+                state[id] = { status: 'ready', value: asset };
+                f.failures = 0;
+                if (asset.integrity.integrityCheck === 'PENDING') {
+                    f.start ??= clock.now();
+                    if (!expire(id, f))
+                        f.next = f.count < 13 ? clock.now() + pendingDelay(f.count) : f.start + 120000;
+                }
+                else {
+                    f.start = undefined;
+                    f.next = undefined;
+                }
+            }
+            catch (error) {
+                if (started !== epoch)
+                    return;
+                state[id] = { ...state[id], status: 'error', error: uiError(error), notice: '文件状态尚未确认 · 核对文件状态' };
+                const status = error?.status ?? uiError(error).httpStatus;
+                const transient = status === 503 || status === undefined && (!(error?.code) || uiError(error).code === 'STUDIO_REQUEST_FAILED');
+                if (transient && f.start !== undefined && !expire(id, f))
+                    f.next = clock.now() + backoffDelay(f.failures++);
+                else
+                    f.next = undefined;
+            }
+            finally {
+                if (started === epoch) {
+                    f.busy = undefined;
+                    arm();
+                    emit();
+                }
+            }
+        })();
+        f.busy = pending;
+        return pending;
+    }
+    function markVisible(id, on) {
+        if (on)
+            visible.add(id);
+        else
+            visible.delete(id);
+        if (pageVisible && on && !lazy.has(id) && state[id]?.value)
+            void read(id, { lazy: true });
+    }
+    function setPageVisible(value) {
+        pageVisible = value;
+        if (value)
+            for (const id of visible)
+                if (!lazy.has(id) && state[id]?.value)
+                    void read(id, { lazy: true });
+        arm();
+        emit();
+    }
+    function dispose() {
+        epoch++;
+        queue.reset('asset:');
+        stopTimer();
+        follows.clear();
+        visible.clear();
+        lazy.clear();
+        tickets.clear();
+        for (const id of Object.keys(state))
+            delete state[id];
+        emit();
+    }
+    return { state, read, markVisible, setPageVisible, beginList, rememberList, dispose };
+}
+//# sourceMappingURL=asset-controller.js.map

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

@@ -0,0 +1,29 @@
+export interface AssetIntegrity {
+    file: 'NOT_CHECKED' | 'ABSENT' | 'PARTIAL' | 'VERIFIED' | 'MISSING' | 'MODIFIED' | 'UNSAFE' | 'UNKNOWN';
+    checkedAt: string | null;
+    integrityCheck: 'IDLE' | 'PENDING';
+}
+export interface LocalAsset {
+    assetId: string;
+    displayName: string;
+    mediaType: string;
+    byteLength: number;
+    integrity?: AssetIntegrity;
+}
+export interface ObservedAsset extends LocalAsset {
+    integrity: AssetIntegrity;
+}
+/** A fresh local list receipt, shared with Canvas C1. Loading/error values remain stale, not new receipts. */
+export declare function parseLocalAssetReceipt(resource: unknown): {
+    assets: LocalAsset[];
+    recoveryIssues: unknown[];
+} | undefined;
+export declare function assetFileLink(asset: LocalAsset): {
+    canOpen: boolean;
+    reason: string;
+};
+export declare function parseAssetMetadata(value: unknown, assetId: string): ObservedAsset;
+export declare function assetPresentation(asset: LocalAsset, observationFailed?: boolean): {
+    status: string;
+};
+//# sourceMappingURL=asset-model.d.ts.map

package/dist/studio/web/asset-model.js

@@ -0,0 +1,51 @@
+import { isId, isRecord, invalidSaveResponse } from './save-model.js';
+/** A fresh local list receipt, shared with Canvas C1. Loading/error values remain stale, not new receipts. */
+export function parseLocalAssetReceipt(resource) {
+    if (!isRecord(resource) || resource.status !== 'ready')
+        return undefined;
+    const value = resource.value;
+    if (!isRecord(value) || !Array.isArray(value.assets) || !Array.isArray(value.recoveryIssues))
+        return invalidSaveResponse();
+    for (const asset of value.assets) {
+        if (!isRecord(asset) || !isId(asset.assetId) || typeof asset.displayName !== 'string' || typeof asset.mediaType !== 'string' ||
+            !Number.isSafeInteger(asset.byteLength) || asset.byteLength < 1)
+            return invalidSaveResponse();
+    }
+    if (new Set(value.assets.map(asset => asset.assetId)).size !== value.assets.length)
+        return invalidSaveResponse();
+    return value;
+}
+export function assetFileLink(asset) {
+    switch (asset.integrity?.file) {
+        case 'MISSING':
+            return { canOpen: false, reason: '文件已缺失，无法打开本机文件。' };
+        case 'UNSAFE':
+            return { canOpen: false, reason: '文件安全状态异常，暂不能打开本机文件。' };
+        case 'MODIFIED':
+            return { canOpen: true, reason: '文件已被修改，当前内容可能与原素材不同。' };
+        default:
+            return { canOpen: true, reason: '' };
+    }
+}
+export function parseAssetMetadata(value, assetId) {
+    if (!isRecord(value) || !(value.scope === null || isRecord(value.scope) && (value.scope.rootId === null || isId(value.scope.rootId)) && isId(value.scope.connectionId)) || !isRecord(value.asset))
+        return invalidSaveResponse();
+    const a = value.asset, fact = a.integrity;
+    if (a.assetId !== assetId || !isId(a.assetId) || typeof a.displayName !== 'string' || typeof a.mediaType !== 'string' || typeof a.byteLength !== 'number' || !Number.isSafeInteger(a.byteLength) || a.byteLength < 1 || !isRecord(fact) ||
+        !['NOT_CHECKED', 'ABSENT', 'PARTIAL', 'VERIFIED', 'MISSING', 'MODIFIED', 'UNSAFE', 'UNKNOWN'].includes(fact.file) || !['IDLE', 'PENDING'].includes(fact.integrityCheck) || !(fact.checkedAt === null || typeof fact.checkedAt === 'string' && Number.isFinite(Date.parse(fact.checkedAt))) || fact.file === 'VERIFIED' && !fact.checkedAt || fact.integrityCheck === 'PENDING' && fact.file !== 'NOT_CHECKED')
+        return invalidSaveResponse();
+    return a;
+}
+export function assetPresentation(asset, observationFailed = false) {
+    if (observationFailed)
+        return { status: '文件状态尚未确认' };
+    const fact = asset.integrity;
+    if (!fact)
+        return { status: '文件状态尚未读取' };
+    if (fact.integrityCheck === 'PENDING')
+        return { status: '正在核对文件' };
+    if (fact.file === 'VERIFIED' && fact.checkedAt)
+        return { status: '本机文件 · 当前已核验' };
+    return { status: { NOT_CHECKED: '文件尚未核验', MISSING: '文件现已缺失', MODIFIED: '文件现已变更', UNSAFE: '文件安全状态异常', UNKNOWN: '文件状态未确认', ABSENT: '文件不存在', PARTIAL: '文件不完整', VERIFIED: '文件状态未确认' }[fact.file] };
+}
+//# sourceMappingURL=asset-model.js.map

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

@@ -0,0 +1,113 @@
+import { type MediaModel, type Mode, type PublicRun, type PublicFailure } from './model.js';
+import { type SaveState } from './save-controller.js';
+import { createAssetController } from './asset-controller.js';
+import { type LocalAsset } from './asset-model.js';
+export interface Resource<T> {
+    status: 'idle' | 'loading' | 'ready' | 'error';
+    value?: T;
+    error?: UiError;
+}
+export type UiError = Omit<PublicFailure, 'type'> & {
+    type?: string;
+};
+interface Draft {
+    modelId: string;
+    fields: Record<string, string>;
+    savedAt?: string;
+}
+interface Drafts {
+    revision: number;
+    drafts: Partial<Record<Mode, Draft>>;
+}
+export interface Session {
+    storage: {
+        configured: boolean;
+        outputDir?: string;
+    };
+    cloud: {
+        connected: boolean;
+        gateway?: string;
+    };
+}
+export type Asset = LocalAsset;
+export interface State {
+    local: Resource<Session>;
+    catalog: Resource<MediaModel[]>;
+    balance: Resource<{
+        availableCredits: number;
+        reservedCredits: number;
+    }>;
+    runs: Resource<PublicRun[]>;
+    assets: Resource<{
+        assets: Asset[];
+        recoveryIssues: unknown[];
+    }>;
+    drafts: Resource<Drafts>;
+    mode: Mode;
+    edits: Record<Mode, Draft>;
+    dirty: Record<Mode, boolean>;
+    connected: boolean;
+    gateway?: string;
+    connecting: boolean;
+    quoteBusy: boolean;
+    submitBusy: boolean;
+    saving: boolean;
+    refreshing: boolean;
+    quote?: PublicRun;
+    error?: UiError;
+    notice: string;
+    sessionExpired: boolean;
+    saves: SaveState;
+    assetChecks: ReturnType<typeof createAssetController>['state'];
+}
+export type StudioApi = (route: string, body?: unknown) => Promise<any>;
+export declare function createLocalApi(fetcher?: typeof fetch, onUnauthorized?: () => void): StudioApi & {
+    request: typeof fetch;
+};
+export declare function uiError(error: unknown): UiError;
+export declare function createStudioController(options: {
+    api: StudioApi;
+    onChange?: (state: State) => void;
+    uuid?: () => string;
+    now?: () => number;
+}): {
+    state: State;
+    expireSession: () => void;
+    readOutputs: (runId: string, retry?: boolean) => Promise<void>;
+    saveOutput: (runId: string, outputId: string) => Promise<void>;
+    checkOutput: (runId: string, outputId: string) => Promise<void>;
+    readSave: (id: string, readOptions?: {
+        manual?: boolean;
+        automatic?: boolean;
+        lazy?: boolean;
+    }) => Promise<void>;
+    retrySave: (id: string) => Promise<void>;
+    markSaveVisible: (id: string, onScreen: boolean) => void;
+    readAsset: (id: string, opts?: {
+        manual?: boolean;
+        automatic?: boolean;
+        lazy?: boolean;
+    }) => Promise<void>;
+    markAssetVisible: (id: string, on: boolean) => void;
+    setSavePageVisible(value: boolean): void;
+    disposeSaves(): void;
+    bindSaves(): Promise<void>;
+    init(): Promise<void>;
+    setMode(mode: Mode): void;
+    selectModel(id: string): void;
+    setField(key: string, value: string): void;
+    saveDraft(): Promise<void>;
+    rereadDrafts(): Promise<void>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    refreshCloud: () => Promise<void>;
+    quote(): Promise<void>;
+    confirm(): Promise<void>;
+    refreshRun(id: string): Promise<void>;
+    refreshAssets: (options?: {
+        afterWrite?: boolean;
+    }) => Promise<void>;
+    reportError: (error: unknown) => void;
+};
+export {};
+//# sourceMappingURL=controller.d.ts.map