@ricsam/formula-engine 0.0.17 → 0.0.19

package/dist/types/core/commands/table-commands.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Table Commands - Commands that modify table definitions
+ *
+ * These commands all require re-evaluation after execution.
+ */
+import type { TableManager } from "../managers/table-manager";
+import type { NamedExpressionManager } from "../managers/named-expression-manager";
+import type { WorkbookManager } from "../managers/workbook-manager";
+import type { ApiSchemaManager } from "../managers/api-schema-manager";
+import type { CellAddress, SerializedCellValue, SpreadsheetRangeEnd, TableDefinition } from "../types";
+import type { EngineCommand, EngineAction } from "./types";
+/**
+ * Dependencies needed for table commands.
+ */
+export interface TableCommandDeps {
+    tableManager: TableManager;
+    namedExpressionManager: NamedExpressionManager;
+    workbookManager: WorkbookManager;
+    apiSchemaManager: ApiSchemaManager;
+    getCellValue: (cellAddress: CellAddress) => SerializedCellValue;
+    renameTableInFormula: (formula: string, oldName: string, newName: string) => string;
+}
+/**
+ * Command to add a table.
+ */
+export declare class AddTableCommand implements EngineCommand {
+    private deps;
+    private props;
+    readonly requiresReevaluation = true;
+    constructor(deps: TableCommandDeps, props: {
+        tableName: string;
+        sheetName: string;
+        workbookName: string;
+        start: string;
+        numRows: SpreadsheetRangeEnd;
+        numCols: number;
+    });
+    execute(): void;
+    undo(): void;
+    toAction(): EngineAction;
+}
+/**
+ * Command to remove a table.
+ */
+export declare class RemoveTableCommand implements EngineCommand {
+    private deps;
+    private opts;
+    readonly requiresReevaluation = true;
+    private removedTable;
+    constructor(deps: TableCommandDeps, opts: {
+        tableName: string;
+        workbookName: string;
+    });
+    execute(): void;
+    undo(): void;
+    toAction(): EngineAction;
+}
+/**
+ * Command to rename a table.
+ */
+export declare class RenameTableCommand implements EngineCommand {
+    private deps;
+    private workbookName;
+    private oldName;
+    private newName;
+    readonly requiresReevaluation = true;
+    constructor(deps: TableCommandDeps, workbookName: string, oldName: string, newName: string);
+    execute(): void;
+    undo(): void;
+    toAction(): EngineAction;
+}
+/**
+ * Command to update a table.
+ */
+export declare class UpdateTableCommand implements EngineCommand {
+    private deps;
+    private opts;
+    readonly requiresReevaluation = true;
+    private previousTable;
+    constructor(deps: TableCommandDeps, opts: {
+        tableName: string;
+        sheetName?: string;
+        start?: string;
+        numRows?: SpreadsheetRangeEnd;
+        numCols?: number;
+        workbookName: string;
+    });
+    execute(): void;
+    undo(): void;
+    toAction(): EngineAction;
+}
+/**
+ * Command to reset all tables.
+ */
+export declare class ResetTablesCommand implements EngineCommand {
+    private deps;
+    private newTables;
+    readonly requiresReevaluation = true;
+    private previousTables;
+    constructor(deps: TableCommandDeps, newTables: Map<string, Map<string, TableDefinition>>);
+    execute(): void;
+    undo(): void;
+    toAction(): EngineAction;
+}

package/dist/types/core/commands/types.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Command Pattern Types for FormulaEngine
+ *
+ * Commands encapsulate all mutating operations on the engine,
+ * enabling undo/redo, schema validation with rollback, and action serialization.
+ */
+import type { CellAddress } from "../types";
+/**
+ * Serializable action representation of a command.
+ * Used for persistence, collaboration, and changelog functionality.
+ */
+export interface EngineAction {
+    type: string;
+    payload: unknown;
+    timestamp?: number;
+}
+/**
+ * Base interface for all engine commands.
+ */
+export interface EngineCommand {
+    /**
+     * Whether this command affects cell values/formulas and requires re-evaluation.
+     * Commands that only affect metadata or styles don't need re-evaluation.
+     */
+    readonly requiresReevaluation: boolean;
+    /**
+     * Execute the command (forward operation).
+     */
+    execute(): void;
+    /**
+     * Undo the command (reverse operation).
+     */
+    undo(): void;
+    /**
+     * Convert the command to a serializable action for persistence/collaboration.
+     */
+    toAction(): EngineAction;
+}
+/**
+ * Options for command execution.
+ */
+export interface ExecuteOptions {
+    /**
+     * Whether to validate schema constraints after execution.
+     * Only applies to commands that require re-evaluation.
+     */
+    validate?: boolean;
+    /**
+     * Whether to skip adding to undo stack (for internal use).
+     */
+    skipUndoStack?: boolean;
+    /**
+     * Whether to skip emitting update events.
+     */
+    skipEmitUpdate?: boolean;
+}
+/**
+ * Result of schema validation.
+ */
+export interface SchemaValidationResult {
+    valid: boolean;
+    errors: SchemaValidationErrorInfo[];
+}
+/**
+ * Information about a schema validation error.
+ */
+export interface SchemaValidationErrorInfo {
+    message: string;
+    cellAddress?: CellAddress;
+    schemaNamespace?: string;
+    columnName?: string;
+    originalError?: Error;
+}
+/**
+ * Action types for all commands.
+ * Used for serialization and deserialization.
+ */
+export declare const ActionTypes: {
+    readonly SET_CELL_CONTENT: "SET_CELL_CONTENT";
+    readonly SET_SHEET_CONTENT: "SET_SHEET_CONTENT";
+    readonly CLEAR_RANGE: "CLEAR_RANGE";
+    readonly PASTE_CELLS: "PASTE_CELLS";
+    readonly FILL_AREAS: "FILL_AREAS";
+    readonly MOVE_CELL: "MOVE_CELL";
+    readonly MOVE_RANGE: "MOVE_RANGE";
+    readonly AUTO_FILL: "AUTO_FILL";
+    readonly ADD_WORKBOOK: "ADD_WORKBOOK";
+    readonly REMOVE_WORKBOOK: "REMOVE_WORKBOOK";
+    readonly RENAME_WORKBOOK: "RENAME_WORKBOOK";
+    readonly CLONE_WORKBOOK: "CLONE_WORKBOOK";
+    readonly ADD_SHEET: "ADD_SHEET";
+    readonly REMOVE_SHEET: "REMOVE_SHEET";
+    readonly RENAME_SHEET: "RENAME_SHEET";
+    readonly ADD_TABLE: "ADD_TABLE";
+    readonly REMOVE_TABLE: "REMOVE_TABLE";
+    readonly RENAME_TABLE: "RENAME_TABLE";
+    readonly UPDATE_TABLE: "UPDATE_TABLE";
+    readonly RESET_TABLES: "RESET_TABLES";
+    readonly ADD_NAMED_EXPRESSION: "ADD_NAMED_EXPRESSION";
+    readonly REMOVE_NAMED_EXPRESSION: "REMOVE_NAMED_EXPRESSION";
+    readonly UPDATE_NAMED_EXPRESSION: "UPDATE_NAMED_EXPRESSION";
+    readonly RENAME_NAMED_EXPRESSION: "RENAME_NAMED_EXPRESSION";
+    readonly SET_NAMED_EXPRESSIONS: "SET_NAMED_EXPRESSIONS";
+    readonly SET_CELL_METADATA: "SET_CELL_METADATA";
+    readonly SET_SHEET_METADATA: "SET_SHEET_METADATA";
+    readonly SET_WORKBOOK_METADATA: "SET_WORKBOOK_METADATA";
+    readonly ADD_CONDITIONAL_STYLE: "ADD_CONDITIONAL_STYLE";
+    readonly REMOVE_CONDITIONAL_STYLE: "REMOVE_CONDITIONAL_STYLE";
+    readonly ADD_CELL_STYLE: "ADD_CELL_STYLE";
+    readonly REMOVE_CELL_STYLE: "REMOVE_CELL_STYLE";
+    readonly CLEAR_CELL_STYLES: "CLEAR_CELL_STYLES";
+    readonly RESET_TO_SERIALIZED: "RESET_TO_SERIALIZED";
+};
+export type ActionType = (typeof ActionTypes)[keyof typeof ActionTypes];

package/dist/types/core/engine.d.ts

@@ -12,13 +12,21 @@ import { EventManager } from "./managers/event-manager";
 import { EvaluationManager } from "./managers/evaluation-manager";
 import { DependencyManager } from "./managers/dependency-manager";
 import { StyleManager } from "./managers/style-manager";
+import type { Api, CreateApi, Declaration } from "./api/api";
+import { type EngineAction } from "./commands/types";
+type Metadata = {
+    cell?: unknown;
+    sheet?: unknown;
+    workbook?: unknown;
+};
+type MetadataType<TMetadata extends Metadata, TKey extends keyof Metadata> = TMetadata[TKey];
 /**
  * Main FormulaEngine class
  * @template TCellMetadata - Consumer-defined type for cell metadata (rich text, links, custom data, etc.)
  * @template TSheetMetadata - Consumer-defined type for sheet metadata (text boxes, frozen panes, etc.)
  * @template TWorkbookMetadata - Consumer-defined type for workbook metadata (themes, document properties, etc.)
  */
-export declare class FormulaEngine<TCellMetadata = unknown, TSheetMetadata = unknown, TWorkbookMetadata = unknown> {
+export declare class FormulaEngine<TMetadata extends Metadata = Metadata, TCreateApi extends CreateApi<MetadataType<TMetadata, "cell">, Api, Declaration> | undefined = undefined> {
     private workbookManager;
     private namedExpressionManager;
     private tableManager;
@@ -29,6 +37,10 @@ export declare class FormulaEngine<TCellMetadata = unknown, TSheetMetadata = unk
     private styleManager;
     private copyManager;
     private referenceManager;
+    private apiSchemaManager;
+    private commandExecutor;
+    api: TCreateApi extends CreateApi<MetadataType<TMetadata, "cell">, Api, Declaration> ? TCreateApi["api"] : undefined;
+    private apiDeclaration;
     /**
      * Public access to the store manager for testing
      */
@@ -40,32 +52,32 @@ export declare class FormulaEngine<TCellMetadata = unknown, TSheetMetadata = unk
     _autoFillManager: AutoFill;
     _dependencyManager: DependencyManager;
     _styleManager: StyleManager;
-    constructor();
+    constructor(api?: TCreateApi);
     /**
      * Static factory method to build an empty engine
      * @template TC - Consumer-defined cell metadata type
      * @template TS - Consumer-defined sheet metadata type
      * @template TW - Consumer-defined workbook metadata type
      */
-    static buildEmpty<TC = unknown, TS = unknown, TW = unknown>(): FormulaEngine<TC, TS, TW>;
+    static buildEmpty<TMetadata extends Metadata = Metadata, TApiDeclaration extends CreateApi<MetadataType<TMetadata, "cell">, any, any> | undefined = undefined>(api?: TApiDeclaration): FormulaEngine<TMetadata, TApiDeclaration>;
     getCellEvaluationResult(cellAddress: CellAddress): SingleEvaluationResult | undefined;
     getCellValue(cellAddress: CellAddress, debug?: boolean): SerializedCellValue;
     /**
      * Set metadata for a cell
      * Metadata can contain rich text, links, comments, or any consumer-defined data
      */
-    setCellMetadata(address: CellAddress, metadata: TCellMetadata | undefined): void;
+    setCellMetadata(address: CellAddress, metadata: MetadataType<TMetadata, "cell"> | undefined): void;
     /**
      * Get metadata for a cell
      */
-    getCellMetadata(address: CellAddress): TCellMetadata | undefined;
+    getCellMetadata(address: CellAddress): MetadataType<TMetadata, "cell"> | undefined;
     /**
      * Get all cell metadata for a sheet (serialized as Map)
      */
     getSheetMetadataSerialized(opts: {
         sheetName: string;
         workbookName: string;
-    }): Map<string, TCellMetadata>;
+    }): Map<string, MetadataType<TMetadata, "sheet">>;
     /**
      * Set metadata for a sheet
      * Sheet metadata can contain text boxes, frozen panes, print settings, or any consumer-defined data
@@ -73,23 +85,23 @@ export declare class FormulaEngine<TCellMetadata = unknown, TSheetMetadata = unk
     setSheetMetadata(opts: {
         workbookName: string;
         sheetName: string;
-    }, metadata: TSheetMetadata): void;
+    }, metadata: MetadataType<TMetadata, "sheet">): void;
     /**
      * Get metadata for a sheet
      */
     getSheetMetadata(opts: {
         workbookName: string;
         sheetName: string;
-    }): TSheetMetadata | undefined;
+    }): MetadataType<TMetadata, "sheet"> | undefined;
     /**
      * Set metadata for a workbook
      * Workbook metadata can contain themes, document properties, settings, or any consumer-defined data
      */
-    setWorkbookMetadata(workbookName: string, metadata: TWorkbookMetadata): void;
+    setWorkbookMetadata(workbookName: string, metadata: MetadataType<TMetadata, "workbook">): void;
     /**
      * Get metadata for a workbook
      */
-    getWorkbookMetadata(workbookName: string): TWorkbookMetadata | undefined;
+    getWorkbookMetadata(workbookName: string): MetadataType<TMetadata, "workbook"> | undefined;
     /**
      * Create a tracked reference to a range
      * Returns a stable UUID that can be used to retrieve the address later
@@ -118,29 +130,37 @@ export declare class FormulaEngine<TCellMetadata = unknown, TSheetMetadata = unk
     formula: string, cellAddress: CellAddress): SerializedCellValue;
     getCellDependents(address: CellAddress | SpreadsheetRange): (SpreadsheetRange | CellAddress)[];
     getCellPrecedents(address: CellAddress | SpreadsheetRange): (SpreadsheetRange | CellAddress)[];
-    addNamedExpression({ expression, expressionName, sheetName, workbookName, }: {
+    addNamedExpression(opts: {
         expression: string;
         expressionName: string;
         sheetName?: string;
         workbookName?: string;
     }): void;
-    removeNamedExpression({ expressionName, sheetName, workbookName, }: {
+    removeNamedExpression(opts: {
+        expressionName: string;
+        sheetName?: string;
+        workbookName?: string;
+    }): void;
+    /**
+     * Check if a named expression exists
+     */
+    hasNamedExpression(opts: {
         expressionName: string;
         sheetName?: string;
         workbookName?: string;
     }): boolean;
-    updateNamedExpression({ expression, expressionName, sheetName, workbookName, }: {
+    updateNamedExpression(opts: {
         expression: string;
         expressionName: string;
         sheetName?: string;
         workbookName?: string;
     }): void;
-    renameNamedExpression({ expressionName, sheetName, workbookName, newName, }: {
+    renameNamedExpression(opts: {
         expressionName: string;
         sheetName?: string;
         workbookName?: string;
         newName: string;
-    }): boolean;
+    }): void;
     setNamedExpressions(opts: ({
         type: "global";
     } | {
@@ -160,7 +180,7 @@ export declare class FormulaEngine<TCellMetadata = unknown, TSheetMetadata = unk
         start: string;
         numRows: SpreadsheetRangeEnd;
         numCols: number;
-    }): TableDefinition;
+    }): void;
     renameTable(workbookName: string, names: {
         oldName: string;
         newName: string;
@@ -176,10 +196,29 @@ export declare class FormulaEngine<TCellMetadata = unknown, TSheetMetadata = unk
     removeTable(opts: {
         tableName: string;
         workbookName: string;
+    }): void;
+    /**
+     * Check if a table exists
+     */
+    hasTable(opts: {
+        tableName: string;
+        workbookName: string;
     }): boolean;
+    /**
+     * Get a table definition by name
+     */
+    getTable(opts: {
+        tableName: string;
+        workbookName: string;
+    }): TableDefinition | undefined;
     resetTables(tables: Map<string, Map<string, TableDefinition>>): void;
     getTables(workbookName: string): Map<string, TableDefinition>;
     isCellInTable(cellAddress: CellAddress): TableDefinition | undefined;
+    /**
+     * Get all data cells in a table (excluding header row).
+     * Uses workbook indexes to efficiently handle infinite tables.
+     */
+    private getTableDataCells;
     /**
      * Add a conditional style rule
      */
@@ -187,7 +226,11 @@ export declare class FormulaEngine<TCellMetadata = unknown, TSheetMetadata = unk
     /**
      * Remove a conditional style rule by index
      */
-    removeConditionalStyle(workbookName: string, index: number): boolean;
+    removeConditionalStyle(workbookName: string, index: number): void;
+    /**
+     * Get the count of conditional styles for a workbook
+     */
+    getConditionalStyleCount(workbookName: string): number;
     /**
      * Get all conditional styles intersecting with a range
      */
@@ -211,7 +254,11 @@ export declare class FormulaEngine<TCellMetadata = unknown, TSheetMetadata = unk
     /**
      * Remove a direct cell style rule by index
      */
-    removeCellStyle(workbookName: string, index: number): boolean;
+    removeCellStyle(workbookName: string, index: number): void;
+    /**
+     * Get the count of direct cell styles for a workbook
+     */
+    getCellStyleCount(workbookName: string): number;
     /**
      * Get all direct cell styles intersecting with a range
      */
@@ -337,16 +384,23 @@ export declare class FormulaEngine<TCellMetadata = unknown, TSheetMetadata = unk
     addSheet(opts: {
         workbookName: string;
         sheetName: string;
-    }): import("./types").Sheet<unknown, unknown>;
+    }): void;
     removeSheet(opts: {
         workbookName: string;
         sheetName: string;
-    }): import("./types").Sheet<unknown, unknown>;
+    }): void;
     renameSheet(opts: {
         sheetName: string;
         newSheetName: string;
         workbookName: string;
-    }): import("./types").Sheet<unknown, unknown>;
+    }): void;
+    /**
+     * Check if a sheet exists
+     */
+    hasSheet(opts: {
+        workbookName: string;
+        sheetName: string;
+    }): boolean;
     getSheets(workbookName: string): Map<string, import("./types").Sheet<unknown, unknown>>;
     getSheet({ workbookName, sheetName, }: {
         workbookName: string;
@@ -358,6 +412,10 @@ export declare class FormulaEngine<TCellMetadata = unknown, TSheetMetadata = unk
     }): Map<string, SerializedCellValue>;
     addWorkbook(workbookName: string): void;
     removeWorkbook(workbookName: string): void;
+    /**
+     * Check if a workbook exists
+     */
+    hasWorkbook(workbookName: string): boolean;
     cloneWorkbook(fromWorkbookName: string, toWorkbookName: string): void;
     renameWorkbook(opts: {
         workbookName: string;
@@ -369,18 +427,17 @@ export declare class FormulaEngine<TCellMetadata = unknown, TSheetMetadata = unk
      * @param sheetName - The name of the sheet to set the content of
      * @param content - A map of cell addresses to their serialized values
      * @remarks This method is used to set the content of a sheet. It will re-evaluate all sheets to ensure all dependencies are resolved correctly.
+     * @throws SchemaIntegrityError if any evaluated cell value violates a schema constraint
      */
     setSheetContent(opts: {
         sheetName: string;
         workbookName: string;
     }, content: Map<string, SerializedCellValue>): void;
-    setCellContent(address: CellAddress, content: SerializedCellValue): void;
     /**
-     * Re-evaluates all sheets to ensure all dependencies are resolved correctly
-     *
-     * but just clears the evaluation cache
+     * Set the content of a single cell.
+     * @throws SchemaIntegrityError if the evaluated value violates a schema constraint
      */
-    reevaluate(): void;
+    setCellContent(address: CellAddress, content: SerializedCellValue): void;
     /**
      * Auto-fills one or more ranges based on the seedRange and the direction.
      * Supports pattern detection and style copying.
@@ -420,4 +477,51 @@ export declare class FormulaEngine<TCellMetadata = unknown, TSheetMetadata = unk
     onUpdate(listener: () => void): () => void;
     serializeEngine(): string;
     resetToSerializedEngine(data: string): void;
+    /**
+     * Undo the last command.
+     * @returns true if undo was performed, false if nothing to undo
+     */
+    undo(): boolean;
+    /**
+     * Redo the last undone command.
+     * @returns true if redo was performed, false if nothing to redo
+     */
+    redo(): boolean;
+    /**
+     * Check if undo is available.
+     */
+    canUndo(): boolean;
+    /**
+     * Check if redo is available.
+     */
+    canRedo(): boolean;
+    /**
+     * Get the action log for persistence/collaboration.
+     * Actions can be serialized and replayed to reconstruct state.
+     */
+    getActionLog(): EngineAction[];
+    /**
+     * Clear the action log.
+     */
+    clearActionLog(): void;
+    /**
+     * Clear undo/redo history.
+     */
+    clearHistory(): void;
+    /**
+     * Get dependencies for structure commands.
+     * @internal
+     */
+    private getStructureCommandDeps;
+    /**
+     * Get dependencies for table commands.
+     * @internal
+     */
+    private getTableCommandDeps;
+    /**
+     * Get dependencies for named expression commands.
+     * @internal
+     */
+    private getNamedExpressionCommandDeps;
 }
+export {};

package/dist/types/core/managers/api-schema-manager.d.ts

@@ -0,0 +1,121 @@
+/**
+ * ApiSchemaManager - Manages API schema definitions and validation
+ *
+ * Tracks registered schemas and provides validation for cell writes,
+ * spill operations, and copy/paste operations.
+ */
+import type { CellAddress, SerializedCellValue, SpreadsheetRange, TableDefinition } from "../types";
+import type { TableManager } from "./table-manager";
+export type ParseFunction<TCellMetadata = unknown> = (value: unknown, metadata: TCellMetadata) => unknown;
+export type TableSchemaHeaders<TCellMetadata = unknown> = Record<string, {
+    parse: ParseFunction<TCellMetadata>;
+    index: number;
+}>;
+export interface RegisteredTableSchema {
+    type: "table";
+    namespace: string;
+    workbookName: string;
+    tableName: string;
+    headers: TableSchemaHeaders;
+}
+export interface RegisteredCellSchema {
+    type: "cell";
+    namespace: string;
+    cellAddress: CellAddress;
+    parse: ParseFunction;
+}
+export type RegisteredSchema = RegisteredTableSchema | RegisteredCellSchema;
+export interface ValidationResult {
+    valid: boolean;
+    error?: string;
+    originalError?: Error;
+}
+export declare class SchemaValidationError extends Error {
+    cellAddress?: CellAddress | undefined;
+    originalError?: Error | undefined;
+    constructor(message: string, cellAddress?: CellAddress | undefined, originalError?: Error | undefined);
+}
+export declare class ApiSchemaManager {
+    private tableManager;
+    private schemas;
+    constructor(tableManager: TableManager);
+    /**
+     * Register a table schema
+     */
+    registerTableSchema(namespace: string, workbookName: string, tableName: string, headers: TableSchemaHeaders): void;
+    /**
+     * Register a cell schema
+     */
+    registerCellSchema(namespace: string, cellAddress: CellAddress, parse: ParseFunction): void;
+    /**
+     * Get a schema by namespace
+     */
+    getSchema(namespace: string): RegisteredSchema | undefined;
+    /**
+     * Remove a schema
+     */
+    removeSchema(namespace: string): boolean;
+    /**
+     * Check if a cell is protected by a schema
+     * Returns the schema info if protected, null otherwise
+     */
+    isCellProtected(cell: CellAddress): {
+        schema: RegisteredSchema;
+        columnName?: string;
+    } | null;
+    /**
+     * Check if a cell is within a table's data range (excluding header row)
+     */
+    private isCellInTableDataRange;
+    /**
+     * Get column name by index from headers
+     */
+    private getColumnNameByIndex;
+    /**
+     * Validate a cell write against schemas
+     */
+    validateCellWrite(cell: CellAddress, value: SerializedCellValue, metadata?: unknown): ValidationResult;
+    /**
+     * Validate a spill area against schemas
+     * Returns validation result - if invalid, spill should produce #SPILL! error
+     */
+    validateSpillArea(origin: CellAddress, spillArea: SpreadsheetRange, getSpillValue: (row: number, col: number) => SerializedCellValue, getMetadata?: (cell: CellAddress) => unknown): ValidationResult;
+    /**
+     * Update schemas when a table is renamed
+     */
+    updateForTableRename(workbookName: string, oldTableName: string, newTableName: string): void;
+    /**
+     * Update schemas when a sheet is renamed
+     */
+    updateForSheetRename(workbookName: string, oldSheetName: string, newSheetName: string): void;
+    /**
+     * Update schemas when a workbook is renamed
+     */
+    updateForWorkbookRename(oldWorkbookName: string, newWorkbookName: string): void;
+    /**
+     * Get all schemas (for debugging/testing)
+     */
+    getAllSchemas(): Map<string, RegisteredSchema>;
+    /**
+     * Validate all schema constraints using evaluated cell values.
+     *
+     * This is the key method for schema validation with rollback:
+     * - It validates EVALUATED values, not raw content
+     * - A cell with "=123+123" validates as number (246), not string
+     * - Called after re-evaluation to check all schema-constrained cells
+     *
+     * @param getCellValue - Function to get the evaluated value of a cell
+     * @param getCellMetadata - Optional function to get cell metadata
+     * @returns Validation result with all errors found
+     */
+    validateAllSchemaConstraints(getCellValue: (cell: CellAddress) => SerializedCellValue, getCellMetadata?: (cell: CellAddress) => unknown, getTableDataCells?: (table: TableDefinition) => CellAddress[]): {
+        valid: boolean;
+        errors: Array<{
+            message: string;
+            cellAddress?: CellAddress;
+            schemaNamespace?: string;
+            columnName?: string;
+            originalError?: Error;
+        }>;
+    };
+}

package/dist/types/core/types.d.ts

@@ -363,7 +363,7 @@ export interface CopyCellsOptions {
      *   - ['content', 'style', 'metadata'] - same as 'all'
      * @default 'all'
      */
-    include?: 'all' | ('content' | 'style' | 'metadata')[];
+    include?: "all" | ("content" | "style" | "metadata")[];
     /**
      * The type of the content to copy
      * value: Copy the value from the source to the target,

package/dist/types/lib.d.ts

@@ -2,3 +2,11 @@ export { FormulaEngine } from "./core/engine";
 export * from "./core/types";
 export * from "./core/utils";
 export * from "./core/utils/color-utils";
+export { defineApi, createApi } from "./core/api/api";
+export type { CreateApi, Declaration, Api, TableApi, CellApi } from "./core/api/api";
+export { TableOrm } from "./core/api/table-orm";
+export { CellOrm } from "./core/api/cell-orm";
+export { SchemaValidationError } from "./core/managers/api-schema-manager";
+export type { ValidationResult } from "./core/managers/api-schema-manager";
+export { SchemaIntegrityError } from "./core/commands/command-executor";
+export type { EngineAction, EngineCommand } from "./core/commands/types";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ricsam/formula-engine",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "module": "./dist/mjs/lib.mjs",
   "scripts": {
     "test": "bun test",