slash-tokens 0.1.0 → 0.3.0

package/README.md

@@ -1,8 +1,8 @@
 # /slash-tokens
 
-Token budget estimation in 4.8 KB WASM. Sub-millisecond. Zero dependencies.
+Pre-flight checks for API calls. 4.8 KB WASM. Sub-millisecond. Zero dependencies.
 
-I don't count tokens. I slash them.
+**Fly First. Pay Economy.**
 
 ## Install
 
@@ -15,106 +15,23 @@ npm install slash-tokens
 ```js
 import { slash } from 'slash-tokens'
 
-const tokens = slash('Your content here')
+const tokens = slash(prompt)
 
-if (tokens > 128_000) trim(content)     // Context window gate
-const cost = tokens * PRICE_PER_TOKEN   // Cost estimation
+if (tokens > contextWindow) trim(prompt)
+if (tokens < cheapThreshold) useHaiku()
 ```
 
-One function. Returns a number. That's the entire API.
+One function. Returns a token estimate. Sub-millisecond. Any model.
 
-## Scan your project
+## Evaluate a repo
 
 ```bash
 bunx slash-tokens
 ```
 
-Finds every AI API call in your codebase and estimates your token burn:
+## Docs
 
-```
-  ⚡ /slash
-  Token burn analysis
-
-  Scanned 47 files in 3ms
-
-  CALL SITES
-  ────────────────────────────────────────────────────────
-  src/api/chat.ts:24       Anthropic    ~2,400 tok/call
-  src/api/summary.ts:11    OpenAI       ~8,200 tok/call
-  src/lib/agent.ts:88      Vercel AI    ~1,100 tok/call
-
-  DAILY BURN (100 calls/site/day)
-  ────────────────────────────────────────────────────────
-  Input tokens:    1,520,000
-  Output tokens:   3,040,000  (estimated)
-  Total:           4,560,000 tokens/day
-
-  MONTHLY COST ($3/$15 per MTok)
-  ────────────────────────────────────────────────────────
-  Total:           $1,504.80/mo
-
-  ⚡ SLASH SAVINGS (10% gate efficiency)
-  ────────────────────────────────────────────────────────
-  Annual savings:  $1,805.76/yr
-```
-
-Detects: OpenAI, Anthropic, Vercel AI, LangChain, Gemini, Bedrock, Grok, Cohere, Mistral.
-
-## How it works
-
-Single-pass byte classification over your content. No vocabulary tables. No BPE decode. Classifies content type (prose, code, JSON, YAML, mixed), applies a calibrated chars-per-token ratio, adds a safety margin.
-
-Budget gate — better to say "doesn't fit" than overflow. The API returns exact counts after the call. Pre-call, you only need go/no-go.
-
-## Numbers
-
-| | js-tiktoken | gpt-tokenizer | slash-tokens |
-|---|---|---|---|
-| Size | ~1 MB | 300 KB+ | **4.8 KB** |
-| Cold start | Heavy | Moderate | **Sub-ms** |
-| Edge-ready | Painful | Difficult | **Native** |
-| Models | GPT only | GPT only | **Any model** |
-| Dependencies | npm tree | npm tree | **Zero** |
-| Allocations | Many | Many | **Zero** |
-
-## Runtime support
-
-Works everywhere WASM runs:
-
-- Node.js
-- Bun
-- Deno
-- Cloudflare Workers
-- Vercel Edge
-- Browser
-
-## API
-
-### `slash(content: string): number`
-
-Estimate token count for a string. Returns `u32`.
-
-```js
-slash('')                    // 0
-slash('hello')               // 1
-slash(longDocument)          // 4,283
-```
-
-### `slashBytes(bytes: Uint8Array): number`
-
-Estimate token count from raw bytes. Skips `TextEncoder` overhead.
-
-## What this is not
-
-This is not a tokenizer. It doesn't decode BPE. It doesn't reproduce exact token counts. No tokenizer can — Claude, Grok, and Gemini vocabularies are not public.
-
-This is a **budget gate**. It answers "does this fit?" with 96-98% accuracy in sub-millisecond time. The 2-4% margin is intentional — overestimate, never underestimate.
-
-## Engine
-
-4,865 bytes of Zig-compiled WASM (`wasm32-freestanding`). No allocator. No floats. No heap. Base64-embedded — no separate `.wasm` file to load.
-
-Built from [xai-faf-zig](https://github.com/Wolfe-Jam/xai-faf-zig). 172 tests including 65 adversarial (CJK, emoji, binary, base64, threshold boundaries).
+Everything is at **[slashtokens.com](https://slashtokens.com)**
 
 ## License
 

package/dist/auto.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/auto.js

@@ -0,0 +1,9 @@
+import { patchFetch, onIntercept } from './intercept.js';
+// Auto mode: import this file and every LLM call is pre-flighted.
+// Usage: import 'slash-tokens/auto'
+patchFetch();
+// Default handler: log to console
+onIntercept((event) => {
+    const status = event.fits ? 'OK' : 'OVER LIMIT';
+    console.log(`[slash] ${event.provider} ${event.model} | ${event.tokens.toLocaleString()} tokens | $${event.cost.toFixed(4)} | ${status}`);
+});

package/dist/cli.js

@@ -230,7 +230,94 @@ function printReport(sites, filesScanned, timeMs, cwd) {
   console.log("");
 }
 
+// src/config.ts
+var _key = null;
+var _endpoint = "https://mcpaas.live/api/slash/transact";
+function init(opts) {
+  _key = opts.key;
+  if (opts.endpoint)
+    _endpoint = opts.endpoint;
+}
+function resolveKey(perCallKey) {
+  const key = perCallKey || _key || process.env.SLASH_KEY;
+  if (!key) {
+    throw new Error(`No Slash API key. Set SLASH_KEY env var, call init({ key }), or pass key to report().
+` + "Register: POST https://mcpaas.live/api/slash/register");
+  }
+  return key;
+}
+function getEndpoint() {
+  return _endpoint;
+}
+
+// src/transact.ts
+async function report(opts) {
+  const key = resolveKey(opts.key);
+  const endpoint = getEndpoint();
+  const res = await fetch(endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${key}`
+    },
+    body: JSON.stringify({
+      tokens_estimated: opts.tokens_estimated,
+      tokens_saved: opts.tokens_saved,
+      model: opts.model || "unknown",
+      action: opts.action,
+      cost_saved_usd: opts.cost_saved_usd
+    })
+  });
+  if (res.status === 401)
+    throw new Error("Invalid Slash API key");
+  if (res.status === 402)
+    throw new Error("Insufficient balance. Purchase credits at slashtokens.com");
+  if (res.status === 429)
+    throw new Error("Rate limited. Try again shortly.");
+  if (!res.ok)
+    throw new Error(`Slash API error: ${res.status}`);
+  return res.json();
+}
+
 // src/cli.ts
+var args = process.argv.slice(2);
+var keyArg = args.find((a) => a.startsWith("--key="));
+var key = keyArg?.split("=")[1] || process.env.SLASH_KEY;
+if (key)
+  init({ key });
 var cwd = process.cwd();
 var { sites, filesScanned, timeMs } = scan(cwd);
 printReport(sites, filesScanned, timeMs, cwd);
+var R2 = "\x1B[0m";
+var B2 = "\x1B[1m";
+var GREEN = "\x1B[38;2;74;222;128m";
+var GOLD2 = "\x1B[38;2;230;161;65m";
+var GRAY2 = "\x1B[90m";
+var ORANGE2 = "\x1B[38;2;255;68;0m";
+if (key && sites.length > 0) {
+  const callsPerDay = 100;
+  const dailyInput = sites.reduce((sum, s) => sum + s.tokensPerCall * callsPerDay, 0);
+  const dailyOutput = dailyInput * 2;
+  const monthlyCostInput = dailyInput * 30 / 1e6 * 3;
+  const monthlyCostOutput = dailyOutput * 30 / 1e6 * 15;
+  const monthlyCost = monthlyCostInput + monthlyCostOutput;
+  const monthlySaved = monthlyCost * 0.1;
+  report({
+    tokens_estimated: dailyInput * 30,
+    tokens_saved: Math.round(dailyInput * 30 * 0.1),
+    model: "scan",
+    action: "reduced",
+    cost_saved_usd: monthlySaved
+  }).then((result) => {
+    console.log(`${GREEN}${B2}  ✓ Reported to MCPaaS${R2} ${GRAY2}(${result.transaction_id})${R2}`);
+    console.log(`${GRAY2}    Fee: $${result.fee_usd.toFixed(4)} · Balance: $${result.balance_remaining_usd.toFixed(2)}${R2}`);
+    console.log("");
+  }).catch((err) => {
+    console.log(`${GOLD2}  ⚠ Report failed: ${err.message}${R2}`);
+    console.log("");
+  });
+} else if (!key && sites.length > 0) {
+  console.log(`${GRAY2}  → Report savings: ${ORANGE2}bunx slash-tokens --key=YOUR_KEY${R2}`);
+  console.log(`${GRAY2}  → Get a key:      POST https://mcpaas.live/api/slash/register${R2}`);
+  console.log("");
+}

package/dist/config.d.ts

@@ -0,0 +1,6 @@
+export declare function init(opts: {
+    key: string;
+    endpoint?: string;
+}): void;
+export declare function resolveKey(perCallKey?: string): string;
+export declare function getEndpoint(): string;

package/dist/config.js

@@ -0,0 +1,18 @@
+let _key = null;
+let _endpoint = 'https://mcpaas.live/api/slash/transact';
+export function init(opts) {
+    _key = opts.key;
+    if (opts.endpoint)
+        _endpoint = opts.endpoint;
+}
+export function resolveKey(perCallKey) {
+    const key = perCallKey || _key || process.env.SLASH_KEY;
+    if (!key) {
+        throw new Error('No Slash API key. Set SLASH_KEY env var, call init({ key }), or pass key to report().\n' +
+            'Register: POST https://mcpaas.live/api/slash/register');
+    }
+    return key;
+}
+export function getEndpoint() {
+    return _endpoint;
+}

package/dist/index.d.ts

@@ -1 +1,9 @@
-export { slash, slashBytes } from './slash';
+export { slash, slashBytes } from './slash.js';
+export { preflight } from './preflight.js';
+export type { PreflightResult, Alternative } from './preflight.js';
+export { MODELS, listModels } from './models.js';
+export type { ModelInfo } from './models.js';
+export { report } from './transact.js';
+export type { ReportOptions, ReportResult } from './transact.js';
+export { init } from './config.js';
+export { resolveKey } from './config.js';

package/dist/index.js

@@ -1,57 +1,11 @@
-// src/wasm.ts
-var WASM_BASE64 = "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";
-var WASM_INPUT_OFFSET = 4096;
-var encoder = new TextEncoder;
-var _instance = null;
-function decodeBase64(b64) {
-  if (typeof Buffer !== "undefined") {
-    return new Uint8Array(Buffer.from(b64, "base64"));
-  }
-  const binary = atob(b64);
-  const bytes = new Uint8Array(binary.length);
-  for (let i = 0;i < binary.length; i++) {
-    bytes[i] = binary.charCodeAt(i);
-  }
-  return bytes;
-}
-function getInstance() {
-  if (_instance)
-    return _instance;
-  const bytes = decodeBase64(WASM_BASE64);
-  const module = new WebAssembly.Module(bytes);
-  _instance = new WebAssembly.Instance(module);
-  return _instance;
-}
-function writeToMemory(content) {
-  const instance = getInstance();
-  const bytes = encoder.encode(content);
-  const memory = instance.exports.memory;
-  const buffer = new Uint8Array(memory.buffer);
-  const maxLen = Math.min(bytes.length, buffer.length - WASM_INPUT_OFFSET - 1);
-  buffer.set(bytes.subarray(0, maxLen), WASM_INPUT_OFFSET);
-  return maxLen;
-}
-
-// src/slash.ts
-var WASM_INPUT_OFFSET2 = 4096;
-function slash(content) {
-  if (!content)
-    return 0;
-  const len = writeToMemory(content);
-  const instance = getInstance();
-  return instance.exports.estimate_tokens(WASM_INPUT_OFFSET2, len);
-}
-function slashBytes(bytes) {
-  if (!bytes.length)
-    return 0;
-  const instance = getInstance();
-  const memory = instance.exports.memory;
-  const buffer = new Uint8Array(memory.buffer);
-  const maxLen = Math.min(bytes.length, buffer.length - WASM_INPUT_OFFSET2 - 1);
-  buffer.set(bytes.subarray(0, maxLen), WASM_INPUT_OFFSET2);
-  return instance.exports.estimate_tokens(WASM_INPUT_OFFSET2, maxLen);
-}
-export {
-  slashBytes,
-  slash
-};
+// Core estimation
+export { slash, slashBytes } from './slash.js';
+// Pre-flight checks
+export { preflight } from './preflight.js';
+// Model intelligence
+export { MODELS, listModels } from './models.js';
+// Transaction reporting
+export { report } from './transact.js';
+// Configuration
+export { init } from './config.js';
+export { resolveKey } from './config.js';

package/dist/intercept.d.ts

@@ -0,0 +1,11 @@
+export interface InterceptEvent {
+    endpoint: string;
+    provider: string;
+    model: string;
+    tokens: number;
+    cost: number;
+    fits: boolean;
+    timestamp: string;
+}
+export declare function onIntercept(handler: (event: InterceptEvent) => void): void;
+export declare function patchFetch(): void;

package/dist/intercept.js

@@ -0,0 +1,120 @@
+import { slash } from './slash.js';
+import { getModel } from './models.js';
+// AI API endpoint detection — same patterns as scanner, runtime version
+const AI_ENDPOINTS = [
+    {
+        pattern: /api\.anthropic\.com/,
+        provider: 'Anthropic',
+        modelExtractor: (body) => body?.model || 'claude-sonnet',
+    },
+    {
+        pattern: /api\.openai\.com/,
+        provider: 'OpenAI',
+        modelExtractor: (body) => body?.model || 'gpt-4o',
+    },
+    {
+        pattern: /generativelanguage\.googleapis\.com/,
+        provider: 'Google',
+        modelExtractor: (body) => 'gemini-2.0-flash',
+    },
+    {
+        pattern: /api\.x\.ai/,
+        provider: 'xAI',
+        modelExtractor: (body) => body?.model || 'grok-3',
+    },
+];
+// Normalize model names to our pricing table keys
+function normalizeModel(raw) {
+    const lower = raw.toLowerCase();
+    if (lower.includes('opus'))
+        return 'claude-opus';
+    if (lower.includes('sonnet'))
+        return 'claude-sonnet';
+    if (lower.includes('haiku'))
+        return 'claude-haiku';
+    if (lower.includes('grok') && lower.includes('mini'))
+        return 'grok-3-mini';
+    if (lower.includes('grok'))
+        return 'grok-3';
+    if (lower.includes('gemini') && lower.includes('pro'))
+        return 'gemini-2.0-pro';
+    if (lower.includes('gemini'))
+        return 'gemini-2.0-flash';
+    if (lower.includes('4o-mini') || lower.includes('4o_mini'))
+        return 'gpt-4o-mini';
+    if (lower.includes('4o'))
+        return 'gpt-4o';
+    if (lower.includes('4.1') && lower.includes('nano'))
+        return 'gpt-4.1-nano';
+    if (lower.includes('4.1') && lower.includes('mini'))
+        return 'gpt-4.1-mini';
+    if (lower.includes('4.1'))
+        return 'gpt-4.1';
+    return raw;
+}
+// Extract message content from request body
+function extractContent(body) {
+    if (!body)
+        return '';
+    // Anthropic: { messages: [{ content: "..." }] }
+    // OpenAI: { messages: [{ content: "..." }] }
+    if (body.messages && Array.isArray(body.messages)) {
+        return body.messages
+            .map((m) => typeof m.content === 'string' ? m.content : JSON.stringify(m.content))
+            .join('\n');
+    }
+    // Anthropic: { prompt: "..." }
+    if (typeof body.prompt === 'string')
+        return body.prompt;
+    // Google: { contents: [{ parts: [{ text: "..." }] }] }
+    if (body.contents && Array.isArray(body.contents)) {
+        return body.contents
+            .flatMap((c) => c.parts || [])
+            .map((p) => p.text || '')
+            .join('\n');
+    }
+    return JSON.stringify(body);
+}
+let _onIntercept = null;
+export function onIntercept(handler) {
+    _onIntercept = handler;
+}
+export function patchFetch() {
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = async function slashFetch(input, init) {
+        const url = typeof input === 'string' ? input : input instanceof URL ? input.toString() : input.url;
+        // Check if this is an AI API call
+        const match = AI_ENDPOINTS.find(ep => ep.pattern.test(url));
+        if (match && init?.body) {
+            try {
+                const bodyStr = typeof init.body === 'string' ? init.body : undefined;
+                if (bodyStr) {
+                    const body = JSON.parse(bodyStr);
+                    const content = extractContent(body);
+                    const rawModel = match.modelExtractor(body);
+                    const model = normalizeModel(rawModel);
+                    const tokens = slash(content);
+                    const info = getModel(model);
+                    const cost = info ? Math.round(((tokens / 1000000) * info.input) * 1000000) / 1000000 : 0;
+                    const fits = info ? tokens <= info.context : true;
+                    const event = {
+                        endpoint: url,
+                        provider: match.provider,
+                        model,
+                        tokens,
+                        cost,
+                        fits,
+                        timestamp: new Date().toISOString(),
+                    };
+                    if (_onIntercept) {
+                        _onIntercept(event);
+                    }
+                }
+            }
+            catch {
+                // Non-blocking — never break the actual API call
+            }
+        }
+        return originalFetch(input, init);
+    };
+}

package/dist/models.d.ts

@@ -0,0 +1,8 @@
+export interface ModelInfo {
+    input: number;
+    output: number;
+    context: number;
+}
+export declare const MODELS: Record<string, ModelInfo>;
+export declare function getModel(name: string): ModelInfo | undefined;
+export declare function listModels(): string[];

package/dist/models.js

@@ -0,0 +1,24 @@
+export const MODELS = {
+    // Anthropic
+    'claude-opus': { input: 15.00, output: 75.00, context: 200000 },
+    'claude-sonnet': { input: 3.00, output: 15.00, context: 200000 },
+    'claude-haiku': { input: 0.25, output: 1.25, context: 200000 },
+    // xAI
+    'grok-3': { input: 5.00, output: 15.00, context: 131072 },
+    'grok-3-mini': { input: 0.30, output: 0.50, context: 131072 },
+    // Google
+    'gemini-2.0-flash': { input: 0.10, output: 0.40, context: 1048576 },
+    'gemini-2.0-pro': { input: 1.25, output: 5.00, context: 1048576 },
+    // OpenAI
+    'gpt-4o': { input: 2.50, output: 10.00, context: 128000 },
+    'gpt-4o-mini': { input: 0.15, output: 0.60, context: 128000 },
+    'gpt-4.1': { input: 2.00, output: 8.00, context: 1047576 },
+    'gpt-4.1-mini': { input: 0.40, output: 1.60, context: 1047576 },
+    'gpt-4.1-nano': { input: 0.10, output: 0.40, context: 1047576 },
+};
+export function getModel(name) {
+    return MODELS[name] || MODELS[name.toLowerCase()];
+}
+export function listModels() {
+    return Object.keys(MODELS);
+}

package/dist/patterns.js

@@ -0,0 +1,30 @@
+export const AI_PATTERNS = [
+    // OpenAI
+    { name: 'OpenAI', regex: /openai\.chat\.completions\.create|new OpenAI\(|from\s+['"]openai['"]/g },
+    // Anthropic
+    { name: 'Anthropic', regex: /anthropic\.messages\.create|new Anthropic\(|from\s+['"]@anthropic-ai/g },
+    // Vercel AI SDK
+    { name: 'Vercel AI', regex: /from\s+['"]ai['"]|generateText|streamText|generateObject/g },
+    // LangChain
+    { name: 'LangChain', regex: /from\s+['"]langchain|ChatOpenAI|ChatAnthropic|\.invoke\(/g },
+    // Google Gemini
+    { name: 'Gemini', regex: /GoogleGenerativeAI|generateContent|from\s+['"]@google\/generative/g },
+    // AWS Bedrock
+    { name: 'Bedrock', regex: /BedrockRuntimeClient|InvokeModelCommand/g },
+    // xAI Grok
+    { name: 'Grok', regex: /x\.ai\/api|xai\.chat|from\s+['"]grok/g },
+    // Raw fetch to AI endpoints
+    { name: 'fetch (AI)', regex: /fetch\(.*api\.openai\.com|fetch\(.*api\.anthropic\.com|fetch\(.*generativelanguage\.googleapis/g },
+    // Cohere
+    { name: 'Cohere', regex: /from\s+['"]cohere|CohereClient|cohere\.chat/g },
+    // Mistral
+    { name: 'Mistral', regex: /from\s+['"]@mistralai|MistralClient/g },
+];
+export const SKIP_DIRS = new Set([
+    'node_modules', '.git', 'dist', 'build', '.next', '.nuxt', '.svelte-kit',
+    'coverage', '.turbo', '.cache', '__pycache__', '.venv', 'venv',
+    'target', 'zig-out', 'zig-cache',
+]);
+export const SCAN_EXTENSIONS = new Set([
+    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.mts', '.py', '.rs',
+]);

package/dist/preflight.d.ts

@@ -0,0 +1,16 @@
+export interface Alternative {
+    model: string;
+    cost: number;
+    savings: number;
+    savingsPercent: number;
+}
+export interface PreflightResult {
+    tokens: number;
+    cost: number;
+    fits: boolean;
+    model: string;
+    context: number;
+    utilization: number;
+    options: Alternative[];
+}
+export declare function preflight(content: string, model: string): PreflightResult;

package/dist/preflight.js

@@ -0,0 +1,27 @@
+import { slash } from './slash.js';
+import { getModel, MODELS } from './models.js';
+export function preflight(content, model) {
+    const tokens = slash(content);
+    const info = getModel(model);
+    if (!info) {
+        throw new Error(`Unknown model: "${model}". Available: ${Object.keys(MODELS).join(', ')}`);
+    }
+    const cost = Math.round(((tokens / 1000000) * info.input) * 1000000) / 1000000;
+    const fits = tokens <= info.context;
+    const utilization = Math.round((tokens / info.context) * 10000) / 10000;
+    const options = Object.entries(MODELS)
+        .filter(([m]) => m !== model)
+        .filter(([_, v]) => v.context >= tokens)
+        .map(([m, v]) => {
+        const altCost = Math.round(((tokens / 1000000) * v.input) * 1000000) / 1000000;
+        return {
+            model: m,
+            cost: altCost,
+            savings: Math.round((cost - altCost) * 1000000) / 1000000,
+            savingsPercent: cost > 0 ? Math.round(((cost - altCost) / cost) * 10000) / 100 : 0,
+        };
+    })
+        .filter(o => o.savings > 0)
+        .sort((a, b) => a.cost - b.cost);
+    return { tokens, cost, fits, model, context: info.context, utilization, options };
+}

package/dist/report.d.ts

@@ -1,2 +1,2 @@
-import { CallSite } from './scanner';
+import { CallSite } from './scanner.js';
 export declare function printReport(sites: CallSite[], filesScanned: number, timeMs: number, cwd: string): void;

package/dist/report.js

@@ -0,0 +1,69 @@
+// ANSI — zero deps
+const R = '\x1b[0m';
+const B = '\x1b[1m';
+const DIM = '\x1b[2m';
+const ORANGE = '\x1b[38;2;255;68;0m';
+const GOLD = '\x1b[38;2;230;161;65m';
+const WHITE = '\x1b[97m';
+const GRAY = '\x1b[90m';
+function pad(s, n) {
+    return s.length >= n ? s : s + ' '.repeat(n - s.length);
+}
+function formatNum(n) {
+    return n.toLocaleString('en-US');
+}
+export function printReport(sites, filesScanned, timeMs, cwd) {
+    console.log('');
+    console.log(`${ORANGE}${B}  ⚡ /slash${R}`);
+    console.log(`${GRAY}  Token burn analysis${R}`);
+    console.log('');
+    console.log(`${DIM}  Scanned ${filesScanned} files in ${timeMs}ms${R}`);
+    console.log('');
+    if (sites.length === 0) {
+        console.log(`${WHITE}  No AI API call sites detected.${R}`);
+        console.log(`${GRAY}  Supported: OpenAI, Anthropic, Vercel AI, LangChain, Gemini, Bedrock, Grok${R}`);
+        console.log('');
+        return;
+    }
+    // Call sites
+    console.log(`${ORANGE}  CALL SITES${R}`);
+    console.log(`${DIM}  ${'─'.repeat(60)}${R}`);
+    for (const site of sites) {
+        const loc = site.file.replace(cwd + '/', '') + ':' + site.line;
+        console.log(`${WHITE}  ${pad(loc, 40)} ${GOLD}${pad(site.sdk, 12)} ${ORANGE}~${formatNum(site.tokensPerCall)} tok/call${R}`);
+    }
+    console.log('');
+    // Daily estimates (100 calls/site/day)
+    const callsPerDay = 100;
+    const dailyInput = sites.reduce((sum, s) => sum + s.tokensPerCall * callsPerDay, 0);
+    const dailyOutput = dailyInput * 2; // Estimate output at 2x input
+    const dailyTotal = dailyInput + dailyOutput;
+    const monthlyTotal = dailyTotal * 30;
+    // Cost at $3/MTok input, $15/MTok output (GPT-4o class)
+    const monthlyCostInput = (dailyInput * 30 / 1000000) * 3;
+    const monthlyCostOutput = (dailyOutput * 30 / 1000000) * 15;
+    const monthlyCost = monthlyCostInput + monthlyCostOutput;
+    console.log(`${ORANGE}  DAILY BURN ${GRAY}(${callsPerDay} calls/site/day)${R}`);
+    console.log(`${DIM}  ${'─'.repeat(60)}${R}`);
+    console.log(`${WHITE}  Input tokens:    ${B}${formatNum(dailyInput)}${R}`);
+    console.log(`${WHITE}  Output tokens:   ${B}${formatNum(dailyOutput)}${R}  ${GRAY}(estimated)${R}`);
+    console.log(`${WHITE}  Total:           ${ORANGE}${B}${formatNum(dailyTotal)} tokens/day${R}`);
+    console.log('');
+    console.log(`${ORANGE}  MONTHLY COST ${GRAY}($3/$15 per MTok)${R}`);
+    console.log(`${DIM}  ${'─'.repeat(60)}${R}`);
+    console.log(`${WHITE}  Input:           ${B}$${monthlyCostInput.toFixed(2)}/mo${R}`);
+    console.log(`${WHITE}  Output:          ${B}$${monthlyCostOutput.toFixed(2)}/mo${R}`);
+    console.log(`${WHITE}  Total:           ${ORANGE}${B}$${monthlyCost.toFixed(2)}/mo${R}`);
+    console.log('');
+    // Slash savings (conservative 10% gate savings)
+    const savingsPct = 10;
+    const monthlySaved = monthlyCost * savingsPct / 100;
+    console.log(`${GOLD}  ⚡ SLASH SAVINGS ${GRAY}(${savingsPct}% gate efficiency)${R}`);
+    console.log(`${DIM}  ${'─'.repeat(60)}${R}`);
+    console.log(`${WHITE}  Monthly savings: ${GOLD}${B}$${monthlySaved.toFixed(2)}/mo${R}`);
+    console.log(`${WHITE}  Annual savings:  ${GOLD}${B}$${(monthlySaved * 12).toFixed(2)}/yr${R}`);
+    console.log('');
+    console.log(`${GRAY}  4.8 KB WASM · sub-ms · zero deps${R}`);
+    console.log(`${GRAY}  → ${ORANGE}slashtokens.com${R}`);
+    console.log('');
+}

package/dist/scanner.js

@@ -0,0 +1,81 @@
+import { readdirSync, readFileSync, statSync } from 'fs';
+import { join, extname } from 'path';
+import { slash } from './slash.js';
+import { AI_PATTERNS, SKIP_DIRS, SCAN_EXTENSIONS } from './patterns.js';
+function walkDir(dir, files) {
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (SKIP_DIRS.has(entry))
+            continue;
+        const full = join(dir, entry);
+        let stat;
+        try {
+            stat = statSync(full);
+        }
+        catch {
+            continue;
+        }
+        if (stat.isDirectory()) {
+            walkDir(full, files);
+        }
+        else if (SCAN_EXTENSIONS.has(extname(entry))) {
+            files.push(full);
+        }
+    }
+}
+function findCallSites(filePath, content) {
+    const sites = [];
+    const lines = content.split('\n');
+    for (const pattern of AI_PATTERNS) {
+        // Reset regex
+        pattern.regex.lastIndex = 0;
+        let match;
+        while ((match = pattern.regex.exec(content)) !== null) {
+            // Find line number
+            const beforeMatch = content.substring(0, match.index);
+            const lineNum = beforeMatch.split('\n').length;
+            // Estimate tokens from surrounding context (grab the function/block)
+            const startLine = Math.max(0, lineNum - 5);
+            const endLine = Math.min(lines.length, lineNum + 20);
+            const context = lines.slice(startLine, endLine).join('\n');
+            const tokensPerCall = slash(context);
+            // Avoid duplicates at same location
+            if (!sites.some(s => s.line === lineNum && s.sdk === pattern.name)) {
+                sites.push({
+                    file: filePath,
+                    line: lineNum,
+                    sdk: pattern.name,
+                    tokensPerCall,
+                });
+            }
+        }
+    }
+    return sites;
+}
+export function scan(dir) {
+    const start = performance.now();
+    const files = [];
+    walkDir(dir, files);
+    const sites = [];
+    for (const file of files) {
+        let content;
+        try {
+            content = readFileSync(file, 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        sites.push(...findCallSites(file, content));
+    }
+    return {
+        sites,
+        filesScanned: files.length,
+        timeMs: Math.round(performance.now() - start),
+    };
+}

package/dist/slash.js

@@ -0,0 +1,26 @@
+import { getInstance, writeToMemory } from './wasm.js';
+const WASM_INPUT_OFFSET = 4096;
+/**
+ * Estimate token count for a string.
+ * Sub-millisecond. Zero allocations in WASM.
+ */
+export function slash(content) {
+    if (!content)
+        return 0;
+    const len = writeToMemory(content);
+    const instance = getInstance();
+    return instance.exports.estimate_tokens(WASM_INPUT_OFFSET, len);
+}
+/**
+ * Estimate token count from raw bytes.
+ */
+export function slashBytes(bytes) {
+    if (!bytes.length)
+        return 0;
+    const instance = getInstance();
+    const memory = instance.exports.memory;
+    const buffer = new Uint8Array(memory.buffer);
+    const maxLen = Math.min(bytes.length, buffer.length - WASM_INPUT_OFFSET - 1);
+    buffer.set(bytes.subarray(0, maxLen), WASM_INPUT_OFFSET);
+    return instance.exports.estimate_tokens(WASM_INPUT_OFFSET, maxLen);
+}

package/dist/transact.d.ts

@@ -0,0 +1,15 @@
+export interface ReportOptions {
+    key?: string;
+    tokens_estimated: number;
+    tokens_saved: number;
+    model?: string;
+    action: 'skipped' | 'reduced' | 'routed';
+    cost_saved_usd: number;
+}
+export interface ReportResult {
+    transaction_id: string;
+    fee_usd: number;
+    balance_remaining_usd: number;
+    timestamp: string;
+}
+export declare function report(opts: ReportOptions): Promise<ReportResult>;

package/dist/transact.js

@@ -0,0 +1,28 @@
+import { resolveKey, getEndpoint } from './config.js';
+export async function report(opts) {
+    const key = resolveKey(opts.key);
+    const endpoint = getEndpoint();
+    const res = await fetch(endpoint, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${key}`,
+        },
+        body: JSON.stringify({
+            tokens_estimated: opts.tokens_estimated,
+            tokens_saved: opts.tokens_saved,
+            model: opts.model || 'unknown',
+            action: opts.action,
+            cost_saved_usd: opts.cost_saved_usd,
+        }),
+    });
+    if (res.status === 401)
+        throw new Error('Invalid Slash API key');
+    if (res.status === 402)
+        throw new Error('Insufficient balance. Purchase credits at slashtokens.com');
+    if (res.status === 429)
+        throw new Error('Rate limited. Try again shortly.');
+    if (!res.ok)
+        throw new Error(`Slash API error: ${res.status}`);
+    return res.json();
+}

package/dist/wasm.js

@@ -0,0 +1,34 @@
+// Auto-generated WASM binary (4,865 bytes / xai-faf-zig ghost engine)
+// Contains estimate_tokens(ptr, len) -> u32
+const WASM_BASE64 = "AGFzbQEAAAABLAZgAn9/AX9gBH9/f38AYAZ/f39/f38AYAV/f39/fwBgBH9/f38Bf2ABfwF/AxEQAAABAQIDBAQBBAMAAAUABQUDAQARBgkBfwFBgIDAAAsHWQYGbWVtb3J5AgAJc2NvcmVfZmFmAAAUc2NvcmVfZmFmX2VudGVycHJpc2UACwx2YWxpZGF0ZV9mYWYADAhnZXRfdGllcgAND2VzdGltYXRlX3Rva2VucwAOCoEaEBAAIAAgARCBgICAAEH/AXELSgEBfyOAgICAAEEQayICJICAgIAAAkACQCABDQBBACEBDAELIAJBC2ogACABQQAQgoCAgAAgAi0ACyEBCyACQRBqJICAgIAAIAEL/wcBE38jgICAgABB0ABrIgQkgICAgABBqIHAgABBgIDAgAAgA0EBcSIFGyEGQSFBFSAFGyEHQQAhCEEAIQlBACEKA0ACQAJAAkAgCCAHRg0AIARBOGogBiAIQQN0aiIFKAIAIgsgBSgCBCIFQeeIwIAAEIOAgIAAAkAgBC0APA0AQQAhDAwCC0EBIQ0gBSAEKAI4Ig5BAWoiD2shECALIA9qIRFBACESQQAhEwNAQQAhDAJAAkAgDUH/AXENAEEAIQ1BACEFQQAhDwwBCyAEQcgAaiABIAIgEkH3iMCAAEEBEISAgIAAIAQoAkgiFCACIAQtAEwiFRsgEmshDyABIBJqIQUgFUEARyENIBRBAWpBACAVGyESCyAFRQ0CIARBMGogBSAPQfWIwIAAQQEQhYCAgAAgBCgCMCEWIAQoAjQiDEUNAEEAIQVBACEPA0ACQAJAIAwgBUYNAAJAIBYgBWotAAAiFEEJRg0AQQEhFSAUQSBHDQEMAgtBAiEVDAELAkAgDw0AIARBGGogFiAMQfmIwIAAQQIQhYCAgABBACETIAQoAhgiDyAEKAIcIgUgCyAOEIaAgIAAQQFxRQ0DIAUgDk0NAyAPIA5qLQAAQTpGIRMMAwsgEyAPQQFHcUUNAiAEQShqIBYgDEH5iMCAAEECEIWAgIAAQQEhEyAEKAIoIhUgBCgCLCIPIBEgEBCGgICAAEEBcUUNAiAPIBBNDQIgFSAQai0AAEE6Rw0CIARBwABqIBUgD0HliMCAABCDgICAACAELQBERQ0CQQAhDEEAIQUgDyAEKAJAQQFqIhRNDQUgBEEgaiAVIBRqIA8gFGtB8IjAgABBBBCFgICAACAEKAIgQQAgBCgCJCIFGyEMIAVBACAFGyEFDAULIAVBAWohBSAVIA9qIQ8MAAsLC0EhQRUgA0EBcRsiBSAJayEPQQAhFQJAIAUgCUH/AXFGDQAgCkH/AXFB5ABsIA9B/wFxIhVBAXZqIBVuIRULIAAgBToABCAAIA86AAMgACAJOgACIAAgCjoAASAAIBVB/wFxIgVB5AAgBUHkAEkbOgAAIARB0ABqJICAgIAADwtBACEFCwJAIAxFDQAgBEEQaiAMIAVB6YjAgABBBhCFgICAAAJAIAQoAhAgBCgCFEHKiMCAAEELEIeAgIAAQQFxDQAgBEEIaiAMIAVB6YjAgABBBhCFgICAACAEKAIMIgxFDQEgBCgCCCEWQbh/IQUCQANAIAVBCGoiD0UNASAFQciJwIAAaiEVIAVBxInAgABqIRQgDyEFIBYgDCAUKAIAIBUoAgAQh4CAgABBAXFFDQAMAwsLIApBAWohCgwBCyAJQQFqIQkLIAhBAWohCAwACws/AQF/I4CAgIAAQRBrIgQkgICAgAAgBEEIaiABIAJBACADQQEQhICAgAAgACAEKQMINwIAIARBEGokgICAgAALsQMDAn8BfgF/I4CAgIAAQZAIayIGJICAgIAAAkACQCACIAVPDQAgAEIANwIADAELAkACQAJAAkACQCAFQQFLDQAgBQ0BIABBAToABAwECyACQTRJDQEgBUEFSQ0BQQAhBwwCCyAGQQhqIAEgAiADIAQtAAAQioCAgAAgACAGKQMINwIADAMLIAIgBWshBwNAAkACQAJAIAMgB00NAEEAIQNCACEIDAELIAEgA2ogBSAEIAUQiYCAgABBAXFFDQFCgICAgBAhCAsgACAIIAOthDcCAAwECyADQQFqIQMMAAsLAkADQCAHQYAIRg0BIAZBEGogB2ogBTYCACAHQQRqIQcMAAsLIAVBf2ohByAEIQkDQAJAIAcNACACIAVrIQkDQAJAIAMgCU0NACAAQgA3AgAMBQsCQCABIANqIgcgBSAEIAUQiYCAgABBAXFFDQAgAEEBOgAEDAQLIAZBEGogByAFakF/ai0AAEECdGooAgAgA2ohAwwACwsgBkEQaiAJLQAAQQJ0aiAHNgIAIAlBAWohCSAHQX9qIQcMAAsLIAAgAzYCAAsgBkGQCGokgICAgAALrgEBBH8jgICAgABBEGsiBSSAgICAAEEAIQYCQANAAkAgAiAGRw0AIAIhBgwCCyAFIAMgBCABIAZqLQAAEIiAgIAAIAUtAARFDQEgBkEBaiEGDAALCyABQX9qIQcCQANAIAIiCCAGTQ0BIAVBCGogAyAEIAcgCGotAAAQiICAgAAgCEF/aiECIAUtAAwNAAsLIAAgCCAGazYCBCAAIAEgBmo2AgAgBUEQaiSAgICAAAskAQF/QQAhBAJAIAMgAUsNACAAIAMgAiADEImAgIAAIQQLIAQLeQECf0EAIQQCQCABIANHDQADQCABRSEEIAFFDQEgAi0AACEDIAAtAAAhBSACQQFqIQIgAEEBaiEAIAFBf2ohASAFQSBqIAUgBUG/f2pB/wFxQRpJG0H/AXEgA0EgaiADIANBv39qQf8BcUEaSRtB/wFxRg0ACwsgBAs9AQF/I4CAgIAAQRBrIgQkgICAgAAgBEEIaiABIAJBACADEIqAgIAAIAAgBCkDCDcCACAEQRBqJICAgIAAC/0CAQV/I4CAgIAAQRBrIgQkgICAgAACQAJAIAEgA0cNAEEBIQUgAUUNASAAQarVqtV6IAEbIgYgAkGq1arVeiADGyIHRg0BAkAgAUEQSw0AAkAgAUEETw0AIAAtAAAgBy0AAEYgACABQX9qIgNqLQAAIAcgA2otAABGcSAAIAFBAXYiA2otAAAgByADai0AAEZxIQUMAwtBACEDIARBADYCACAEIAFBfGoiBTYCBCAEIAFBAXZBDHEiADYCCCAEIAUgAGs2AgxBACEFAkADQCADQRBGDQEgByAEIANqKAIAIgBqKAAAIAYgAGooAABzIAVyIQUgA0EEaiEDDAALCyAFRSEFDAILIAFBf2pBAnZBAWohACAGIQMgByEFAkADQCAAQX9qIgBFDQEgBSgAACECIAMoAAAhCCADQQRqIQMgBUEEaiEFIAggAkcNAgwACwsgBiABQXxqIgNqKAAAIAcgA2ooAABGIQUMAQtBACEFCyAEQRBqJICAgIAAIAULWAACQCADIAJJDQAgAEIANwIADwsgBEH/AXEhBAJAA0AgAiADRg0BAkAgASADai0AACAERw0AIABBAToABCAAIAM2AgAPCyADQQFqIQMMAAsLIABCADcCAAtOAQF/I4CAgIAAQRBrIgIkgICAgAACQAJAIAENAEEAIQEMAQsgAkELaiAAIAFBARCCgICAACACLQALIQELIAJBEGokgICAgAAgAUH/AXELFAAgACABEIGAgIAAQf8BcUHjAEsLCAAgAEHjAEsL5gQBCH8jgICAgABBEGsiAiSAgICAAAJAAkAgAQ0AQQAhAwwBCyACIAAtAAAiBBCPgICAAEEHcSIDOgAPIANBBHNBB3FBAnQiA0GcisCAAGohBSADQfyJwIAAaiEGIANB3InAgABqIQcgA0G8icCAAGohA0EAIQgCQAJAAkAgBEGFf2oOAwECAQALIARBWGpBAk8NAQtBASEICyAFKAIAIQUgBigCACEJIAcoAgAhBiADKAIAIQcgAUF/aiEDIABBAWohAANAAkACQAJAAkACQAJAAkACQCADRQ0AIAAtAAAiBBCPgICAAEEHcQ4GBAQHAQIDBAsgCEHkAGwgAW4hCCAGQeQAbCABbiEDIAdB5ABsIAFuIQAgBUHkAGwgAW4hBCAJIAZqQeQAbCABbkEjSQ0EIANBBU8NBEE4IQMMBQsgCUEBaiEJDAULIAZBAWohBgwECyAHQQFqIQcMAwsgBUEBaiEFDAILAkAgBEHBAEkNACADQQJLDQAgAEEITw0AQTYhAwwBCwJAIAhBAkkNACADQQRJDQAgAEENTQ0AQRohAwwBCwJAIABBFU0NAEEcIQMMAQsCQCADQQRJDQAgAEENTQ0AQSAhAwwBCwJAIABBDkkNACAEQcgASw0AIAhBAk8NAEEeIQMMAQtBIUEjIABBBksbQSMgA0EESxshAwsgA0EBdiABQQpsaiADbiIDQSFuIANqIgNBASADQQFLGyEDDAILAkACQCAEQVhqQQJJDQAgBEGFf2oOAwABAAELIAhBAWohCAsgA0F/aiEDIABBAWohAAwACwsgAkEQaiSAgICAACADC3UBAX8CQCAAQZ9/akH/AXFBGk8NAEEADwsCQCAAQb9/akH/AXFBGk8NAEEBDwsCQCAAQVBqQf8BcUEKTw0AQQIPC0EDIQECQAJAAkACQCAAQf8BcSIAQXdqDgUDAgEBAgALIABBIEYNAgtBBQ8LQQQhAQsgAQsLxgoBAEGAgMAAC7wKvwMQAAwAAAAjAxAADAAAAP0DEAAVAAAAsQIQABEAAAAxAhAAEgAAAMEBEAARAAAAiQMQABMAAADoAhAAEgAAAPABEAARAAAAIQQQAA4AAABLAxAAEwAAALABEAAQAAAAGgIQABYAAAAwBBAADQAAAJ0DEAAOAAAAsQMQAA0AAAB6AxAADgAAAMsCEAAQAAAAbAMQAA0AAAA+BBAACwAAAFYEEAAKAAAAvwMQAAwAAAAjAxAADAAAAP0DEAAVAAAAsQIQABEAAAAxAhAAEgAAAMEBEAARAAAAiQMQABMAAADoAhAAEgAAAPABEAARAAAAIQQQAA4AAABLAxAAEwAAALABEAAQAAAAGgIQABYAAAAwBBAADQAAAJ0DEAAOAAAAsQMQAA0AAAB6AxAADgAAAMsCEAAQAAAAbAMQAA0AAAA+BBAACwAAAFYEEAAKAAAACgMQABMAAACbAhAAFQAAAG4CEAAQAAAAAgIQABcAAAB/AhAAGwAAANwCEAALAAAA8QMQAAsAAABfAxAADAAAABMEEAANAAAA0wEQABwAAABWAhAAFwAAANsDEAAVAAAAc3RhY2sudWlfbGlicmFyeQBodW1hbl9jb250ZXh0LndoeQBtb25vcmVwby52ZXJzaW9uaW5nX3N0cmF0ZWd5AGh1bWFuX2NvbnRleHQuaG93AG1vbm9yZXBvLnBhY2thZ2VzX2NvdW50AHN0YWNrLnN0YXRlX21hbmFnZW1lbnQAaHVtYW5fY29udGV4dC53aGF0AGRldmVsb3BtZW50IHRlYW1zAG1vbm9yZXBvLnNoYXJlZF9jb25maWdzAHN0YWNrLndvcmtzcGFjZXMAbW9ub3JlcG8uYnVpbGRfb3JjaGVzdHJhdG9yAHN0YWNrLnBhY2thZ2VfbWFuYWdlcgBodW1hbl9jb250ZXh0LndobwB1bmtub3duAHN0YWNrLmNvbm5lY3Rpb24Ac3RhY2suYWRtaW4AaHVtYW5fY29udGV4dC53aGVuAGNsb3VkIHBsYXRmb3JtAHN0YWNrLm1vbm9yZXBvX3Rvb2wAbnVsbABwcm9qZWN0LmdvYWwAZGVzY3JpYmUgeW91ciBwcm9qZWN0IGdvYWwAc3RhY2suY3NzX2ZyYW1ld29yawBzdGFjay5zZWFyY2gAc3RhY2suaG9zdGluZwBzdGFjay5kYXRhYmFzZQBodW1hbl9jb250ZXh0LndoZXJlAHN0YWNrLmFwaV90eXBlAG5vbmUAc3RhY2sucnVudGltZQBwcm9qZWN0Lm5hbWUAbm90IGFwcGxpY2FibGUAbW9ub3JlcG8ucmVtb3RlX2NhY2hlAHN0YWNrLmNhY2hlAHByb2plY3QubWFpbl9sYW5ndWFnZQBzdGFjay5zdG9yYWdlAHN0YWNrLmZyb250ZW5kAHN0YWNrLmJhY2tlbmQAc3RhY2suYnVpbGQAc2xvdGlnbm9yZWQAc3RhY2suY2ljZABuL2EAOgAuACAJDQoiJwAgCSInAA0ACgAgCQAwAxAAGgAAAEQCEAARAAAA+wIQAA4AAAAeAxAABAAAAKwDEAAEAAAAwwIQAAcAAABhBBAAAwAAAMwDEAAOAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAAAAAAAAAAA=";
+const WASM_INPUT_OFFSET = 4096;
+const encoder = new TextEncoder();
+let _instance = null;
+function decodeBase64(b64) {
+    if (typeof Buffer !== 'undefined') {
+        return new Uint8Array(Buffer.from(b64, 'base64'));
+    }
+    const binary = atob(b64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}
+export function getInstance() {
+    if (_instance)
+        return _instance;
+    const bytes = decodeBase64(WASM_BASE64);
+    const module = new WebAssembly.Module(bytes);
+    _instance = new WebAssembly.Instance(module);
+    return _instance;
+}
+export function writeToMemory(content) {
+    const instance = getInstance();
+    const bytes = encoder.encode(content);
+    const memory = instance.exports.memory;
+    const buffer = new Uint8Array(memory.buffer);
+    const maxLen = Math.min(bytes.length, buffer.length - WASM_INPUT_OFFSET - 1);
+    buffer.set(bytes.subarray(0, maxLen), WASM_INPUT_OFFSET);
+    return maxLen;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "slash-tokens",
-  "version": "0.1.0",
-  "description": "Token budget estimation in 4.8 KB WASM. Sub-millisecond. Zero dependencies. I don't count tokens. I slash them.",
+  "version": "0.3.0",
+  "description": "Pre-flight checks for API calls. 4.8 KB WASM. Sub-millisecond. Zero dependencies. Fly First. Pay Economy.",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -13,12 +13,16 @@
     ".": {
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
+    },
+    "./auto": {
+      "import": "./dist/auto.js",
+      "types": "./dist/auto.d.ts"
     }
   },
   "files": ["dist"],
   "sideEffects": false,
   "scripts": {
-    "build": "bun build src/cli.ts --outfile=dist/cli.js --target=node && tsc --emitDeclarationOnly && bun build src/index.ts --outfile=dist/index.js --target=node",
+    "build": "npx tsc && bun build src/cli.ts --outfile=dist/cli.js --target=node",
     "test": "bun test"
   },
   "author": "wolfejam",