atune 0.1.0

package/dist/auth.d.ts

@@ -0,0 +1,12 @@
+import type { AtuneAccount } from "./capture.js";
+export type GetAccount = (request: Request) => AtuneAccount | null | Promise<AtuneAccount | null>;
+type OptionalImporter = (moduleName: string) => Promise<unknown>;
+export type ResolveAccountOptions = {
+    getAccount?: GetAccount;
+    importer?: OptionalImporter;
+};
+export declare function resolveAtuneAccount(request: Request, options?: ResolveAccountOptions): Promise<AtuneAccount | null>;
+export declare function resolveClerk(importer?: OptionalImporter): Promise<AtuneAccount | null>;
+export declare function resolveNextAuth(importer?: OptionalImporter): Promise<AtuneAccount | null>;
+export declare function resolveSupabase(importer?: OptionalImporter): Promise<AtuneAccount | null>;
+export {};

package/dist/auth.js

@@ -0,0 +1,56 @@
+const optionalImport = (moduleName) => import(/* webpackIgnore: true */ /* turbopackIgnore: true */ moduleName);
+export async function resolveAtuneAccount(request, options = {}) {
+    if (options.getAccount)
+        return options.getAccount(request);
+    const importer = options.importer ?? optionalImport;
+    return (await resolveClerk(importer)) ?? (await resolveNextAuth(importer)) ?? (await resolveSupabase(importer)) ?? null;
+}
+export async function resolveClerk(importer = optionalImport) {
+    try {
+        const mod = (await importer("@clerk/nextjs/server"));
+        const session = await mod.auth?.();
+        if (session?.userId)
+            return { accountId: session.orgId ?? session.userId, userId: session.userId };
+    }
+    catch { }
+    return null;
+}
+export async function resolveNextAuth(importer = optionalImport) {
+    try {
+        const mod = (await importer("next-auth"));
+        const session = mod.getServerSession ? await mod.getServerSession() : mod.auth ? await mod.auth() : null;
+        const user = session?.user;
+        if (!user)
+            return null;
+        const account = user.orgId ?? user.organizationId ?? user.teamId ?? user.tenantId ?? user.companyId ?? user.id ?? user.sub ?? user.email;
+        if (!account)
+            return null;
+        const userId = user.id ?? user.sub ?? user.email;
+        return { accountId: String(account), userId: userId == null ? undefined : String(userId) };
+    }
+    catch { }
+    return null;
+}
+export async function resolveSupabase(importer = optionalImport) {
+    try {
+        const nextHeaders = (await importer("next/headers"));
+        const supabaseMod = (await importer("@supabase/ssr"));
+        const store = await nextHeaders.cookies?.();
+        const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL;
+        const supabaseKey = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY;
+        if (!store || !supabaseUrl || !supabaseKey || !supabaseMod.createServerClient)
+            return null;
+        const supabase = supabaseMod.createServerClient(supabaseUrl, supabaseKey, {
+            cookies: { getAll: () => store.getAll(), setAll: () => { } },
+        });
+        const { data } = await supabase.auth.getSession();
+        const user = data.session?.user;
+        if (!user)
+            return null;
+        const meta = { ...(user.app_metadata ?? {}), ...(user.user_metadata ?? {}) };
+        const account = meta.org_id ?? meta.organization_id ?? meta.team_id ?? meta.tenant_id ?? meta.company_id ?? user.id;
+        return { accountId: String(account), userId: user.id };
+    }
+    catch { }
+    return null;
+}

package/dist/capture.d.ts

@@ -0,0 +1,15 @@
+export declare function normalizeRoute(pathname: string): string;
+export declare function captureEventName(method: string, pathname: string): string;
+export type AtuneAccount = {
+    accountId: string;
+    userId?: string;
+};
+export type CaptureEvent = {
+    event: string;
+    accountId: string;
+    userId?: string;
+    properties: {
+        statusCode: number;
+    };
+};
+export declare function buildCaptureEvent(account: AtuneAccount | null, method: string, pathname: string, statusCode: number): CaptureEvent | null;

package/dist/capture.js

@@ -0,0 +1,31 @@
+// Canonical capture logic for Atune's auto-instrumenting middleware.
+// Behavior only: identity traits never flow through capture.
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const CUID = /^c[a-z0-9]{20,}$/i;
+const LONG_HEX = /^[0-9a-f]{16,}$/i;
+const NUMERIC = /^\d+$/;
+export function normalizeRoute(pathname) {
+    const clean = (pathname || "/").split("?")[0].split("#")[0];
+    const segments = clean.split("/").filter(Boolean);
+    if (segments.length === 0)
+        return "/";
+    const normalized = segments.map((seg) => {
+        if (NUMERIC.test(seg) || UUID.test(seg) || CUID.test(seg) || LONG_HEX.test(seg))
+            return ":id";
+        return seg.toLowerCase();
+    });
+    return "/" + normalized.join("/");
+}
+export function captureEventName(method, pathname) {
+    return `http.${(method || "GET").toLowerCase()}.${normalizeRoute(pathname)}`;
+}
+export function buildCaptureEvent(account, method, pathname, statusCode) {
+    if (!account?.accountId)
+        return null;
+    return {
+        event: captureEventName(method, pathname),
+        accountId: account.accountId,
+        userId: account.userId,
+        properties: { statusCode },
+    };
+}

package/dist/cli-core.d.ts

@@ -0,0 +1,18 @@
+export type InitOptions = {
+    cwd?: string;
+    apiKey?: string;
+    atuneUrl?: string;
+    install?: boolean;
+    log?: (message: string) => void;
+};
+export type InitResult = {
+    framework: "next" | "unknown";
+    auth: "clerk" | "next-auth" | "supabase" | "unknown";
+    changedFiles: string[];
+    installed: boolean;
+    manualFallback: boolean;
+};
+export declare function initProject(options?: InitOptions): Promise<InitResult>;
+export declare function detectAuth(deps: Record<string, string>): InitResult["auth"];
+export declare function patchNextMiddleware(cwd: string, auth: InitResult["auth"]): string | null;
+export declare function appendEnv(cwd: string, apiKey: string, atuneUrl: string): string | null;

package/dist/cli-core.js

@@ -0,0 +1,126 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+export async function initProject(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const log = options.log ?? console.log;
+    const pkg = readPackage(cwd);
+    const deps = { ...(pkg.dependencies ?? {}), ...(pkg.devDependencies ?? {}) };
+    const framework = deps.next ? "next" : "unknown";
+    const auth = detectAuth(deps);
+    const changedFiles = [];
+    if (framework !== "next") {
+        log("Atune could not auto-wire this framework yet. Manually call createAtuneMiddleware() around your server requests.");
+        return { framework, auth, changedFiles, installed: false, manualFallback: true };
+    }
+    if (options.install !== false) {
+        installSdk(cwd);
+    }
+    const middlewarePath = patchNextMiddleware(cwd, auth);
+    if (middlewarePath)
+        changedFiles.push(middlewarePath);
+    const apiKey = options.apiKey ?? (await promptForApiKey());
+    const envPath = appendEnv(cwd, apiKey, options.atuneUrl ?? "https://useatune.com");
+    if (envPath)
+        changedFiles.push(envPath);
+    log("Atune is capturing. Add identify() on your login route to name your users.");
+    return { framework, auth, changedFiles, installed: options.install !== false, manualFallback: false };
+}
+export function detectAuth(deps) {
+    if (deps["@clerk/nextjs"])
+        return "clerk";
+    if (deps["next-auth"])
+        return "next-auth";
+    if (deps["@supabase/ssr"] || deps["@supabase/supabase-js"])
+        return "supabase";
+    return "unknown";
+}
+export function patchNextMiddleware(cwd, auth) {
+    const srcProxy = path.join(cwd, "src", "proxy.ts");
+    const rootProxy = path.join(cwd, "proxy.ts");
+    const rootMiddleware = path.join(cwd, "middleware.ts");
+    const target = [srcProxy, rootProxy, rootMiddleware].find((file) => existsSync(file)) ?? rootProxy;
+    const existing = existsSync(target) ? readFileSync(target, "utf8") : "";
+    if (existing.includes("atune") && existing.includes("createAtuneMiddleware"))
+        return null;
+    const next = existing ? patchExistingMiddleware(existing, auth) : freshMiddleware(auth);
+    writeFileSync(target, next);
+    return path.relative(cwd, target);
+}
+export function appendEnv(cwd, apiKey, atuneUrl) {
+    const envPath = path.join(cwd, ".env.local");
+    const existing = existsSync(envPath) ? readFileSync(envPath, "utf8") : "";
+    const additions = [];
+    if (!/^ATUNE_API_KEY=/m.test(existing))
+        additions.push(`ATUNE_API_KEY=${apiKey}`);
+    if (!/^ATUNE_URL=/m.test(existing))
+        additions.push(`ATUNE_URL=${atuneUrl}`);
+    if (additions.length === 0)
+        return null;
+    const prefix = existing && !existing.endsWith("\n") ? "\n" : "";
+    writeFileSync(envPath, `${existing}${prefix}${additions.join("\n")}\n`);
+    return ".env.local";
+}
+function patchExistingMiddleware(source, auth) {
+    let next = source;
+    if (!next.includes("createAtuneMiddleware")) {
+        next = `import { createAtuneMiddleware } from "atune";\n${next}`;
+    }
+    if (!next.includes("const atuneMiddleware = createAtuneMiddleware();")) {
+        next = next.replace(/((?:import[^\n]+\n)+)/, "$1\nconst atuneMiddleware = createAtuneMiddleware();\n");
+    }
+    if (auth === "clerk" && next.includes("clerkMiddleware") && !next.includes("return atuneMiddleware(request);")) {
+        next = next.replace(/\n\s*}\);\s*\n/, "\n  return atuneMiddleware(request);\n});\n");
+        return next;
+    }
+    return `${next.trimEnd()}\n\n// Atune capture is installed. If this proxy returns a custom response,\n// call atuneMiddleware(request, response) before returning it.\n`;
+}
+function freshMiddleware(auth) {
+    if (auth === "clerk") {
+        return `import { clerkMiddleware } from "@clerk/nextjs/server";
+import { createAtuneMiddleware } from "atune";
+
+const atuneMiddleware = createAtuneMiddleware();
+
+export default clerkMiddleware(async (_auth, request) => {
+  return atuneMiddleware(request);
+});
+
+export const config = {
+  matcher: ["/((?!_next|[^?]*\\\\.(?:html?|css|js(?!on)|jpe?g|webp|png|gif|svg|ttf|woff2?|ico|csv|docx?|xlsx?|zip|webmanifest)).*)"],
+};
+`;
+    }
+    return `import { createAtuneMiddleware } from "atune";
+
+const atuneMiddleware = createAtuneMiddleware();
+
+export default function proxy(request: Request) {
+  return atuneMiddleware(request);
+}
+
+export const config = {
+  matcher: ["/((?!_next|[^?]*\\\\.(?:html?|css|js(?!on)|jpe?g|webp|png|gif|svg|ttf|woff2?|ico|csv|docx?|xlsx?|zip|webmanifest)).*)"],
+};
+`;
+}
+function readPackage(cwd) {
+    const pkgPath = path.join(cwd, "package.json");
+    if (!existsSync(pkgPath))
+        return {};
+    return JSON.parse(readFileSync(pkgPath, "utf8"));
+}
+function installSdk(cwd) {
+    execFileSync("npm", ["i", "atune"], { cwd, stdio: "inherit" });
+}
+async function promptForApiKey() {
+    const rl = readline.createInterface({ input, output });
+    try {
+        return (await rl.question("Paste your ATUNE_API_KEY: ")).trim();
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { initProject } from "./cli-core.js";
+import { startMcpServer } from "./mcp.js";
+const [, , command] = process.argv;
+if (command === "mcp") {
+    startMcpServer();
+}
+else if (command === "init") {
+    initProject().catch((err) => {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    });
+}
+else {
+    console.log("Usage: npx atune init\n       npx atune mcp");
+    process.exit(command ? 1 : 0);
+}

package/dist/client.d.ts

@@ -0,0 +1,20 @@
+import type { AtuneAccount } from "./capture.js";
+export type IdentifyTraits = {
+    name?: string;
+    email?: string;
+};
+export type GroupTraits = {
+    company?: string;
+};
+export type AtuneRequestOptions = {
+    accountId?: string;
+    apiKey?: string;
+    url?: string;
+    fetch?: typeof fetch;
+    timeoutMs?: number;
+};
+export declare function identify(userId: string, traits?: IdentifyTraits, options?: AtuneRequestOptions): Promise<void>;
+export declare function group(accountId: string, traits?: GroupTraits, options?: AtuneRequestOptions): Promise<void>;
+export declare function postEvent(account: AtuneAccount, event: string, properties: Record<string, unknown>, options?: AtuneRequestOptions): Promise<void>;
+export declare function eventsEndpoint(url?: string): string;
+export declare function identifyEndpoint(url?: string): string;

package/dist/client.js

@@ -0,0 +1,51 @@
+export async function identify(userId, traits = {}, options = {}) {
+    if (!userId)
+        return;
+    await postIdentify({ accountId: options.accountId ?? userId, userId, traits }, options);
+}
+export async function group(accountId, traits = {}, options = {}) {
+    if (!accountId)
+        return;
+    await postIdentify({ accountId, traits }, options);
+}
+export function postEvent(account, event, properties, options = {}) {
+    const body = { accountId: account.accountId, userId: account.userId, event, properties };
+    return postJson(eventsEndpoint(options.url), body, options);
+}
+async function postIdentify(body, options) {
+    await postJson(identifyEndpoint(options.url), body, options);
+}
+async function postJson(endpoint, body, options) {
+    const apiKey = options.apiKey ?? process.env.ATUNE_API_KEY;
+    if (!apiKey || !endpoint)
+        return;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), options.timeoutMs ?? 1000);
+    try {
+        await (options.fetch ?? fetch)(endpoint, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` },
+            body: JSON.stringify(body),
+            signal: controller.signal,
+        });
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+export function eventsEndpoint(url = process.env.ATUNE_URL ?? "") {
+    return endpointFor(url, "/api/events");
+}
+export function identifyEndpoint(url = process.env.ATUNE_URL ?? "") {
+    return endpointFor(url, "/api/identify");
+}
+function endpointFor(rawUrl, path) {
+    if (!rawUrl)
+        return "";
+    const url = rawUrl.replace(/\/$/, "");
+    if (url.endsWith("/api/events"))
+        return path === "/api/events" ? url : url.replace(/\/api\/events$/, path);
+    if (url.endsWith("/api/identify"))
+        return path === "/api/identify" ? url : url.replace(/\/api\/identify$/, path);
+    return `${url}${path}`;
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { buildCaptureEvent, captureEventName, normalizeRoute } from "./capture.js";
+export type { AtuneAccount, CaptureEvent } from "./capture.js";
+export { identify, group } from "./client.js";
+export type { AtuneRequestOptions, GroupTraits, IdentifyTraits } from "./client.js";
+export { understand, understandEndpoint } from "./understand.js";
+export type { UnderstandCitation, UnderstandOptions, UnderstandResult } from "./understand.js";
+export { createAtuneMiddleware } from "./middleware.js";
+export type { AtuneMiddlewareOptions } from "./middleware.js";
+export { resolveAtuneAccount, resolveClerk, resolveNextAuth, resolveSupabase } from "./auth.js";
+export type { GetAccount, ResolveAccountOptions } from "./auth.js";

package/dist/index.js

@@ -0,0 +1,5 @@
+export { buildCaptureEvent, captureEventName, normalizeRoute } from "./capture.js";
+export { identify, group } from "./client.js";
+export { understand, understandEndpoint } from "./understand.js";
+export { createAtuneMiddleware } from "./middleware.js";
+export { resolveAtuneAccount, resolveClerk, resolveNextAuth, resolveSupabase } from "./auth.js";

package/dist/mcp.d.ts

@@ -0,0 +1,5 @@
+export declare function startMcpServer(input?: NodeJS.ReadStream & {
+    fd: 0;
+}, output?: NodeJS.WriteStream & {
+    fd: 1;
+}): void;

package/dist/mcp.js

@@ -0,0 +1,88 @@
+import { understand } from "./understand.js";
+export function startMcpServer(input = process.stdin, output = process.stdout) {
+    input.setEncoding("utf8");
+    let buffer = "";
+    input.on("data", (chunk) => {
+        buffer += chunk;
+        const lines = buffer.split(/\r?\n/);
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+            if (line.trim())
+                void handleLine(line, output);
+        }
+    });
+}
+async function handleLine(line, output) {
+    let request;
+    try {
+        request = JSON.parse(line);
+    }
+    catch {
+        write(output, { jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } });
+        return;
+    }
+    try {
+        if (request.method === "initialize") {
+            write(output, {
+                jsonrpc: "2.0",
+                id: request.id ?? null,
+                result: {
+                    protocolVersion: "2024-11-05",
+                    capabilities: { tools: {} },
+                    serverInfo: { name: "atune", version: "0.1.0" },
+                },
+            });
+            return;
+        }
+        if (request.method === "tools/list") {
+            write(output, {
+                jsonrpc: "2.0",
+                id: request.id ?? null,
+                result: {
+                    tools: [
+                        {
+                            name: "understand",
+                            description: "Ask Atune a grounded, cited question about a customer entity.",
+                            inputSchema: {
+                                type: "object",
+                                properties: {
+                                    entity: {
+                                        type: "string",
+                                        description: "One of: account:<externalId>, user:<accountExternalId>/<userExternalId>, feature:<key>, portfolio",
+                                    },
+                                    question: { type: "string" },
+                                },
+                                required: ["entity", "question"],
+                            },
+                        },
+                    ],
+                },
+            });
+            return;
+        }
+        if (request.method === "tools/call") {
+            const name = request.params?.name;
+            const args = (request.params?.arguments ?? {});
+            if (name !== "understand" || typeof args.entity !== "string" || typeof args.question !== "string") {
+                write(output, { jsonrpc: "2.0", id: request.id ?? null, error: { code: -32602, message: "Invalid understand tool arguments" } });
+                return;
+            }
+            const result = await understand(args.entity, args.question);
+            write(output, {
+                jsonrpc: "2.0",
+                id: request.id ?? null,
+                result: { content: [{ type: "text", text: JSON.stringify(result) }], structuredContent: result },
+            });
+            return;
+        }
+        if (request.id != null) {
+            write(output, { jsonrpc: "2.0", id: request.id, error: { code: -32601, message: "Method not found" } });
+        }
+    }
+    catch (err) {
+        write(output, { jsonrpc: "2.0", id: request.id ?? null, error: { code: -32000, message: err instanceof Error ? err.message : String(err) } });
+    }
+}
+function write(output, message) {
+    output.write(`${JSON.stringify(message)}\n`);
+}

package/dist/middleware.d.ts

@@ -0,0 +1,8 @@
+import { type AtuneRequestOptions } from "./client.js";
+import { type GetAccount } from "./auth.js";
+export type AtuneMiddlewareOptions = AtuneRequestOptions & {
+    getAccount?: GetAccount;
+};
+type MaybeResponse = Response | undefined | null;
+export declare function createAtuneMiddleware(options?: AtuneMiddlewareOptions): (request: Request, response?: MaybeResponse | Promise<MaybeResponse>) => Promise<Response>;
+export {};

package/dist/middleware.js

@@ -0,0 +1,45 @@
+import { buildCaptureEvent } from "./capture.js";
+import { postEvent } from "./client.js";
+import { resolveAtuneAccount } from "./auth.js";
+export function createAtuneMiddleware(options = {}) {
+    return async function atuneMiddleware(request, response) {
+        const resolvedResponse = (await response) ?? (await nextResponse());
+        captureAfterResponse(request, resolvedResponse, options);
+        return resolvedResponse;
+    };
+}
+function captureAfterResponse(request, response, options) {
+    try {
+        const method = request.method || "GET";
+        const pathname = requestPathname(request);
+        const statusCode = response.status || 200;
+        void Promise.resolve()
+            .then(async () => {
+            const account = await resolveAtuneAccount(request, { getAccount: options.getAccount });
+            const payload = buildCaptureEvent(account, method, pathname, statusCode);
+            if (!payload)
+                return;
+            await postEvent({ accountId: payload.accountId, userId: payload.userId }, payload.event, payload.properties, options);
+        })
+            .catch(() => { });
+    }
+    catch { }
+}
+function requestPathname(request) {
+    try {
+        return new URL(request.url).pathname;
+    }
+    catch {
+        return "/";
+    }
+}
+async function nextResponse() {
+    try {
+        const moduleName = "next/server";
+        const mod = (await import(moduleName));
+        return mod.NextResponse?.next?.() ?? new Response(null, { status: 200 });
+    }
+    catch {
+        return new Response(null, { status: 200 });
+    }
+}

package/dist/understand.d.ts

@@ -0,0 +1,20 @@
+export type UnderstandCitation = {
+    signal: string;
+    value: string;
+    when: string;
+};
+export type UnderstandResult = {
+    knows: boolean;
+    answer: string;
+    confidence: number;
+    citations: UnderstandCitation[];
+    recommendedNext: string | null;
+    signals: Record<string, unknown>;
+};
+export type UnderstandOptions = {
+    apiKey?: string;
+    url?: string;
+    fetch?: typeof fetch;
+};
+export declare function understand(entity: string, question: string, options?: UnderstandOptions): Promise<UnderstandResult>;
+export declare function understandEndpoint(rawUrl: string): string;

package/dist/understand.js

@@ -0,0 +1,31 @@
+export async function understand(entity, question, options = {}) {
+    const apiKey = options.apiKey ?? process.env.ATUNE_API_KEY;
+    const endpoint = understandEndpoint(options.url ?? process.env.ATUNE_URL ?? "");
+    if (!apiKey)
+        throw new Error("ATUNE_API_KEY is required");
+    if (!endpoint)
+        throw new Error("ATUNE_URL is required");
+    const response = await (options.fetch ?? fetch)(endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` },
+        body: JSON.stringify({ entity, question }),
+    });
+    if (!response.ok) {
+        throw new Error(`Atune understand() failed with ${response.status}: ${await response.text()}`);
+    }
+    return (await response.json());
+}
+export function understandEndpoint(rawUrl) {
+    if (!rawUrl)
+        return "";
+    const url = rawUrl.replace(/\/$/, "");
+    if (url.endsWith("/api/v1/understand"))
+        return url;
+    if (url.endsWith("/api/v1"))
+        return `${url}/understand`;
+    if (url.endsWith("/api/events"))
+        return url.replace(/\/api\/events$/, "/api/v1/understand");
+    if (url.endsWith("/api/identify"))
+        return url.replace(/\/api\/identify$/, "/api/v1/understand");
+    return `${url}/api/v1/understand`;
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "atune",
+  "version": "0.1.0",
+  "description": "Atune server-side SDK and installer — capture, identify, and understand() your customers.",
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/KrohnChris/Atune.git",
+    "directory": "packages/sdk"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "atune": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run"
+  },
+  "peerDependencies": {
+    "next": ">=14"
+  },
+  "peerDependenciesMeta": {
+    "next": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "typescript": "^5",
+    "vitest": "^3.2.6"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./capture": {
+      "types": "./dist/capture.d.ts",
+      "import": "./dist/capture.js"
+    },
+    "./understand": {
+      "types": "./dist/understand.d.ts",
+      "import": "./dist/understand.js"
+    }
+  }
+}