@noopolis/mneme 0.1.0

package/dist/runtime/support.js

@@ -0,0 +1,229 @@
+import { memoryPolicy } from "../policy/policy.js";
+import { runRecall } from "../recall/recall.js";
+const defaultTokenBudget = 1200;
+const defaultSourcePrefix = "daimon";
+export const defaultSource = (agentId) => `${defaultSourcePrefix}/${agentId}`;
+export const clampTokenBudget = (value) => {
+    if (!value || Number.isNaN(value) || value <= 0) {
+        return defaultTokenBudget;
+    }
+    return Math.max(128, Math.floor(value));
+};
+const trimText = (value, maxLength) => {
+    const normalized = value.trim();
+    return normalized.length <= maxLength ? normalized : normalized.slice(0, maxLength).trim();
+};
+export const normalizeScopeIds = (ids) => {
+    return [...new Set(ids.map((value) => value.trim().toLowerCase()).filter(Boolean))];
+};
+const extractTokens = (text) => {
+    const payload = `${text}`.toLowerCase();
+    return [...new Set(payload
+            .split(/[^a-z0-9]+/u)
+            .map((value) => value.trim())
+            .filter((value) => value.length > 3))].slice(0, 32);
+};
+export const readByScopes = async (store, scopeIds) => {
+    const queries = await Promise.all(scopeIds.map((scope) => store.read({ scope })));
+    const seen = new Set();
+    const events = [];
+    for (const event of queries.flat()) {
+        if (seen.has(event.id)) {
+            continue;
+        }
+        seen.add(event.id);
+        events.push(event);
+    }
+    return events;
+};
+export const recallableEvents = (events) => {
+    const forgotten = new Set(events
+        .filter((event) => event.type === "memory.forgotten")
+        .flatMap((event) => event.parentEventIds));
+    return events.filter((event) => event.type !== "memory.located" &&
+        event.type !== "memory.denied" &&
+        event.type !== "memory.forgotten" &&
+        !forgotten.has(event.id));
+};
+export const deniedMemoryEvents = (input) => input.events.flatMap((event) => {
+    if (input.selectedIds.has(event.id)) {
+        return [];
+    }
+    const decision = memoryPolicy({
+        request: input.requester,
+        activeScope: input.activeScope,
+        candidate: event
+    });
+    return decision.decision === "deny" ? [{ event, reason: decision.reason }] : [];
+});
+export const buildRecallInput = (input) => {
+    return runRecall({
+        actor: input.actor,
+        scopeIds: input.scopeIds,
+        events: input.events,
+        query: input.text,
+        maxTokens: clampTokenBudget(input.maxTokens)
+    });
+};
+const toDecisionText = (decision) => {
+    return decision === "allow_raw" ? "used raw"
+        : decision === "allow_summary" ? "used summary"
+            : decision === "allow_redacted_summary" ? "used redacted summary"
+                : decision === "known_but_private" ? "used private memory via scope policy"
+                    : decision === "locate_only" ? "used locate-only hint"
+                        : decision === "unavailable" ? "memory unavailable"
+                            : decision === "malformed_request" ? "malformed request"
+                                : "denied by policy";
+};
+const memoryTagsFromRequest = (request, packet, result) => {
+    const context = request.context ?? {};
+    const tokens = [
+        ...extractTokens(request.text),
+        ...extractTokens(packet.principal.scope),
+        request.kind,
+        result.principal.scope,
+        ...extractTokens(result.principal.qualifier ?? ""),
+        ...context.networkId ? [context.networkId] : [],
+        ...context.roomId ? [context.roomId] : []
+    ];
+    return [...new Set(tokens)].slice(0, 64);
+};
+const baseEventInput = (input) => {
+    return {
+        principal: input.principal,
+        scope: input.scope,
+        visibility: input.visibility,
+        source: input.source,
+        parentEventIds: input.parentEventIds,
+        tags: input.tags,
+        entities: input.entities,
+        sensitivity: "normal"
+    };
+};
+const visibilityForPrincipal = (principal) => {
+    if (principal.scope === "global" ||
+        principal.scope === "team" ||
+        principal.scope === "room" ||
+        principal.scope === "pair") {
+        return principal.scope;
+    }
+    return "private";
+};
+export const buildDecisionEvents = (input) => {
+    const entities = [
+        ...extractTokens(input.request.text),
+        ...extractTokens(input.packet.principal.agentId),
+        ...extractTokens(input.packet.principal.scope)
+    ];
+    const tags = memoryTagsFromRequest(input.request, input.packet, {
+        principal: input.principal,
+        packet: input.packet,
+        promptText: input.outputText,
+        recall: input.recall
+    });
+    const base = baseEventInput({
+        principal: input.principal,
+        scope: input.scope,
+        source: input.source,
+        visibility: visibilityForPrincipal(input.principal),
+        tags,
+        entities,
+        parentEventIds: input.parentEventIds
+    });
+    const events = [
+        {
+            ...base,
+            type: "memory.claimed",
+            content: {
+                kind: "text",
+                text: `Wake request ${input.request.eventId} from ${input.request.from ?? "operator"}: ${trimText(input.request.text, 480)}`
+            }
+        },
+        {
+            ...base,
+            type: "memory.observed",
+            tags: [...tags, "output", input.result],
+            content: {
+                kind: "text",
+                text: `Agent output: ${trimText(input.outputText, 620)}`
+            }
+        }
+    ];
+    for (const selected of input.recall.selected ?? []) {
+        events.push({
+            ...base,
+            type: "memory.recalled",
+            tags: [...tags, "memory", selected.decision, selected.scope],
+            content: {
+                kind: "text",
+                text: `Recalled ${selected.eventId}: ${selected.representation}. Decision=${toDecisionText(selected.decision)} (${selected.scope})`
+            },
+            entities: [...entities, selected.eventId]
+        });
+    }
+    if (input.result === "failed" && input.error) {
+        events.push({
+            ...base,
+            type: "memory.denied",
+            tags: [...tags, "failed"],
+            content: {
+                kind: "text",
+                text: `Turn failed: ${trimText(input.error, 480)}`
+            }
+        });
+    }
+    if (input.packet.sections.length > 0) {
+        for (const section of input.packet.sections) {
+            events.push({
+                ...base,
+                type: "memory.observed",
+                tags: [...tags, "section", section.heading.toLowerCase()],
+                content: {
+                    kind: "text",
+                    text: `${section.heading}: ${trimText(section.text, 420)}`
+                },
+                entities: [...entities, ...extractTokens(section.heading), ...extractTokens(section.text)]
+            });
+        }
+    }
+    return events;
+};
+export const selectToolSummary = (toolEvents) => {
+    if (!Array.isArray(toolEvents) || toolEvents.length === 0) {
+        return undefined;
+    }
+    return {
+        principal: {
+            agentId: "daimon",
+            scope: "global"
+        },
+        type: "memory.summarized",
+        scope: "global",
+        visibility: "global",
+        source: "mneme/tool",
+        content: {
+            kind: "text",
+            text: `Observed ${toolEvents.length} tool event(s) during turn.`
+        },
+        tags: ["tool", "summary"],
+        entities: ["tool"],
+        parentEventIds: []
+    };
+};
+export const runMemorySelection = (input) => {
+    const selection = runRecall({
+        actor: input.requester,
+        scopeIds: input.scopeIds,
+        events: input.events,
+        query: input.query,
+        maxTokens: clampTokenBudget((input.maxResults ?? 1) * 160)
+    });
+    const limited = input.maxResults !== undefined ? selection.selected.slice(0, input.maxResults) : selection.selected;
+    return limited.map((entry) => ({
+        event: entry.event,
+        decision: entry.decision,
+        representation: entry.representation,
+        scope: entry.scope
+    }));
+};
+export { runRecall };

package/dist/store/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./sqliteIndex.js";
+export * from "./store.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/store/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/store/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC"}

package/dist/store/index.js

@@ -0,0 +1,2 @@
+export * from "./sqliteIndex.js";
+export * from "./store.js";

package/dist/store/sqliteIndex.d.ts

@@ -0,0 +1,38 @@
+import type { MemoryEvent, MemoryEventType, MemoryPrincipalRef } from "../contract/types.js";
+export interface MemoryIndexQuery {
+    allowedScopes?: string[];
+    query?: string;
+    tags?: string[];
+    entities?: string[];
+    types?: MemoryEventType[];
+    principalAgentId?: string;
+    principalScope?: MemoryPrincipalRef["scope"];
+    principalQualifier?: string;
+    limit?: number;
+    offset?: number;
+}
+export interface MemoryIndexSearchResult {
+    event: MemoryEvent;
+    score: number;
+}
+export interface SQLiteIndexConfig {
+    runtimeHomePath: string;
+    indexFilePath?: string;
+}
+export declare class SQLiteMemoryIndex {
+    private readonly db;
+    private readonly dbPath;
+    private ftsEnabled;
+    constructor(options: SQLiteIndexConfig);
+    rebuildFromStore(): Promise<void>;
+    rebuildFromEvents(events: MemoryEvent[]): Promise<void>;
+    query(input: MemoryIndexQuery): Promise<MemoryIndexSearchResult[]>;
+    close(): void;
+    private useFtsFallback;
+    private detectFts;
+    private rebuildSchema;
+    private runQuery;
+    private tableExists;
+}
+export declare const createMemoryIndex: (options: SQLiteIndexConfig) => SQLiteMemoryIndex;
+//# sourceMappingURL=sqliteIndex.d.ts.map

package/dist/store/sqliteIndex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqliteIndex.d.ts","sourceRoot":"","sources":["../../src/store/sqliteIndex.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,WAAW,EACX,eAAe,EACf,kBAAkB,EACnB,MAAM,sBAAsB,CAAC;AAE9B,MAAM,WAAW,gBAAgB;IAC/B,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,KAAK,CAAC,EAAE,eAAe,EAAE,CAAC;IAC1B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,cAAc,CAAC,EAAE,kBAAkB,CAAC,OAAO,CAAC,CAAC;IAC7C,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,WAAW,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf;AA0BD,MAAM,WAAW,iBAAiB;IAChC,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAe;IAClC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,UAAU,CAAsB;gBAE5B,OAAO,EAAE,iBAAiB;IAOhC,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAKjC,iBAAiB,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAIvD,KAAK,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,uBAAuB,EAAE,CAAC;IAKxE,KAAK,IAAI,IAAI;IAIb,OAAO,CAAC,cAAc;IAOtB,OAAO,CAAC,SAAS;IAUjB,OAAO,CAAC,aAAa;IAyIrB,OAAO,CAAC,QAAQ;IA2GhB,OAAO,CAAC,WAAW;CAMpB;AAED,eAAO,MAAM,iBAAiB,GAAI,SAAS,iBAAiB,KAAG,iBAC/B,CAAC"}

package/dist/store/sqliteIndex.js

@@ -0,0 +1,270 @@
+import { DatabaseSync } from "node:sqlite";
+import { mkdirSync } from "node:fs";
+import path from "node:path";
+import { JsonlMemoryStore } from "./store.js";
+import { canonicalScopeKey } from "../identity/ids.js";
+const defaultIndexFileName = "index.sqlite";
+const normalizeScope = (scope) => canonicalScopeKey(scope);
+const uniqueSorted = (values) => [...new Set(values.map((value) => value.trim().toLowerCase()).filter(Boolean))].sort();
+const splitQueryTokens = (query) => {
+    return uniqueSorted(query.split(/[^a-z0-9]+/u).filter((value) => value.length >= 2));
+};
+const escapeLikeTerm = (value) => value.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_");
+const placeholders = (count) => new Array(count).fill("?").join(", ");
+export class SQLiteMemoryIndex {
+    db;
+    dbPath;
+    ftsEnabled;
+    constructor(options) {
+        const memoryPath = path.join(options.runtimeHomePath, "memory");
+        mkdirSync(memoryPath, { recursive: true });
+        this.dbPath = options.indexFilePath ?? path.join(memoryPath, defaultIndexFileName);
+        this.db = new DatabaseSync(this.dbPath);
+    }
+    async rebuildFromStore() {
+        const events = await new JsonlMemoryStore(path.dirname(path.dirname(this.dbPath))).read();
+        await this.rebuildFromEvents(events);
+    }
+    async rebuildFromEvents(events) {
+        this.rebuildSchema(events);
+    }
+    async query(input) {
+        const results = this.runQuery(input);
+        return results;
+    }
+    close() {
+        this.db.close();
+    }
+    useFtsFallback() {
+        if (this.ftsEnabled === undefined) {
+            this.ftsEnabled = this.detectFts();
+        }
+        return this.ftsEnabled;
+    }
+    detectFts() {
+        try {
+            this.db.exec("CREATE VIRTUAL TABLE memory_events_fts_probe USING fts5(term)");
+            this.db.exec("DROP TABLE memory_events_fts_probe");
+            return true;
+        }
+        catch (_error) {
+            return false;
+        }
+    }
+    rebuildSchema(events) {
+        const normalized = [...events]
+            .map((event) => {
+            const scope = normalizeScope(event.scope);
+            const tags = uniqueSorted(event.tags ?? []);
+            const entities = uniqueSorted(event.entities ?? []);
+            const searchable = JSON.stringify({
+                id: event.id,
+                type: event.type,
+                scope,
+                principal: event.principal,
+                visibility: event.visibility,
+                sensitivity: event.sensitivity,
+                source: event.source,
+                tags,
+                entities,
+                content: event.content
+            }).toLowerCase();
+            return {
+                event,
+                eventId: event.id,
+                checksum: event.checksum,
+                createdAt: event.createdAt,
+                scope,
+                tags,
+                entities,
+                searchable,
+            };
+        })
+            .sort((left, right) => {
+            const createdAt = Date.parse(right.createdAt) - Date.parse(left.createdAt);
+            if (createdAt !== 0) {
+                return createdAt;
+            }
+            const scopeDelta = left.scope.localeCompare(right.scope);
+            if (scopeDelta !== 0) {
+                return scopeDelta;
+            }
+            const idDelta = left.eventId.localeCompare(right.eventId);
+            if (idDelta !== 0) {
+                return idDelta;
+            }
+            return left.checksum.localeCompare(right.checksum);
+        });
+        const useFts = this.useFtsFallback();
+        this.db.exec("BEGIN");
+        try {
+            this.db.exec("DROP TABLE IF EXISTS memory_event_entities");
+            this.db.exec("DROP TABLE IF EXISTS memory_event_tags");
+            this.db.exec("DROP TABLE IF EXISTS memory_events_fts");
+            this.db.exec("DROP TABLE IF EXISTS memory_events");
+            this.db.exec(`CREATE TABLE memory_events (
+        event_id TEXT PRIMARY KEY,
+        created_at TEXT NOT NULL,
+        scope TEXT NOT NULL,
+        type TEXT NOT NULL,
+        principal_agent_id TEXT NOT NULL,
+        principal_scope TEXT NOT NULL,
+        principal_qualifier TEXT,
+        visibility TEXT NOT NULL,
+        sensitivity TEXT NOT NULL,
+        source TEXT NOT NULL,
+        checksum TEXT NOT NULL,
+        searchable_text TEXT NOT NULL,
+        event_json TEXT NOT NULL
+      )`);
+            this.db.exec("CREATE INDEX memory_events_scope_idx ON memory_events(scope)");
+            this.db.exec("CREATE INDEX memory_events_type_idx ON memory_events(type)");
+            this.db.exec("CREATE INDEX memory_events_principal_agent_idx ON memory_events(principal_agent_id)");
+            this.db.exec("CREATE INDEX memory_events_principal_scope_idx ON memory_events(principal_scope)");
+            this.db.exec("CREATE INDEX memory_events_principal_qualifier_idx ON memory_events(principal_qualifier)");
+            this.db.exec("CREATE TABLE memory_event_tags (event_id TEXT NOT NULL, tag TEXT NOT NULL)");
+            this.db.exec("CREATE TABLE memory_event_entities (event_id TEXT NOT NULL, entity TEXT NOT NULL)");
+            this.db.exec("CREATE INDEX memory_event_tags_event_idx ON memory_event_tags(event_id)");
+            this.db.exec("CREATE INDEX memory_event_tags_tag_idx ON memory_event_tags(tag)");
+            this.db.exec("CREATE INDEX memory_event_entities_event_idx ON memory_event_entities(event_id)");
+            this.db.exec("CREATE INDEX memory_event_entities_entity_idx ON memory_event_entities(entity)");
+            if (useFts) {
+                this.db.exec(`CREATE VIRTUAL TABLE memory_events_fts USING fts5(event_id UNINDEXED, text)`);
+            }
+            const insertEvent = this.db.prepare(`
+        INSERT INTO memory_events
+        (event_id, created_at, scope, type, principal_agent_id, principal_scope, principal_qualifier, visibility, sensitivity, source, checksum, searchable_text, event_json)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+            const insertTag = this.db.prepare(`
+        INSERT INTO memory_event_tags (event_id, tag)
+        VALUES (?, ?)
+      `);
+            const insertEntity = this.db.prepare(`
+        INSERT INTO memory_event_entities (event_id, entity)
+        VALUES (?, ?)
+      `);
+            const insertFts = useFts ? this.db.prepare(`
+        INSERT INTO memory_events_fts (event_id, text)
+        VALUES (?, ?)
+      `) : undefined;
+            for (const event of normalized) {
+                const rawEvent = event.event;
+                insertEvent.run(rawEvent.id, rawEvent.createdAt, event.scope, rawEvent.type, rawEvent.principal.agentId, rawEvent.principal.scope, rawEvent.principal.qualifier ?? null, rawEvent.visibility, rawEvent.sensitivity, rawEvent.source, rawEvent.checksum, event.searchable, JSON.stringify(rawEvent));
+                for (const tag of event.tags) {
+                    insertTag.run(rawEvent.id, tag);
+                }
+                for (const entity of event.entities) {
+                    insertEntity.run(rawEvent.id, entity);
+                }
+                insertFts?.run(rawEvent.id, event.searchable);
+            }
+            this.db.exec("COMMIT");
+        }
+        catch (error) {
+            this.db.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    runQuery(input) {
+        const where = [];
+        const whereParams = [];
+        const scoreParams = [];
+        const allowedScopes = uniqueSorted((input.allowedScopes ?? []).map(normalizeScope).filter(Boolean));
+        if (allowedScopes.length > 0) {
+            where.push(`e.scope IN (${placeholders(allowedScopes.length)})`);
+            whereParams.push(...allowedScopes);
+        }
+        const types = uniqueSorted(input.types ?? []);
+        if (types.length > 0) {
+            where.push(`e.type IN (${placeholders(types.length)})`);
+            whereParams.push(...types);
+        }
+        if (input.principalAgentId) {
+            where.push("e.principal_agent_id = ?");
+            whereParams.push(input.principalAgentId);
+        }
+        if (input.principalScope) {
+            where.push("e.principal_scope = ?");
+            whereParams.push(input.principalScope);
+        }
+        if (input.principalQualifier) {
+            where.push("e.principal_qualifier = ?");
+            whereParams.push(input.principalQualifier);
+        }
+        const tags = uniqueSorted(input.tags ?? []);
+        if (tags.length > 0) {
+            where.push(`
+        e.event_id IN (
+          SELECT event_id
+          FROM memory_event_tags
+          WHERE tag IN (${placeholders(tags.length)})
+          GROUP BY event_id
+          HAVING COUNT(DISTINCT tag) = ${tags.length}
+        )
+      `);
+            whereParams.push(...tags);
+        }
+        const entities = uniqueSorted(input.entities ?? []);
+        if (entities.length > 0) {
+            where.push(`
+        e.event_id IN (
+          SELECT event_id
+          FROM memory_event_entities
+          WHERE entity IN (${placeholders(entities.length)})
+          GROUP BY event_id
+          HAVING COUNT(DISTINCT entity) = ${entities.length}
+        )
+      `);
+            whereParams.push(...entities);
+        }
+        const queryTokens = splitQueryTokens(input.query ?? "");
+        let searchScore = "0";
+        if (queryTokens.length > 0) {
+            if (this.useFtsFallback() && this.tableExists("memory_events_fts")) {
+                const match = queryTokens.map((token) => `${token}*`).join(" ");
+                where.push(`e.event_id IN (SELECT event_id FROM memory_events_fts WHERE memory_events_fts MATCH ?)`);
+                whereParams.push(match);
+                searchScore = "1.0";
+            }
+            else {
+                const scoreParts = [];
+                for (const token of queryTokens) {
+                    const like = `%${escapeLikeTerm(token)}%`;
+                    where.push(`LOWER(e.searchable_text) LIKE ? ESCAPE '\\'`);
+                    whereParams.push(like);
+                    scoreParts.push("CASE WHEN LOWER(e.searchable_text) LIKE ? ESCAPE '\\' THEN 1 ELSE 0 END");
+                    scoreParams.push(like);
+                }
+                searchScore = `(${scoreParts.join(" + ")})`;
+            }
+        }
+        const clause = where.length > 0 ? `WHERE ${where.join(" AND ")}` : "";
+        const orderBy = "ORDER BY score DESC, e.created_at DESC, e.scope ASC, e.event_id ASC, e.checksum ASC";
+        const limit = input.limit ?? 100;
+        const safeLimit = Number.isFinite(limit) && limit > 0 ? limit : 100;
+        const offset = input.offset ?? 0;
+        const safeOffset = Number.isFinite(offset) && offset >= 0 ? offset : 0;
+        const statement = this.db.prepare(`
+      SELECT
+        e.event_json AS event_json,
+        ${searchScore} AS score
+      FROM memory_events e
+      ${clause}
+      GROUP BY e.event_id
+      ${orderBy}
+      LIMIT ${safeLimit}
+      OFFSET ${safeOffset}
+    `);
+        const rows = statement.all(...scoreParams, ...whereParams);
+        return rows.map((row) => ({
+            event: JSON.parse(row.event_json),
+            score: Number(row.score)
+        }));
+    }
+    tableExists(tableName) {
+        const row = this.db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(tableName);
+        return Boolean(row?.name);
+    }
+}
+export const createMemoryIndex = (options) => new SQLiteMemoryIndex(options);

package/dist/store/store.d.ts

@@ -0,0 +1,27 @@
+import type { MemoryEvent, MemoryEventInput } from "../contract/types.js";
+export interface MemoryStoreQuery {
+    scope?: string;
+    principalAgentId?: string;
+    principalScope?: string;
+    principalQualifier?: string;
+    types?: string[];
+    tags?: string[];
+    search?: string;
+}
+export interface MemoryStore {
+    append(event: MemoryEventInput): Promise<MemoryEvent>;
+    appendBatch(events: MemoryEventInput[]): Promise<MemoryEvent[]>;
+    read(query?: MemoryStoreQuery): Promise<MemoryEvent[]>;
+    clear(): Promise<void>;
+}
+export declare class JsonlMemoryStore implements MemoryStore {
+    private readonly eventsPath;
+    private readonly dirPath;
+    constructor(runtimeHomePath: string);
+    private appendOne;
+    append(input: MemoryEventInput): Promise<MemoryEvent>;
+    appendBatch(inputs: MemoryEventInput[]): Promise<MemoryEvent[]>;
+    clear(): Promise<void>;
+    read(query?: MemoryStoreQuery): Promise<MemoryEvent[]>;
+}
+//# sourceMappingURL=store.d.ts.map

package/dist/store/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/store/store.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,WAAW,EACX,gBAAgB,EACjB,MAAM,sBAAsB,CAAC;AAE9B,MAAM,WAAW,gBAAgB;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,WAAW;IAC1B,MAAM,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;IACtD,WAAW,CAAC,MAAM,EAAE,gBAAgB,EAAE,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;IAChE,IAAI,CAAC,KAAK,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;IACvD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,qBAAa,gBAAiB,YAAW,WAAW;IAClD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;gBAErB,eAAe,EAAE,MAAM;YAKrB,SAAS;IA4BjB,MAAM,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,WAAW,CAAC;IAIrD,WAAW,CAAC,MAAM,EAAE,gBAAgB,EAAE,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAa/D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAItB,IAAI,CAAC,KAAK,GAAE,gBAAqB,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;CAyEjE"}