dirsql 0.0.21 → 0.0.25

package/README.md

@@ -1,225 +1,43 @@
-# dirsql
+# `dirsql` (TypeScript SDK)
 
-Ephemeral SQL index over a local directory. Watches a filesystem, ingests structured files into an in-memory SQLite database, and exposes a SQL query interface. On shutdown, the database is discarded -- the filesystem remains the source of truth.
-
-## Why
-
-Structured data stored as flat files (JSONL, JSON) is easy to read, write, diff, and version. But querying across many files is slow -- "show me all unresolved comments across 50 documents" requires opening and parsing every file.
-
-dirsql bridges this gap: files remain the source of truth, but you get SQL queries and real-time change events for free.
+TypeScript SDK for `dirsql` -- napi-rs bindings wrapping the Rust core (`dirsql`).
 
 ## Installation
 
 ```bash
-pip install dirsql
-```
-
-Rust (library only, no Python bindings):
-
-```bash
-cargo add dirsql
-```
-
-## Quick Start
-
-```python
-import json
-import os
-import tempfile
-from dirsql import DirSQL, Table
-
-# Create some data files
-root = tempfile.mkdtemp()
-os.makedirs(os.path.join(root, "comments", "abc"), exist_ok=True)
-os.makedirs(os.path.join(root, "comments", "def"), exist_ok=True)
-
-with open(os.path.join(root, "comments", "abc", "index.jsonl"), "w") as f:
-    f.write(json.dumps({"body": "looks good", "author": "alice"}) + "\n")
-    f.write(json.dumps({"body": "needs work", "author": "bob"}) + "\n")
-
-with open(os.path.join(root, "comments", "def", "index.jsonl"), "w") as f:
-    f.write(json.dumps({"body": "agreed", "author": "carol"}) + "\n")
-
-# Define a table: DDL, glob pattern, and an extract function
-db = DirSQL(
-    root,
-    tables=[
-        Table(
-            ddl="CREATE TABLE comments (id TEXT, body TEXT, author TEXT)",
-            glob="comments/**/index.jsonl",
-            extract=lambda path, content: [
-                {
-                    "id": os.path.basename(os.path.dirname(path)),
-                    "body": row["body"],
-                    "author": row["author"],
-                }
-                for line in content.splitlines()
-                for row in [json.loads(line)]
-            ],
-        ),
-    ],
-)
-
-# Query with SQL
-results = db.query("SELECT * FROM comments WHERE author = 'alice'")
-# [{"id": "abc", "body": "looks good", "author": "alice"}]
+pnpm add dirsql
 ```
 
-## Multiple Tables and Joins
-
-```python
-db = DirSQL(
-    root,
-    tables=[
-        Table(
-            ddl="CREATE TABLE posts (title TEXT, author_id TEXT)",
-            glob="posts/*.json",
-            extract=lambda path, content: [json.loads(content)],
-        ),
-        Table(
-            ddl="CREATE TABLE authors (id TEXT, name TEXT)",
-            glob="authors/*.json",
-            extract=lambda path, content: [json.loads(content)],
-        ),
-    ],
-)
-
-results = db.query("""
-    SELECT posts.title, authors.name
-    FROM posts JOIN authors ON posts.author_id = authors.id
-""")
-```
-
-## Async API
-
-`AsyncDirSQL` wraps the synchronous API for use with asyncio. Initialization is awaitable, and `watch()` returns an async iterator of row-level change events.
+Requires a native build step (Rust toolchain). The native module is compiled during `pnpm build`.
 
-```python
-import asyncio
-import json
-import os
-from dirsql import AsyncDirSQL, Table
+## Usage
 
-async def main():
-    db = AsyncDirSQL(
-        "/path/to/data",
-        tables=[
-            Table(
-                ddl="CREATE TABLE items (name TEXT)",
-                glob="**/*.json",
-                extract=lambda path, content: [json.loads(content)],
-            ),
-        ],
-    )
-    await db.ready()  # wait for initial scan to complete
+```typescript
+import { DirSQL } from "dirsql";
 
-    # Query works the same way
-    results = await db.query("SELECT * FROM items")
+const db = new DirSQL("/path/to/directory", [
+  {
+    ddl: "CREATE TABLE users (name TEXT, age INTEGER)",
+    glob: "data/*.json",
+    extract: (filePath, content) => JSON.parse(content),
+  },
+]);
 
-    # Watch for file changes (insert/update/delete/error events)
-    async for event in db.watch():
-        print(f"{event.action} on {event.table}: {event.row}")
-        if event.action == "error":
-            print(f"  error: {event.error}")
-
-asyncio.run(main())
+const rows = db.query("SELECT * FROM users WHERE age > 25");
+console.log(rows);
 ```
 
-## Ignoring Files
-
-Pass `ignore` patterns to skip files during scanning and watching:
+## Building
 
-```python
-db = DirSQL(
-    root,
-    ignore=["**/drafts/**", "**/.git/**"],
-    tables=[...],
-)
+```bash
+pnpm install
+pnpm build
 ```
 
-## API Reference
-
-### `Table(*, ddl, glob, extract)`
-
-Defines how files map to a SQL table.
-
-- **`ddl`** (`str`): A `CREATE TABLE` statement defining the schema.
-- **`glob`** (`str`): A glob pattern matched against file paths relative to root.
-- **`extract`** (`Callable[[str, str], list[dict]]`): A function receiving `(relative_path, file_content)` and returning a list of row dicts. Each dict's keys must match the DDL column names.
-
-### `DirSQL(root, *, tables, ignore=None)`
-
-Creates an in-memory SQLite database indexed from the directory at `root`.
-
-- **`root`** (`str`): Path to the directory to index.
-- **`tables`** (`list[Table]`): Table definitions.
-- **`ignore`** (`list[str] | None`): Glob patterns for paths to skip.
-
-#### `DirSQL.query(sql) -> list[dict]`
-
-Execute a SQL query. Returns a list of dicts keyed by column name. Internal tracking columns (`_dirsql_*`) are excluded from results.
-
-### `AsyncDirSQL(root, *, tables, ignore=None)`
-
-Async wrapper. Constructor is sync (returns immediately). Call `await db.ready()` to wait for the initial scan.
-
-#### `await AsyncDirSQL.ready()`
-
-Wait for the initial scan to complete. Idempotent -- safe to call multiple times. Raises any exception that occurred during init.
-
-#### `await AsyncDirSQL.query(sql) -> list[dict]`
-
-Same as `DirSQL.query`, but async.
-
-#### `AsyncDirSQL.watch() -> AsyncIterator[RowEvent]`
-
-Returns an async iterator that yields `RowEvent` objects as files change on disk. Starts the filesystem watcher on first iteration.
-
-### `RowEvent`
-
-Emitted by `watch()` when a file change produces row-level diffs.
-
-- **`table`** (`str`): The affected table name.
-- **`action`** (`str`): One of `"insert"`, `"update"`, `"delete"`, `"error"`.
-- **`row`** (`dict | None`): The new row (for insert/update) or deleted row (for delete).
-- **`old_row`** (`dict | None`): The previous row (for update only).
-- **`error`** (`str | None`): Error message (for error events).
-- **`file_path`** (`str | None`): The relative file path that triggered the event.
-
-## How It Works
-
-The Rust core (`rusqlite` + `notify` + `walkdir`) does the heavy lifting:
-
-1. **Startup scan**: Walks the directory tree, matches files to tables via glob patterns, calls the user-provided `extract` function for each file, and inserts rows into an in-memory SQLite database.
-2. **File watching**: Uses the `notify` crate (inotify on Linux, FSEvents on macOS) to detect file creates, modifications, and deletions.
-3. **Row diffing**: When a file changes, the new rows are diffed against the previous rows for that file, producing granular insert/update/delete events.
-4. **Python bindings**: PyO3 exposes the Rust core as a native Python extension module. The async layer runs blocking operations in a thread pool via `asyncio.to_thread`.
-
-The SQLite database is purely ephemeral -- it exists only in memory and is discarded when the `DirSQL` instance is garbage collected. The filesystem is always the source of truth.
-
-## Development
-
-### Prerequisites
-
-- Rust (stable)
-- Python >= 3.12
-- [maturin](https://github.com/PyO3/maturin) for building the Python extension
-- [just](https://github.com/casey/just) as a task runner
-
-### Build and Test
+## Testing
 
 ```bash
-# Build the Python extension (dev mode)
-maturin develop
-
-# Run all CI checks
-just ci
-
-# Individual targets
-just test-rust        # Rust unit tests
-just test-integration # Python integration tests
-just clippy           # Rust lints
-just lint             # Python lints (ruff)
+pnpm test
 ```
 
 ## License

package/dist/index.d.ts

@@ -0,0 +1,105 @@
+/** Definition of a SQL-indexed table backed by files on disk. */
+export interface TableDef {
+    /** SQL DDL statement, e.g. `CREATE TABLE users (name TEXT, age INTEGER)`. */
+    ddl: string;
+    /** Glob pattern (relative to the DirSQL root) for files backing this table. */
+    glob: string;
+    /** Extract rows from a file's contents. Returns an array of row objects. */
+    extract: (filePath: string, content: string) => Record<string, unknown>[];
+    /** If true, reject rows with columns not declared in `ddl`. */
+    strict?: boolean;
+}
+/** A row-level event emitted by the file watcher. */
+export interface RowEvent {
+    table: string;
+    action: "insert" | "update" | "delete" | "error";
+    row?: Record<string, unknown> | null;
+    oldRow?: Record<string, unknown> | null;
+    error?: string | null;
+    filePath?: string | null;
+}
+interface NativeDirSQL {
+    query(sql: string): Record<string, unknown>[];
+    startWatcher(): void;
+    pollEvents(timeoutMs: number): RowEvent[];
+}
+interface NativeDirSQLConstructor {
+    new (root: string, tables: TableDef[], ignore?: string[]): NativeDirSQL;
+    fromConfig(configPath: string): NativeDirSQL;
+}
+interface CoreModule {
+    DirSQL: NativeDirSQLConstructor;
+}
+/**
+ * **Test-only.** Replace the core module used by the SDK with a fake.
+ *
+ * This is an internal escape hatch for unit tests that want to mock the
+ * napi-rs binding layer without loading the real native binary. Passing
+ * `null` resets to the default (lazy native load on next access). Not
+ * part of the public API; do not use in application code.
+ */
+export declare function __setCoreForTesting(fake: CoreModule | null): void;
+/**
+ * Ephemeral SQL index over a local directory.
+ *
+ * Constructing a `DirSQL` scans `root`, matches files against each
+ * {@link TableDef}'s `glob`, extracts rows via `extract`, and builds an
+ * in-memory SQLite database. `query` / `startWatcher` / `pollEvents`
+ * are synchronous; {@link ready} and {@link watch} expose the same
+ * surface in an async-idiomatic shape so TypeScript consumers don't
+ * need a separate `AsyncDirSQL` class.
+ *
+ * ```ts
+ * const db = new DirSQL(root, tables);
+ * await db.ready;
+ * const rows = db.query("SELECT ...");
+ * for await (const event of db.watch()) { ... }
+ * ```
+ */
+export declare class DirSQL {
+    /**
+     * Resolves once the initial directory scan has completed. Scanning
+     * runs synchronously inside the constructor, so this Promise is
+     * already resolved by the time the constructor returns; construction
+     * failures throw synchronously rather than surfacing here. Exposed
+     * as a Promise purely so consumers can write async-style code
+     * uniformly across SDKs.
+     */
+    readonly ready: Promise<void>;
+    private _inner;
+    constructor(root: string, tables: TableDef[], ignore?: string[]);
+    /**
+     * Load a {@link DirSQL} instance from a `.dirsql.toml` config file.
+     *
+     * The root directory is derived from the config file's parent. Tables
+     * are parsed using the built-in parser for each format declared in the
+     * config. No JS `extract` callback is required.
+     */
+    static fromConfig(configPath: string): DirSQL;
+    /** Execute a SQL query and return results as an array of row objects. */
+    query(sql: string): Record<string, unknown>[];
+    /**
+     * Start the file watcher. Must be called before {@link pollEvents}.
+     * Idempotent — safe to call multiple times.
+     */
+    startWatcher(): void;
+    /**
+     * Poll for file change events, blocking up to `timeoutMs` for the first
+     * event. Returns all events observed in the window (possibly empty).
+     */
+    pollEvents(timeoutMs: number): RowEvent[];
+    /**
+     * Watch for file change events as an async iterable.
+     *
+     * ```ts
+     * for await (const event of db.watch()) { ... }
+     * ```
+     *
+     * Starts the underlying watcher on first iteration, then polls in 200ms
+     * increments and yields each {@link RowEvent}. The iterator runs
+     * indefinitely; break out of the `for await` loop to stop.
+     */
+    watch(): AsyncGenerator<RowEvent, void, unknown>;
+}
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../ts/index.ts"],"names":[],"mappings":"AAgBA,iEAAiE;AACjE,MAAM,WAAW,QAAQ;IACvB,6EAA6E;IAC7E,GAAG,EAAE,MAAM,CAAC;IACZ,+EAA+E;IAC/E,IAAI,EAAE,MAAM,CAAC;IACb,4EAA4E;IAC5E,OAAO,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IAC1E,+DAA+D;IAC/D,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,qDAAqD;AACrD,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,QAAQ,GAAG,QAAQ,GAAG,QAAQ,GAAG,OAAO,CAAC;IACjD,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACxC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAGD,UAAU,YAAY;IACpB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IAC9C,YAAY,IAAI,IAAI,CAAC;IACrB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,QAAQ,EAAE,CAAC;CAC3C;AAED,UAAU,uBAAuB;IAC/B,KAAK,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,GAAG,YAAY,CAAC;IACxE,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,YAAY,CAAC;CAC9C;AAID,UAAU,UAAU;IAClB,MAAM,EAAE,uBAAuB,CAAC;CACjC;AAwBD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,GAAG,IAAI,CAEjE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,MAAM;IACjB;;;;;;;OAOG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAE9B,OAAO,CAAC,MAAM,CAAe;gBAEjB,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE;IAS/D;;;;;;OAMG;IACH,MAAM,CAAC,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;IAW7C,yEAAyE;IACzE,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE;IAI7C;;;OAGG;IACH,YAAY,IAAI,IAAI;IAIpB;;;OAGG;IACH,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,QAAQ,EAAE;IAIzC;;;;;;;;;;OAUG;IACI,KAAK,IAAI,cAAc,CAAC,QAAQ,EAAE,IAAI,EAAE,OAAO,CAAC;CASxD"}

package/dist/index.js

@@ -0,0 +1,129 @@
+"use strict";
+// dirsql TypeScript SDK.
+//
+// The public surface is implemented in Rust via napi-rs. `pnpm build` runs
+// `napi build` which produces `dirsql.node` at the package root, then
+// `tsc` compiles this file to `dist/index.js` + `dist/index.d.ts`, which
+// is what consumers import via the package's `main` / `types` / `exports`
+// fields.
+//
+// The native binary lives at the package root (not in `dist/`) because
+// that is where napi-rs writes it and where `napi prepublish` expects it.
+// We resolve it relative to this file's location at runtime so the
+// loader works whether the package is consumed via `node_modules/dirsql`
+// or via a pnpm workspace self-reference from `test/`.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DirSQL = void 0;
+exports.__setCoreForTesting = __setCoreForTesting;
+const node_path_1 = require("node:path");
+// Lazy-loaded reference to the core module. Populated on first access
+// by `loadNativeCore()`, or by `__setCoreForTesting()` for tests.
+let core = null;
+/**
+ * Load the native napi-rs binary. Resolved relative to this compiled
+ * module: after `tsc` emits to `dist/`, `__dirname` is `<pkg>/dist`, so
+ * `..` reaches the package root where napi-rs writes `dirsql.node`.
+ */
+function loadNativeCore() {
+    const bindingPath = (0, node_path_1.join)(__dirname, "..", "dirsql.node");
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    return require(bindingPath);
+}
+function getCore() {
+    if (core === null) {
+        core = loadNativeCore();
+    }
+    return core;
+}
+/**
+ * **Test-only.** Replace the core module used by the SDK with a fake.
+ *
+ * This is an internal escape hatch for unit tests that want to mock the
+ * napi-rs binding layer without loading the real native binary. Passing
+ * `null` resets to the default (lazy native load on next access). Not
+ * part of the public API; do not use in application code.
+ */
+function __setCoreForTesting(fake) {
+    core = fake;
+}
+/**
+ * Ephemeral SQL index over a local directory.
+ *
+ * Constructing a `DirSQL` scans `root`, matches files against each
+ * {@link TableDef}'s `glob`, extracts rows via `extract`, and builds an
+ * in-memory SQLite database. `query` / `startWatcher` / `pollEvents`
+ * are synchronous; {@link ready} and {@link watch} expose the same
+ * surface in an async-idiomatic shape so TypeScript consumers don't
+ * need a separate `AsyncDirSQL` class.
+ *
+ * ```ts
+ * const db = new DirSQL(root, tables);
+ * await db.ready;
+ * const rows = db.query("SELECT ...");
+ * for await (const event of db.watch()) { ... }
+ * ```
+ */
+class DirSQL {
+    constructor(root, tables, ignore) {
+        const Ctor = getCore().DirSQL;
+        this._inner =
+            ignore === undefined
+                ? new Ctor(root, tables)
+                : new Ctor(root, tables, ignore);
+        this.ready = Promise.resolve();
+    }
+    /**
+     * Load a {@link DirSQL} instance from a `.dirsql.toml` config file.
+     *
+     * The root directory is derived from the config file's parent. Tables
+     * are parsed using the built-in parser for each format declared in the
+     * config. No JS `extract` callback is required.
+     */
+    static fromConfig(configPath) {
+        const instance = Object.create(DirSQL.prototype);
+        const writable = instance;
+        writable._inner = getCore().DirSQL.fromConfig(configPath);
+        writable.ready = Promise.resolve();
+        return instance;
+    }
+    /** Execute a SQL query and return results as an array of row objects. */
+    query(sql) {
+        return this._inner.query(sql);
+    }
+    /**
+     * Start the file watcher. Must be called before {@link pollEvents}.
+     * Idempotent — safe to call multiple times.
+     */
+    startWatcher() {
+        this._inner.startWatcher();
+    }
+    /**
+     * Poll for file change events, blocking up to `timeoutMs` for the first
+     * event. Returns all events observed in the window (possibly empty).
+     */
+    pollEvents(timeoutMs) {
+        return this._inner.pollEvents(timeoutMs);
+    }
+    /**
+     * Watch for file change events as an async iterable.
+     *
+     * ```ts
+     * for await (const event of db.watch()) { ... }
+     * ```
+     *
+     * Starts the underlying watcher on first iteration, then polls in 200ms
+     * increments and yields each {@link RowEvent}. The iterator runs
+     * indefinitely; break out of the `for await` loop to stop.
+     */
+    async *watch() {
+        this._inner.startWatcher();
+        while (true) {
+            const events = this._inner.pollEvents(200);
+            for (const event of events) {
+                yield event;
+            }
+        }
+    }
+}
+exports.DirSQL = DirSQL;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../ts/index.ts"],"names":[],"mappings":";AAAA,yBAAyB;AACzB,EAAE;AACF,2EAA2E;AAC3E,sEAAsE;AACtE,yEAAyE;AACzE,0EAA0E;AAC1E,UAAU;AACV,EAAE;AACF,uEAAuE;AACvE,0EAA0E;AAC1E,mEAAmE;AACnE,yEAAyE;AACzE,uDAAuD;;;AA0EvD,kDAEC;AA1ED,yCAAiC;AA0CjC,sEAAsE;AACtE,kEAAkE;AAClE,IAAI,IAAI,GAAsB,IAAI,CAAC;AAEnC;;;;GAIG;AACH,SAAS,cAAc;IACrB,MAAM,WAAW,GAAG,IAAA,gBAAI,EAAC,SAAS,EAAE,IAAI,EAAE,aAAa,CAAC,CAAC;IACzD,iEAAiE;IACjE,OAAO,OAAO,CAAC,WAAW,CAAe,CAAC;AAC5C,CAAC;AAED,SAAS,OAAO;IACd,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;QAClB,IAAI,GAAG,cAAc,EAAE,CAAC;IAC1B,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,mBAAmB,CAAC,IAAuB;IACzD,IAAI,GAAG,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAa,MAAM;IAajB,YAAY,IAAY,EAAE,MAAkB,EAAE,MAAiB;QAC7D,MAAM,IAAI,GAAG,OAAO,EAAE,CAAC,MAAM,CAAC;QAC9B,IAAI,CAAC,MAAM;YACT,MAAM,KAAK,SAAS;gBAClB,CAAC,CAAC,IAAI,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC;gBACxB,CAAC,CAAC,IAAI,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;QACrC,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;IACjC,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,UAAU,CAAC,UAAkB;QAClC,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,CAAW,CAAC;QAC3D,MAAM,QAAQ,GAAG,QAGhB,CAAC;QACF,QAAQ,CAAC,MAAM,GAAG,OAAO,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;QAC1D,QAAQ,CAAC,KAAK,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;QACnC,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,yEAAyE;IACzE,KAAK,CAAC,GAAW;QACf,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAChC,CAAC;IAED;;;OAGG;IACH,YAAY;QACV,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC;IAC7B,CAAC;IAED;;;OAGG;IACH,UAAU,CAAC,SAAiB;QAC1B,OAAO,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;IAC3C,CAAC;IAED;;;;;;;;;;OAUG;IACH,KAAK,CAAC,CAAC,KAAK;QACV,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC;QAC3B,OAAO,IAAI,EAAE,CAAC;YACZ,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;YAC3C,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;gBAC3B,MAAM,KAAK,CAAC;YACd,CAAC;QACH,CAAC;IACH,CAAC;CACF;AAjFD,wBAiFC"}

package/package.json

@@ -1,8 +1,52 @@
 {
   "name": "dirsql",
-  "version": "0.0.21",
+  "version": "0.0.25",
   "description": "Ephemeral SQL index over a local directory",
   "license": "MIT",
   "repository": "https://github.com/thekevinscott/dirsql",
-  "main": "index.js"
-}
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/",
+    "dirsql.node"
+  ],
+  "napi": {
+    "binaryName": "dirsql",
+    "triples": {}
+  },
+  "scripts": {
+    "artifacts": "napi artifacts",
+    "build": "napi build --release && tsc",
+    "build:debug": "napi build && tsc",
+    "prepublishOnly": "napi prepublish -t npm",
+    "test": "vitest run",
+    "test:unit": "vitest run --dir src --passWithNoTests",
+    "test:integration": "vitest run --dir test --passWithNoTests",
+    "coverage": "vitest run --coverage",
+    "lint": "biome check .",
+    "lint:fix": "biome check --write .",
+    "format": "biome format --write .",
+    "format:check": "biome format ."
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.0",
+    "@napi-rs/cli": "^3.0.0",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.8.0",
+    "vitest": "^3.1.1",
+    "@vitest/coverage-v8": "^3.1.1"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "@biomejs/biome",
+      "esbuild"
+    ]
+  },
+  "optionalDependencies": {}
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Kevin Scott
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/index.js

@@ -1,5 +0,0 @@
-"use strict";
-
-module.exports = {
-  message: "dirsql TypeScript SDK is not yet implemented. See https://github.com/thekevinscott/dirsql for status.",
-};