@beeintel/batch-image 0.0.0-stage → 1.0.0

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

@@ -0,0 +1,114 @@
+import type { WorkspaceAssetReference, WorkspaceDisclosure, WorkspaceExecutionPlan } from './contracts';
+export interface WorkspaceRemoteDescriptor {
+    readonly serviceId: string;
+    readonly modeId: string;
+    readonly modelId?: string;
+    readonly paramsVersion: string;
+}
+export interface WorkspaceRemotePlan extends WorkspaceExecutionPlan, WorkspaceRemoteDescriptor {
+    readonly schemaVersion: 1;
+    readonly canonicalVersion: 'sorted-json-v1';
+    readonly batchId: string;
+    readonly contextRevision: string;
+    readonly input: Readonly<WorkspaceAssetReference>;
+    readonly paramsSha256: string;
+    readonly planSha256: string;
+}
+export interface WorkspaceRemoteGenerated {
+    outputId: string;
+    sha256: string;
+    mime: string;
+    bytes: number;
+    width: number;
+    height: number;
+}
+export interface WorkspaceRemoteResultDetails {
+    inputSha256?: string;
+    skipped?: boolean;
+    reason?: string;
+    reasonCode?: 'already_target_language' | 'no_editable_text';
+    disclosure?: WorkspaceDisclosure | null;
+    translation?: Record<string, unknown>;
+}
+export type WorkspaceRemoteResult = WorkspaceRemoteResultDetails & ({
+    kind: 'image';
+    asset: WorkspaceAssetReference;
+} | {
+    kind: 'analysis';
+});
+export interface WorkspaceRemoteReceipt {
+    schemaVersion: 1;
+    canonicalVersion: 'sorted-json-v1';
+    batchId: string;
+    clientRequestId: string;
+    operationId: string;
+    itemId: string;
+    inputVersionId: string;
+    inputSha256: string;
+    paramsSha256: string;
+    planSha256: string;
+    serviceId: string;
+    modeId: string;
+    modelId?: string;
+    paramsVersion: string;
+    toolId: string;
+    toolVersion: '1' | '2';
+    taskId: string;
+    status: 'accepted' | 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled';
+    statusVersion: number;
+    stage?: string;
+    pollAfterMs?: number;
+    result?: WorkspaceRemoteResult;
+    generated?: WorkspaceRemoteGenerated;
+    /** Validated workflow metadata retained while a generated output awaits publication. */
+    generatedDetails?: WorkspaceRemoteResultDetails;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+export type WorkspaceRemoteAdmission = {
+    state: 'accepted';
+    receipt: WorkspaceRemoteReceipt;
+} | {
+    state: 'not_accepted';
+    clientRequestId: string;
+    planSha256: string;
+    code: string;
+    reason: string;
+} | {
+    state: 'unknown' | 'not_found';
+    clientRequestId: string;
+    planSha256: string;
+    reason?: string;
+};
+export interface WorkspaceRemoteExecution {
+    supports(request: {
+        toolId: string;
+        params: Readonly<Record<string, unknown>>;
+    }): boolean;
+    describe(request: {
+        toolId: string;
+        params: Readonly<Record<string, unknown>>;
+    }): WorkspaceRemoteDescriptor;
+    submit(plan: WorkspaceRemotePlan, context: {
+        input: Blob;
+        signal: AbortSignal;
+        readAsset(reference: WorkspaceAssetReference): Promise<Blob>;
+    }): Promise<WorkspaceRemoteAdmission>;
+    query(taskId: string, plan: WorkspaceRemotePlan, signal?: AbortSignal): Promise<WorkspaceRemoteReceipt>;
+    queryByRequest(clientRequestId: string, plan: WorkspaceRemotePlan, signal?: AbortSignal): Promise<WorkspaceRemoteAdmission>;
+    publish?(request: {
+        plan: WorkspaceRemotePlan;
+        generated: WorkspaceRemoteGenerated;
+        publicationId: string;
+    }, signal?: AbortSignal): Promise<{
+        state: 'published';
+        publicationId: string;
+        asset: WorkspaceAssetReference;
+    } | {
+        state: 'unknown' | 'pending';
+        publicationId: string;
+    }>;
+    cancel?(taskId: string, plan: WorkspaceRemotePlan, signal?: AbortSignal): Promise<WorkspaceRemoteReceipt>;
+}

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

@@ -0,0 +1,40 @@
+/** Explicit, immutable resources for the existing browser cutout modes. No site-root defaults. */
+export type WorkspaceCutoutModel = 'isnet_fp16' | 'birefnet_quality';
+export interface WorkspaceCutoutResourceSource {
+    manifestUrl: string;
+    manifestSha256: string;
+    modelBaseUrl: string;
+    runtimeBaseUrl: string;
+}
+export interface WorkspaceCutoutResources {
+    models: Partial<Record<WorkspaceCutoutModel, WorkspaceCutoutResourceSource>>;
+    /** Optional host-built module workers implementing the documented engine messages. */
+    workers?: Partial<Record<WorkspaceCutoutModel, string>>;
+}
+export interface WorkspaceBrowserAdapterOptions {
+    namespace: string;
+    /** Explicit HTTP(S) directory containing the SDK's prepared immutable resources. */
+    resourceBaseUrl?: string;
+    /** Advanced custom resource/Worker contract; mutually exclusive with resourceBaseUrl. */
+    cutoutResources?: WorkspaceCutoutResources;
+}
+export interface WorkspaceCutoutResourceFile {
+    kind: 'model' | 'runtime';
+    size: number;
+    mime: string;
+    sha256: string;
+    chunks: {
+        name: string;
+        offsets: [number, number];
+        sha256: string;
+    }[];
+}
+export interface WorkspaceCutoutResourceManifest {
+    schemaVersion: 1;
+    model: WorkspaceCutoutModel;
+    modelId: string;
+    revision: string;
+    runtimeVersion: string;
+    /** Model paths are relative to modelBaseUrl; runtime paths to runtimeBaseUrl. */
+    files: Record<string, WorkspaceCutoutResourceFile>;
+}

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

@@ -0,0 +1,43 @@
+/** Optional compatibility services for retained tools. The core owns parsing and queue state.
+ * These are never required for browser tools or WorkspaceRemoteExecution. */
+export type WorkspaceServiceSource = {
+    kind: 'asset';
+    assetId: string;
+    assetVersionId: string;
+} | {
+    kind: 'external_url';
+    url: string;
+    expectedSha256?: string;
+};
+export interface WorkspaceTaskSubmission {
+    clientRequestId: string;
+    operationId: string;
+    itemId: string;
+    inputVersionId: string;
+    source: WorkspaceServiceSource;
+    toolId: string;
+    toolVersion: string;
+    params: Readonly<Record<string, unknown>>;
+    resumeFromTaskId?: string;
+    retryActionId?: string;
+    serviceEpoch?: string;
+}
+export interface WorkspaceUploadOptions {
+    resumeUploadId?: string;
+    strictResume?: boolean;
+    onTicket?: (uploadId: string) => void | Promise<void>;
+}
+export interface WorkspaceServices {
+    getCapabilities?(): Promise<unknown>;
+    getAiCapabilities?(): Promise<unknown>;
+    uploadLocal?(blob: Blob, filename: string, options?: WorkspaceUploadOptions): Promise<unknown>;
+    resolveAsset?(assetId: string, versionId: string): Promise<unknown>;
+    submitTask?(submission: WorkspaceTaskSubmission): Promise<unknown>;
+    queryOriginalTask?(taskId: string): Promise<unknown>;
+    getTask?(taskId: string, service?: 'node' | 'python-ai'): Promise<unknown>;
+    getTaskByRequest?(requestId: string, service?: 'node' | 'python-ai'): Promise<unknown>;
+    submitLirSegment?(body: Readonly<Record<string, unknown>>): Promise<unknown>;
+    exportDeclaredImage?(source: WorkspaceServiceSource, format: 'png' | 'jpeg', expectedSha256: string, service?: 'node' | 'python-ai'): Promise<Blob>;
+    fetchExternalSource?(url: string, expectedSha256?: string, signal?: AbortSignal): Promise<Blob>;
+    fetchExternalThumbnail?(url: string, expectedSha256?: string): Promise<Blob>;
+}

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

@@ -0,0 +1,34 @@
+import type { Attempt, Batch, Operation, ToolId } from './model';
+export declare const isPendingAttempt: (attempt: Attempt) => boolean;
+export declare const isUnsubmittedAttempt: (attempt: Attempt) => boolean;
+export declare function latestQueueSteps(batch: Batch): Map<string, Attempt>;
+export declare function itemQueueSteps(batch: Batch, itemId: string): Attempt[];
+export declare function queuePredecessors(batch: Batch): Map<string, Attempt>;
+export declare function queuePredecessor(batch: Batch, itemId: string): Attempt | undefined;
+export declare function latestOperationAttempt(batch: Batch, operationId: string, itemId: string): Attempt | undefined;
+export declare function dependsOnStep(batch: Batch, child: Attempt, operationId: string): boolean;
+export declare function queueChain(batch: Batch, step: Attempt): Attempt[];
+export declare function advanceQueue(batch: Batch): boolean;
+/** One operation admits work at a time. Existing receipts finish before queued recoveries. */
+export declare function executionOperation(batch: Batch): Operation | undefined;
+export declare function hasExceptionalDependency(batch: Batch, attempt: Attempt): boolean;
+export declare function createOperation(batch: Batch, itemIds: string[], toolId: ToolId, params: Record<string, unknown>): Operation;
+export declare function canRetryAttempt(batch: Batch, attempt: Attempt): boolean;
+export declare function retryFailed(batch: Batch, operationId: string, itemIds?: string[]): Attempt[];
+export declare function waitingDescendants(batch: Batch, attempt: Attempt): Attempt[];
+/** New intent explicitly replaces an unresolved failure; it never edits its frozen operation. */
+export declare function replaceFailedAttempt(batch: Batch, attemptId: string, toolId: ToolId, params: Record<string, unknown>): Operation;
+export declare function skipFailedStep(batch: Batch, attemptId: string): boolean;
+/** Validate the whole cohort before changing any dependency. Failed receipts remain as history. */
+export declare function skipFailedSteps(batch: Batch, ids: string[]): number;
+export type ForceInput = {
+    attemptId: string;
+    itemId: string;
+    versionId: string;
+};
+export declare function forceContinueCandidates(batch: Batch, operationId: string): ForceInput[];
+/** An explicit input fork: receipt facts remain, while released predecessors can never auto-adopt/replay. */
+export declare function forceContinueOperation(batch: Batch, operationId: string, frozen: ForceInput[]): number;
+export declare function cancelQueueStep(batch: Batch, attemptId: string, includeStep?: boolean): number;
+export declare function attentionItems(batch: Batch): string[];
+export declare function blockingStep(batch: Batch, attempt: Attempt): Attempt | undefined;

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

@@ -0,0 +1,85 @@
+import type { Asset, WorkflowResult, TaskStep, IpAnalysis } from './model';
+import { type TranslationDetails } from './features/image-translation/params';
+export type TaskResponse = {
+    submittedParams?: Record<string, unknown>;
+    taskId: string;
+    clientRequestId: string;
+    operationId: string;
+    itemId: string;
+    inputVersionId: string;
+    status: 'accepted' | 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled';
+    statusVersion: number;
+    stage?: string;
+    pollAfterMs?: number;
+    result?: WorkflowResult;
+    partialResult?: {
+        kind: 'image';
+        asset: Asset;
+    };
+    partialAnalysis?: IpAnalysis;
+    partialTranslation?: TranslationDetails;
+    steps?: TaskStep[];
+    error?: {
+        code: string;
+        message: string;
+        retryAction?: string;
+    };
+    actualSourceSha256?: string;
+};
+export type ExpectedTask = Partial<Pick<TaskResponse, 'taskId' | 'clientRequestId' | 'operationId' | 'itemId' | 'inputVersionId'>>;
+export declare function record(value: unknown): Record<string, unknown>;
+export declare function text(value: unknown): string;
+export declare function parseAsset(value: unknown): Asset;
+export declare function parseTaskResponse(value: unknown, expected?: ExpectedTask): TaskResponse;
+export declare function parseUploadStatus(value: unknown): {
+    status: "failed" | "ready" | "waiting_upload" | "verifying";
+    asset: Asset;
+    error: {
+        code: string;
+        message: string;
+        retryAction?: string;
+    };
+};
+export declare function parseUploadTicket(value: unknown): {
+    uploadId: string;
+    uploadUrl: string;
+    method: string;
+};
+export declare function parseCapabilities(value: unknown): {
+    storage: "local" | "r2";
+    taskPersistence: "local_disk";
+    authentication: "loopback_only";
+    idempotencyRetention: "local_state_lifetime";
+    uploadStatus: boolean;
+    maxItems: number;
+    maxUploadBytes: number;
+    maxPixels: number;
+    tools: string[];
+    metadataExport: boolean;
+    assetRetentionHours: number;
+};
+export declare function parseAiCapabilities(value: unknown): {
+    taskService: "python-ai";
+    queue: "sqlite-huey";
+    taskPersistence: "sqlite";
+    idempotencyRetention: "local_state_lifetime";
+    executor: "rembg" | "fixture";
+    tools: string[];
+    cutoutModels: string[];
+    retouchModes: string[];
+    upscaleModes: string[];
+    svgEngines: string[];
+    beautificationModes: string[];
+    lir: {
+        maxReferenceImages: number;
+        maxAcceptedTasks: number;
+        serviceEpoch: string;
+    };
+};
+export declare function parseErrorBody(value: unknown): {
+    code?: string;
+    message?: string;
+    accepted?: boolean | 'unknown';
+    retryAfterMs?: number;
+};
+export declare function parseSubmissionErrorBody(value: unknown): ReturnType<typeof parseErrorBody>;

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

@@ -0,0 +1,13 @@
+/** UTC milliseconds. File lifetime and page inactivity share a duration, not a start time. */
+export declare const RETENTION_MS: number;
+export declare const TEMP_RETENTION_POLICY: "batch-temp-48h-v1";
+export type RetentionPolicy = typeof TEMP_RETENTION_POLICY;
+export type AssetLifetime = {
+    availableUntil?: number;
+    retentionPolicy?: RetentionPolicy;
+};
+export declare function assetExpired(asset: AssetLifetime | undefined, now?: number): boolean;
+export declare function pageExpired(record: {
+    lastSeenAt?: number;
+    hiddenSince?: number;
+}, now?: number): boolean;

package/dist/types/onnxruntime-web.d.ts

@@ -0,0 +1,5 @@
+// onnxruntime-web 1.21.0 omits its declaration from the ESM exports condition.
+// This matches its published types.d.ts and uses the public common API types.
+declare module 'onnxruntime-web' {
+  export * from 'onnxruntime-common';
+}

package/dist/types/plugins/cutout/core/hosted-resources.d.ts

@@ -0,0 +1,11 @@
+import type { WorkspaceCutoutModel, WorkspaceCutoutResourceManifest, WorkspaceCutoutResourceSource } from '../../../batch/public/resource-contracts';
+export type CutoutResourceProgress = (key: string, current: number, total: number) => void;
+export declare function explicitResourceUrl(value: string, directory?: boolean): URL;
+export declare function validateCutoutResourceSource(source: WorkspaceCutoutResourceSource): void;
+/** Worker-safe loader, also usable by host executors. Every request is pinned and bounded. */
+export declare function loadCutoutResources(model: WorkspaceCutoutModel, source: WorkspaceCutoutResourceSource, signal?: AbortSignal, progress?: CutoutResourceProgress): Promise<{
+    manifest: WorkspaceCutoutResourceManifest;
+    source: WorkspaceCutoutResourceSource;
+    read: (path: string) => Promise<Uint8Array>;
+}>;
+export type LoadedCutoutResources = Awaited<ReturnType<typeof loadCutoutResources>>;

package/dist/types/processing.d.ts

@@ -0,0 +1,18 @@
+/** Pure processing protocol shared with optional external executors. No UI, store or network client. */
+export * from './batch/retention';
+export { processCutoutResult } from './batch/cutout-output';
+export * from './batch/features/basic-edit/engine.mjs';
+export * from './batch/features/brand-mark/engine.mjs';
+export * from './batch/features/shadow/engine.mjs';
+export * from './batch/features/background/engine.mjs';
+export { validateSvg } from './shared/svg-security.mjs';
+export type { WorkflowResult } from './batch/model';
+export { loadCutoutResources } from './plugins/cutout/core/hosted-resources';
+export type * from './batch/public/resource-contracts';
+export { createWorkspaceServiceClient, ApiError } from './batch/api';
+export { isPythonTool } from './batch/model';
+export { parseTaskResponse, parseAsset, parseUploadStatus, parseUploadTicket, parseCapabilities, parseAiCapabilities, parseErrorBody, parseSubmissionErrorBody, } from './batch/receipts';
+export { parseLirSegment } from './batch/features/listing-remake/transport';
+export { prepareSvgDownload as prepareSvgArtifactDownload } from './batch/features/svg-export/download-prepare';
+export { prepareSvgDownload } from './batch/features/svg-export/download';
+export type { SvgAssetReader, SvgDownloadInput, SvgDownloadResult } from './batch/features/svg-export/download-contract';

package/dist/types/shared/svg-security.d.mts

@@ -0,0 +1,4 @@
+export const MAX_SVG_BYTES: number;
+export const MAX_SVG_NODES: number;
+export const MAX_SVG_DEPTH: number;
+export function validateSvg(content: string | Uint8Array): { width: number; height: number };

package/dist/types/workspace-worker.d.ts

@@ -0,0 +1,2 @@
+/** Module worker URLs stay relative to the emitted package, independent of the app route. */
+export declare function createModuleWorker(source: string | URL, options?: WorkerOptions): Worker;

package/package.json

@@ -1,6 +1,94 @@
 {
   "name": "@beeintel/batch-image",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.0",
+  "description": "Embeddable batch image workspace for Vue applications",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "type": "module",
+  "files": [
+    "dist",
+    "README.md",
+    "FONT-LICENSE.txt"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./style.css": "./dist/style.css",
+    "./processing": {
+      "types": "./dist/processing.d.ts",
+      "import": "./dist/processing.js"
+    },
+    "./resources.json": "./dist/resources.json",
+    "./node": {
+      "types": "./dist/node/index.d.mts",
+      "import": "./dist/node/index.mjs"
+    }
+  },
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "peerDependencies": {
+    "vue": "^3.5.0",
+    "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
+  },
+  "dependencies": {
+    "@huggingface/transformers": "4.3.0",
+    "@imgly/background-removal": "1.7.0",
+    "@lucide/vue": "1.47.0",
+    "@lunapaint/tga-codec": "0.2.0",
+    "@tanstack/vue-virtual": "3.13.39",
+    "@xmldom/xmldom": "0.9.12",
+    "driver.js": "1.9.0",
+    "fflate": "0.8.3",
+    "gifenc": "1.0.3",
+    "imagetracerjs": "1.2.6",
+    "motion-v": "2.5.1",
+    "onnxruntime-common": "1.21.0",
+    "onnxruntime-web": "1.21.0",
+    "pinia": "4.0.3",
+    "svgo": "4.0.0",
+    "upng-js": "2.1.0",
+    "vue-i18n": "11.4.13"
+  },
+  "devDependencies": {
+    "@types/node": "22.18.6",
+    "@vitejs/plugin-vue": "5.2.4",
+    "@vue/compiler-dom": "3.5.41",
+    "@vue/compiler-sfc": "3.5.41",
+    "@vue/devtools-api": "8.2.1",
+    "@vue/server-renderer": "3.5.41",
+    "@vue/test-utils": "2.4.6",
+    "@webgpu/types": "0.1.60",
+    "css-tree": "3.2.1",
+    "fake-indexeddb": "6.2.5",
+    "jsdom": "26.1.0",
+    "sharp": "0.34.5",
+    "typescript": "5.8.3",
+    "vite": "6.4.3",
+    "vitest": "3.2.4",
+    "vue": "3.5.41",
+    "vue-router": "4.5.1",
+    "vue-tsc": "3.0.8"
+  },
+  "bin": {
+    "batch-images-prepare-resources": "./dist/node/cli.mjs"
+  },
+  "peerDependenciesMeta": {
+    "vite": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "watch": "node scripts/watch.mjs",
+    "typecheck": "vue-tsc --noEmit",
+    "test": "vitest run --maxWorkers=1 --config vitest.config.ts"
+  }
 }