@beeintel/batch-image 0.0.0-stage → 1.0.1

package/dist/types/batch/model.d.ts

@@ -0,0 +1,317 @@
+import { type AssetLifetime } from './retention';
+import type { TranslationDetails } from './features/image-translation/params';
+export { newId } from './ids';
+export { createOperation, retryFailed } from './queue';
+export declare const BATCH_LIMIT = 250;
+export type Source = {
+    kind: 'external_url';
+    url: string;
+    expectedSha256?: string;
+} | {
+    kind: 'asset';
+    assetId: string;
+    assetVersionId: string;
+    oss_url?: string;
+} | {
+    kind: 'local';
+    blobKey: string;
+    filename: string;
+    mime: string;
+    bytes: number;
+    uploadId?: string;
+};
+export type Asset = AssetLifetime & {
+    assetId: string;
+    assetVersionId: string;
+    sha256: string;
+    mime: string;
+    width: number;
+    height: number;
+    bytes: number;
+    oss_url?: string;
+    orientation?: number;
+};
+export type Disclosure = {
+    method?: 'manual' | 'ai';
+    decision: 'YES' | 'NO' | 'REVIEW';
+    reason: string;
+    status: 'verified' | 'unchanged' | 'review';
+    verified: boolean;
+    keywordPresent: boolean;
+    fileSha256: string;
+};
+export type IpAnalysis = {
+    schemaVersion: 1;
+    inputSha256: string;
+    findings: {
+        id: string;
+        category: string;
+        evidence: string;
+        risk: number;
+        box: [number, number, number, number] | null;
+        suspectedIp?: string | null;
+    }[];
+    summary: string;
+    revisionRoute: 'NONE' | 'LOCAL_EDIT' | 'REGENERATE' | 'REVIEW_BEFORE_EDIT';
+    revisionPrompt: string;
+};
+export type LirDetails = {
+    productAssets: {
+        assetId: string;
+        assetVersionId: string;
+        sha256: string;
+    }[];
+    productAtlasSha256: string;
+    promptSha256: string;
+    segmentId: string;
+    referenceNumber: number;
+};
+export type WorkflowDetails = {
+    processingAudit?: import('./features/image-effects/photo-audit').PhotoProcessingAudit;
+    translation?: TranslationDetails;
+    lir?: LirDetails;
+    inputSha256?: string;
+    analysis?: IpAnalysis | null;
+    disclosure?: Disclosure | null;
+    needsReview?: boolean;
+    skipped?: boolean;
+    reasonCode?: 'already_target_language' | 'no_editable_text';
+    reason?: string;
+    autoRescreened?: boolean;
+};
+export type WorkflowResult = WorkflowDetails & ({
+    kind: 'image';
+    asset: Asset;
+    localSource?: Extract<Source, {
+        kind: 'local';
+    }>;
+} | {
+    kind: 'analysis';
+} | {
+    kind: 'export';
+    exportKind: 'svg';
+    asset: Asset;
+});
+export type TaskStep = {
+    name: string;
+    status: 'started' | 'waiting' | 'succeeded' | 'failed' | 'unknown';
+    error?: {
+        code: string;
+        message: string;
+    } | null;
+};
+export type Version = {
+    id: string;
+    source: Source;
+    asset?: Asset;
+    disclosure?: Disclosure;
+    createdAt: number;
+    parentVersionId?: string;
+    fromAttemptId?: string;
+};
+export type Item = {
+    id: string;
+    name: string;
+    groupId?: string;
+    versions: Version[];
+    currentVersionId: string;
+    redo: string[];
+    error?: string;
+    busyAttemptId?: string;
+};
+export type Group = {
+    id: string;
+    label: string;
+    itemIds: string[];
+};
+export type ToolId = 'resize' | 'background' | 'cutout' | 'ip_audit' | 'ai_disclosure' | 'expand' | 'adjust' | 'crop' | 'listing_remake' | 'orient' | 'shadow' | 'metadata_cleanup' | 'image_translation' | 'brand_mark' | 'retouch' | 'upscale' | 'beautify' | 'vectorize_svg' | 'image_effects';
+export declare const isPythonTool: (toolId: ToolId) => boolean;
+export type AttemptStatus = 'waiting_dependency' | 'blocked_dependency' | 'waiting_source' | 'ready_to_submit' | 'submitting' | 'submission_unknown' | 'accepted' | 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled';
+export type Attempt = {
+    remoteAdmission?: 'accepted' | 'not_accepted' | 'unknown';
+    remotePlan?: import('./public/remote-contracts').WorkspaceRemotePlan;
+    remoteGenerated?: import('./public/remote-contracts').WorkspaceRemoteGenerated;
+    remotePublicationId?: string;
+    remoteWaitingStopped?: boolean;
+    remotePublicationStatus?: 'pending' | 'unknown' | 'published';
+    remoteReceipt?: import('./public/remote-contracts').WorkspaceRemoteReceipt;
+    localExecutionResult?: {
+        blobKey: string;
+        sha256: string;
+        mime: string;
+        bytes: number;
+        inputSha256: string;
+        reason?: string;
+        disclosure?: Disclosure;
+    };
+    automaticRecovery?: {
+        count: number;
+        notBefore: number;
+    };
+    timing?: {
+        startedAt: number;
+        lastProgressAt: number;
+    };
+    localSvgResult?: {
+        blobKey: string;
+        uploadId?: string;
+        sha256: string;
+        mime: 'image/svg+xml';
+        bytes: number;
+        inputSha256: string;
+    };
+    localMetadataResult?: {
+        blobKey: string;
+        uploadId?: string;
+        sha256: string;
+        mime: string;
+        bytes: number;
+        inputSha256: string;
+        reason: string;
+    };
+    localImageEffectResult?: {
+        blobKey: string;
+        uploadId?: string;
+        sha256: string;
+        mime: string;
+        bytes: number;
+        width: number;
+        height: number;
+        alpha: boolean;
+        inputSha256: string;
+        outputKind: 'image' | 'svg';
+        effectId: string;
+        effectVersion: import('./features/image-effects/contracts').ImageEffectVersion;
+        paramsDigest?: string;
+        processingAudit?: import('./features/image-effects/photo-audit').PhotoProcessingAudit;
+    };
+    submittedTask?: Record<string, unknown>;
+    retryActionId?: string;
+    submittedParams?: Record<string, unknown>;
+    lirSubmission?: Record<string, unknown>;
+    dependsOnOperationId?: string;
+    continuation?: 'skip' | 'cancel' | 'force';
+    forcedContinuation?: {
+        operationId: string;
+        versionId: string;
+    };
+    queueBlockReason?: 'missing_dependency' | 'upstream_failed' | 'upstream_unknown' | 'unapplied_result' | 'source_changed';
+    id: string;
+    operationId: string;
+    itemId: string;
+    inputVersionId: string;
+    clientRequestId: string;
+    submittedSource?: Exclude<Source, {
+        kind: 'local';
+    }>;
+    taskService?: 'node' | 'python-ai';
+    taskId?: string;
+    status: AttemptStatus;
+    statusVersion: number;
+    stage?: string;
+    localProgress?: {
+        stage: 'decode' | 'process' | 'encode';
+        completed: number;
+        total?: number;
+    };
+    retryOf?: string;
+    resumeFromTaskId?: string;
+    error?: string;
+    errorCode?: string;
+    retryable?: boolean;
+    applied?: boolean;
+    result?: Asset;
+    exportArtifact?: Asset;
+    details?: WorkflowDetails;
+    partialResult?: Asset;
+    steps?: TaskStep[];
+    performance?: {
+        latencyMs: number;
+        coldStart: boolean;
+        threads?: number;
+        backend: string;
+        engineVersion: string;
+    };
+};
+export type Operation = {
+    /** Original SVG draft versions, distinct from dependency-bound execution inputs. */
+    svgIntentInputVersionIds?: Readonly<Record<string, string>>;
+    lirSegments?: string[];
+    queueVersion?: 1;
+    id: string;
+    toolId: ToolId;
+    toolVersion: '1' | '2';
+    params: Record<string, unknown>;
+    itemIds: string[];
+    inputVersionIds: Record<string, string>;
+    createdAt: number;
+    attemptIds: string[];
+    skippedItemIds?: string[];
+    busySkippedItemIds?: string[];
+};
+export type VersionAction = {
+    id: string;
+    kind: 'operation' | 'restore' | 'replacement' | 'rollback' | 'delete';
+    removedItems?: {
+        index: number;
+        item: Item;
+    }[];
+    operationId?: string;
+    changes: {
+        itemId: string;
+        beforeVersionId: string;
+        afterVersionId: string;
+    }[];
+    createdAt: number;
+};
+export type Batch = {
+    workspaceView?: Record<string, unknown>;
+    expiredAt?: number;
+    archivedAt?: number;
+    clonedFromBatchId?: string;
+    schema: 1;
+    id: string;
+    name: string;
+    createdAt: number;
+    items: Item[];
+    groups: Group[];
+    operations: Operation[];
+    attempts: Attempt[];
+    selectedIds: string[];
+    paused: boolean;
+    activeOperationId?: string;
+    actionHistory?: VersionAction[];
+    actionCursor?: number;
+};
+export declare function newBatch(): Batch;
+export declare function assetDisplaySize(asset: Asset): {
+    width: number;
+    height: number;
+};
+export declare function currentVersion(item: Item): Version;
+export declare function recordVersionChange(batch: Batch, kind: VersionAction['kind'], itemId: string, beforeVersionId: string, afterVersionId: string, operationId?: string): void;
+export declare function restoreVersionAsAction(batch: Batch, itemId: string, versionId: string): boolean;
+/** A verified, locally stored version is distinct from a file awaiting upload. */
+export declare function hasStoredLocalAsset(version: Version): boolean;
+export declare function deleteItemsAsAction(batch: Batch, ids: string[]): boolean;
+export declare function canTraverseAction(batch: Batch, direction: -1 | 1): boolean;
+export declare const undoLastAction: (batch: Batch) => VersionAction;
+export declare const redoLastAction: (batch: Batch) => VersionAction;
+export declare function initializeActionHistory(batch: Batch): void;
+export declare function addItems(batch: Batch, entries: {
+    name: string;
+    source: Source;
+    groupLabel?: string;
+    groupId?: string;
+}[], mergeGroups?: boolean): void;
+export declare function applyTaskResult(batch: Batch, attempt: Attempt, asset: Asset, localSource?: Extract<Source, {
+    kind: 'local';
+}>): 'applied' | 'stale';
+export declare function finishAttempt(batch: Batch, attempt: Attempt, status: 'failed' | 'cancelled', error?: string, errorCode?: string, retryable?: boolean): void;
+export declare function applyWorkflowResult(batch: Batch, attempt: Attempt, result: WorkflowResult): 'applied' | 'stale';
+export declare function undo(batch: Batch, itemId: string): boolean;
+export declare function redo(batch: Batch, itemId: string): boolean;
+export declare function undoOperation(batch: Batch, operationId: string): {
+    undone: number;
+    skipped: number;
+};

package/dist/types/batch/public/config.d.ts

@@ -0,0 +1,66 @@
+/** An exact allowlist. New tools, entries and execution modes stay closed. */
+export interface WorkspaceCapability {
+    toolId: string;
+    entryId?: string;
+    execution: 'local' | 'remote';
+    mode?: string;
+}
+export type WorkspaceResetAction = 'draft' | 'newBatch' | 'restoreVersion';
+export interface WorkspaceResetRequest {
+    readonly action: WorkspaceResetAction;
+    /** full clears the tool draft; parameters preserves its selected assets/mode where supported. */
+    readonly intent?: 'full' | 'parameters';
+    readonly toolId?: string;
+    readonly entryId?: string;
+    readonly batchId: string;
+}
+export interface WorkspaceParameterDefault {
+    readonly schemaVersion: 1;
+    readonly toolId: string;
+    readonly entryId?: string;
+    /** Existing tool parameter schema. Asset/task identities are never accepted in defaults. */
+    readonly params: Readonly<Record<string, unknown>>;
+}
+export interface WorkspaceNavigationRequest {
+    readonly reason: 'busy' | 'history' | 'readonly';
+    readonly batchId: string;
+    readonly toolId?: string;
+    readonly entryId?: string;
+}
+export interface WorkspaceConfig {
+    toolOptions?: {
+        translation?: {
+            targets: readonly {
+                code: string;
+                label: string;
+            }[];
+        };
+        expand?: {
+            prompt?: boolean;
+            ratios?: readonly string[];
+        };
+    };
+    /** The host opens its route/container. The core never constructs a product URL. */
+    navigation?: {
+        openWorkspace(request: WorkspaceNavigationRequest): void | Promise<void>;
+    };
+    parameterDefaults?: readonly WorkspaceParameterDefault[];
+    capabilities?: readonly WorkspaceCapability[];
+    visibility?: {
+        brand?: boolean;
+        history?: boolean;
+        import?: boolean;
+        export?: boolean;
+        newBatch?: boolean;
+        draftReset?: boolean;
+        theme?: boolean;
+        language?: boolean;
+        /** 服务可用性诊断与重新检测入口；不影响实际执行能力检查。 */
+        serviceStatus?: boolean;
+    };
+    /** Host confirmation/reset policy. False or rejection preserves the original state. */
+    beforeReset?(request: WorkspaceResetRequest): boolean | Promise<boolean>;
+}
+/** V1 compatibility only: omitting config retains the original metadata tool.
+ * Passing an explicit {} closes it too. Every newly introduced tool stays closed. */
+export declare const DEFAULT_WORKSPACE_CONFIG: WorkspaceConfig;

package/dist/types/batch/public/contracts.d.ts

@@ -0,0 +1,272 @@
+import type { WorkspaceConfig } from './config';
+import type { WorkspaceServices } from './service-contracts';
+export * from './service-contracts';
+/** Version 1 candidate surface. No product identity, authorization or wallet objects. */
+export interface MetadataParameters {
+    version: 1;
+    removeGps: true;
+    removeDevice: true;
+    removeSerial: true;
+    removeTime: boolean;
+    removeAuthorComments: boolean;
+}
+export interface MetadataResult {
+    blob: Blob;
+    inputSha256: string;
+    outputSha256: string;
+    changed: boolean;
+    format: 'png' | 'jpeg' | 'webp';
+    removedCount: number;
+    removed: Record<'gps' | 'device' | 'serial' | 'time' | 'authorComments', number>;
+}
+export interface MetadataExecutor {
+    run(blob: Blob, params: MetadataParameters | {
+        execution: 'browser';
+        mode: 'declare';
+    }, expectedSha256?: string, signal?: AbortSignal): Promise<MetadataResult>;
+    dispose(): void;
+}
+export interface WorkspaceFile {
+    name: string;
+    blob: Blob;
+    itemId: string;
+    versionId: string;
+}
+export interface WorkspaceAssetIdentity {
+    assetId: string;
+    assetVersionId: string;
+    sha256: string;
+}
+export interface WorkspaceAssetReference extends WorkspaceAssetIdentity {
+    mime: string;
+    bytes: number;
+    width: number;
+    height: number;
+}
+export interface WorkspaceExternalSource {
+    readonly url: string;
+    readonly expectedSha256?: string;
+}
+export interface WorkspaceExecutionPlan {
+    readonly clientRequestId: string;
+    readonly operationId: string;
+    readonly itemId: string;
+    readonly inputVersionId: string;
+    readonly inputSha256: string;
+    readonly toolId: string;
+    readonly toolVersion: '1' | '2';
+    readonly params: Readonly<Record<string, unknown>>;
+}
+export interface WorkspaceDisclosure {
+    method?: 'manual' | 'ai';
+    decision: 'YES' | 'NO' | 'REVIEW';
+    reason: string;
+    status: 'verified' | 'unchanged' | 'review';
+    verified: boolean;
+    keywordPresent: boolean;
+    fileSha256: string;
+}
+export type WorkspaceLocalResult = {
+    kind: 'image';
+    blob: Blob;
+    reason?: string;
+    disclosure?: WorkspaceDisclosure;
+} | {
+    kind: 'analysis';
+    reason: string;
+    skipped?: boolean;
+    disclosure?: WorkspaceDisclosure;
+};
+export interface WorkspaceLocalExecutor {
+    run(plan: WorkspaceExecutionPlan, input: Blob, context: {
+        signal: AbortSignal;
+        readAsset(reference: WorkspaceAssetIdentity): Promise<Blob>;
+        progress(value: {
+            stage: 'decode' | 'process' | 'encode';
+            completed: number;
+            total?: number;
+        }): void;
+    }): Promise<WorkspaceLocalResult>;
+    dispose(): void;
+}
+export interface WorkspaceLocalCapability {
+    supports?(params: Readonly<Record<string, unknown>>): boolean;
+    createExecutor(): WorkspaceLocalExecutor;
+}
+import type { WorkspaceRemoteExecution, WorkspaceRemoteResultDetails } from './remote-contracts';
+export * from './remote-contracts';
+export interface WorkspacePageSession {
+    readonly active: boolean;
+    readonly batchId: string | undefined;
+    start(): Promise<void>;
+    bind(batchId: string): void;
+    stop(): void;
+}
+export interface BatchWorkspaceAdapter {
+    namespace: string;
+    /** SDK 页签绑定；需配合按项目读取的持久化，缺省保留旧的命名空间单写者契约。 */
+    pageSession?: () => WorkspacePageSession;
+    services?: WorkspaceServices;
+    coordination?: {
+        acquire(namespace: string): Promise<() => void | Promise<void>>;
+    };
+    assets: {
+        read(key: string): Promise<Blob | undefined>;
+        write(key: string, blob: Blob): Promise<void>;
+        remove(key: string): Promise<void>;
+        describe(blob: Blob): Promise<{
+            sha256: string;
+            width: number;
+            height: number;
+        }>;
+        /** Resolve a frozen identity without relying on mutable UI draft metadata. */
+        resolveReference?(identity: WorkspaceAssetIdentity, signal?: AbortSignal): Promise<WorkspaceAssetReference>;
+        readReference?(reference: WorkspaceAssetReference, signal?: AbortSignal): Promise<Blob>;
+        /** Explicit host-owned external IO. Frozen versions require an expected hash. */
+        readExternal?(source: WorkspaceExternalSource, signal?: AbortSignal): Promise<Blob>;
+    };
+    execution?: {
+        local?: Readonly<Record<string, WorkspaceLocalCapability>>;
+        remote?: WorkspaceRemoteExecution;
+    };
+    persistence: {
+        load(page?: {
+            batchId?: string;
+        }): Promise<unknown>;
+        save(snapshot: unknown): Promise<void>;
+        loadBatch?(batchId: string): Promise<unknown>;
+        list?(): Promise<unknown[]>;
+        removeBatch?(batchId: string): Promise<void>;
+    };
+    metadata: {
+        createExecutor(): MetadataExecutor;
+    };
+    download?(file: WorkspaceFile): Promise<void> | void;
+}
+export type WorkspaceCommand = {
+    type: 'updateConfig';
+    config: WorkspaceConfig;
+    display?: WorkspaceDisplay;
+} | {
+    type: 'updateContext';
+    adapter: BatchWorkspaceAdapter;
+    revision: string;
+    display?: WorkspaceDisplay;
+} | {
+    type: 'newBatch';
+} | {
+    type: 'openBatch';
+    batchId: string;
+} | {
+    type: 'restoreVersion';
+    itemId: string;
+    versionId: string;
+} | {
+    type: 'resetDraft';
+    toolId: string;
+    entryId?: string;
+} | {
+    type: 'runTool';
+    toolId: string;
+    params: Readonly<Record<string, unknown>>;
+} | {
+    type: 'cancelAttempt';
+    attemptId: string;
+} | {
+    type: 'queryAttempt' | 'stopWaiting' | 'resumeWaiting' | 'cancelRemote';
+    attemptId: string;
+} | {
+    type: 'importFiles';
+    files: File[];
+} | {
+    type: 'openTool';
+    toolId: string;
+    entryId?: string;
+} | {
+    type: 'runMetadataCleanup';
+    removeTime?: boolean;
+    removeAuthorComments?: boolean;
+} | {
+    type: 'select';
+    itemIds: string[];
+} | {
+    type: 'exportCurrent';
+    itemIds?: string[];
+};
+export type WorkspaceCommandResult = {
+    status: 'completed';
+    operationId?: string;
+    files?: readonly WorkspaceFile[];
+} | {
+    status: 'rejected';
+    code: string;
+    message: string;
+};
+export interface WorkspaceSnapshot {
+    readonly schemaVersion: 1;
+    readonly context: Readonly<{
+        namespace: string;
+        revision: string;
+    }>;
+    readonly writable: boolean;
+    readonly ready: boolean;
+    readonly batchId: string;
+    readonly selectedIds: readonly string[];
+    readonly items: readonly {
+        readonly id: string;
+        readonly name: string;
+        readonly currentVersionId: string;
+        readonly versions: readonly {
+            readonly id: string;
+            readonly sha256?: string;
+            readonly parentVersionId?: string;
+        }[];
+    }[];
+    readonly attempts: readonly {
+        readonly id: string;
+        readonly clientRequestId: string;
+        readonly operationId: string;
+        readonly itemId: string;
+        readonly taskId?: string;
+        readonly inputVersionId?: string;
+        readonly status: string;
+        readonly statusVersion: number;
+        readonly outcome?: Readonly<Omit<WorkspaceRemoteResultDetails, 'disclosure'>> & {
+            readonly disclosure?: Readonly<WorkspaceDisclosure> | null;
+        };
+        readonly admission?: 'accepted' | 'not_accepted' | 'unknown';
+        readonly remoteExecutionStatus?: string;
+        readonly publicationStatus?: 'pending' | 'unknown' | 'published';
+        readonly waitingStopped?: boolean;
+        readonly applied?: boolean;
+        readonly error?: string;
+    }[];
+    readonly operations: readonly {
+        readonly id: string;
+        readonly toolId: string;
+        readonly toolVersion: string;
+        readonly params: Readonly<Record<string, unknown>>;
+    }[];
+}
+export interface WorkspaceEvent {
+    readonly type: 'ready' | 'changed' | 'disposed' | 'error';
+    readonly snapshot: WorkspaceSnapshot;
+    readonly message?: string;
+}
+export interface BatchWorkspaceHandle {
+    command(command: WorkspaceCommand): Promise<WorkspaceCommandResult>;
+    snapshot(): WorkspaceSnapshot;
+    subscribe(listener: (event: WorkspaceEvent) => void): () => void;
+    dispose(): Promise<void>;
+}
+export interface BatchWorkspaceProps {
+    adapter: BatchWorkspaceAdapter;
+    config?: WorkspaceConfig;
+    display?: WorkspaceDisplay;
+    revision?: string;
+    onEvent?: (event: WorkspaceEvent) => void;
+}
+export interface WorkspaceDisplay {
+    locale?: 'en' | 'zh-CN' | 'ja' | 'ko' | 'ar' | 'es' | 'fr' | 'de';
+    theme?: 'light' | 'dark' | 'system';
+}