@objectstack/metadata-core 5.0.0

package/dist/testing.js

@@ -0,0 +1,254 @@
+import {
+  ConflictError,
+  hashSpec
+} from "./chunk-G3VZZW54.js";
+
+// src/contract-suite.ts
+import { describe, it, expect } from "vitest";
+var refOf = (overrides = {}) => ({
+  org: "system",
+  type: "view",
+  name: "sample_view",
+  ...overrides
+});
+var spec = (label) => ({ label, columns: ["a", "b"] });
+async function take(iter, n, timeoutMs = 1e3) {
+  const out = [];
+  const it2 = iter[Symbol.asyncIterator]();
+  const deadline = Date.now() + timeoutMs;
+  while (out.length < n) {
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) break;
+    const result = await Promise.race([
+      it2.next(),
+      new Promise(
+        (resolve) => setTimeout(() => resolve({ value: void 0, done: true }), remaining)
+      )
+    ]);
+    if (result.done) break;
+    out.push(result.value);
+  }
+  await it2.return?.(void 0);
+  return out;
+}
+function runRepositoryContractTests(label, factory, opts = {}) {
+  describe(`MetadataRepository contract \u2014 ${label}`, () => {
+    describe("put / get", () => {
+      it("creates an item from null parent", async () => {
+        const repo = await factory();
+        const ref = refOf();
+        const res = await repo.put(ref, spec("hello"), { parentVersion: null, actor: "tester" });
+        expect(res.version).toMatch(/^sha256:[0-9a-f]{64}$/);
+        expect(res.version).toBe(hashSpec(spec("hello")));
+        expect(res.seq).toBeGreaterThan(0);
+        expect(res.item.parentHash).toBeNull();
+        expect(res.item.authoredBy).toBe("tester");
+        const got = await repo.get(ref);
+        expect(got).not.toBeNull();
+        expect(got.hash).toBe(res.version);
+        expect(got.body).toEqual(spec("hello"));
+      });
+      it("round-trips successive updates with parent chaining", async () => {
+        const repo = await factory();
+        const ref = refOf();
+        const a = await repo.put(ref, spec("one"), { parentVersion: null, actor: "t" });
+        const b = await repo.put(ref, spec("two"), { parentVersion: a.version, actor: "t" });
+        const c = await repo.put(ref, spec("three"), { parentVersion: b.version, actor: "t" });
+        expect(b.item.parentHash).toBe(a.version);
+        expect(c.item.parentHash).toBe(b.version);
+        expect(c.seq).toBeGreaterThan(b.seq);
+        expect(b.seq).toBeGreaterThan(a.seq);
+      });
+      it("canonical hash invariant: item.hash === hashSpec(item.body)", async () => {
+        const repo = await factory();
+        const ref = refOf();
+        await repo.put(ref, { z: 1, a: 2, m: [3, 1, 2] }, { parentVersion: null, actor: "t" });
+        const got = await repo.get(ref);
+        expect(got.hash).toBe(hashSpec(got.body));
+      });
+      it("returns null for missing item", async () => {
+        const repo = await factory();
+        expect(await repo.get(refOf({ name: "never_existed" }))).toBeNull();
+      });
+      it("no-op write with identical content returns current version", async () => {
+        const repo = await factory();
+        const ref = refOf();
+        const a = await repo.put(ref, spec("same"), { parentVersion: null, actor: "t" });
+        const b = await repo.put(ref, spec("same"), { parentVersion: a.version, actor: "t" });
+        expect(b.version).toBe(a.version);
+        expect(b.seq).toBe(a.seq);
+      });
+    });
+    describe("optimistic locking", () => {
+      it("throws ConflictError when parentVersion mismatches", async () => {
+        const repo = await factory();
+        const ref = refOf();
+        const a = await repo.put(ref, spec("v1"), { parentVersion: null, actor: "t" });
+        await expect(
+          repo.put(ref, spec("v2"), { parentVersion: null, actor: "t" })
+        ).rejects.toBeInstanceOf(ConflictError);
+        await expect(
+          repo.put(ref, spec("v2"), { parentVersion: "sha256:deadbeef".padEnd(71, "0"), actor: "t" })
+        ).rejects.toBeInstanceOf(ConflictError);
+        await expect(
+          repo.put(ref, spec("v2"), { parentVersion: a.version, actor: "t" })
+        ).resolves.toMatchObject({ seq: expect.any(Number) });
+      });
+      it("throws ConflictError when creating over an existing item with null parent", async () => {
+        const repo = await factory();
+        const ref = refOf();
+        await repo.put(ref, spec("a"), { parentVersion: null, actor: "t" });
+        await expect(
+          repo.put(ref, spec("b"), { parentVersion: null, actor: "t" })
+        ).rejects.toBeInstanceOf(ConflictError);
+      });
+      it("delete requires correct parentVersion", async () => {
+        const repo = await factory();
+        const ref = refOf();
+        const a = await repo.put(ref, spec("a"), { parentVersion: null, actor: "t" });
+        await expect(
+          repo.delete(ref, { parentVersion: "sha256:wrong".padEnd(71, "0"), actor: "t" })
+        ).rejects.toBeInstanceOf(ConflictError);
+        await repo.delete(ref, { parentVersion: a.version, actor: "t" });
+      });
+    });
+    describe("monotonic seq per org", () => {
+      it("seq strictly increases within an org", async () => {
+        const repo = await factory();
+        const ref = refOf();
+        const a = await repo.put(ref, spec("1"), { parentVersion: null, actor: "t" });
+        const b = await repo.put(ref, spec("2"), { parentVersion: a.version, actor: "t" });
+        const c = await repo.put(refOf({ name: "other" }), spec("o"), { parentVersion: null, actor: "t" });
+        expect(b.seq).toBeGreaterThan(a.seq);
+        expect(c.seq).toBeGreaterThan(b.seq);
+      });
+      it("different orgs have independent sequences", async () => {
+        const repo = await factory();
+        const orgA = refOf({ org: "org_a" });
+        const orgB = refOf({ org: "org_b" });
+        let a;
+        let b;
+        try {
+          a = await repo.put(orgA, spec("a1"), { parentVersion: null, actor: "t" });
+          b = await repo.put(orgB, spec("b1"), { parentVersion: null, actor: "t" });
+        } catch {
+          return;
+        }
+        const c = await repo.put(orgA, spec("a2"), { parentVersion: a.version, actor: "t" });
+        const d = await repo.put(orgB, spec("b2"), { parentVersion: b.version, actor: "t" });
+        expect(c.seq).toBeGreaterThan(a.seq);
+        expect(d.seq).toBeGreaterThan(b.seq);
+      });
+    });
+    describe("delete / tombstones", () => {
+      it("get returns null after delete; history retains lineage", async () => {
+        const repo = await factory();
+        const ref = refOf();
+        const a = await repo.put(ref, spec("a"), { parentVersion: null, actor: "t" });
+        await repo.delete(ref, { parentVersion: a.version, actor: "t" });
+        expect(await repo.get(ref)).toBeNull();
+        const hist = [];
+        for await (const evt of repo.history(ref)) hist.push(evt);
+        expect(hist.map((e) => e.op)).toEqual(["create", "delete"]);
+        expect(hist[1]?.parentHash).toBe(a.version);
+        expect(hist[1]?.hash).toBeNull();
+      });
+      it("can recreate after delete with null parent", async () => {
+        const repo = await factory();
+        const ref = refOf();
+        const a = await repo.put(ref, spec("a"), { parentVersion: null, actor: "t" });
+        await repo.delete(ref, { parentVersion: a.version, actor: "t" });
+        const b = await repo.put(ref, spec("a-redux"), { parentVersion: null, actor: "t" });
+        expect(b.item.parentHash).toBeNull();
+      });
+    });
+    describe("watch / history", () => {
+      it("history yields events in monotonic seq order", async () => {
+        const repo = await factory();
+        const ref = refOf();
+        const a = await repo.put(ref, spec("1"), { parentVersion: null, actor: "t" });
+        const b = await repo.put(ref, spec("2"), { parentVersion: a.version, actor: "t" });
+        const c = await repo.put(ref, spec("3"), { parentVersion: b.version, actor: "t" });
+        const evts = [];
+        for await (const e of repo.history(ref)) evts.push(e);
+        expect(evts.map((e) => e.seq)).toEqual([a.seq, b.seq, c.seq]);
+        expect(evts.every((e, i) => i === 0 || e.seq > evts[i - 1].seq)).toBe(true);
+      });
+      it("watch(sinceSeq) replays subsequent events then goes live", async () => {
+        const repo = await factory();
+        const ref = refOf();
+        const a = await repo.put(ref, spec("1"), { parentVersion: null, actor: "t" });
+        const b = await repo.put(ref, spec("2"), { parentVersion: a.version, actor: "t" });
+        const iter = repo.watch({ org: ref.org }, a.seq);
+        const collected = [];
+        const it2 = iter[Symbol.asyncIterator]();
+        const first = await it2.next();
+        expect(first.done).toBe(false);
+        collected.push(first.value);
+        expect(collected[0].seq).toBe(b.seq);
+        const livePromise = it2.next();
+        const c = await repo.put(ref, spec("3"), { parentVersion: b.version, actor: "t" });
+        const live = await livePromise;
+        expect(live.done).toBe(false);
+        collected.push(live.value);
+        expect(collected[1].seq).toBe(c.seq);
+        await it2.return?.(void 0);
+      });
+      it("watch filters by type and name", async () => {
+        const repo = await factory();
+        await repo.put(refOf({ name: "a" }), spec("a"), { parentVersion: null, actor: "t" });
+        await repo.put(refOf({ name: "b" }), spec("b"), { parentVersion: null, actor: "t" });
+        const events = await take(
+          repo.watch({ org: "system", type: "view", name: "a" }),
+          5,
+          200
+        );
+        expect(events.length).toBe(1);
+        expect(events[0].ref.name).toBe("a");
+      });
+    });
+    describe("list", () => {
+      it("returns headers (no body) for matching items", async () => {
+        const repo = await factory();
+        await repo.put(refOf({ name: "alpha" }), spec("a"), { parentVersion: null, actor: "t" });
+        await repo.put(refOf({ name: "beta" }), spec("b"), { parentVersion: null, actor: "t" });
+        await repo.put(refOf({ type: "object", name: "thing" }), spec("o"), {
+          parentVersion: null,
+          actor: "t"
+        });
+        const headers = [];
+        for await (const h of repo.list({ type: "view" })) headers.push(h);
+        expect(headers.length).toBe(2);
+        for (const h of headers) {
+          expect(h.body).toBeUndefined();
+        }
+      });
+      it("limit clamps result size", async () => {
+        const repo = await factory();
+        for (let i = 0; i < 5; i++) {
+          await repo.put(refOf({ name: `v_${i}` }), spec(`v${i}`), { parentVersion: null, actor: "t" });
+        }
+        const headers = [];
+        for await (const h of repo.list({ type: "view", limit: 3 })) headers.push(h);
+        expect(headers.length).toBe(3);
+      });
+    });
+    if (opts.supportsVersionedReads) {
+      describe("versioned reads", () => {
+        it("get with version pin returns that historical version", async () => {
+          const repo = await factory();
+          const ref = refOf();
+          const a = await repo.put(ref, spec("v1"), { parentVersion: null, actor: "t" });
+          await repo.put(ref, spec("v2"), { parentVersion: a.version, actor: "t" });
+          const pinned = await repo.get({ ...ref, version: a.version });
+          expect(pinned?.hash).toBe(a.version);
+          expect(pinned?.body).toEqual(spec("v1"));
+        });
+      });
+    }
+  });
+}
+export {
+  runRepositoryContractTests
+};
+//# sourceMappingURL=testing.js.map

package/dist/testing.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/contract-suite.ts"],"sourcesContent":["// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Parameterised Repository contract test suite. Every `MetadataRepository`\n * implementation MUST pass this suite. Reuse:\n *\n *     import { runRepositoryContractTests } from '@objectstack/metadata-core/test';\n *     runRepositoryContractTests('InMemory', () => new InMemoryRepository());\n *\n * The suite verifies the seven invariants from `repository.ts`:\n *\n *   1. Atomic put\n *   2. Monotonic seq per branch\n *   3. Optimistic locking (ConflictError)\n *   4. Canonical hashing (hash === hashSpec(body))\n *   5. Event ordering (monotonic seq, no gaps)\n *   6. Resumability (watch with `since` replays)\n *   7. Tombstones (delete event emitted, get returns null)\n */\n\nimport { describe, it, expect } from 'vitest';\nimport type { MetadataRepository } from './repository.js';\nimport type { MetaRef, MetadataEvent } from './types.js';\nimport { hashSpec } from './canonicalize.js';\nimport { ConflictError } from './errors.js';\n\nexport interface ContractSuiteOptions {\n  /** If the implementation supports `version`-pinned reads, set true. */\n  supportsVersionedReads?: boolean;\n}\n\nconst refOf = (overrides: Partial<MetaRef> = {}): MetaRef => ({\n  org: 'system',\n  type: 'view',\n  name: 'sample_view',\n  ...overrides,\n});\n\nconst spec = (label: string) => ({ label, columns: ['a', 'b'] });\n\n/** Drain at most `n` events from an async iterable with a timeout. */\nasync function take<T>(iter: AsyncIterable<T>, n: number, timeoutMs = 1000): Promise<T[]> {\n  const out: T[] = [];\n  const it = iter[Symbol.asyncIterator]();\n  const deadline = Date.now() + timeoutMs;\n  while (out.length < n) {\n    const remaining = deadline - Date.now();\n    if (remaining <= 0) break;\n    const result = await Promise.race([\n      it.next(),\n      new Promise<{ value: undefined; done: true }>((resolve) =>\n        setTimeout(() => resolve({ value: undefined, done: true }), remaining),\n      ),\n    ]);\n    if (result.done) break;\n    out.push(result.value as T);\n  }\n  // Close the iterator so the repo subscriber is freed.\n  await it.return?.(undefined);\n  return out;\n}\n\nexport function runRepositoryContractTests(\n  label: string,\n  factory: () => MetadataRepository | Promise<MetadataRepository>,\n  opts: ContractSuiteOptions = {},\n): void {\n  describe(`MetadataRepository contract — ${label}`, () => {\n    // ── 1. Atomic put + canonical hash ──────────────────────────────\n    describe('put / get', () => {\n      it('creates an item from null parent', async () => {\n        const repo = await factory();\n        const ref = refOf();\n        const res = await repo.put(ref, spec('hello'), { parentVersion: null, actor: 'tester' });\n        expect(res.version).toMatch(/^sha256:[0-9a-f]{64}$/);\n        expect(res.version).toBe(hashSpec(spec('hello')));\n        expect(res.seq).toBeGreaterThan(0);\n        expect(res.item.parentHash).toBeNull();\n        expect(res.item.authoredBy).toBe('tester');\n\n        const got = await repo.get(ref);\n        expect(got).not.toBeNull();\n        expect(got!.hash).toBe(res.version);\n        expect(got!.body).toEqual(spec('hello'));\n      });\n\n      it('round-trips successive updates with parent chaining', async () => {\n        const repo = await factory();\n        const ref = refOf();\n        const a = await repo.put(ref, spec('one'), { parentVersion: null, actor: 't' });\n        const b = await repo.put(ref, spec('two'), { parentVersion: a.version, actor: 't' });\n        const c = await repo.put(ref, spec('three'), { parentVersion: b.version, actor: 't' });\n        expect(b.item.parentHash).toBe(a.version);\n        expect(c.item.parentHash).toBe(b.version);\n        expect(c.seq).toBeGreaterThan(b.seq);\n        expect(b.seq).toBeGreaterThan(a.seq);\n      });\n\n      it('canonical hash invariant: item.hash === hashSpec(item.body)', async () => {\n        const repo = await factory();\n        const ref = refOf();\n        await repo.put(ref, { z: 1, a: 2, m: [3, 1, 2] }, { parentVersion: null, actor: 't' });\n        const got = await repo.get(ref);\n        expect(got!.hash).toBe(hashSpec(got!.body));\n      });\n\n      it('returns null for missing item', async () => {\n        const repo = await factory();\n        expect(await repo.get(refOf({ name: 'never_existed' }))).toBeNull();\n      });\n\n      it('no-op write with identical content returns current version', async () => {\n        const repo = await factory();\n        const ref = refOf();\n        const a = await repo.put(ref, spec('same'), { parentVersion: null, actor: 't' });\n        const b = await repo.put(ref, spec('same'), { parentVersion: a.version, actor: 't' });\n        expect(b.version).toBe(a.version);\n        expect(b.seq).toBe(a.seq);\n      });\n    });\n\n    // ── 2 & 3. Optimistic locking + Monotonic seq ───────────────────\n    describe('optimistic locking', () => {\n      it('throws ConflictError when parentVersion mismatches', async () => {\n        const repo = await factory();\n        const ref = refOf();\n        const a = await repo.put(ref, spec('v1'), { parentVersion: null, actor: 't' });\n        await expect(\n          repo.put(ref, spec('v2'), { parentVersion: null, actor: 't' }),\n        ).rejects.toBeInstanceOf(ConflictError);\n        await expect(\n          repo.put(ref, spec('v2'), { parentVersion: 'sha256:deadbeef'.padEnd(71, '0'), actor: 't' }),\n        ).rejects.toBeInstanceOf(ConflictError);\n        // Sanity: correct parent succeeds.\n        await expect(\n          repo.put(ref, spec('v2'), { parentVersion: a.version, actor: 't' }),\n        ).resolves.toMatchObject({ seq: expect.any(Number) });\n      });\n\n      it('throws ConflictError when creating over an existing item with null parent', async () => {\n        const repo = await factory();\n        const ref = refOf();\n        await repo.put(ref, spec('a'), { parentVersion: null, actor: 't' });\n        await expect(\n          repo.put(ref, spec('b'), { parentVersion: null, actor: 't' }),\n        ).rejects.toBeInstanceOf(ConflictError);\n      });\n\n      it('delete requires correct parentVersion', async () => {\n        const repo = await factory();\n        const ref = refOf();\n        const a = await repo.put(ref, spec('a'), { parentVersion: null, actor: 't' });\n        await expect(\n          repo.delete(ref, { parentVersion: 'sha256:wrong'.padEnd(71, '0'), actor: 't' }),\n        ).rejects.toBeInstanceOf(ConflictError);\n        await repo.delete(ref, { parentVersion: a.version, actor: 't' });\n      });\n    });\n\n    describe('monotonic seq per org', () => {\n      it('seq strictly increases within an org', async () => {\n        const repo = await factory();\n        const ref = refOf();\n        const a = await repo.put(ref, spec('1'), { parentVersion: null, actor: 't' });\n        const b = await repo.put(ref, spec('2'), { parentVersion: a.version, actor: 't' });\n        const c = await repo.put(refOf({ name: 'other' }), spec('o'), { parentVersion: null, actor: 't' });\n        expect(b.seq).toBeGreaterThan(a.seq);\n        expect(c.seq).toBeGreaterThan(b.seq);\n      });\n\n      it('different orgs have independent sequences', async () => {\n        const repo = await factory();\n        const orgA = refOf({ org: 'org_a' });\n        const orgB = refOf({ org: 'org_b' });\n        // Some backends (FileSystemRepository) are scoped to a single\n        // org; for those any foreign-org put throws — skip the test.\n        let a: { seq: number; version: string };\n        let b: { seq: number; version: string };\n        try {\n          a = await repo.put(orgA, spec('a1'), { parentVersion: null, actor: 't' });\n          b = await repo.put(orgB, spec('b1'), { parentVersion: null, actor: 't' });\n        } catch {\n          return;\n        }\n        const c = await repo.put(orgA, spec('a2'), { parentVersion: a.version, actor: 't' });\n        const d = await repo.put(orgB, spec('b2'), { parentVersion: b.version, actor: 't' });\n        expect(c.seq).toBeGreaterThan(a.seq);\n        expect(d.seq).toBeGreaterThan(b.seq);\n      });\n    });\n\n    // ── 4. Tombstones ───────────────────────────────────────────────\n    describe('delete / tombstones', () => {\n      it('get returns null after delete; history retains lineage', async () => {\n        const repo = await factory();\n        const ref = refOf();\n        const a = await repo.put(ref, spec('a'), { parentVersion: null, actor: 't' });\n        await repo.delete(ref, { parentVersion: a.version, actor: 't' });\n        expect(await repo.get(ref)).toBeNull();\n        const hist: MetadataEvent[] = [];\n        for await (const evt of repo.history(ref)) hist.push(evt);\n        expect(hist.map((e) => e.op)).toEqual(['create', 'delete']);\n        expect(hist[1]?.parentHash).toBe(a.version);\n        expect(hist[1]?.hash).toBeNull();\n      });\n\n      it('can recreate after delete with null parent', async () => {\n        const repo = await factory();\n        const ref = refOf();\n        const a = await repo.put(ref, spec('a'), { parentVersion: null, actor: 't' });\n        await repo.delete(ref, { parentVersion: a.version, actor: 't' });\n        const b = await repo.put(ref, spec('a-redux'), { parentVersion: null, actor: 't' });\n        expect(b.item.parentHash).toBeNull();\n      });\n    });\n\n    // ── 5. Event ordering & watch replay ────────────────────────────\n    describe('watch / history', () => {\n      it('history yields events in monotonic seq order', async () => {\n        const repo = await factory();\n        const ref = refOf();\n        const a = await repo.put(ref, spec('1'), { parentVersion: null, actor: 't' });\n        const b = await repo.put(ref, spec('2'), { parentVersion: a.version, actor: 't' });\n        const c = await repo.put(ref, spec('3'), { parentVersion: b.version, actor: 't' });\n        const evts: MetadataEvent[] = [];\n        for await (const e of repo.history(ref)) evts.push(e);\n        expect(evts.map((e) => e.seq)).toEqual([a.seq, b.seq, c.seq]);\n        expect(evts.every((e, i) => i === 0 || e.seq > evts[i - 1]!.seq)).toBe(true);\n      });\n\n      it('watch(sinceSeq) replays subsequent events then goes live', async () => {\n        const repo = await factory();\n        const ref = refOf();\n        const a = await repo.put(ref, spec('1'), { parentVersion: null, actor: 't' });\n        const b = await repo.put(ref, spec('2'), { parentVersion: a.version, actor: 't' });\n\n        // Start watching with `since = a.seq` — must replay b, then deliver a live event.\n        const iter = repo.watch({ org: ref.org }, a.seq);\n        const collected: MetadataEvent[] = [];\n        const it = iter[Symbol.asyncIterator]();\n\n        // First yield should be the replay of `b`.\n        const first = await it.next();\n        expect(first.done).toBe(false);\n        collected.push(first.value as MetadataEvent);\n        expect(collected[0]!.seq).toBe(b.seq);\n\n        // Now trigger a live event and collect it.\n        const livePromise = it.next();\n        const c = await repo.put(ref, spec('3'), { parentVersion: b.version, actor: 't' });\n        const live = await livePromise;\n        expect(live.done).toBe(false);\n        collected.push(live.value as MetadataEvent);\n        expect(collected[1]!.seq).toBe(c.seq);\n\n        await it.return?.(undefined);\n      });\n\n      it('watch filters by type and name', async () => {\n        const repo = await factory();\n        await repo.put(refOf({ name: 'a' }), spec('a'), { parentVersion: null, actor: 't' });\n        await repo.put(refOf({ name: 'b' }), spec('b'), { parentVersion: null, actor: 't' });\n        const events = await take(\n          repo.watch({ org: 'system', type: 'view', name: 'a' }),\n          5,\n          200,\n        );\n        expect(events.length).toBe(1);\n        expect(events[0]!.ref.name).toBe('a');\n      });\n    });\n\n    // ── list ────────────────────────────────────────────────────────\n    describe('list', () => {\n      it('returns headers (no body) for matching items', async () => {\n        const repo = await factory();\n        await repo.put(refOf({ name: 'alpha' }), spec('a'), { parentVersion: null, actor: 't' });\n        await repo.put(refOf({ name: 'beta' }), spec('b'), { parentVersion: null, actor: 't' });\n        await repo.put(refOf({ type: 'object', name: 'thing' }), spec('o'), {\n          parentVersion: null,\n          actor: 't',\n        });\n        const headers: unknown[] = [];\n        for await (const h of repo.list({ type: 'view' })) headers.push(h);\n        expect(headers.length).toBe(2);\n        for (const h of headers) {\n          expect((h as { body?: unknown }).body).toBeUndefined();\n        }\n      });\n\n      it('limit clamps result size', async () => {\n        const repo = await factory();\n        for (let i = 0; i < 5; i++) {\n          await repo.put(refOf({ name: `v_${i}` }), spec(`v${i}`), { parentVersion: null, actor: 't' });\n        }\n        const headers: unknown[] = [];\n        for await (const h of repo.list({ type: 'view', limit: 3 })) headers.push(h);\n        expect(headers.length).toBe(3);\n      });\n    });\n\n    // ── Optional behaviour ──────────────────────────────────────────\n    if (opts.supportsVersionedReads) {\n      describe('versioned reads', () => {\n        it('get with version pin returns that historical version', async () => {\n          const repo = await factory();\n          const ref = refOf();\n          const a = await repo.put(ref, spec('v1'), { parentVersion: null, actor: 't' });\n          await repo.put(ref, spec('v2'), { parentVersion: a.version, actor: 't' });\n          const pinned = await repo.get({ ...ref, version: a.version });\n          expect(pinned?.hash).toBe(a.version);\n          expect(pinned?.body).toEqual(spec('v1'));\n        });\n      });\n    }\n  });\n}\n"],"mappings":"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","names":["it"]}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@objectstack/metadata-core",
+  "version": "5.0.0",
+  "license": "Apache-2.0",
+  "description": "Metadata Repository contracts: types, canonicalization, errors, interface (ADR-0008).",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./testing": {
+      "types": "./dist/testing.d.ts",
+      "import": "./dist/testing.js",
+      "require": "./dist/testing.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "objectstack",
+    "metadata",
+    "repository",
+    "change-log"
+  ],
+  "dependencies": {
+    "zod": "^4.4.3"
+  },
+  "peerDependencies": {
+    "vitest": "^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "vitest": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.1",
+    "fast-check": "^4.8.0",
+    "tsup": "^8.5.1",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.7"
+  },
+  "author": "ObjectStack",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/objectstack-ai/framework.git",
+    "directory": "packages/metadata-core"
+  },
+  "homepage": "https://objectstack.ai/docs",
+  "bugs": "https://github.com/objectstack-ai/framework/issues",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}