@knolo/core 3.2.1 → 3.2.4

package/README.md

@@ -309,6 +309,74 @@ Properties:
 
 ---
 
+# 🧠 Knolo Cortex
+
+Knolo Cortex is a local-first overlay memory layer for `.knolo` packs.
+
+It gives you:
+
+* Deterministic append-only memory writes
+* Lexical-first recall with label and namespace filters
+* Portable memory logs you can serialize and replay
+* Consolidation back into pack docs without mutating the pack itself
+* Deterministic graph export via `memoryToClaimOps()`
+
+## Example
+
+```ts
+import {
+  buildPack,
+  consolidateMemories,
+  createCortex,
+  mountPack,
+  recall,
+  remember,
+} from "@knolo/core";
+
+const cortex = createCortex({ actor: "notes-app" });
+const { cortex: next, memory } = remember(cortex, {
+  kind: "note",
+  text: "Project alpha uses a local-first memory overlay.",
+  labels: ["project.alpha"],
+  namespace: "project.alpha",
+});
+
+const hits = recall(next, "project alpha");
+const docs = consolidateMemories(next, { namespacePrefix: "memory" });
+const bytes = await buildPack(docs);
+const pack = await mountPack({ src: bytes });
+```
+
+If you need to load a local file in Node, use `@knolo/core/node` or read the bytes first and pass a `Uint8Array` into `mountPack()`.
+
+## Cortex API
+
+```ts
+import {
+  createCortex,
+  remember,
+  forget,
+  labelMemory,
+  linkMemories,
+  recall,
+  consolidateMemories,
+  memoryToClaimOps,
+} from "@knolo/core";
+```
+
+* `createCortex({ actor?, now?, log? })` creates an immutable memory runtime
+* `remember()` appends a new memory entry
+* `forget()` tombstones a memory
+* `labelMemory()` adds labels without mutating the original cortex
+* `linkMemories()` records deterministic memory relationships
+* `recall()` ranks memories with lexical-first scoring
+* `consolidateMemories()` converts selected memories back into `BuildInputDoc[]`
+* `memoryToClaimOps()` emits deterministic ClaimGraph ops for memory nodes, labels, and links
+
+The full example lives in [`examples/memory-overlay/README.md`](../../examples/memory-overlay/README.md).
+
+---
+
 # 🗺 Roadmap
 
 * Incremental pack updates
@@ -388,4 +456,3 @@ Runtimes that ignore unknown trailing bytes remain compatible.
 # 📄 License
 
 Apache-2.0
-

package/dist/index.d.ts

@@ -3,13 +3,19 @@ export { query, lexConfidence, validateQueryOptions, validateSemanticQueryOption
 export { makeContextPatch } from './patch.js';
 export { buildPack } from './builder.js';
 export { quantizeEmbeddingInt8L2Norm, encodeScaleF16, decodeScaleF16, } from './semantic.js';
+export { cosineSimilarity, normalizeVector } from './semantic/cosine.js';
+export { createPackFingerprint, serializeSidecar, parseSidecar, validateSidecarForPack, } from './semantic/sidecar.js';
+export { rerankCandidates } from './semantic/rerank.js';
+export { assertProviderCompatible, ensureProviderModelId } from './semantic/provider.js';
 export { listAgents, getAgent, resolveAgent, buildSystemPrompt, isToolAllowed, assertToolAllowed, validateAgentRegistry, validateAgentDefinition, } from './agent.js';
 export { getClaimGraph, validateClaimGraph, } from './graph/claim_graph.js';
 export { buildClaimGraph } from './graph/build_claim_graph.js';
 export { createGraphLog, appendOp, applyClaimGraphLog, mergeClaimGraphLogs, serializeClaimGraphLog, deserializeClaimGraphLog, } from './graph/log.js';
 export { expandQueryWithGraph } from './graph/query_expand.js';
+export * from './memory/index.js';
 export type { MountOptions, PackMeta, Pack } from './pack.runtime.js';
 export type { QueryOptions, Hit } from './query.js';
+export type { EmbeddingProvider, SemanticSidecar, SemanticQueryOptions, RetrievalEvidence } from './semantic/types.js';
 export type { ContextPatch } from './patch.js';
 export type { BuildInputDoc, BuildPackOptions } from './builder.js';
 export type { AgentPromptTemplate, AgentToolPolicy, AgentRetrievalDefaults, AgentDefinitionV1, AgentRegistry, ResolveAgentInput, ResolvedAgent, } from './agent.js';

package/dist/index.js

@@ -4,11 +4,16 @@ export { query, lexConfidence, validateQueryOptions, validateSemanticQueryOption
 export { makeContextPatch } from './patch.js';
 export { buildPack } from './builder.js';
 export { quantizeEmbeddingInt8L2Norm, encodeScaleF16, decodeScaleF16, } from './semantic.js';
+export { cosineSimilarity, normalizeVector } from './semantic/cosine.js';
+export { createPackFingerprint, serializeSidecar, parseSidecar, validateSidecarForPack, } from './semantic/sidecar.js';
+export { rerankCandidates } from './semantic/rerank.js';
+export { assertProviderCompatible, ensureProviderModelId } from './semantic/provider.js';
 export { listAgents, getAgent, resolveAgent, buildSystemPrompt, isToolAllowed, assertToolAllowed, validateAgentRegistry, validateAgentDefinition, } from './agent.js';
 export { getClaimGraph, validateClaimGraph, } from './graph/claim_graph.js';
 export { buildClaimGraph } from './graph/build_claim_graph.js';
 export { createGraphLog, appendOp, applyClaimGraphLog, mergeClaimGraphLogs, serializeClaimGraphLog, deserializeClaimGraphLog, } from './graph/log.js';
 export { expandQueryWithGraph } from './graph/query_expand.js';
+export * from './memory/index.js';
 export { parseToolCallV1FromText } from './tool_parse.js';
 export { nowIso, createTrace } from './trace.js';
 export { assertToolCallAllowed } from './tool_gate.js';

package/dist/indexer.d.ts

@@ -13,11 +13,12 @@ export type IndexBuildResult = {
  * sequences of blockId and positions for that term, with zeros as delimiters.
  * The structure looks like:
  *
- *     [termId, blockId+1, pos, pos, 0, blockId+1, pos, 0, 0, termId, ...]
+ *     [termId, blockId+1, pos+1, pos+1, 0, blockId+1, pos+1, 0, 0, termId, ...]
  *
  * Block IDs are stored as bid+1 so that 0 can remain a sentinel delimiter.
- * Each block section ends with a 0, and each term section ends with a 0. The
- * entire array can be streamed sequentially without needing to know the sizes
- * of individual lists ahead of time.
+ * Positions are also stored as pos+1 for the same reason. Each block section
+ * ends with a 0, and each term section ends with a 0. The entire array can be
+ * streamed sequentially without needing to know the sizes of individual lists
+ * ahead of time.
  */
 export declare function buildIndex(blocks: Block[]): IndexBuildResult;

package/dist/indexer.js

@@ -14,12 +14,13 @@ import { tokenize } from "./tokenize.js";
  * sequences of blockId and positions for that term, with zeros as delimiters.
  * The structure looks like:
  *
- *     [termId, blockId+1, pos, pos, 0, blockId+1, pos, 0, 0, termId, ...]
+ *     [termId, blockId+1, pos+1, pos+1, 0, blockId+1, pos+1, 0, 0, termId, ...]
  *
  * Block IDs are stored as bid+1 so that 0 can remain a sentinel delimiter.
- * Each block section ends with a 0, and each term section ends with a 0. The
- * entire array can be streamed sequentially without needing to know the sizes
- * of individual lists ahead of time.
+ * Positions are also stored as pos+1 for the same reason. Each block section
+ * ends with a 0, and each term section ends with a 0. The entire array can be
+ * streamed sequentially without needing to know the sizes of individual lists
+ * ahead of time.
  */
 export function buildIndex(blocks) {
     // Map term to termId and interim map of termId -> blockId -> positions
@@ -61,7 +62,7 @@ export function buildIndex(blocks) {
     for (const [tid, blockMap] of termBlockPositions) {
         postings.push(tid);
         for (const [bid, positions] of blockMap) {
-            postings.push(bid + 1, ...positions, 0);
+            postings.push(bid + 1, ...positions.map((pos) => pos + 1), 0);
         }
         postings.push(0); // end of term
     }

package/dist/memory/consolidate.d.ts

@@ -0,0 +1,15 @@
+import type { BuildInputDoc } from '../builder.js';
+import type { CortexV1 } from './cortex.js';
+import type { MemoryEngramV1 } from './engram.js';
+export type ConsolidateMemoriesOptionsV1 = {
+    namespacePrefix?: string;
+    kind?: string | readonly string[];
+    labels?: string | readonly string[];
+    namespace?: string | readonly string[];
+    minImportance?: number;
+    minConfidence?: number;
+    minAgeMs?: number;
+    maxAgeMs?: number;
+    now?: number;
+};
+export declare function consolidateMemories(cortexOrMemories: CortexV1 | readonly MemoryEngramV1[], opts?: ConsolidateMemoriesOptionsV1): BuildInputDoc[];

package/dist/memory/consolidate.js

@@ -0,0 +1,71 @@
+import { matchesMemoryLabels, validateMemoryLabels } from './label.js';
+import { normalizeMemoryLabel } from './label.js';
+import { normalize } from '../tokenize.js';
+export function consolidateMemories(cortexOrMemories, opts = {}) {
+    const memories = isCortex(cortexOrMemories)
+        ? cortexOrMemories.memories
+        : cortexOrMemories;
+    const now = opts.now ?? (isCortex(cortexOrMemories) ? cortexOrMemories.now() : Date.now());
+    const namespacePrefix = normalizeNamespacePrefix(opts.namespacePrefix);
+    const kindFilters = normalizeKindFilters(opts.kind);
+    const labelsFilter = validateMemoryLabels(opts.labels);
+    const namespaceFilters = normalizeNamespaceFilters(opts.namespace);
+    return memories
+        .filter((memory) => {
+        if (kindFilters.length > 0 && !kindFilters.includes(normalizeKind(memory.kind)))
+            return false;
+        if (labelsFilter.length > 0 && !matchesMemoryLabels(memory.labels, labelsFilter))
+            return false;
+        if (namespaceFilters.length > 0 && !matchesNamespace(memory.namespace, namespaceFilters))
+            return false;
+        if (opts.minImportance !== undefined && valueOrDefault(memory.importance, 0.5) < opts.minImportance)
+            return false;
+        if (opts.minConfidence !== undefined && valueOrDefault(memory.confidence, 0.5) < opts.minConfidence)
+            return false;
+        const ageMs = now - memory.ts;
+        if (opts.minAgeMs !== undefined && ageMs < opts.minAgeMs)
+            return false;
+        if (opts.maxAgeMs !== undefined && ageMs > opts.maxAgeMs)
+            return false;
+        return true;
+    })
+        .slice()
+        .sort((a, b) => a.ts - b.ts || a.id.localeCompare(b.id))
+        .map((memory) => ({
+        id: memory.id,
+        heading: `${memory.kind}: ${memory.labels.join('/')}`,
+        namespace: `${namespacePrefix}.${memory.kind}`,
+        text: memory.text,
+    }));
+}
+function isCortex(input) {
+    return !Array.isArray(input) && typeof input === 'object' && input !== null && 'memories' in input;
+}
+function normalizeNamespacePrefix(value) {
+    const normalized = normalizeMemoryLabel(value ?? 'memory');
+    return normalized || 'memory';
+}
+function normalizeKindFilters(kind) {
+    if (kind === undefined)
+        return [];
+    const values = Array.isArray(kind) ? kind : [kind];
+    return [...new Set(values.map(normalizeKind).filter(Boolean))].sort((a, b) => a.localeCompare(b));
+}
+function normalizeNamespaceFilters(value) {
+    if (value === undefined)
+        return [];
+    const values = Array.isArray(value) ? value : [value];
+    return [...new Set(values.map((entry) => normalizeMemoryLabel(entry)).filter(Boolean))].sort((a, b) => a.localeCompare(b));
+}
+function normalizeKind(kind) {
+    return normalize(kind).replace(/\s+/g, ' ').trim();
+}
+function matchesNamespace(value, filters) {
+    if (!value)
+        return false;
+    const normalized = normalizeMemoryLabel(value);
+    return filters.some((filter) => normalized === filter || normalized.startsWith(`${filter}.`));
+}
+function valueOrDefault(value, fallback) {
+    return Number.isFinite(value) ? value : fallback;
+}

package/dist/memory/cortex.d.ts

@@ -0,0 +1,43 @@
+import type { MemoryEngramV1, MemoryInputV1, MemoryLinkV1 } from './engram.js';
+import { type MemoryLogV1, type MemoryOpV1 } from './log.js';
+export type CortexV1 = {
+    version: 1;
+    actor: string;
+    now: () => number;
+    log: MemoryLogV1;
+    memories: MemoryEngramV1[];
+};
+export type CortexWriteResult<T extends object> = T & {
+    cortex: CortexV1;
+};
+export declare function createCortex(opts?: {
+    actor?: string;
+    now?: () => number;
+    log?: MemoryLogV1;
+}): CortexV1;
+export declare function remember(cortex: CortexV1, input: MemoryInputV1): CortexWriteResult<{
+    memory: MemoryEngramV1;
+    op: MemoryOpV1;
+}>;
+export declare function forget(cortex: CortexV1, id: string, provenance?: {
+    ts?: number;
+    actor?: string;
+}): CortexWriteResult<{
+    memoryId: string;
+    op: MemoryOpV1;
+}>;
+export declare function labelMemory(cortex: CortexV1, id: string, labels: string | readonly string[], provenance?: {
+    ts?: number;
+    actor?: string;
+}): CortexWriteResult<{
+    memory?: MemoryEngramV1;
+    op: MemoryOpV1;
+}>;
+export declare function linkMemories(cortex: CortexV1, from: string, to: string, relation: string, provenance?: {
+    ts?: number;
+    actor?: string;
+    confidence?: number;
+}): CortexWriteResult<{
+    link: MemoryLinkV1;
+    op: MemoryOpV1;
+}>;

package/dist/memory/cortex.js

@@ -0,0 +1,93 @@
+import { createMemoryId, normalizeMemoryActor, normalizeMemoryInput, normalizeMemoryKind, normalizeMemoryTimestamp, } from './engram.js';
+import { appendMemoryOp, applyMemoryLog, createMemoryLog, } from './log.js';
+import { validateMemoryLabels } from './label.js';
+export function createCortex(opts = {}) {
+    const log = opts.log ? { version: 1, ops: [...opts.log.ops] } : createMemoryLog();
+    return {
+        version: 1,
+        actor: normalizeMemoryActor(opts.actor ?? 'cortex'),
+        now: opts.now ?? (() => Date.now()),
+        log,
+        memories: applyMemoryLog(log),
+    };
+}
+export function remember(cortex, input) {
+    const memory = normalizeMemoryInput(input, {
+        actor: cortex.actor,
+        ts: cortex.now(),
+    });
+    const op = {
+        op: 'remember',
+        ts: memory.ts,
+        actor: memory.actor,
+        memory,
+    };
+    return applyWrite(cortex, op, { memory });
+}
+export function forget(cortex, id, provenance = {}) {
+    const op = {
+        op: 'forget',
+        id,
+        ts: normalizeMemoryTimestamp(provenance.ts ?? cortex.now()),
+        actor: normalizeMemoryActor(provenance.actor ?? cortex.actor),
+    };
+    return applyWrite(cortex, op, { memoryId: id });
+}
+export function labelMemory(cortex, id, labels, provenance = {}) {
+    const normalizedLabels = validateMemoryLabels(labels);
+    const op = {
+        op: 'label',
+        id,
+        labels: normalizedLabels,
+        ts: normalizeMemoryTimestamp(provenance.ts ?? cortex.now()),
+        actor: normalizeMemoryActor(provenance.actor ?? cortex.actor),
+    };
+    return applyWrite(cortex, op, {
+        memory: cortex.memories.find((memory) => memory.id === id),
+    });
+}
+export function linkMemories(cortex, from, to, relation, provenance = {}) {
+    const normalizedRelation = normalizeMemoryKind(relation);
+    const ts = normalizeMemoryTimestamp(provenance.ts ?? cortex.now());
+    const actor = normalizeMemoryActor(provenance.actor ?? cortex.actor);
+    const link = {
+        version: 1,
+        id: createMemoryId({
+            kind: 'link',
+            text: [from, normalizedRelation, to, provenance.confidence ?? ''].join('\u0001'),
+            ts,
+            actor,
+        }),
+        from,
+        to,
+        relation: normalizedRelation,
+        ts,
+        actor,
+        confidence: provenance.confidence,
+    };
+    const op = {
+        op: 'link',
+        from,
+        to,
+        relation: normalizedRelation,
+        confidence: provenance.confidence,
+        ts,
+        actor,
+    };
+    return applyWrite(cortex, op, { link });
+}
+function applyWrite(cortex, op, extra) {
+    const log = appendMemoryOp(cortex.log, op);
+    const memories = applyMemoryLog(log);
+    return {
+        ...extra,
+        op,
+        cortex: {
+            version: 1,
+            actor: cortex.actor,
+            now: cortex.now,
+            log,
+            memories,
+        },
+    };
+}

package/dist/memory/engram.d.ts

@@ -0,0 +1,48 @@
+export type MemoryKind = string;
+export type MemoryLinkV1 = {
+    version: 1;
+    id: string;
+    from: string;
+    to: string;
+    relation: string;
+    ts: number;
+    actor: string;
+    confidence?: number;
+};
+export type MemoryEngramV1 = {
+    version: 1;
+    id: string;
+    kind: MemoryKind;
+    text: string;
+    labels: string[];
+    namespace?: string;
+    source?: string;
+    importance?: number;
+    confidence?: number;
+    ts: number;
+    actor: string;
+    links: MemoryLinkV1[];
+};
+export type MemoryInputV1 = {
+    kind: MemoryKind;
+    text: string;
+    labels?: string | readonly string[];
+    namespace?: string;
+    source?: string;
+    importance?: number;
+    confidence?: number;
+    ts?: number;
+    actor?: string;
+};
+export type MemoryProvenanceV1 = {
+    ts?: number;
+    actor?: string;
+};
+export declare function createMemoryId(input: Pick<MemoryEngramV1, 'kind' | 'text' | 'ts' | 'actor'>): string;
+export declare function normalizeMemoryInput(input: MemoryInputV1, provenance?: MemoryProvenanceV1): MemoryEngramV1;
+export declare function normalizeMemoryKind(kind: string): string;
+export declare function normalizeMemoryText(text: string): string;
+export declare function normalizeMemoryNamespace(namespace?: string): string | undefined;
+export declare function normalizeMemorySource(source?: string): string | undefined;
+export declare function normalizeMemoryActor(actor: string): string;
+export declare function normalizeMemoryTimestamp(ts: number): number;

package/dist/memory/engram.js

@@ -0,0 +1,90 @@
+import { normalize } from '../tokenize.js';
+import { normalizeMemoryLabel, validateMemoryLabels } from './label.js';
+export function createMemoryId(input) {
+    const payload = [
+        normalizeMemoryKind(input.kind),
+        normalizeMemoryTextForId(input.text),
+        normalizeMemoryTimestamp(input.ts),
+        normalizeMemoryActor(input.actor),
+    ].join('\u0001');
+    return `mem_${hash64Hex(payload)}`;
+}
+export function normalizeMemoryInput(input, provenance = {}) {
+    const kind = normalizeMemoryKind(input.kind);
+    if (!kind) {
+        throw new Error('Memory kind must be a non-empty string.');
+    }
+    const text = normalizeMemoryText(input.text);
+    if (!text) {
+        throw new Error('Memory text must be a non-empty string.');
+    }
+    const ts = normalizeMemoryTimestamp(input.ts ?? provenance.ts ?? 0);
+    const actor = normalizeMemoryActor(input.actor ?? provenance.actor ?? 'cortex');
+    const labels = validateMemoryLabels(input.labels);
+    const namespace = normalizeMemoryNamespace(input.namespace);
+    const source = normalizeMemorySource(input.source);
+    const importance = normalizeMemoryRatio(input.importance, 'importance');
+    const confidence = normalizeMemoryRatio(input.confidence, 'confidence');
+    return {
+        version: 1,
+        id: createMemoryId({ kind, text, ts, actor }),
+        kind,
+        text,
+        labels,
+        namespace,
+        source,
+        importance,
+        confidence,
+        ts,
+        actor,
+        links: [],
+    };
+}
+export function normalizeMemoryKind(kind) {
+    return normalize(String(kind ?? '')).replace(/\s+/g, ' ').trim();
+}
+export function normalizeMemoryText(text) {
+    return String(text ?? '').trim();
+}
+export function normalizeMemoryNamespace(namespace) {
+    const normalized = normalizeMemoryLabel(namespace ?? '');
+    return normalized || undefined;
+}
+export function normalizeMemorySource(source) {
+    const normalized = normalize(String(source ?? '')).replace(/\s+/g, ' ').trim();
+    return normalized || undefined;
+}
+export function normalizeMemoryActor(actor) {
+    return String(actor ?? '').replace(/\s+/g, ' ').trim();
+}
+export function normalizeMemoryTimestamp(ts) {
+    const value = Number(ts);
+    if (!Number.isFinite(value)) {
+        throw new Error('Memory timestamp must be a finite number.');
+    }
+    return value;
+}
+function normalizeMemoryRatio(value, name) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (!Number.isFinite(value)) {
+        throw new Error(`Memory ${name} must be a finite number.`);
+    }
+    if (value < 0)
+        return 0;
+    if (value > 1)
+        return 1;
+    return value;
+}
+function normalizeMemoryTextForId(text) {
+    return normalize(String(text ?? '')).replace(/\s+/g, ' ').trim();
+}
+function hash64Hex(input) {
+    let hash = 0xcbf29ce484222325n;
+    const prime = 0x100000001b3n;
+    for (const char of input) {
+        hash ^= BigInt(char.codePointAt(0) ?? 0);
+        hash = (hash * prime) & 0xffffffffffffffffn;
+    }
+    return hash.toString(16).padStart(16, '0');
+}

package/dist/memory/graph_adapter.d.ts

@@ -0,0 +1,3 @@
+import type { ClaimOp } from '../graph/log.js';
+import type { MemoryEngramV1 } from './engram.js';
+export declare function memoryToClaimOps(memory: MemoryEngramV1): ClaimOp[];

package/dist/memory/graph_adapter.js

@@ -0,0 +1,65 @@
+import { computeEdgeId, computeNodeId, normalizeClaimLabel } from '../graph/claim_graph.js';
+import { validateMemoryLabels } from './label.js';
+export function memoryToClaimOps(memory) {
+    const nodeOps = new Map();
+    const edgeOps = new Map();
+    const memoryLabel = memoryNodeLabel(memory.id);
+    upsertNode(nodeOps, memoryLabel, memory.ts, memory.actor);
+    for (const label of validateMemoryLabels(memory.labels)) {
+        const entityLabel = normalizeClaimLabel(label);
+        if (!entityLabel)
+            continue;
+        upsertNode(nodeOps, entityLabel, memory.ts, memory.actor);
+        upsertEdge(edgeOps, memoryLabel, 'mentions', entityLabel, memory.ts, memory.actor);
+    }
+    for (const link of sortedLinks(memory.links)) {
+        const relation = normalizeClaimLabel(link.relation);
+        if (!relation)
+            continue;
+        const targetLabel = memoryNodeLabel(link.to);
+        upsertNode(nodeOps, targetLabel, link.ts, link.actor);
+        upsertEdge(edgeOps, memoryLabel, relation, targetLabel, link.ts, link.actor);
+    }
+    return [...nodeOps.values(), ...edgeOps.values()];
+}
+function memoryNodeLabel(id) {
+    return normalizeClaimLabel(`memory ${id}`);
+}
+function upsertNode(nodeOps, label, ts, actor) {
+    if (!label)
+        return;
+    const id = computeNodeId(label);
+    if (nodeOps.has(id))
+        return;
+    nodeOps.set(id, {
+        op: 'upsert_node',
+        id,
+        label,
+        ts,
+        actor,
+    });
+}
+function upsertEdge(edgeOps, fromLabel, relation, toLabel, ts, actor) {
+    if (!fromLabel || !relation || !toLabel)
+        return;
+    const from = computeNodeId(fromLabel);
+    const to = computeNodeId(toLabel);
+    const id = computeEdgeId(from, relation, to);
+    if (edgeOps.has(id))
+        return;
+    edgeOps.set(id, {
+        op: 'add_edge',
+        from,
+        p: relation,
+        to,
+        ts,
+        actor,
+    });
+}
+function sortedLinks(memoryLinks) {
+    return [...memoryLinks].sort((a, b) => a.ts - b.ts ||
+        a.actor.localeCompare(b.actor) ||
+        a.relation.localeCompare(b.relation) ||
+        a.to.localeCompare(b.to) ||
+        a.id.localeCompare(b.id));
+}

package/dist/memory/index.d.ts

@@ -0,0 +1,13 @@
+export { normalizeMemoryLabel, validateMemoryLabels, matchesMemoryLabels, normalizeMemoryLabelTokens, } from './label.js';
+export type { MemoryKind, MemoryLinkV1, MemoryLinkV1 as MemoryLink, MemoryEngramV1, MemoryEngramV1 as MemoryEngram, MemoryInputV1, MemoryInputV1 as MemoryInput, MemoryProvenanceV1, MemoryProvenanceV1 as MemoryProvenance, } from './engram.js';
+export { createMemoryId, normalizeMemoryInput, normalizeMemoryKind, normalizeMemoryText, normalizeMemoryNamespace, normalizeMemorySource, normalizeMemoryActor, normalizeMemoryTimestamp, } from './engram.js';
+export type { MemoryLogV1, MemoryOpV1 } from './log.js';
+export type { MemoryLogV1 as MemoryLog, MemoryOpV1 as MemoryOp, } from './log.js';
+export { createMemoryLog, appendMemoryOp, mergeMemoryLogs, serializeMemoryLog, deserializeMemoryLog, applyMemoryLog, } from './log.js';
+export type { CortexV1, CortexV1 as Cortex, CortexWriteResult, } from './cortex.js';
+export { createCortex, remember, forget, labelMemory, linkMemories } from './cortex.js';
+export type { RecallOptionsV1, RecallOptionsV1 as RecallOptions, MemoryRecallHitV1, MemoryRecallHitV1 as MemoryRecallHit, } from './recall.js';
+export { recall } from './recall.js';
+export type { ConsolidateMemoriesOptionsV1, ConsolidateMemoriesOptionsV1 as ConsolidateMemoriesOptions, } from './consolidate.js';
+export { consolidateMemories } from './consolidate.js';
+export { memoryToClaimOps } from './graph_adapter.js';

package/dist/memory/index.js

@@ -0,0 +1,7 @@
+export { normalizeMemoryLabel, validateMemoryLabels, matchesMemoryLabels, normalizeMemoryLabelTokens, } from './label.js';
+export { createMemoryId, normalizeMemoryInput, normalizeMemoryKind, normalizeMemoryText, normalizeMemoryNamespace, normalizeMemorySource, normalizeMemoryActor, normalizeMemoryTimestamp, } from './engram.js';
+export { createMemoryLog, appendMemoryOp, mergeMemoryLogs, serializeMemoryLog, deserializeMemoryLog, applyMemoryLog, } from './log.js';
+export { createCortex, remember, forget, labelMemory, linkMemories } from './cortex.js';
+export { recall } from './recall.js';
+export { consolidateMemories } from './consolidate.js';
+export { memoryToClaimOps } from './graph_adapter.js';

package/dist/memory/label.d.ts

@@ -0,0 +1,4 @@
+export declare function normalizeMemoryLabel(label: string): string;
+export declare function validateMemoryLabels(labels?: string | readonly string[] | null): string[];
+export declare function matchesMemoryLabels(memoryLabels?: string[] | string | null, requestedLabels?: string | readonly string[] | null): boolean;
+export declare function normalizeMemoryLabelTokens(label: string): string[];