@utaba/deep-memory 0.1.0

package/dist/providers/index.cjs

@@ -0,0 +1,19 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/providers/index.ts
+var providers_exports = {};
+module.exports = __toCommonJS(providers_exports);
+//# sourceMappingURL=index.cjs.map

package/dist/providers/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/providers/index.ts"],"sourcesContent":["// Provider interface re-exports — @utaba/deep-memory/providers\n\nexport type { StorageProvider } from './StorageProvider.js';\nexport type { EmbeddingProvider } from './EmbeddingProvider.js';\nexport type {\n  SearchProvider,\n  SearchableEntity,\n} from './SearchProvider.js';\nexport type {\n  LockProvider,\n  LockOptions,\n  LockHandle,\n} from './LockProvider.js';\n"],"mappings":";;;;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

package/dist/providers/index.d.cts

@@ -0,0 +1,75 @@
+export { S as StorageProvider } from '../StorageProvider-CkFjdboX.cjs';
+import { a5 as SearchOptions, P as PaginatedResult, a6 as SearchHit } from '../portability-DdlNYXGX.cjs';
+
+/**
+ * EmbeddingProvider — enables semantic search and vocabulary deduplication.
+ *
+ * Optional. When not provided:
+ * - `searchByConcept` throws EmbeddingProviderRequiredError
+ * - Vocabulary deduplication falls back to string similarity (Jaro-Winkler)
+ * - Entity creation skips embedding generation
+ */
+interface EmbeddingProvider {
+    /** Generate a single embedding vector */
+    embed(text: string): Promise<number[]>;
+    /** Generate embeddings in batch (more efficient for bulk operations) */
+    embedBatch(texts: string[]): Promise<number[][]>;
+    /** The dimensionality of the embedding vectors (e.g., 1536, 768) */
+    dimensions(): number;
+    /** Identifier for the model used — stored with embeddings for compatibility tracking */
+    modelId(): string;
+    /**
+     * Compute cosine similarity between two vectors.
+     * Default implementation provided by the library — override for optimised hardware paths.
+     */
+    similarity?(a: number[], b: number[]): number;
+}
+
+/** Entity data indexed for full-text search */
+interface SearchableEntity {
+    entityId: string;
+    entityType: string;
+    label: string;
+    summary?: string;
+    properties?: Record<string, unknown>;
+    data?: string;
+}
+/**
+ * SearchProvider — enhances entity finding with full-text search.
+ *
+ * Optional. When not provided, `findEntities` falls back to the
+ * StorageProvider's basic label/property matching.
+ */
+interface SearchProvider {
+    /** Index an entity for full-text search */
+    indexEntity(repositoryId: string, entity: SearchableEntity): Promise<void>;
+    /** Remove an entity from the search index */
+    removeEntity(repositoryId: string, entityId: string): Promise<void>;
+    /** Full-text search across entity labels, summaries, properties, and data */
+    search(repositoryId: string, query: string, options?: SearchOptions): Promise<PaginatedResult<SearchHit>>;
+    /** Re-index an entire repository (for rebuild/migration) */
+    reindexRepository?(repositoryId: string, entities: AsyncIterable<SearchableEntity>): Promise<void>;
+}
+
+/**
+ * LockProvider — for multi-process or distributed deployments.
+ *
+ * Optional. When not provided, the core uses a no-op lock internally.
+ * Used for vocabulary modifications and bulk import operations.
+ */
+interface LockProvider {
+    /** Acquire a named lock. Returns a handle to release it. Throws if not acquired within timeout. */
+    acquire(lockName: string, options?: LockOptions): Promise<LockHandle>;
+}
+interface LockOptions {
+    /** Max wait to acquire in milliseconds (default 5000) */
+    timeoutMs?: number;
+    /** Auto-release after TTL in milliseconds (default 30000) */
+    ttlMs?: number;
+}
+interface LockHandle {
+    release(): Promise<void>;
+    extend(additionalMs: number): Promise<void>;
+}
+
+export type { EmbeddingProvider, LockHandle, LockOptions, LockProvider, SearchProvider, SearchableEntity };

package/dist/providers/index.d.ts

@@ -0,0 +1,75 @@
+export { S as StorageProvider } from '../StorageProvider-CJjz8uBY.js';
+import { a5 as SearchOptions, P as PaginatedResult, a6 as SearchHit } from '../portability-DdlNYXGX.js';
+
+/**
+ * EmbeddingProvider — enables semantic search and vocabulary deduplication.
+ *
+ * Optional. When not provided:
+ * - `searchByConcept` throws EmbeddingProviderRequiredError
+ * - Vocabulary deduplication falls back to string similarity (Jaro-Winkler)
+ * - Entity creation skips embedding generation
+ */
+interface EmbeddingProvider {
+    /** Generate a single embedding vector */
+    embed(text: string): Promise<number[]>;
+    /** Generate embeddings in batch (more efficient for bulk operations) */
+    embedBatch(texts: string[]): Promise<number[][]>;
+    /** The dimensionality of the embedding vectors (e.g., 1536, 768) */
+    dimensions(): number;
+    /** Identifier for the model used — stored with embeddings for compatibility tracking */
+    modelId(): string;
+    /**
+     * Compute cosine similarity between two vectors.
+     * Default implementation provided by the library — override for optimised hardware paths.
+     */
+    similarity?(a: number[], b: number[]): number;
+}
+
+/** Entity data indexed for full-text search */
+interface SearchableEntity {
+    entityId: string;
+    entityType: string;
+    label: string;
+    summary?: string;
+    properties?: Record<string, unknown>;
+    data?: string;
+}
+/**
+ * SearchProvider — enhances entity finding with full-text search.
+ *
+ * Optional. When not provided, `findEntities` falls back to the
+ * StorageProvider's basic label/property matching.
+ */
+interface SearchProvider {
+    /** Index an entity for full-text search */
+    indexEntity(repositoryId: string, entity: SearchableEntity): Promise<void>;
+    /** Remove an entity from the search index */
+    removeEntity(repositoryId: string, entityId: string): Promise<void>;
+    /** Full-text search across entity labels, summaries, properties, and data */
+    search(repositoryId: string, query: string, options?: SearchOptions): Promise<PaginatedResult<SearchHit>>;
+    /** Re-index an entire repository (for rebuild/migration) */
+    reindexRepository?(repositoryId: string, entities: AsyncIterable<SearchableEntity>): Promise<void>;
+}
+
+/**
+ * LockProvider — for multi-process or distributed deployments.
+ *
+ * Optional. When not provided, the core uses a no-op lock internally.
+ * Used for vocabulary modifications and bulk import operations.
+ */
+interface LockProvider {
+    /** Acquire a named lock. Returns a handle to release it. Throws if not acquired within timeout. */
+    acquire(lockName: string, options?: LockOptions): Promise<LockHandle>;
+}
+interface LockOptions {
+    /** Max wait to acquire in milliseconds (default 5000) */
+    timeoutMs?: number;
+    /** Auto-release after TTL in milliseconds (default 30000) */
+    ttlMs?: number;
+}
+interface LockHandle {
+    release(): Promise<void>;
+    extend(additionalMs: number): Promise<void>;
+}
+
+export type { EmbeddingProvider, LockHandle, LockOptions, LockProvider, SearchProvider, SearchableEntity };

package/dist/providers/index.js

@@ -0,0 +1 @@
+//# sourceMappingURL=index.js.map

package/dist/providers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/testing/conformance.cjs

@@ -0,0 +1,357 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/providers-builtin/conformance.ts
+var conformance_exports = {};
+__export(conformance_exports, {
+  runStorageProviderConformanceTests: () => runStorageProviderConformanceTests
+});
+module.exports = __toCommonJS(conformance_exports);
+var import_vitest = require("vitest");
+function makeProvenance() {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    createdBy: "conformance-test",
+    createdByType: "agent",
+    createdAt: now,
+    modifiedBy: "conformance-test",
+    modifiedByType: "agent",
+    modifiedAt: now
+  };
+}
+function makeEntity(id, type = "test-type", label) {
+  return {
+    id,
+    slug: `${type}:${(label ?? id).toLowerCase().replace(/[^a-z0-9]+/g, "-")}`,
+    entityType: type,
+    label: label ?? id,
+    summary: `Summary for ${id}`,
+    properties: { key: "value" },
+    provenance: makeProvenance()
+  };
+}
+function makeRelationship(id, type, sourceId, targetId, bidirectional = false) {
+  return {
+    id,
+    relationshipType: type,
+    sourceEntityId: sourceId,
+    targetEntityId: targetId,
+    properties: {},
+    bidirectional,
+    provenance: makeProvenance()
+  };
+}
+function runStorageProviderConformanceTests(factory) {
+  const repoId = "40000000-0000-4000-a000-000000000001";
+  let provider;
+  async function setup() {
+    provider = await factory();
+    if (provider.initialise) await provider.initialise();
+    await provider.createRepository({
+      repositoryId: repoId,
+      label: "Conformance Test",
+      governanceConfig: { mode: "open" },
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      createdBy: "conformance-test"
+    });
+  }
+  (0, import_vitest.describe)("StorageProvider Conformance Tests", () => {
+    (0, import_vitest.beforeEach)(async () => {
+      await setup();
+    });
+    (0, import_vitest.describe)("repository operations", () => {
+      (0, import_vitest.it)("creates a repository", async () => {
+        const repo = await provider.getRepository(repoId);
+        (0, import_vitest.expect)(repo).not.toBeNull();
+        (0, import_vitest.expect)(repo.repositoryId).toBe(repoId);
+        (0, import_vitest.expect)(repo.label).toBe("Conformance Test");
+      });
+      (0, import_vitest.it)("returns null for non-existent repository", async () => {
+        const repo = await provider.getRepository("ffffffff-ffff-4fff-afff-ffffffffffff");
+        (0, import_vitest.expect)(repo).toBeNull();
+      });
+      (0, import_vitest.it)("lists repositories", async () => {
+        const list = await provider.listRepositories();
+        (0, import_vitest.expect)(list.items.length).toBeGreaterThanOrEqual(1);
+        (0, import_vitest.expect)(list.items.some((r) => r.repositoryId === repoId)).toBe(true);
+      });
+      (0, import_vitest.it)("updates a repository", async () => {
+        const updated = await provider.updateRepository(repoId, {
+          label: "Updated Label",
+          description: "Updated description",
+          governanceConfig: { mode: "open", defaultSimilarityThreshold: 0.4 }
+        });
+        (0, import_vitest.expect)(updated.label).toBe("Updated Label");
+        (0, import_vitest.expect)(updated.description).toBe("Updated description");
+        (0, import_vitest.expect)(updated.governanceConfig.defaultSimilarityThreshold).toBe(0.4);
+        const fetched = await provider.getRepository(repoId);
+        (0, import_vitest.expect)(fetched.label).toBe("Updated Label");
+        (0, import_vitest.expect)(fetched.governanceConfig.defaultSimilarityThreshold).toBe(0.4);
+      });
+      (0, import_vitest.it)("deletes a repository", async () => {
+        await provider.deleteRepository(repoId);
+        (0, import_vitest.expect)(await provider.getRepository(repoId)).toBeNull();
+      });
+      (0, import_vitest.it)("returns repository stats", async () => {
+        const stats = await provider.getRepositoryStats(repoId);
+        (0, import_vitest.expect)(stats.entityCount).toBe(0);
+        (0, import_vitest.expect)(stats.relationshipCount).toBe(0);
+        (0, import_vitest.expect)(typeof stats.vocabularyVersion).toBe("string");
+      });
+    });
+    (0, import_vitest.describe)("vocabulary operations", () => {
+      (0, import_vitest.it)("gets and saves vocabulary", async () => {
+        const vocab = await provider.getVocabulary(repoId);
+        (0, import_vitest.expect)(vocab).toBeDefined();
+        (0, import_vitest.expect)(typeof vocab.version).toBe("string");
+        const updated = { ...vocab, version: "1.0.0" };
+        await provider.saveVocabulary(repoId, updated);
+        const fetched = await provider.getVocabulary(repoId);
+        (0, import_vitest.expect)(fetched.version).toBe("1.0.0");
+      });
+      (0, import_vitest.it)("returns vocabulary change log", async () => {
+        const log = await provider.getVocabularyChangeLog(repoId);
+        (0, import_vitest.expect)(Array.isArray(log.items)).toBe(true);
+      });
+    });
+    (0, import_vitest.describe)("entity operations", () => {
+      (0, import_vitest.it)("creates and retrieves an entity", async () => {
+        const entity = makeEntity("e1");
+        await provider.createEntity(repoId, entity);
+        const retrieved = await provider.getEntity(repoId, "e1");
+        (0, import_vitest.expect)(retrieved).not.toBeNull();
+        (0, import_vitest.expect)(retrieved.id).toBe("e1");
+        (0, import_vitest.expect)(retrieved.label).toBe("e1");
+      });
+      (0, import_vitest.it)("retrieves an entity by slug", async () => {
+        const entity = makeEntity("e1", "test-type", "Alpha");
+        await provider.createEntity(repoId, entity);
+        const retrieved = await provider.getEntityBySlug(repoId, entity.slug);
+        (0, import_vitest.expect)(retrieved).not.toBeNull();
+        (0, import_vitest.expect)(retrieved.id).toBe("e1");
+        (0, import_vitest.expect)(retrieved.slug).toBe(entity.slug);
+      });
+      (0, import_vitest.it)("returns null for non-existent entity", async () => {
+        const result = await provider.getEntity(repoId, "nonexistent");
+        (0, import_vitest.expect)(result).toBeNull();
+      });
+      (0, import_vitest.it)("returns null for non-existent slug", async () => {
+        const result = await provider.getEntityBySlug(repoId, "nonexistent:slug");
+        (0, import_vitest.expect)(result).toBeNull();
+      });
+      (0, import_vitest.it)("batch retrieves entities", async () => {
+        await provider.createEntity(repoId, makeEntity("e1"));
+        await provider.createEntity(repoId, makeEntity("e2"));
+        const map = await provider.getEntities(repoId, ["e1", "e2", "missing"]);
+        (0, import_vitest.expect)(map.size).toBe(2);
+        (0, import_vitest.expect)(map.has("e1")).toBe(true);
+        (0, import_vitest.expect)(map.has("e2")).toBe(true);
+        (0, import_vitest.expect)(map.has("missing")).toBe(false);
+      });
+      (0, import_vitest.it)("updates an entity", async () => {
+        await provider.createEntity(repoId, makeEntity("e1"));
+        const updated = await provider.updateEntity(repoId, "e1", {
+          label: "Updated Label",
+          provenance: makeProvenance()
+        });
+        (0, import_vitest.expect)(updated.label).toBe("Updated Label");
+        const fetched = await provider.getEntity(repoId, "e1");
+        (0, import_vitest.expect)(fetched.label).toBe("Updated Label");
+      });
+      (0, import_vitest.it)("deletes an entity", async () => {
+        await provider.createEntity(repoId, makeEntity("e1"));
+        await provider.deleteEntity(repoId, "e1");
+        (0, import_vitest.expect)(await provider.getEntity(repoId, "e1")).toBeNull();
+      });
+      (0, import_vitest.it)("finds entities by search term", async () => {
+        await provider.createEntity(repoId, makeEntity("e1", "test-type", "Alpha"));
+        await provider.createEntity(repoId, makeEntity("e2", "test-type", "Beta"));
+        const result = await provider.findEntities(repoId, {
+          searchTerm: "alpha",
+          limit: 10,
+          offset: 0
+        });
+        (0, import_vitest.expect)(result.items).toHaveLength(1);
+        (0, import_vitest.expect)(result.items[0].label).toBe("Alpha");
+      });
+      (0, import_vitest.it)("finds entities by type filter", async () => {
+        await provider.createEntity(repoId, makeEntity("e1", "type-a", "A"));
+        await provider.createEntity(repoId, makeEntity("e2", "type-b", "B"));
+        const result = await provider.findEntities(repoId, {
+          entityTypes: ["type-a"],
+          limit: 10,
+          offset: 0
+        });
+        (0, import_vitest.expect)(result.items).toHaveLength(1);
+        (0, import_vitest.expect)(result.items[0].entityType).toBe("type-a");
+      });
+      (0, import_vitest.it)("paginates find results", async () => {
+        await provider.createEntity(repoId, makeEntity("e1"));
+        await provider.createEntity(repoId, makeEntity("e2"));
+        await provider.createEntity(repoId, makeEntity("e3"));
+        const page1 = await provider.findEntities(repoId, { limit: 2, offset: 0 });
+        (0, import_vitest.expect)(page1.items).toHaveLength(2);
+        (0, import_vitest.expect)(page1.hasMore).toBe(true);
+        const page2 = await provider.findEntities(repoId, { limit: 2, offset: 2 });
+        (0, import_vitest.expect)(page2.items).toHaveLength(1);
+        (0, import_vitest.expect)(page2.hasMore).toBe(false);
+      });
+    });
+    (0, import_vitest.describe)("relationship operations", () => {
+      (0, import_vitest.beforeEach)(async () => {
+        await provider.createEntity(repoId, makeEntity("a"));
+        await provider.createEntity(repoId, makeEntity("b"));
+        await provider.createEntity(repoId, makeEntity("c"));
+      });
+      (0, import_vitest.it)("creates and retrieves a relationship", async () => {
+        const rel = makeRelationship("r1", "connects", "a", "b");
+        await provider.createRelationship(repoId, rel);
+        const retrieved = await provider.getRelationship(repoId, "r1");
+        (0, import_vitest.expect)(retrieved).not.toBeNull();
+        (0, import_vitest.expect)(retrieved.sourceEntityId).toBe("a");
+        (0, import_vitest.expect)(retrieved.targetEntityId).toBe("b");
+      });
+      (0, import_vitest.it)("returns null for non-existent relationship", async () => {
+        (0, import_vitest.expect)(await provider.getRelationship(repoId, "nonexistent")).toBeNull();
+      });
+      (0, import_vitest.it)("gets entity relationships", async () => {
+        await provider.createRelationship(repoId, makeRelationship("r1", "connects", "a", "b"));
+        await provider.createRelationship(repoId, makeRelationship("r2", "connects", "c", "a"));
+        const result = await provider.getEntityRelationships(repoId, "a");
+        (0, import_vitest.expect)(result.items).toHaveLength(2);
+      });
+      (0, import_vitest.it)("filters relationships by direction", async () => {
+        await provider.createRelationship(repoId, makeRelationship("r1", "connects", "a", "b"));
+        await provider.createRelationship(repoId, makeRelationship("r2", "connects", "c", "a"));
+        const outbound = await provider.getEntityRelationships(repoId, "a", { direction: "outbound" });
+        (0, import_vitest.expect)(outbound.items).toHaveLength(1);
+        (0, import_vitest.expect)(outbound.items[0].targetEntityId).toBe("b");
+        const inbound = await provider.getEntityRelationships(repoId, "a", { direction: "inbound" });
+        (0, import_vitest.expect)(inbound.items).toHaveLength(1);
+        (0, import_vitest.expect)(inbound.items[0].sourceEntityId).toBe("c");
+      });
+      (0, import_vitest.it)("deletes a relationship", async () => {
+        await provider.createRelationship(repoId, makeRelationship("r1", "connects", "a", "b"));
+        await provider.deleteRelationship(repoId, "r1");
+        (0, import_vitest.expect)(await provider.getRelationship(repoId, "r1")).toBeNull();
+      });
+    });
+    (0, import_vitest.describe)("graph traversal", () => {
+      (0, import_vitest.beforeEach)(async () => {
+        await provider.createEntity(repoId, makeEntity("a", "node", "A"));
+        await provider.createEntity(repoId, makeEntity("b", "node", "B"));
+        await provider.createEntity(repoId, makeEntity("c", "node", "C"));
+        await provider.createRelationship(repoId, makeRelationship("r1", "links", "a", "b"));
+        await provider.createRelationship(repoId, makeRelationship("r2", "links", "b", "c"));
+      });
+      (0, import_vitest.it)("explores neighbourhood at depth 1", async () => {
+        const result = await provider.exploreNeighbourhood(repoId, "a", {
+          depth: 1,
+          direction: "both",
+          limitPerType: 10,
+          offsetPerType: 0
+        });
+        (0, import_vitest.expect)(result.centreId).toBe("a");
+        (0, import_vitest.expect)(result.layers).toHaveLength(1);
+      });
+      (0, import_vitest.it)("finds paths between connected entities", async () => {
+        const result = await provider.findPaths(repoId, "a", "c", {
+          maxDepth: 3,
+          limit: 5,
+          offset: 0
+        });
+        (0, import_vitest.expect)(result.paths.length).toBeGreaterThanOrEqual(1);
+        const firstPath = result.paths[0];
+        (0, import_vitest.expect)(firstPath.entityIds[0]).toBe("a");
+        (0, import_vitest.expect)(firstPath.entityIds[firstPath.entityIds.length - 1]).toBe("c");
+      });
+      (0, import_vitest.it)("returns empty paths when no connection", async () => {
+        await provider.createEntity(repoId, makeEntity("isolated", "node", "Isolated"));
+        const result = await provider.findPaths(repoId, "a", "isolated", {
+          maxDepth: 3,
+          limit: 5,
+          offset: 0
+        });
+        (0, import_vitest.expect)(result.paths).toHaveLength(0);
+      });
+      (0, import_vitest.it)("finds paths through non-bidirectional inbound edges", async () => {
+        await provider.createEntity(repoId, makeEntity("d", "node", "D"));
+        await provider.createRelationship(repoId, makeRelationship("r3", "links", "d", "b"));
+        const result = await provider.findPaths(repoId, "a", "d", {
+          maxDepth: 3,
+          limit: 5,
+          offset: 0
+        });
+        (0, import_vitest.expect)(result.paths.length).toBeGreaterThanOrEqual(1);
+        const firstPath = result.paths[0];
+        (0, import_vitest.expect)(firstPath.entityIds[0]).toBe("a");
+        (0, import_vitest.expect)(firstPath.entityIds[firstPath.entityIds.length - 1]).toBe("d");
+      });
+    });
+    (0, import_vitest.describe)("timeline", () => {
+      (0, import_vitest.it)("returns timeline events", async () => {
+        await provider.createEntity(repoId, makeEntity("e1"));
+        const result = await provider.getTimeline(repoId, "e1", {
+          limit: 10,
+          offset: 0
+        });
+        (0, import_vitest.expect)(result.events.length).toBeGreaterThanOrEqual(1);
+      });
+    });
+    (0, import_vitest.describe)("bulk operations", () => {
+      (0, import_vitest.it)("exports data", async () => {
+        await provider.createEntity(repoId, makeEntity("e1"));
+        const chunks = [];
+        for await (const chunk of provider.exportAll(repoId)) {
+          chunks.push(chunk);
+        }
+        (0, import_vitest.expect)(chunks.length).toBeGreaterThanOrEqual(1);
+      });
+      (0, import_vitest.it)("imports data", async () => {
+        const result = await provider.importBulk(repoId, [
+          { entities: [makeEntity("imported-1"), makeEntity("imported-2")] },
+          { relationships: [makeRelationship("ir1", "links", "imported-1", "imported-2")] }
+        ]);
+        (0, import_vitest.expect)(result.entitiesImported).toBe(2);
+        (0, import_vitest.expect)(result.relationshipsImported).toBe(1);
+        const e = await provider.getEntity(repoId, "imported-1");
+        (0, import_vitest.expect)(e).not.toBeNull();
+      });
+    });
+    (0, import_vitest.describe)("stats reflect data", () => {
+      (0, import_vitest.it)("counts entities and relationships", async () => {
+        await provider.createEntity(repoId, makeEntity("e1", "alpha"));
+        await provider.createEntity(repoId, makeEntity("e2", "alpha"));
+        await provider.createEntity(repoId, makeEntity("e3", "beta"));
+        await provider.createRelationship(repoId, makeRelationship("r1", "links", "e1", "e2"));
+        const stats = await provider.getRepositoryStats(repoId);
+        (0, import_vitest.expect)(stats.entityCount).toBe(3);
+        (0, import_vitest.expect)(stats.relationshipCount).toBe(1);
+        (0, import_vitest.expect)(stats.entityTypeBreakdown["alpha"]).toBe(2);
+        (0, import_vitest.expect)(stats.entityTypeBreakdown["beta"]).toBe(1);
+        (0, import_vitest.expect)(stats.relationshipTypeBreakdown["links"]).toBe(1);
+      });
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runStorageProviderConformanceTests
+});
+//# sourceMappingURL=conformance.cjs.map

package/dist/testing/conformance.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/providers-builtin/conformance.ts"],"sourcesContent":["// Provider Conformance Test Suite\n// Any StorageProvider implementer can import and run these tests to verify conformance.\n//\n// Usage:\n//   import { runStorageProviderConformanceTests } from '@utaba/deep-memory';\n//   runStorageProviderConformanceTests(() => new MyStorageProvider());\n\nimport { describe, it, expect, beforeEach } from 'vitest';\nimport type { StorageProvider } from '../providers/StorageProvider.js';\nimport type { StoredEntity } from '../types/entities.js';\nimport type { StoredRelationship } from '../types/relationships.js';\nimport type { Provenance } from '../types/provenance.js';\n\nfunction makeProvenance(): Provenance {\n  const now = new Date().toISOString();\n  return {\n    createdBy: 'conformance-test',\n    createdByType: 'agent',\n    createdAt: now,\n    modifiedBy: 'conformance-test',\n    modifiedByType: 'agent',\n    modifiedAt: now,\n  };\n}\n\nfunction makeEntity(id: string, type = 'test-type', label?: string): StoredEntity {\n  return {\n    id,\n    slug: `${type}:${(label ?? id).toLowerCase().replace(/[^a-z0-9]+/g, '-')}`,\n    entityType: type,\n    label: label ?? id,\n    summary: `Summary for ${id}`,\n    properties: { key: 'value' },\n    provenance: makeProvenance(),\n  };\n}\n\nfunction makeRelationship(\n  id: string,\n  type: string,\n  sourceId: string,\n  targetId: string,\n  bidirectional = false,\n): StoredRelationship {\n  return {\n    id,\n    relationshipType: type,\n    sourceEntityId: sourceId,\n    targetEntityId: targetId,\n    properties: {},\n    bidirectional,\n    provenance: makeProvenance(),\n  };\n}\n\n/**\n * Run the full StorageProvider conformance test suite.\n *\n * @param factory - A function that creates a fresh, empty StorageProvider instance.\n *                  Called before each test to ensure isolation.\n */\nexport function runStorageProviderConformanceTests(\n  factory: () => StorageProvider | Promise<StorageProvider>,\n): void {\n  // Use a stable GUID so external cleanup scripts can target it\n  const repoId = '40000000-0000-4000-a000-000000000001';\n\n  let provider: StorageProvider;\n\n  async function setup(): Promise<void> {\n    provider = await factory();\n    if (provider.initialise) await provider.initialise();\n\n    await provider.createRepository({\n      repositoryId: repoId,\n      label: 'Conformance Test',\n      governanceConfig: { mode: 'open' },\n      createdAt: new Date().toISOString(),\n      createdBy: 'conformance-test',\n    });\n  }\n\n  describe('StorageProvider Conformance Tests', () => {\n    beforeEach(async () => {\n      await setup();\n    });\n\n    // ─── Repository ─────────────────────────────────────────\n\n    describe('repository operations', () => {\n      it('creates a repository', async () => {\n        const repo = await provider.getRepository(repoId);\n        expect(repo).not.toBeNull();\n        expect(repo!.repositoryId).toBe(repoId);\n        expect(repo!.label).toBe('Conformance Test');\n      });\n\n      it('returns null for non-existent repository', async () => {\n        const repo = await provider.getRepository('ffffffff-ffff-4fff-afff-ffffffffffff');\n        expect(repo).toBeNull();\n      });\n\n      it('lists repositories', async () => {\n        const list = await provider.listRepositories();\n        expect(list.items.length).toBeGreaterThanOrEqual(1);\n        expect(list.items.some((r) => r.repositoryId === repoId)).toBe(true);\n      });\n\n      it('updates a repository', async () => {\n        const updated = await provider.updateRepository(repoId, {\n          label: 'Updated Label',\n          description: 'Updated description',\n          governanceConfig: { mode: 'open', defaultSimilarityThreshold: 0.4 },\n        });\n        expect(updated.label).toBe('Updated Label');\n        expect(updated.description).toBe('Updated description');\n        expect(updated.governanceConfig.defaultSimilarityThreshold).toBe(0.4);\n\n        // Verify persistence\n        const fetched = await provider.getRepository(repoId);\n        expect(fetched!.label).toBe('Updated Label');\n        expect(fetched!.governanceConfig.defaultSimilarityThreshold).toBe(0.4);\n      });\n\n      it('deletes a repository', async () => {\n        await provider.deleteRepository(repoId);\n        expect(await provider.getRepository(repoId)).toBeNull();\n      });\n\n      it('returns repository stats', async () => {\n        const stats = await provider.getRepositoryStats(repoId);\n        expect(stats.entityCount).toBe(0);\n        expect(stats.relationshipCount).toBe(0);\n        expect(typeof stats.vocabularyVersion).toBe('string');\n      });\n    });\n\n    // ─── Vocabulary ─────────────────────────────────────────\n\n    describe('vocabulary operations', () => {\n      it('gets and saves vocabulary', async () => {\n        const vocab = await provider.getVocabulary(repoId);\n        expect(vocab).toBeDefined();\n        expect(typeof vocab.version).toBe('string');\n\n        const updated = { ...vocab, version: '1.0.0' };\n        await provider.saveVocabulary(repoId, updated);\n\n        const fetched = await provider.getVocabulary(repoId);\n        expect(fetched.version).toBe('1.0.0');\n      });\n\n      it('returns vocabulary change log', async () => {\n        const log = await provider.getVocabularyChangeLog(repoId);\n        expect(Array.isArray(log.items)).toBe(true);\n      });\n    });\n\n    // ─── Entities ───────────────────────────────────────────\n\n    describe('entity operations', () => {\n      it('creates and retrieves an entity', async () => {\n        const entity = makeEntity('e1');\n        await provider.createEntity(repoId, entity);\n\n        const retrieved = await provider.getEntity(repoId, 'e1');\n        expect(retrieved).not.toBeNull();\n        expect(retrieved!.id).toBe('e1');\n        expect(retrieved!.label).toBe('e1');\n      });\n\n      it('retrieves an entity by slug', async () => {\n        const entity = makeEntity('e1', 'test-type', 'Alpha');\n        await provider.createEntity(repoId, entity);\n\n        const retrieved = await provider.getEntityBySlug(repoId, entity.slug);\n        expect(retrieved).not.toBeNull();\n        expect(retrieved!.id).toBe('e1');\n        expect(retrieved!.slug).toBe(entity.slug);\n      });\n\n      it('returns null for non-existent entity', async () => {\n        const result = await provider.getEntity(repoId, 'nonexistent');\n        expect(result).toBeNull();\n      });\n\n      it('returns null for non-existent slug', async () => {\n        const result = await provider.getEntityBySlug(repoId, 'nonexistent:slug');\n        expect(result).toBeNull();\n      });\n\n      it('batch retrieves entities', async () => {\n        await provider.createEntity(repoId, makeEntity('e1'));\n        await provider.createEntity(repoId, makeEntity('e2'));\n\n        const map = await provider.getEntities(repoId, ['e1', 'e2', 'missing']);\n        expect(map.size).toBe(2);\n        expect(map.has('e1')).toBe(true);\n        expect(map.has('e2')).toBe(true);\n        expect(map.has('missing')).toBe(false);\n      });\n\n      it('updates an entity', async () => {\n        await provider.createEntity(repoId, makeEntity('e1'));\n        const updated = await provider.updateEntity(repoId, 'e1', {\n          label: 'Updated Label',\n          provenance: makeProvenance(),\n        });\n        expect(updated.label).toBe('Updated Label');\n\n        const fetched = await provider.getEntity(repoId, 'e1');\n        expect(fetched!.label).toBe('Updated Label');\n      });\n\n      it('deletes an entity', async () => {\n        await provider.createEntity(repoId, makeEntity('e1'));\n        await provider.deleteEntity(repoId, 'e1');\n        expect(await provider.getEntity(repoId, 'e1')).toBeNull();\n      });\n\n      it('finds entities by search term', async () => {\n        await provider.createEntity(repoId, makeEntity('e1', 'test-type', 'Alpha'));\n        await provider.createEntity(repoId, makeEntity('e2', 'test-type', 'Beta'));\n\n        const result = await provider.findEntities(repoId, {\n          searchTerm: 'alpha',\n          limit: 10,\n          offset: 0,\n        });\n        expect(result.items).toHaveLength(1);\n        expect(result.items[0]!.label).toBe('Alpha');\n      });\n\n      it('finds entities by type filter', async () => {\n        await provider.createEntity(repoId, makeEntity('e1', 'type-a', 'A'));\n        await provider.createEntity(repoId, makeEntity('e2', 'type-b', 'B'));\n\n        const result = await provider.findEntities(repoId, {\n          entityTypes: ['type-a'],\n          limit: 10,\n          offset: 0,\n        });\n        expect(result.items).toHaveLength(1);\n        expect(result.items[0]!.entityType).toBe('type-a');\n      });\n\n      it('paginates find results', async () => {\n        await provider.createEntity(repoId, makeEntity('e1'));\n        await provider.createEntity(repoId, makeEntity('e2'));\n        await provider.createEntity(repoId, makeEntity('e3'));\n\n        const page1 = await provider.findEntities(repoId, { limit: 2, offset: 0 });\n        expect(page1.items).toHaveLength(2);\n        expect(page1.hasMore).toBe(true);\n\n        const page2 = await provider.findEntities(repoId, { limit: 2, offset: 2 });\n        expect(page2.items).toHaveLength(1);\n        expect(page2.hasMore).toBe(false);\n      });\n    });\n\n    // ─── Relationships ──────────────────────────────────────\n\n    describe('relationship operations', () => {\n      beforeEach(async () => {\n        await provider.createEntity(repoId, makeEntity('a'));\n        await provider.createEntity(repoId, makeEntity('b'));\n        await provider.createEntity(repoId, makeEntity('c'));\n      });\n\n      it('creates and retrieves a relationship', async () => {\n        const rel = makeRelationship('r1', 'connects', 'a', 'b');\n        await provider.createRelationship(repoId, rel);\n\n        const retrieved = await provider.getRelationship(repoId, 'r1');\n        expect(retrieved).not.toBeNull();\n        expect(retrieved!.sourceEntityId).toBe('a');\n        expect(retrieved!.targetEntityId).toBe('b');\n      });\n\n      it('returns null for non-existent relationship', async () => {\n        expect(await provider.getRelationship(repoId, 'nonexistent')).toBeNull();\n      });\n\n      it('gets entity relationships', async () => {\n        await provider.createRelationship(repoId, makeRelationship('r1', 'connects', 'a', 'b'));\n        await provider.createRelationship(repoId, makeRelationship('r2', 'connects', 'c', 'a'));\n\n        const result = await provider.getEntityRelationships(repoId, 'a');\n        expect(result.items).toHaveLength(2);\n      });\n\n      it('filters relationships by direction', async () => {\n        await provider.createRelationship(repoId, makeRelationship('r1', 'connects', 'a', 'b'));\n        await provider.createRelationship(repoId, makeRelationship('r2', 'connects', 'c', 'a'));\n\n        const outbound = await provider.getEntityRelationships(repoId, 'a', { direction: 'outbound' });\n        expect(outbound.items).toHaveLength(1);\n        expect(outbound.items[0]!.targetEntityId).toBe('b');\n\n        const inbound = await provider.getEntityRelationships(repoId, 'a', { direction: 'inbound' });\n        expect(inbound.items).toHaveLength(1);\n        expect(inbound.items[0]!.sourceEntityId).toBe('c');\n      });\n\n      it('deletes a relationship', async () => {\n        await provider.createRelationship(repoId, makeRelationship('r1', 'connects', 'a', 'b'));\n        await provider.deleteRelationship(repoId, 'r1');\n        expect(await provider.getRelationship(repoId, 'r1')).toBeNull();\n      });\n    });\n\n    // ─── Graph Traversal ────────────────────────────────────\n\n    describe('graph traversal', () => {\n      beforeEach(async () => {\n        await provider.createEntity(repoId, makeEntity('a', 'node', 'A'));\n        await provider.createEntity(repoId, makeEntity('b', 'node', 'B'));\n        await provider.createEntity(repoId, makeEntity('c', 'node', 'C'));\n        await provider.createRelationship(repoId, makeRelationship('r1', 'links', 'a', 'b'));\n        await provider.createRelationship(repoId, makeRelationship('r2', 'links', 'b', 'c'));\n      });\n\n      it('explores neighbourhood at depth 1', async () => {\n        const result = await provider.exploreNeighbourhood(repoId, 'a', {\n          depth: 1,\n          direction: 'both',\n          limitPerType: 10,\n          offsetPerType: 0,\n        });\n        expect(result.centreId).toBe('a');\n        expect(result.layers).toHaveLength(1);\n      });\n\n      it('finds paths between connected entities', async () => {\n        const result = await provider.findPaths(repoId, 'a', 'c', {\n          maxDepth: 3,\n          limit: 5,\n          offset: 0,\n        });\n        expect(result.paths.length).toBeGreaterThanOrEqual(1);\n        const firstPath = result.paths[0]!;\n        expect(firstPath.entityIds[0]).toBe('a');\n        expect(firstPath.entityIds[firstPath.entityIds.length - 1]).toBe('c');\n      });\n\n      it('returns empty paths when no connection', async () => {\n        await provider.createEntity(repoId, makeEntity('isolated', 'node', 'Isolated'));\n        const result = await provider.findPaths(repoId, 'a', 'isolated', {\n          maxDepth: 3,\n          limit: 5,\n          offset: 0,\n        });\n        expect(result.paths).toHaveLength(0);\n      });\n\n      it('finds paths through non-bidirectional inbound edges', async () => {\n        // Graph: a → b ← d (both edges are non-bidirectional)\n        // Path from a to d should traverse: a →(outbound) b ←(inbound) d\n        await provider.createEntity(repoId, makeEntity('d', 'node', 'D'));\n        await provider.createRelationship(repoId, makeRelationship('r3', 'links', 'd', 'b'));\n        const result = await provider.findPaths(repoId, 'a', 'd', {\n          maxDepth: 3,\n          limit: 5,\n          offset: 0,\n        });\n        expect(result.paths.length).toBeGreaterThanOrEqual(1);\n        const firstPath = result.paths[0]!;\n        expect(firstPath.entityIds[0]).toBe('a');\n        expect(firstPath.entityIds[firstPath.entityIds.length - 1]).toBe('d');\n      });\n    });\n\n    // ─── Timeline ───────────────────────────────────────────\n\n    describe('timeline', () => {\n      it('returns timeline events', async () => {\n        await provider.createEntity(repoId, makeEntity('e1'));\n        const result = await provider.getTimeline(repoId, 'e1', {\n          limit: 10,\n          offset: 0,\n        });\n        expect(result.events.length).toBeGreaterThanOrEqual(1);\n      });\n    });\n\n    // ─── Bulk Operations ────────────────────────────────────\n\n    describe('bulk operations', () => {\n      it('exports data', async () => {\n        await provider.createEntity(repoId, makeEntity('e1'));\n\n        const chunks = [];\n        for await (const chunk of provider.exportAll(repoId)) {\n          chunks.push(chunk);\n        }\n        expect(chunks.length).toBeGreaterThanOrEqual(1);\n      });\n\n      it('imports data', async () => {\n        const result = await provider.importBulk(repoId, [\n          { entities: [makeEntity('imported-1'), makeEntity('imported-2')] },\n          { relationships: [makeRelationship('ir1', 'links', 'imported-1', 'imported-2')] },\n        ]);\n        expect(result.entitiesImported).toBe(2);\n        expect(result.relationshipsImported).toBe(1);\n\n        // Verify imported data is accessible\n        const e = await provider.getEntity(repoId, 'imported-1');\n        expect(e).not.toBeNull();\n      });\n    });\n\n    // ─── Stats after data ───────────────────────────────────\n\n    describe('stats reflect data', () => {\n      it('counts entities and relationships', async () => {\n        await provider.createEntity(repoId, makeEntity('e1', 'alpha'));\n        await provider.createEntity(repoId, makeEntity('e2', 'alpha'));\n        await provider.createEntity(repoId, makeEntity('e3', 'beta'));\n        await provider.createRelationship(repoId, makeRelationship('r1', 'links', 'e1', 'e2'));\n\n        const stats = await provider.getRepositoryStats(repoId);\n        expect(stats.entityCount).toBe(3);\n        expect(stats.relationshipCount).toBe(1);\n        expect(stats.entityTypeBreakdown['alpha']).toBe(2);\n        expect(stats.entityTypeBreakdown['beta']).toBe(1);\n        expect(stats.relationshipTypeBreakdown['links']).toBe(1);\n      });\n    });\n  });\n}\n"],"mappings":"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","names":[]}

package/dist/testing/conformance.d.cts

@@ -0,0 +1,12 @@
+import { S as StorageProvider } from '../StorageProvider-CkFjdboX.cjs';
+import '../portability-DdlNYXGX.cjs';
+
+/**
+ * Run the full StorageProvider conformance test suite.
+ *
+ * @param factory - A function that creates a fresh, empty StorageProvider instance.
+ *                  Called before each test to ensure isolation.
+ */
+declare function runStorageProviderConformanceTests(factory: () => StorageProvider | Promise<StorageProvider>): void;
+
+export { runStorageProviderConformanceTests };

package/dist/testing/conformance.d.ts

@@ -0,0 +1,12 @@
+import { S as StorageProvider } from '../StorageProvider-CJjz8uBY.js';
+import '../portability-DdlNYXGX.js';
+
+/**
+ * Run the full StorageProvider conformance test suite.
+ *
+ * @param factory - A function that creates a fresh, empty StorageProvider instance.
+ *                  Called before each test to ensure isolation.
+ */
+declare function runStorageProviderConformanceTests(factory: () => StorageProvider | Promise<StorageProvider>): void;
+
+export { runStorageProviderConformanceTests };