@noopolis/mneme 0.1.0

package/dist/identity/scope.js

@@ -0,0 +1,123 @@
+import { sanitizePrincipalQualifier } from "./ids.js";
+const roomPrincipal = (agentId, context) => {
+    if (!context?.networkId || !context.roomId) {
+        return undefined;
+    }
+    return {
+        agentId,
+        scope: "room",
+        qualifier: `${context.networkId}:${context.roomId}`
+    };
+};
+const teamPrincipal = (agentId, context) => {
+    if (!context?.teamId) {
+        return undefined;
+    }
+    return {
+        agentId,
+        scope: "team",
+        qualifier: context.teamId
+    };
+};
+const pairPrincipals = (agentId, context) => {
+    const peers = context?.pairPeers ?? [];
+    return [...new Set(peers
+            .map((peer) => sanitizePrincipalQualifier(peer))
+            .filter((peer) => Boolean(peer)))]
+        .sort()
+        .map((peer) => ({
+        agentId,
+        scope: "pair",
+        qualifier: peer
+    }));
+};
+const taskPrincipal = (agentId, context) => {
+    if (!context?.taskId) {
+        return undefined;
+    }
+    return {
+        agentId,
+        scope: "task",
+        qualifier: context.taskId
+    };
+};
+const rolePrincipal = (agentId, context) => {
+    if (!context?.roleId) {
+        return undefined;
+    }
+    return {
+        agentId,
+        scope: "role",
+        qualifier: context.roleId
+    };
+};
+export const resolveScopePlan = (input) => {
+    const global = {
+        agentId: input.agentId,
+        scope: "global"
+    };
+    const fromPeer = input.context?.from;
+    const fromPair = fromPeer ? [{
+            agentId: input.agentId,
+            scope: "pair",
+            qualifier: sanitizePrincipalQualifier(fromPeer) ?? fromPeer.trim().toLowerCase()
+        }] : [];
+    const room = roomPrincipal(input.agentId, input.context);
+    const team = teamPrincipal(input.agentId, input.context);
+    const task = taskPrincipal(input.agentId, input.context);
+    const role = rolePrincipal(input.agentId, input.context);
+    const pairEntries = pairPrincipals(input.agentId, input.context);
+    const pairPrincipal = fromPair[0] ?? pairEntries[0];
+    const isMessage = input.wake.kind === "message" || input.wake.kind === "manual";
+    const activePrincipal = ((isMessage && fromPair.length > 0) ? fromPair[0]
+        : room ? room
+            : team ? team
+                : task ? task
+                    : role ? role
+                        : global);
+    const readableScopes = [
+        global,
+        activePrincipal,
+        room,
+        team,
+        task,
+        role
+    ].filter((value) => Boolean(value));
+    if (isMessage && (pairEntries.length > 0 || pairPrincipal)) {
+        const pairs = [...pairEntries, ...(pairPrincipal ? [pairPrincipal] : [])];
+        readableScopes.push(...pairs);
+    }
+    const candidateScopes = [
+        global,
+        roomPrincipal(input.agentId, input.context),
+        teamPrincipal(input.agentId, input.context),
+        ...pairEntries,
+        ...(fromPair[0] ? [fromPair[0]] : []),
+        taskPrincipal(input.agentId, input.context),
+        rolePrincipal(input.agentId, input.context)
+    ].filter((value) => Boolean(value));
+    const deniedScopes = [];
+    return {
+        activePrincipal,
+        readableScopes,
+        candidateScopes,
+        deniedScopes
+    };
+};
+export const readMemoryContext = (event) => {
+    const context = event.context ?? {};
+    const participants = context.participants;
+    const pairPeers = context.pairPeers ?? participants;
+    const resolvedParticipants = participants ?? pairPeers;
+    return {
+        from: event.from ?? context.from,
+        networkId: context.networkId,
+        roomId: context.roomId,
+        teamId: context.teamId,
+        taskId: context.taskId,
+        roleId: context.roleId,
+        pairPeers,
+        artifactPaths: context.artifactPaths,
+        participants: resolvedParticipants
+    };
+};

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./contract/index.js";
+export * from "./identity/index.js";
+export * from "./kernel/index.js";
+export * from "./policy/index.js";
+export * from "./recall/index.js";
+export * from "./runtime/index.js";
+export * from "./store/index.js";
+export * from "./mcp/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from "./contract/index.js";
+export * from "./identity/index.js";
+export * from "./kernel/index.js";
+export * from "./policy/index.js";
+export * from "./recall/index.js";
+export * from "./runtime/index.js";
+export * from "./store/index.js";
+export * from "./mcp/index.js";

package/dist/kernel/index.d.ts

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

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

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

package/dist/kernel/index.js

@@ -0,0 +1,2 @@
+export * from "./kernel.js";
+export * from "./support.js";

package/dist/kernel/kernel.d.ts

@@ -0,0 +1,19 @@
+import type { MemoryKernel, MemoryToolCall, MemoryToolResult } from "../contract/types.js";
+export interface MemoryKernelConfig {
+    runtimeHomePath: string;
+    source?: string;
+}
+export declare class JsonlMemoryKernel implements MemoryKernel {
+    private readonly config;
+    private readonly store;
+    private readonly index;
+    private readonly source;
+    constructor(config: MemoryKernelConfig);
+    search(call: MemoryToolCall): Promise<MemoryToolResult>;
+    locate(call: MemoryToolCall): Promise<MemoryToolResult>;
+    register(call: MemoryToolCall): Promise<MemoryToolResult>;
+    summarize(call: MemoryToolCall): Promise<MemoryToolResult>;
+    forget(call: MemoryToolCall): Promise<MemoryToolResult>;
+}
+export declare const createMemoryKernel: (config: MemoryKernelConfig) => MemoryKernel;
+//# sourceMappingURL=kernel.d.ts.map

package/dist/kernel/kernel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kernel.d.ts","sourceRoot":"","sources":["../../src/kernel/kernel.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAEV,YAAY,EACZ,cAAc,EACd,gBAAgB,EACjB,MAAM,sBAAsB,CAAC;AA0B9B,MAAM,WAAW,kBAAkB;IACjC,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,iBAAkB,YAAW,YAAY;IAKxC,OAAO,CAAC,QAAQ,CAAC,MAAM;IAJnC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmB;IACzC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;gBAEH,MAAM,EAAE,kBAAkB;IAMjD,MAAM,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAmEvD,MAAM,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA+FvD,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAgDzD,SAAS,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAuE1D,MAAM,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAgD9D;AAED,eAAO,MAAM,kBAAkB,GAAI,QAAQ,kBAAkB,KAAG,YAA6C,CAAC"}

package/dist/kernel/kernel.js

@@ -0,0 +1,318 @@
+import { JsonlMemoryStore } from "../store/store.js";
+import { memoryPolicy } from "../policy/policy.js";
+import { createMemoryIndex } from "../store/sqliteIndex.js";
+import { runRecall } from "../recall/recall.js";
+import { asNumber, collectTombstones, hasInvalidV1Envelope, decide, eventText, isForgetArguments, isLocateArguments, isRegisterArguments, isRecallableMemoryEvent, isSearchArguments, isSummarizeArguments, makeAudit, matchesQuery, makeLocateResult, makeSearchResult, malformed, unavailable, policyText, resolveScope, locateCandidateId, sanitizePrincipal, } from "./support.js";
+export class JsonlMemoryKernel {
+    config;
+    store;
+    index;
+    source;
+    constructor(config) {
+        this.config = config;
+        this.store = new JsonlMemoryStore(config.runtimeHomePath);
+        this.index = createMemoryIndex({ runtimeHomePath: config.runtimeHomePath });
+        this.source = this.config.source ?? `mneme/${this.config.runtimeHomePath}`;
+    }
+    async search(call) {
+        const startAt = Date.now();
+        if (hasInvalidV1Envelope(call.envelope.version)) {
+            return malformed(call, "memory.search", "unsupported envelope", startAt);
+        }
+        const args = call.arguments;
+        if (!isSearchArguments(args)) {
+            return malformed(call, "memory.search", "memory.search requires { scope, query }", startAt);
+        }
+        const requester = sanitizePrincipal(call.envelope.principal);
+        const scope = resolveScope(args.scope, requester);
+        const limit = asNumber(args.limit) || 20;
+        try {
+            const allEvents = await this.store.read();
+            await this.index.rebuildFromEvents(allEvents);
+            const indexed = await this.index.query({
+                allowedScopes: scope === "all" ? undefined : [scope],
+                query: args.query,
+                limit: Math.max(limit * 4, 40)
+            });
+            const events = indexed.map((entry) => entry.event);
+            const tombstones = collectTombstones(allEvents);
+            const filteredEvents = events
+                .filter((event) => isRecallableMemoryEvent(event) && !tombstones.has(event.id))
+                .filter((event) => matchesQuery(event, args.query));
+            const selections = scope === "all"
+                ? filteredEvents.map((event) => ({
+                    event,
+                    decision: memoryPolicy({ request: requester, candidate: event, activeScope: requester }).decision
+                })).filter((entry) => entry.decision !== "deny")
+                    .sort((left, right) => Date.parse(right.event.createdAt) - Date.parse(left.event.createdAt))
+                : runRecall({
+                    actor: requester,
+                    scopeIds: [scope],
+                    events: filteredEvents,
+                    query: args.query,
+                    maxTokens: limit * 80
+                }).selected.map((entry) => ({ event: entry.event, decision: entry.decision }));
+            const selected = selections.slice(0, limit);
+            if (selected.length === 0) {
+                return {
+                    request_id: call.request_id,
+                    tool: "memory.search",
+                    decision: "deny",
+                    content: [],
+                    audit: makeAudit(call, events, startAt)
+                };
+            }
+            return {
+                request_id: call.request_id,
+                tool: "memory.search",
+                decision: decide(selected.map((entry) => entry.decision)),
+                content: selected.map((entry) => makeSearchResult(entry.decision, entry.event)),
+                audit: makeAudit(call, selected.map((entry) => entry.event), startAt)
+            };
+        }
+        catch (error) {
+            return unavailable(call, "memory.search", String(error instanceof Error ? error.message : error), startAt);
+        }
+    }
+    async locate(call) {
+        const startAt = Date.now();
+        if (hasInvalidV1Envelope(call.envelope.version)) {
+            return malformed(call, "memory.locate", "unsupported envelope", startAt);
+        }
+        const args = call.arguments;
+        if (!isLocateArguments(args)) {
+            return malformed(call, "memory.locate", "memory.locate requires { query }", startAt);
+        }
+        const requester = sanitizePrincipal(call.envelope.principal);
+        const limit = asNumber(args.limit) || 5;
+        try {
+            const allEvents = await this.store.read();
+            await this.index.rebuildFromEvents(allEvents);
+            const query = args.query;
+            const candidateEvents = (await this.index.query({
+                query,
+                limit: Math.max(limit * 8, 40)
+            })).map((entry) => entry.event)
+                .filter((event) => isRecallableMemoryEvent(event) && !collectTombstones(allEvents).has(event.id));
+            const tokens = query.toLowerCase()
+                .split(/\W+/u)
+                .filter((value) => value.length > 3);
+            const byHandle = new Map();
+            for (const event of candidateEvents) {
+                const decision = memoryPolicy({
+                    request: requester,
+                    candidate: event,
+                    activeScope: requester
+                }).decision;
+                if (decision === "deny" || decision === "unavailable" || decision === "malformed_request") {
+                    continue;
+                }
+                const score = tokens.filter((token) => eventText(event).toLowerCase().includes(token)).length;
+                const key = locateCandidateId(event);
+                const next = byHandle.get(key);
+                const handle = {
+                    decision,
+                    event,
+                    score,
+                    eventIds: [event.id],
+                    scope: event.scope
+                };
+                if (!next) {
+                    byHandle.set(key, handle);
+                    continue;
+                }
+                next.eventIds.push(event.id);
+                next.score = Math.max(next.score, score);
+            }
+            const selected = [...byHandle.values()]
+                .sort((left, right) => right.score - left.score || Date.parse(right.event.createdAt) - Date.parse(left.event.createdAt))
+                .slice(0, limit);
+            if (selected.length === 0) {
+                return { request_id: call.request_id, tool: "memory.locate", decision: "deny", content: [], audit: makeAudit(call, [], startAt) };
+            }
+            const locatedEvent = await this.store.append({
+                type: "memory.located",
+                principal: requester,
+                scope: resolveScope("current", requester),
+                visibility: "private",
+                source: this.source,
+                content: {
+                    kind: "text",
+                    text: `Located ${selected.length} memory candidate(s).`
+                },
+                tags: ["locate"],
+                entities: [requester.agentId, requester.scope],
+                sensitivity: "normal",
+                parentEventIds: selected.flatMap((entry) => entry.eventIds)
+            });
+            return {
+                request_id: call.request_id,
+                tool: "memory.locate",
+                decision: "locate_only",
+                content: selected.map((entry) => makeLocateResult(entry)),
+                audit: makeAudit(call, [locatedEvent, ...selected.map((entry) => entry.event)], startAt)
+            };
+        }
+        catch (error) {
+            return unavailable(call, "memory.locate", String(error instanceof Error ? error.message : error), startAt);
+        }
+    }
+    async register(call) {
+        const startAt = Date.now();
+        if (hasInvalidV1Envelope(call.envelope.version)) {
+            return malformed(call, "memory.register", "unsupported envelope", startAt);
+        }
+        const args = call.arguments;
+        if (!isRegisterArguments(args)) {
+            return malformed(call, "memory.register", "memory.register requires evidence and content fields", startAt);
+        }
+        const principal = args.principal
+            ? sanitizePrincipal(args.principal)
+            : sanitizePrincipal(call.envelope.principal);
+        try {
+            const event = await this.store.append({
+                type: "memory.registered",
+                principal,
+                scope: resolveScope(args.scope, principal),
+                visibility: args.visibility,
+                source: args.source_type,
+                content: args.content,
+                tags: ["registered", principal.scope, args.visibility],
+                entities: [principal.agentId, principal.scope],
+                sensitivity: args.sensitivity,
+                parentEventIds: args.evidence_event_ids,
+                confidence: args.confidence
+            });
+            return {
+                request_id: call.request_id,
+                tool: "memory.register",
+                decision: "allow_raw",
+                content: [{
+                        kind: "memory",
+                        text: "Registered memory with explicit evidence.",
+                        event_ids: [event.id],
+                        scope: event.scope,
+                        principal: event.principal,
+                        redactions: [],
+                        confidence: args.confidence
+                    }],
+                audit: makeAudit(call, [event], startAt)
+            };
+        }
+        catch (error) {
+            return unavailable(call, "memory.register", String(error instanceof Error ? error.message : error), startAt);
+        }
+    }
+    async summarize(call) {
+        const startAt = Date.now();
+        if (hasInvalidV1Envelope(call.envelope.version)) {
+            return malformed(call, "memory.summarize", "unsupported envelope", startAt);
+        }
+        const args = call.arguments;
+        if (!isSummarizeArguments(args)) {
+            return malformed(call, "memory.summarize", "memory.summarize requires { scope }", startAt);
+        }
+        const requester = sanitizePrincipal(call.envelope.principal);
+        const scope = resolveScope(args.scope, requester);
+        const horizon = Math.min(asNumber(args.horizon) || 12, 40);
+        try {
+            const events = await this.store.read({ scope });
+            const tombstones = collectTombstones(events);
+            const sourceIds = [];
+            const lines = events
+                .filter((event) => isRecallableMemoryEvent(event) && !tombstones.has(event.id))
+                .map((event) => ({
+                event,
+                decision: memoryPolicy({ request: requester, candidate: event, activeScope: requester }).decision
+            }))
+                .filter((entry) => entry.decision !== "deny")
+                .slice(0, horizon)
+                .map((entry) => {
+                sourceIds.push(entry.event.id);
+                return `${entry.event.createdAt}: ${policyText(entry.decision, eventText(entry.event))}`;
+            });
+            if (sourceIds.length === 0) {
+                return { request_id: call.request_id, tool: "memory.summarize", decision: "deny", content: [], audit: makeAudit(call, [], startAt) };
+            }
+            const summary = await this.store.append({
+                type: "memory.summarized",
+                principal: requester,
+                scope,
+                visibility: "private",
+                source: this.source,
+                content: { kind: "text", text: lines.join("\n") },
+                tags: ["summary", ...sourceIds],
+                entities: [requester.agentId, requester.scope],
+                sensitivity: "normal",
+                confidence: 1,
+                parentEventIds: sourceIds
+            });
+            return {
+                request_id: call.request_id,
+                tool: "memory.summarize",
+                decision: "allow_summary",
+                content: [{
+                        kind: "narrative",
+                        text: lines.join("\n"),
+                        event_ids: sourceIds,
+                        scope,
+                        principal: requester,
+                        redactions: [],
+                        confidence: 1
+                    }],
+                audit: makeAudit(call, [summary], startAt)
+            };
+        }
+        catch (error) {
+            return unavailable(call, "memory.summarize", String(error instanceof Error ? error.message : error), startAt);
+        }
+    }
+    async forget(call) {
+        const startAt = Date.now();
+        if (hasInvalidV1Envelope(call.envelope.version)) {
+            return malformed(call, "memory.forget", "unsupported envelope", startAt);
+        }
+        const args = call.arguments;
+        if (!isForgetArguments(args)) {
+            return malformed(call, "memory.forget", "memory.forget requires { scope, event_ids }", startAt);
+        }
+        const requester = sanitizePrincipal(call.envelope.principal);
+        try {
+            const event = await this.store.append({
+                type: "memory.forgotten",
+                principal: requester,
+                scope: resolveScope(args.scope, requester),
+                visibility: "private",
+                source: this.source,
+                content: {
+                    kind: "text",
+                    text: `Tombstone for ${args.event_ids.length} event(s).`
+                },
+                tags: ["forget", "tombstone"],
+                entities: [requester.agentId, requester.scope],
+                sensitivity: "secret",
+                confidence: 1,
+                parentEventIds: args.event_ids
+            });
+            return {
+                request_id: call.request_id,
+                tool: "memory.forget",
+                decision: "allow_raw",
+                content: [{
+                        kind: "memory",
+                        text: `Tombstone written for ${args.event_ids.length} event(s).`,
+                        event_ids: [event.id],
+                        scope: event.scope,
+                        principal: event.principal,
+                        redactions: ["content-redacted"],
+                        confidence: 1
+                    }],
+                audit: makeAudit(call, [event], startAt)
+            };
+        }
+        catch (error) {
+            return unavailable(call, "memory.forget", String(error instanceof Error ? error.message : error), startAt);
+        }
+    }
+}
+export const createMemoryKernel = (config) => new JsonlMemoryKernel(config);

package/dist/kernel/support.d.ts

@@ -0,0 +1,66 @@
+import type { MemoryDecision, MemoryEvent, MemoryEventType, MemoryContent, MemoryForgetArguments, MemoryLocateArguments, MemoryRegisterArguments, MemorySearchArguments, MemorySummarizeArguments, MemoryToolCall, MemoryToolAudit, MemoryToolCallEnvelope, MemoryToolDecision, MemoryToolName, MemoryToolResult, MemoryToolResultContent, MemoryVisibility, MemorySensitivity } from "../contract/types.js";
+export interface CandidateHandle {
+    decision: MemoryDecision;
+    event: MemoryEvent;
+    score: number;
+    eventIds: string[];
+    scope: string;
+}
+export type MemoryResultItem = Omit<MemoryToolResultContent, "event_ids" | "redactions"> & {
+    event_ids: string[];
+    redactions: string[];
+};
+export declare const isPlainObject: (value: unknown) => value is Record<string, unknown>;
+export declare const asNumber: (value: unknown) => number;
+export declare const isVisibility: (value: unknown) => value is MemoryVisibility;
+export declare const isSensitivity: (value: unknown) => value is MemorySensitivity;
+export declare const isSearchArguments: (value: Record<string, unknown>) => value is Omit<MemorySearchArguments, "scope" | "query"> & {
+    scope: string;
+    query: string;
+};
+export declare const isLocateArguments: (value: Record<string, unknown>) => value is Omit<MemoryLocateArguments, "query"> & {
+    query: string;
+};
+export declare const isSummarizeArguments: (value: Record<string, unknown>) => value is Omit<MemorySummarizeArguments, "scope"> & {
+    scope: string;
+};
+export declare const isMemoryContent: (value: unknown) => value is MemoryContent;
+export declare const isRegisterArguments: (value: unknown) => value is MemoryRegisterArguments;
+export declare const isForgetArguments: (value: unknown) => value is MemoryForgetArguments;
+export declare const makeAudit: (call: MemoryToolCall, sources: MemoryEvent[], startAt: number) => MemoryToolAudit;
+export declare const malformed: (call: MemoryToolCall, tool: MemoryToolName, error: string, startAt: number) => MemoryToolResult;
+export declare const unavailable: (call: MemoryToolCall, tool: MemoryToolName, error: string, startAt: number) => MemoryToolResult;
+export declare const eventText: (event: MemoryEvent) => string;
+export declare const resultKind: (kind: MemoryEventType | MemoryEvent["content"]["kind"]) => MemoryToolResultContent["kind"];
+export declare const policyText: (decision: MemoryDecision, text: string) => string;
+export declare const decide: (decisions: MemoryDecision[]) => MemoryToolDecision;
+export declare const resolveScope: (scopeInput: string, requester: MemoryToolCallEnvelope["principal"]) => string;
+export declare const sanitizePrincipal: (principal: MemoryToolCallEnvelope["principal"]) => {
+    qualifier: string | undefined;
+    agentId: string;
+    scope: "global" | "team" | "room" | "pair" | "task" | "role" | "artifact";
+};
+export declare const collectTombstones: (events: MemoryEvent[]) => Set<string>;
+export declare const isRecallableMemoryEvent: (event: MemoryEvent) => boolean;
+export declare const matchesQuery: (event: MemoryEvent, query: string) => boolean;
+export declare const canExposeEventId: (decision: MemoryDecision) => boolean;
+export declare const locateCandidateId: (event: MemoryEvent) => string;
+export declare const hasInvalidV1Envelope: (version: string) => boolean;
+export declare const makeSearchResult: (decision: MemoryDecision, event: MemoryEvent) => {
+    kind: "artifact" | "memory" | "claim" | "narrative" | "relationship" | "locate";
+    text: string;
+    event_ids: string[];
+    scope: string;
+    principal: import("../contract/types.js").MemoryPrincipalRef;
+    confidence: number;
+    redactions: string[];
+};
+export declare const makeLocateResult: (entry: CandidateHandle) => {
+    kind: "locate";
+    event_ids: string[];
+    scope: string;
+    principal: import("../contract/types.js").MemoryPrincipalRef;
+    confidence: number;
+    redactions: string[];
+};
+//# sourceMappingURL=support.d.ts.map

package/dist/kernel/support.d.ts.map

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