dirsql 0.3.70 → 0.3.71

package/docs/reference/hooks.md

@@ -0,0 +1,141 @@
+# Command hooks
+
+Three [config keys](./config.md) run an external command: `on-file` (per
+`[[table]]`), and the server-wide `pre-query` and `post-query` (under
+`[dirsql]`; CLI server only). All three share one execution contract.
+
+## Execution contract
+
+### argv, not a shell
+
+The command string is split into an argv with shell-like quoting: whitespace
+separates arguments, and single or double quotes group them (so
+`sh -c 'grep foo {path} | sort'` keeps the quoted script as a single
+argument). **No shell is invoked** — there is no globbing, piping, `$VAR`
+expansion, or `&&`/`;` chaining. To get shell features, ask for a shell
+explicitly with `sh -c '…'`.
+
+A command that is empty, whitespace-only, or has unbalanced quotes is
+invalid (empty/whitespace commands are already rejected at
+[config parse time](./config.md#parse-errors)).
+
+### Placeholders
+
+A `{name}` in the command is substituted with its value, in every
+occurrence, within whole argv tokens, in a single left-to-right pass:
+
+- A substituted value is always exactly one argv element — a value
+  containing spaces, quotes, or shell metacharacters stays a single
+  argument. This makes untrusted input (file paths, request bodies)
+  injection-safe at the argv level.
+- Substituted values are never re-scanned: a value that itself contains
+  `{…}` is inert.
+- An unrecognized `{…}` is left literal.
+
+Which placeholders exist depends on the hook (see
+[per-hook contracts](#per-hook-contracts) below).
+
+### Working directory and environment
+
+The command runs in the **config file's directory**, so relative paths in
+the command resolve predictably regardless of where `dirsql` was launched.
+It inherits `dirsql`'s environment, so tools like `uvx --with …` / `npx …`
+resolve their dependencies as usual.
+
+### stdout protocol
+
+The command's result payload is the **last non-empty line of stdout**,
+trimmed. Any log or chatter lines above it are ignored. A command that
+exits successfully but prints no non-empty line is a failure ("produced no
+output on stdout").
+
+stderr is never data — it is captured only to enrich error messages (the
+last 2 000 characters are attached to failures).
+
+::: tip Print single-line output
+Because only the last non-empty line is the payload, multi-line output loses
+everything above the last line. `jq` users: pass `-c` so the JSON is emitted
+compactly on one line.
+:::
+
+### Timeout
+
+Every hook run is bounded by a **30-second** default timeout. A run
+exceeding it is killed and treated as a failure. One global config key
+raises (or tightens) the bound for **all** hooks:
+
+```toml
+[dirsql]
+hook-timeout = 300   # positive whole seconds
+```
+
+Zero and negative values are a config error.
+
+### Failure semantics
+
+A hook run fails when the command:
+
+- cannot be spawned (e.g. the program is not found),
+- exits non-zero (the exit code — or `signal`, if killed by one — and the
+  stderr tail are reported),
+- exceeds the timeout (killed; stderr tail reported),
+- exits zero but prints no non-empty stdout line,
+- or (per hook, below) prints output that does not parse as expected.
+
+What a failure *means* differs per hook:
+
+| Hook | On failure |
+|---|---|
+| `on-file` | **Per-file isolation.** The file contributes no rows; a one-line warning naming the file and error goes to stderr; the scan continues. One bad file never aborts the scan. |
+| `pre-query` | The request returns `500 Internal Server Error` with the command's stderr tail in the JSON `error` body. |
+| `post-query` | The request returns `500 Internal Server Error` with the command's stderr tail (or, for unparseable output, `post-query did not return valid JSON: <err>`) in the JSON `error` body. |
+
+## Per-hook contracts
+
+### `on-file`
+
+Runs once per file matched by the table's `glob`, at initial scan and on
+every watched change. The command reads the file itself and prints a JSON
+array of row objects; see [`[[table]]`](./config.md#table) for the
+row-mapping rules.
+
+| Placeholder | Value |
+|---|---|
+| `{path}` | The matched file's path **relative to the index root**. Appended automatically as a final argument when the command omits it, so `extract.py` and `extract.py {path}` behave identically. |
+| `{abspath}` | The matched file's absolute path. |
+| `{root}` | The index root directory. |
+
+### `pre-query`
+
+Runs once per `POST /query` request, before the query. The raw request body
+goes in; plain-text SQL comes out (the stdout payload line). `dirsql` runs
+that SQL and returns rows as usual. With no `pre-query` key, the body is
+parsed as `{"sql": …}` instead — see [HTTP API](./http-api.md#post-query).
+
+| Placeholder | Value |
+|---|---|
+| `{args}` | The raw `POST /query` request body, verbatim, as one argv token. |
+
+**The hook owns SQL safety.** The `{args}` substitution keeps the untrusted
+body inert *as an argv token*, but whatever SQL string the hook prints is
+executed as-is. Validate, escape, or parameterize inside the hook.
+
+### `post-query`
+
+Runs once per successful `POST /query`, after the query. The result rows
+are serialized to a JSON array and delivered two ways:
+
+- **On stdin** — always, unbounded. This is the recommended path.
+- **As `{args}`** — only when the serialized payload is ≤ **96 KiB**. Above
+  that, `{args}` is substituted with an **empty string** and a stderr
+  warning naming the byte size directs the operator to stdin. The full
+  payload is still on stdin — this is a fallback, not truncation.
+
+| Placeholder | Value |
+|---|---|
+| `{args}` | The result rows as a JSON array, as one argv token; emptied (with a stderr warning) when the payload exceeds 96 KiB. |
+
+The stdout payload line is parsed as JSON and returned verbatim as the
+`200 application/json` response body. A payload that is not valid JSON
+fails the request (`500`). With no `post-query` key, the bare row array is
+returned — see [HTTP API](./http-api.md#post-query).

package/docs/reference/http-api.md

@@ -0,0 +1,120 @@
+# HTTP API
+
+The [`dirsql` server](./cli.md#server-mode) (default `localhost:7117`)
+exposes two endpoints: `POST /query` and `GET /events`.
+
+## `POST /query`
+
+Run a read-only SQL query. Request body is JSON:
+
+```json
+{"sql": "SELECT title, author FROM posts WHERE draft = 0"}
+```
+
+The `200` response is a JSON array of row objects keyed by column name:
+
+```json
+[
+  {"title": "Hello World", "author": "alice"},
+  {"title": "Second Post", "author": "bob"}
+]
+```
+
+```bash
+curl -s http://localhost:7117/query \
+  -H 'content-type: application/json' \
+  -d '{"sql":"SELECT COUNT(*) AS n FROM files"}' \
+  | jq
+```
+
+### Value serialization
+
+| SQLite value | JSON |
+|---|---|
+| `NULL` | `null` |
+| `INTEGER` | number |
+| `REAL` | number; `NaN` / `±Infinity` become `null` |
+| `TEXT` | string |
+| `BLOB` | lowercase hex string (e.g. `"deadbeef"`) |
+
+Internal tracking columns (`_dirsql_file_path`, `_dirsql_row_index`) are
+excluded from `SELECT *` results.
+
+### Status codes
+
+| Status | When |
+|---|---|
+| `200` | Query succeeded. Body: array of row objects (or the [`post-query`](./hooks.md#post-query) hook's JSON). |
+| `400` | Malformed JSON body, missing or empty `sql` field, or a SQL error (syntax error, unknown table, or a statement SQLite classifies as a write — queries are read-only). |
+| `405` | `GET /query`. Plain-text body `method not allowed`. |
+| `408` | The query exceeded the 30-second per-query timeout. |
+| `500` | Internal server fault, or a failed [`pre-query`](./hooks.md#pre-query) / [`post-query`](./hooks.md#post-query) hook. |
+| `503` | The server is in [degraded mode](./cli.md#degraded-mode) (the config file exists but failed to load). |
+
+All error responses (except `405`) are `application/json`:
+
+```json
+{"error": "syntax error near \"SLECT\""}
+```
+
+### Hook interactions
+
+- With [`[dirsql].pre-query`](./config.md#dirsql-keys) configured, the
+  request body is **not** parsed as `{"sql": …}`; the raw body is passed to
+  the hook, which prints the SQL to run. Hook failure → `500`.
+- With [`[dirsql].post-query`](./config.md#dirsql-keys) configured, the
+  `200` body is whatever JSON the hook prints instead of the bare row
+  array. Hook failure or non-JSON output → `500`.
+
+## `GET /events`
+
+Opens a [Server-Sent Events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events)
+stream of row-change events.
+
+```bash
+curl -N http://localhost:7117/events
+```
+
+On open, the server emits a single `ready` frame signalling the
+subscription is attached. Every subsequent frame is named `row`:
+
+```
+event: ready
+data: {}
+
+event: row
+data: {"action":"insert","table":"posts","file_path":"posts/hello.json","row":{"title":"Hello World"},"old_row":null}
+```
+
+### Event payloads
+
+The `data:` payload is one JSON object per row-level change:
+
+| Field | `insert` | `update` | `delete` | `error` |
+|---|---|---|---|---|
+| `action` | `"insert"` | `"update"` | `"delete"` | `"error"` |
+| `table` | table name | table name | table name | table name, or `null` when the failure isn't tied to one table |
+| `file_path` | path relative to the root | same | same | same |
+| `row` | the new row | the new row | the deleted row | — (absent) |
+| `old_row` | `null` | the previous row | `null` | — (absent) |
+| `error` | — | — | — | message string |
+
+Row values serialize as in [`POST /query`](#value-serialization).
+
+### Stream semantics
+
+- **Errors do not terminate the stream.** A malformed file produces an
+  `error` event; the stream continues.
+- **Slow consumers skip, not crash.** A subscriber that lags behind the
+  event buffer silently misses the overflowed events and keeps receiving
+  new ones.
+- The server sends periodic SSE keep-alive comments.
+- The stream closes when the server shuts down.
+
+### Status codes
+
+| Status | When |
+|---|---|
+| `200` | Stream opened (`text/event-stream`). |
+| `405` | `POST /events`. Plain-text body `method not allowed`. |
+| `503` | The server is in [degraded mode](./cli.md#degraded-mode). JSON `{"error": …}` body. |

package/docs/reference/sdk.md

@@ -0,0 +1,357 @@
+# SDK
+
+`dirsql` ships as a library for Python (PyPI: `dirsql`), TypeScript (npm:
+`dirsql`), and Rust (crates.io: `dirsql`). All three are thin bindings over
+one shared Rust core, so behavior is identical; only the calling conventions
+differ.
+
+## Install
+
+::: code-group
+
+```bash [Python]
+uv add dirsql
+```
+
+```bash [TypeScript]
+pnpm add dirsql
+```
+
+```bash [Rust]
+cargo add dirsql
+```
+
+:::
+
+## Import
+
+::: code-group
+
+```python [Python]
+from dirsql import DirSQL, Table, RowEvent
+```
+
+```typescript [TypeScript]
+import { DirSQL, Table } from "dirsql";
+import type { TableDef, RowEvent, ExtensionSpec, DirSQLOptions } from "dirsql";
+```
+
+```rust [Rust]
+use dirsql::{DirSQL, AsyncDirSQL, Table, Row, RowEvent, Value, Extension, DirSqlError};
+```
+
+:::
+
+## `DirSQL`
+
+### Constructor
+
+::: code-group
+
+```python [Python]
+DirSQL(
+    root: str | None = None,
+    *,
+    tables: list[Table] | None = None,
+    ignore: list[str] | None = None,
+    config: str | None = None,
+    persist: bool = False,
+    persist_path: str | None = None,
+    extensions: list[dict] | None = None,  # [{ "path": str, "entrypoint"?: str }]
+)
+```
+
+```typescript [TypeScript]
+new DirSQL(configPath: string)
+// or
+new DirSQL({
+    root?: string,
+    tables?: TableDef[],
+    ignore?: string[],
+    config?: string,
+    persist?: boolean,
+    persistPath?: string,
+    extensions?: ExtensionSpec[],  // [{ path: string, entrypoint?: string }]
+})
+```
+
+```rust [Rust]
+DirSQL::builder()
+    .root(root)                     // optional
+    .tables(tables)                 // optional; append one with .table(t)
+    .ignore(patterns)               // optional
+    .config(config_toml_path)       // optional
+    .persist(true)                  // optional; default false
+    .persist_path(path)             // optional
+    .extensions(extensions)         // optional; append one with .extension(e)
+    .poll_interval(duration)        // optional; watch-loop cadence, default 200ms
+    .build()                        // -> Result<DirSQL>  (synchronous scan)
+// Shortcuts: DirSQL::new(root, tables), DirSQL::with_ignore(root, tables, ignore),
+//            DirSQL::from_config(root), DirSQL::from_config_path(path)
+```
+
+:::
+
+Creates a SQLite index over a directory. At least one of `root` or `config`
+must be supplied; with neither, construction fails with a "no root
+directory" error.
+
+**Parameters:**
+
+- `root` — Directory to index. Optional if `config` is supplied.
+- `tables` — Programmatic [`Table`](#table) definitions.
+- `ignore` — Glob patterns matched against root-relative paths; matched
+  files are skipped entirely (scan and watch).
+- `config` — Path to a [`.dirsql.toml`](./config.md). Its `[[table]]`
+  entries are appended after any programmatic `tables`; its `ignore`
+  patterns and `[[dirsql.extension]]` entries are appended likewise; its
+  `[dirsql].root` supplies the root when no explicit `root` is passed.
+  When both an explicit `root` and a config root are present, the explicit
+  value wins and a warning is emitted on stderr.
+- `persist` — Keep the SQLite index on disk between runs (default off:
+  ephemeral, rebuilt every startup). The cache lives at
+  `<root>/.dirsql/cache.db` by default; on restart, only files whose stat
+  changed are re-parsed. `persist = true` in the config also enables it.
+- `persist_path` / `persistPath` — Override the cache location. An
+  explicit value wins over the config's `persist_path`. Ignored when
+  persistence is off. (Config-file values resolve relative to the config's
+  parent directory; constructor values are used as given.)
+- `extensions` — SQLite extensions to load at startup, before any table
+  DDL (enable → load → disable, so SQL `load_extension()` is never
+  exposed). Each entry pairs a shared-library `path` with an optional
+  `entrypoint` init symbol. In Python and TypeScript, `path` may be a bare
+  **package name**, resolved from the installed package (`importlib` /
+  `node_modules`) — for both the programmatic list and a `config` file's
+  `[[dirsql.extension]]` entries. The Rust SDK is file-path-only.
+  Programmatic entries load first, then the config's. A relative
+  programmatic path is used verbatim (resolved by the OS against the
+  process working directory); config-file paths resolve against the config
+  file's parent.
+
+**Construction is asynchronous in Python and TypeScript.** The constructor
+returns immediately and the initial scan runs in the background; `query`
+and the other methods transparently await [readiness](#ready). In Rust,
+`.build()` scans synchronously; use `.build_async()` → [`AsyncDirSQL`](#asyncdirsql-rust)
+for the non-blocking equivalent.
+
+::: details Rust builder extras
+- `Table` appears in the builder via `.table(t)` (append) or `.tables(v)`
+  (replace).
+- `.poll_interval(Duration)` sets the channel-based `watch()` loop's poll
+  cadence (default 200 ms): lower values give tighter event latency at
+  higher idle CPU.
+- `.suppress_config_extensions(true)` skips loading the config file's own
+  `[[dirsql.extension]]` entries. Launcher plumbing (used with
+  pre-resolved `.extensions(...)`); not needed in application code.
+- `Extension { path: PathBuf, entrypoint: Option<String> }` is the
+  extension spec type.
+:::
+
+### `ready`
+
+::: code-group
+
+```python [Python]
+await db.ready() -> None
+```
+
+```typescript [TypeScript]
+await db.ready  // awaitable property
+```
+
+```rust [Rust]
+// AsyncDirSQL only; DirSQL::build() is already complete when it returns.
+db.ready().await -> Result<()>
+```
+
+:::
+
+Waits for the initial scan to complete, re-raising any construction error.
+Safe to call multiple times. In Python and TypeScript every other method
+awaits readiness internally, so an explicit `ready` is only needed to
+observe construction errors before issuing a query.
+
+### `query`
+
+::: code-group
+
+```python [Python]
+await db.query(sql: str) -> list[dict]
+```
+
+```typescript [TypeScript]
+await db.query(sql: string) -> Record<string, unknown>[]
+// Runs on the libuv threadpool; the JS event loop stays responsive.
+```
+
+```rust [Rust]
+db.query(sql: &str) -> Result<Vec<Row>>   // Row = HashMap<String, Value>
+```
+
+:::
+
+Executes a SQL query and returns rows keyed by column name.
+
+- **Read-only.** Each statement is classified by SQLite itself
+  (`sqlite3_stmt_readonly`); anything classified as a write — `INSERT`,
+  `UPDATE`, `DELETE`, `DROP`, `CREATE`, `ALTER`, `VACUUM`, … — is rejected
+  before producing rows. Rust surfaces this as
+  `DirSqlError::WriteForbidden`; Python raises a `RuntimeError` and
+  TypeScript rejects with an `Error` carrying a "read-only" message.
+- Internal tracking columns (`_dirsql_file_path`, `_dirsql_row_index`) are
+  excluded from `SELECT *` results; name them explicitly to see them.
+- SQLite values map back to language types:
+
+| SQLite | Python | TypeScript | Rust |
+|---|---|---|---|
+| TEXT | `str` | `string` | `Value::Text` |
+| INTEGER | `int` | `number` | `Value::Integer` |
+| REAL | `float` | `number` | `Value::Real` |
+| BLOB | `bytes` | `Buffer` | `Value::Blob` |
+| NULL | `None` | `null` | `Value::Null` |
+
+### `watch`
+
+::: code-group
+
+```python [Python]
+async for event in db.watch():   # AsyncIterator[RowEvent]
+    ...
+```
+
+```typescript [TypeScript]
+for await (const event of db.watch()) {   // AsyncIterable<RowEvent>
+    ...
+}
+```
+
+```rust [Rust]
+use futures::StreamExt;
+let mut stream = db.watch()?;   // WatchStream: impl Stream<Item = RowEvent>
+while let Some(event) = stream.next().await { ... }
+```
+
+:::
+
+Returns a stream of [`RowEvent`](#rowevent)s reflecting filesystem changes
+under the root. The watcher starts on first iteration (Python/TypeScript)
+or at the `watch()` call (Rust). The stream never terminates on its own;
+stop consuming it to stop.
+
+Rust: `watch()` may be called once per instance and is mutually exclusive
+with the polling API below — mixing them returns an error, since both drain
+the same underlying filesystem watcher.
+
+### Low-level watch primitives
+
+::: code-group
+
+```typescript [TypeScript]
+await db.startWatcher()               // idempotent; must precede pollEvents
+await db.pollEvents(timeoutMs) -> RowEvent[]
+```
+
+```rust [Rust]
+db.start_watching() -> Result<()>     // idempotent; implied by poll_events/watch
+db.poll_events(timeout: Duration) -> Result<Vec<RowEvent>>
+```
+
+:::
+
+`pollEvents` / `poll_events` blocks up to the timeout for the first event,
+then drains everything that arrived, applies it to the database, and
+returns the batch (possibly empty). Safe to call in a loop. TypeScript runs
+the poll on the libuv threadpool. Python does not expose public polling
+primitives — use `watch()`.
+
+## `AsyncDirSQL` (Rust)
+
+Rust's non-blocking wrapper: the constructor returns immediately while the
+scan runs on a background thread. Python and TypeScript need no equivalent —
+their `DirSQL` is already async-by-default.
+
+```rust
+let db = DirSQL::builder().root("./data").tables(tables).build_async()?; // -> AsyncDirSQL
+db.ready().await?;                        // required before use
+let rows = db.query("SELECT ...").await?; // spawn_blocking under the hood
+let stream = db.watch()?;                 // same WatchStream as DirSQL
+let sync: DirSQL = db.sync()?;            // unwrap the inner sync handle
+```
+
+Shortcuts mirror `DirSQL`: `AsyncDirSQL::new`, `with_ignore`,
+`from_config`, `from_config_path`. Unlike the Python/TypeScript SDKs,
+methods called before `ready().await` completes return a "not ready" error
+rather than waiting — an intentional, language-idiomatic difference.
+
+## `Table`
+
+::: code-group
+
+```python [Python]
+Table(*, ddl: str, glob: str, extract: Callable[[str], list[dict]], strict: bool = False)
+```
+
+```typescript [TypeScript]
+new Table({ ddl, glob, extract, strict? })
+// or a plain object — TableDef and Table are interchangeable:
+{ ddl: string, glob: string, extract: (path: string) => Record<string, unknown>[], strict?: boolean }
+```
+
+```rust [Rust]
+Table::new(ddl, glob, extract)      // extract: Fn(&str) -> Vec<Row>, infallible
+Table::try_new(ddl, glob, extract)  // extract: Fn(&str) -> Result<Vec<Row>, _>
+Table::strict(ddl, glob, extract)   // Table::new with strict = true
+```
+
+:::
+
+Maps files to table rows.
+
+- `ddl` — A SQLite `CREATE TABLE` statement; the table name is parsed from
+  it. Table names must be unique across all tables.
+- `glob` — Glob pattern matched against root-relative paths. May contain
+  `{name}` [captures](./columns.md#glob-captures).
+- `extract` — Callback receiving the matched file's full path (the root
+  joined with the file's relative path — absolute when `root` is absolute)
+  and returning the rows that file contributes. `dirsql` never reads file
+  contents itself; a callback that needs the body reads the path. Return
+  an empty list to skip a file. [Virtual columns and glob
+  captures](./columns.md) are merged onto each returned row; values the
+  callback emits win over same-named facts.
+- `strict` — Default off: extra row keys are dropped and missing declared
+  columns become `NULL`. When on, any extra or missing key is an error
+  (see [`strict`](./config.md#table)).
+
+Readable attributes: `ddl`, `glob` (all SDKs), plus `strict`.
+
+## `RowEvent`
+
+Emitted by [`watch`](#watch) and the polling primitives; one event per
+row-level change caused by a filesystem event.
+
+| Field | Python | Rust | TypeScript |
+|---|---|---|---|
+| Action | `action: str` | enum variant (`Insert` / `Update` / `Delete` / `Error`) | `action: string` |
+| Table | `table: str \| None` | `table: String` (`Option<String>` on `Error`) | `table: string \| null` |
+| New/current row | `row: dict \| None` | `row` / `new_row` on the variant | `row?: Record \| null` |
+| Previous row | `old_row: dict \| None` | `old_row` on `Update` | `oldRow?: Record \| null` |
+| Error message | `error: str \| None` | `error: String` on `Error` | `error?: string \| null` |
+| File path | `file_path: str \| None` | `file_path` (`String`; `PathBuf` on `Error`) | `filePath?: string \| null` |
+
+Actions: `insert` (new row; no previous), `update` (row changed in place;
+carries both old and new), `delete` (row removed), `error` (an extraction
+or watch failure — carries `error`, never `row`/`old_row`; `table` is
+`None`/`null` when the failure isn't tied to one table). `file_path` is
+relative to the root. Errors never terminate the stream.
+
+## Value types
+
+An `extract` callback (and the SQLite columns it feeds) accepts:
+
+| SQLite column | Python value | TypeScript value | Rust `Value` |
+|---|---|---|---|
+| TEXT | `str` | `string` | `Value::Text(String)` |
+| INTEGER | `int`, `bool` | `number`, `boolean` | `Value::Integer(i64)` |
+| REAL | `float` | `number` | `Value::Real(f64)` |
+| BLOB | `bytes` | `Buffer` / `Uint8Array` | `Value::Blob(Vec<u8>)` |
+| NULL | `None` | `null` | `Value::Null` |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dirsql",
-  "version": "0.3.70",
+  "version": "0.3.71",
   "description": "Ephemeral SQL index over a local directory",
   "license": "MIT",
   "repository": "https://github.com/thekevinscott/dirsql",
@@ -230,15 +230,15 @@
     ]
   },
   "optionalDependencies": {
-    "@dirsql/lib-linux-x64-gnu": "0.3.70",
-    "@dirsql/lib-linux-arm64-gnu": "0.3.70",
-    "@dirsql/lib-darwin-x64": "0.3.70",
-    "@dirsql/lib-darwin-arm64": "0.3.70",
-    "@dirsql/lib-win32-x64-msvc": "0.3.70",
-    "@dirsql/cli-linux-x64-gnu": "0.3.70",
-    "@dirsql/cli-linux-arm64-gnu": "0.3.70",
-    "@dirsql/cli-darwin-x64": "0.3.70",
-    "@dirsql/cli-darwin-arm64": "0.3.70",
-    "@dirsql/cli-win32-x64-msvc": "0.3.70"
+    "@dirsql/lib-linux-x64-gnu": "0.3.71",
+    "@dirsql/lib-linux-arm64-gnu": "0.3.71",
+    "@dirsql/lib-darwin-x64": "0.3.71",
+    "@dirsql/lib-darwin-arm64": "0.3.71",
+    "@dirsql/lib-win32-x64-msvc": "0.3.71",
+    "@dirsql/cli-linux-x64-gnu": "0.3.71",
+    "@dirsql/cli-linux-arm64-gnu": "0.3.71",
+    "@dirsql/cli-darwin-x64": "0.3.71",
+    "@dirsql/cli-darwin-arm64": "0.3.71",
+    "@dirsql/cli-win32-x64-msvc": "0.3.71"
   }
 }