@lingbi/studio 0.4.0 → 0.5.0

package/Application.d.ts

@@ -1,39 +1,87 @@
+import { ImportPerformanceMode } from './ImportPerformanceMode';
 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 lastPublishedInset;
+    private lastPublishedToolbarBusinessStateKey;
+    private lastPublishedToolbarState;
+    private latestRendererWorkspaceState;
+    private nextArchiveTaskId;
+    private nextDownloadTaskId;
     private renderer;
     private workspace;
     mount(container: HTMLElement): void;
-    importObj(source: ObjImportSource): Promise<ObjImportResult>;
+    setImportPerformanceMode(mode: ImportPerformanceMode): 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 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 handleDownloadRequested;
+    private handleBooleanRequested;
+    private handleModelVisibilityRequested;
+    private createExportJobFromCurrentScene;
+    private handleDownloadStateChanged;
+    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 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/StudioToolbarState.d.ts

@@ -0,0 +1,20 @@
+/** 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 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,38 @@
  */
 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 downloadStatusElement;
+    private readonly downloadSuccessElement;
     private readonly editButtonElement;
     private readonly editStatusElement;
+    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 modelPanelVisible;
+    constructor(container: HTMLElement, onEditRequested: () => void, onEditExited: () => void, onDownloadRequested: () => void, onBooleanRequested?: () => void, onBooleanEditConfirmed?: () => void, onBooleanEditCancelled?: () => void, onModelVisibilityRequested?: (role: StudioModelRole, visible: boolean) => void);
+    /** Applies Application's combined renderer and download state. */
+    setToolbarState(state: StudioToolbarState): void;
     getViewportBottomInset(): number;
     dispose(): void;
     private wrapClick;
+    private toggleModelVisibilityPanel;
+    private wrapModelVisibilityClick;
+    private updateModelVisibilityButton;
+    private createVisibilityIcon;
 }
+export {};

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 {};

package/archive/ArchiveImportWorkerFactory.d.ts

@@ -0,0 +1,4 @@
+import type { ArchiveImportWorkerEndpoint } from './ArchiveImportWorkerEndpoint';
+export interface ArchiveImportWorkerFactory {
+    create(): ArchiveImportWorkerEndpoint;
+}

package/archive/ArchiveImportWorkerMessage.d.ts

@@ -0,0 +1,48 @@
+import type { ArchiveImportModelFormat } from './ArchiveImportModelFormat';
+import type { ArchiveImportRole } from './ArchiveImportRole';
+export interface ArchiveImportStartMessage {
+    readonly file: File;
+    readonly taskId: number;
+    readonly type: 'start';
+}
+export interface ArchiveImportAcknowledgeChunkMessage {
+    readonly chunkId: number;
+    readonly taskId: number;
+    readonly type: 'acknowledge-chunk';
+}
+export interface ArchiveImportCancelMessage {
+    readonly taskId: number;
+    readonly type: 'cancel';
+}
+export type ArchiveImportInboundMessage = ArchiveImportAcknowledgeChunkMessage | ArchiveImportCancelMessage | ArchiveImportStartMessage;
+export interface ArchiveImportEntryStartMessage {
+    readonly entryId: number;
+    readonly fileName: string;
+    readonly format?: ArchiveImportModelFormat;
+    readonly isModel: boolean;
+    readonly role: ArchiveImportRole;
+    readonly taskId: number;
+    readonly type: 'entry-start';
+}
+export interface ArchiveImportEntryChunkMessage {
+    readonly chunk: ArrayBuffer;
+    readonly chunkId: number;
+    readonly entryId: number;
+    readonly final: boolean;
+    readonly taskId: number;
+    readonly type: 'entry-chunk';
+}
+export interface ArchiveImportCancelledMessage {
+    readonly taskId: number;
+    readonly type: 'cancelled';
+}
+export interface ArchiveImportCompleteMessage {
+    readonly taskId: number;
+    readonly type: 'complete';
+}
+export interface ArchiveImportErrorMessage {
+    readonly message: string;
+    readonly taskId: number;
+    readonly type: 'error';
+}
+export type ArchiveImportOutboundMessage = ArchiveImportCancelledMessage | ArchiveImportCompleteMessage | ArchiveImportEntryChunkMessage | ArchiveImportEntryStartMessage | ArchiveImportErrorMessage;

package/archive/ArchiveImportWorkerMessageParser.d.ts

@@ -0,0 +1,16 @@
+import type { ArchiveImportInboundMessage, ArchiveImportOutboundMessage } from './ArchiveImportWorkerMessage';
+/** Narrows structured-clone data at the archive Worker boundary. */
+export declare class ArchiveImportWorkerMessageParser {
+    parseInbound(value: unknown): ArchiveImportInboundMessage | undefined;
+    parseOutbound(value: unknown): ArchiveImportOutboundMessage | undefined;
+    private getRecord;
+    private isFileLike;
+    private isFormat;
+    private isPositiveSafeInteger;
+    private isRecord;
+    private parseAcknowledgement;
+    private parseCancellation;
+    private parseEntryChunk;
+    private parseEntryStart;
+    private parseStart;
+}

package/archive/ArchiveImportWorkerPort.d.ts

@@ -0,0 +1,5 @@
+import type { ArchiveImportOutboundMessage } from './ArchiveImportWorkerMessage';
+export interface ArchiveImportWorkerPort {
+    addEventListener(type: 'message', listener: (event: MessageEvent<unknown>) => void): void;
+    postMessage(message: ArchiveImportOutboundMessage, transfer?: readonly Transferable[]): void;
+}

package/archive/ArchiveImportWorkerRuntime.d.ts

@@ -0,0 +1,47 @@
+import type { ArchiveImportWorkerPort } from './ArchiveImportWorkerPort';
+/** Streams a ZIP file through fflate and returns validated role files by chunk. */
+export declare class ArchiveImportWorkerRuntime {
+    private readonly inputChunkSize;
+    private activeTask;
+    private readonly jobValidator;
+    private latestStartedTaskId;
+    private readonly centralDirectoryValidator;
+    private readonly messageParser;
+    private readonly pathValidator;
+    private readonly port;
+    constructor(port: ArchiveImportWorkerPort);
+    attach(): void;
+    private acknowledgeChunk;
+    private cancelTask;
+    private copyChunk;
+    private createUnzip;
+    private drainMessages;
+    private handleArchiveStream;
+    private handleDirectoryData;
+    private handleEntryData;
+    private handleFile;
+    private handleInboundMessage;
+    private handleCancellation;
+    private handleChunkAcknowledgement;
+    private handleDirectory;
+    private handleMessage;
+    private handleStart;
+    private isCurrentTask;
+    private postCancelled;
+    private postComplete;
+    private postError;
+    private processInputChunk;
+    private pushToUnzip;
+    private queueEntryChunk;
+    private queueEntryStart;
+    private registerEntry;
+    private runTask;
+    private sendQueuedMessage;
+    private throwIfCancelled;
+    private assertRoleOrder;
+    private validateArchive;
+    private validateChecksums;
+    private cancelReader;
+    private getErrorMessage;
+    private isCancelledError;
+}