@origints/xlsx 0.1.1 → 0.2.0

package/dist/parse.d.ts

@@ -1,4 +1,5 @@
 import { XlsxWorkbook } from './xlsx-workbook';
+import { XlsxSpecBuilder } from './xlsx-spec-builder';
 /**
  * Transform AST specification.
  * Compatible with @origints/core TransformAst.
@@ -9,6 +10,14 @@ export interface TransformAst {
     readonly name: string;
     readonly args?: unknown;
 }
+/**
+ * Typed transform AST with spec builder type parameter.
+ * Compatible with @origints/core TypedTransformAst.
+ */
+export interface TypedTransformAst<SB = unknown> extends TransformAst {
+    readonly __specBuilder?: SB;
+    readonly specBuilderFactory: () => SB;
+}
 /**
  * Transform implementation.
  * Compatible with @origints/core TransformImpl.
@@ -59,12 +68,12 @@ export interface XlsxParseOptions {
  *   .in(loadFile('data.xlsx'))
  *   .mapIn(parseXlsx())
  *   .emit((out, $) => out
- *     .add('revenue', $.sheet('Sales').cell('B2').number())
+ *     .add('revenue', $.get('Sales').get('B2').number())
  *   )
  *   .compile()
  * ```
  */
-export declare function parseXlsx(options?: XlsxParseOptions): TransformAst;
+export declare function parseXlsx(options?: XlsxParseOptions): TypedTransformAst<XlsxSpecBuilder>;
 /**
  * Sync transform implementation for parseXlsx.
  * Note: XLSX parsing requires async due to file reading.

package/dist/xlsx-cell.d.ts

@@ -1,3 +1,4 @@
+import { TYPE_LABEL } from '@origints/core';
 import { Cell as ExcelJSCell } from 'exceljs';
 import { XlsxResult, XlsxPath, CellValue, ExtendedCellValue } from './xlsx-result';
 /**
@@ -61,6 +62,7 @@ export declare class XlsxCell {
     private readonly cell;
     private readonly _path;
     private readonly _sheetName;
+    get [TYPE_LABEL](): string;
     private constructor();
     /**
      * Creates an XlsxCell from an ExcelJS cell.

package/dist/xlsx-cursor.d.ts

@@ -1,3 +1,4 @@
+import { TYPE_LABEL } from '@origints/core';
 import { XlsxSheet } from './xlsx-sheet';
 import { XlsxCell } from './xlsx-cell';
 import { XlsxResult, XlsxPath } from './xlsx-result';
@@ -33,6 +34,7 @@ export declare class XlsxCursor {
     private readonly _row;
     private readonly _col;
     private readonly _direction;
+    get [TYPE_LABEL](): string;
     private constructor();
     /**
      * Create a cursor from an address string.

package/dist/xlsx-predicate-compiler.d.ts

@@ -0,0 +1,17 @@
+import { XlsxSheet } from './xlsx-sheet';
+import { CellPredicate } from './xlsx-query';
+import { SheetPredicate } from './xlsx-workbook';
+import { CellPredicateSpec, SheetPredicateSpec, RowPredicateSpec } from './xlsx-predicate-spec';
+/**
+ * Compile a CellPredicateSpec AST into a runtime CellPredicate closure.
+ */
+export declare function compileCellPredicate(spec: CellPredicateSpec): CellPredicate;
+/**
+ * Compile a SheetPredicateSpec AST into a runtime SheetPredicate closure.
+ */
+export declare function compileSheetPredicate(spec: SheetPredicateSpec): SheetPredicate;
+export type RowPredicate = (sheet: XlsxSheet, row: number, anchorCol: number) => boolean;
+/**
+ * Compile a RowPredicateSpec AST into a runtime RowPredicate closure.
+ */
+export declare function compileRowPredicate(spec: RowPredicateSpec): RowPredicate;

package/dist/xlsx-predicate-spec.d.ts

@@ -0,0 +1,175 @@
+import { CellValue } from './xlsx-result';
+export type CellPredicateSpec = {
+    readonly kind: 'equals';
+    readonly value: CellValue;
+} | {
+    readonly kind: 'contains';
+    readonly text: string;
+    readonly caseSensitive: boolean;
+} | {
+    readonly kind: 'matches';
+    readonly pattern: string;
+    readonly flags: string;
+} | {
+    readonly kind: 'startsWith';
+    readonly prefix: string;
+    readonly caseSensitive: boolean;
+} | {
+    readonly kind: 'endsWith';
+    readonly suffix: string;
+    readonly caseSensitive: boolean;
+} | {
+    readonly kind: 'isString';
+} | {
+    readonly kind: 'isNumber';
+} | {
+    readonly kind: 'isBoolean';
+} | {
+    readonly kind: 'isDate';
+} | {
+    readonly kind: 'isEmpty';
+} | {
+    readonly kind: 'isNotEmpty';
+} | {
+    readonly kind: 'isFormula';
+} | {
+    readonly kind: 'isError';
+} | {
+    readonly kind: 'isMerged';
+} | {
+    readonly kind: 'gt';
+    readonly value: number;
+} | {
+    readonly kind: 'gte';
+    readonly value: number;
+} | {
+    readonly kind: 'lt';
+    readonly value: number;
+} | {
+    readonly kind: 'lte';
+    readonly value: number;
+} | {
+    readonly kind: 'between';
+    readonly min: number;
+    readonly max: number;
+} | {
+    readonly kind: 'isBold';
+} | {
+    readonly kind: 'isItalic';
+} | {
+    readonly kind: 'hasHyperlink';
+} | {
+    readonly kind: 'hasComment';
+} | {
+    readonly kind: 'and';
+    readonly left: CellPredicateSpec;
+    readonly right: CellPredicateSpec;
+} | {
+    readonly kind: 'or';
+    readonly left: CellPredicateSpec;
+    readonly right: CellPredicateSpec;
+} | {
+    readonly kind: 'not';
+    readonly operand: CellPredicateSpec;
+};
+export type SheetPredicateSpec = {
+    readonly kind: 'nameEquals';
+    readonly name: string;
+} | {
+    readonly kind: 'nameContains';
+    readonly text: string;
+} | {
+    readonly kind: 'nameStartsWith';
+    readonly prefix: string;
+} | {
+    readonly kind: 'nameEndsWith';
+    readonly suffix: string;
+} | {
+    readonly kind: 'nameMatches';
+    readonly pattern: string;
+    readonly flags: string;
+} | {
+    readonly kind: 'and';
+    readonly left: SheetPredicateSpec;
+    readonly right: SheetPredicateSpec;
+} | {
+    readonly kind: 'or';
+    readonly left: SheetPredicateSpec;
+    readonly right: SheetPredicateSpec;
+} | {
+    readonly kind: 'not';
+    readonly operand: SheetPredicateSpec;
+};
+export interface CellPred {
+    readonly _spec: CellPredicateSpec;
+    and(other: CellPred): CellPred;
+    or(other: CellPred): CellPred;
+    not(): CellPred;
+    describe(): string;
+}
+export interface SheetPred {
+    readonly _spec: SheetPredicateSpec;
+    and(other: SheetPred): SheetPred;
+    or(other: SheetPred): SheetPred;
+    not(): SheetPred;
+    describe(): string;
+}
+export declare const cell: Readonly<{
+    equals: (value: CellValue) => CellPred;
+    contains: (text: string, caseSensitive?: boolean) => CellPred;
+    matches: (pattern: RegExp) => CellPred;
+    startsWith: (prefix: string, caseSensitive?: boolean) => CellPred;
+    endsWith: (suffix: string, caseSensitive?: boolean) => CellPred;
+    isString: () => CellPred;
+    isNumber: () => CellPred;
+    isBoolean: () => CellPred;
+    isDate: () => CellPred;
+    isEmpty: () => CellPred;
+    isNotEmpty: () => CellPred;
+    isFormula: () => CellPred;
+    isError: () => CellPred;
+    isMerged: () => CellPred;
+    gt: (value: number) => CellPred;
+    gte: (value: number) => CellPred;
+    lt: (value: number) => CellPred;
+    lte: (value: number) => CellPred;
+    between: (min: number, max: number) => CellPred;
+    isBold: () => CellPred;
+    isItalic: () => CellPred;
+    hasHyperlink: () => CellPred;
+    hasComment: () => CellPred;
+}>;
+export declare const sheet: Readonly<{
+    nameEquals: (name: string) => SheetPred;
+    nameContains: (text: string) => SheetPred;
+    nameStartsWith: (prefix: string) => SheetPred;
+    nameEndsWith: (suffix: string) => SheetPred;
+    nameMatches: (pattern: RegExp) => SheetPred;
+}>;
+export declare function describeCellPredicate(spec: CellPredicateSpec): string;
+export type RowPredicateSpec = {
+    readonly kind: 'rowCol';
+    readonly offset: number;
+    readonly predicate: CellPredicateSpec;
+} | {
+    readonly kind: 'and';
+    readonly left: RowPredicateSpec;
+    readonly right: RowPredicateSpec;
+} | {
+    readonly kind: 'or';
+    readonly left: RowPredicateSpec;
+    readonly right: RowPredicateSpec;
+} | {
+    readonly kind: 'not';
+    readonly operand: RowPredicateSpec;
+};
+export interface RowPred {
+    readonly _spec: RowPredicateSpec;
+    and(other: RowPred): RowPred;
+    or(other: RowPred): RowPred;
+    not(): RowPred;
+    describe(): string;
+}
+export declare function rowCol(offset: number, predicate: CellPred): RowPred;
+export declare function describeRowPredicate(spec: RowPredicateSpec): string;
+export declare function describeSheetPredicate(spec: SheetPredicateSpec): string;

package/dist/xlsx-range.d.ts

@@ -1,3 +1,4 @@
+import { TYPE_LABEL } from '@origints/core';
 import { Worksheet } from 'exceljs';
 import { XlsxCell } from './xlsx-cell';
 import { XlsxResult, XlsxPath, CellValue } from './xlsx-result';
@@ -18,6 +19,7 @@ export declare class XlsxRange {
     private readonly _path;
     private readonly _sheetName;
     private readonly _file?;
+    get [TYPE_LABEL](): string;
     private constructor();
     /**
      * Creates an XlsxRange from coordinates.

package/dist/xlsx-sheet.d.ts

@@ -1,3 +1,4 @@
+import { TYPE_LABEL } from '@origints/core';
 import { Worksheet } from 'exceljs';
 import { XlsxCell } from './xlsx-cell';
 import { XlsxRange } from './xlsx-range';
@@ -26,6 +27,7 @@ export declare class XlsxSheet {
     private readonly worksheet;
     private readonly _path;
     private readonly _file?;
+    get [TYPE_LABEL](): string;
     private constructor();
     /**
      * Creates an XlsxSheet from an ExcelJS worksheet.

package/dist/xlsx-spec-builder.d.ts

@@ -0,0 +1,177 @@
+import { ArraySpec, ExtractSpec, Spec } from '@origints/core';
+import { XlsxStep, Direction } from './xlsx-spec';
+import { CellPred, SheetPred, RowPred } from './xlsx-predicate-spec';
+/**
+ * Spec builder at the cell level — terminal extraction and navigation methods.
+ */
+export declare class XlsxCellSB {
+    private readonly steps;
+    /** @internal */
+    constructor(steps: readonly XlsxStep[]);
+    /** @internal Expose steps for colWhere/rowWhere headerRef */
+    get _steps(): readonly XlsxStep[];
+    /** Extract cell value as string */
+    string(): ExtractSpec<XlsxStep, 'string'>;
+    /** Extract cell value as number */
+    number(): ExtractSpec<XlsxStep, 'number'>;
+    /** Extract cell value as boolean */
+    boolean(): ExtractSpec<XlsxStep, 'boolean'>;
+    /** Extract cell value as Date */
+    date(): ExtractSpec<XlsxStep, 'date'>;
+    /** Extract raw cell value */
+    value(): ExtractSpec<XlsxStep, 'value'>;
+    /** Extract cell formula */
+    formula(): ExtractSpec<XlsxStep, 'formula'>;
+    /** Move right by count cells (default 1) */
+    right(count?: number): XlsxCellSB;
+    /** Move left by count cells (default 1) */
+    left(count?: number): XlsxCellSB;
+    /** Move up by count cells (default 1) */
+    up(count?: number): XlsxCellSB;
+    /** Move down by count cells (default 1) */
+    down(count?: number): XlsxCellSB;
+    /** Move by row and column deltas */
+    offset(rowDelta: number, colDelta: number): XlsxCellSB;
+    /** Scan in direction until predicate matches */
+    scanTo(direction: Direction, predicate: CellPred): XlsxCellSB;
+    /** Skip cells in direction while predicate matches, land on first non-matching */
+    skipWhile(direction: Direction, predicate: CellPred): XlsxCellSB;
+    /**
+     * Iterate over cells from this position in a direction while the predicate matches.
+     * Returns an ArraySpec whose items are produced by the itemMapper.
+     */
+    eachCell<T extends Spec>(direction: Direction, while_: CellPred, itemMapper: (cell: XlsxCellSB) => T): ArraySpec<T>;
+    /**
+     * Iterate over slices (rows or columns) from this cell position.
+     * Each slice is passed as an XlsxSliceSB to the mapper, providing
+     * header-relative column/row access via colWhere/rowWhere.
+     */
+    eachSlice<T extends Spec>(direction: Direction, while_: RowPred, itemMapper: (slice: XlsxSliceSB) => T): ArraySpec<T>;
+}
+/**
+ * Spec builder for items within a slice (row or column section).
+ * Provides header-relative column/row access.
+ */
+export declare class XlsxSliceSB {
+    private readonly steps;
+    /** @internal */
+    constructor(steps: readonly XlsxStep[]);
+    /** Access a column by matching its header cell against a predicate (header-relative) */
+    colWhere(headerRef: XlsxCellSB, predicate: CellPred): XlsxCellSB;
+    /** Access a row by matching its header cell against a predicate (header-relative, for rotated tables) */
+    rowWhere(headerRef: XlsxCellSB, predicate: CellPred): XlsxCellSB;
+    /** Access a column by 0-based offset from the anchor */
+    col(offset: number): XlsxCellSB;
+    /** Access a row by 0-based offset from the anchor (for rotated tables) */
+    row(offset: number): XlsxCellSB;
+}
+/**
+ * Spec builder for items within a row (receives an XlsxRange representing one row).
+ * Provides column access to navigate within the row.
+ */
+export declare class XlsxRowItemSB {
+    private readonly steps;
+    /** @internal */
+    constructor(steps: readonly XlsxStep[]);
+    /** Access a column by 1-based index within the row */
+    col(index: number): XlsxCellSB;
+    /** Navigate to a cell by address within the row */
+    cell(ref: string): XlsxCellSB;
+}
+/**
+ * Spec builder at the range level — cell navigation, rows, and cells collection.
+ */
+export declare class XlsxRangeSB {
+    private readonly steps;
+    /** @internal */
+    constructor(steps: readonly XlsxStep[]);
+    /** Navigate to a cell by address within the range */
+    cell(ref: string): XlsxCellSB;
+    /** Navigate to a cell by coordinates within the range */
+    cellAt(row: number, col: number): XlsxCellSB;
+    /**
+     * Iterate over rows in the range.
+     * Each row is provided as an XlsxRowItemSB to the mapper.
+     * Returns an ArraySpec.
+     */
+    rows<T extends Spec>(itemMapper: (row: XlsxRowItemSB) => T): ArraySpec<T>;
+    /**
+     * Iterate over all cells in the range as a flat list.
+     * Each cell is provided as an XlsxCellSB to the mapper.
+     * Returns an ArraySpec.
+     */
+    cells<T extends Spec>(itemMapper: (cell: XlsxCellSB) => T): ArraySpec<T>;
+}
+/**
+ * Spec builder at the row level.
+ */
+export declare class XlsxRowSB {
+    private readonly steps;
+    /** @internal */
+    constructor(steps: readonly XlsxStep[]);
+    /** Navigate to a cell by address within this row */
+    cell(ref: string): XlsxCellSB;
+    /** Navigate to a cell by column within this row */
+    cellAt(row: number, col: number): XlsxCellSB;
+}
+/**
+ * Spec builder at the column level.
+ */
+export declare class XlsxColSB {
+    private readonly steps;
+    /** @internal */
+    constructor(steps: readonly XlsxStep[]);
+    /** Navigate to a cell by address within this column */
+    cell(ref: string): XlsxCellSB;
+    /** Navigate to a cell by coordinates within this column */
+    cellAt(row: number, col: number): XlsxCellSB;
+}
+/**
+ * Spec builder at the sheet level — cell, range, row, column, and search navigation.
+ */
+export declare class XlsxSheetSB {
+    private readonly steps;
+    /** @internal */
+    constructor(steps: readonly XlsxStep[]);
+    /** Navigate to a cell by address (e.g., "A1", "B2") */
+    cell(ref: string): XlsxCellSB;
+    /** Navigate to a cell by 1-based row and column coordinates */
+    cellAt(row: number, col: number): XlsxCellSB;
+    /** Find the first cell matching the predicate */
+    find(predicate: CellPred): XlsxCellSB;
+    /** Find the first cell matching the predicate in the specified row */
+    findInRow(rowIndex: number, predicate: CellPred): XlsxCellSB;
+    /** Find the first cell matching the predicate in the specified column */
+    findInCol(colIndex: number, predicate: CellPred): XlsxCellSB;
+    /** Find the first cell matching the predicate in the specified range */
+    findInRange(rangeRef: string, predicate: CellPred): XlsxCellSB;
+    /** Navigate to a range by address (e.g., "A1:C10") */
+    range(ref: string): XlsxRangeSB;
+    /** Navigate to a range by two corner addresses */
+    range(from: string, to: string): XlsxRangeSB;
+    /** Navigate to a range defined by two dynamically resolved cells */
+    range(from: XlsxCellSB, to: XlsxCellSB): XlsxRangeSB;
+    /** Navigate to a row by 1-based index */
+    row(index: number): XlsxRowSB;
+    /** Navigate to a column by 1-based index */
+    col(index: number): XlsxColSB;
+}
+/**
+ * Spec builder for XLSX workbook — the entry point for xlsx navigation specs.
+ *
+ * Used as `$` in `emit()` after `.mapIn(parseXlsx())`.
+ */
+export declare class XlsxSpecBuilder {
+    private readonly steps;
+    private constructor();
+    /** Create a root spec builder */
+    static root(): XlsxSpecBuilder;
+    /** Navigate to a sheet by name */
+    sheet(name: string): XlsxSheetSB;
+    /** Navigate to a sheet by 1-based index */
+    sheetAt(index: number): XlsxSheetSB;
+    /** Navigate to the first sheet */
+    firstSheet(): XlsxSheetSB;
+    /** Find a sheet matching the predicate */
+    findSheet(predicate: SheetPred): XlsxSheetSB;
+}

package/dist/xlsx-spec-executor.d.ts

@@ -0,0 +1,25 @@
+import { TYPE_LABEL, ExtractionResult } from '@origints/core';
+import { XlsxSpec } from './xlsx-spec';
+import { XlsxWorkbook } from './xlsx-workbook';
+import { XlsxSheet } from './xlsx-sheet';
+import { XlsxCell } from './xlsx-cell';
+/**
+ * Context wrapper for slice items.
+ * Carries workbook+sheet references so colWhere/rowWhere can resolve headers.
+ */
+export declare class XlsxSliceContext {
+    readonly workbook: XlsxWorkbook;
+    readonly sheet: XlsxSheet;
+    readonly anchorCell: XlsxCell;
+    get [TYPE_LABEL](): string;
+    constructor(workbook: XlsxWorkbook, sheet: XlsxSheet, anchorCell: XlsxCell);
+}
+/**
+ * Execute an XlsxSpec against data.
+ *
+ * The executor is polymorphic — it detects the input type:
+ * - XlsxWorkbook → starts at workbook level
+ * - XlsxRange → starts at range level (used for row items)
+ * - XlsxCell → starts at cell level (used for cell items)
+ */
+export declare function executeXlsxSpec(spec: XlsxSpec, data: unknown): ExtractionResult<unknown>;

package/dist/xlsx-spec.d.ts

@@ -0,0 +1,121 @@
+import { ExtractSpec, Spec } from '@origints/core';
+import { CellPredicateSpec, SheetPredicateSpec, RowPredicateSpec } from './xlsx-predicate-spec';
+/**
+ * Direction for cell navigation.
+ */
+export type Direction = 'right' | 'left' | 'up' | 'down';
+/**
+ * A single navigation step through an XLSX workbook.
+ */
+export type XlsxStep = {
+    readonly kind: 'sheet';
+    readonly name: string;
+} | {
+    readonly kind: 'sheetAt';
+    readonly index: number;
+} | {
+    readonly kind: 'firstSheet';
+} | {
+    readonly kind: 'findSheet';
+    readonly predicate: SheetPredicateSpec;
+} | {
+    readonly kind: 'find';
+    readonly predicate: CellPredicateSpec;
+} | {
+    readonly kind: 'findInRow';
+    readonly rowIndex: number;
+    readonly predicate: CellPredicateSpec;
+} | {
+    readonly kind: 'findInCol';
+    readonly colIndex: number;
+    readonly predicate: CellPredicateSpec;
+} | {
+    readonly kind: 'findInRange';
+    readonly rangeRef: string;
+    readonly predicate: CellPredicateSpec;
+} | {
+    readonly kind: 'cell';
+    readonly ref: string;
+} | {
+    readonly kind: 'cellAt';
+    readonly row: number;
+    readonly col: number;
+} | {
+    readonly kind: 'right';
+    readonly count: number;
+} | {
+    readonly kind: 'left';
+    readonly count: number;
+} | {
+    readonly kind: 'up';
+    readonly count: number;
+} | {
+    readonly kind: 'down';
+    readonly count: number;
+} | {
+    readonly kind: 'offset';
+    readonly rowDelta: number;
+    readonly colDelta: number;
+} | {
+    readonly kind: 'scanTo';
+    readonly direction: Direction;
+    readonly predicate: CellPredicateSpec;
+} | {
+    readonly kind: 'skipWhile';
+    readonly direction: Direction;
+    readonly predicate: CellPredicateSpec;
+} | {
+    readonly kind: 'colWhere';
+    readonly headerRef: Spec;
+    readonly predicate: CellPredicateSpec;
+} | {
+    readonly kind: 'rowWhere';
+    readonly headerRef: Spec;
+    readonly predicate: CellPredicateSpec;
+} | {
+    readonly kind: 'range';
+    readonly ref: string;
+} | {
+    readonly kind: 'rangeFromCells';
+    readonly from: Spec;
+    readonly to: Spec;
+} | {
+    readonly kind: 'row';
+    readonly index: number;
+} | {
+    readonly kind: 'col';
+    readonly index: number;
+};
+/**
+ * Specification for iterating over cells in a direction while a predicate matches.
+ */
+export interface EachCellExtract {
+    readonly kind: 'eachCell';
+    readonly direction: Direction;
+    readonly while: CellPredicateSpec;
+}
+/**
+ * Specification for iterating over slices (rows or columns) in a direction
+ * while a row-level predicate matches. Each slice is an anchor cell
+ * wrapped in XlsxSliceContext for header-relative navigation.
+ */
+export interface EachSliceExtract {
+    readonly kind: 'eachSlice';
+    readonly direction: Direction;
+    readonly while: RowPredicateSpec;
+}
+/**
+ * The terminal extraction type for an XLSX value.
+ *
+ * - Cell-level: 'string', 'number', 'boolean', 'date', 'value', 'formula'
+ * - Range-level (produce arrays): 'rows', 'cells'
+ * - Cell-level (produce arrays): EachCellExtract, EachSliceExtract
+ */
+export type XlsxExtract = 'string' | 'number' | 'boolean' | 'date' | 'value' | 'formula' | 'rows' | 'cells' | EachCellExtract | EachSliceExtract;
+/**
+ * A complete XLSX extraction spec.
+ *
+ * Describes a path through the workbook (steps) and what to extract (extract).
+ * JSON-serializable and suitable for AST introspection.
+ */
+export type XlsxSpec = ExtractSpec<XlsxStep, XlsxExtract>;

package/dist/xlsx-workbook.d.ts

@@ -1,3 +1,4 @@
+import { TYPE_LABEL } from '@origints/core';
 import { Workbook } from 'exceljs';
 import { XlsxSheet } from './xlsx-sheet';
 import { XlsxResult, XlsxPath } from './xlsx-result';
@@ -25,6 +26,7 @@ export interface WorkbookProperties {
 export declare class XlsxWorkbook {
     private readonly workbook;
     private readonly _path;
+    get [TYPE_LABEL](): string;
     private readonly sheetsCache;
     private constructor();
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@origints/xlsx",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "XLSX parsing for Origins with full traceability to sheets, ranges, and cells.",
   "type": "module",
   "license": "MIT",
@@ -20,27 +20,46 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "build": "vite build",
-    "test": "vitest run",
-    "test:coverage": "vitest run --coverage",
-    "lint": "eslint \"{src,tests}/**/*.{ts,tsx}\" --max-warnings 0",
-    "typecheck": "tsc -p tsconfig.json --noEmit"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fponticelli/origints.git",
+    "directory": "packages/xlsx"
+  },
+  "homepage": "https://origints.dev",
+  "bugs": "https://github.com/fponticelli/origints/issues",
+  "keywords": [
+    "origints",
+    "data-extraction",
+    "lineage",
+    "provenance",
+    "xlsx",
+    "excel",
+    "spreadsheet"
+  ],
+  "engines": {
+    "node": ">=18"
   },
   "dependencies": {
     "exceljs": "^4.4.0"
   },
   "peerDependencies": {
-    "@origints/core": "^0.1.0"
+    "@origints/core": "^0.2.0"
   },
   "devDependencies": {
-    "@origints/core": "workspace:*",
     "@types/node": "25.0.6",
     "@vitest/coverage-v8": "^4.0.16",
     "eslint": "9.39.2",
     "typescript": "5.9.3",
     "vite": "7.3.1",
     "vite-plugin-dts": "4.5.4",
-    "vitest": "4.0.16"
+    "vitest": "4.0.16",
+    "@origints/core": "0.2.0"
+  },
+  "scripts": {
+    "build": "vite build",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "lint": "eslint \"{src,tests}/**/*.{ts,tsx}\" --max-warnings 0",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
   }
-}
+}