opencode-graphiti 0.1.0

package/script/src/services/client.js

@@ -0,0 +1,238 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphitiClient = void 0;
+const dntShim = __importStar(require("../../_dnt.shims.js"));
+const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+const logger_js_1 = require("./logger.js");
+class GraphitiClient {
+    constructor(endpoint) {
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "transport", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "connected", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "endpoint", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.endpoint = endpoint;
+        this.client = new index_js_1.Client({ name: "opencode-graphiti", version: "0.1.0" });
+        const url = new dntShim.dntGlobalThis.URL(endpoint);
+        this.transport = new streamableHttp_js_1.StreamableHTTPClientTransport(url);
+    }
+    async connect() {
+        if (this.connected)
+            return true;
+        try {
+            await this.client.connect(this.transport);
+            this.connected = true;
+            logger_js_1.logger.info("Connected to Graphiti MCP server at", this.endpoint);
+            return true;
+        }
+        catch (err) {
+            logger_js_1.logger.error("Failed to connect to Graphiti:", err);
+            return false;
+        }
+    }
+    async disconnect() {
+        if (this.connected) {
+            await this.client.close();
+            this.connected = false;
+        }
+    }
+    async callTool(name, args) {
+        if (!this.connected) {
+            const ok = await this.connect();
+            if (!ok)
+                throw new Error("Not connected to Graphiti");
+        }
+        // Sanitize arguments: omit task_id (and others) if null or undefined
+        const sanitizedArgs = Object.fromEntries(Object.entries(args).filter(([_, v]) => v !== null && v !== undefined));
+        try {
+            const result = await this.client.callTool({
+                name,
+                arguments: sanitizedArgs,
+            });
+            return this.parseToolResult(result);
+        }
+        catch (err) {
+            if (this.isSessionExpired(err)) {
+                logger_js_1.logger.warn("Graphiti session expired, reconnecting...");
+                await this.reconnect();
+                const result = await this.client.callTool({
+                    name,
+                    arguments: sanitizedArgs,
+                });
+                return this.parseToolResult(result);
+            }
+            throw err;
+        }
+    }
+    isSessionExpired(err) {
+        return !!(err &&
+            typeof err === "object" &&
+            "code" in err &&
+            err.code === 404);
+    }
+    async reconnect() {
+        this.connected = false;
+        try {
+            await this.transport.close();
+        }
+        catch {
+            // ignore transport close errors
+        }
+        this.transport = new streamableHttp_js_1.StreamableHTTPClientTransport(new URL(this.endpoint));
+        await this.client.connect(this.transport);
+        this.connected = true;
+        logger_js_1.logger.info("Reconnected to Graphiti MCP server");
+    }
+    // Public for testing
+    parseToolResult(result) {
+        const typedResult = result;
+        const content = typedResult.content;
+        if (!Array.isArray(content) || content.length === 0)
+            return result;
+        const text = content.find((item) => item?.type === "text")?.text;
+        if (text === undefined)
+            return result;
+        if (typeof text !== "string") {
+            try {
+                return JSON.parse(String(text));
+            }
+            catch {
+                return text;
+            }
+        }
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return text;
+        }
+    }
+    async addEpisode(params) {
+        await this.callTool("add_memory", {
+            name: params.name,
+            episode_body: params.episodeBody,
+            group_id: params.groupId,
+            source: params.source || "text",
+            source_description: params.sourceDescription || "",
+        });
+        logger_js_1.logger.debug("Added episode:", params.name);
+    }
+    async searchFacts(params) {
+        try {
+            const result = await this.callTool("search_memory_facts", {
+                query: params.query,
+                group_ids: params.groupIds,
+                max_facts: params.maxFacts || 10,
+            });
+            if (Array.isArray(result))
+                return result;
+            if (result &&
+                typeof result === "object" &&
+                Array.isArray(result.facts)) {
+                return result.facts;
+            }
+            return [];
+        }
+        catch (err) {
+            logger_js_1.logger.error("searchFacts error:", err);
+            return [];
+        }
+    }
+    async searchNodes(params) {
+        try {
+            const result = await this.callTool("search_nodes", {
+                query: params.query,
+                group_ids: params.groupIds,
+                max_nodes: params.maxNodes || 10,
+            });
+            if (Array.isArray(result))
+                return result;
+            if (result &&
+                typeof result === "object" &&
+                Array.isArray(result.nodes)) {
+                return result.nodes;
+            }
+            return [];
+        }
+        catch (err) {
+            logger_js_1.logger.error("searchNodes error:", err);
+            return [];
+        }
+    }
+    async getEpisodes(params) {
+        try {
+            const result = await this.callTool("get_episodes", {
+                group_ids: params.groupIds,
+                max_episodes: params.maxEpisodes || 10,
+            });
+            return result || [];
+        }
+        catch (err) {
+            logger_js_1.logger.error("getEpisodes error:", err);
+            return [];
+        }
+    }
+    async getStatus() {
+        try {
+            await this.callTool("get_status", {});
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.GraphitiClient = GraphitiClient;

package/script/src/services/compaction.d.ts

@@ -0,0 +1,93 @@
+import type { GraphitiConfig } from "../types/index.js";
+export interface CompactionDependencies {
+    sdkClient: {
+        session: {
+            summarize: (options: {
+                path: {
+                    id: string;
+                };
+                body?: {
+                    providerID: string;
+                    modelID: string;
+                };
+                query?: {
+                    directory?: string;
+                };
+            }) => Promise<unknown>;
+            promptAsync: (options: {
+                path: {
+                    id: string;
+                };
+                body?: {
+                    parts: Array<{
+                        type: "text";
+                        text: string;
+                    }>;
+                };
+                query?: {
+                    directory?: string;
+                };
+            }) => Promise<unknown>;
+        };
+        tui: {
+            showToast: (options?: {
+                body?: {
+                    title?: string;
+                    message: string;
+                    variant: "info" | "success" | "warning" | "error";
+                    duration?: number;
+                };
+                query?: {
+                    directory?: string;
+                };
+            }) => Promise<unknown>;
+        };
+        provider: {
+            list: (options?: {
+                directory?: string;
+            }) => Promise<unknown>;
+        };
+    };
+    directory: string;
+}
+export declare function createPreemptiveCompactionHandler(config: Pick<GraphitiConfig, "compactionThreshold" | "minTokensForCompaction" | "compactionCooldownMs" | "autoResumeAfterCompaction">, deps: CompactionDependencies): {
+    checkAndTriggerCompaction(sessionId: string, tokens: {
+        input: number;
+        output: number;
+        reasoning: number;
+        cache: {
+            read: number;
+            write: number;
+        };
+    }, providerID: string, modelID: string): Promise<void>;
+};
+export declare function handleCompaction(params: {
+    client: {
+        addEpisode: (args: {
+            name: string;
+            episodeBody: string;
+            groupId?: string;
+            source?: "text" | "json" | "message";
+            sourceDescription?: string;
+        }) => Promise<void>;
+    };
+    config: GraphitiConfig;
+    groupId: string;
+    summary: string;
+    sessionId: string;
+}): Promise<void>;
+export declare function getCompactionContext(params: {
+    client: {
+        searchFacts: (args: {
+            query: string;
+            groupIds?: string[];
+            maxFacts?: number;
+        }) => Promise<Array<{
+            fact: string;
+        }>>;
+    };
+    config: GraphitiConfig;
+    groupId: string;
+    contextStrings: string[];
+}): Promise<string[]>;
+//# sourceMappingURL=compaction.d.ts.map

package/script/src/services/compaction.d.ts.map

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

package/script/src/services/compaction.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPreemptiveCompactionHandler = createPreemptiveCompactionHandler;
+exports.handleCompaction = handleCompaction;
+exports.getCompactionContext = getCompactionContext;
+const logger_js_1 = require("./logger.js");
+const DEFAULT_CONTEXT_LIMIT = 200_000;
+const RESUME_DELAY_MS = 500;
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const buildModelKey = (providerID, modelID) => `${providerID}/${modelID}`;
+const resolveContextLimit = async (providerID, modelID, deps, state) => {
+    const modelKey = buildModelKey(providerID, modelID);
+    const cached = state.contextLimitCache.get(modelKey);
+    if (cached)
+        return cached;
+    try {
+        const providers = await deps.sdkClient.provider.list({
+            directory: deps.directory,
+        });
+        const list = providers.providers ?? [];
+        for (const provider of list) {
+            const providerInfo = provider;
+            if (providerInfo.id !== providerID)
+                continue;
+            const models = providerInfo.models ?? [];
+            for (const model of models) {
+                const modelInfo = model;
+                if (modelInfo.id !== modelID)
+                    continue;
+                const contextLimit = modelInfo.limit?.context;
+                if (typeof contextLimit === "number" && contextLimit > 0) {
+                    state.contextLimitCache.set(modelKey, contextLimit);
+                    return contextLimit;
+                }
+            }
+        }
+    }
+    catch (err) {
+        logger_js_1.logger.warn("Failed to fetch provider context limit", err);
+    }
+    state.contextLimitCache.set(modelKey, DEFAULT_CONTEXT_LIMIT);
+    return DEFAULT_CONTEXT_LIMIT;
+};
+function createPreemptiveCompactionHandler(config, deps) {
+    const state = {
+        lastCompactionTime: new Map(),
+        compactionInProgress: new Set(),
+        contextLimitCache: new Map(),
+    };
+    const checkAndTriggerCompaction = async (sessionId, tokens, providerID, modelID) => {
+        const totalTokens = tokens.input + tokens.cache.read + tokens.output +
+            tokens.reasoning;
+        if (totalTokens < (config.minTokensForCompaction ?? 0))
+            return;
+        if (state.compactionInProgress.has(sessionId))
+            return;
+        const lastCompaction = state.lastCompactionTime.get(sessionId) ?? 0;
+        if (Date.now() - lastCompaction < (config.compactionCooldownMs ?? 0)) {
+            return;
+        }
+        const contextLimit = await resolveContextLimit(providerID, modelID, deps, state);
+        const usageRatio = totalTokens / contextLimit;
+        if (usageRatio < (config.compactionThreshold ?? 1))
+            return;
+        state.compactionInProgress.add(sessionId);
+        try {
+            await deps.sdkClient.tui.showToast({
+                body: {
+                    title: "Graphiti",
+                    message: "Compacting session to preserve context...",
+                    variant: "info",
+                    duration: 3000,
+                },
+                query: { directory: deps.directory },
+            });
+            await deps.sdkClient.session.summarize({
+                path: { id: sessionId },
+                body: { providerID, modelID },
+                query: { directory: deps.directory },
+            });
+            state.lastCompactionTime.set(sessionId, Date.now());
+            if (config.autoResumeAfterCompaction) {
+                await delay(RESUME_DELAY_MS);
+                await deps.sdkClient.session.promptAsync({
+                    path: { id: sessionId },
+                    body: { parts: [{ type: "text", text: "Continue" }] },
+                    query: { directory: deps.directory },
+                });
+            }
+            logger_js_1.logger.info("Preemptive compaction triggered", {
+                sessionId,
+                providerID,
+                modelID,
+                usageRatio,
+                totalTokens,
+                contextLimit,
+            });
+        }
+        catch (err) {
+            logger_js_1.logger.error("Preemptive compaction failed", err);
+        }
+        finally {
+            state.compactionInProgress.delete(sessionId);
+        }
+    };
+    return { checkAndTriggerCompaction };
+}
+async function handleCompaction(params) {
+    const { client, config, groupId, summary, sessionId } = params;
+    if (!config.enableCompactionSave || !summary)
+        return;
+    try {
+        await client.addEpisode({
+            name: `Session compaction: ${sessionId}`,
+            episodeBody: summary,
+            groupId,
+            source: "text",
+            sourceDescription: "OpenCode session compaction summary",
+        });
+        logger_js_1.logger.info("Saved compaction summary to Graphiti for session", sessionId);
+    }
+    catch (err) {
+        logger_js_1.logger.error("Failed to save compaction summary:", err);
+    }
+}
+async function getCompactionContext(params) {
+    const { client, config, groupId, contextStrings } = params;
+    try {
+        const queryText = contextStrings.slice(0, 3).join(" ").slice(0, 500);
+        if (!queryText.trim())
+            return [];
+        const facts = await client.searchFacts({
+            query: queryText,
+            groupIds: [groupId],
+            maxFacts: config.maxFacts,
+        });
+        if (facts.length === 0)
+            return [];
+        const lines = [
+            "## Persistent Knowledge (preserve these facts during compaction):",
+            ...facts.map((fact) => `- ${fact.fact}`),
+        ];
+        return [lines.join("\n")];
+    }
+    catch (err) {
+        logger_js_1.logger.error("Failed to get compaction context:", err);
+        return [];
+    }
+}

package/script/src/services/context.d.ts

@@ -0,0 +1,3 @@
+import type { GraphitiFact, GraphitiNode } from "../types/index.js";
+export declare function formatMemoryContext(facts: GraphitiFact[], nodes: GraphitiNode[]): string;
+//# sourceMappingURL=context.d.ts.map

package/script/src/services/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/src/services/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEpE,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,YAAY,EAAE,EACrB,KAAK,EAAE,YAAY,EAAE,GACpB,MAAM,CA0CR"}

package/script/src/services/context.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatMemoryContext = formatMemoryContext;
+function formatMemoryContext(facts, nodes) {
+    const sections = [];
+    sections.push("# Persistent Memory (from Graphiti Knowledge Graph)");
+    sections.push("");
+    sections.push("The following information was retrieved from your persistent memory.");
+    sections.push("Use this context to inform your responses, but do not mention it unless asked.");
+    sections.push("");
+    if (facts.length > 0) {
+        sections.push("## Known Facts");
+        for (const fact of facts) {
+            const entities = [];
+            if (fact.source_node?.name)
+                entities.push(fact.source_node.name);
+            if (fact.target_node?.name)
+                entities.push(fact.target_node.name);
+            const entityStr = entities.length > 0
+                ? ` [${entities.join(" -> ")}]`
+                : "";
+            sections.push(`- ${fact.fact}${entityStr}`);
+        }
+        sections.push("");
+    }
+    if (nodes.length > 0) {
+        sections.push("## Known Entities");
+        for (const node of nodes) {
+            const labels = node.labels?.length ? ` (${node.labels.join(", ")})` : "";
+            const summary = node.summary ? `: ${node.summary}` : "";
+            sections.push(`- **${node.name}**${labels}${summary}`);
+        }
+        sections.push("");
+    }
+    if (facts.length === 0 && nodes.length === 0) {
+        return "";
+    }
+    return sections.join("\n");
+}

package/script/src/services/logger.d.ts

@@ -0,0 +1,7 @@
+export declare const logger: {
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+    debug: (...args: unknown[]) => void;
+};
+//# sourceMappingURL=logger.d.ts.map

package/script/src/services/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/src/services/logger.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,MAAM;oBACD,OAAO,EAAE;oBAGT,OAAO,EAAE;qBAGR,OAAO,EAAE;qBAGT,OAAO,EAAE;CAG3B,CAAC"}

package/script/src/services/logger.js

@@ -0,0 +1,61 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const dntShim = __importStar(require("../../_dnt.shims.js"));
+const node_process_1 = __importDefault(require("node:process"));
+const console = dntShim.dntGlobalThis.console;
+const PREFIX = "[graphiti]";
+exports.logger = {
+    info: (...args) => {
+        if (node_process_1.default.env.GRAPHITI_DEBUG)
+            console.log(PREFIX, ...args);
+    },
+    warn: (...args) => {
+        if (node_process_1.default.env.GRAPHITI_DEBUG)
+            console.warn(PREFIX, ...args);
+    },
+    error: (...args) => {
+        if (node_process_1.default.env.GRAPHITI_DEBUG)
+            console.error(PREFIX, ...args);
+    },
+    debug: (...args) => {
+        if (node_process_1.default.env.GRAPHITI_DEBUG)
+            console.debug(PREFIX, ...args);
+    },
+};

package/script/src/types/index.d.ts

@@ -0,0 +1,48 @@
+export interface GraphitiConfig {
+    endpoint: string;
+    groupIdPrefix: string;
+    maxFacts: number;
+    maxNodes: number;
+    maxEpisodes: number;
+    injectOnFirstMessage: boolean;
+    enableCompactionSave: boolean;
+    compactionThreshold?: number;
+    minTokensForCompaction?: number;
+    compactionCooldownMs?: number;
+    autoResumeAfterCompaction?: boolean;
+}
+export interface GraphitiFact {
+    uuid: string;
+    fact: string;
+    valid_at?: string;
+    invalid_at?: string;
+    source_node?: {
+        name: string;
+        uuid: string;
+    };
+    target_node?: {
+        name: string;
+        uuid: string;
+    };
+}
+export interface GraphitiFactsResponse {
+    facts: GraphitiFact[];
+}
+export interface GraphitiNode {
+    uuid: string;
+    name: string;
+    summary?: string;
+    labels?: string[];
+}
+export interface GraphitiNodesResponse {
+    nodes: GraphitiNode[];
+}
+export interface GraphitiEpisode {
+    uuid: string;
+    name: string;
+    content: string;
+    source?: string;
+    created_at?: string;
+    labels?: string[];
+}
+//# sourceMappingURL=index.d.ts.map

package/script/src/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/src/types/index.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,oBAAoB,EAAE,OAAO,CAAC;IAC9B,oBAAoB,EAAE,OAAO,CAAC;IAE9B,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,yBAAyB,CAAC,EAAE,OAAO,CAAC;CACrC;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7C,WAAW,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;CAC9C;AAED,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,YAAY,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,YAAY,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB"}

package/script/src/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });