opencode-graphiti 0.1.0 → 0.1.2

package/README.md

@@ -23,9 +23,12 @@ reminded of recent project context — regardless of what survived the summary.
 This plugin connects to a Graphiti MCP server and:
 
 - Injects relevant memories into the first user message of each session
-- Detects user-triggered memory saves ("remember this", "keep in mind", etc.)
+- Periodically re-injects project memories as the conversation progresses
+- Buffers user and assistant messages, flushing them to Graphiti on idle or
+  before compaction
 - Preserves key facts during context compaction
-- Scopes memories per project using directory-based group IDs
+- Saves compaction summaries as episodes so knowledge survives across boundaries
+- Scopes memories per project (and per user) using directory-based group IDs
 
 ## Prerequisites
 
@@ -101,47 +104,61 @@ Create a config file at `~/.config/opencode/graphiti.jsonc`:
   // Prefix for project group IDs (e.g. "opencode_my-project")
   "groupIdPrefix": "opencode",
 
-  // Maximum results to retrieve
-  "maxFacts": 10,
-  "maxNodes": 5,
-  "maxEpisodes": 5,
-
-  // Feature toggles
-  "injectOnFirstMessage": true,
-  "enableTriggerDetection": true,
-  "enableCompactionSave": true
+  // Number of user messages between memory re-injections (0 = disabled)
+  "injectionInterval": 10
 }
 ```
 
-All fields are optional — defaults are used for any missing values.
+All fields are optional — defaults (shown above) are used for any missing
+values.
 
 ## How It Works
 
 ### Memory Injection (`chat.message`)
 
 On the first user message in a session, the plugin searches Graphiti for facts
-and entities relevant to the message content. Matching results are formatted and
-prepended to the conversation as a synthetic context block.
+and entities relevant to the message content. Results are split into project and
+user scopes (70% / 30% budget split), formatted, and prepended to the
+conversation as a synthetic context block.
+
+The injection budget is calculated dynamically: 5% of the model's context limit
+(resolved from the provider list) multiplied by 4 characters per token.
+
+### Re-injection (`chat.message`)
+
+When `injectionInterval` is greater than 0, the plugin periodically re-injects
+project-scoped memories as the conversation progresses. After every N user
+messages (where N is `injectionInterval`), stale synthetic memory parts are
+replaced with fresh results. Re-injection uses the full character budget for
+project memories only (no user scope).
 
-### Trigger Detection (`chat.message`)
+### Message Buffering (`event`)
 
-User messages are scanned for phrases like:
+User and assistant messages are buffered in memory as they arrive. The plugin
+listens on `message.part.updated` to capture assistant text as it streams, and
+on `message.updated` to finalize completed assistant replies. Buffered messages
+are flushed to Graphiti as episodes:
 
-- "remember this", "memorize that"
-- "save this in memory", "keep this in mind"
-- "don't forget", "note this"
-- "for future reference"
+- **On idle** (`session.idle`): when the session becomes idle with at least 50
+  bytes of buffered content.
+- **Before compaction** (`session.compacted`): all buffered messages are flushed
+  immediately (no minimum size) so nothing is lost.
 
-When detected, the message content is saved as an episode in Graphiti.
+If the last buffered message is from the user (i.e. no assistant reply was
+captured), the plugin fetches the latest assistant message from the session API
+as a fallback before flushing.
 
-### Compaction Preservation (`event` + `experimental.session.compacting`)
+### Compaction Preservation (`session.compacted` + `experimental.session.compacting`)
 
-When OpenCode compacts the context window:
+Compaction is handled entirely by OpenCode's native compaction mechanism. The
+plugin participates in two ways:
 
-1. **Before compaction**: The plugin injects known facts into the compaction
-   context, so the summarizer preserves important knowledge.
-2. **After compaction**: If a summary is produced, it is saved as an episode to
-   Graphiti, ensuring knowledge survives across compaction boundaries.
+1. **Before compaction** (`experimental.session.compacting`): The plugin injects
+   known facts and entities into the compaction context using the same 70% / 30%
+   project/user budget split, so the summarizer preserves important knowledge.
+2. **After compaction** (`session.compacted`): The compaction summary is saved
+   as an episode to Graphiti, ensuring knowledge survives across compaction
+   boundaries.
 
 ### Project Scoping
 

package/esm/src/config.d.ts

@@ -1,3 +1,6 @@
 import type { GraphitiConfig } from "./types/index.js";
+/**
+ * Load Graphiti configuration from JSONC files with defaults applied.
+ */
 export declare function loadConfig(): GraphitiConfig;
 //# sourceMappingURL=config.d.ts.map

package/esm/src/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/src/config.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AA0BvD,wBAAgB,UAAU,IAAI,cAAc,CAe3C"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/src/config.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAcvD;;GAEG;AACH,wBAAgB,UAAU,IAAI,cAAc,CAc3C"}

package/esm/src/config.js

@@ -1,43 +1,29 @@
-import * as dntShim from "../_dnt.shims.js";
 import { cosmiconfigSync } from "cosmiconfig";
-import { readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
+import * as z from "zod/mini";
 const DEFAULT_CONFIG = {
     endpoint: "http://localhost:8000/mcp",
     groupIdPrefix: "opencode",
-    maxFacts: 10,
-    maxNodes: 5,
-    maxEpisodes: 5,
-    injectOnFirstMessage: true,
-    enableCompactionSave: true,
-    compactionThreshold: 0.8,
-    minTokensForCompaction: 50000,
-    compactionCooldownMs: 30000,
-    autoResumeAfterCompaction: true,
-};
-function parseJsonc(text) {
-    let stripped = text.replace(/(^|\s)\/\/.*$/gm, "$1");
-    stripped = stripped.replace(/\/\*[\s\S]*?\*\//g, "");
-    return JSON.parse(stripped);
-}
-const createExplorer = (cwd) => {
-    return cosmiconfigSync("graphiti", { stopDir: cwd });
+    injectionInterval: 10,
 };
+const GraphitiConfigSchema = z.object({
+    endpoint: z.string(),
+    groupIdPrefix: z.string(),
+    injectionInterval: z.number(),
+});
+/**
+ * Load Graphiti configuration from JSONC files with defaults applied.
+ */
 export function loadConfig() {
-    const cwd = dntShim.Deno.cwd();
-    const explorer = createExplorer(cwd);
-    const result = explorer.search(cwd);
-    let config = result?.config;
-    if (!config) {
-        const configPath = join(homedir(), ".config", "opencode", "graphiti.jsonc");
-        try {
-            const raw = readFileSync(configPath, "utf-8");
-            config = parseJsonc(raw);
-        }
-        catch {
-            config = null;
-        }
+    const explorer = cosmiconfigSync("graphiti", { searchStrategy: "global" });
+    const result = explorer.search();
+    const candidate = result?.config ?? {};
+    const merged = {
+        ...DEFAULT_CONFIG,
+        ...candidate,
+    };
+    const parsed = GraphitiConfigSchema.safeParse(merged);
+    if (parsed.success) {
+        return parsed.data;
     }
-    return { ...DEFAULT_CONFIG, ...(config ?? {}) };
+    return DEFAULT_CONFIG;
 }

package/esm/src/handlers/chat.d.ts

@@ -0,0 +1,21 @@
+import type { Part } from "@opencode-ai/sdk";
+import type { GraphitiClient } from "../services/client.js";
+import type { SessionManager } from "../session.js";
+/** Dependencies for the chat message handler. */
+export interface ChatHandlerDeps {
+    sessionManager: SessionManager;
+    injectionInterval: number;
+    client: GraphitiClient;
+}
+/** Creates the `chat.message` hook handler. */
+export declare function createChatHandler(deps: ChatHandlerDeps): ({ sessionID }: {
+    sessionID: string;
+}, output: {
+    allow_buffering?: boolean;
+    parts: Part[];
+    message: {
+        sessionID: string;
+        id: string;
+    };
+}) => Promise<void>;
+//# sourceMappingURL=chat.d.ts.map

package/esm/src/handlers/chat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat.d.ts","sourceRoot":"","sources":["../../../src/src/handlers/chat.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAI5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAGpD,iDAAiD;AACjD,MAAM,WAAW,eAAe;IAC9B,cAAc,EAAE,cAAc,CAAC;IAC/B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,MAAM,EAAE,cAAc,CAAC;CACxB;AAED,+CAA+C;AAC/C,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,eAAe,IA6FnD,eAAe;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,EACpC,QAAQ;IACN,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,OAAO,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC;CAC5C,mBA4DJ"}

package/esm/src/handlers/chat.js

@@ -0,0 +1,127 @@
+import { formatMemoryContext } from "../services/context.js";
+import { calculateInjectionBudget } from "../services/context-limit.js";
+import { logger } from "../services/logger.js";
+import { extractTextFromParts } from "../utils.js";
+/** Creates the `chat.message` hook handler. */
+export function createChatHandler(deps) {
+    const { sessionManager, injectionInterval, client } = deps;
+    const removeSyntheticMemoryParts = (parts) => parts.filter((part) => {
+        const synthetic = part.synthetic;
+        const id = typeof part.id === "string"
+            ? String(part.id)
+            : "";
+        if (!synthetic)
+            return true;
+        if (id.startsWith("graphiti-memory-"))
+            return false;
+        if (id.startsWith("graphiti-refresh-"))
+            return false;
+        return true;
+    });
+    const injectMemoryContext = async (state, messageText, output, prefix, useUserScope, characterBudget) => {
+        const userGroupId = state.userGroupId;
+        const projectFactsPromise = client.searchFacts({
+            query: messageText,
+            groupIds: [state.groupId],
+            maxFacts: 50,
+        });
+        const projectNodesPromise = client.searchNodes({
+            query: messageText,
+            groupIds: [state.groupId],
+            maxNodes: 30,
+        });
+        const userFactsPromise = useUserScope && userGroupId
+            ? client.searchFacts({
+                query: messageText,
+                groupIds: [userGroupId],
+                maxFacts: 20,
+            })
+            : Promise.resolve([]);
+        const userNodesPromise = useUserScope && userGroupId
+            ? client.searchNodes({
+                query: messageText,
+                groupIds: [userGroupId],
+                maxNodes: 10,
+            })
+            : Promise.resolve([]);
+        const [projectFacts, projectNodes, userFacts, userNodes] = await Promise
+            .all([
+            projectFactsPromise,
+            projectNodesPromise,
+            userFactsPromise,
+            userNodesPromise,
+        ]);
+        const projectContext = formatMemoryContext(projectFacts, projectNodes);
+        const userContext = formatMemoryContext(userFacts, userNodes);
+        if (!projectContext && !userContext)
+            return;
+        const projectBudget = useUserScope
+            ? Math.floor(characterBudget * 0.7)
+            : characterBudget;
+        const userBudget = characterBudget - projectBudget;
+        const truncatedProject = projectContext.slice(0, projectBudget);
+        const truncatedUser = useUserScope ? userContext.slice(0, userBudget) : "";
+        const memoryContext = [truncatedProject, truncatedUser]
+            .filter((section) => section.trim().length > 0)
+            .join("\n\n")
+            .slice(0, characterBudget);
+        if (!memoryContext)
+            return;
+        output.parts.unshift({
+            type: "text",
+            text: memoryContext,
+            id: `${prefix}${Date.now()}`,
+            sessionID: output.message.sessionID,
+            messageID: output.message.id,
+            synthetic: true,
+        });
+        logger.info(`Injected ${projectFacts.length + userFacts.length} facts and ${projectNodes.length + userNodes.length} nodes`);
+    };
+    return async ({ sessionID }, output) => {
+        if (await sessionManager.isSubagentSession(sessionID)) {
+            logger.debug("Ignoring subagent chat message:", sessionID);
+            return;
+        }
+        const { state, resolved } = await sessionManager.resolveSessionState(sessionID);
+        if (!resolved) {
+            output.allow_buffering = true;
+            logger.debug("Unable to resolve session for message:", { sessionID });
+            return;
+        }
+        if (!state?.isMain) {
+            logger.debug("Ignoring subagent chat message:", sessionID);
+            return;
+        }
+        state.messageCount++;
+        const messageText = extractTextFromParts(output.parts);
+        if (!messageText)
+            return;
+        state.pendingMessages.push(`User: ${messageText}`);
+        logger.info("Buffered user message", {
+            hook: "chat.message",
+            sessionID,
+            messageLength: messageText.length,
+        });
+        const shouldInjectOnFirst = !state.injectedMemories;
+        const shouldReinject = !shouldInjectOnFirst &&
+            injectionInterval > 0 &&
+            (state.messageCount - state.lastInjectionMessageCount) >=
+                injectionInterval;
+        if (!shouldInjectOnFirst && !shouldReinject)
+            return;
+        if (shouldReinject) {
+            output.parts = removeSyntheticMemoryParts(output.parts);
+        }
+        try {
+            const prefix = shouldReinject ? "graphiti-refresh-" : "graphiti-memory-";
+            const useUserScope = shouldInjectOnFirst;
+            const characterBudget = calculateInjectionBudget(state.contextLimit);
+            await injectMemoryContext(state, messageText, output, prefix, useUserScope, characterBudget);
+            state.injectedMemories = true;
+            state.lastInjectionMessageCount = state.messageCount;
+        }
+        catch (err) {
+            logger.error("Failed to inject memories:", err);
+        }
+    };
+}

package/esm/src/handlers/compacting.d.ts

@@ -0,0 +1,15 @@
+import type { GraphitiClient } from "../services/client.js";
+import type { SessionManager } from "../session.js";
+/** Dependencies for the compacting handler. */
+export interface CompactingHandlerDeps {
+    sessionManager: SessionManager;
+    client: GraphitiClient;
+    defaultGroupId: string;
+}
+/** Creates the `experimental.session.compacting` hook handler. */
+export declare function createCompactingHandler(deps: CompactingHandlerDeps): ({ sessionID }: {
+    sessionID: string;
+}, output: {
+    context: string[];
+}) => Promise<void>;
+//# sourceMappingURL=compacting.d.ts.map

package/esm/src/handlers/compacting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compacting.d.ts","sourceRoot":"","sources":["../../../src/src/handlers/compacting.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAI5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD,+CAA+C;AAC/C,MAAM,WAAW,qBAAqB;IACpC,cAAc,EAAE,cAAc,CAAC;IAC/B,MAAM,EAAE,cAAc,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,kEAAkE;AAClE,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,qBAAqB,IAI/D,eAAe;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,EACpC,QAAQ;IAAE,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,mBAyBhC"}

package/esm/src/handlers/compacting.js

@@ -0,0 +1,29 @@
+import { getCompactionContext } from "../services/compaction.js";
+import { calculateInjectionBudget } from "../services/context-limit.js";
+import { logger } from "../services/logger.js";
+/** Creates the `experimental.session.compacting` hook handler. */
+export function createCompactingHandler(deps) {
+    const { sessionManager, client, defaultGroupId } = deps;
+    return async ({ sessionID }, output) => {
+        const state = sessionManager.getState(sessionID);
+        if (!state?.isMain) {
+            logger.debug("Ignoring non-main compaction context:", sessionID);
+            return;
+        }
+        const groupId = state.groupId || defaultGroupId;
+        const characterBudget = calculateInjectionBudget(state.contextLimit);
+        const additionalContext = await getCompactionContext({
+            client,
+            characterBudget,
+            groupIds: {
+                project: groupId,
+                user: state.userGroupId,
+            },
+            contextStrings: output.context,
+        });
+        if (additionalContext.length > 0) {
+            output.context.push(...additionalContext);
+            logger.info("Injected persistent knowledge into compaction context");
+        }
+    };
+}

package/esm/src/handlers/event.d.ts

@@ -0,0 +1,18 @@
+import type { Event } from "@opencode-ai/sdk";
+import type { GraphitiClient } from "../services/client.js";
+import type { ProviderListClient } from "../services/context-limit.js";
+import type { SessionManager } from "../session.js";
+/** Dependencies for the event handler. */
+export interface EventHandlerDeps {
+    sessionManager: SessionManager;
+    client: GraphitiClient;
+    defaultGroupId: string;
+    sdkClient: ProviderListClient;
+    directory: string;
+    groupIdPrefix: string;
+}
+/** Creates the `event` hook handler. */
+export declare function createEventHandler(deps: EventHandlerDeps): ({ event }: {
+    event: Event;
+}) => Promise<void>;
+//# sourceMappingURL=event.d.ts.map

package/esm/src/handlers/event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.d.ts","sourceRoot":"","sources":["../../../src/src/handlers/event.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAGvE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAGpD,0CAA0C;AAC1C,MAAM,WAAW,gBAAgB;IAC/B,cAAc,EAAE,cAAc,CAAC;IAC/B,MAAM,EAAE,cAAc,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,kBAAkB,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,wCAAwC;AACxC,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,gBAAgB,IAWzC,WAAW;IAAE,KAAK,EAAE,KAAK,CAAA;CAAE,mBA+J1C"}

package/esm/src/handlers/event.js

@@ -0,0 +1,132 @@
+import { handleCompaction } from "../services/compaction.js";
+import { resolveContextLimit } from "../services/context-limit.js";
+import { logger } from "../services/logger.js";
+import { isTextPart, makeUserGroupId } from "../utils.js";
+/** Creates the `event` hook handler. */
+export function createEventHandler(deps) {
+    const { sessionManager, client, defaultGroupId, sdkClient, directory, groupIdPrefix, } = deps;
+    const defaultUserGroupId = makeUserGroupId(groupIdPrefix);
+    return async ({ event }) => {
+        try {
+            if (event.type === "session.created") {
+                const info = event.properties.info;
+                const sessionId = info.id;
+                const parentId = info.parentID ?? null;
+                const isMain = !parentId;
+                sessionManager.setParentId(sessionId, parentId);
+                logger.info("Session created:", {
+                    sessionId,
+                    isMain,
+                    parentID: info.parentID,
+                });
+                if (isMain) {
+                    sessionManager.setState(sessionId, {
+                        groupId: defaultGroupId,
+                        userGroupId: defaultUserGroupId,
+                        injectedMemories: false,
+                        lastInjectionMessageCount: 0,
+                        messageCount: 0,
+                        pendingMessages: [],
+                        contextLimit: 200_000,
+                        isMain,
+                    });
+                }
+                else {
+                    logger.debug("Ignoring subagent session:", sessionId);
+                }
+                return;
+            }
+            if (event.type === "session.compacted") {
+                const sessionId = event.properties.sessionID;
+                const { state, resolved } = await sessionManager.resolveSessionState(sessionId);
+                if (!resolved) {
+                    logger.debug("Unable to resolve session compaction:", sessionId);
+                    return;
+                }
+                if (!state?.isMain) {
+                    logger.debug("Ignoring non-main compaction:", sessionId);
+                    return;
+                }
+                const summary = event.properties.summary ||
+                    "";
+                await sessionManager.flushPendingMessages(sessionId, "Buffered messages flushed before compaction", 0);
+                if (summary) {
+                    await handleCompaction({
+                        client,
+                        groupId: state.groupId,
+                        summary,
+                        sessionId,
+                    });
+                }
+                return;
+            }
+            if (event.type === "session.idle") {
+                const sessionId = event.properties.sessionID;
+                const { state, resolved } = await sessionManager.resolveSessionState(sessionId);
+                if (!resolved) {
+                    logger.debug("Unable to resolve idle session:", sessionId);
+                    return;
+                }
+                if (!state?.isMain) {
+                    logger.debug("Ignoring non-main idle session:", sessionId);
+                    return;
+                }
+                await sessionManager.flushPendingMessages(sessionId, "Buffered messages from OpenCode session", 50);
+                return;
+            }
+            if (event.type === "message.updated") {
+                const info = event.properties.info;
+                const sessionId = info.sessionID;
+                logger.info("Message event fired", {
+                    hook: "message.updated",
+                    eventType: "message.updated",
+                    sessionId,
+                    role: info.role,
+                    messageID: info.id,
+                });
+                const { state, resolved } = await sessionManager.resolveSessionState(sessionId);
+                if (!resolved) {
+                    logger.debug("Unable to resolve session for message update:", {
+                        sessionId,
+                        messageID: info.id,
+                        role: info.role,
+                    });
+                    return;
+                }
+                if (!state?.isMain) {
+                    logger.debug("Ignoring non-main message update:", sessionId);
+                    return;
+                }
+                if (info.role !== "assistant") {
+                    sessionManager.deletePendingAssistant(sessionId, info.id);
+                    return;
+                }
+                const time = info.time;
+                if (!time?.completed)
+                    return;
+                if (sessionManager.isAssistantBuffered(sessionId, info.id))
+                    return;
+                sessionManager.finalizeAssistantMessage(state, sessionId, info.id, "message.updated");
+                if (info.tokens && info.providerID && info.modelID) {
+                    resolveContextLimit(info.providerID, info.modelID, sdkClient, directory)
+                        .then((limit) => {
+                        state.contextLimit = limit;
+                    })
+                        .catch((err) => logger.debug("Failed to resolve context limit", err));
+                }
+                return;
+            }
+            if (event.type === "message.part.updated") {
+                const part = event.properties.part;
+                if (!isTextPart(part))
+                    return;
+                const sessionId = part.sessionID;
+                const messageId = part.messageID;
+                sessionManager.bufferAssistantPart(sessionId, messageId, part.text);
+            }
+        }
+        catch (err) {
+            logger.error("Event handler error", { type: event.type, err });
+        }
+    };
+}

package/esm/src/index.d.ts

@@ -1,4 +1,6 @@
 import type { Plugin } from "@opencode-ai/plugin";
-export declare const makeGroupId: (prefix: string, directory?: string) => string;
+/**
+ * OpenCode plugin entry point for Graphiti memory integration.
+ */
 export declare const graphiti: Plugin;
 //# sourceMappingURL=index.d.ts.map

package/esm/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,qBAAqB,CAAC;AAqB/D,eAAO,MAAM,WAAW,GAAI,QAAQ,MAAM,EAAE,YAAY,MAAM,KAAG,MAKhE,CAAC;AAeF,eAAO,MAAM,QAAQ,EAAE,MA+ftB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,qBAAqB,CAAC;AAW/D;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,MA4CtB,CAAC"}