@lingbi/studio 0.4.0 → 0.6.0

package/export/BrowserExportWorkerPort.d.ts

@@ -0,0 +1,7 @@
+import type { ExportWorkerOutboundMessage } from './ExportWorkerMessage';
+import type { ExportWorkerPort } from './ExportWorkerPort';
+/** Dedicated Worker global adapter kept separate from the pure runtime protocol. */
+export declare class BrowserExportWorkerPort implements ExportWorkerPort {
+    addEventListener(type: 'message', listener: (event: MessageEvent<unknown>) => void): void;
+    postMessage(message: ExportWorkerOutboundMessage, transfer?: readonly Transferable[]): void;
+}

package/export/BrowserModelExportWorkerEndpoint.d.ts

@@ -0,0 +1,15 @@
+import type { ExportWorkerInboundMessage } from './ExportWorkerMessage';
+import type { ModelExportWorkerEndpoint, ModelExportWorkerEndpointErrorListener, ModelExportWorkerEndpointMessageListener } from './ModelExportWorkerEndpoint';
+/** Native browser Worker adapter with the Vite-recognized module Worker constructor. */
+export declare class BrowserModelExportWorkerEndpoint implements ModelExportWorkerEndpoint {
+    private errorListener;
+    private messageListener;
+    private readonly worker;
+    constructor();
+    postMessage(message: ExportWorkerInboundMessage): void;
+    setErrorListener(listener: ModelExportWorkerEndpointErrorListener): void;
+    setMessageListener(listener: ModelExportWorkerEndpointMessageListener): void;
+    terminate(): void;
+    private handleError;
+    private handleMessage;
+}

package/export/BrowserModelExportWorkerFactory.d.ts

@@ -0,0 +1,6 @@
+import type { ModelExportWorkerEndpoint } from './ModelExportWorkerEndpoint';
+import type { ModelExportWorkerFactory } from './ModelExportWorkerFactory';
+/** Default factory retained behind an interface for Worker protocol tests. */
+export declare class BrowserModelExportWorkerFactory implements ModelExportWorkerFactory {
+    create(): ModelExportWorkerEndpoint;
+}

package/export/ByteChunkWriter.d.ts

@@ -0,0 +1,11 @@
+/** Builds one bounded output chunk while preserving source byte slices verbatim where possible. */
+export declare class ByteChunkWriter {
+    private buffer;
+    private length;
+    constructor(initialCapacity: number);
+    append(bytes: Uint8Array): void;
+    appendRange(bytes: Uint8Array, start: number, end: number): void;
+    hasData(): boolean;
+    toBytes(): Uint8Array;
+    private ensureCapacity;
+}

package/export/ExportChunkAcknowledgement.d.ts

@@ -0,0 +1,13 @@
+/** One explicit main-thread acknowledgement gate for a ZIP output chunk. */
+export declare class ExportChunkAcknowledgement {
+    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/export/ExportJobRequest.d.ts

@@ -0,0 +1,6 @@
+import type { ExportRoleRequest } from './ExportRoleRequest';
+/** A complete ZIP job with one visible role or stone followed by base. */
+export interface ExportJobRequest {
+    readonly roles: readonly ExportRoleRequest[];
+    readonly taskId: number;
+}

package/export/ExportJobValidator.d.ts

@@ -0,0 +1,17 @@
+import type { ExportJobRequest } from './ExportJobRequest';
+/** Validates the private Studio-to-Worker contract before either side starts I/O. */
+export declare class ExportJobValidator {
+    validate(job: ExportJobRequest): void;
+    private assertTaskId;
+    private assertRoles;
+    private assertRole;
+    private assertGeneratedRole;
+    private assertGeneratedSnapshot;
+    private hasFiniteValues;
+    private assertMatrix;
+    private assertFiles;
+    private assertFile;
+    private hasExpectedModelExtension;
+    private isModelFormat;
+    private isSafeFileName;
+}

package/export/ExportModelFormat.d.ts

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

package/export/ExportModelRole.d.ts

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

package/export/ExportResourceFile.d.ts

@@ -0,0 +1,6 @@
+/** A single source file retained as one ZIP entry for its model role. */
+export interface ExportResourceFile {
+    readonly fileName: string;
+    readonly isModel: boolean;
+    readonly url: string;
+}

package/export/ExportRoleRequest.d.ts

@@ -0,0 +1,25 @@
+import type { GeneratedBooleanBaseExportSnapshot } from '@lingbi/renderer';
+import type { ExportModelFormat } from './ExportModelFormat';
+import type { ExportModelRole } from './ExportModelRole';
+import type { ExportResourceFile } from './ExportResourceFile';
+/** Source data and the already-final renderer world matrix for one role. */
+export interface OriginalExportRoleRequest {
+    readonly kind?: 'original';
+    readonly files: readonly ExportResourceFile[];
+    readonly format: ExportModelFormat;
+    readonly matrix: readonly number[];
+    readonly role: ExportModelRole;
+}
+/** A Boolean-generated base mesh that replaces the original base model file. */
+export interface GeneratedObjExportRoleRequest {
+    readonly files: readonly ExportResourceFile[];
+    readonly format: 'obj';
+    readonly generated: GeneratedBooleanBaseExportSnapshot;
+    readonly kind: 'generated-obj';
+    readonly materialFileName: string;
+    readonly matrix: readonly number[];
+    readonly modelFileName: string;
+    readonly role: 'base';
+    readonly sourceFormat: ExportModelFormat;
+}
+export type ExportRoleRequest = OriginalExportRoleRequest | GeneratedObjExportRoleRequest;

package/export/ExportWorkerMessage.d.ts

@@ -0,0 +1,41 @@
+import type { ExportJobRequest } from './ExportJobRequest';
+export interface ExportWorkerAcknowledgeChunkMessage {
+    readonly chunkId: number;
+    readonly taskId: number;
+    readonly type: 'acknowledge-chunk';
+}
+export interface ExportWorkerCancelMessage {
+    readonly taskId: number;
+    readonly type: 'cancel';
+}
+export interface ExportWorkerStartMessage {
+    readonly job: ExportJobRequest;
+    readonly type: 'start';
+}
+export type ExportWorkerInboundMessage = ExportWorkerAcknowledgeChunkMessage | ExportWorkerCancelMessage | ExportWorkerStartMessage;
+export interface ExportWorkerCancelledMessage {
+    readonly taskId: number;
+    readonly type: 'cancelled';
+}
+export interface ExportWorkerCompleteMessage {
+    readonly taskId: number;
+    readonly type: 'complete';
+}
+export interface ExportWorkerErrorMessage {
+    readonly message: string;
+    readonly taskId: number;
+    readonly type: 'error';
+}
+export interface ExportWorkerProgressMessage {
+    readonly completedFileCount: number;
+    readonly taskId: number;
+    readonly totalFileCount: number;
+    readonly type: 'progress';
+}
+export interface ExportWorkerZipChunkMessage {
+    readonly chunk: ArrayBuffer;
+    readonly chunkId: number;
+    readonly taskId: number;
+    readonly type: 'zip-chunk';
+}
+export type ExportWorkerOutboundMessage = ExportWorkerCancelledMessage | ExportWorkerCompleteMessage | ExportWorkerErrorMessage | ExportWorkerProgressMessage | ExportWorkerZipChunkMessage;

package/export/ExportWorkerMessageParser.d.ts

@@ -0,0 +1,29 @@
+import type { ExportWorkerInboundMessage, ExportWorkerOutboundMessage } from './ExportWorkerMessage';
+/** Narrows structured-clone data at the worker boundary without using untyped values internally. */
+export declare class ExportWorkerMessageParser {
+    parseInbound(value: unknown): ExportWorkerInboundMessage | undefined;
+    parseOutbound(value: unknown): ExportWorkerOutboundMessage | undefined;
+    private getRecord;
+    private isPositiveSafeInteger;
+    private parseAcknowledgement;
+    private parseCancellation;
+    private parseProgress;
+    private parseStart;
+    private parseZipChunk;
+    private isModelFormat;
+    private isModelRole;
+    private isRecord;
+    private isUnknownArray;
+    private parseFile;
+    private parseFiles;
+    private parseJob;
+    private parseMatrix;
+    private parseRole;
+    private parseGeneratedRole;
+    private parseGeneratedSnapshot;
+    private parseGeneratedGroups;
+    private parseGeneratedMaterials;
+    private parseColor;
+    private parseRoles;
+    private isNonNegativeSafeInteger;
+}

package/export/ExportWorkerPort.d.ts

@@ -0,0 +1,6 @@
+import type { ExportWorkerOutboundMessage } from './ExportWorkerMessage';
+/** The minimal Worker-global port used by the runtime and replaceable by tests. */
+export interface ExportWorkerPort {
+    addEventListener(type: 'message', listener: (event: MessageEvent<unknown>) => void): void;
+    postMessage(message: ExportWorkerOutboundMessage, transfer?: readonly Transferable[]): void;
+}

package/export/ExportWorkerTask.d.ts

@@ -0,0 +1,15 @@
+import type { Zip } from 'fflate';
+import type { ExportChunkAcknowledgement } from './ExportChunkAcknowledgement';
+import type { ExportJobRequest } from './ExportJobRequest';
+/** Runtime-local state for one Worker job, deliberately isolated from later task ids. */
+export declare class ExportWorkerTask {
+    readonly abortController: AbortController;
+    awaitingAcknowledgement: ExportChunkAcknowledgement | undefined;
+    cancelled: boolean;
+    nextChunkId: number;
+    readonly queuedZipChunks: ArrayBuffer[];
+    readonly request: ExportJobRequest;
+    zip: Zip | undefined;
+    constructor(request: ExportJobRequest);
+    cancel(): void;
+}

package/export/GeneratedMtlWriter.d.ts

@@ -0,0 +1,10 @@
+import type { GeneratedBooleanBaseExportSnapshot } from '@lingbi/renderer';
+/** Rebuilds one MTL from used source definitions plus the Boolean cut material. */
+export declare class GeneratedMtlWriter {
+    createChunks(snapshot: GeneratedBooleanBaseExportSnapshot, sourceTexts: readonly string[]): readonly Uint8Array[];
+    private collectDefinitions;
+    private addDefinition;
+    private writeMaterial;
+    private writeMinimalMaterial;
+    private formatNumber;
+}

package/export/GeneratedObjModelBaker.d.ts

@@ -0,0 +1,12 @@
+import type { GeneratedBooleanBaseExportSnapshot } from '@lingbi/renderer';
+/** Serializes a renderer Boolean snapshot into a transformed OBJ stream. */
+export declare class GeneratedObjModelBaker {
+    createChunks(snapshot: GeneratedBooleanBaseExportSnapshot, matrix: readonly number[], materialFileName: string): readonly Uint8Array[];
+    private writeFaces;
+    private writeNormals;
+    private writePositions;
+    private writeUvs;
+    private getValue;
+    private formatIndex;
+    private formatNumber;
+}

package/export/GeneratedTextChunkWriter.d.ts

@@ -0,0 +1,10 @@
+/** Collects generated text into bounded transferable chunks. */
+export declare class GeneratedTextChunkWriter {
+    private chunks;
+    private current;
+    private currentLength;
+    private readonly encoder;
+    appendLine(value: string): void;
+    toChunks(): readonly Uint8Array[];
+    private append;
+}

package/export/MatrixTransformer.d.ts

@@ -0,0 +1,21 @@
+/** Applies an affine renderer Matrix4 and its normal inverse-transpose without Three.js. */
+export declare class MatrixTransformer {
+    private readonly inverseTranspose00;
+    private readonly inverseTranspose01;
+    private readonly inverseTranspose02;
+    private readonly inverseTranspose10;
+    private readonly inverseTranspose11;
+    private readonly inverseTranspose12;
+    private readonly inverseTranspose20;
+    private readonly inverseTranspose21;
+    private readonly inverseTranspose22;
+    private readonly matrix;
+    constructor(matrix: readonly number[]);
+    transformNormal(x: number, y: number, z: number): readonly [number, number, number];
+    transformPosition(x: number, y: number, z: number): readonly [number, number, number];
+    private assertAffineMatrix;
+    private assertFiniteResult;
+    private assertFiniteVector;
+    private createInverseTranspose;
+    private getMatrixValue;
+}

package/export/ModelExportError.d.ts

@@ -0,0 +1,14 @@
+export declare enum ModelExportErrorCode {
+    Cancelled = "cancelled",
+    InvalidJob = "invalid-job",
+    InvalidModel = "invalid-model",
+    InvalidSource = "invalid-source",
+    Protocol = "protocol",
+    UnsupportedModel = "unsupported-model",
+    WriteFailed = "write-failed"
+}
+/** A concise, intentional failure which can be shown by Studio without guessing. */
+export declare class ModelExportError extends Error {
+    readonly code: ModelExportErrorCode;
+    constructor(code: ModelExportErrorCode, message: string);
+}

package/export/ModelExportWorkerClient.d.ts

@@ -0,0 +1,24 @@
+import type { ExportJobRequest } from './ExportJobRequest';
+import type { ModelExportWorkerClientListener } from './ModelExportWorkerClientListener';
+import type { ModelExportWorkerEndpointErrorListener, ModelExportWorkerEndpointMessageListener } from './ModelExportWorkerEndpoint';
+import type { ModelExportWorkerFactory } from './ModelExportWorkerFactory';
+/** Main-thread side of the private Worker protocol, including ZIP write backpressure. */
+export declare class ModelExportWorkerClient implements ModelExportWorkerEndpointErrorListener, ModelExportWorkerEndpointMessageListener {
+    private activeTask;
+    private disposed;
+    private readonly jobValidator;
+    private lastStartedTaskId;
+    private readonly listener;
+    private readonly messageParser;
+    private readonly workerFactory;
+    constructor(listener: ModelExportWorkerClientListener, workerFactory?: ModelExportWorkerFactory);
+    cancel(taskId: number): void;
+    dispose(): void;
+    handleWorkerEndpointError(message: string): void;
+    handleWorkerEndpointMessage(message: unknown): void;
+    start(job: ExportJobRequest): Promise<void>;
+    private rejectTask;
+    private resolveTask;
+    private toError;
+    private writeAndAcknowledge;
+}

package/export/ModelExportWorkerClientListener.d.ts

@@ -0,0 +1,5 @@
+export interface ModelExportWorkerClientListener {
+    reportExportProgress?(taskId: number, completedFileCount: number, totalFileCount: number): void;
+    reportExportError?(taskId: number, message: string): void;
+    writeZipChunk(taskId: number, chunk: Uint8Array): Promise<void>;
+}

package/export/ModelExportWorkerClientTask.d.ts

@@ -0,0 +1,14 @@
+import type { ModelExportWorkerEndpoint } from './ModelExportWorkerEndpoint';
+/** Completion state for one client task; the promise has no hidden callbacks. */
+export declare class ModelExportWorkerClientTask {
+    readonly completion: Promise<void>;
+    readonly endpoint: ModelExportWorkerEndpoint;
+    readonly taskId: number;
+    private rejectCompletion;
+    private resolveCompletion;
+    private settled;
+    constructor(taskId: number, endpoint: ModelExportWorkerEndpoint);
+    reject(reason: unknown): void;
+    resolve(): void;
+    private initializeCompletion;
+}

package/export/ModelExportWorkerEndpoint.d.ts

@@ -0,0 +1,14 @@
+import type { ExportWorkerInboundMessage } from './ExportWorkerMessage';
+export interface ModelExportWorkerEndpointErrorListener {
+    handleWorkerEndpointError(message: string): void;
+}
+export interface ModelExportWorkerEndpointMessageListener {
+    handleWorkerEndpointMessage(message: unknown): void;
+}
+/** Small browser Worker adapter so client tests can substitute a deterministic endpoint. */
+export interface ModelExportWorkerEndpoint {
+    postMessage(message: ExportWorkerInboundMessage): void;
+    setErrorListener(listener: ModelExportWorkerEndpointErrorListener): void;
+    setMessageListener(listener: ModelExportWorkerEndpointMessageListener): void;
+    terminate(): void;
+}

package/export/ModelExportWorkerEntry.d.ts

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

package/export/ModelExportWorkerFactory.d.ts

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

package/export/ModelExportWorkerRuntime.d.ts

@@ -0,0 +1,47 @@
+import type { ExportWorkerPort } from './ExportWorkerPort';
+/** Fetches, transforms and streams an ordered ZIP wholly inside a dedicated Worker. */
+export declare class ModelExportWorkerRuntime {
+    private activeTask;
+    private readonly jobValidator;
+    private latestStartedTaskId;
+    private readonly messageParser;
+    private readonly port;
+    private readonly generatedMtlWriter;
+    private readonly generatedObjModelBaker;
+    constructor(port: ExportWorkerPort);
+    attach(): void;
+    private acknowledgeChunk;
+    private cancelTask;
+    private copyZipChunk;
+    private createBaker;
+    private createZip;
+    private drainZipChunks;
+    private exportFile;
+    private exportGeneratedRole;
+    private fetchSourceMaterialTexts;
+    private writeGeneratedEntry;
+    private createZipEntry;
+    private finishCurrentTask;
+    private getErrorMessage;
+    private getFileCount;
+    private getPotentialTaskId;
+    private getRoleMatrix;
+    private handleCancellation;
+    private handleChunkAcknowledgement;
+    private handleMessage;
+    private handleInboundMessage;
+    private handleStart;
+    private handleZipData;
+    private isCurrentTask;
+    private matchesRoleDirectory;
+    private isMtlFile;
+    private postCancelled;
+    private postComplete;
+    private postError;
+    private postProgress;
+    private runTask;
+    private streamResponseIntoEntry;
+    private pushEntryChunk;
+    private throwIfCancelled;
+    private isCancelledError;
+}

package/export/ObjModelBaker.d.ts

@@ -0,0 +1,27 @@
+/** Incrementally rewrites OBJ positions and normals while retaining non-model source bytes. */
+export declare class ObjModelBaker {
+    private static readonly MAX_LINE_BYTES;
+    private readonly encoder;
+    private readonly transformer;
+    private pending;
+    constructor(matrix: readonly number[]);
+    push(chunk: Uint8Array, final: boolean): Uint8Array;
+    private appendProcessedLine;
+    private appendNormalLine;
+    private appendVertexLine;
+    private assertFiniteColorValues;
+    private assertLineLength;
+    private collectFields;
+    private combinePending;
+    private decodeLine;
+    private findLineCommand;
+    private findLineEnd;
+    private hasSupportedVertexFieldCount;
+    private isAsciiWhitespace;
+    private isNumericLiteral;
+    private isWhitespace;
+    private parseFiniteNumber;
+    private replaceFieldValues;
+    private skipWhitespace;
+    private formatNumber;
+}

package/export/PlyHeaderParser.d.ts

@@ -0,0 +1,64 @@
+export type PlyFormat = 'ascii' | 'binary_big_endian' | 'binary_little_endian';
+export type PlyScalarType = 'char' | 'double' | 'float' | 'float32' | 'float64' | 'int' | 'int16' | 'int32' | 'int8' | 'short' | 'uchar' | 'uint' | 'uint16' | 'uint32' | 'uint8' | 'ushort';
+export interface PlyScalarDefinition {
+    readonly byteLength: number;
+    readonly floatingPoint: boolean;
+    readonly integer: boolean;
+}
+export interface PlyScalarProperty {
+    readonly kind: 'scalar';
+    readonly name: string;
+    readonly type: PlyScalarType;
+}
+export interface PlyListProperty {
+    readonly countType: PlyScalarType;
+    readonly itemType: PlyScalarType;
+    readonly kind: 'list';
+    readonly name: string;
+}
+export type PlyProperty = PlyListProperty | PlyScalarProperty;
+export interface PlyElement {
+    readonly count: number;
+    readonly name: string;
+    readonly properties: readonly PlyProperty[];
+}
+export interface PlyVertexField {
+    readonly asciiIndex: number;
+    readonly byteOffset: number;
+    readonly name: string;
+    readonly type: PlyScalarType;
+}
+export interface PlyVertexLayout {
+    readonly normal?: readonly [PlyVertexField, PlyVertexField, PlyVertexField];
+    readonly position: readonly [PlyVertexField, PlyVertexField, PlyVertexField];
+    readonly recordByteLength: number;
+}
+export interface PlySchema {
+    readonly elements: readonly PlyElement[];
+    readonly format: PlyFormat;
+    readonly vertexElementIndex: number;
+    readonly vertexLayout: PlyVertexLayout;
+}
+/** Parses only the declarative PLY header needed to safely locate vertex records. */
+export declare class PlyHeaderParser {
+    getScalarDefinition(type: PlyScalarType): PlyScalarDefinition;
+    parse(headerBytes: Uint8Array): PlySchema;
+    private addProperty;
+    private assertMagic;
+    private createVertexLayout;
+    private createNormalFields;
+    private createVertexFields;
+    private decodeHeader;
+    private findSingleField;
+    private findVertexElementIndex;
+    private getRecordByteLength;
+    private isListProperty;
+    private parseElement;
+    private parseCount;
+    private parseFormat;
+    private parseScalarType;
+    private isScalarType;
+    private requireFloatingPointField;
+    private requirePart;
+    private assertFloatingPointField;
+}

package/export/PlyModelBaker.d.ts

@@ -0,0 +1,52 @@
+/** Incrementally rewrites ordinary ASCII and binary PLY vertex data without parsing full files. */
+export declare class PlyModelBaker {
+    private static readonly MAX_BINARY_RECORD_BYTES;
+    private static readonly MAX_HEADER_BYTES;
+    private static readonly MAX_LINE_BYTES;
+    private completed;
+    private elementIndex;
+    private readonly encoder;
+    private readonly headerParser;
+    private pending;
+    private remainingElementRecords;
+    private schema;
+    private readonly transformer;
+    constructor(matrix: readonly number[]);
+    push(chunk: Uint8Array, final: boolean): Uint8Array;
+    private appendAsciiRecord;
+    private appendBinaryRecords;
+    private appendProcessedAsciiLines;
+    private assertCompleteSource;
+    private assertPendingByteLength;
+    private combinePending;
+    private consumeRecord;
+    private createAsciiFields;
+    private createReplacement;
+    private decodeAsciiLine;
+    private findHeaderEnd;
+    private findLineEnd;
+    private getBinaryRecordByteLength;
+    private getCurrentElement;
+    private getSchema;
+    private getSchemaOrUndefined;
+    private initializeElements;
+    private isEndHeaderLine;
+    private isNumericLiteral;
+    private isWhitespace;
+    private parseAsciiFloat;
+    private pushBody;
+    private pushHeaderAndInitialBody;
+    private readScalar;
+    private replaceAsciiValues;
+    private compareReplacements;
+    private formatNumber;
+    private skipWhitespace;
+    private transformAsciiVertex;
+    private createVertexReplacements;
+    private getCurrentElementPropertyCount;
+    private requireAsciiField;
+    private transformBinaryVertex;
+    private readRequiredFloat;
+    private writeRequiredFloat;
+    private advanceElement;
+}

package/index.d.ts

@@ -1,12 +1,10 @@
 export { Application } from './Application';
+export { ImportPerformanceMode } from './ImportPerformanceMode';
+export type { ModelInventoryConfirmationHandler, ModelInventoryConfirmationRequest, ModelInventoryFiles, ModelInventoryHandler, ModelInventoryRequest, } from './ModelInventory';
 export type { ModelResourceListSource } from './ModelResourceListSource';
 export type { ModelResourceSceneSource } from './ModelResourceSceneSource';
 export { ModelUpAxis } from './ModelUpAxis';
 export type { ObjImportResult } from './ObjImportResult';
 export type { ObjImportWarning } from './ObjImportResult';
 export { ObjImportFailureCode, ObjImportWarningCode } from './ObjImportResult';
-export type { ObjImportSource } from './ObjImportSource';
-export type { ObjResourceListSource } from './ObjResourceListSource';
-export type { ObjResourceSceneSource } from './ObjResourceSceneSource';
-export type { ObjSceneSource } from './ObjSceneSource';
 export { StoneBasePoseMode } from './StoneBasePoseMode';