@motebit/protocol 0.7.0 → 1.0.0

package/dist/tool-mode.js

@@ -0,0 +1,50 @@
+/**
+ * Tool cost-tier taxonomy.
+ *
+ * Every `ToolDefinition` declares one of these modes. The motebit's
+ * tool registry sorts the list by tier, so when the model scans its
+ * available tools it sees structured / cheap options first and the
+ * pixel-level fallback last. Cost tiers (hybrid engine doctrine):
+ *
+ *   - **api** — structured, semantically rich, KB round-trip.
+ *     MCP tools, web_search, read_url, memory ops, file I/O, goals.
+ *     The default for any tool that moves text or structured data.
+ *
+ *   - **ax** — accessibility-tree extraction: DOM, AX API, reader
+ *     shapes. Structured but lossy (visual context discarded). Used
+ *     when the target surface exposes a hierarchy the motebit can
+ *     read without screen capture. Today: the web Reader / virtual
+ *     browser path. Tomorrow: macOS AXUIElement traversal for native
+ *     apps.
+ *
+ *   - **pixels** — screen capture + synthetic input. Works on every
+ *     app (legacy software, games, custom UI) but costs ~30k tokens
+ *     per observation even downscaled and crosses a whole-screen
+ *     privacy surface. The universal fallback — reserved for
+ *     surfaces that have no API and no accessibility tree.
+ *
+ * `ToolMode` is a closed string-literal union, following the `SuiteId`
+ * registry pattern. Adding a tier is additive (new entry + new
+ * priority arm in the registry sort). Removing one is a wire-format
+ * break — third parties declare `mode` in their tool definitions and
+ * that claim is stable.
+ */
+/**
+ * All declared modes in priority order (cheapest first). Consumers
+ * that need to rank or enumerate tool modes iterate this array rather
+ * than hard-coding the order.
+ */
+export const TOOL_MODES = ["api", "ax", "pixels"];
+/**
+ * Priority index of a declared mode (0 = cheapest). Tools without a
+ * `mode` declaration sort to the end (`TOOL_MODES.length`) — they are
+ * neither rejected nor prioritized, just deprioritized relative to
+ * explicit tiers.
+ */
+export function toolModePriority(mode) {
+    if (mode === undefined)
+        return TOOL_MODES.length;
+    const idx = TOOL_MODES.indexOf(mode);
+    return idx === -1 ? TOOL_MODES.length : idx;
+}
+//# sourceMappingURL=tool-mode.js.map

package/dist/tool-mode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-mode.js","sourceRoot":"","sources":["../src/tool-mode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAIH;;;;GAIG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,KAAK,EAAE,IAAI,EAAE,QAAQ,CAAU,CAAC;AAE3D;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAA0B;IACzD,IAAI,IAAI,KAAK,SAAS;QAAE,OAAO,UAAU,CAAC,MAAM,CAAC;IACjD,MAAM,GAAG,GAAG,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IACrC,OAAO,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC;AAC9C,CAAC"}

package/dist/traversal.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Generic graph traversal over arbitrary semirings.
+ *
+ * The core insight: shortest path, most-trusted path, cheapest path,
+ * most reliable path, and reachability are ALL the same algorithm.
+ * The semiring determines the answer.
+ *
+ * Bellman-Ford generalized: relax edges using ⊕ (choice) and ⊗ (composition).
+ * Floyd-Warshall generalized: all-pairs transitive closure.
+ *
+ * These are the only two traversal algorithms the system needs.
+ * Every routing query is a semiring instantiation of one of them.
+ */
+import type { WeightedDigraph } from "./graph.js";
+/**
+ * Single-source optimal paths via generalized Bellman-Ford.
+ *
+ * Returns a map from each reachable node to the optimal semiring value
+ * of the best path from `source` to that node.
+ *
+ * - Over TrustSemiring: most trusted delegation chain from source
+ * - Over CostSemiring:  cheapest pipeline from source
+ * - Over BooleanSemiring: reachable set from source
+ * - Over product semiring: all of the above simultaneously
+ *
+ * Complexity: O(V × E) — safe for graphs with negative-weight analogs
+ * (semirings where ⊕ is not monotone). For monotone semirings
+ * (trust, cost), could be optimized to Dijkstra-like O((V+E) log V).
+ */
+export declare function optimalPaths<T>(graph: WeightedDigraph<T>, source: string): Map<string, T>;
+/**
+ * Optimal path between two specific nodes.
+ * Convenience wrapper around optimalPaths.
+ */
+export declare function optimalPath<T>(graph: WeightedDigraph<T>, source: string, target: string): T;
+/**
+ * All-pairs transitive closure via generalized Floyd-Warshall.
+ *
+ * Computes the optimal semiring value between every pair of nodes.
+ * Returns a nested map: closure.get(from)?.get(to) → optimal value.
+ *
+ * Use cases:
+ *   - Pre-compute all trust relationships in a network
+ *   - Find all cheapest routes for capacity planning
+ *   - Detect isolated subgraphs (boolean semiring)
+ *
+ * Complexity: O(V³). Use optimalPaths for single-source queries on large graphs.
+ */
+export declare function transitiveClosure<T>(graph: WeightedDigraph<T>): Map<string, Map<string, T>>;
+/**
+ * Reconstruct the actual optimal path (sequence of node IDs).
+ *
+ * Returns null if no path exists (value equals semiring zero).
+ * Runs a modified Bellman-Ford that tracks predecessors.
+ */
+export declare function optimalPathTrace<T>(graph: WeightedDigraph<T>, source: string, target: string): {
+    value: T;
+    path: string[];
+} | null;
+//# sourceMappingURL=traversal.d.ts.map

package/dist/traversal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traversal.d.ts","sourceRoot":"","sources":["../src/traversal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,eAAe,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,CAsCzF;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,eAAe,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,CAAC,CAE3F;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,KAAK,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CA6C3F;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAChC,KAAK,EAAE,eAAe,CAAC,CAAC,CAAC,EACzB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb;IAAE,KAAK,EAAE,CAAC,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,IAAI,CAiDrC"}

package/dist/traversal.js

@@ -0,0 +1,183 @@
+/**
+ * Generic graph traversal over arbitrary semirings.
+ *
+ * The core insight: shortest path, most-trusted path, cheapest path,
+ * most reliable path, and reachability are ALL the same algorithm.
+ * The semiring determines the answer.
+ *
+ * Bellman-Ford generalized: relax edges using ⊕ (choice) and ⊗ (composition).
+ * Floyd-Warshall generalized: all-pairs transitive closure.
+ *
+ * These are the only two traversal algorithms the system needs.
+ * Every routing query is a semiring instantiation of one of them.
+ */
+/**
+ * Single-source optimal paths via generalized Bellman-Ford.
+ *
+ * Returns a map from each reachable node to the optimal semiring value
+ * of the best path from `source` to that node.
+ *
+ * - Over TrustSemiring: most trusted delegation chain from source
+ * - Over CostSemiring:  cheapest pipeline from source
+ * - Over BooleanSemiring: reachable set from source
+ * - Over product semiring: all of the above simultaneously
+ *
+ * Complexity: O(V × E) — safe for graphs with negative-weight analogs
+ * (semirings where ⊕ is not monotone). For monotone semirings
+ * (trust, cost), could be optimized to Dijkstra-like O((V+E) log V).
+ */
+export function optimalPaths(graph, source) {
+    const sr = graph.sr;
+    const srEq = sr.eq;
+    const eq = (a, b) => (srEq ? srEq(a, b) : a === b);
+    const dist = new Map();
+    // Initialize: source = 1 (identity), everything else = 0 (worst)
+    for (const node of graph.nodes()) {
+        dist.set(node, sr.zero);
+    }
+    dist.set(source, sr.one);
+    const nodes = [...graph.nodes()];
+    const nodeCount = nodes.length;
+    // Relax all edges V-1 times
+    for (let i = 0; i < nodeCount - 1; i++) {
+        let changed = false;
+        for (const node of nodes) {
+            const dNode = dist.get(node);
+            // Skip unreachable nodes — mul(zero, w) = zero (annihilation), so no update possible
+            if (eq(dNode, sr.zero))
+                continue;
+            for (const [neighbor, weight] of graph.neighbors(node)) {
+                // New candidate: path-to-node ⊗ edge-weight
+                const candidate = sr.mul(dNode, weight);
+                const current = dist.get(neighbor);
+                const combined = sr.add(current, candidate);
+                // Only update if the value actually changed
+                if (!eq(combined, current)) {
+                    dist.set(neighbor, combined);
+                    changed = true;
+                }
+            }
+        }
+        if (!changed)
+            break; // Early termination — converged
+    }
+    return dist;
+}
+/**
+ * Optimal path between two specific nodes.
+ * Convenience wrapper around optimalPaths.
+ */
+export function optimalPath(graph, source, target) {
+    return optimalPaths(graph, source).get(target) ?? graph.sr.zero;
+}
+/**
+ * All-pairs transitive closure via generalized Floyd-Warshall.
+ *
+ * Computes the optimal semiring value between every pair of nodes.
+ * Returns a nested map: closure.get(from)?.get(to) → optimal value.
+ *
+ * Use cases:
+ *   - Pre-compute all trust relationships in a network
+ *   - Find all cheapest routes for capacity planning
+ *   - Detect isolated subgraphs (boolean semiring)
+ *
+ * Complexity: O(V³). Use optimalPaths for single-source queries on large graphs.
+ */
+export function transitiveClosure(graph) {
+    const sr = graph.sr;
+    const nodes = [...graph.nodes()];
+    const n = nodes.length;
+    const idx = new Map();
+    for (let i = 0; i < n; i++)
+        idx.set(nodes[i], i);
+    // Initialize distance matrix
+    const dist = [];
+    for (let i = 0; i < n; i++) {
+        dist.push([]);
+        for (let j = 0; j < n; j++) {
+            dist[i].push(i === j ? sr.one : sr.zero);
+        }
+    }
+    // Load edges
+    for (const node of nodes) {
+        const i = idx.get(node);
+        for (const [neighbor, weight] of graph.neighbors(node)) {
+            const j = idx.get(neighbor);
+            dist[i][j] = sr.add(dist[i][j], weight);
+        }
+    }
+    // Floyd-Warshall relaxation
+    for (let k = 0; k < n; k++) {
+        for (let i = 0; i < n; i++) {
+            for (let j = 0; j < n; j++) {
+                const through_k = sr.mul(dist[i][k], dist[k][j]);
+                dist[i][j] = sr.add(dist[i][j], through_k);
+            }
+        }
+    }
+    // Convert to nested map
+    const result = new Map();
+    for (let i = 0; i < n; i++) {
+        const row = new Map();
+        for (let j = 0; j < n; j++) {
+            row.set(nodes[j], dist[i][j]);
+        }
+        result.set(nodes[i], row);
+    }
+    return result;
+}
+/**
+ * Reconstruct the actual optimal path (sequence of node IDs).
+ *
+ * Returns null if no path exists (value equals semiring zero).
+ * Runs a modified Bellman-Ford that tracks predecessors.
+ */
+export function optimalPathTrace(graph, source, target) {
+    const sr = graph.sr;
+    const dist = new Map();
+    const pred = new Map();
+    for (const node of graph.nodes()) {
+        dist.set(node, sr.zero);
+        pred.set(node, null);
+    }
+    dist.set(source, sr.one);
+    const nodes = [...graph.nodes()];
+    const srEq = sr.eq;
+    const eq = (a, b) => (srEq ? srEq(a, b) : a === b);
+    for (let i = 0; i < nodes.length - 1; i++) {
+        let changed = false;
+        for (const node of nodes) {
+            const dNode = dist.get(node);
+            if (eq(dNode, sr.zero))
+                continue;
+            for (const [neighbor, weight] of graph.neighbors(node)) {
+                const candidate = sr.mul(dNode, weight);
+                const current = dist.get(neighbor);
+                const combined = sr.add(current, candidate);
+                if (!eq(combined, current)) {
+                    dist.set(neighbor, combined);
+                    pred.set(neighbor, node);
+                    changed = true;
+                }
+            }
+        }
+        if (!changed)
+            break;
+    }
+    const value = dist.get(target) ?? sr.zero;
+    if (value === sr.zero && source !== target)
+        return null;
+    // Reconstruct path
+    const path = [];
+    let current = target;
+    const visited = new Set();
+    while (current != null && !visited.has(current)) {
+        visited.add(current);
+        path.unshift(current);
+        current = pred.get(current) ?? null;
+    }
+    if (path[0] !== source)
+        return null;
+    return { value, path };
+}
+//# sourceMappingURL=traversal.js.map

package/dist/traversal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"traversal.js","sourceRoot":"","sources":["../src/traversal.ts"],"names":[],"mappings":"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"}

package/dist/trust-algebra.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Trust algebra: concrete semiring operations for agent trust scoring.
+ *
+ * (TrustScores, max, ×, 0, 1) — standard algebraic path problem.
+ * Multiplicative discount for serial chains, max for parallel paths.
+ *
+ * These are protocol-level primitives: any compatible implementation
+ * must compute trust the same way for interoperable routing.
+ */
+import type { TrustTransitionThresholds, AgentTrustLevel } from "./index.js";
+/**
+ * Canonical AgentTrustLevel → [0,1] mapping (single source of truth).
+ *
+ * Uses string literals instead of enum computed keys to avoid circular
+ * initialization between trust-algebra.ts ↔ index.ts. The values match
+ * AgentTrustLevel enum values exactly.
+ */
+export declare const TRUST_LEVEL_SCORES: Record<string, number>;
+/** Convert a trust level to its numeric score. */
+export declare function trustLevelToScore(level: AgentTrustLevel | string): number;
+/** Semiring zero — annihilator for ⊗, identity for ⊕. */
+export declare const TRUST_ZERO = 0;
+/** Semiring one — identity for ⊗. */
+export declare const TRUST_ONE = 1;
+/** ⊕: parallel paths — pick the best route. */
+export declare function trustAdd(a: number, b: number): number;
+/** ⊗: serial chain — discount per hop. */
+export declare function trustMultiply(a: number, b: number): number;
+/** Fold a chain of trust scores with ⊗. Empty chain → 1.0 (identity). */
+export declare function composeTrustChain(scores: number[]): number;
+/** Fold parallel route scores with ⊕. No routes → 0.0 (identity). */
+export declare function joinParallelRoutes(scores: number[]): number;
+export declare const DEFAULT_TRUST_THRESHOLDS: TrustTransitionThresholds;
+//# sourceMappingURL=trust-algebra.d.ts.map

package/dist/trust-algebra.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trust-algebra.d.ts","sourceRoot":"","sources":["../src/trust-algebra.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,yBAAyB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAI7E;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAMrD,CAAC;AAEF,kDAAkD;AAClD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,GAAG,MAAM,CAEzE;AAED,yDAAyD;AACzD,eAAO,MAAM,UAAU,IAAI,CAAC;AAE5B,qCAAqC;AACrC,eAAO,MAAM,SAAS,IAAI,CAAC;AAE3B,+CAA+C;AAC/C,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAErD;AAED,0CAA0C;AAC1C,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED,yEAAyE;AACzE,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAE1D;AAED,qEAAqE;AACrE,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAE3D;AAID,eAAO,MAAM,wBAAwB,EAAE,yBAOtC,CAAC"}

package/dist/trust-algebra.js

@@ -0,0 +1,58 @@
+/**
+ * Trust algebra: concrete semiring operations for agent trust scoring.
+ *
+ * (TrustScores, max, ×, 0, 1) — standard algebraic path problem.
+ * Multiplicative discount for serial chains, max for parallel paths.
+ *
+ * These are protocol-level primitives: any compatible implementation
+ * must compute trust the same way for interoperable routing.
+ */
+// ── Trust Semiring Algebra ──────────────────────────────────────────
+/**
+ * Canonical AgentTrustLevel → [0,1] mapping (single source of truth).
+ *
+ * Uses string literals instead of enum computed keys to avoid circular
+ * initialization between trust-algebra.ts ↔ index.ts. The values match
+ * AgentTrustLevel enum values exactly.
+ */
+export const TRUST_LEVEL_SCORES = {
+    unknown: 0.1,
+    first_contact: 0.3,
+    verified: 0.6,
+    trusted: 0.9,
+    blocked: 0.0,
+};
+/** Convert a trust level to its numeric score. */
+export function trustLevelToScore(level) {
+    return TRUST_LEVEL_SCORES[level] ?? 0.1;
+}
+/** Semiring zero — annihilator for ⊗, identity for ⊕. */
+export const TRUST_ZERO = 0;
+/** Semiring one — identity for ⊗. */
+export const TRUST_ONE = 1;
+/** ⊕: parallel paths — pick the best route. */
+export function trustAdd(a, b) {
+    return Math.max(a, b);
+}
+/** ⊗: serial chain — discount per hop. */
+export function trustMultiply(a, b) {
+    return a * b;
+}
+/** Fold a chain of trust scores with ⊗. Empty chain → 1.0 (identity). */
+export function composeTrustChain(scores) {
+    return scores.reduce(trustMultiply, TRUST_ONE);
+}
+/** Fold parallel route scores with ⊕. No routes → 0.0 (identity). */
+export function joinParallelRoutes(scores) {
+    return scores.reduce(trustAdd, TRUST_ZERO);
+}
+// ── Default Thresholds ─────────────────────────────────────────────
+export const DEFAULT_TRUST_THRESHOLDS = {
+    promoteToVerified_minTasks: 5,
+    promoteToVerified_minRate: 0.8,
+    promoteToTrusted_minTasks: 20,
+    promoteToTrusted_minRate: 0.9,
+    demote_belowRate: 0.5,
+    demote_minTasks: 3,
+};
+//# sourceMappingURL=trust-algebra.js.map

package/dist/trust-algebra.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trust-algebra.js","sourceRoot":"","sources":["../src/trust-algebra.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,uEAAuE;AAEvE;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAA2B;IACxD,OAAO,EAAE,GAAG;IACZ,aAAa,EAAE,GAAG;IAClB,QAAQ,EAAE,GAAG;IACb,OAAO,EAAE,GAAG;IACZ,OAAO,EAAE,GAAG;CACb,CAAC;AAEF,kDAAkD;AAClD,MAAM,UAAU,iBAAiB,CAAC,KAA+B;IAC/D,OAAO,kBAAkB,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC;AAC1C,CAAC;AAED,yDAAyD;AACzD,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,CAAC;AAE5B,qCAAqC;AACrC,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,CAAC;AAE3B,+CAA+C;AAC/C,MAAM,UAAU,QAAQ,CAAC,CAAS,EAAE,CAAS;IAC3C,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACxB,CAAC;AAED,0CAA0C;AAC1C,MAAM,UAAU,aAAa,CAAC,CAAS,EAAE,CAAS;IAChD,OAAO,CAAC,GAAG,CAAC,CAAC;AACf,CAAC;AAED,yEAAyE;AACzE,MAAM,UAAU,iBAAiB,CAAC,MAAgB;IAChD,OAAO,MAAM,CAAC,MAAM,CAAC,aAAa,EAAE,SAAS,CAAC,CAAC;AACjD,CAAC;AAED,qEAAqE;AACrE,MAAM,UAAU,kBAAkB,CAAC,MAAgB;IACjD,OAAO,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;AAC7C,CAAC;AAED,sEAAsE;AAEtE,MAAM,CAAC,MAAM,wBAAwB,GAA8B;IACjE,0BAA0B,EAAE,CAAC;IAC7B,yBAAyB,EAAE,GAAG;IAC9B,yBAAyB,EAAE,EAAE;IAC7B,wBAAwB,EAAE,GAAG;IAC7B,gBAAgB,EAAE,GAAG;IACrB,eAAe,EAAE,CAAC;CACnB,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@motebit/protocol",
-  "version": "0.7.0",
-  "description": "Motebit network protocol types — identity, receipts, credentials, settlement, trust algebra. MIT, zero dependencies.",
+  "version": "1.0.0",
+  "description": "Motebit protocol — identity, receipts, credentials, delegation, settlement, and trust algebra for sovereign AI agents. Types, semirings, routing primitives. Apache-2.0, zero dependencies.",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -12,15 +12,16 @@
     }
   },
   "files": [
-    "dist/index.js",
-    "dist/index.js.map",
-    "dist/index.d.ts",
-    "dist/index.d.ts.map",
+    "dist/**/*.js",
+    "dist/**/*.js.map",
+    "dist/**/*.d.ts",
+    "dist/**/*.d.ts.map",
     "LICENSE",
+    "NOTICE",
     "README.md"
   ],
   "sideEffects": false,
-  "license": "MIT",
+  "license": "Apache-2.0",
   "keywords": [
     "motebit",
     "protocol",
@@ -48,17 +49,20 @@
   "devDependencies": {
     "@types/node": "^22.0.0",
     "typescript": "^5.6.0",
+    "fast-check": "^4.6.0",
     "vitest": "^2.1.0"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
   "scripts": {
     "build": "tsc -b",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "typecheck": "tsc --noEmit",
-    "lint": "eslint src/",
+    "lint": "eslint --parser-options=project:tsconfig.eslint.json src/",
+    "lint:pack": "publint --strict && attw --pack --profile esm-only",
+    "api:extract": "api-extractor run --local",
     "clean": "rm -rf dist .turbo *.tsbuildinfo"
   }
 }