@sqsoffice/slide 0.0.0-stage → 0.1.0

package/dist/types/app/lib/engine/protocol.d.ts

@@ -0,0 +1,233 @@
+import type { TextInput, TextSelection, ViewRequest, ViewResult } from './view';
+import type { ScriptReplay, ScriptRequest, ScriptResult } from './script';
+import type { McpRequest, McpResult } from '../automation/protocol';
+import type { SourceInput, SourceInputResult, SourceSelectionHistory } from './markdown';
+import type { SheetClipboardRequest, SheetClipboardResult } from './sheet-clipboard';
+import type { PresentationClipboardRequest, PresentationClipboardResult } from './presentation-clipboard';
+import type { SheetValidationPolicy, SheetValidationReport } from './sheet-validation';
+import type { PdfImportRequest, PdfImportResult } from './pdf-import';
+export type Json = null | boolean | number | string | Json[] | {
+    [key: string]: Json;
+};
+export type Command = {
+    kind: string;
+    [key: string]: Json;
+};
+export type CommandResponse = {
+    kind: 'read';
+    revision: number;
+    value: Json;
+} | {
+    kind: 'error';
+    code: string;
+    message: string;
+};
+export interface CalculationEnvironment {
+    seconds: string;
+    nanos: number;
+    offset: number;
+    seed: string;
+    activeCell?: {
+        sheet: number;
+        row: number;
+        column: number;
+    };
+    locale?: 'zh-CN' | 'en-US' | 'de-DE' | 'en-GB' | 'fr-FR';
+    validationPolicy?: SheetValidationPolicy;
+}
+export interface ArtifactManifest {
+    kind: 'manifest';
+    revision: number;
+    format: 'docx' | 'sds' | 'xlsx' | 'sxs' | 'pptx' | 'pdf' | 'markdown' | 'text' | 'svg' | 'image';
+    main: string;
+    files: {
+        relative_path: string;
+        role: 'main' | 'raw' | 'asset';
+        bytes: number;
+        sha256: string;
+    }[];
+    report: Json;
+}
+export interface SaveReceipt {
+    id: string;
+    name: string;
+    manifest: ArtifactManifest;
+}
+export interface PreparedSave extends SaveReceipt {
+    files: ArrayBuffer[];
+}
+export type ExportFormat = 'docx' | 'sds' | 'xlsx' | 'sxs' | 'pptx' | 'pdf' | 'markdown' | 'markdown_bundle' | 'text' | 'html' | 'original' | 'png';
+export interface CopyExport {
+    bytes: ArrayBuffer;
+    report: Json;
+}
+export type HistoryAction = 'undo' | 'redo';
+export type ReplayEntry = {
+    environment: CalculationEnvironment;
+    revision: number;
+    validationConfirmed?: boolean;
+} & ({
+    kind: 'command';
+    command: Command;
+    sourceSelection?: SourceSelectionHistory;
+} | {
+    kind: 'history';
+    action: HistoryAction;
+} | {
+    kind: 'save';
+    receipt: SaveReceipt;
+} | {
+    kind: 'script';
+    replay: ScriptReplay;
+} | {
+    kind: 'pdf_import';
+    request: PdfImportRequest;
+} | {
+    kind: 'sheet_clipboard';
+    request: Exclude<SheetClipboardRequest, {
+        action: 'inspect';
+    }>;
+} | {
+    kind: 'presentation_clipboard';
+    request: Exclude<PresentationClipboardRequest, {
+        action: 'inspect';
+    }>;
+});
+/** Explicitly bump this when confirmed operations cannot be replayed compatibly. */
+export declare const ENGINE_REPLAY_VERSION: number;
+export declare const ENGINE_PROTOCOL_VERSION: number;
+export type Operation = {
+    kind: 'open';
+    name: string;
+    bytes: ArrayBuffer;
+    password?: string;
+} | {
+    kind: 'command';
+    command: Command;
+} | {
+    kind: 'view';
+    request: ViewRequest;
+} | {
+    kind: 'input';
+    input: TextInput | SourceInput;
+} | {
+    kind: 'script';
+    request: ScriptRequest;
+} | {
+    kind: 'mcp';
+    request: McpRequest;
+} | {
+    kind: 'history';
+    action: HistoryAction;
+} | {
+    kind: 'sheet_clipboard';
+    request: SheetClipboardRequest;
+} | {
+    kind: 'presentation_clipboard';
+    request: PresentationClipboardRequest;
+} | {
+    kind: 'pdf_import';
+    request: PdfImportRequest;
+} | {
+    kind: 'export';
+} | {
+    kind: 'export_copy';
+    format: ExportFormat;
+} | {
+    kind: 'prepare_save';
+    id: string;
+    name: string;
+} | {
+    kind: 'commit_save';
+    receipt: SaveReceipt;
+} | {
+    kind: 'read_save';
+    receipt: SaveReceipt;
+} | {
+    kind: 'discard_save';
+    id: string;
+};
+export interface Correlation {
+    id: number;
+    generation: number;
+    revision: number;
+}
+export type WorkerInput = (Correlation & {
+    kind: 'run';
+    operation: Operation;
+    cancellation?: SharedArrayBuffer;
+    environment: CalculationEnvironment;
+}) | (Correlation & {
+    kind: 'accept' | 'discard';
+    confirmValidation?: boolean;
+}) | {
+    kind: 'restore';
+    generation: number;
+    source?: {
+        name: string;
+        bytes: ArrayBuffer;
+    };
+    entries: ReplayEntry[];
+    revision: number;
+    save?: {
+        receipt: SaveReceipt;
+        environment: CalculationEnvironment;
+    };
+};
+export type WorkerOutput = {
+    kind: 'ready';
+    engine: string;
+    protocolVersion: number;
+    replayVersion: number;
+} | {
+    kind: 'restored';
+    generation: number;
+    revision: number;
+} | {
+    kind: 'fatal';
+    code: string;
+    message: string;
+} | (Correlation & {
+    kind: 'running';
+}) | (Correlation & {
+    kind: 'prepared';
+    response?: CommandResponse;
+    bytes?: ArrayBuffer;
+    copyExport?: CopyExport;
+    save?: PreparedSave;
+    view?: ViewResult;
+    input?: {
+        command: Command | null;
+        selection: TextSelection | SourceInputResult;
+        sourceSelection?: SourceSelectionHistory;
+        warnings?: string[];
+    };
+    script?: ScriptResult;
+    mcp?: McpResult;
+    clipboard?: SheetClipboardResult;
+    presentationClipboard?: PresentationClipboardResult;
+    pdfImport?: PdfImportResult;
+    calculationEnvironment?: CalculationEnvironment;
+    validation?: SheetValidationReport;
+    error?: {
+        code: string;
+        message: string;
+    };
+    calculated: boolean;
+}) | (Correlation & {
+    kind: 'committed' | 'discarded';
+    calculated: boolean;
+    recoveryAllowed?: boolean;
+    response?: CommandResponse;
+});
+export declare const ENGINE_LIMITS: {
+    readonly sourceBytes: number;
+    readonly commandBytes: number;
+    readonly queuedTasks: 32;
+    readonly queuedBytes: number;
+    readonly replayEntries: 1024;
+    readonly replayBytes: number;
+    readonly artifactBytes: number;
+    readonly cancelGraceMs: 400;
+};
+export declare function isWrite(command: Command): boolean;

package/dist/types/app/lib/engine/script.d.ts

@@ -0,0 +1,46 @@
+import type { Command, CommandResponse, Json } from './protocol';
+export interface ScriptPermissions {
+    read: boolean;
+    write: boolean;
+}
+export interface ScriptRequest {
+    source: string;
+    permissions: ScriptPermissions;
+    limits?: {
+        maxSourceBytes?: number;
+        maxDurationMs?: number;
+        maxMemoryBytes?: number;
+        maxStackBytes?: number;
+        maxCalls?: number;
+    };
+}
+export interface ScriptOutcome {
+    result: Json | null;
+    failure: {
+        kind: 'exception' | 'stopped' | 'timed_out' | 'limit_exceeded' | 'engine';
+        message: string;
+        line: number | null;
+        column: number | null;
+        stack: string | null;
+    } | null;
+    saved: string[];
+    calls: number;
+    elapsed: {
+        secs: number;
+        nanos: number;
+    };
+}
+export interface ScriptReplay {
+    commands: Command[];
+    /** Original active sheet/range for deterministic replay of unqualified A1 commands. */
+    selection?: Json;
+}
+export interface ScriptResult {
+    response: CommandResponse;
+    outcome: ScriptOutcome;
+    logs: {
+        level: 'log' | 'info' | 'warn' | 'error';
+        text: string;
+    }[];
+    replay: ScriptReplay | null;
+}

package/dist/types/app/lib/engine/sheet-clipboard.d.ts

@@ -0,0 +1,42 @@
+/** Clipboard contents live in the Rust session; requests only identify an immutable capture. */
+export type SheetClipboardRequest = {
+    action: 'inspect';
+} | {
+    action: 'capture';
+    id: string;
+    source: {
+        sheet_id: number;
+        range: string;
+    };
+    cut: boolean;
+} | {
+    action: 'paste';
+    id: string;
+    destination: {
+        sheet_id: number;
+        range: string;
+    };
+    mode?: 'all' | 'values' | 'formulas' | 'formats' | 'column_widths';
+    transpose?: boolean;
+    skip_blanks?: boolean;
+} | {
+    action: 'paste_external';
+    id: string;
+    destination: {
+        sheet_id: number;
+        range: string;
+    };
+    text: string;
+    html?: string;
+    mode?: 'all' | 'values' | 'formulas' | 'formats' | 'column_widths';
+    transpose?: boolean;
+    skip_blanks?: boolean;
+};
+export interface SheetClipboardResult {
+    id: string;
+    rows: number;
+    columns: number;
+    text?: string;
+    html?: string;
+    cut?: boolean;
+}

package/dist/types/app/lib/engine/sheet-validation.d.ts

@@ -0,0 +1,19 @@
+export type SheetValidationPolicy = 'rules' | 'reject' | 'prompt' | 'allow';
+export interface SheetValidationViolation {
+    sheet_id: number;
+    cell: string;
+    rule_id: number;
+    title: string;
+    message: string;
+    alert: 'stop' | 'warning' | 'information';
+    show_error: boolean;
+    unsupported: boolean;
+}
+export interface SheetValidationReport {
+    total: number;
+    enforced_total: number;
+    can_override: boolean;
+    unsupported: boolean;
+    violations: SheetValidationViolation[];
+}
+export type SheetValidationHandler = (report: SheetValidationReport, signal: AbortSignal) => Promise<boolean>;

package/dist/types/app/lib/engine/view.d.ts

@@ -0,0 +1,186 @@
+/** Read-only view data, always bound to the document revision in EngineResult. */
+import type { GridViewRequest, GridViewResult } from './grid';
+import type { DocxCommand, DocxContext } from './docx';
+import type { Json } from './protocol';
+import type { SourceViewRequest, SourceViewResult } from './markdown';
+import type { ImageViewRequest, ImageInfo } from './image';
+import type { PresentationViewRequest, PresentationViewResult } from './presentation';
+import type { PdfViewRequest, PdfViewResult } from './pdf';
+import type { PdfOcrViewRequest, PdfOcrViewResult } from './pdf-ocr';
+import type { PdfOutputViewRequest, PdfOutputViewResult } from './pdf-output';
+import type { PrintViewRequest, PrintViewResult } from './printing';
+import type { PresentationMediaViewRequest, PresentationMediaViewResult } from './presentation-media';
+export interface TextPosition {
+    block: string;
+    byte_offset: number;
+}
+export interface TextSelection {
+    anchor: TextPosition;
+    focus: TextPosition;
+    following_paragraphs?: number;
+}
+export interface PageInfo {
+    index: number;
+    width: number;
+    height: number;
+    missing_glyphs?: boolean;
+    section?: number;
+}
+export type TextReviewMode = 'markup' | 'final' | 'original';
+export interface TextReviewState {
+    revision: number;
+    view_epoch: number;
+    review_mode: TextReviewMode;
+    read_only: boolean;
+}
+export interface TextPageGuides {
+    page: number;
+    ruler: {
+        left: number;
+        right: number;
+    };
+    marks: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        label: string;
+        after: boolean;
+    }[];
+}
+export interface DocumentLayout {
+    revision: number;
+    font_epoch: number;
+    reset_from: number | null;
+    pages: PageInfo[];
+    known_pages: number;
+    complete: boolean;
+    first_caret: TextPosition | null;
+    substituted_fonts: string[];
+    font_warnings?: string[];
+    story?: TextStory;
+    view_epoch?: number;
+    review_mode?: TextReviewMode;
+    read_only?: boolean;
+}
+export interface TextStory {
+    slot: string;
+    section: number;
+    page: number;
+}
+export interface PageSemantics {
+    page: number;
+    blocks: {
+        id: string;
+        role: 'paragraph' | 'heading' | 'list_item' | 'image' | 'formula';
+        text: string;
+        level?: number;
+        alt?: string;
+        selection: TextSelection;
+    }[];
+    truncated: boolean;
+}
+export interface ViewRect {
+    page: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface SelectionGeometry {
+    selection: TextSelection;
+    text?: string | null;
+    context?: DocxContext;
+    format_brush?: Json;
+    html?: string;
+    story?: TextStory;
+    semantics?: PageSemantics;
+    guides?: TextPageGuides;
+    format?: {
+        bold: boolean;
+        italic: boolean;
+        underline: boolean;
+        font_size_half_points?: number | null;
+        font?: string;
+    };
+    rects: ViewRect[];
+    caret?: ViewRect | null;
+    caret_page?: number;
+}
+export interface TileRequest {
+    page: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    scale: number;
+}
+export interface RenderedTile {
+    width: number;
+    height: number;
+    pixels: ArrayBuffer;
+}
+export interface TextInput {
+    action: 'insert_text' | 'paste_text' | 'delete_backward' | 'delete_forward' | 'delete_word_backward' | 'delete_word_forward' | 'insert_paragraph' | 'insert_soft_break' | 'insert_page_break' | 'tab' | 'move' | 'select_all' | 'toggle_bold' | 'toggle_italic' | 'toggle_underline' | 'set_font_size' | 'command' | 'object_commands' | 'paste_html' | 'find' | 'story' | 'page_numbers' | 'update_toc';
+    selection: TextSelection;
+    text?: string;
+    direction?: 'left' | 'right' | 'up' | 'down' | 'word_left' | 'word_right' | 'home' | 'end' | 'story_start' | 'story_end' | 'paragraph_up' | 'paragraph_down' | 'page_up' | 'page_down';
+    extend?: boolean;
+    reverse?: boolean;
+    literal?: boolean;
+    half_points?: number;
+    command?: DocxCommand;
+    commands?: DocxCommand[];
+    merge_format?: boolean;
+    match_case?: boolean;
+    index?: number;
+    story?: 'body' | 'header' | 'footer' | 'first_header' | 'first_footer' | 'even_header' | 'even_footer';
+    page?: number;
+    section?: number;
+    mode?: 'insert' | 'remove';
+    header?: boolean;
+    alignment?: 'left' | 'center' | 'right' | 'inside' | 'outside';
+    target?: string;
+    anchor?: string;
+    levels?: number;
+}
+export type ViewRequest = GridViewRequest | SourceViewRequest | ImageViewRequest | PresentationViewRequest | PresentationMediaViewRequest | PdfViewRequest | PdfOcrViewRequest | PdfOutputViewRequest | PrintViewRequest | {
+    kind: 'text_review';
+    mode?: TextReviewMode;
+} | {
+    kind: 'text_objects';
+    request: Record<string, Json>;
+} | {
+    kind: 'text_statistics';
+    includeStories?: boolean;
+    selection?: TextSelection;
+    reviewMode?: TextReviewMode;
+} | {
+    kind: 'layout';
+    pageBudget: number;
+    reviewMode?: TextReviewMode;
+} | {
+    kind: 'tile';
+    tile: TileRequest;
+    reviewMode?: TextReviewMode;
+} | {
+    kind: 'hit';
+    page: number;
+    x: number;
+    y: number;
+    reviewMode?: TextReviewMode;
+} | {
+    kind: 'selection';
+    page: number;
+    selection: TextSelection;
+    includeHtml?: boolean;
+    includeSemantics?: boolean;
+    includeGuides?: boolean;
+    reviewMode?: TextReviewMode;
+};
+export interface HitResult {
+    revision: number;
+    caret: TextPosition | null;
+    selection?: TextSelection;
+}
+export type ViewResult = Json | TextReviewState | PdfViewResult | PdfOcrViewResult | PdfOutputViewResult | PrintViewResult | DocumentLayout | RenderedTile | HitResult | SelectionGeometry | GridViewResult | SourceViewResult | ImageInfo | PresentationViewResult | PresentationMediaViewResult;

package/dist/types/app/lib/files/session.d.ts

@@ -0,0 +1,114 @@
+import { BrowserEngine, type EngineEvent, type EngineResult, type TaskOptions } from '../engine/client';
+import { type Command, type CommandResponse, type HistoryAction, type Json, type ExportFormat } from '../engine/protocol';
+import type { BrowserFileHandle } from './storage';
+import type { TextInput, TextSelection, ViewRequest, ViewResult } from '../engine/view';
+import type { ScriptRequest, ScriptResult } from '../engine/script';
+import type { McpRequest, McpResult } from '../automation/protocol';
+import type { SourceInput, SourceSelection } from '../engine/markdown';
+import type { SheetClipboardRequest, SheetClipboardResult } from '../engine/sheet-clipboard';
+import type { PresentationClipboardRequest, PresentationClipboardResult } from '../engine/presentation-clipboard';
+import type { SheetValidationHandler, SheetValidationPolicy } from '../engine/sheet-validation';
+type SavePhase = 'idle' | 'permission' | 'preparing' | 'writing' | 'confirming' | 'cancelling' | 'pending';
+export interface FileSessionState {
+    id: string;
+    name: string;
+    dirty: boolean;
+    inputPending: boolean;
+    revision: number;
+    canUndo?: boolean;
+    canRedo?: boolean;
+    sourceFormat?: string;
+    canSaveSource?: boolean;
+    importReport?: Json;
+    recoveryAllowed?: boolean;
+    savePhase: SavePhase;
+    saveError?: string;
+}
+/** Optional host restrictions are applied before work enters the document Worker. */
+export interface FileSessionAccess {
+    readOnly: boolean;
+    checkFile(name: string): void;
+    checkCommand(command: Command): void;
+    checkView(request: ViewRequest): void;
+}
+export interface BrowserFileSessionOptions {
+    assetBase?: string;
+    access?: FileSessionAccess;
+}
+/** Browser permissions/publication stay outside the Rust document and its history. */
+export declare class BrowserFileSession {
+    private validationHandler?;
+    requestPassword?: (name: string, retry: boolean) => Promise<string | undefined>;
+    confirmDiscard?: (name: string) => Promise<boolean>;
+    private engine;
+    readonly assetBase: string;
+    private readonly access?;
+    private detachEngine?;
+    private listeners;
+    private lifecycle;
+    private handle?;
+    private baseline?;
+    private publication?;
+    private fileAction;
+    private deferFilePublication;
+    private deferredFileEvent?;
+    private selection;
+    private detachSelection?;
+    private closed;
+    private value;
+    beforeFileChange?: () => Promise<void>;
+    whenIdle(): Promise<void>;
+    constructor(options?: BrowserFileSessionOptions);
+    get state(): Readonly<FileSessionState>;
+    get changingFile(): boolean;
+    /** UI input has not reached the engine yet and must still prevent accidental navigation. */
+    setInputPending(pending: boolean, documentId: string): void;
+    cancelOpen(): void;
+    subscribe(listener: (state: FileSessionState, event?: EngineEvent) => void): () => void;
+    private emit;
+    private attach;
+    private check;
+    private checkChanging;
+    private checkWritable;
+    private beginSelection;
+    private checkSelection;
+    private status;
+    command(command: Command, options?: TaskOptions): Promise<EngineResult<CommandResponse>>;
+    history(action: HistoryAction, options?: TaskOptions): Promise<EngineResult<CommandResponse>>;
+    sheetClipboard(request: SheetClipboardRequest, options?: TaskOptions): Promise<EngineResult<SheetClipboardResult>>;
+    get inputLocale(): NonNullable<"zh-CN" | "en-US" | "de-DE" | "en-GB" | "fr-FR" | undefined>;
+    importPdfPages(request: import('../engine/pdf-import').PdfImportRequest, options?: TaskOptions): Promise<EngineResult<import('../engine/pdf-import').PdfImportResult>>;
+    presentationClipboard(request: PresentationClipboardRequest, options?: TaskOptions): Promise<EngineResult<PresentationClipboardResult>>;
+    setInputLocale(locale: Parameters<BrowserEngine['setInputLocale']>[0]): void;
+    get validationPolicy(): SheetValidationPolicy;
+    setValidationPolicy(policy: SheetValidationPolicy): void;
+    setValidationHandler(handler?: SheetValidationHandler): void;
+    view<T extends ViewResult>(request: ViewRequest, options?: TaskOptions): Promise<EngineResult<T>>;
+    input<T extends TextSelection | SourceSelection = TextSelection>(input: TextInput | SourceInput, options?: TaskOptions): Promise<EngineResult<T>>;
+    openFile(file: File, handle?: BrowserFileHandle): Promise<void>;
+    runScript(request: ScriptRequest, options?: TaskOptions): Promise<EngineResult<ScriptResult>>;
+    runMcp(request: McpRequest, options?: TaskOptions): Promise<EngineResult<McpResult>>;
+    authenticatePdf(password: string): Promise<void>;
+    private openSelectedFile;
+    pickFile(beforeOpen?: () => Promise<void>): Promise<void>;
+    openDrop(data: DataTransfer, signal?: AbortSignal): Promise<void>;
+    openDirectory(files: File[], signal?: AbortSignal): Promise<void>;
+    pickDirectory(signal?: AbortSignal): Promise<void>;
+    /** Acquire browser permission in the user's click before flushing queued UI input. */
+    pickSaveTarget(): Promise<BrowserFileHandle>;
+    save(target?: BrowserFileHandle, signal?: AbortSignal): Promise<{
+        published: boolean;
+        confirmed: boolean;
+    }>;
+    private confirm;
+    resumeSave(): Promise<void>;
+    recover(): Promise<void>;
+    cancelPendingSave(): Promise<void>;
+    downloadCopy(): Promise<void>;
+    downloadExportCopy(format: ExportFormat): Promise<Json>;
+    bindLifecycle(target?: Window): () => void;
+    close(options?: {
+        discard?: boolean;
+    }): Promise<void>;
+}
+export {};

package/dist/types/app/lib/files/storage.d.ts

@@ -0,0 +1,20 @@
+/** Browser-granted file handles and in-memory save publication metadata. */
+export interface BrowserFileHandle extends FileSystemFileHandle {
+    queryPermission?(descriptor: {
+        mode: 'read' | 'readwrite';
+    }): Promise<PermissionState>;
+    requestPermission?(descriptor: {
+        mode: 'read' | 'readwrite';
+    }): Promise<PermissionState>;
+}
+export interface FileFingerprint {
+    bytes: number;
+    modified: number;
+    sha256: string;
+}
+export interface FilePublication {
+    stage: 'prepared' | 'published';
+    handle: BrowserFileHandle;
+    before: FileFingerprint;
+    after?: FileFingerprint;
+}

package/dist/types/packages/slide/api.d.ts

@@ -0,0 +1,4 @@
+import type { OfficeOptions, ReadonlyOfficeApi } from '../../sdk/types';
+export type * from '../../sdk/types';
+export { EngineError } from '../../app/lib/engine/client';
+export declare function createApi(options?: OfficeOptions): ReadonlyOfficeApi;

package/dist/types/packages/slide/index.d.ts

@@ -0,0 +1,5 @@
+import type { MountOptions, MountedOffice } from '../../sdk/types';
+export * from './api';
+export type { MountOptions, MountedOffice } from '../../sdk/types';
+/** Mount into an empty element with an explicit height. */
+export declare function mount(container: Element | string, options?: MountOptions): Promise<MountedOffice<'slide'>>;