sh3-core 0.8.2 → 0.9.0

package/dist/documents/sync/journal.js

@@ -1,179 +0,0 @@
-/*
- * Change journal for the sync subsystem.
- *
- * Append-only per-tenant sequence of JournalEntry, stored as JSON
- * segments under journal/<n>.json. Cursors are opaque "<seq>:<version>"
- * strings; version matches the journal's truncation epoch. A cursor with
- * an older version whose seq < oldestSeq means the connector has fallen
- * behind retained history.
- */
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Journal_meta, _Journal_segmentSize, _Journal_pageSize;
-import { readJson, writeJson, deletePath, listJsonPaths } from './serialization';
-const META_PATH = 'journal/meta.json';
-const SEGMENT_PREFIX = 'journal/seg-';
-const CURSOR_PREFIX = 'cursors/';
-const DEFAULT_SEGMENT_SIZE = 500;
-const DEFAULT_PAGE_SIZE = 100;
-function segmentPath(i) {
-    return `${SEGMENT_PREFIX}${i}.json`;
-}
-function cursorPath(connectorId) {
-    return `${CURSOR_PREFIX}${encodeURIComponent(connectorId)}.json`;
-}
-function matchesScope(entry, scope) {
-    switch (scope.kind) {
-        case 'tenant': return true;
-        case 'shard': return entry.shardId === scope.shardId;
-        case 'path': return entry.shardId === scope.shardId && entry.path.startsWith(scope.prefix);
-    }
-}
-export class Journal {
-    constructor(backend, tenantId, opts = {}) {
-        var _a, _b;
-        this.backend = backend;
-        this.tenantId = tenantId;
-        _Journal_meta.set(this, { currentSeq: 0, currentSegment: 0, oldestSegment: 0, version: 0 });
-        _Journal_segmentSize.set(this, void 0);
-        _Journal_pageSize.set(this, void 0);
-        __classPrivateFieldSet(this, _Journal_segmentSize, (_a = opts.segmentSize) !== null && _a !== void 0 ? _a : DEFAULT_SEGMENT_SIZE, "f");
-        __classPrivateFieldSet(this, _Journal_pageSize, (_b = opts.pageSize) !== null && _b !== void 0 ? _b : DEFAULT_PAGE_SIZE, "f");
-    }
-    async init() {
-        const meta = await readJson(this.backend, this.tenantId, META_PATH);
-        if (meta)
-            __classPrivateFieldSet(this, _Journal_meta, meta, "f");
-    }
-    static encodeCursor(seq, version) {
-        return `${seq}:${version}`;
-    }
-    static decodeCursor(cursor) {
-        const m = /^(\d+):(\d+)$/.exec(cursor);
-        if (!m)
-            return null;
-        return { seq: Number(m[1]), version: Number(m[2]) };
-    }
-    async append(entry) {
-        var _a;
-        const seq = __classPrivateFieldGet(this, _Journal_meta, "f").currentSeq + 1;
-        const full = Object.assign(Object.assign({}, entry), { seq, ts: Date.now() });
-        const segIdx = __classPrivateFieldGet(this, _Journal_meta, "f").currentSegment;
-        const current = (_a = (await readJson(this.backend, this.tenantId, segmentPath(segIdx)))) !== null && _a !== void 0 ? _a : [];
-        current.push(full);
-        await writeJson(this.backend, this.tenantId, segmentPath(segIdx), current);
-        __classPrivateFieldGet(this, _Journal_meta, "f").currentSeq = seq;
-        if (current.length >= __classPrivateFieldGet(this, _Journal_segmentSize, "f")) {
-            __classPrivateFieldGet(this, _Journal_meta, "f").currentSegment = segIdx + 1;
-        }
-        await writeJson(this.backend, this.tenantId, META_PATH, __classPrivateFieldGet(this, _Journal_meta, "f"));
-        return full;
-    }
-    async oldestRetainedSeq() {
-        const first = await readJson(this.backend, this.tenantId, segmentPath(__classPrivateFieldGet(this, _Journal_meta, "f").oldestSegment));
-        if (!first || first.length === 0)
-            return 0;
-        return first[0].seq;
-    }
-    async changesSince(scope, cursor) {
-        var _a;
-        let startSeq = 0;
-        if (cursor) {
-            const decoded = Journal.decodeCursor(cursor);
-            if (!decoded)
-                return { entries: [], nextCursor: cursor, hasMore: false };
-            const oldest = await this.oldestRetainedSeq();
-            if (decoded.version < __classPrivateFieldGet(this, _Journal_meta, "f").version && decoded.seq < oldest) {
-                return { entries: [], nextCursor: cursor, hasMore: false, truncated: true };
-            }
-            startSeq = decoded.seq;
-        }
-        const out = [];
-        let lastSeq = startSeq;
-        let hasMore = false;
-        for (let seg = __classPrivateFieldGet(this, _Journal_meta, "f").oldestSegment; seg <= __classPrivateFieldGet(this, _Journal_meta, "f").currentSegment; seg++) {
-            const entries = (_a = (await readJson(this.backend, this.tenantId, segmentPath(seg)))) !== null && _a !== void 0 ? _a : [];
-            for (const e of entries) {
-                if (e.seq <= startSeq)
-                    continue;
-                if (!matchesScope(e, scope)) {
-                    lastSeq = e.seq;
-                    continue;
-                }
-                if (out.length >= __classPrivateFieldGet(this, _Journal_pageSize, "f")) {
-                    hasMore = true;
-                    break;
-                }
-                out.push(e);
-                lastSeq = e.seq;
-            }
-            if (hasMore)
-                break;
-        }
-        return {
-            entries: out,
-            nextCursor: Journal.encodeCursor(lastSeq, __classPrivateFieldGet(this, _Journal_meta, "f").version),
-            hasMore,
-        };
-    }
-    async getCursor(connectorId) {
-        return readJson(this.backend, this.tenantId, cursorPath(connectorId));
-    }
-    async ackCursor(connectorId, cursor) {
-        await writeJson(this.backend, this.tenantId, cursorPath(connectorId), cursor);
-    }
-    async dropCursor(connectorId) {
-        await deletePath(this.backend, this.tenantId, cursorPath(connectorId));
-    }
-    async listCursors() {
-        const paths = await listJsonPaths(this.backend, this.tenantId, CURSOR_PREFIX);
-        const out = [];
-        for (const p of paths) {
-            const cursor = await readJson(this.backend, this.tenantId, p);
-            if (cursor === null)
-                continue;
-            const id = decodeURIComponent(p.slice(CURSOR_PREFIX.length, -'.json'.length));
-            out.push({ connectorId: id, cursor });
-        }
-        return out;
-    }
-    async minSeqAckedByAll(connectorIds) {
-        if (connectorIds.length === 0)
-            return 0;
-        let min = Infinity;
-        for (const id of connectorIds) {
-            const c = await this.getCursor(id);
-            const decoded = c ? Journal.decodeCursor(c) : null;
-            const seq = decoded ? decoded.seq : 0;
-            if (seq < min)
-                min = seq;
-        }
-        return min === Infinity ? 0 : min;
-    }
-    /** Test-only: simulate truncating all segments whose entries are <= uptoSeq. */
-    async __truncateForTest(uptoSeq) {
-        var _a;
-        for (let seg = __classPrivateFieldGet(this, _Journal_meta, "f").oldestSegment; seg <= __classPrivateFieldGet(this, _Journal_meta, "f").currentSegment; seg++) {
-            const entries = (_a = (await readJson(this.backend, this.tenantId, segmentPath(seg)))) !== null && _a !== void 0 ? _a : [];
-            const last = entries[entries.length - 1];
-            if (last && last.seq <= uptoSeq) {
-                await deletePath(this.backend, this.tenantId, segmentPath(seg));
-                __classPrivateFieldGet(this, _Journal_meta, "f").oldestSegment = seg + 1;
-            }
-            else
-                break;
-        }
-        __classPrivateFieldGet(this, _Journal_meta, "f").version += 1;
-        await writeJson(this.backend, this.tenantId, META_PATH, __classPrivateFieldGet(this, _Journal_meta, "f"));
-    }
-}
-_Journal_meta = new WeakMap(), _Journal_segmentSize = new WeakMap(), _Journal_pageSize = new WeakMap();

package/dist/documents/sync/journal.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/documents/sync/journal.test.js

@@ -1,87 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { MemoryDocumentBackend } from '../backends';
-import { Journal } from './journal';
-describe('Journal', () => {
-    let backend;
-    let journal;
-    beforeEach(async () => {
-        backend = new MemoryDocumentBackend();
-        journal = new Journal(backend, 'tenant-a', { segmentSize: 3 });
-        await journal.init();
-    });
-    it('starts with no entries', async () => {
-        const page = await journal.changesSince({ kind: 'tenant' });
-        expect(page.entries).toEqual([]);
-        expect(page.hasMore).toBe(false);
-    });
-    it('appends and reads entries', async () => {
-        await journal.append({ shardId: 's1', path: 'a.md', op: 'upsert', hash: 'h1' });
-        await journal.append({ shardId: 's1', path: 'b.md', op: 'upsert', hash: 'h2' });
-        const page = await journal.changesSince({ kind: 'tenant' });
-        expect(page.entries.map((e) => e.path)).toEqual(['a.md', 'b.md']);
-        expect(page.entries[0].seq).toBe(1);
-        expect(page.entries[1].seq).toBe(2);
-    });
-    it('filters by shard scope', async () => {
-        await journal.append({ shardId: 's1', path: 'a.md', op: 'upsert', hash: 'h1' });
-        await journal.append({ shardId: 's2', path: 'b.md', op: 'upsert', hash: 'h2' });
-        const scoped = { kind: 'shard', shardId: 's1' };
-        const page = await journal.changesSince(scoped);
-        expect(page.entries.map((e) => e.path)).toEqual(['a.md']);
-    });
-    it('filters by path prefix', async () => {
-        await journal.append({ shardId: 's1', path: 'docs/x.md', op: 'upsert', hash: 'h1' });
-        await journal.append({ shardId: 's1', path: 'notes/y.md', op: 'upsert', hash: 'h2' });
-        const scoped = { kind: 'path', shardId: 's1', prefix: 'docs/' };
-        const page = await journal.changesSince(scoped);
-        expect(page.entries.map((e) => e.path)).toEqual(['docs/x.md']);
-    });
-    it('resumes from a cursor', async () => {
-        for (let i = 0; i < 5; i++) {
-            await journal.append({ shardId: 's1', path: `f${i}.md`, op: 'upsert', hash: `h${i}` });
-        }
-        const first = await journal.changesSince({ kind: 'tenant' });
-        // Walk through pages until end.
-        let cursor = first.nextCursor;
-        const seen = [...first.entries];
-        let hasMore = first.hasMore;
-        while (hasMore) {
-            const next = await journal.changesSince({ kind: 'tenant' }, cursor);
-            seen.push(...next.entries);
-            cursor = next.nextCursor;
-            hasMore = next.hasMore;
-        }
-        expect(seen.map((e) => e.seq)).toEqual([1, 2, 3, 4, 5]);
-    });
-    it('persists cursors per connector and returns only new entries after ack', async () => {
-        await journal.append({ shardId: 's1', path: 'a.md', op: 'upsert', hash: 'h1' });
-        const p1 = await journal.changesSince({ kind: 'tenant' });
-        await journal.ackCursor('conn-A', p1.nextCursor);
-        await journal.append({ shardId: 's1', path: 'b.md', op: 'upsert', hash: 'h2' });
-        const saved = await journal.getCursor('conn-A');
-        const p2 = await journal.changesSince({ kind: 'tenant' }, saved !== null && saved !== void 0 ? saved : undefined);
-        expect(p2.entries.map((e) => e.path)).toEqual(['b.md']);
-    });
-    it('reports truncated=true when a cursor predates oldest retained seq', async () => {
-        // Force many segments then truncate
-        for (let i = 0; i < 10; i++) {
-            await journal.append({ shardId: 's1', path: `f${i}.md`, op: 'upsert', hash: `h${i}` });
-        }
-        // Simulate truncation up to seq 6.
-        await journal.__truncateForTest(6);
-        const stale = Journal.encodeCursor(2, 0); // old version
-        const page = await journal.changesSince({ kind: 'tenant' }, stale);
-        expect(page.truncated).toBe(true);
-        expect(page.entries).toEqual([]);
-    });
-    it('minSeqAckedByAll returns the lowest acked seq across registered cursors', async () => {
-        await journal.append({ shardId: 's1', path: 'a.md', op: 'upsert', hash: 'h1' });
-        await journal.append({ shardId: 's1', path: 'b.md', op: 'upsert', hash: 'h2' });
-        await journal.append({ shardId: 's1', path: 'c.md', op: 'upsert', hash: 'h3' });
-        await journal.ackCursor('conn-A', Journal.encodeCursor(3, 0));
-        await journal.ackCursor('conn-B', Journal.encodeCursor(1, 0));
-        expect(await journal.minSeqAckedByAll(['conn-A', 'conn-B'])).toBe(1);
-        expect(await journal.minSeqAckedByAll(['conn-A'])).toBe(3);
-        expect(await journal.minSeqAckedByAll([])).toBe(0);
-    });
-});

package/dist/documents/sync/observer.d.ts

@@ -1,3 +0,0 @@
-import type { DocumentBackend } from '../types';
-import type { SyncRegistry } from './registry';
-export declare function createSyncRegistryAccessor(backend: DocumentBackend, tenantId: string): () => SyncRegistry;

package/dist/documents/sync/observer.js

@@ -1,45 +0,0 @@
-/*
- * Observer factory for ctx.syncRegistry.
- *
- * Returns a lazy accessor that resolves to the same SyncRegistry instance
- * backed by the per-tenant sync bundle. Observer-class shards (e.g. the
- * file-explorer) and connector shards share one view of grants and
- * conflicts.
- *
- * Gated upstream on the 'documents:browse' permission — granting remains
- * exclusive to <SyncGrantPicker />.
- */
-import { getSyncBundle } from './singleton';
-export function createSyncRegistryAccessor(backend, tenantId) {
-    let cached = null;
-    let initPromise = null;
-    function resolve() {
-        if (cached)
-            return Promise.resolve(cached);
-        if (!initPromise) {
-            initPromise = getSyncBundle(backend, tenantId).then(({ registry }) => {
-                cached = registry;
-                return registry;
-            });
-        }
-        return initPromise;
-    }
-    return () => {
-        const proxy = {
-            async list(connectorId) {
-                return (await resolve()).list(connectorId);
-            },
-            async revoke(connectorId, scope) {
-                return (await resolve()).revoke(connectorId, scope);
-            },
-            listConflicts: (async (shardId) => {
-                const r = await resolve();
-                return shardId === undefined ? r.listConflicts() : r.listConflicts(shardId);
-            }),
-            async listAllConnectorIds() {
-                return (await resolve()).listAllConnectorIds();
-            },
-        };
-        return proxy;
-    };
-}

package/dist/documents/sync/registry.d.ts

@@ -1,13 +0,0 @@
-import type { DocumentBackend } from '../types';
-import type { ConflictResolution, GrantRecord, SyncScope } from './types';
-export declare function __grantInternal(backend: DocumentBackend, tenantId: string, connectorId: string, scope: SyncScope): Promise<void>;
-export interface SyncRegistry {
-    list(connectorId?: string): Promise<GrantRecord[]>;
-    revoke(connectorId: string, scope: SyncScope): Promise<void>;
-    /** Per-shard conflict enumeration. */
-    listConflicts(shardId: string): Promise<ConflictResolution[]>;
-    /** Tenant-wide conflict enumeration (fans out over every shard). */
-    listConflicts(): Promise<ConflictResolution[]>;
-    listAllConnectorIds(): Promise<string[]>;
-}
-export declare function createSyncRegistry(backend: DocumentBackend, tenantId: string): SyncRegistry;

package/dist/documents/sync/registry.js

@@ -1,73 +0,0 @@
-/*
- * Grant registry — public surface (revoke/list/listConflicts) for
- * connectors, plus __grantInternal used only by the core-owned
- * SyncGrantPicker component. Connectors do not import __grantInternal.
- */
-import { readJson, writeJson, deletePath, listJsonPaths } from './serialization';
-import { ConflictManager } from './conflicts';
-const GRANTS_PREFIX = 'grants/';
-function grantPath(connectorId) {
-    return `${GRANTS_PREFIX}${encodeURIComponent(connectorId)}.json`;
-}
-function scopesEqual(a, b) {
-    if (a.kind !== b.kind)
-        return false;
-    if (a.kind === 'tenant')
-        return true;
-    if (a.kind === 'shard' && b.kind === 'shard')
-        return a.shardId === b.shardId;
-    if (a.kind === 'path' && b.kind === 'path')
-        return a.shardId === b.shardId && a.prefix === b.prefix;
-    return false;
-}
-export async function __grantInternal(backend, tenantId, connectorId, scope) {
-    var _a;
-    const existing = (_a = (await readJson(backend, tenantId, grantPath(connectorId)))) !== null && _a !== void 0 ? _a : [];
-    if (existing.some((g) => scopesEqual(g.scope, scope)))
-        return;
-    existing.push({ connectorId, scope, grantedAt: Date.now() });
-    await writeJson(backend, tenantId, grantPath(connectorId), existing);
-}
-export function createSyncRegistry(backend, tenantId) {
-    const conflicts = new ConflictManager(backend, tenantId);
-    async function readGrants(connectorId) {
-        var _a;
-        return (_a = (await readJson(backend, tenantId, grantPath(connectorId)))) !== null && _a !== void 0 ? _a : [];
-    }
-    return {
-        async list(connectorId) {
-            if (connectorId)
-                return readGrants(connectorId);
-            const paths = await listJsonPaths(backend, tenantId, GRANTS_PREFIX);
-            const out = [];
-            for (const p of paths) {
-                const arr = await readJson(backend, tenantId, p);
-                if (arr)
-                    out.push(...arr);
-            }
-            return out;
-        },
-        async revoke(connectorId, scope) {
-            const grants = await readGrants(connectorId);
-            const next = grants.filter((g) => !scopesEqual(g.scope, scope));
-            if (next.length === 0)
-                await deletePath(backend, tenantId, grantPath(connectorId));
-            else
-                await writeJson(backend, tenantId, grantPath(connectorId), next);
-        },
-        async listConflicts(shardId) {
-            if (shardId !== undefined)
-                return conflicts.listConflicts(shardId);
-            const shards = await backend.listAllShards(tenantId);
-            const out = [];
-            for (const s of shards) {
-                out.push(...(await conflicts.listConflicts(s)));
-            }
-            return out;
-        },
-        async listAllConnectorIds() {
-            const paths = await listJsonPaths(backend, tenantId, GRANTS_PREFIX);
-            return paths.map((p) => decodeURIComponent(p.slice(GRANTS_PREFIX.length, -'.json'.length)));
-        },
-    };
-}

package/dist/documents/sync/registry.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/documents/sync/registry.test.js

@@ -1,53 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { MemoryDocumentBackend } from '../backends';
-import { createSyncRegistry, __grantInternal } from './registry';
-describe('syncRegistry', () => {
-    let backend;
-    let reg;
-    beforeEach(() => {
-        backend = new MemoryDocumentBackend();
-        reg = createSyncRegistry(backend, 'tenant-a');
-    });
-    it('list returns [] when nothing granted', async () => {
-        expect(await reg.list()).toEqual([]);
-    });
-    it('__grantInternal records and list returns it', async () => {
-        vi.useFakeTimers().setSystemTime(new Date(1000));
-        await __grantInternal(backend, 'tenant-a', 'conn-A', { kind: 'tenant' });
-        const all = await reg.list();
-        expect(all).toEqual([
-            { connectorId: 'conn-A', scope: { kind: 'tenant' }, grantedAt: 1000 },
-        ]);
-        vi.useRealTimers();
-    });
-    it('list filters by connectorId', async () => {
-        await __grantInternal(backend, 'tenant-a', 'conn-A', { kind: 'shard', shardId: 's1' });
-        await __grantInternal(backend, 'tenant-a', 'conn-B', { kind: 'tenant' });
-        const a = await reg.list('conn-A');
-        expect(a).toHaveLength(1);
-        expect(a[0].connectorId).toBe('conn-A');
-    });
-    it('revoke removes one scope, leaving other grants intact', async () => {
-        await __grantInternal(backend, 'tenant-a', 'conn-A', { kind: 'shard', shardId: 's1' });
-        await __grantInternal(backend, 'tenant-a', 'conn-A', { kind: 'shard', shardId: 's2' });
-        await reg.revoke('conn-A', { kind: 'shard', shardId: 's1' });
-        const all = await reg.list('conn-A');
-        expect(all.map((g) => g.scope.shardId)).toEqual(['s2']);
-    });
-    it('__grantInternal is idempotent for same scope', async () => {
-        await __grantInternal(backend, 'tenant-a', 'conn-A', { kind: 'tenant' });
-        await __grantInternal(backend, 'tenant-a', 'conn-A', { kind: 'tenant' });
-        expect((await reg.list('conn-A')).length).toBe(1);
-    });
-    it('listConflicts() with no args returns conflicts across all shards', async () => {
-        var _a, _b;
-        // Seed conflict artifacts directly via the backend (matches
-        // ConflictManager's artifact naming).
-        await backend.write('tenant-a', 'shard-a', 'doc.md.sync-conflict-connA-111', 'remote-a');
-        await backend.write('tenant-a', 'shard-b', 'other.md.sync-conflict-connB-222', 'remote-b');
-        const all = await reg.listConflicts();
-        expect(all.map((c) => c.shardId).sort()).toEqual(['shard-a', 'shard-b']);
-        expect((_a = all.find((c) => c.shardId === 'shard-a')) === null || _a === void 0 ? void 0 : _a.path).toBe('doc.md');
-        expect((_b = all.find((c) => c.shardId === 'shard-b')) === null || _b === void 0 ? void 0 : _b.path).toBe('other.md');
-    });
-});

package/dist/documents/sync/serialization.d.ts

@@ -1,5 +0,0 @@
-import type { DocumentBackend } from '../types';
-export declare function readJson<T>(backend: DocumentBackend, tenantId: string, path: string): Promise<T | null>;
-export declare function writeJson(backend: DocumentBackend, tenantId: string, path: string, value: unknown): Promise<void>;
-export declare function deletePath(backend: DocumentBackend, tenantId: string, path: string): Promise<void>;
-export declare function listJsonPaths(backend: DocumentBackend, tenantId: string, prefix: string): Promise<string[]>;

package/dist/documents/sync/serialization.js

@@ -1,24 +0,0 @@
-/*
- * JSON storage helpers on top of DocumentBackend. All sync metadata
- * lives under the reserved shardId SYNC_RESERVED_SHARD_ID, scoped per
- * tenant by the backend. Callers pass tenantId explicitly; tenant
- * scoping is enforced at the SyncHandle/engine layer.
- */
-import { SYNC_RESERVED_SHARD_ID } from './types';
-export async function readJson(backend, tenantId, path) {
-    const raw = await backend.read(tenantId, SYNC_RESERVED_SHARD_ID, path);
-    if (raw === null)
-        return null;
-    const str = typeof raw === 'string' ? raw : new TextDecoder().decode(raw);
-    return JSON.parse(str);
-}
-export async function writeJson(backend, tenantId, path, value) {
-    await backend.write(tenantId, SYNC_RESERVED_SHARD_ID, path, JSON.stringify(value));
-}
-export async function deletePath(backend, tenantId, path) {
-    await backend.delete(tenantId, SYNC_RESERVED_SHARD_ID, path);
-}
-export async function listJsonPaths(backend, tenantId, prefix) {
-    const all = await backend.list(tenantId, SYNC_RESERVED_SHARD_ID);
-    return all.map((m) => m.path).filter((p) => p.startsWith(prefix));
-}

package/dist/documents/sync/serialization.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/documents/sync/serialization.test.js

@@ -1,26 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { MemoryDocumentBackend } from '../backends';
-import { readJson, writeJson, listJsonPaths } from './serialization';
-import { SYNC_RESERVED_SHARD_ID } from './types';
-describe('sync serialization', () => {
-    let backend;
-    beforeEach(() => { backend = new MemoryDocumentBackend(); });
-    it('writes and reads JSON round-trip', async () => {
-        await writeJson(backend, 'tenant-a', 'foo/bar.json', { hello: 'world', n: 7 });
-        const out = await readJson(backend, 'tenant-a', 'foo/bar.json');
-        expect(out).toEqual({ hello: 'world', n: 7 });
-    });
-    it('returns null when a path is absent', async () => {
-        expect(await readJson(backend, 'tenant-a', 'missing.json')).toBeNull();
-    });
-    it('lists JSON paths under a prefix', async () => {
-        await writeJson(backend, 't', 'grants/a.json', { a: 1 });
-        await writeJson(backend, 't', 'grants/b.json', { b: 2 });
-        await writeJson(backend, 't', 'other/c.json', { c: 3 });
-        const paths = await listJsonPaths(backend, 't', 'grants/');
-        expect(paths.sort()).toEqual(['grants/a.json', 'grants/b.json']);
-    });
-    it('uses SYNC_RESERVED_SHARD_ID', () => {
-        expect(SYNC_RESERVED_SHARD_ID).toBe('__sync__');
-    });
-});

package/dist/documents/sync/singleton.d.ts

@@ -1,11 +0,0 @@
-import type { DocumentBackend } from '../types';
-import { SyncEngine } from './engine';
-import { type SyncRegistry } from './registry';
-interface Bundle {
-    engine: SyncEngine;
-    registry: SyncRegistry;
-}
-export declare function getSyncBundle(backend: DocumentBackend, tenantId: string): Promise<Bundle>;
-/** Test-only reset. */
-export declare function __resetSyncBundlesForTest(): void;
-export {};

package/dist/documents/sync/singleton.js

@@ -1,26 +0,0 @@
-/*
- * Per-tenant SyncEngine singleton. Lazily initialised on first
- * ctx.sync() call. The journal appender hook is registered once
- * when the engine is first built so regular shard writes feed
- * the journal for all future connectors.
- */
-import { setJournalAppender } from '../journal-hook';
-import { SyncEngine } from './engine';
-import { createSyncRegistry } from './registry';
-const bundles = new Map();
-export async function getSyncBundle(backend, tenantId) {
-    const existing = bundles.get(tenantId);
-    if (existing)
-        return existing;
-    const engine = new SyncEngine(backend, tenantId);
-    await engine.init();
-    const registry = createSyncRegistry(backend, tenantId);
-    setJournalAppender(async (e) => { await engine.journal.append(e); });
-    const bundle = { engine, registry };
-    bundles.set(tenantId, bundle);
-    return bundle;
-}
-/** Test-only reset. */
-export function __resetSyncBundlesForTest() {
-    bundles.clear();
-}

package/dist/documents/sync/tombstones.d.ts

@@ -1,19 +0,0 @@
-import type { DocumentBackend } from '../types';
-export interface TombstoneRecord {
-    deletedAt: number;
-    lastHash: string;
-}
-export interface TombstoneEntry extends TombstoneRecord {
-    shardId: string;
-    path: string;
-}
-export declare class TombstoneStore {
-    private backend;
-    private tenantId;
-    constructor(backend: DocumentBackend, tenantId: string);
-    record(shardId: string, path: string, lastHash: string, deletedAt: number): Promise<void>;
-    get(shardId: string, path: string): Promise<TombstoneRecord | null>;
-    clear(shardId: string, path: string): Promise<void>;
-    listByShard(shardId: string): Promise<TombstoneEntry[]>;
-    listAll(): Promise<TombstoneEntry[]>;
-}

package/dist/documents/sync/tombstones.js

@@ -1,58 +0,0 @@
-/*
- * Tombstone store — records deletion metadata so sync connectors can
- * distinguish "never existed" from "was deleted." Backed by JSON docs
- * under the reserved sync shardId. GC is driven by the engine, not here.
- */
-import { readJson, writeJson, deletePath, listJsonPaths } from './serialization';
-const PREFIX = 'tombstones/';
-function key(shardId, path) {
-    return `${PREFIX}${shardId}__${encodeURIComponent(path)}.json`;
-}
-export class TombstoneStore {
-    constructor(backend, tenantId) {
-        this.backend = backend;
-        this.tenantId = tenantId;
-    }
-    async record(shardId, path, lastHash, deletedAt) {
-        await writeJson(this.backend, this.tenantId, key(shardId, path), {
-            deletedAt,
-            lastHash,
-        });
-    }
-    async get(shardId, path) {
-        return readJson(this.backend, this.tenantId, key(shardId, path));
-    }
-    async clear(shardId, path) {
-        await deletePath(this.backend, this.tenantId, key(shardId, path));
-    }
-    async listByShard(shardId) {
-        const prefix = `${PREFIX}${shardId}__`;
-        const paths = await listJsonPaths(this.backend, this.tenantId, prefix);
-        const out = [];
-        for (const p of paths) {
-            const rec = await readJson(this.backend, this.tenantId, p);
-            if (!rec)
-                continue;
-            const originalPath = decodeURIComponent(p.slice(prefix.length, -'.json'.length));
-            out.push(Object.assign({ shardId, path: originalPath }, rec));
-        }
-        return out;
-    }
-    async listAll() {
-        const paths = await listJsonPaths(this.backend, this.tenantId, PREFIX);
-        const out = [];
-        for (const p of paths) {
-            const rec = await readJson(this.backend, this.tenantId, p);
-            if (!rec)
-                continue;
-            const rest = p.slice(PREFIX.length, -'.json'.length);
-            const sep = rest.indexOf('__');
-            if (sep < 0)
-                continue;
-            const shardId = rest.slice(0, sep);
-            const path = decodeURIComponent(rest.slice(sep + 2));
-            out.push(Object.assign({ shardId, path }, rec));
-        }
-        return out;
-    }
-}

package/dist/documents/sync/tombstones.test.d.ts

@@ -1 +0,0 @@
-export {};