@opengeni/artifact-tool 0.2.2

package/dist/presentation.d.ts

@@ -0,0 +1,565 @@
+import { FileBlob } from "./file-blob.js";
+import type { HelpOptions } from "./spreadsheet-types.js";
+export { PPTX_MEDIA_TYPE, PresentationFidelityError, PresentationSecurityError, type PresentationFidelityIssue, type PresentationLossPreservationEnvelope, type PresentationPptxExportOptions, type PresentationPptxFeature, type PresentationPptxImportLimits, type PresentationPptxImportOptions, } from "./presentation-pptx-api.js";
+import type { PresentationFidelityIssue, PresentationLossPreservationEnvelope, PresentationPptxExportOptions, PresentationPptxImportOptions } from "./presentation-pptx-api.js";
+export type PresentationPosition = {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+};
+export type PresentationFill = string | {
+    type?: "solid";
+    color: string;
+};
+export type PresentationLine = {
+    style?: "solid" | "dash" | "dot" | "none";
+    fill?: PresentationFill;
+    width?: number;
+};
+export type PresentationTextStyle = {
+    fontFamily?: string;
+    fontSize?: number;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    color?: string;
+    alignment?: "left" | "center" | "right" | "justify";
+    verticalAlignment?: "top" | "middle" | "bottom";
+};
+export type PresentationShapeGeometry = "textbox" | "rect" | "roundRect" | "ellipse" | "triangle" | "rightArrow" | "line";
+export type PresentationShapeConfig = {
+    geometry: PresentationShapeGeometry;
+    name?: string;
+    position?: Partial<PresentationPosition>;
+    fill?: PresentationFill;
+    line?: PresentationLine;
+    text?: string;
+    textStyle?: PresentationTextStyle;
+    rotation?: number;
+    borderRadius?: number | string;
+    placeholder?: {
+        type: string;
+        index?: number;
+    };
+};
+export type PresentationChartType = "bar" | "line" | "area" | "pie" | "doughnut" | "scatter" | "bubble" | "radar";
+export type PresentationChartSeriesConfig = {
+    name: string;
+    categories?: string[];
+    values?: number[];
+    xValues?: number[];
+    bubbleSizes?: number[];
+    fill?: PresentationFill;
+    line?: PresentationLine;
+};
+export type PresentationChartConfig = {
+    name?: string;
+    position?: Partial<PresentationPosition>;
+    title?: string;
+    categories?: string[];
+    series?: PresentationChartSeriesConfig[];
+    hasLegend?: boolean;
+    legend?: {
+        position?: "left" | "top" | "topRight" | "right" | "bottom";
+        overlay?: boolean;
+    };
+    xAxis?: {
+        visible?: boolean;
+        title?: string;
+        min?: number;
+        max?: number;
+    };
+    yAxis?: {
+        visible?: boolean;
+        title?: string;
+        min?: number;
+        max?: number;
+    };
+    dataLabels?: {
+        showValue?: boolean;
+        showSeriesName?: boolean;
+        showCategoryName?: boolean;
+        showPercent?: boolean;
+        position?: "center" | "inEnd" | "outEnd";
+    };
+};
+export type PresentationTableCellConfig = {
+    text: string;
+    fill?: PresentationFill;
+    textStyle?: PresentationTextStyle;
+    rowSpan?: number;
+    colSpan?: number;
+};
+export type PresentationTableCellInput = string | PresentationTableCellConfig | null;
+export type PresentationTableConfig = {
+    name?: string;
+    position?: Partial<PresentationPosition>;
+    /** null marks a grid position covered by an earlier rowSpan/colSpan anchor. */
+    rows: ReadonlyArray<ReadonlyArray<PresentationTableCellInput>>;
+    columnWidths?: readonly number[];
+    rowHeights?: readonly number[];
+    fill?: PresentationFill;
+    line?: PresentationLine;
+    textStyle?: PresentationTextStyle;
+};
+export type PresentationGroupChildConfig = {
+    kind: "shape";
+    config: PresentationShapeConfig;
+} | {
+    kind: "chart";
+    type: PresentationChartType;
+    config?: PresentationChartConfig;
+} | {
+    kind: "image";
+    config: PresentationImageConfig;
+} | {
+    kind: "table";
+    config: PresentationTableConfig;
+} | {
+    kind: "group";
+    config: PresentationGroupConfig;
+};
+export type PresentationGroupConfig = {
+    name?: string;
+    position?: Partial<PresentationPosition>;
+    childOffset?: {
+        left: number;
+        top: number;
+    };
+    childExtent?: {
+        width: number;
+        height: number;
+    };
+    rotation?: number;
+    flipHorizontal?: boolean;
+    flipVertical?: boolean;
+    children?: readonly PresentationGroupChildConfig[];
+};
+export type PresentationTemplateElement = Exclude<PresentationGroupChildConfig, {
+    kind: "group";
+}>;
+export type PresentationMasterConfig = {
+    name?: string;
+    background?: PresentationFill;
+    elements?: readonly PresentationTemplateElement[];
+};
+export type PresentationLayoutConfig = PresentationMasterConfig & {
+    masterId?: string;
+    /** Skill-compatible alias for masterId. */
+    parentLayoutId?: string;
+};
+type ConcreteImageSource = {
+    blob: ArrayBuffer | Uint8Array;
+    dataUrl?: never;
+    uri?: never;
+} | {
+    dataUrl: string;
+    blob?: never;
+    uri?: never;
+} | {
+    uri: string;
+    blob?: never;
+    dataUrl?: never;
+};
+export type PresentationRasterImageContentType = "image/png" | "image/jpeg" | "image/gif" | "image/webp";
+export type PresentationImageResolution = {
+    blob: ArrayBuffer | Uint8Array;
+    contentType?: PresentationRasterImageContentType;
+};
+export type PresentationImageResolver = (reference: {
+    uri: string;
+    imageId: string;
+    name: string;
+}) => Promise<PresentationImageResolution> | PresentationImageResolution;
+export type PresentationCreateOptions = {
+    slideSize?: {
+        width: number;
+        height: number;
+    };
+    /** Host-owned resolver; it is invoked only by an explicit image.resolveUri() call. */
+    imageResolver?: PresentationImageResolver;
+    /** URI schemes the host resolver owns, for example `["asset"]`. Empty by default. */
+    allowedImageUriSchemes?: readonly string[];
+};
+export type PresentationImageConfig = (ConcreteImageSource & PresentationImageMetadata) | ({
+    prompt: string;
+    blob?: never;
+    dataUrl?: never;
+    uri?: never;
+} & PresentationImageMetadata);
+type PresentationImageMetadata = {
+    name?: string;
+    prompt?: string;
+    contentType?: string;
+    alt?: string;
+    fit?: "contain" | "cover";
+    position?: Partial<PresentationPosition>;
+    frame?: Partial<PresentationPosition>;
+    crop?: {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    };
+    geometry?: "rect" | "roundRect" | "ellipse";
+    borderRadius?: number | string;
+    rotation?: number;
+    flipHorizontal?: boolean;
+    flipVertical?: boolean;
+    lockAspectRatio?: boolean;
+};
+export type PresentationInspectOptions = {
+    target?: {
+        id: string;
+        beforeLines?: number;
+        afterLines?: number;
+    };
+    kind?: string;
+    include?: string;
+    exclude?: string;
+    search?: string;
+    maxChars?: number;
+};
+export type PresentationInspectResult = {
+    ndjson: string;
+    records: Array<Record<string, unknown>>;
+    truncated: boolean;
+};
+export type PresentationResolvedObject = Presentation | Slide | PresentationShape | PresentationChart | PresentationImage | PresentationTable | PresentationGroup | PresentationMaster | PresentationLayout;
+export type PresentationElement = PresentationShape | PresentationChart | PresentationImage | PresentationTable | PresentationGroup;
+export type PresentationExportOptions = {
+    slide?: Slide;
+    format: "svg" | "png" | "layout" | "webp";
+    scale?: number;
+    montage?: boolean;
+    columns?: number;
+    gap?: number;
+};
+export declare class UnsupportedPresentationFeatureError extends Error {
+    readonly code = "UNSUPPORTED_PRESENTATION_FEATURE";
+    constructor(feature: string, detail?: string);
+}
+/** Untrusted presentation input was rejected before reaching a renderer or file codec. */
+export declare class InvalidPresentationInputError extends Error {
+    readonly field: string;
+    readonly code = "INVALID_PRESENTATION_INPUT";
+    constructor(field: string, detail: string);
+}
+/**
+ * Skill-compatible TypeScript reference presentation. Native production
+ * presentation editing remains unsupported and must fail closed until the
+ * Rust modality is feature-complete.
+ */
+export declare class Presentation {
+    readonly slides: SlideCollection;
+    readonly masters: PresentationMasterCollection;
+    readonly layouts: PresentationLayoutCollection;
+    readonly slideSize: {
+        width: number;
+        height: number;
+    };
+    private readonly objects;
+    private readonly imageResolver;
+    private readonly allowedImageUriSchemes;
+    private nextId;
+    private constructor();
+    static create(options?: PresentationCreateOptions): Presentation;
+    assertImageUriAccepted(uri: string): void;
+    resolveImageUri(reference: {
+        uri: string;
+        imageId: string;
+        name: string;
+    }): Promise<PresentationImageResolution>;
+    allocateId(prefix: "sl" | "sh" | "ch" | "im" | "tb" | "gp" | "mt" | "ly", value: unknown): string;
+    resolve<T extends PresentationResolvedObject = PresentationResolvedObject>(id: string): T;
+    inspect(options?: PresentationInspectOptions): Promise<PresentationInspectResult>;
+    help(query: string, options?: HelpOptions): PresentationInspectResult;
+    export(options: PresentationExportOptions): Promise<FileBlob>;
+    layoutSnapshot(): Record<string, unknown>;
+    private register;
+    private assertOwns;
+}
+declare class PresentationPlaceholderCollection {
+    private readonly elements;
+    constructor(elements: readonly PresentationTemplateElement[]);
+    summary(): {
+        count: number;
+        names: string[];
+    };
+}
+export declare class PresentationMaster {
+    readonly presentation: Presentation;
+    readonly id: string;
+    name: string;
+    background: PresentationFill;
+    readonly elements: PresentationTemplateElement[];
+    readonly placeholders: PresentationPlaceholderCollection;
+    constructor(presentation: Presentation, config?: PresentationMasterConfig);
+    inspectRecord(): Record<string, unknown>;
+    toProto(): Record<string, unknown>;
+}
+export declare class PresentationLayout {
+    readonly presentation: Presentation;
+    readonly id: string;
+    name: string;
+    masterId: string | undefined;
+    background: PresentationFill;
+    readonly elements: PresentationTemplateElement[];
+    readonly placeholders: PresentationPlaceholderCollection;
+    get parentLayoutId(): string | undefined;
+    constructor(presentation: Presentation, config?: PresentationLayoutConfig);
+    inspectRecord(): Record<string, unknown>;
+    toProto(): Record<string, unknown>;
+}
+export declare class PresentationMasterCollection {
+    private readonly presentation;
+    readonly items: PresentationMaster[];
+    constructor(presentation: Presentation);
+    add(config?: PresentationMasterConfig): PresentationMaster;
+    getItem(index: number): PresentationMaster;
+}
+export declare class PresentationLayoutCollection {
+    private readonly presentation;
+    readonly items: PresentationLayout[];
+    constructor(presentation: Presentation);
+    add(config?: PresentationLayoutConfig): PresentationLayout;
+    getItem(index: number): PresentationLayout;
+}
+export declare class SlideCollection {
+    private readonly presentation;
+    readonly items: Slide[];
+    constructor(presentation: Presentation);
+    add(): Slide;
+    getItem(index: number): Slide;
+}
+export declare class Slide {
+    readonly presentation: Presentation;
+    readonly id: string;
+    readonly shapes: PresentationShapeCollection;
+    readonly charts: PresentationChartCollection;
+    readonly images: PresentationImageCollection;
+    readonly tables: PresentationTableCollection;
+    readonly groups: PresentationGroupCollection;
+    readonly notes: PresentationText;
+    readonly placeholders: SlidePlaceholderCollection;
+    /** Canonical cross-type z-order. Typed collections are filtered indexes over this list. */
+    readonly elements: PresentationElement[];
+    readonly background: {
+        fill: PresentationFill;
+    };
+    title: string;
+    layout: PresentationLayout | undefined;
+    constructor(presentation: Presentation);
+    get speakerNotes(): PresentationText;
+    setLayout(layout: PresentationLayout | undefined): void;
+    appendElement(element: PresentationElement): void;
+    export(options: Omit<PresentationExportOptions, "slide" | "montage">): Promise<FileBlob>;
+    inspectRecord(index: number): Record<string, unknown>;
+    layoutSnapshot(index: number): Record<string, unknown>;
+}
+export declare class SlidePlaceholderCollection {
+    private readonly slide;
+    constructor(slide: Slide);
+    get items(): PresentationShape[];
+    summary(): {
+        count: number;
+        types: Record<string, number>;
+    };
+}
+export declare class PresentationText {
+    private value;
+    private styleValue;
+    constructor(initialValue?: string, style?: PresentationTextStyle);
+    get style(): PresentationTextStyle;
+    set style(value: PresentationTextStyle);
+    set(value: string): void;
+    replace(searchValue: string | RegExp, replaceValue: string): number;
+    toString(): string;
+    toJSON(): string;
+}
+export declare class PresentationShape {
+    readonly slide: Slide;
+    readonly id: string;
+    readonly geometry: PresentationShapeGeometry;
+    name: string;
+    position: PresentationPosition;
+    fill: PresentationFill;
+    line: PresentationLine;
+    rotation: number;
+    borderRadius: number | string | undefined;
+    placeholder: {
+        type: string;
+        index?: number;
+    } | undefined;
+    private readonly textValue;
+    constructor(slide: Slide, config: PresentationShapeConfig);
+    get text(): PresentationText;
+    set text(value: string | PresentationText);
+    inspectRecord(slideIndex: number): Record<string, unknown>;
+    layoutSnapshot(): Record<string, unknown>;
+}
+export declare class PresentationShapeCollection {
+    private readonly slide;
+    readonly items: PresentationShape[];
+    constructor(slide: Slide);
+    add(config: PresentationShapeConfig): PresentationShape;
+}
+export declare class PresentationChartSeries {
+    name: string;
+    categories: string[];
+    values: number[];
+    xValues: number[];
+    bubbleSizes: number[];
+    fill: PresentationFill | undefined;
+    line: PresentationLine | undefined;
+    constructor(config: PresentationChartSeriesConfig);
+}
+export declare class PresentationChartSeriesCollection {
+    readonly items: PresentationChartSeries[];
+    constructor(series: PresentationChartSeriesConfig[]);
+    getItemAt(index: number): PresentationChartSeries;
+}
+export declare class PresentationChart {
+    readonly slide: Slide;
+    readonly id: string;
+    readonly type: PresentationChartType;
+    name: string;
+    position: PresentationPosition;
+    title: string;
+    categories: string[];
+    readonly series: PresentationChartSeriesCollection;
+    hasLegend: boolean;
+    legend: PresentationChartConfig["legend"];
+    xAxis: PresentationChartConfig["xAxis"];
+    yAxis: PresentationChartConfig["yAxis"];
+    dataLabels: PresentationChartConfig["dataLabels"];
+    constructor(slide: Slide, type: PresentationChartType, config: PresentationChartConfig);
+    inspectRecord(slideIndex: number): Record<string, unknown>;
+    layoutSnapshot(): Record<string, unknown>;
+}
+export declare class PresentationChartCollection {
+    private readonly slide;
+    readonly items: PresentationChart[];
+    constructor(slide: Slide);
+    add(type: PresentationChartType, config?: PresentationChartConfig): PresentationChart;
+}
+export declare class PresentationTableCell {
+    readonly text: PresentationText;
+    fill: PresentationFill;
+    rowSpan: number;
+    colSpan: number;
+    constructor(config: string | PresentationTableCellConfig, defaults: Pick<PresentationTableConfig, "fill" | "textStyle">);
+    toConfig(): PresentationTableCellConfig;
+}
+export declare class PresentationTable {
+    readonly slide: Slide;
+    readonly id: string;
+    name: string;
+    position: PresentationPosition;
+    rows: Array<Array<PresentationTableCell | null>>;
+    columnWidths: number[];
+    rowHeights: number[];
+    fill: PresentationFill;
+    line: PresentationLine;
+    textStyle: PresentationTextStyle;
+    constructor(slide: Slide, config: PresentationTableConfig);
+    inspectRecord(slideIndex: number): Record<string, unknown>;
+    layoutSnapshot(): Record<string, unknown>;
+}
+export declare class PresentationTableCollection {
+    private readonly slide;
+    readonly items: PresentationTable[];
+    constructor(slide: Slide);
+    add(config: PresentationTableConfig): PresentationTable;
+}
+export type PresentationGroupChild = PresentationShape | PresentationChart | PresentationImage | PresentationTable | PresentationGroup;
+export declare class PresentationGroup {
+    readonly slide: Slide;
+    readonly id: string;
+    name: string;
+    position: PresentationPosition;
+    childOffset: {
+        left: number;
+        top: number;
+    };
+    childExtent: {
+        width: number;
+        height: number;
+    };
+    rotation: number;
+    flipHorizontal: boolean;
+    flipVertical: boolean;
+    readonly children: PresentationGroupChild[];
+    constructor(slide: Slide, config?: PresentationGroupConfig, depth?: number);
+    inspectRecord(slideIndex: number): Record<string, unknown>;
+    layoutSnapshot(): Record<string, unknown>;
+}
+export declare class PresentationGroupCollection {
+    private readonly slide;
+    readonly items: PresentationGroup[];
+    constructor(slide: Slide);
+    add(config?: PresentationGroupConfig): PresentationGroup;
+}
+export declare class PresentationImage {
+    readonly slide: Slide;
+    readonly id: string;
+    name: string;
+    position: PresentationPosition;
+    fit: "contain" | "cover";
+    contentType: string | undefined;
+    alt: string;
+    prompt: string | undefined;
+    crop: {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    } | undefined;
+    geometry: "rect" | "roundRect" | "ellipse";
+    borderRadius: number | string | undefined;
+    rotation: number;
+    flipHorizontal: boolean;
+    flipVertical: boolean;
+    lockAspectRatio: boolean;
+    private blob;
+    private dataUrl;
+    private uri;
+    private validatedContentType;
+    private cachedCanonicalDataUrl;
+    constructor(slide: Slide, config: PresentationImageConfig);
+    get frame(): PresentationPosition;
+    set frame(value: PresentationPosition);
+    replace(config: PresentationImageConfig): void;
+    /**
+     * Explicitly materializes a host-owned URI into trusted raster bytes.
+     *
+     * Render and file export never invoke resolvers, fetch, or read files. A host
+     * must call this method deliberately, and returned bytes still pass the same
+     * MIME/signature validation as direct `blob` input.
+     */
+    resolveUri(): Promise<void>;
+    sourceForSvg(): string | undefined;
+    sourceForPptx(): {
+        data: string;
+    };
+    inspectRecord(slideIndex: number): Record<string, unknown>;
+    layoutSnapshot(): Record<string, unknown>;
+    private assignSource;
+}
+export declare class PresentationImageCollection {
+    private readonly slide;
+    readonly items: PresentationImage[];
+    constructor(slide: Slide);
+    add(config: PresentationImageConfig): PresentationImage;
+}
+export declare class PresentationFile {
+    static exportPptx(presentation: Presentation, options?: PresentationPptxExportOptions): Promise<FileBlob>;
+    static importPptx(input: FileBlob | Blob | ArrayBuffer | Uint8Array, options?: PresentationPptxImportOptions): Promise<Presentation>;
+    static fidelityReport(presentation: Presentation): readonly PresentationFidelityIssue[];
+    static lossPreservationEnvelope(presentation: Presentation): PresentationLossPreservationEnvelope | null;
+}
+declare function assertRenderPixelBudget(width: number, height: number, scale: number): void;
+declare function colorValue(fill: PresentationFill): string;
+declare function truncate(value: string, max: number): string;
+export { assertRenderPixelBudget as assertPresentationRenderPixelBudget, colorValue as presentationColorValue, truncate as truncatePresentationText, };

package/dist/presentation.js

@@ -0,0 +1,71 @@
+import {
+  InvalidPresentationInputError,
+  PPTX_MEDIA_TYPE,
+  Presentation,
+  PresentationChart,
+  PresentationChartCollection,
+  PresentationChartSeries,
+  PresentationChartSeriesCollection,
+  PresentationFidelityError,
+  PresentationFile,
+  PresentationGroup,
+  PresentationGroupCollection,
+  PresentationImage,
+  PresentationImageCollection,
+  PresentationLayout,
+  PresentationLayoutCollection,
+  PresentationMaster,
+  PresentationMasterCollection,
+  PresentationSecurityError,
+  PresentationShape,
+  PresentationShapeCollection,
+  PresentationTable,
+  PresentationTableCell,
+  PresentationTableCollection,
+  PresentationText,
+  Slide,
+  SlideCollection,
+  SlidePlaceholderCollection,
+  UnsupportedPresentationFeatureError,
+  assertRenderPixelBudget,
+  colorValue,
+  truncate
+} from "./chunk-PI2AZVGK.js";
+import "./chunk-FGZM4FQ6.js";
+import "./chunk-4BSENMAE.js";
+import "./chunk-Q2FFHEY7.js";
+import "./chunk-VUNV25KB.js";
+export {
+  InvalidPresentationInputError,
+  PPTX_MEDIA_TYPE,
+  Presentation,
+  PresentationChart,
+  PresentationChartCollection,
+  PresentationChartSeries,
+  PresentationChartSeriesCollection,
+  PresentationFidelityError,
+  PresentationFile,
+  PresentationGroup,
+  PresentationGroupCollection,
+  PresentationImage,
+  PresentationImageCollection,
+  PresentationLayout,
+  PresentationLayoutCollection,
+  PresentationMaster,
+  PresentationMasterCollection,
+  PresentationSecurityError,
+  PresentationShape,
+  PresentationShapeCollection,
+  PresentationTable,
+  PresentationTableCell,
+  PresentationTableCollection,
+  PresentationText,
+  Slide,
+  SlideCollection,
+  SlidePlaceholderCollection,
+  UnsupportedPresentationFeatureError,
+  assertRenderPixelBudget as assertPresentationRenderPixelBudget,
+  colorValue as presentationColorValue,
+  truncate as truncatePresentationText
+};
+//# sourceMappingURL=presentation.js.map

package/dist/presentation.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/production-composite.d.ts

@@ -0,0 +1,68 @@
+import type { WorkbookChange } from "./spreadsheet.js";
+import type { NativeArtifactSession, NativeDocumentSession, NativePresentationSession, NativeSpreadsheetSession } from "./native.js";
+export type CompositeModality = "spreadsheet" | "document" | "presentation";
+export type CompositeReconciliation = Readonly<{
+    session: NativeArtifactSession;
+    data?: unknown;
+}>;
+export type CompositeReconciler<Root extends object> = (root: Root) => CompositeReconciliation;
+export type CompositePropertyRead = Readonly<{
+    handled: boolean;
+    value?: unknown;
+}>;
+type Locator<Root extends object> = Readonly<{
+    key: string;
+    resolve(root: Root): unknown;
+}>;
+export type CompositeMutation = Readonly<{
+    member: PropertyKey;
+    owner: unknown;
+    arguments?: readonly unknown[];
+}>;
+export type PreparedCompositeMutation = Readonly<{
+    /** Applies one already-prevalidated mutation to the retained native session. */
+    commit(result: unknown): boolean;
+}>;
+export type CompositeMutationPreparer<Root extends object> = (mutation: CompositeMutation, state: CompositeArtifactState<Root>) => PreparedCompositeMutation | null;
+/**
+ * Owns one host projection and one exact native session. Public objects are
+ * location proxies, not aliases to a particular projection instance. Rare
+ * reconciliation mutations can therefore replace the host graph atomically;
+ * hot mutations retain both the host graph and native session.
+ */
+export declare class CompositeArtifactState<Root extends object> {
+    #private;
+    readonly modality: CompositeModality;
+    readonly namespace: bigint;
+    constructor(input: Readonly<{
+        modality: CompositeModality;
+        namespace: bigint;
+        root: Root;
+        reconciliation: CompositeReconciliation;
+        reconcile: CompositeReconciler<Root>;
+        prepareMutation?: CompositeMutationPreparer<Root>;
+        installProjection?: (root: Root, state: CompositeArtifactState<Root>) => void;
+        readProperty?: (owner: unknown, member: PropertyKey, state: CompositeArtifactState<Root>) => CompositePropertyRead;
+        captureAuxiliary?: (root: Root) => unknown;
+        restoreAuxiliary?: (root: Root, value: unknown) => void;
+    }>);
+    get root(): Root;
+    get native(): NativeArtifactSession;
+    get nativeData(): unknown;
+    /** Monotonic facade revision across retained and rare replacement sessions. */
+    get revision(): number;
+    /** True only inside one explicit/public mutation transaction. */
+    get inMutation(): boolean;
+    proxy(): Root;
+    rawRoot(): Root;
+    assertUsable(): void;
+    onWorkbookChange(listener: (change: WorkbookChange) => void): () => void;
+    dispose(): void;
+    mutate<Result>(operation: () => Result, hint: CompositeMutation): Result;
+    wrap(locator: Locator<Root>): unknown;
+}
+export declare function stateOf(value: unknown): CompositeArtifactState<object> | null;
+export declare function requireCompositeState(value: unknown, modality?: CompositeModality): CompositeArtifactState<object>;
+export declare function unwrapArtifactValue(value: unknown): unknown;
+export declare function nativeSessionOf(state: CompositeArtifactState<object>): NativeSpreadsheetSession | NativeDocumentSession | NativePresentationSession;
+export {};