@opengeni/artifact-tool 0.2.2

package/dist/production.d.ts

@@ -0,0 +1,96 @@
+import type { FileBlob } from "./file-blob.js";
+import { Document as ReferenceDocument, DocumentFile as ReferenceDocumentFile, type DocumentCreateOptions, type SerializedDocument } from "./document.js";
+import { Presentation as ReferencePresentation, PresentationFile as ReferencePresentationFile, type PresentationCreateOptions } from "./presentation.js";
+import { ArtifactKernelRuntime } from "./runtime.js";
+import { Workbook as ReferenceWorkbook, type SerializedWorkbook, type WorkbookOptions } from "./spreadsheet.js";
+import { SpreadsheetFile as ReferenceSpreadsheetFile } from "./spreadsheet-file.js";
+export { SPREADSHEET_RECALCULATION_LIMITS, SPREADSHEET_SNAPSHOT_LIMITS, ChartSeriesCollection, CommentThread, ConditionalFormattingCollection, DataValidationCollection, FreezePanes, ImageCollection, Range, RangeConditionalFormats, RangeFormat, RangeSparklines, ShapeCollection, SparklineGroup, SparklineGroupCollection, SpreadsheetChart, SpreadsheetChartSeries, SpreadsheetImage, SpreadsheetShape, Table, TableCollection, WorkbookComments, Worksheet, WorksheetCollection, validateSerializedWorkbook, } from "./spreadsheet.js";
+export type { RangeSparklineConfig, RangeWritePayload, SerializedWorkbook, SparklineConfig, SpreadsheetRecalculationLimits, WorkbookChange, WorkbookOptions, } from "./spreadsheet.js";
+export { DocumentBlockCollection, DocumentCommentThread, DocumentComments, DocumentPageBreak, DocumentParagraph, DocumentSection, DocumentSectionStories, DocumentSections, DocumentStory, DocumentTable, DocumentTextRun, TrackedChange, TrackedChanges, } from "./document.js";
+export type { DocumentBlock, DocumentCreateOptions, DocumentPageGeometry, DocumentParagraphEdit, DocumentParagraphFormat, DocumentParagraphStyle, DocumentRenderOptions, DocumentStoryBlock, DocumentTableStyle, DocumentTextStyle, DocumentTextStylePatch, SerializedDocument, SerializedDocumentBlock, SerializedDocumentComment, SerializedDocumentSection, SerializedPageBreak, SerializedParagraph, SerializedStory, SerializedTable, SerializedTextRun, SerializedTrackedChange, } from "./document.js";
+export { InvalidPresentationInputError, PresentationChart, PresentationChartCollection, PresentationChartSeries, PresentationChartSeriesCollection, PresentationGroup, PresentationGroupCollection, PresentationImage, PresentationImageCollection, PresentationLayout, PresentationLayoutCollection, PresentationMaster, PresentationMasterCollection, PresentationShape, PresentationShapeCollection, PresentationTable, PresentationTableCell, PresentationTableCollection, PresentationText, Slide, SlideCollection, SlidePlaceholderCollection, UnsupportedPresentationFeatureError, assertPresentationRenderPixelBudget, presentationColorValue, truncatePresentationText, } from "./presentation.js";
+export type { PresentationChartConfig, PresentationChartSeriesConfig, PresentationChartType, PresentationCreateOptions, PresentationElement, PresentationExportOptions, PresentationFill, PresentationGroupChild, PresentationGroupChildConfig, PresentationGroupConfig, PresentationImageConfig, PresentationImageResolution, PresentationImageResolver, PresentationInspectOptions, PresentationInspectResult, PresentationLayoutConfig, PresentationLine, PresentationMasterConfig, PresentationPosition, PresentationRasterImageContentType, PresentationResolvedObject, PresentationShapeConfig, PresentationShapeGeometry, PresentationTableCellConfig, PresentationTableCellInput, PresentationTableConfig, PresentationTemplateElement, PresentationTextStyle, } from "./presentation.js";
+export { SpreadsheetFidelityError, SpreadsheetSecurityError } from "./spreadsheet-file.js";
+export type { SpreadsheetFidelityIssue, SpreadsheetLossPreservationEnvelope, SpreadsheetXlsxExportOptions, SpreadsheetXlsxImportLimits, SpreadsheetXlsxImportOptions, } from "./spreadsheet-file.js";
+export type ArtifactBatchControls<Root> = Readonly<{
+    /** One atomic host/native transaction; nested edits reconcile exactly once. */
+    batch<Result>(callback: (artifact: Root) => Result): Result;
+    /** Idempotently releases the owned exact native session. */
+    dispose(): void;
+}>;
+export type Workbook = ReferenceWorkbook & ArtifactBatchControls<ReferenceWorkbook>;
+export type Document = ReferenceDocument & ArtifactBatchControls<ReferenceDocument>;
+export type Presentation = ReferencePresentation & ArtifactBatchControls<ReferencePresentation>;
+export type WorkbookFactory = Readonly<{
+    prototype: ReferenceWorkbook;
+    [Symbol.hasInstance](value: unknown): boolean;
+    create(options?: WorkbookOptions): Workbook;
+    fromCSV(csvText: string, options?: {
+        sheetName?: string;
+        delimiter?: string;
+    }): Promise<Workbook>;
+    fromJSON(input: unknown): Workbook;
+}>;
+export type DocumentFactory = Readonly<{
+    prototype: ReferenceDocument;
+    [Symbol.hasInstance](value: unknown): boolean;
+    create(options?: DocumentCreateOptions): Document;
+    fromJSON(input: unknown): Document;
+}>;
+export type PresentationFactory = Readonly<{
+    prototype: ReferencePresentation;
+    [Symbol.hasInstance](value: unknown): boolean;
+    create(options?: PresentationCreateOptions): Presentation;
+}>;
+/**
+ * Installs the one exact native runtime selected by host bootstrap. Runtime
+ * replacement is deliberately forbidden: a process that needs another target
+ * must use an isolated worker/process and configure it once.
+ */
+export declare function configureArtifactRuntime(runtime: ArtifactKernelRuntime): void;
+/** Exact configured runtime, or null before the host bootstrap runs. */
+export declare function getConfiguredArtifactRuntime(): ArtifactKernelRuntime | null;
+/** Skill-compatible factory; returned objects are exact native composites. */
+export declare const Workbook: WorkbookFactory;
+/** Skill-compatible factory; returned objects are exact native composites. */
+export declare const Document: DocumentFactory;
+/** Skill-compatible factory; returned objects are exact native composites. */
+export declare const Presentation: PresentationFactory;
+export declare class SpreadsheetFile {
+    static importXlsx(...args: Parameters<typeof ReferenceSpreadsheetFile.importXlsx>): Promise<Workbook>;
+    static exportXlsx(workbook: ReferenceWorkbook, options?: Parameters<typeof ReferenceSpreadsheetFile.exportXlsx>[1]): Promise<FileBlob>;
+    static fidelityReport(workbook: ReferenceWorkbook): ReturnType<typeof ReferenceSpreadsheetFile.fidelityReport>;
+    static lossPreservationEnvelope(workbook: ReferenceWorkbook): ReturnType<typeof ReferenceSpreadsheetFile.lossPreservationEnvelope>;
+    static attachLossPreservationEnvelope(workbook: ReferenceWorkbook, envelope: Parameters<typeof ReferenceSpreadsheetFile.attachLossPreservationEnvelope>[1], options?: Parameters<typeof ReferenceSpreadsheetFile.attachLossPreservationEnvelope>[2]): Promise<void>;
+}
+export declare class DocumentFile {
+    static importDocx(...args: Parameters<typeof ReferenceDocumentFile.importDocx>): Promise<Document>;
+    static exportDocx(document: ReferenceDocument): Promise<FileBlob>;
+}
+export declare class PresentationFile {
+    static importPptx(...args: Parameters<typeof ReferencePresentationFile.importPptx>): Promise<Presentation>;
+    static exportPptx(presentation: ReferencePresentation, options?: Parameters<typeof ReferencePresentationFile.exportPptx>[1]): Promise<FileBlob>;
+    static fidelityReport(presentation: ReferencePresentation): ReturnType<typeof ReferencePresentationFile.fidelityReport>;
+    static lossPreservationEnvelope(presentation: ReferencePresentation): ReturnType<typeof ReferencePresentationFile.lossPreservationEnvelope>;
+}
+export type ArtifactCompositeDiagnostics = Readonly<{
+    version: 1;
+    modality: "spreadsheet" | "document" | "presentation";
+    namespace: string;
+    runtimeTarget: string;
+    runtimeBuildIdentity: string;
+    nativeRevision: bigint;
+    nativeStateHash: string;
+    nativeSnapshot: Uint8Array;
+    hostProjection: SerializedWorkbook | SerializedDocument | Record<string, unknown>;
+}>;
+/**
+ * Point-in-time diagnostics only. This is deliberately not a persistence,
+ * restore, or provenance envelope: presentation layout snapshots omit media
+ * bytes and host capabilities, and the two projections are not cryptographically
+ * bound. Durable state uses canonical collaboration snapshots plus the owned
+ * format-loss envelope instead of pretending this view is restorable.
+ */
+export declare function getArtifactCompositeDiagnostics(artifact: ReferenceWorkbook | ReferenceDocument | ReferencePresentation): ArtifactCompositeDiagnostics;
+/** Idempotently closes the exact native session owned by a facade artifact. */
+export declare function disposeArtifact(artifact: ReferenceWorkbook | ReferenceDocument | ReferencePresentation): void;

package/dist/raster-image.d.ts

@@ -0,0 +1,34 @@
+export type RasterImageContentType = "image/png" | "image/jpeg" | "image/gif" | "image/webp";
+export type RasterImageMetadata = {
+    contentType: RasterImageContentType;
+    width: number;
+    height: number;
+};
+/** Internal validation failure. Public model boundaries translate this to their typed error. */
+export declare class RasterImageValidationError extends Error {
+    readonly name = "RasterImageValidationError";
+    get detail(): string;
+}
+/** Decode already-syntax-checked base64 without forcing a large intermediary string when supported. */
+export declare function decodeRasterBase64(encoded: string): Uint8Array<ArrayBuffer>;
+/** Encode bytes using the zero-copy native primitive where available, with a bounded fallback. */
+export declare function encodeRasterBase64(bytes: Uint8Array): string;
+/** Normalize one supported raster MIME without admitting active image formats. */
+export declare function normalizeRasterContentType(value: unknown): RasterImageContentType;
+/** Validate bytes and, when supplied, bind the declared MIME to their signature. */
+export declare function validateRasterImageBytes(bytes: Uint8Array, declaredType?: unknown): RasterImageContentType;
+/** Strictly decode and canonicalize an inline raster source under a byte cap. */
+export declare function canonicalizeRasterDataUrl(value: unknown, maximumBytes: number): Readonly<{
+    contentType: RasterImageContentType;
+    canonical: string;
+    byteLength: number;
+}>;
+/** Count UTF-8 bytes without allocating an encoded copy; returns as soon as the cap is crossed. */
+export declare function boundedUtf8ByteLength(value: string, maximum: number): number;
+/**
+ * Structurally validates supported raster bytes before a native/browser decoder sees them.
+ *
+ * Callers must separately bound the encoded byte length. This parser bounds decoded canvas,
+ * animation frame count, and cumulative animated pixels while walking each container once.
+ */
+export declare function inspectRasterImage(bytes: Uint8Array): RasterImageMetadata;

package/dist/reference.d.ts

@@ -0,0 +1,17 @@
+/**
+ * TypeScript artifact models used for API conformance, codec development, and
+ * deterministic tests. They are not a production fallback for the Rust
+ * native/WASM kernel.
+ *
+ * Production Node/Bun spreadsheet editing uses the native session facade.
+ * Browser editing uses `@opengeni/sdk/editable-artifacts`, which owns a
+ * dedicated Worker and the paired WASM kernel.
+ */
+export * from "./document.js";
+export * from "./kernel.js";
+export * from "./presentation.js";
+export * from "./spreadsheet.js";
+export { SpreadsheetFile } from "./spreadsheet-file.js";
+export { Document as ReferenceDocument } from "./document.js";
+export { Presentation as ReferencePresentation } from "./presentation.js";
+export { Workbook as ReferenceWorkbook } from "./spreadsheet.js";