@kaoruisaac/pedelec 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Isaac Lin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,9 @@
+# Pedelec SDK
+[![npm version](https://img.shields.io/npm/v/@kaoruisaac/pedelec.svg)](https://www.npmjs.com/package/@kaoruisaac/pedelec)
+Browser SDK for connecting a web app to the Pedelec Chrome Extension and Desktop Runtime.
+
+```ts
+import { Pedelec } from "@kaoruisaac/pedelec";
+```
+
+See the repository README for full setup and usage documentation.

package/dist/extension-id.d.ts

@@ -0,0 +1 @@
+export declare const PEDELEC_EXTENSION_ID = "ogccgaminlphbkeghldidiiimajfdpag";

package/dist/extension-id.js

@@ -0,0 +1 @@
+export const PEDELEC_EXTENSION_ID = "ogccgaminlphbkeghldidiiimajfdpag";

package/dist/index.d.ts

@@ -0,0 +1,140 @@
+export type PedelecOptions = {
+    bridgeTimeoutMs?: number;
+};
+export type ProviderCode = "codex" | "gemini" | "opencode" | "cursor" | "claude";
+type CreateSessionInputWithProvider = {
+    provider: ProviderCode;
+    model?: string;
+    skillsUrls?: string[];
+};
+type CreateSessionInputWithDefaults = {
+    provider?: undefined;
+    model?: never;
+    skillsUrls?: string[];
+};
+export type CreateSessionInput = CreateSessionInputWithProvider | CreateSessionInputWithDefaults;
+export type ProviderInfo = {
+    name: string;
+    code: ProviderCode;
+    path: string | null;
+    available: boolean;
+    error: string | null;
+};
+export type PedelecSettings = {
+    defaultProvider: ProviderCode | null;
+    defaultModel: string | null;
+};
+export type ApprovalStatus = {
+    installed: boolean;
+    approved: boolean;
+    origin: string | null;
+};
+export type PedelecError = {
+    code: string;
+    message: string;
+    details?: unknown;
+};
+export type PedelecSessionStatus = "idle" | "running" | "waiting_tool_result" | "ended" | "error";
+type SessionEvent = {
+    type: "chat_delta";
+    channelId: string;
+    sessionId: string;
+    seq?: number;
+    text: string;
+} | {
+    type: "status_changed";
+    channelId: string;
+    sessionId: string;
+    seq?: number;
+    status: PedelecSessionStatus;
+} | {
+    type: "tool_call";
+    channelId: string;
+    sessionId: string;
+    seq?: number;
+    toolRequestId: string;
+    tool: string;
+    args: unknown;
+} | {
+    type: "done";
+    channelId: string;
+    sessionId: string;
+    seq?: number;
+} | {
+    type: "error";
+    channelId?: string;
+    sessionId?: string;
+    seq?: number;
+    error?: PedelecError;
+} | {
+    type: "ended";
+    channelId: string;
+    sessionId: string;
+    seq?: number;
+};
+type ChatHandler = (text: string) => void;
+type ToolHandler = (tool: string, args: unknown) => unknown | Promise<unknown>;
+type ErrorHandler = (error: PedelecError) => void;
+type StatusHandler = (status: PedelecSessionStatus) => void;
+type EndedHandler = () => void;
+export declare class Pedelec {
+    private readonly pageWindow;
+    private readonly channelId;
+    private readonly bridgeTimeoutMs;
+    private readonly pendingRequests;
+    private readonly sessions;
+    private readonly lastSeqBySession;
+    private nextRequestNumber;
+    private disconnectedError;
+    private port;
+    constructor(options?: PedelecOptions);
+    createSession(input?: CreateSessionInput): Promise<PedelecSession>;
+    listProviders(): Promise<ProviderInfo[]>;
+    getSettings(): Promise<PedelecSettings>;
+    getApprovalStatus(): Promise<ApprovalStatus>;
+    resumeSession(sessionId: string): Promise<PedelecSession>;
+    request<T>(type: string, payload?: Record<string, unknown>): Promise<T>;
+    unregisterSession(sessionId: string): void;
+    private resolveCreateSessionInput;
+    private resolveDefaultCreateSessionInput;
+    private resolveProviderOnlyCreateSessionInput;
+    private assertDefaultProviderAvailable;
+    private registerSession;
+    private connectExtension;
+    private handlePortMessage;
+    private handleResponse;
+    private isNewEvent;
+    private handleDisconnect;
+    private broadcastError;
+}
+export declare class PedelecSession {
+    private readonly client;
+    readonly sessionId: string;
+    readonly provider: string;
+    readonly model?: string;
+    private status;
+    private pendingSend;
+    private toolHandler;
+    private readonly chatHandlers;
+    private readonly errorHandlers;
+    private readonly statusHandlers;
+    private readonly endedHandlers;
+    constructor(client: Pedelec, sessionId: string, provider: string, model?: string);
+    sendText(text: string): Promise<void>;
+    onChat(handler: ChatHandler): () => void;
+    onTool(handler: ToolHandler): () => void;
+    onError(handler: ErrorHandler): () => void;
+    onStatus(handler: StatusHandler): () => void;
+    onEnded(handler: EndedHandler): () => void;
+    getStatus(): PedelecSessionStatus;
+    end(): Promise<void>;
+    handleEvent(event: SessionEvent): void;
+    private handleToolCall;
+    private resolvePendingSend;
+    private rejectPendingSend;
+    private clearPendingSend;
+    private markEnded;
+    private emitError;
+    private setStatus;
+}
+export {};

package/dist/index.js

@@ -0,0 +1,526 @@
+import { PEDELEC_EXTENSION_ID } from "./extension-id.js";
+const SDK_EXTERNAL_PORT_NAME = "pedelec-sdk-external";
+const DEFAULT_BRIDGE_TIMEOUT_MS = 30_000;
+export class Pedelec {
+    pageWindow;
+    channelId;
+    bridgeTimeoutMs;
+    pendingRequests = new Map();
+    sessions = new Map();
+    lastSeqBySession = new Map();
+    nextRequestNumber = 1;
+    disconnectedError = null;
+    port = null;
+    constructor(options = {}) {
+        this.pageWindow = typeof window === "undefined" ? null : window;
+        this.channelId = createChannelId();
+        this.bridgeTimeoutMs = Math.max(1, options.bridgeTimeoutMs ?? DEFAULT_BRIDGE_TIMEOUT_MS);
+        if (!this.pageWindow) {
+            this.disconnectedError = makeError("EXTENSION_UNAVAILABLE", "Pedelec SDK must run in a browser page context.");
+            return;
+        }
+        this.connectExtension();
+    }
+    async createSession(input = {}) {
+        const resolvedOrPromise = this.resolveCreateSessionInput(input);
+        const resolvedInput = resolvedOrPromise instanceof Promise ? await resolvedOrPromise : resolvedOrPromise;
+        const result = await this.request("create_session", {
+            input: {
+                provider: resolvedInput.provider,
+                model: resolvedInput.model,
+                skillsUrls: resolvedInput.skillsUrls,
+            },
+        });
+        if (!result.sessionId) {
+            throw makeError("SDK_PROTOCOL_ERROR", "create_session response did not include sessionId");
+        }
+        return this.registerSession(result.sessionId, resolvedInput.provider, resolvedInput.model);
+    }
+    async listProviders() {
+        const result = await this.request("list_providers");
+        if (!Array.isArray(result)) {
+            throw makeError("SDK_PROTOCOL_ERROR", "list_providers response was not an array");
+        }
+        return result;
+    }
+    async getSettings() {
+        const result = await this.request("get_settings");
+        if (!isSettings(result)) {
+            throw makeError("SDK_PROTOCOL_ERROR", "get_settings response had invalid shape");
+        }
+        return result;
+    }
+    async getApprovalStatus() {
+        if (this.disconnectedError) {
+            return {
+                installed: false,
+                approved: false,
+                origin: getCurrentOrigin(this.pageWindow),
+            };
+        }
+        try {
+            const result = await this.request("get_approval_status");
+            if (!isApprovalStatus(result)) {
+                throw makeError("SDK_PROTOCOL_ERROR", "get_approval_status response had invalid shape");
+            }
+            return result;
+        }
+        catch (err) {
+            const error = normalizeError(err, "EXTENSION_UNAVAILABLE", "Pedelec extension is unavailable.");
+            if (error.code === "EXTENSION_UNAVAILABLE" || error.code === "EXTENSION_DISCONNECTED") {
+                return {
+                    installed: false,
+                    approved: false,
+                    origin: getCurrentOrigin(this.pageWindow),
+                };
+            }
+            throw error;
+        }
+    }
+    async resumeSession(sessionId) {
+        if (!sessionId?.trim()) {
+            throw makeError("INVALID_INPUT", "sessionId is required");
+        }
+        const result = await this.request("resume_session", {
+            sessionId,
+        });
+        if (!result.sessionId) {
+            throw makeError("SDK_PROTOCOL_ERROR", "resume_session response did not include sessionId");
+        }
+        return this.registerSession(result.sessionId, "", undefined);
+    }
+    request(type, payload = {}) {
+        if (this.disconnectedError) {
+            return Promise.reject(this.disconnectedError);
+        }
+        if (!this.port) {
+            return Promise.reject(makeError("EXTENSION_UNAVAILABLE", "Pedelec extension is unavailable."));
+        }
+        const requestId = `sdk_${Date.now()}_${this.nextRequestNumber++}`;
+        const message = { channelId: this.channelId, type, requestId, ...payload };
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                this.pendingRequests.delete(requestId);
+                reject(makeError("SDK_BRIDGE_TIMEOUT", "Pedelec extension did not respond.", {
+                    requestId,
+                    type,
+                }));
+            }, this.bridgeTimeoutMs);
+            this.pendingRequests.set(requestId, {
+                resolve: (value) => resolve(value),
+                reject,
+                timeoutId,
+            });
+            try {
+                this.port?.postMessage(message);
+            }
+            catch (err) {
+                this.pendingRequests.delete(requestId);
+                clearTimeout(timeoutId);
+                reject(normalizeError(err, "EXTENSION_DISCONNECTED", "Pedelec extension disconnected."));
+            }
+        });
+    }
+    unregisterSession(sessionId) {
+        this.sessions.delete(sessionId);
+        this.lastSeqBySession.delete(sessionId);
+    }
+    resolveCreateSessionInput(input) {
+        const raw = (input ?? {});
+        const provider = typeof raw.provider === "string" ? raw.provider.trim() : "";
+        const hasProvider = provider.length > 0;
+        const hasModel = raw.model !== undefined;
+        if (!hasProvider && hasModel) {
+            throw makeError("INVALID_INPUT", "model cannot be provided without provider");
+        }
+        const skillsUrls = Array.isArray(raw.skillsUrls) ? raw.skillsUrls : [];
+        const userModel = typeof raw.model === "string" ? raw.model : undefined;
+        if (!hasProvider) {
+            return this.resolveDefaultCreateSessionInput(skillsUrls);
+        }
+        if (!isProviderCode(provider)) {
+            throw makeError("INVALID_INPUT", "provider is not supported", { provider });
+        }
+        let model = userModel;
+        if (model === undefined) {
+            return this.resolveProviderOnlyCreateSessionInput(provider, skillsUrls);
+        }
+        return {
+            provider: provider,
+            model,
+            skillsUrls,
+        };
+    }
+    async resolveDefaultCreateSessionInput(skillsUrls) {
+        const settings = await this.getSettings();
+        if (!settings.defaultProvider) {
+            throw makeError("DEFAULT_PROVIDER_NOT_SET", "Default provider is not set. Open the Pedelec desktop app Settings page and choose a default provider.");
+        }
+        await this.assertDefaultProviderAvailable(settings.defaultProvider);
+        return {
+            provider: settings.defaultProvider,
+            model: settings.defaultModel ?? undefined,
+            skillsUrls,
+        };
+    }
+    async resolveProviderOnlyCreateSessionInput(provider, skillsUrls) {
+        const settings = await this.getSettings();
+        return {
+            provider,
+            model: settings.defaultProvider === provider && settings.defaultModel
+                ? settings.defaultModel
+                : undefined,
+            skillsUrls,
+        };
+    }
+    async assertDefaultProviderAvailable(provider) {
+        const providers = await this.listProviders();
+        const info = providers.find((candidate) => candidate.code === provider);
+        if (!info?.available) {
+            throw makeError("DEFAULT_PROVIDER_UNAVAILABLE", "Default provider is not currently available. Open the Pedelec desktop app Settings page and choose an available provider.", { provider });
+        }
+    }
+    registerSession(sessionId, provider, model) {
+        const existing = this.sessions.get(sessionId);
+        if (existing)
+            return existing;
+        const session = new PedelecSession(this, sessionId, provider, model);
+        this.sessions.set(sessionId, session);
+        return session;
+    }
+    connectExtension() {
+        const runtime = globalThis.chrome?.runtime;
+        if (!runtime?.connect) {
+            this.disconnectedError = makeError("EXTENSION_UNAVAILABLE", "Pedelec extension is unavailable.");
+            return;
+        }
+        try {
+            this.port = runtime.connect(PEDELEC_EXTENSION_ID, { name: SDK_EXTERNAL_PORT_NAME });
+            this.port.onMessage.addListener((message) => this.handlePortMessage(message));
+            this.port.onDisconnect.addListener(() => this.handleDisconnect());
+        }
+        catch (err) {
+            this.disconnectedError = normalizeError(err, "EXTENSION_UNAVAILABLE", "Pedelec extension is unavailable.");
+            this.port = null;
+        }
+    }
+    handlePortMessage(raw) {
+        const message = raw;
+        if (!message || typeof message !== "object")
+            return;
+        if (message.channelId && message.channelId !== this.channelId)
+            return;
+        if (message.type === "response") {
+            this.handleResponse(message);
+            return;
+        }
+        if (isSessionEvent(message) && this.isNewEvent(message)) {
+            if (message.sessionId) {
+                this.sessions.get(message.sessionId)?.handleEvent(message);
+            }
+            else if (message.type === "error") {
+                this.broadcastError(normalizeError(message.error, "SDK_TRANSPORT_ERROR", "Pedelec transport error"));
+            }
+        }
+    }
+    handleResponse(message) {
+        const pending = this.pendingRequests.get(message.requestId);
+        if (!pending)
+            return;
+        this.pendingRequests.delete(message.requestId);
+        clearTimeout(pending.timeoutId);
+        if (message.ok) {
+            pending.resolve(message.result);
+        }
+        else {
+            pending.reject(normalizeError(message.error, "SDK_TRANSPORT_ERROR", "SDK transport request failed"));
+        }
+    }
+    isNewEvent(event) {
+        if (!event.sessionId || typeof event.seq !== "number")
+            return true;
+        const lastSeq = this.lastSeqBySession.get(event.sessionId);
+        if (typeof lastSeq === "number" && event.seq <= lastSeq) {
+            return false;
+        }
+        this.lastSeqBySession.set(event.sessionId, event.seq);
+        return true;
+    }
+    handleDisconnect() {
+        const runtime = globalThis.chrome?.runtime;
+        const error = normalizeError(runtime?.lastError, "EXTENSION_DISCONNECTED", "Pedelec extension disconnected.");
+        this.disconnectedError = error;
+        this.port = null;
+        for (const pending of this.pendingRequests.values()) {
+            clearTimeout(pending.timeoutId);
+            pending.reject(error);
+        }
+        this.pendingRequests.clear();
+        this.broadcastError(error);
+    }
+    broadcastError(error) {
+        for (const session of this.sessions.values()) {
+            session.handleEvent({ type: "error", sessionId: session.sessionId, error });
+        }
+    }
+}
+export class PedelecSession {
+    client;
+    sessionId;
+    provider;
+    model;
+    status = "idle";
+    pendingSend = null;
+    toolHandler = null;
+    chatHandlers = new Set();
+    errorHandlers = new Set();
+    statusHandlers = new Set();
+    endedHandlers = new Set();
+    constructor(client, sessionId, provider, model) {
+        this.client = client;
+        this.sessionId = sessionId;
+        this.provider = provider;
+        this.model = model;
+    }
+    sendText(text) {
+        if (this.status === "ended") {
+            return Promise.reject(makeError("SESSION_ENDED", "session has ended", { sessionId: this.sessionId }));
+        }
+        if (this.pendingSend) {
+            return Promise.reject(makeError("SESSION_BUSY", "session is already running", { sessionId: this.sessionId }));
+        }
+        this.setStatus("running");
+        const donePromise = new Promise((resolve, reject) => {
+            this.pendingSend = { resolve, reject };
+        });
+        const requestPromise = this.client
+            .request("send_text", {
+            sessionId: this.sessionId,
+            text,
+        })
+            .catch((err) => {
+            const error = normalizeError(err, "SEND_TEXT_FAILED", "sendText failed");
+            this.clearPendingSend();
+            this.emitError(error);
+            throw error;
+        });
+        return Promise.all([requestPromise, donePromise]).then(() => undefined);
+    }
+    onChat(handler) {
+        this.chatHandlers.add(handler);
+        return () => this.chatHandlers.delete(handler);
+    }
+    onTool(handler) {
+        this.toolHandler = handler;
+        return () => {
+            if (this.toolHandler === handler) {
+                this.toolHandler = null;
+            }
+        };
+    }
+    onError(handler) {
+        this.errorHandlers.add(handler);
+        return () => this.errorHandlers.delete(handler);
+    }
+    onStatus(handler) {
+        this.statusHandlers.add(handler);
+        return () => this.statusHandlers.delete(handler);
+    }
+    onEnded(handler) {
+        this.endedHandlers.add(handler);
+        return () => this.endedHandlers.delete(handler);
+    }
+    getStatus() {
+        return this.status;
+    }
+    async end() {
+        if (this.status === "ended")
+            return;
+        try {
+            await this.client.request("end_session", {
+                sessionId: this.sessionId,
+            });
+        }
+        catch (err) {
+            const error = normalizeError(err, "END_SESSION_FAILED", "end failed");
+            this.emitError(error);
+            throw error;
+        }
+        this.markEnded();
+        this.client.unregisterSession(this.sessionId);
+    }
+    handleEvent(event) {
+        if (event.type === "chat_delta") {
+            for (const handler of this.chatHandlers) {
+                handler(event.text);
+            }
+            return;
+        }
+        if (event.type === "status_changed") {
+            this.setStatus(event.status);
+            if (event.status === "idle") {
+                this.resolvePendingSend();
+            }
+            else if (event.status === "ended") {
+                this.markEnded();
+            }
+            else if (event.status === "error") {
+                const error = makeError("SESSION_ERROR", "session entered error status", { sessionId: this.sessionId });
+                this.rejectPendingSend(error);
+                this.emitError(error);
+            }
+            return;
+        }
+        if (event.type === "tool_call") {
+            this.setStatus("waiting_tool_result");
+            this.handleToolCall(event);
+            return;
+        }
+        if (event.type === "done") {
+            this.setStatus("idle");
+            this.resolvePendingSend();
+            return;
+        }
+        if (event.type === "error") {
+            this.setStatus("error");
+            const error = normalizeError(event.error, "SESSION_ERROR", "session error");
+            this.rejectPendingSend(error);
+            this.emitError(error);
+            return;
+        }
+        if (event.type === "ended") {
+            this.markEnded();
+        }
+    }
+    async handleToolCall(event) {
+        let result;
+        if (!this.toolHandler) {
+            result = {
+                error: makeError("TOOL_HANDLER_NOT_FOUND", `No tool handler registered for ${event.tool}`, {
+                    tool: event.tool,
+                }),
+            };
+        }
+        else {
+            try {
+                result = await this.toolHandler(event.tool, event.args);
+            }
+            catch (err) {
+                result = {
+                    error: normalizeError(err, "TOOL_HANDLER_ERROR", "Tool handler failed"),
+                };
+            }
+        }
+        try {
+            await this.client.request("submit_tool_result", {
+                sessionId: this.sessionId,
+                toolRequestId: event.toolRequestId,
+                result,
+            });
+        }
+        catch (err) {
+            this.emitError(normalizeError(err, "SUBMIT_TOOL_RESULT_FAILED", "submit_tool_result failed"));
+        }
+    }
+    resolvePendingSend() {
+        const pending = this.pendingSend;
+        this.pendingSend = null;
+        pending?.resolve();
+    }
+    rejectPendingSend(error) {
+        const pending = this.pendingSend;
+        this.pendingSend = null;
+        pending?.reject(error);
+    }
+    clearPendingSend() {
+        this.pendingSend = null;
+    }
+    markEnded() {
+        const wasEnded = this.status === "ended";
+        this.setStatus("ended");
+        this.rejectPendingSend(makeError("SESSION_ENDED", "session has ended", { sessionId: this.sessionId }));
+        if (!wasEnded) {
+            for (const handler of this.endedHandlers) {
+                handler();
+            }
+        }
+    }
+    emitError(error) {
+        for (const handler of this.errorHandlers) {
+            handler(error);
+        }
+    }
+    setStatus(status) {
+        if (this.status === status)
+            return;
+        this.status = status;
+        for (const handler of this.statusHandlers) {
+            handler(status);
+        }
+    }
+}
+function isSessionEvent(message) {
+    return (message.type === "chat_delta" ||
+        message.type === "status_changed" ||
+        message.type === "tool_call" ||
+        message.type === "done" ||
+        message.type === "error" ||
+        message.type === "ended");
+}
+function isSettings(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const settings = value;
+    return ((settings.defaultProvider === null ||
+        settings.defaultProvider === "codex" ||
+        settings.defaultProvider === "gemini" ||
+        settings.defaultProvider === "opencode" ||
+        settings.defaultProvider === "cursor" ||
+        settings.defaultProvider === "claude") &&
+        (settings.defaultModel === null || typeof settings.defaultModel === "string"));
+}
+function isApprovalStatus(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const status = value;
+    return (typeof status.installed === "boolean" &&
+        typeof status.approved === "boolean" &&
+        (status.origin === null || typeof status.origin === "string"));
+}
+function isProviderCode(value) {
+    return (value === "codex" ||
+        value === "gemini" ||
+        value === "opencode" ||
+        value === "cursor" ||
+        value === "claude");
+}
+function makeError(code, message, details) {
+    return details === undefined ? { code, message } : { code, message, details };
+}
+function createChannelId() {
+    const random = typeof crypto !== "undefined" && "randomUUID" in crypto
+        ? crypto.randomUUID()
+        : Math.random().toString(36).slice(2);
+    return `pedelec_${Date.now()}_${random}`;
+}
+function getCurrentOrigin(pageWindow) {
+    const origin = pageWindow?.location?.origin;
+    return typeof origin === "string" && origin ? origin : null;
+}
+function normalizeError(err, fallbackCode, fallbackMessage) {
+    if (!err)
+        return makeError(fallbackCode, fallbackMessage);
+    if (typeof err === "string")
+        return makeError(fallbackCode, err);
+    if (err instanceof Error)
+        return makeError(fallbackCode, err.message || fallbackMessage);
+    const value = err;
+    if (typeof value.code === "string" && typeof value.message === "string") {
+        return {
+            code: value.code,
+            message: value.message,
+            details: value.details,
+        };
+    }
+    return makeError(fallbackCode, fallbackMessage, err);
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@kaoruisaac/pedelec",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "prepublishOnly": "npm run test && npm run build"
+  },
+  "devDependencies": {
+    "typescript": "^5.8.3",
+    "vitest": "^4.1.8"
+  }
+}