@lingbi/studio 0.4.0 → 0.6.0

package/Application.d.ts

@@ -1,39 +1,115 @@
+import { ImportPerformanceMode } from './ImportPerformanceMode';
+import type { ModelInventoryConfirmationHandler, ModelInventoryHandler } from './ModelInventory';
 import type { ModelResourceSceneSource } from './ModelResourceSceneSource';
 import type { ObjImportResult } from './ObjImportResult';
-import type { ObjImportSource } from './ObjImportSource';
-import type { ObjResourceListSource } from './ObjResourceListSource';
-import type { ObjResourceSceneSource } from './ObjResourceSceneSource';
-import type { ObjSceneSource } from './ObjSceneSource';
 export declare class Application {
+    private archiveImportController;
+    private archiveImporting;
+    private booleanEditConfirmationVisible;
     private disposed;
-    private lastPublishedEditState;
+    private downloadController;
+    private downloadError;
+    private downloadSuccess;
+    private downloading;
+    private readonly exportContextFactory;
+    private exportSceneContext;
+    private editedArchiveResourceContext;
+    private importGeneration;
+    private importPerformanceMode;
+    private inventoryConfirmationController;
+    private inventoryConfirming;
+    private inventoryError;
+    private inventorying;
+    private modelInventoryConfirmationHandler;
+    private modelInventoryController;
+    private modelInventoryHandler;
+    private editStatusMessage;
     private lastPublishedInset;
+    private lastPublishedToolbarBusinessStateKey;
+    private lastPublishedToolbarState;
+    private latestRendererWorkspaceState;
+    private nextArchiveTaskId;
+    private nextDownloadTaskId;
+    private nextInventoryTaskId;
     private renderer;
     private workspace;
     mount(container: HTMLElement): void;
-    importObj(source: ObjImportSource): Promise<ObjImportResult>;
+    setImportPerformanceMode(mode: ImportPerformanceMode): void;
+    /** Injects the host-owned business operation used by the inventory button. */
+    setModelInventoryHandler(handler?: ModelInventoryHandler): void;
+    /** Injects the host confirmation shown before inventory preparation starts. */
+    setModelInventoryConfirmationHandler(handler?: ModelInventoryConfirmationHandler): void;
     importModelResourceScene(source: ModelResourceSceneSource): Promise<ObjImportResult>;
-    importObjResources(source: ObjResourceListSource): Promise<ObjImportResult>;
-    importObjResourceScene(source: ObjResourceSceneSource): Promise<ObjImportResult>;
-    importObjScene(source: ObjSceneSource): Promise<ObjImportResult>;
+    /**
+     * Imports one ZIP produced by Studio's download command as a preserved-pose
+     * stone-and-base scene. The caller chooses this entry explicitly; the
+     * archive is never inspected for an implicit baked marker.
+     */
+    importEditedModelArchive(file: File): Promise<ObjImportResult>;
     resetView(): void;
     takeScreenshot(): Promise<Blob>;
     dispose(): void;
-    private handleEditRequested;
-    private handleEditExited;
-    private assertNotDisposed;
+    private cancelDownload;
+    private cancelInventory;
+    private cancelInventoryConfirmation;
+    private cancelArchiveImport;
+    private completeModelResourceSceneImport;
+    private completeEditedArchiveImport;
+    private completeEditedArchiveImportFailure;
+    private commitExportSceneContext;
+    private clearExportSceneContext;
+    private createExportJob;
+    private createExportJobRequest;
+    private createCancelledImportResult;
+    private createExportRole;
+    private createGeneratedBaseExportRole;
+    private getGeneratedMaterialFileName;
+    private isModelFile;
     private getRenderer;
+    private handleDownloadFailure;
+    private handleDownloadSuccess;
+    private handleInventoryFailure;
+    private handleInventorySuccess;
+    private handleDownloadRequested;
+    private handleInventoryRequested;
+    /** Both call sites validate disposal, handler identity, and scene readiness first. */
+    private startInventory;
+    private confirmInventoryAndStart;
+    private handleBooleanRequested;
+    private handleModelVisibilityRequested;
+    private createExportJobFromCurrentScene;
+    private createInventoryJobFromCurrentScene;
+    private handleDownloadStateChanged;
+    private handleInventoryStateChanged;
+    private handleEditOperationBlocked;
+    private handleEditExited;
+    private handleEditRequested;
+    private handleBooleanEditConfirmed;
+    private handleBooleanEditCancelled;
+    private handleRendererWorkspaceStateChanged;
     private hasValidSceneSource;
-    private releaseRuntime;
-    private mapObjImportResult;
-    private mapObjImportSource;
-    private mapModelResourceSceneSource;
     private mapModelResourceListSource;
-    private mapObjResourceSceneSource;
-    private mapObjSceneSource;
-    private mapObjResourceListSource;
-    private mapUpAxis;
+    private mapImportPerformanceMode;
+    private mapModelResourceSceneSource;
+    private mapObjImportResult;
     private mapStoneBasePoseMode;
-    private mapAsyncObjImportResult;
+    private mapUpAxis;
     private mapWarnings;
+    private clearBooleanEditConfirmation;
+    private publishWorkspaceState;
+    private createToolbarBusinessStateKey;
+    private isSameToolbarState;
+    private isSameModelVisibility;
+    private shouldDeferToolbarState;
+    private canDownload;
+    private canInventory;
+    private isInventorySceneReady;
+    private isInventoryVisible;
+    private isExportReady;
+    private assertNotDisposed;
+    private releaseRuntime;
+    private isCurrentImportGeneration;
+    private mapEditedArchiveError;
+    private startImportGeneration;
+    private invalidateImportGeneration;
 }

package/DownloadSaveSink.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Browser save target for a ZIP stream. Chromium writes directly to the user
+ * selected file; other browsers retain chunks only for the final Blob fallback.
+ */
+export declare class DownloadSaveSink {
+    private aborted;
+    private readonly blobChunks;
+    private completed;
+    private readonly nativeWritable;
+    private constructor();
+    static create(): Promise<DownloadSaveSink>;
+    get usesNativeStream(): boolean;
+    abort(): Promise<void>;
+    complete(): Promise<void>;
+    write(chunk: Uint8Array): Promise<void>;
+    private static createNativeSink;
+    private static getBrowserFilePicker;
+    private static hasBrowserFilePicker;
+    private downloadBlob;
+    private revokeObjectUrl;
+}

package/EditedArchiveResourceContext.d.ts

@@ -0,0 +1,32 @@
+import { ModelUpAxis, StoneBasePoseMode } from '@lingbi/renderer';
+import type { ArchiveImportResult } from './archive/ArchiveImportResult';
+import type { ModelExportSceneCandidate } from './ModelExportContext';
+export interface EditedArchiveRendererResourceFile {
+    readonly fetchUrl: string;
+    readonly fileName: string;
+}
+interface EditedArchiveRendererResourceList {
+    readonly files: readonly EditedArchiveRendererResourceFile[];
+    readonly upAxis: ModelUpAxis.Z;
+}
+export interface EditedArchiveRendererSource {
+    readonly base: EditedArchiveRendererResourceList;
+    readonly poseMode: StoneBasePoseMode.PreservePose;
+    readonly stone: EditedArchiveRendererResourceList;
+}
+/** Owns local Blob URLs created from one validated edited-result archive. */
+export declare class EditedArchiveResourceContext {
+    readonly candidate: ModelExportSceneCandidate;
+    readonly rendererSource: EditedArchiveRendererSource;
+    private disposed;
+    private readonly objectUrls;
+    constructor(result: ArchiveImportResult);
+    dispose(): void;
+    private createFile;
+    private createRoleResources;
+    private findRole;
+    private getMimeType;
+    private getUrl;
+    private matchesRole;
+}
+export {};

package/ImportPerformanceMode.d.ts

@@ -0,0 +1,5 @@
+export declare enum ImportPerformanceMode {
+    Off = "off",
+    Summary = "summary",
+    Verbose = "verbose"
+}

package/ModelDownloadController.d.ts

@@ -0,0 +1,21 @@
+import type { ExportJobRequest } from './export/ExportJobRequest';
+/**
+ * Owns one browser download lifecycle. It keeps the Worker, native file
+ * stream and stale task messages together so Application only manages UI and
+ * renderer resource context.
+ */
+export declare class ModelDownloadController {
+    private readonly onDownloadFailed;
+    private readonly onDownloadSucceeded;
+    private readonly onDownloadStateChanged;
+    private activeTask;
+    private disposed;
+    constructor(onDownloadFailed: () => void, onDownloadSucceeded: () => void, onDownloadStateChanged: (downloading: boolean) => void);
+    cancel(): void;
+    dispose(): void;
+    start(createJob: () => ExportJobRequest | undefined): void;
+    writeZipChunk(taskId: number, chunk: Uint8Array): Promise<void>;
+    private completeTask;
+    private run;
+    private isCurrentTask;
+}

package/ModelExportContext.d.ts

@@ -0,0 +1,20 @@
+export type ModelExportFormat = 'obj' | 'ply';
+export type ModelExportRole = 'base' | 'stone';
+export interface ModelExportFile {
+    readonly fileName: string;
+    readonly isModel: boolean;
+    readonly url: string;
+}
+export interface ModelExportRoleContext {
+    readonly files: readonly ModelExportFile[];
+    readonly format: ModelExportFormat;
+    readonly role: ModelExportRole;
+}
+export interface ModelExportSceneCandidate {
+    readonly base?: ModelExportRoleContext;
+    readonly stone: ModelExportRoleContext;
+}
+/** Resource context committed only after Renderer commits the same scene. */
+export interface ModelExportSceneContext extends ModelExportSceneCandidate {
+    readonly revision: number;
+}

package/ModelExportContextFactory.d.ts

@@ -0,0 +1,21 @@
+import type { ModelExportSceneCandidate, ModelExportSceneContext } from './ModelExportContext';
+import type { ModelResourceListSource } from './ModelResourceListSource';
+interface ModelExportSceneSource {
+    readonly base?: ModelResourceListSource;
+    readonly stone?: ModelResourceListSource;
+}
+/**
+ * Copies and validates the caller-owned resource list before it enters the
+ * Renderer. It retains only data Studio needs for a later download.
+ */
+export declare class ModelExportContextFactory {
+    commit(candidate: ModelExportSceneCandidate, revision: number): ModelExportSceneContext | undefined;
+    create(source: ModelExportSceneSource): ModelExportSceneCandidate | undefined;
+    private createFile;
+    private createRoleContext;
+    private getFileName;
+    private getModelFormat;
+    private parseResourceUrl;
+    private isStringArray;
+}
+export {};

package/ModelInventory.d.ts

@@ -0,0 +1,19 @@
+/** The complete, latest file set for one stone-and-base inventory request. */
+export interface ModelInventoryFiles {
+    readonly base: readonly File[];
+    readonly stone: readonly File[];
+}
+/** Data handed to the host after Studio has prepared the inventory files. */
+export interface ModelInventoryRequest {
+    readonly files: ModelInventoryFiles;
+    /** Aborts when Studio invalidates the in-flight inventory task. */
+    readonly signal: AbortSignal;
+}
+/** Data handed to the host before Studio starts preparing inventory files. */
+export interface ModelInventoryConfirmationRequest {
+    readonly signal: AbortSignal;
+}
+/** Allows the host to confirm an inventory request before any export work starts. */
+export type ModelInventoryConfirmationHandler = (request: ModelInventoryConfirmationRequest) => Promise<boolean>;
+/** Host-owned business operation which receives the prepared files. */
+export type ModelInventoryHandler = (request: ModelInventoryRequest) => Promise<void>;

package/ModelInventoryController.d.ts

@@ -0,0 +1,29 @@
+import type { ExportJobRequest } from './export/ExportJobRequest';
+import type { ModelExportWorkerClientListener } from './export/ModelExportWorkerClientListener';
+import type { ModelExportWorkerFactory } from './export/ModelExportWorkerFactory';
+import type { ModelInventoryHandler } from './ModelInventory';
+/** Owns preparation, collection and host hand-off for one inventory task. */
+export declare class ModelInventoryController implements ModelExportWorkerClientListener {
+    private readonly onInventoryFailed;
+    private readonly onInventorySucceeded;
+    private readonly onInventoryStateChanged;
+    private readonly workerFactory;
+    private activeTask;
+    private disposed;
+    constructor(onInventoryFailed: () => void, onInventorySucceeded: () => void, onInventoryStateChanged: (inProgress: boolean) => void, workerFactory?: ModelExportWorkerFactory);
+    cancel(): void;
+    dispose(): void;
+    reportExportError(_taskId: number, _message: string): void;
+    reportExportProgress(_taskId: number, _completedFileCount: number, _totalFileCount: number): void;
+    start(createJob: () => ExportJobRequest | undefined, handler: ModelInventoryHandler): void;
+    writeZipChunk(taskId: number, chunk: Uint8Array): Promise<void>;
+    private completeTask;
+    private concatenate;
+    private createFiles;
+    private copyBytes;
+    private getMimeType;
+    private run;
+    private isCancelled;
+    private isAbortError;
+    private isCurrentTask;
+}

package/StudioToolbarState.d.ts

@@ -0,0 +1,25 @@
+/** Studio-owned state projected onto the bottom toolbar. */
+export interface StudioToolbarState {
+    readonly booleanEnabled?: boolean;
+    readonly booleanInProgress?: boolean;
+    readonly booleanReediting?: boolean;
+    readonly booleanResultInvalidated?: boolean;
+    readonly booleanEditConfirmationVisible?: boolean;
+    readonly downloadEnabled: boolean;
+    readonly downloadError?: string;
+    readonly downloadInProgress?: boolean;
+    readonly downloadSuccess?: string;
+    readonly editActive: boolean;
+    readonly editEnabled: boolean;
+    readonly editVisible: boolean;
+    readonly editStatusMessage?: string;
+    readonly inventoryEnabled?: boolean;
+    readonly inventoryError?: string;
+    readonly inventoryInProgress?: boolean;
+    readonly inventoryVisible?: boolean;
+    readonly modelVisibility?: {
+        readonly baseVisible: boolean;
+        readonly enabled: boolean;
+        readonly stoneVisible: boolean;
+    };
+}

package/StudioWorkspace.d.ts

@@ -1,3 +1,5 @@
+import type { StudioToolbarState } from './StudioToolbarState';
+type StudioModelRole = 'base' | 'stone';
 /**
  * Studio-owned chrome around the render canvas: the viewport, the bottom
  * toolbar with its edit control, and the floating edit-status bubble that
@@ -6,21 +8,47 @@
  */
 export declare class StudioWorkspace {
     readonly canvas: HTMLCanvasElement;
-    private static readonly EDIT_BUTTON_VIEWPORT_BOTTOM_INSET;
+    private static readonly SVG_NAMESPACE;
+    private static readonly BOTTOM_TOOLBAR_BOTTOM_OFFSET;
+    private static readonly BOTTOM_TOOLBAR_HEIGHT;
+    private static readonly BOTTOM_TOOLBAR_VIEWPORT_GAP;
+    private static readonly BOTTOM_TOOLBAR_VIEWPORT_BOTTOM_INSET;
+    private readonly booleanButtonElement;
+    private readonly booleanOperationOverlayElement;
+    private readonly booleanOperationStatusElement;
+    private readonly booleanEditConfirmationElement;
     private readonly bottomToolbarElement;
+    private readonly downloadButtonElement;
+    private readonly downloadButtonWrapperElement;
+    private readonly downloadStatusElement;
+    private readonly downloadSuccessElement;
     private readonly editButtonElement;
     private readonly editStatusElement;
+    private readonly editStatusTextElement;
+    private readonly inventoryButtonElement;
+    private readonly inventoryButtonWrapperElement;
+    private readonly modelButtonElement;
+    private readonly modelVisibilityElement;
+    private readonly stoneVisibilityButtonElement;
+    private readonly baseVisibilityButtonElement;
     private readonly listenerAbortController;
     private readonly rootElement;
     private readonly styleElement;
-    constructor(container: HTMLElement, onEditRequested: () => void, onEditExited: () => void);
-    /**
-     * Single entry point that reflects the renderer-owned edit truth onto the
-     * toolbar: viewing shows an inert 编辑 until a dual-model scene enables
-     * it; editing floats a hint bubble with a dedicated exit above it.
-     */
-    setEditButtonState(visible: boolean, enabled: boolean, active: boolean): void;
+    private currentEditActive;
+    private modelPanelVisible;
+    constructor(container: HTMLElement, onEditRequested: () => void, onEditExited: () => void, onDownloadRequested: () => void, onBooleanRequested?: () => void, onBooleanEditConfirmed?: () => void, onBooleanEditCancelled?: () => void, onModelVisibilityRequested?: (role: StudioModelRole, visible: boolean) => void, onInventoryRequested?: () => void, onEditOperationBlocked?: () => void);
+    /** Applies Application's combined renderer and download state. */
+    setToolbarState(state: StudioToolbarState): void;
     getViewportBottomInset(): number;
     dispose(): void;
     private wrapClick;
+    private wrapOperationClick;
+    private wrapOperationKeyDown;
+    private setInventoryButtonVisible;
+    private updateOperationButtonWrapper;
+    private toggleModelVisibilityPanel;
+    private wrapModelVisibilityClick;
+    private updateModelVisibilityButton;
+    private createVisibilityIcon;
 }
+export {};

package/THIRD_PARTY_LICENSES.md

@@ -2,6 +2,30 @@
 
 The app bundles dependencies which contain the following licenses:
 
+## fflate - 0.8.3 (MIT)
+
+MIT License
+
+Copyright (c) 2026 Arjun Barrett
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
 ## three - 0.185.1 (MIT)
 
 The MIT License

package/archive/ArchiveImportCentralDirectoryValidator.d.ts

@@ -0,0 +1,21 @@
+export interface ArchiveImportChecksumEntry {
+    readonly byteLength: number;
+    readonly crc32: number;
+    readonly path: string;
+}
+/** Checks central-directory sizes and CRC values without buffering model data. */
+export declare class ArchiveImportCentralDirectoryValidator {
+    private readonly pathValidator;
+    validate(file: File, entries: readonly ArchiveImportChecksumEntry[], signal?: AbortSignal): Promise<void>;
+    private decodeName;
+    private findEndRecord;
+    private invalidArchive;
+    private parseCentralRecord;
+    private readCentralDirectory;
+    private readEndRecord;
+    private validatePath;
+    private validateRecords;
+    private readUint16;
+    private readUint32;
+    private throwIfAborted;
+}

package/archive/ArchiveImportChunkAcknowledgement.d.ts

@@ -0,0 +1,12 @@
+export declare class ArchiveImportChunkAcknowledgement {
+    readonly chunkId: number;
+    readonly promise: Promise<void>;
+    readonly taskId: number;
+    private rejectPromise;
+    private resolvePromise;
+    private settled;
+    constructor(taskId: number, chunkId: number);
+    acknowledge(): void;
+    cancel(): void;
+    private initializePromise;
+}

package/archive/ArchiveImportCrc32.d.ts

@@ -0,0 +1,8 @@
+/** Small incremental CRC-32 implementation used to verify ZIP entries. */
+export declare class ArchiveImportCrc32 {
+    private readonly table;
+    private value;
+    constructor();
+    digest(): number;
+    update(data: Uint8Array): void;
+}

package/archive/ArchiveImportError.d.ts

@@ -0,0 +1,9 @@
+export declare enum ArchiveImportErrorCode {
+    Cancelled = "cancelled",
+    InvalidSource = "invalid-source",
+    Protocol = "protocol"
+}
+export declare class ArchiveImportError extends Error {
+    readonly code: ArchiveImportErrorCode;
+    constructor(code: ArchiveImportErrorCode, message: string);
+}

package/archive/ArchiveImportFileResult.d.ts

@@ -0,0 +1,7 @@
+import type { ArchiveImportModelFormat } from './ArchiveImportModelFormat';
+export interface ArchiveImportFileResult {
+    readonly chunks: readonly Uint8Array<ArrayBuffer>[];
+    readonly fileName: string;
+    readonly format?: ArchiveImportModelFormat;
+    readonly isModel: boolean;
+}

package/archive/ArchiveImportJobRequest.d.ts

@@ -0,0 +1,4 @@
+export interface ArchiveImportJobRequest {
+    readonly file: File;
+    readonly taskId: number;
+}

package/archive/ArchiveImportJobValidator.d.ts

@@ -0,0 +1,8 @@
+import type { ArchiveImportJobRequest } from './ArchiveImportJobRequest';
+/** Validates the small structured-clone request before a Worker task starts. */
+export declare class ArchiveImportJobValidator {
+    validate(job: ArchiveImportJobRequest): void;
+    private isReadableFile;
+    private getRecord;
+    private isRecord;
+}

package/archive/ArchiveImportModelFormat.d.ts

@@ -0,0 +1 @@
+export type ArchiveImportModelFormat = 'obj' | 'ply';

package/archive/ArchiveImportPathValidator.d.ts

@@ -0,0 +1,22 @@
+import type { ArchiveImportModelFormat } from './ArchiveImportModelFormat';
+import type { ArchiveImportRole } from './ArchiveImportRole';
+export type ArchiveImportPath = {
+    readonly kind: 'directory';
+    readonly role: ArchiveImportRole;
+} | {
+    readonly fileName: string;
+    readonly format?: ArchiveImportModelFormat;
+    readonly isModel: boolean;
+    readonly kind: 'file';
+    readonly role: ArchiveImportRole;
+};
+/** Enforces the two-level stone/base archive contract. */
+export declare class ArchiveImportPathValidator {
+    parse(path: string): ArchiveImportPath;
+    private getModelFormat;
+    private hasControlCharacter;
+    private invalidPath;
+    private isDrivePath;
+    private parseDirectory;
+    private parseRole;
+}

package/archive/ArchiveImportResult.d.ts

@@ -0,0 +1,6 @@
+import type { ArchiveImportRoleResult } from './ArchiveImportRoleResult';
+export interface ArchiveImportResult {
+    readonly roles: readonly ArchiveImportRoleResult[];
+}
+export type { ArchiveImportFileResult } from './ArchiveImportFileResult';
+export type { ArchiveImportRoleResult } from './ArchiveImportRoleResult';

package/archive/ArchiveImportResultAccumulator.d.ts

@@ -0,0 +1,17 @@
+import type { ArchiveImportResult } from './ArchiveImportResult';
+import type { ArchiveImportEntryChunkMessage, ArchiveImportEntryStartMessage } from './ArchiveImportWorkerMessage';
+/** Reassembles ordered Worker entry chunks and performs a second protocol check. */
+export declare class ArchiveImportResultAccumulator {
+    private activeEntry;
+    private readonly entries;
+    private lastChunkId;
+    private lastEntryId;
+    private lastRoleIndex;
+    acceptChunk(message: ArchiveImportEntryChunkMessage): void;
+    complete(): ArchiveImportResult;
+    startEntry(message: ArchiveImportEntryStartMessage): void;
+    private createFileResult;
+    private createRoleResults;
+    private protocolError;
+    private hasControlCharacter;
+}

package/archive/ArchiveImportRole.d.ts

@@ -0,0 +1 @@
+export type ArchiveImportRole = 'base' | 'stone';

package/archive/ArchiveImportRoleResult.d.ts

@@ -0,0 +1,6 @@
+import type { ArchiveImportFileResult } from './ArchiveImportFileResult';
+import type { ArchiveImportRole } from './ArchiveImportRole';
+export interface ArchiveImportRoleResult {
+    readonly files: readonly ArchiveImportFileResult[];
+    readonly role: ArchiveImportRole;
+}

package/archive/ArchiveImportSignatureValidator.d.ts

@@ -0,0 +1,7 @@
+/** Checks the first local-file signature while the archive stream is opened. */
+export declare class ArchiveImportSignatureValidator {
+    private readonly prefix;
+    finish(): void;
+    push(chunk: Uint8Array): void;
+    private hasLocalFileSignature;
+}

package/archive/ArchiveImportWorkerClient.d.ts

@@ -0,0 +1,23 @@
+import type { ArchiveImportJobRequest } from './ArchiveImportJobRequest';
+import type { ArchiveImportResult } from './ArchiveImportResult';
+import type { ArchiveImportWorkerEndpointErrorListener, ArchiveImportWorkerEndpointMessageListener } from './ArchiveImportWorkerEndpoint';
+import type { ArchiveImportWorkerFactory } from './ArchiveImportWorkerFactory';
+/** Main-thread side of the archive import protocol and chunk accumulator. */
+export declare class ArchiveImportWorkerClient implements ArchiveImportWorkerEndpointErrorListener, ArchiveImportWorkerEndpointMessageListener {
+    private activeTask;
+    private disposed;
+    private readonly jobValidator;
+    private lastStartedTaskId;
+    private readonly messageParser;
+    private readonly workerFactory;
+    constructor(workerFactory?: ArchiveImportWorkerFactory);
+    cancel(taskId?: number): void;
+    dispose(): void;
+    handleWorkerEndpointError(message: string): void;
+    handleWorkerEndpointMessage(message: unknown): void;
+    start(job: ArchiveImportJobRequest): Promise<ArchiveImportResult>;
+    private acceptChunk;
+    private rejectTask;
+    private resolveTask;
+    private toError;
+}

package/archive/ArchiveImportWorkerClientTask.d.ts

@@ -0,0 +1,17 @@
+import type { ArchiveImportResult } from './ArchiveImportResult';
+import { ArchiveImportResultAccumulator } from './ArchiveImportResultAccumulator';
+import type { ArchiveImportWorkerEndpoint } from './ArchiveImportWorkerEndpoint';
+/** Completion state for one archive import Worker task. */
+export declare class ArchiveImportWorkerClientTask {
+    readonly accumulator: ArchiveImportResultAccumulator;
+    readonly completion: Promise<ArchiveImportResult>;
+    readonly endpoint: ArchiveImportWorkerEndpoint;
+    readonly taskId: number;
+    private rejectCompletion;
+    private resolveCompletion;
+    private settled;
+    constructor(taskId: number, endpoint: ArchiveImportWorkerEndpoint);
+    reject(reason: unknown): void;
+    resolve(result: ArchiveImportResult): void;
+    private initializeCompletion;
+}

package/archive/ArchiveImportWorkerEndpoint.d.ts

@@ -0,0 +1,13 @@
+import type { ArchiveImportInboundMessage } from './ArchiveImportWorkerMessage';
+export interface ArchiveImportWorkerEndpointErrorListener {
+    handleWorkerEndpointError(message: string): void;
+}
+export interface ArchiveImportWorkerEndpointMessageListener {
+    handleWorkerEndpointMessage(message: unknown): void;
+}
+export interface ArchiveImportWorkerEndpoint {
+    postMessage(message: ArchiveImportInboundMessage): void;
+    setErrorListener(listener: ArchiveImportWorkerEndpointErrorListener): void;
+    setMessageListener(listener: ArchiveImportWorkerEndpointMessageListener): void;
+    terminate(): void;
+}

package/archive/ArchiveImportWorkerEntry.d.ts

@@ -0,0 +1 @@
+export {};