jevctl 0.1.0 → 0.2.0

package/docs/guidelines.md

@@ -0,0 +1,19 @@
+# Guidelines for good results
+
+**Write claims as single, checkable statements.** "The API returns JSON and supports pagination" is two claims. Split them so each gets its own verdict.
+
+**Give the model everything it needs, and only that.** Evidence should contain the passages the claims depend on. Very long, unrelated evidence dilutes accuracy and costs more. For quote-level checks, locate the passage in code first.
+
+**Put domain rules in descriptions.** For `classify`, `route`, and `ask --choice`, the option descriptions are where your rules go, not the label names. Always include an escape option (`--other`, `none`) unless every input is known to fit.
+
+**Treat thresholds as starting points.** The defaults (`0.8` auto-accept, `0.75` block, `0.25` review, `0.7`/`0.35` exists, `0.6` min confidence) come from TypeSafe's published cookbooks. Run `jev` over a sample of your own data with `--json`, look at the distributions, and set thresholds that match the cost of a wrong answer. Then pin a model version with `-m jev-1.13.0` so an alias update does not silently shift results.
+
+**Read confidence correctly.** For `choice` and `score` answers, confidence measures how concentrated the distribution is. Low confidence means the options were close, not that the model is wrong; look at `probabilities` before deciding. `noul` answers carry no separate confidence; a value near `0.5` means "as likely yes as no".
+
+**Keep policy in your code.** `jev` reports judgments. Whether to block, retry, escalate, or ignore is your decision, expressed through `--fail-on` or by reading the JSON.
+
+**Mind what you send.** Everything you pass goes to the configured provider. Do not include secrets or data you are not permitted to share. `--dry-run` shows the exact payload.
+
+**Batch.** Several questions in one `ask` call, or many rows through `batch`, cost less and finish sooner than separate calls. Only input tokens are billed; the usage footer shows them.
+
+**Prefer direct TypeSafe.** Proxies add latency and lag behind on model versions.

package/docs/library.md

@@ -0,0 +1,41 @@
+# Use from Node.js
+
+The same functions the CLI uses are exported from the `jevctl` package, so you can embed judgments in a script without shelling out.
+
+```ts
+import { createAsk, runVerify, runScreen, runClassify, runCompact } from "jevctl";
+
+const ask = createAsk({ provider: "auto", model: "jev-latest", timeoutMs: 30_000 });
+
+const verdicts = await runVerify(ask, {
+  claims: ["The ordinance mentions reflective gear."],
+  evidence: [{ id: "ordinance", text: ordinanceText }],
+  autoAccept: 0.8,
+});
+console.log(verdicts.results[0].verdict, verdicts.results[0].confidence);
+
+const screened = await runScreen(ask, { text: pageHtml, purpose: "extract prices", blockAt: 0.75, reviewAt: 0.25 });
+if (screened.recommendation.action === "block") throw new Error(screened.recommendation.reason);
+
+const label = await runClassify(ask, {
+  text: ticket,
+  labels: [{ label: "billing", description: null }, { label: "technical", description: null }],
+  other: true,
+  minConfidence: 0.6,
+});
+```
+
+Every `run*` function takes an `AskFn` first. `createAsk` builds one from the environment (or from stored credentials via `withStoredCredentials`); in tests, pass your own `async (state, questions) => ({ answers, usage, provider, model })`.
+
+| Export | From |
+| --- | --- |
+| `runVerify`, `runScreen`, `runFind`, `runAsk`, `runClassify`, `runClassifyMulti`, `runClassifyTaxonomy`, `runExtract`, `runRerank`, `runMatch`, `runRoute`, `runCompact` | `core/*` |
+| `build*Request` | The exact `state` and `questions` a command would send |
+| `parseRows`, `runBatch` | Row parsing and the concurrency pool |
+| `parseTranscript` | Claude Code session log or messages JSON to `Message[]` |
+| `createAsk`, `resolveProvider`, `providerModel` | Providers |
+| `resolveConfig`, `configPath` | Configuration |
+| `resolveStore`, `withStoredCredentials` | Stored credentials |
+| `compaction` | The vendored compaction library namespace |
+
+Types are included. The package is ESM only.

package/docs/match.md

@@ -0,0 +1,52 @@
+# jev match
+
+Decide whether pairs of records describe the same thing: `same`, `different`, or `unclear`.
+
+```bash
+jev match (--pairs <ref> | --left <ref> --right <ref> | --dedupe <ref>) [--kind <text>] [options]
+```
+
+## When to use
+
+Dedupe a contact export, align your catalog with a supplier's, merge duplicate issues. One Score per pair has three levels that map to actions: leave unlinked, send to a person, merge. The decision is the most likely level, so there is no threshold to tune.
+
+## Options
+
+| Option | Meaning |
+| --- | --- |
+| `-p, --pairs <ref>` | JSON: `[["a","b"], ...]` or `[{"left": ..., "right": ...}]`. Items are strings or `{id, text}`. |
+| `--left <ref> --right <ref>` | Two JSON item lists; every left item is compared with every right item |
+| `-d, --dedupe <ref>` | One JSON item list; every pair within it is compared |
+| `-k, --kind <text>` | What the records are, e.g. `"customer contacts"`. Sharpens the question. |
+| `--fail-on <list>` | Exit 2 when any pair is `same`, `unclear`, or `different` |
+
+Limit: 200 pairs per call, sent in groups of 50. For large sets, block first (by postcode, name prefix, category) and match within blocks.
+
+## Output
+
+`results[]` with `left`, `right` (ids), `left_text`, `right_text`, `decision`, `confidence`, `probabilities` (`different`, `unclear`, `same`); `summary` counts.
+
+`unclear` is a real outcome meaning a person should look, not a weak `same`.
+
+## Example
+
+```bash
+jev match --dedupe @contacts.json --kind "customer contacts"
+```
+
+```text
+Decision   Conf  Left    Right
+---------  ----  ------  ------
+same       0.91  c_1042  c_2210
+unclear    0.48  c_1042  c_3187
+different  0.97  c_2210  c_3187
+
+1 same · 1 unclear · 1 different
+```
+
+```bash
+# Only the pairs a human should check
+jev match --dedupe @contacts.json --json | jq -r '.results[] | select(.decision=="unclear") | "\(.left) ~ \(.right)"'
+```
+
+Pattern: [entity alignment cookbook](https://docs.typesafe.ai/cookbooks/entity_alignment).

package/docs/output.md

@@ -0,0 +1,65 @@
+# Output formats
+
+Every command renders the same result in six formats. Pick one with `--format`, or the shortcuts `--json` and `--md`. Set a default with `JEV_FORMAT` or `jev config set format <name>`.
+
+| Format | What you get | Use it for |
+| --- | --- | --- |
+| `text` (default) | A padded table or short lines, colored on a terminal | Reading at the prompt |
+| `json` | The full result, pretty-printed | Scripts, `jq` |
+| `jsonl` | The full result on one line | Log pipelines, appending to files |
+| `md` | GitHub-flavored Markdown: a table, or a field/value table for single answers | PR comments, `$GITHUB_STEP_SUMMARY`, chat |
+| `csv` | The table only, RFC 4180 quoting | Spreadsheets |
+| `tsv` | The table only, tab separated | `cut`, `awk` |
+
+`--json` and `--format json` are the same. `--md` and `--format md` are the same.
+
+## Rules that apply to all formats
+
+- `-q` removes the token usage footer from `text` and `md`. Other formats never include it.
+- `--no-color` or `NO_COLOR=1` removes color from `text`. Other formats never include it.
+- Exit codes do not depend on the format. `jev screen ... --md` still exits 2 on `block`.
+- `csv` and `tsv` need something tabular. Commands whose result is a single answer (`classify` single mode, `route`, `screen`, `ask`) emit `field,value` rows instead. `compact` with nothing to decide, and `auth login`, have no table; use `--json` or `--pluck` there.
+- `--dry-run` always prints JSON.
+
+## --pluck: one value out
+
+`--pluck <path>` prints a single value from the JSON result instead of the whole thing. Paths use dots, `[n]` for an index, and `[]` to map over an array (one line per element).
+
+```bash
+jev classify @t.txt -l bug,feature --pluck label                 # bug
+jev verify a b -e @spec.md --pluck results[].verdict             # one verdict per line
+jev extract @inv.txt --want amount --pluck fields.amount.normalized.value
+jev route "$msg" -H refund,cancel --pluck handler --fail-on unrouted && echo routed
+```
+
+Scalars print raw, arrays print one element per line, objects print as compact JSON. Combine with `--json` to get the plucked value as pretty JSON. Exit codes are unchanged, so `--pluck` works inside `$(...)` and `if`. A path that matches nothing is an error (exit 1) so a typo cannot read as an empty value; `batch` rows are the exception and print an empty line.
+
+## batch
+
+`jev batch` streams one JSON record per row by default (that is its `text` and `jsonl` behavior).
+
+| Flag | Effect |
+| --- | --- |
+| `--format json` | Collect all records into one JSON array at the end |
+| `--format md`, `csv`, `tsv` | A summary table with `id`, `ok`, `failed`, and a one-cell `result` (label, handler, action, verdicts, extracted values, ...) |
+| `--pluck <path>` | One value per row, e.g. `--pluck result.label` |
+
+## Examples
+
+Post a verification report into a GitHub Actions job summary:
+
+```bash
+jev verify --claims @claims.txt -e @spec.md --md --fail-on none >> "$GITHUB_STEP_SUMMARY"
+```
+
+Feed match decisions into a spreadsheet:
+
+```bash
+jev match --dedupe @contacts.json --format csv > pairs.csv
+```
+
+Use a single field in a shell condition:
+
+```bash
+if [ "$(jev screen @page.html --pluck recommendation.action)" = "pass" ]; then …; fi
+```

package/docs/recipes.md

@@ -0,0 +1,78 @@
+# Recipes
+
+Copy, adjust thresholds, ship.
+
+## Gate a pull request on its own description
+
+One claim per line in `claims.txt`, checked against the diff:
+
+```bash
+git diff origin/main...HEAD | jev verify --claims @claims.txt --evidence - --fail-on contradicted,unsupported
+```
+
+## Guard an agent's web fetches
+
+```bash
+page=$(curl -s "$url")
+if printf '%s' "$page" | jev screen --purpose "$task" --fail-on block,review,skip -q; then
+  printf '%s' "$page" | my-agent --context -
+fi
+```
+
+## Route a support ticket in a shell script
+
+```bash
+team=$(jev classify @ticket.txt -l billing,technical,sales --other --json | jq -r .label)
+```
+
+## Label a whole backlog, flag the uncertain ones
+
+```bash
+jev batch classify -i @issues.jsonl -o labeled.jsonl -- -l bug,feature,question,docs --other --fail-on review
+jq -r 'select(.failed) | .id' labeled.jsonl
+```
+
+## Pull fields from every email in a folder
+
+```bash
+for f in inbox/*.eml; do jq -n --arg id "$f" --arg text "$(cat "$f")" '{id:$id,text:$text}'; done \
+  | jev batch extract -i - -- --want sender=email:the sender --want reply_by=date:the reply deadline --want amount
+```
+
+## Rerank search results before answering from them
+
+```bash
+my-search "$q" --json | jev rerank "$q" -c - --min 0.6 --json | jq '.kept'
+```
+
+## Dedupe a contact export, review only the unclear pairs
+
+```bash
+jev match --dedupe @contacts.json --kind "customer contacts" --json \
+  | jq -r '.results[] | select(.decision=="unclear") | "\(.left) ~ \(.right)"' > needs-review.txt
+```
+
+## Route chat messages to typed handlers in a bot
+
+```bash
+jev route "$message" --handlers-json @handlers.json --fail-on unrouted --json | jq '{handler, args}'
+```
+
+## Find the right file, then open it
+
+```bash
+jev find "where is retry logic configured" --files src/**/*.ts --json | jq -r '.top[0].id' | xargs code
+```
+
+## Check that a knowledge base actually answers a question
+
+```bash
+jev find "$question" --lines @faq.txt --fail-on absent,partial --json
+```
+
+## Compact a Claude Code session offline and inspect what would go
+
+```bash
+jev compact @~/.claude/projects/-Users-me-repo/$SESSION.jsonl --json \
+  | jq '.decisions[] | select(.action != "keep") | {id, tool, action}'
+```

package/docs/rerank.md

@@ -0,0 +1,44 @@
+# jev rerank
+
+Score every candidate's relevance to a query independently, then sort. Several can be relevant, or none.
+
+```bash
+jev rerank <query> (--files <paths...> | --candidates <ref> | --lines <ref>) [options]
+```
+
+## When to use
+
+In front of any search: take the top 30 from BM25 or a vector index, keep what Jev says is relevant. The cookbook shows top-1 accuracy rising from 5% to 18% with one judgment per pair. Where [`find`](find.md) asks "which one is best", `rerank` asks "is this one relevant" for each.
+
+## Options
+
+| Option | Meaning | Default |
+| --- | --- | --- |
+| `<query>` | What results should be relevant to | required |
+| `-f/-c/-l` | Candidates, same forms as `find` | |
+| `-k, --top-k <n>` | How many ranked results to return | `10` |
+| `--min <p>` | Relevance at or above which a candidate is `kept` | `0.5` |
+| `--criteria <text>` | What counts as relevant, e.g. `"a passage stating the rule, not commentary"` | |
+| `--fail-on <list>` | Exit 2 on `empty` (nothing kept) | `none` |
+
+## Output
+
+`ranked[]` with `id`, `relevance`, `kept`, `text`; `kept[]` ids. Up to 250 candidates per call.
+
+## Example
+
+```bash
+my-search "$q" --json | jev rerank "$q" -c - --min 0.6 --json | jq '.kept'
+```
+
+```text
+2 of 5 shown are relevant (min 0.6)  statute of limitations for contract claims
+
+#  Rel        Id    Text
+-  ----  ----  ----  ------------------------------------------------------------
+1  0.94  keep  p17   An action for breach of a written contract must be brought…
+2  0.71  keep  p03   The limitations period begins when the breach occurs…
+3  0.22  drop  p09   Courts have discussed equitable tolling in other contexts…
+```
+
+Pattern: [reranking cookbook](https://docs.typesafe.ai/cookbooks/rerank_typesafe).

package/docs/route.md

@@ -0,0 +1,57 @@
+# jev route
+
+Pick a handler for a request and fill that handler's arguments from closed sets, in one call.
+
+```bash
+jev route [request] (--handlers <list> | --handlers-json <ref>) [options]
+```
+
+## When to use
+
+Turn free text into a typed call: a chat message into a bot command, a support request into a queue plus fields, a voice transcript into an action. Argument questions for every handler are asked in the same request; only the chosen handler's answers come back. A `none` handler is always available so the model can decline.
+
+## Options
+
+| Option | Meaning | Default |
+| --- | --- | --- |
+| `[request]` | Text, `@file`, or `-` | stdin |
+| `-H, --handlers <list>` | Handlers without arguments: `refund:money back,cancel:stop an order,support` | |
+| `--handlers-json <ref>` | Handlers with arguments, see below | |
+| `-i, --instructions <text>` | Replace the default routing question | |
+| `--min-confidence <p>` | Below this confidence the route is `review` | `0.6` |
+| `--state-json` | Parse the request as JSON | |
+| `--fail-on <list>` | Exit 2 on `review` or `unrouted` (no handler fits) | `none` |
+
+## Handlers JSON
+
+Each value is a description string, `null`, or `{"description", "args"}`. Each arg is one of:
+
+```json
+{"type": "choice", "options": ["full", "partial"]}
+{"type": "choice", "options": {"full": "entire order", "partial": "some items"}, "instructions": "optional"}
+{"type": "noul",   "instructions": "Does the customer need this immediately?"}
+{"type": "score",  "levels": ["calm", "annoyed", "furious"]}
+```
+
+## Output
+
+`handler` (or `null`), `confidence`, `action` (`auto`, `review`, `none`), `probabilities` over handlers, and `args` with a typed `value` per argument (`null` when the request does not say).
+
+## Example
+
+```bash
+jev route "cancel order 4411 and refund the whole thing, today please" --handlers-json @handlers.json
+```
+
+```text
+refund  conf 0.87  auto
+[refund 0.90, cancel 0.08, support 0.01, none 0.01]
+  scope = full  conf 0.93
+  urgent = yes  p 0.88
+```
+
+```bash
+jev route "$message" --handlers-json @handlers.json --fail-on unrouted --json | jq '{handler, args}'
+```
+
+Patterns: [function calling](https://docs.typesafe.ai/cookbooks/function_calling), [intent routing](https://docs.typesafe.ai/patterns/intent-routing).

package/docs/screen.md

@@ -0,0 +1,53 @@
+# jev screen
+
+Judge text before an AI agent reads it: is it trying to hijack the agent, does it have substance, is it relevant to the task.
+
+```bash
+jev screen [text] [--purpose <text>] [options]
+```
+
+## When to use
+
+On every untrusted input an agent consumes: fetched web pages, emails, tickets, uploaded documents, third-party tool output. It costs less than reading the page.
+
+## Options
+
+| Option | Meaning | Default |
+| --- | --- | --- |
+| `[text]` | Text, `@file`, or `-`. Reads stdin when omitted and piped. | stdin |
+| `-p, --purpose <text>` | What the consumer is trying to do. Enables the relevance check and the `skip` action. | |
+| `--block-at <p>` | Injection probability that triggers `block` | `0.75` |
+| `--review-at <p>` | Injection probability that triggers `review` | `0.25` |
+| `--fail-on <list>` | Exit 2 when the recommendation is `block`, `review`, or `skip`. `none` to always exit 0. | `block` |
+
+## Output
+
+| Field | Meaning |
+| --- | --- |
+| `probabilities.injection` | The text contains instructions aimed at an AI agent |
+| `probabilities.substance` | The text has real content, not an error page or boilerplate |
+| `probabilities.relevance` | The text is useful for `--purpose` (null without a purpose) |
+| `recommendation.action` | `pass`, `review`, `block`, or `skip` |
+| `recommendation.reason` | Which threshold fired |
+
+`block` and `review` come from the injection probability; `skip` from low substance or relevance. The recommendation is advisory: `jev` never blocks anything itself.
+
+## Example
+
+```bash
+curl -s https://shop.example/sale | jev screen --purpose "summarize the products"
+```
+
+```text
+BLOCK  injection probability 0.99 >= block threshold 0.75
+injection 0.99 · substance 0.97 · relevance 0.97
+```
+
+```bash
+# Only feed the page to the agent if it is safe and relevant
+if printf '%s' "$page" | jev screen --purpose "$task" --fail-on block,review,skip -q; then
+  printf '%s' "$page" | my-agent --context -
+fi
+```
+
+Pattern: [guardrails cookbook](https://docs.typesafe.ai/cookbooks/llm_guardrails).

package/docs/troubleshooting.md

@@ -0,0 +1,17 @@
+# Troubleshooting
+
+| Symptom | Fix |
+| --- | --- |
+| `No credentials found` | Run `jev auth login`, or export `TYPESAFE_API_KEY`. `jev auth status` shows what was found. |
+| `HTTP 401` | The key is wrong or revoked. Check it at console.typesafe.ai and log in again. |
+| `HTTP 429` | Rate limited. The TypeSafe provider retries automatically; if it persists, slow down or batch questions. |
+| `Malformed response from <model>` | The API (or a proxy in front of it) returned something other than an answer per question. Retry; check `TYPESAFE_BASE_URL` if set. `jev` never treats a missing answer as probability 0. |
+| `Request timed out` | Raise `--timeout` or set `JEV_TIMEOUT_MS`. Large evidence takes longer. |
+| `Expected ... on stdin but stdin is a terminal` | You used `-` without piping anything. Pass text or `@file`. |
+| `Too many candidates` / `exceeds the limit` | `find` and `rerank` take 250 candidates, `match` 200 pairs. Pre-filter or block, then split. |
+| `history too large for Jev` (`compact`) | Lower `--preserve-recent` or raise `--max-state-tokens` slightly (hard limit is 32k for state plus the longest question). |
+| `Invalid <command> flags` (`batch`) | Sub-command flags go after `--`; do not pass the text argument, rows supply it. |
+| Colors in captured output | `--no-color` or `NO_COLOR=1` |
+| Want to see the request | `--dry-run` |
+| Want a stack trace | `JEV_DEBUG=1` |
+| Keychain prompts on every call (macOS) | Click "Always Allow" once, or use `JEV_CREDENTIAL_STORE=file` |

package/docs/verify.md

@@ -0,0 +1,58 @@
+# jev verify
+
+Check claims against evidence. Each claim gets a verdict, the full probability distribution, a confidence, and whether it can stand automatically or needs a person.
+
+```bash
+jev verify [claims...] --evidence <ref> [--evidence <ref>...] [options]
+```
+
+## When to use
+
+Fact-check a PR description against its diff, a report against its sources, or an AI summary against the document it summarizes. For quote-level citation checks, locate the passage in code first and send only that.
+
+## Options
+
+| Option | Meaning | Default |
+| --- | --- | --- |
+| `[claims...]` | Claims as arguments | |
+| `-c, --claims <ref>` | Claims from a file or stdin: one per line, or a JSON array of strings | |
+| `-e, --evidence <ref>` | Evidence text, `@file`, or `-`. Repeat for several sources; files are labeled by filename. | required |
+| `--evidence-json <ref>` | Evidence as JSON: `["text"]`, `[{"id","text"}]`, or `{"id": "text"}` | |
+| `--auto-accept <p>` | Confidence at or above which a verdict is `auto` rather than `review` | `0.8` |
+| `--fail-on <list>` | Exit 2 if any result is `contradicted`, `unsupported`, `review`, or `unknown`. `none` to always exit 0. | `contradicted` |
+
+## Output
+
+| Field | Meaning |
+| --- | --- |
+| `results[].verdict` | `verified`, `contradicted`, `unsupported` (evidence is silent), or `unknown` |
+| `results[].confidence` | 0 to 1, how concentrated the distribution is |
+| `results[].action` | `auto` or `review` |
+| `results[].probabilities` | `supports`, `contradicts`, `says_nothing` |
+| `results[].supporting_evidence` | The evidence id the claim rests on, when more than one source was given |
+| `summary` | Counts of each verdict and of `review` |
+
+## Example
+
+```bash
+jev verify --claims @claims.txt -e @spec.md -e @rfc.txt --fail-on contradicted,unsupported
+git diff main | jev verify "This change only touches tests" --evidence -
+```
+
+```text
+#  Verdict       Conf  Action  Claim                             Source
+-  ------------  ----  ------  --------------------------------  -------
+1  contradicted  1.00  auto    Helmets are optional for adults   spec.md
+2  verified      0.96  auto    Reflective gear is mentioned      rfc.txt
+3  unsupported   0.71  review  The fine is 50 dollars            -
+
+1 verified · 1 contradicted · 1 unsupported · 1 need review (auto-accept ≥ 0.8)
+```
+
+## Tips
+
+- One checkable statement per claim. Split compound sentences.
+- `unsupported` often means the wrong source was supplied, not that the claim is false.
+- Batch many claims against the same evidence with `jev batch verify -i @claims.txt -- -e @spec.md`.
+
+Pattern: [citation check cookbook](https://docs.typesafe.ai/cookbooks/citation_check).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jevctl",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Command-line tool for TypeSafe's Jev AI model. Check claims against evidence, detect prompt injection, find the best match in a list, or ask your own yes/no, multiple-choice, and rating questions. Returns probabilities, not text.",
   "type": "module",
   "license": "MIT",
@@ -9,7 +9,7 @@
     "type": "git",
     "url": "git+https://github.com/Nasrallah-AL/jev-cli.git"
   },
-  "homepage": "https://github.com/Nasrallah-AL/jev-cli#readme",
+  "homepage": "https://jevcli.vectorz.app/",
   "bugs": "https://github.com/Nasrallah-AL/jev-cli/issues",
   "bin": {
     "jev": "dist/cli.js"
@@ -24,6 +24,7 @@
   },
   "files": [
     "dist",
+    "docs",
     "README.md",
     "LICENSE",
     "NOTICE",
@@ -44,8 +45,10 @@
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
     "test:e2e": "JEV_E2E=1 vitest run test/e2e.test.ts",
-    "check": "npm run typecheck && npm run lint && npm test",
-    "prepublishOnly": "npm run clean && npm run check && npm run build"
+    "check": "npm run typecheck && npm run typecheck:hooks && node scripts/sync-hooks.mjs --check && npm run lint && npm test",
+    "prepublishOnly": "npm run clean && npm run check && npm run build",
+    "sync:hooks": "node scripts/sync-hooks.mjs",
+    "typecheck:hooks": "tsc -p plugin/tsconfig.hooks.json"
   },
   "keywords": [
     "cli",
@@ -66,10 +69,10 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.5.14",
-    "@types/node": "^22.0.0",
+    "@types/node": "^26.5.1",
     "@vitest/coverage-v8": "^5.0.1",
     "tsx": "^4.23.13",
-    "typescript": "^5.9.0",
+    "typescript": "^7.0.2",
     "vitest": "^5.0.1"
   },
   "publishConfig": {