@sheetxl/sdk 0.8.0-beta.10 → 0.8.0-beta.11

package/types/src/theme/ITheme.d.ts

@@ -1,6 +1,7 @@
 import { IColor } from '../color';
 import { IFont } from '../font';
 import { IFill, IStroke, IEffect } from '../fill';
+import { IShape } from '../shape';
 import { buildPalette as _buildPalette } from './_ThemeUtils';
 /**
  * Defines and manages themes associated to a specific document or spreadsheet.
@@ -34,6 +35,14 @@ export interface ITheme {
      * Office's.
      */
     getFormatScheme(): ITheme.FormatScheme;
+    /**
+     * What a new shape, line or text box starts from in this theme.
+     *
+     * @remarks
+     * Read once, when the object is inserted (`ShapeStyleUtils.withThemeDefaults`); the object
+     * keeps what it took. A theme that states none has the base theme's.
+     */
+    getObjectDefaults(): Readonly<ITheme.ObjectDefaultsJSON>;
     /**
      * This is available for functions that want to resolve themed colors
      *
@@ -207,15 +216,60 @@ export declare namespace ITheme {
          * @returns An array of fallback fonts for the minor font.
          */
         getMinorFallbacks(): readonly string[];
+        /**
+         * The heading fonts, as the scheme states them or as the theme it builds on does.
+         */
+        getMajor(): Readonly<ITheme.FontCollectionJSON>;
+        /**
+         * The body fonts, as the scheme states them or as the theme it builds on does.
+         */
+        getMinor(): Readonly<ITheme.FontCollectionJSON>;
     }
-    interface FontSchemeProperties {
-        majorFont: string;
-        majorFallbacks: string[];
-        minorFont: string;
-        minorFallbacks: string[];
-        name: string;
+    /**
+     * The fonts of one role in a font scheme, heading (major) or body (minor), by the kind of text
+     * they are for.
+     */
+    interface FontCollectionJSON {
+        /**
+         * The font for Latin text: what a cell whose font names the scheme draws with.
+         */
+        latin?: string;
+        /**
+         * The PANOSE classification of {@link latin}, 20 hexadecimal digits. It chooses the generic
+         * family drawn with when the font is not installed.
+         */
+        panose?: string;
+        /**
+         * The font for East Asian text. Usually empty, with the font given by script in {@link scripts}.
+         */
+        eastAsian?: string;
+        /**
+         * The font for complex-script text (Arabic, Hebrew, Thai, ...). Usually empty, with the font
+         * given by script in {@link scripts}.
+         */
+        complexScript?: string;
+        /**
+         * Fonts by the script of the text, keyed by ISO 15924 code (`Jpan`, `Hang`, `Arab`, ...), in the
+         * order they are listed.
+         */
+        scripts?: Record<string, string>;
     }
-    interface FontSchemeJSON extends Partial<FontSchemeProperties> {
+    /**
+     * A theme's fonts: one collection for headings and one for body text.
+     *
+     * @remarks
+     * A collection is taken whole: one that is stated replaces the base theme's, script fonts included.
+     */
+    interface FontSchemeJSON {
+        name?: string;
+        /**
+         * The heading fonts. Office calls these the **Headings** font.
+         */
+        major?: FontCollectionJSON;
+        /**
+         * The body fonts. Office calls these the **Body** font.
+         */
+        minor?: FontCollectionJSON;
     }
     /**
      * One reference into a theme style list (`fillRef`, `lnRef`, `effectRef`): the one-based position
@@ -288,6 +342,53 @@ export declare namespace ITheme {
          * represented are still populated, so the theme draws with them.
          */
         formatSchemeXml?: string;
+        /**
+         * What a new shape, line or text box starts from. Stated, it replaces the base theme's whole,
+         * so `{}` means none.
+         */
+        objectDefaults?: ITheme.ObjectDefaultsJSON;
+        /**
+         * Colors the theme offers beside its scheme, in order: Office lists them as **Custom Colors**
+         * in its color pickers. Not inherited from the base theme.
+         */
+        customColors?: ITheme.CustomColorJSON[];
+        /**
+         * Which theme this is, across the files and versions it appears in. Not inherited from the
+         * base theme.
+         */
+        family?: ITheme.FamilyJSON;
+    }
+    /**
+     * A color a theme offers beside its scheme (DrawingML's `custClr`).
+     */
+    interface CustomColorJSON {
+        /** The name shown for the color. */
+        name?: string;
+        color: string;
+    }
+    /**
+     * A theme's identity (the 2012 theme extension's `themeFamily`). Office matches themes by
+     * {@link id}, and the versions of one theme by {@link vid}.
+     */
+    interface FamilyJSON {
+        /** The family's name, such as `Office Theme`. */
+        name: string;
+        /** A GUID in braces, the same for every version of the theme. */
+        id: string;
+        /** A GUID in braces naming this version. */
+        vid?: string;
+    }
+    /**
+     * What a new object starts from, by kind: its fill, line, effects, text body and style
+     * references, as a shape states them. DrawingML's `objectDefaults`.
+     */
+    interface ObjectDefaultsJSON {
+        /** A new shape (`spDef`). */
+        shape?: IShape.JSON;
+        /** A new line or connector (`lnDef`). */
+        line?: IShape.JSON;
+        /** A new text box (`txDef`). */
+        text?: IShape.JSON;
     }
 }
 //# sourceMappingURL=ITheme.d.ts.map

package/types/src/theme/ThemeCollection.d.ts

@@ -16,6 +16,9 @@ export declare class Theme implements ITheme {
     private _effectStyleLst;
     private _bgFillStyleLst;
     private _formatScheme;
+    private _objectDefaults;
+    private _customColors;
+    private _family;
     private _cacheColors;
     /** System epoch at which `_cacheColors` was populated (for host-theme invalidation). */
     private _cacheEpoch;
@@ -31,6 +34,8 @@ export declare class Theme implements ITheme {
     getFontScheme(): ITheme.IFontScheme;
     /** {@inheritDoc ITheme.getFormatScheme} */
     getFormatScheme(): ITheme.FormatScheme;
+    /** {@inheritDoc ITheme.getObjectDefaults} */
+    getObjectDefaults(): Readonly<ITheme.ObjectDefaultsJSON>;
     /** {@inheritDoc ITheme.schemeLookup} */
     schemeLookup(): IColor.SchemeLookup;
     /** {@inheritDoc ITheme.parseColor} */

package/types/src/theme/_OfficeFontScheme.d.ts

@@ -0,0 +1,8 @@
+import { ITheme } from './ITheme';
+/**
+ * The fonts of the Office theme's font scheme (Excel 2013-2022), as Excel writes them into a new
+ * workbook, script fonts included.
+ */
+export declare const OFFICE_MAJOR_FONTS: Readonly<ITheme.FontCollectionJSON>;
+export declare const OFFICE_MINOR_FONTS: Readonly<ITheme.FontCollectionJSON>;
+//# sourceMappingURL=_OfficeFontScheme.d.ts.map

package/types/src/transaction/ITransaction.d.ts

@@ -657,8 +657,11 @@ export declare namespace ITransaction {
         onBeforeCommitEnd?(state: STATE, commit: ITransaction.ICommit, isRevert: boolean, isRestore: boolean, intents: Readonly<Record<string, any>>): void;
         /**
          * Called after the transaction. This is generally used for cleanup or ui notification.
+         *
+         * @param previous The commit the store moved from: for a commit its parent, for a revert or
+         * restore the commit that was current before it. `null` when there is none.
          */
-        onAfterStateChange?(state: STATE, commit: ITransaction.ICommit, isRevert: boolean, isRestore: boolean, intents: Readonly<Record<string, any>>): void;
+        onAfterStateChange?(state: STATE, commit: ITransaction.ICommit, isRevert: boolean, isRestore: boolean, intents: Readonly<Record<string, any>>, previous: ITransaction.ICommit | null): void;
         /**
          * Called if the restore or revert is called. This is called asynchronously As should only have passive actions.
          */
@@ -776,6 +779,22 @@ export declare namespace ITransaction {
          * Called when this transaction, or any transaction it is nested in, rolls back.
          */
         onRollback?(): void;
+        /**
+         * Called each time a transaction begun directly inside this one commits, while this one is
+         * still open.
+         *
+         * @param child The transaction that committed. It has closed: what this hook writes begins
+         * inside this transaction, and is itself reported here when it commits.
+         * @param intents What `child`, and everything nested in it, recorded with
+         * {@link ITransaction.setIntent}, on its own. The operation's intents
+         * ({@link ITransaction.getIntent}) hold the union.
+         *
+         * @remarks
+         * For a caller that reacts to each step of an operation as it happens, rather than once when
+         * it lands ({@link onCommit}). Deeper transactions are part of the step that holds them and are
+         * not reported on their own. A child that rolls back is not reported.
+         */
+        onChildCommit?(child: ITransaction, intents: Readonly<Record<string, any>>): void;
     }
     /**
      * Options for operations with the store.

package/types/src/transaction/Transaction.d.ts

@@ -161,7 +161,7 @@ export declare class TransactionStore implements ITransaction.IStore {
      * the states were computed against the current snapshot and belong to it.
      */
     protected _commitRecord(container: CommitContainer, states: Map<any, any>, amendOf: string | null): void;
-    _notifyStates(event: keyof ITransaction.IStateListener, container: CommitContainer, states: Map<any, any>, isRevert?: boolean, isRestore?: boolean, async?: boolean, source?: CommitContainer): void;
+    _notifyStates(event: keyof ITransaction.IStateListener, container: CommitContainer, states: Map<any, any>, isRevert?: boolean, isRestore?: boolean, async?: boolean, source?: CommitContainer, previous?: ITransaction.ICommit | null): void;
     protected _notifyClose(commit: ITransaction.ICommit, isRollback: boolean, isElided?: boolean, isAmend?: boolean): void;
     _notify(event: Exclude<keyof ITransaction.IListeners, 'onCommitClose'>, commit: ITransaction.ICommit, async?: boolean): void | Promise<any>;
 }
@@ -181,6 +181,7 @@ declare abstract class AbstractTransaction implements ITransaction {
     protected _hooks: ITransaction.Hooks | null;
     protected _flushing: boolean;
     protected _outcomes: ITransaction.Hooks[] | null;
+    protected _intentMark: number;
     constructor(store: TransactionStore, container: CommitContainer, options: ITransaction.StoreOperationOptions | string | undefined);
     /** @internal Whether a read of some record flushes this transaction. */
     _isFlushedOnRead(): boolean;
@@ -199,6 +200,12 @@ declare abstract class AbstractTransaction implements ITransaction {
     protected _settle(options?: ITransaction.StoreOperationOptions): void;
     /** @internal A committed child's outcome hooks, now waiting on this transaction's outcome. */
     _adoptOutcomes(child: AbstractTransaction): void;
+    /**
+     * Tells this transaction's `onChildCommit` that `child`, begun directly inside it, has
+     * committed.
+     * @internal
+     */
+    _childCommitted(child: AbstractTransaction): void;
     /** @internal Tells the outcome hooks waiting on this transaction how the operation ended. */
     protected _notifyOutcome(commit: ITransaction.ICommit | null): void;
     /**

package/types/src/transaction/_BatchHandle.d.ts

@@ -0,0 +1,118 @@
+import { ITransaction } from './ITransaction';
+/**
+ * The handle a batch hands its callback: the same SDK objects, reached through it, bound to the
+ * batch.
+ *
+ * @remarks
+ * A batch that awaits stays open while other code runs on the event loop: a React render, a hook
+ * subscribing. The store cannot tell the batch's next line from that code, so "is a transaction
+ * open" does not say whether a caller is part of the batch. Holding the batch does. Whatever is
+ * reached through the handle is wrapped by the same rule, so a script that only ever sees the
+ * handle never touches a plain object, and code that never sees it (the UI) is outside the batch
+ * however long it stays open.
+ *
+ * A call made through the handle runs with the handle current ({@link getCurrentBatchHandle}) for
+ * its synchronous extent. That is the only scope there is: nothing is inferred across an `await`,
+ * which is what makes it safe in the browser.
+ *
+ * Objects go back into the SDK unwrapped, so the SDK only ever sees its own objects. A wrapped
+ * object is a different identity from the plain one, but the same object is always wrapped the
+ * same way, so identities compare consistently on either side.
+ *
+ * @internal
+ */
+export declare class BatchHandle {
+    protected _store: ITransaction.IStore;
+    protected _closed: boolean;
+    protected _commitId: string | null;
+    protected _stepListeners: Set<BatchHandle.StepListener> | null;
+    protected _toWrapped: WeakMap<object, any>;
+    /** @param store The store the batch is open on. */
+    constructor(store: ITransaction.IStore);
+    /** The store the batch is open on. */
+    getStore(): ITransaction.IStore;
+    /**
+     * The id of the root commit the batch writes into, or `null` before its callback has started.
+     * A batch nested in another operation shares that operation's commit.
+     */
+    getCommitId(): string | null;
+    /** Whether the batch this handle is bound to has closed. */
+    isClosed(): boolean;
+    /**
+     * The batch has closed. What was reached through the handle keeps working, as the plain object
+     * does: it is no longer part of a batch.
+     */
+    close(): void;
+    /**
+     * Hear each step of the batch as it is made: a transaction begun directly inside the batch has
+     * committed. Dropped when the batch closes.
+     */
+    addStepListener(listener: BatchHandle.StepListener): () => void;
+    protected _onStep(commit: ITransaction.ICommit, intents: Readonly<Record<string, any>>): void;
+    /** `value` as seen through this handle. */
+    wrap<T>(value: T): T;
+    /** `value` as the SDK sees it: what this handle wrapped, unwrapped. */
+    unwrap<T>(value: T): T;
+    protected _wrapModel<T extends object>(raw: T): T;
+    protected _wrapMethod(target: object, method: (...args: any[]) => any): (...args: any[]) => any;
+    protected _methods: WeakMap<object, Map<(...args: any[]) => any, (...args: any[]) => any>>;
+    protected _unwrapArg(arg: any): any;
+    protected _unwrapCallbacks(plain: Record<string, any>): Record<string, any>;
+    protected _callbacks: WeakMap<object, Record<string, any>>;
+    /**
+     * `outward`: a function handed out by the SDK (its arguments go in unwrapped, its result comes
+     * out wrapped). Otherwise one handed in (the SDK calls it: arguments wrapped, result unwrapped).
+     */
+    protected _wrapFunction(fn: (...args: any[]) => any, outward: boolean): (...args: any[]) => any;
+    protected _outward: WeakMap<(...args: any[]) => any, (...args: any[]) => any>;
+    protected _inward: WeakMap<(...args: any[]) => any, (...args: any[]) => any>;
+    protected _wrapArray(array: any[]): any[];
+    protected _wrapIterator(iterator: Iterator<any>): Iterator<any>;
+    protected _inScope<R>(callback: () => R): R;
+    /**
+     * A batch's callback, handed `self` bound to a new handle on `store`.
+     *
+     * @remarks
+     * What the callback answers is handed back plain: the handle is over once the batch is. `close`
+     * belongs in the batch's close callback, and `onChildCommit` in the options it is begun with.
+     */
+    static bind<T extends object, R>(store: ITransaction.IStore, self: T, callback: (commit: ITransaction.ICommit, bound: T) => R | Promise<R>): {
+        callback: (commit: ITransaction.ICommit) => R | Promise<R>;
+        close: () => void;
+        onChildCommit: NonNullable<ITransaction.Hooks['onChildCommit']>;
+    };
+    /**
+     * Whether a batch open on `store` is told of each of its steps. While one is, a write is to be
+     * made as it comes, never held for later: a step made later is heard later.
+     */
+    static isStepping(store: ITransaction.IStore): boolean;
+    /** The handle `value` was reached through, or `null` for a plain object. */
+    static of(value: unknown): BatchHandle | null;
+}
+/**
+ * The open batch handle the running code was called through, or `null`.
+ *
+ * @remarks
+ * Set only for the synchronous extent of a call made through a handle that is still open. Code
+ * reached any other way - the UI, a timer, a hook - sees `null` whatever batch is open.
+ *
+ * @internal
+ */
+export declare const getCurrentBatchHandle: () => BatchHandle | null;
+/**
+ * Whether a listener registered now, on `store`, with no `transactional` of its own, takes part in
+ * the operation: it is registered through an open batch's handle, on that batch's store.
+ *
+ * @internal
+ */
+export declare const isRegisteringInBatch: (store: ITransaction.IStore) => boolean;
+export declare namespace BatchHandle {
+    /**
+     * Told as a step of the batch is made.
+     *
+     * @param commit The root commit the batch writes into.
+     * @param intents What the step recorded ({@link ITransaction.Hooks.onChildCommit}).
+     */
+    type StepListener = (commit: ITransaction.ICommit, intents: Readonly<Record<string, any>>) => void;
+}
+//# sourceMappingURL=_BatchHandle.d.ts.map

package/types/src/type/AbstractCollection.d.ts

@@ -2,20 +2,9 @@ import { ITransaction } from '../transaction';
 import { IListener } from '../listener';
 import { ListenerEmitter } from '../listener/ListenerEmitter';
 import { ICollection } from './ICollection';
-/**
- * Base for every {@link ICollection}.
- *
- * @remarks
- * A subclass supplies {@link _getItems} — how its items are stored is its own business, keyed or
- * ordered, held here or fronted from elsewhere — and gets iteration, the count and every read
- * helper from that one call. A subclass with a cheaper count overrides {@link getCount}.
- *
- * Listeners are uniform: {@link addListeners} on the base, and {@link _notifyCollectionChange} /
- * {@link _notifyInvalidated} for the subclass to announce with. A subclass that fronts another
- * collection and forwards its events overrides `addListeners` instead of keeping a second
- * emitter.
- */
 export declare abstract class AbstractCollection<T, O extends ICollection.GetItemsOptions = ICollection.GetItemsOptions> implements ICollection<T> {
+    /** Answered by the proxy the constructor returns; see {@link ICollection}. */
+    readonly [index: number]: T;
     /**
      * The store transactional listeners are versioned in; `undefined` gives the emitter a transient
      * store of its own.
@@ -25,6 +14,8 @@ export declare abstract class AbstractCollection<T, O extends ICollection.GetIte
     private _collectionEmitter;
     private _closed;
     constructor(transactions?: ITransaction.IStore);
+    /** {@inheritDoc ICollection.length} */
+    get length(): number;
     /** {@inheritDoc ICollection.isClosed} */
     isClosed(): boolean;
     /**

package/types/src/type/ICollection.d.ts

@@ -4,9 +4,10 @@ import { IListener } from '../listener';
  * Interface used for all ICollections.
  *
  * @remarks
- * A collection is the read side of a `ReadonlyArray` without the index operator: it iterates,
- * counts, and offers the familiar helpers (`at`, `find`, `filter`, `map`, ...), but it is not an
- * array and has no `[i]` or `length`. Call {@link toArray} when an array is really wanted.
+ * A collection reads like a `ReadonlyArray`: it indexes (`[i]`), counts (`length`), iterates, and
+ * offers the familiar helpers (`at`, `find`, `filter`, `map`, ...). It is not an array —
+ * `Array.isArray` is `false` and it cannot be written through `[i]` — so call {@link toArray} when
+ * an array is really wanted.
  *
  * Iteration order is the collection's own order — insertion order for the ordered collections
  * (sheets, tables, movables) and unspecified for the keyed ones (resources, functions). Every
@@ -14,11 +15,23 @@ import { IListener } from '../listener';
  * they run.
  */
 export interface ICollection<T> {
+    /**
+     * The item at the given index, or `undefined` if there is none — `wb.getWorksheets()[0]`.
+     *
+     * @remarks
+     * Read-only and live: each read is against the collection as it is now. Assigning through an
+     * index throws.
+     */
+    readonly [index: number]: T;
+    /**
+     * The number of items — the same as {@link getCount}.
+     */
+    readonly length: number;
     /**
      * Iterates the collection's items.
      *
      * @remarks
-     * The unfiltered walk — `for (const sheet of wb.getSheets())`. Every other iterable surface in
+     * The unfiltered walk — `for (const sheet of wb.getWorksheets())`. Every other iterable surface in
      * the SDK (`ICellRange`, `ICellRegions`, `ICellRanges`) reads this way, so a collection that did
      * not was a trap: `for…of` over one is the obvious line to write and it threw at runtime with
      * nothing in the types to warn first.

package/types/src/type/IProperties.d.ts

@@ -11,7 +11,7 @@ export declare namespace IProperties {
      * @typeParam P - The type representing the properties associated with the range.
      * @typeParam U - The type accepted by updates. This need not be `P` widened - a property bag may
      * accept convenience keys that are folded onto canonical ones and never appear in `P` (see
-     * `IStyledFont.Modifiers`). Defaults to {@link IProperties.ResolvableProperties} of `P`.
+     * `IFontStyle.Update`). Defaults to {@link IProperties.ResolvableProperties} of `P`.
      * @typeParam J - The type representing the JSON-serializable representation of the range.
      */
     interface ICellRanged<P, U = IProperties.ResolvableProperties<P>> {

package/types/src/utils/_CSSUtils.d.ts

@@ -18,7 +18,7 @@ export declare function toHex(color: IColor, darkMode?: boolean): string;
 /** Baked modes keep the historical hex output; `'adaptive'` defers to `IColor.toCSS` (`light-dark()`). */
 export declare function toCSSColor(color: IColor, mode?: IColor.CSSMode): string;
 export declare function toCSSFontSize(size: number | null | undefined): string | null;
-export declare function toCSSTextDecoration(underline: IFont.UnderlineStyle | boolean, strike: boolean): CSSTextDecoration;
+export declare function toCSSTextDecoration(underline: IFont.UnderlineStyle | boolean, strikeStyle: IFont.StrikeStyle | boolean): CSSTextDecoration;
 export declare function toCSSTextUnderlineStyle(underline: IFont.UnderlineStyle): string;
 export declare const noDecoration: Readonly<{
     underline: "none";

package/types/src/wasm/_fontsWasm.d.ts

@@ -0,0 +1,7 @@
+import { WasmBindgenExports } from '@sheetxl/utils';
+import * as glue from '../.generated/wasm/fonts.js';
+/** The binding's exports, once instantiated. */
+export type FontsWasmExports = WasmBindgenExports<typeof glue>;
+/** The binding's exports, instantiated and ready to call. */
+export declare const wasm: FontsWasmExports;
+//# sourceMappingURL=_fontsWasm.d.ts.map

package/types/src/wasm/_sdkWasm.d.ts

@@ -1,5 +1,5 @@
 import { WasmBindgenExports } from '@sheetxl/utils';
-import * as glue from '../../wasm/sdk.js';
+import * as glue from '../.generated/wasm/sdk.js';
 /** The binding's exports, once instantiated. */
 export type SdkWasmExports = WasmBindgenExports<typeof glue>;
 /** The binding's exports, instantiated and ready to call. */

package/types/src/wasm/fontsWasm.d.ts

@@ -0,0 +1,32 @@
+import { FontsWasmExports } from './_fontsWasm';
+export type { FontsWasmExports } from './_fontsWasm';
+/**
+ * Reads font files: the Rust that opens a font's bytes and writes its measures tables, compiled to
+ * WebAssembly.
+ *
+ * @remarks
+ * Lazy on every platform, Node included, and never prefetched: only adding a font needs it
+ * (`sheetxl fonts add`, a font a user gives the browser), and its binary is ten times the sdk's
+ * own. Internal to the sdk.
+ *
+ * @example
+ * ```ts
+ * const { FontFile } = await FontsWasm.load();
+ * const file = new FontFile(bytes);
+ * const tables = file.capture(0, file.identity(0).family, 6, 120);
+ * file.free();
+ * ```
+ */
+export declare const FontsWasm: {
+    /**
+     * Loads and instantiates the WebAssembly, or returns it if it is already loaded.
+     *
+     * @remarks
+     * Concurrent calls share one attempt; a failed attempt is retried by the next call. Rejects with
+     * a `LazyLoadError`.
+     */
+    load: () => Promise<FontsWasmExports>;
+    /** The exports if the WebAssembly has loaded, otherwise `undefined`. */
+    peek: () => FontsWasmExports | undefined;
+};
+//# sourceMappingURL=fontsWasm.d.ts.map

package/types/src/wasm/index.d.ts

@@ -1,2 +1,3 @@
 export * from './sdkWasm';
+export * from './fontsWasm';
 //# sourceMappingURL=index.d.ts.map

package/types/src/wasm/loader.browser.d.ts

@@ -0,0 +1,9 @@
+import { SdkWasmExports } from './_sdkWasm';
+/**
+ * Loads and instantiates the WebAssembly, or returns it if it is already loaded. Concurrent calls
+ * share one attempt; a failed attempt is retried by the next call. Rejects with a `LazyLoadError`.
+ */
+export declare const load: () => Promise<SdkWasmExports>;
+/** The exports if the WebAssembly has loaded, otherwise `undefined`. */
+export declare const peek: () => SdkWasmExports | undefined;
+//# sourceMappingURL=loader.browser.d.ts.map

package/types/src/wasm/loader.node.d.ts

@@ -0,0 +1,9 @@
+import { WasmBindgenExports } from '@sheetxl/utils';
+import * as glue from '../.generated/wasm/sdk.js';
+type SdkWasmExports = WasmBindgenExports<typeof glue>;
+/** The exports, ready: resolved at once. */
+export declare const load: () => Promise<SdkWasmExports>;
+/** The exports, always loaded here. */
+export declare const peek: () => SdkWasmExports | undefined;
+export {};
+//# sourceMappingURL=loader.node.d.ts.map

package/types/src/wasm/sdkWasm.d.ts

@@ -1,11 +1,14 @@
 import { SdkWasmExports } from './_sdkWasm';
 export type { SdkWasmExports } from './_sdkWasm';
 /**
- * `@sheetxl/sdk`'s Rust code, compiled to WebAssembly, loaded on first use.
+ * `@sheetxl/sdk`'s Rust code, compiled to WebAssembly.
  *
  * @remarks
- * Nothing is downloaded or compiled until {@link SdkWasm.load} is called. One module serves the
- * browser and Node. Internal to the sdk: the measurer and the wrapper call it; nothing outside the
+ * How it arrives is the platform's: in a browser a lazy chunk that nothing downloads until
+ * {@link SdkWasm.load} is called; in Node an instantiation as the sdk loads, so {@link SdkWasm.peek}
+ * answers before any synchronous code runs (the `@sheetxl/sdk/wasm/loader` conditional export,
+ * `loader.node.ts` for `node` and `default`, `loader.browser.ts` for `browser`, read only here,
+ * like `license/runtime`). Internal to the sdk: the text engine calls it; nothing outside the
  * package does, so it is not exported from the index.
  *
  * @example