@atproto/space 0.0.0-spaces-alpha-20260818022935

package/dist/sync/consumer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consumer.d.ts","sourceRoot":"","sources":["../../src/sync/consumer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,GAAG,EAAU,MAAM,mBAAmB,CAAA;AAEpD,OAAO,EAAE,UAAU,EAAgB,MAAM,mBAAmB,CAAA;AAC5D,OAAO,EAEL,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,WAAW,EAEjB,MAAM,aAAa,CAAA;AAGpB,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IAEd,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB,CAAA;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,UAAU,EAAE,MAAM,CAAA;IAClB,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,GAAG,CAAA;IACR,MAAM,EAAE,WAAW,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,YAAY,GAAG;IACzB,MAAM,EAAE,YAAY,CAAA;IACpB,KAAK,EAAE,SAAS,CAAA;IAChB,IAAI,EAAE,UAAU,CAAA;IAChB,OAAO,EAAE,cAAc,CAAC,cAAc,CAAC,CAAA;CACxC,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,QACnB,aAAa,CAAC,UAAU,CAAC,GAAG,QAAQ,CAAC,UAAU,CAAC,UAC7C,gBAAgB,KACvB,OAAO,CAAC,YAAY,CAwCtB,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,iBAAiB,QACvB,aAAa,CAAC,UAAU,CAAC,GAAG,QAAQ,CAAC,UAAU,CAAC,UAC7C,gBAAgB,KACvB,OAAO,CAAC,IAAI,CAAC,YAAY,EAAE,SAAS,CAAC,GAAG;IAAE,OAAO,EAAE,cAAc,EAAE,CAAA;CAAE,CAOvE,CAAA"}

package/dist/sync/consumer.js

@@ -0,0 +1,89 @@
+import { readCarStream } from '@atproto/common';
+import { decode } from '@atproto/lex-cbor';
+import { RepoVerificationError } from '../error.js';
+import { RepoCommit, verifyCommit } from '../repo-commit.js';
+import { def, } from '../types.js';
+import { parseRecordPath } from '../util.js';
+/**
+ * Verify a serialized repo, streaming out its records.
+ *
+ * The three stages follow the CAR's layout, so nothing needs buffering: the
+ * commit, then the index against the commit's hash (which authenticates every
+ * path/cid pair without reading a record), then each block against its index
+ * entry. That last stage runs as `records` is drained, so it must be consumed to
+ * know the repo was complete — {@link verifyRepoCarFull} does that.
+ */
+export const verifyRepoCar = async (car, params) => {
+    // The reader hashes every block against its cid as it streams.
+    const { roots, blocks } = await readCarStream(car);
+    if (roots.length !== 2) {
+        throw new RepoVerificationError(`expected 2 car roots (commit, index), got ${roots.length}`);
+    }
+    const [commitRoot, indexRoot] = roots;
+    const commitBlock = await blocks.next();
+    if (commitBlock.done || !commitBlock.value.cid.equals(commitRoot)) {
+        throw new RepoVerificationError('expected the commit block to lead the car');
+    }
+    const commit = parseBlock(commitBlock.value.bytes, def.signedCommit);
+    const ctx = { ...params, rev: commit.rev };
+    if (!(await verifyCommit(commit, ctx, params.didKey))) {
+        throw new RepoVerificationError('commit failed verification');
+    }
+    const indexBlock = await blocks.next();
+    if (indexBlock.done || !indexBlock.value.cid.equals(indexRoot)) {
+        throw new RepoVerificationError('expected the index block to follow the commit');
+    }
+    const index = parseBlock(indexBlock.value.bytes, def.repoIndex);
+    const repo = RepoCommit.fromIndex(index);
+    if (!repo.matches(commit)) {
+        throw new RepoVerificationError('index does not match the commit hash');
+    }
+    return {
+        commit,
+        index,
+        repo,
+        records: verifyRecords(blocks, index, params.expectValues !== false),
+    };
+};
+/**
+ * Verify a serialized repo and collect its records. Prefer {@link verifyRepoCar}
+ * for large repos, where streaming avoids holding every record at once.
+ */
+export const verifyRepoCarFull = async (car, params) => {
+    const { records, ...rest } = await verifyRepoCar(car, params);
+    const collected = [];
+    for await (const record of records) {
+        collected.push(record);
+    }
+    return { ...rest, records: collected };
+};
+// The car holds one record block per index entry, in the index's order.
+async function* verifyRecords(blocks, index, expectValues) {
+    const paths = Object.keys(index);
+    let i = 0;
+    for await (const block of blocks) {
+        if (i >= paths.length) {
+            throw new RepoVerificationError('car has more blocks than index entries');
+        }
+        const path = paths[i];
+        const cid = index[path];
+        i++;
+        if (!block.cid.equals(cid)) {
+            throw new RepoVerificationError(`expected block ${cid} at ${path}, got ${block.cid}`);
+        }
+        const { collection, rkey } = parseRecordPath(path);
+        yield { collection, rkey, cid, record: decode(block.bytes) };
+    }
+    const isIndexOnly = !expectValues && i === 0;
+    if (i < paths.length && !isIndexOnly) {
+        throw new RepoVerificationError(`car is missing ${paths.length - i} record(s) named in the index`);
+    }
+}
+const parseBlock = (bytes, def) => {
+    const parsed = def.schema.safeParse(decode(bytes));
+    if (!parsed.success) {
+        throw new RepoVerificationError(`invalid ${def.name}: ${parsed.error.message}`);
+    }
+    return parsed.data;
+};
+//# sourceMappingURL=consumer.js.map

package/dist/sync/consumer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consumer.js","sourceRoot":"","sources":["../../src/sync/consumer.ts"],"names":[],"mappings":"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","sourcesContent":["import { type check, readCarStream } from '@atproto/common'\nimport { decode } from '@atproto/lex-cbor'\nimport type { Cid, LexMap } from '@atproto/lex-data'\nimport { RepoVerificationError } from '../error.js'\nimport { RepoCommit, verifyCommit } from '../repo-commit.js'\nimport {\n  type CommitCtx,\n  type RepoIndex,\n  type SignedCommit,\n  type SpaceRecord,\n  def,\n} from '../types.js'\nimport { parseRecordPath } from '../util.js'\n\nexport type VerifyRepoParams = {\n  space: string\n  author: string\n  didKey: string\n  // False for an index-only car, which carries no record blocks. Defaults to true.\n  expectValues?: boolean\n}\n\nexport type VerifiedRecord = {\n  collection: string\n  rkey: string\n  cid: Cid\n  record: SpaceRecord\n}\n\nexport type VerifiedRepo = {\n  commit: SignedCommit\n  index: RepoIndex\n  repo: RepoCommit\n  records: AsyncGenerator<VerifiedRecord>\n}\n\n/**\n * Verify a serialized repo, streaming out its records.\n *\n * The three stages follow the CAR's layout, so nothing needs buffering: the\n * commit, then the index against the commit's hash (which authenticates every\n * path/cid pair without reading a record), then each block against its index\n * entry. That last stage runs as `records` is drained, so it must be consumed to\n * know the repo was complete — {@link verifyRepoCarFull} does that.\n */\nexport const verifyRepoCar = async (\n  car: AsyncIterable<Uint8Array> | Iterable<Uint8Array>,\n  params: VerifyRepoParams,\n): Promise<VerifiedRepo> => {\n  // The reader hashes every block against its cid as it streams.\n  const { roots, blocks } = await readCarStream(car)\n  if (roots.length !== 2) {\n    throw new RepoVerificationError(\n      `expected 2 car roots (commit, index), got ${roots.length}`,\n    )\n  }\n  const [commitRoot, indexRoot] = roots\n\n  const commitBlock = await blocks.next()\n  if (commitBlock.done || !commitBlock.value.cid.equals(commitRoot)) {\n    throw new RepoVerificationError('expected the commit block to lead the car')\n  }\n  const commit = parseBlock(commitBlock.value.bytes, def.signedCommit)\n\n  const ctx: CommitCtx = { ...params, rev: commit.rev }\n  if (!(await verifyCommit(commit, ctx, params.didKey))) {\n    throw new RepoVerificationError('commit failed verification')\n  }\n\n  const indexBlock = await blocks.next()\n  if (indexBlock.done || !indexBlock.value.cid.equals(indexRoot)) {\n    throw new RepoVerificationError(\n      'expected the index block to follow the commit',\n    )\n  }\n  const index = parseBlock(indexBlock.value.bytes, def.repoIndex)\n\n  const repo = RepoCommit.fromIndex(index)\n  if (!repo.matches(commit)) {\n    throw new RepoVerificationError('index does not match the commit hash')\n  }\n\n  return {\n    commit,\n    index,\n    repo,\n    records: verifyRecords(blocks, index, params.expectValues !== false),\n  }\n}\n\n/**\n * Verify a serialized repo and collect its records. Prefer {@link verifyRepoCar}\n * for large repos, where streaming avoids holding every record at once.\n */\nexport const verifyRepoCarFull = async (\n  car: AsyncIterable<Uint8Array> | Iterable<Uint8Array>,\n  params: VerifyRepoParams,\n): Promise<Omit<VerifiedRepo, 'records'> & { records: VerifiedRecord[] }> => {\n  const { records, ...rest } = await verifyRepoCar(car, params)\n  const collected: VerifiedRecord[] = []\n  for await (const record of records) {\n    collected.push(record)\n  }\n  return { ...rest, records: collected }\n}\n\n// The car holds one record block per index entry, in the index's order.\nasync function* verifyRecords(\n  blocks: AsyncIterable<{ cid: Cid; bytes: Uint8Array }>,\n  index: RepoIndex,\n  expectValues: boolean,\n): AsyncGenerator<VerifiedRecord> {\n  const paths = Object.keys(index)\n  let i = 0\n\n  for await (const block of blocks) {\n    if (i >= paths.length) {\n      throw new RepoVerificationError('car has more blocks than index entries')\n    }\n    const path = paths[i]\n    const cid = index[path]\n    i++\n\n    if (!block.cid.equals(cid)) {\n      throw new RepoVerificationError(\n        `expected block ${cid} at ${path}, got ${block.cid}`,\n      )\n    }\n    const { collection, rkey } = parseRecordPath(path)\n    yield { collection, rkey, cid, record: decode(block.bytes) as LexMap }\n  }\n\n  const isIndexOnly = !expectValues && i === 0\n  if (i < paths.length && !isIndexOnly) {\n    throw new RepoVerificationError(\n      `car is missing ${paths.length - i} record(s) named in the index`,\n    )\n  }\n}\n\nconst parseBlock = <T>(bytes: Uint8Array, def: check.Def<T>): T => {\n  const parsed = def.schema.safeParse(decode(bytes))\n  if (!parsed.success) {\n    throw new RepoVerificationError(\n      `invalid ${def.name}: ${parsed.error.message}`,\n    )\n  }\n  return parsed.data\n}\n"]}

package/dist/sync/index.d.ts

@@ -0,0 +1,3 @@
+export * from './consumer.js';
+export * from './provider.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sync/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA;AAC7B,cAAc,eAAe,CAAA"}

package/dist/sync/index.js

@@ -0,0 +1,3 @@
+export * from './consumer.js';
+export * from './provider.js';
+//# sourceMappingURL=index.js.map

package/dist/sync/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/sync/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA;AAC7B,cAAc,eAAe,CAAA","sourcesContent":["export * from './consumer.js'\nexport * from './provider.js'\n"]}

package/dist/sync/provider.d.ts

@@ -0,0 +1,25 @@
+import { type Cid } from '@atproto/lex-data';
+import type { SignedCommit, SpaceRecord } from '../types.js';
+export type SerializedRecord = {
+    collection: string;
+    rkey: string;
+    cid: Cid;
+    bytes: Uint8Array;
+};
+/**
+ * Serialize a repo as a car: two roots in order — the signed commit, then the
+ * index — followed by one block per index entry, in the index's order. Blobs are
+ * excluded.
+ *
+ * Records are collected up front because the index has to precede the blocks it
+ * describes.
+ *
+ * With `excludeValues` only the two roots are written. The index still
+ * authenticates against the commit, since the set hash is folded from the index's
+ * entries rather than from the blocks.
+ */
+export declare function serializeRepo(commit: SignedCommit, records: AsyncIterable<SerializedRecord> | Iterable<SerializedRecord>, opts?: {
+    excludeValues?: boolean;
+}): AsyncIterable<Uint8Array>;
+export declare const serializeRecord: (collection: string, rkey: string, record: SpaceRecord) => Promise<SerializedRecord>;
+//# sourceMappingURL=provider.d.ts.map

package/dist/sync/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../src/sync/provider.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,GAAG,EAAc,MAAM,mBAAmB,CAAA;AACxD,OAAO,KAAK,EAAa,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAGvE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,UAAU,EAAE,MAAM,CAAA;IAClB,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,GAAG,CAAA;IACR,KAAK,EAAE,UAAU,CAAA;CAClB,CAAA;AAED;;;;;;;;;;;GAWG;AACH,wBAAuB,aAAa,CAClC,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,aAAa,CAAC,gBAAgB,CAAC,GAAG,QAAQ,CAAC,gBAAgB,CAAC,EACrE,IAAI,GAAE;IAAE,aAAa,CAAC,EAAE,OAAO,CAAA;CAAO,GACrC,aAAa,CAAC,UAAU,CAAC,CAiC3B;AAQD,eAAO,MAAM,eAAe,eACd,MAAM,QACZ,MAAM,UACJ,WAAW,KAClB,OAAO,CAAC,gBAAgB,CAO1B,CAAA"}

package/dist/sync/provider.js

@@ -0,0 +1,60 @@
+import { writeCarStream } from '@atproto/common';
+import { cidForLex, encode } from '@atproto/lex-cbor';
+import { cidForCbor } from '@atproto/lex-data';
+import { formatRecordPath } from '../util.js';
+/**
+ * Serialize a repo as a car: two roots in order — the signed commit, then the
+ * index — followed by one block per index entry, in the index's order. Blobs are
+ * excluded.
+ *
+ * Records are collected up front because the index has to precede the blocks it
+ * describes.
+ *
+ * With `excludeValues` only the two roots are written. The index still
+ * authenticates against the commit, since the set hash is folded from the index's
+ * entries rather than from the blocks.
+ */
+export async function* serializeRepo(commit, records, opts = {}) {
+    const byPath = new Map();
+    for await (const record of records) {
+        byPath.set(formatRecordPath(record.collection, record.rkey), record);
+    }
+    // A consumer walks the index as the cbor encoder ordered its keys, so blocks
+    // have to follow that order too.
+    const paths = [...byPath.keys()].sort(byCanonicalKey);
+    const index = {};
+    for (const path of paths) {
+        index[path] = byPath.get(path).cid;
+    }
+    const commitBytes = encode(commit);
+    const indexBytes = encode(index);
+    const [commitRoot, indexRoot] = await Promise.all([
+        cidForCbor(commitBytes),
+        cidForCbor(indexBytes),
+    ]);
+    yield* writeCarStream([commitRoot, indexRoot], (function* () {
+        yield { cid: commitRoot, bytes: commitBytes };
+        yield { cid: indexRoot, bytes: indexBytes };
+        if (opts.excludeValues)
+            return;
+        for (const path of paths) {
+            const record = byPath.get(path);
+            yield { cid: record.cid, bytes: record.bytes };
+        }
+    })());
+}
+// Canonical dag-cbor map key order: shortest first, then bytewise.
+const byCanonicalKey = (a, b) => {
+    if (a.length !== b.length)
+        return a.length - b.length;
+    return a < b ? -1 : a > b ? 1 : 0;
+};
+export const serializeRecord = async (collection, rkey, record) => {
+    return {
+        collection,
+        rkey,
+        cid: await cidForLex(record),
+        bytes: encode(record),
+    };
+};
+//# sourceMappingURL=provider.js.map

package/dist/sync/provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.js","sourceRoot":"","sources":["../../src/sync/provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AACrD,OAAO,EAAY,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAExD,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAS7C;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,SAAS,CAAC,CAAC,aAAa,CAClC,MAAoB,EACpB,OAAqE,EACrE,IAAI,GAAgC,EAAE;IAEtC,MAAM,MAAM,GAAG,IAAI,GAAG,EAA4B,CAAA;IAClD,IAAI,KAAK,EAAE,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;QACnC,MAAM,CAAC,GAAG,CAAC,gBAAgB,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,CAAA;IACtE,CAAC;IACD,6EAA6E;IAC7E,iCAAiC;IACjC,MAAM,KAAK,GAAG,CAAC,GAAG,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAA;IAErD,MAAM,KAAK,GAAc,EAAE,CAAA;IAC3B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,KAAK,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAE,CAAC,GAAG,CAAA;IACrC,CAAC;IAED,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,CAAA;IAClC,MAAM,UAAU,GAAG,MAAM,CAAC,KAAK,CAAC,CAAA;IAChC,MAAM,CAAC,UAAU,EAAE,SAAS,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;QAChD,UAAU,CAAC,WAAW,CAAC;QACvB,UAAU,CAAC,UAAU,CAAC;KACvB,CAAC,CAAA;IAEF,KAAK,CAAC,CAAC,cAAc,CACnB,CAAC,UAAU,EAAE,SAAS,CAAC,EACvB,CAAC,QAAQ,CAAC;QACR,MAAM,EAAE,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,WAAW,EAAE,CAAA;QAC7C,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,KAAK,EAAE,UAAU,EAAE,CAAA;QAC3C,IAAI,IAAI,CAAC,aAAa;YAAE,OAAM;QAC9B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAE,CAAA;YAChC,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,CAAA;QAChD,CAAC;IACH,CAAC,CAAC,EAAE,CACL,CAAA;AACH,CAAC;AAED,mEAAmE;AACnE,MAAM,cAAc,GAAG,CAAC,CAAS,EAAE,CAAS,EAAU,EAAE;IACtD,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM;QAAE,OAAO,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,CAAA;IACrD,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;AACnC,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,eAAe,GAAG,KAAK,EAClC,UAAkB,EAClB,IAAY,EACZ,MAAmB,EACQ,EAAE;IAC7B,OAAO;QACL,UAAU;QACV,IAAI;QACJ,GAAG,EAAE,MAAM,SAAS,CAAC,MAAM,CAAC;QAC5B,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC;KACtB,CAAA;AACH,CAAC,CAAA","sourcesContent":["import { type CarBlock, writeCarStream } from '@atproto/common'\nimport { cidForLex, encode } from '@atproto/lex-cbor'\nimport { type Cid, cidForCbor } from '@atproto/lex-data'\nimport type { RepoIndex, SignedCommit, SpaceRecord } from '../types.js'\nimport { formatRecordPath } from '../util.js'\n\nexport type SerializedRecord = {\n  collection: string\n  rkey: string\n  cid: Cid\n  bytes: Uint8Array\n}\n\n/**\n * Serialize a repo as a car: two roots in order — the signed commit, then the\n * index — followed by one block per index entry, in the index's order. Blobs are\n * excluded.\n *\n * Records are collected up front because the index has to precede the blocks it\n * describes.\n *\n * With `excludeValues` only the two roots are written. The index still\n * authenticates against the commit, since the set hash is folded from the index's\n * entries rather than from the blocks.\n */\nexport async function* serializeRepo(\n  commit: SignedCommit,\n  records: AsyncIterable<SerializedRecord> | Iterable<SerializedRecord>,\n  opts: { excludeValues?: boolean } = {},\n): AsyncIterable<Uint8Array> {\n  const byPath = new Map<string, SerializedRecord>()\n  for await (const record of records) {\n    byPath.set(formatRecordPath(record.collection, record.rkey), record)\n  }\n  // A consumer walks the index as the cbor encoder ordered its keys, so blocks\n  // have to follow that order too.\n  const paths = [...byPath.keys()].sort(byCanonicalKey)\n\n  const index: RepoIndex = {}\n  for (const path of paths) {\n    index[path] = byPath.get(path)!.cid\n  }\n\n  const commitBytes = encode(commit)\n  const indexBytes = encode(index)\n  const [commitRoot, indexRoot] = await Promise.all([\n    cidForCbor(commitBytes),\n    cidForCbor(indexBytes),\n  ])\n\n  yield* writeCarStream(\n    [commitRoot, indexRoot],\n    (function* (): Generator<CarBlock> {\n      yield { cid: commitRoot, bytes: commitBytes }\n      yield { cid: indexRoot, bytes: indexBytes }\n      if (opts.excludeValues) return\n      for (const path of paths) {\n        const record = byPath.get(path)!\n        yield { cid: record.cid, bytes: record.bytes }\n      }\n    })(),\n  )\n}\n\n// Canonical dag-cbor map key order: shortest first, then bytewise.\nconst byCanonicalKey = (a: string, b: string): number => {\n  if (a.length !== b.length) return a.length - b.length\n  return a < b ? -1 : a > b ? 1 : 0\n}\n\nexport const serializeRecord = async (\n  collection: string,\n  rkey: string,\n  record: SpaceRecord,\n): Promise<SerializedRecord> => {\n  return {\n    collection,\n    rkey,\n    cid: await cidForLex(record),\n    bytes: encode(record),\n  }\n}\n"]}

package/dist/sync/repo-index.d.ts

@@ -0,0 +1,19 @@
+import { Cid } from '@atproto/lex-data';
+/**
+ * The index of a serialized repo: `"{collection}/{rkey}"` to the record's cid, in
+ * the order record blocks follow it.
+ *
+ * Folding an index into a `RepoCommit` and comparing against a verified commit
+ * authenticates every path/cid pair without reading a single record.
+ */
+export type RepoIndex = Map<string, Cid>;
+export type RepoIndexEntry = {
+    collection: string;
+    rkey: string;
+    cid: Cid;
+};
+export declare const repoIndex: (entries: Iterable<RepoIndexEntry>) => RepoIndex;
+export declare const repoIndexEntries: (index: RepoIndex) => RepoIndexEntry[];
+export declare const encodeRepoIndex: (index: RepoIndex) => Uint8Array;
+export declare const decodeRepoIndex: (bytes: Uint8Array) => RepoIndex;
+//# sourceMappingURL=repo-index.d.ts.map

package/dist/sync/repo-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repo-index.d.ts","sourceRoot":"","sources":["../../src/sync/repo-index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAS,MAAM,mBAAmB,CAAA;AAI9C;;;;;;GAMG;AACH,MAAM,MAAM,SAAS,GAAG,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;AAExC,MAAM,MAAM,cAAc,GAAG;IAC3B,UAAU,EAAE,MAAM,CAAA;IAClB,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,GAAG,CAAA;CACT,CAAA;AAED,eAAO,MAAM,SAAS,YACX,QAAQ,CAAC,cAAc,CAAC,KAChC,SAMF,CAAA;AAED,eAAO,MAAM,gBAAgB,UAAW,SAAS,KAAG,cAAc,EACI,CAAA;AAEtE,eAAO,MAAM,eAAe,UAAW,SAAS,KAAG,UAChB,CAAA;AAEnC,eAAO,MAAM,eAAe,UAAW,UAAU,KAAG,SAwBnD,CAAA"}

package/dist/sync/repo-index.js

@@ -0,0 +1,58 @@
+import { decode, encode } from '@atproto/lex-cbor';
+import { ifCid } from '@atproto/lex-data';
+import { RepoVerificationError } from '../error.js';
+import { formatRecordPath, parseRecordPath } from '../util.js';
+export const repoIndex = (entries) => {
+    const index = new Map();
+    for (const { collection, rkey, cid } of entries) {
+        index.set(formatRecordPath(collection, rkey), cid);
+    }
+    return canonicalize(index);
+};
+export const repoIndexEntries = (index) => [...index].map(([path, cid]) => ({ ...parseRecordPath(path), cid }));
+export const encodeRepoIndex = (index) => encode(Object.fromEntries(index));
+export const decodeRepoIndex = (bytes) => {
+    const decoded = decode(bytes);
+    if (decoded === null ||
+        typeof decoded !== 'object' ||
+        Array.isArray(decoded)) {
+        throw new RepoVerificationError('Repo index must be a map');
+    }
+    const index = new Map();
+    for (const [path, value] of Object.entries(decoded)) {
+        try {
+            parseRecordPath(path);
+        }
+        catch {
+            throw new RepoVerificationError(`Invalid path in repo index: ${path}`);
+        }
+        const cid = ifCid(value);
+        if (!cid) {
+            throw new RepoVerificationError(`Invalid cid in repo index at: ${path}`);
+        }
+        index.set(path, cid);
+    }
+    return canonicalize(index);
+};
+// Canonical DAG-CBOR key order: length first, then bytewise — not lexicographic.
+// Sorting on construction means an index built from db rows iterates the same way
+// as one decoded from a block, so provider and consumer always agree.
+const canonicalize = (index) => {
+    const encoder = new TextEncoder();
+    const keyed = [...index.keys()].map((path) => ({
+        path,
+        bytes: encoder.encode(path),
+    }));
+    keyed.sort((a, b) => {
+        if (a.bytes.length !== b.bytes.length) {
+            return a.bytes.length - b.bytes.length;
+        }
+        for (let i = 0; i < a.bytes.length; i++) {
+            if (a.bytes[i] !== b.bytes[i])
+                return a.bytes[i] - b.bytes[i];
+        }
+        return 0;
+    });
+    return new Map(keyed.map(({ path }) => [path, index.get(path)]));
+};
+//# sourceMappingURL=repo-index.js.map

package/dist/sync/repo-index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"repo-index.js","sourceRoot":"","sources":["../../src/sync/repo-index.ts"],"names":[],"mappings":"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","sourcesContent":["import { decode, encode } from '@atproto/lex-cbor'\nimport { Cid, ifCid } from '@atproto/lex-data'\nimport { RepoVerificationError } from '../error.js'\nimport { formatRecordPath, parseRecordPath } from '../util.js'\n\n/**\n * The index of a serialized repo: `\"{collection}/{rkey}\"` to the record's cid, in\n * the order record blocks follow it.\n *\n * Folding an index into a `RepoCommit` and comparing against a verified commit\n * authenticates every path/cid pair without reading a single record.\n */\nexport type RepoIndex = Map<string, Cid>\n\nexport type RepoIndexEntry = {\n  collection: string\n  rkey: string\n  cid: Cid\n}\n\nexport const repoIndex = (\n  entries: Iterable<RepoIndexEntry>,\n): RepoIndex => {\n  const index: RepoIndex = new Map()\n  for (const { collection, rkey, cid } of entries) {\n    index.set(formatRecordPath(collection, rkey), cid)\n  }\n  return canonicalize(index)\n}\n\nexport const repoIndexEntries = (index: RepoIndex): RepoIndexEntry[] =>\n  [...index].map(([path, cid]) => ({ ...parseRecordPath(path), cid }))\n\nexport const encodeRepoIndex = (index: RepoIndex): Uint8Array =>\n  encode(Object.fromEntries(index))\n\nexport const decodeRepoIndex = (bytes: Uint8Array): RepoIndex => {\n  const decoded = decode(bytes)\n  if (\n    decoded === null ||\n    typeof decoded !== 'object' ||\n    Array.isArray(decoded)\n  ) {\n    throw new RepoVerificationError('Repo index must be a map')\n  }\n\n  const index: RepoIndex = new Map()\n  for (const [path, value] of Object.entries(decoded)) {\n    try {\n      parseRecordPath(path)\n    } catch {\n      throw new RepoVerificationError(`Invalid path in repo index: ${path}`)\n    }\n    const cid = ifCid(value)\n    if (!cid) {\n      throw new RepoVerificationError(`Invalid cid in repo index at: ${path}`)\n    }\n    index.set(path, cid)\n  }\n  return canonicalize(index)\n}\n\n// Canonical DAG-CBOR key order: length first, then bytewise — not lexicographic.\n// Sorting on construction means an index built from db rows iterates the same way\n// as one decoded from a block, so provider and consumer always agree.\nconst canonicalize = (index: RepoIndex): RepoIndex => {\n  const encoder = new TextEncoder()\n  const keyed = [...index.keys()].map((path) => ({\n    path,\n    bytes: encoder.encode(path),\n  }))\n  keyed.sort((a, b) => {\n    if (a.bytes.length !== b.bytes.length) {\n      return a.bytes.length - b.bytes.length\n    }\n    for (let i = 0; i < a.bytes.length; i++) {\n      if (a.bytes[i] !== b.bytes[i]) return a.bytes[i] - b.bytes[i]\n    }\n    return 0\n  })\n  return new Map(keyed.map(({ path }) => [path, index.get(path)!]))\n}\n"]}

package/dist/types.d.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import type { check } from '@atproto/common';
+import { type Cid, type LexMap } from '@atproto/lex-data';
+export type SpaceRecord = LexMap;
+export type RecordPath = {
+    collection: string;
+    rkey: string;
+};
+export type RepoOp = RecordPath & {
+    cid: Cid | null;
+    prev: Cid | null;
+};
+export declare const COMMIT_VERSION = 1;
+export type CommitCtx = {
+    space: string;
+    author: string;
+    rev: string;
+};
+declare const signedCommit: z.ZodObject<{
+    ver: z.ZodLiteral<1>;
+    hash: z.ZodType<Uint8Array<ArrayBufferLike>, z.ZodTypeDef, Uint8Array<ArrayBufferLike>>;
+    ikm: z.ZodType<Uint8Array<ArrayBufferLike>, z.ZodTypeDef, Uint8Array<ArrayBufferLike>>;
+    sig: z.ZodType<Uint8Array<ArrayBufferLike>, z.ZodTypeDef, Uint8Array<ArrayBufferLike>>;
+    mac: z.ZodType<Uint8Array<ArrayBufferLike>, z.ZodTypeDef, Uint8Array<ArrayBufferLike>>;
+    rev: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    ver: 1;
+    hash: Uint8Array<ArrayBufferLike>;
+    ikm: Uint8Array<ArrayBufferLike>;
+    sig: Uint8Array<ArrayBufferLike>;
+    mac: Uint8Array<ArrayBufferLike>;
+    rev: string;
+}, {
+    ver: 1;
+    hash: Uint8Array<ArrayBufferLike>;
+    ikm: Uint8Array<ArrayBufferLike>;
+    sig: Uint8Array<ArrayBufferLike>;
+    mac: Uint8Array<ArrayBufferLike>;
+    rev: string;
+}>;
+export type SignedCommit = z.infer<typeof signedCommit>;
+declare const repoIndex: z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnknown, Cid<0 | 1, number, number>, unknown>>;
+export type RepoIndex = z.infer<typeof repoIndex>;
+export declare const def: {
+    signedCommit: check.Def<SignedCommit>;
+    repoIndex: check.Def<RepoIndex>;
+};
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AAC5C,OAAO,EAAE,KAAK,GAAG,EAAE,KAAK,MAAM,EAAS,MAAM,mBAAmB,CAAA;AAEhE,MAAM,MAAM,WAAW,GAAG,MAAM,CAAA;AAEhC,MAAM,MAAM,UAAU,GAAG;IACvB,UAAU,EAAE,MAAM,CAAA;IAClB,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAGD,MAAM,MAAM,MAAM,GAAG,UAAU,GAAG;IAChC,GAAG,EAAE,GAAG,GAAG,IAAI,CAAA;IACf,IAAI,EAAE,GAAG,GAAG,IAAI,CAAA;CACjB,CAAA;AAED,eAAO,MAAM,cAAc,IAAI,CAAA;AAE/B,MAAM,MAAM,SAAS,GAAG;IACtB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AAeD,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;EAOhB,CAAA;AACF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAGvD,QAAA,MAAM,SAAS,2FAAkC,CAAA;AACjD,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AAEjD,eAAO,MAAM,GAAG;IACd,YAAY,EAGP,KAAK,CAAC,GAAG,CAAC,YAAY,CAAC;IAC5B,SAAS,EAGJ,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC;CAC1B,CAAA"}

package/dist/types.js

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { ifCid } from '@atproto/lex-data';
+export const COMMIT_VERSION = 1;
+const cidSchema = z.unknown().transform((input, ctx) => {
+    const cid = ifCid(input);
+    if (cid)
+        return cid;
+    ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: 'Not a valid CID',
+    });
+    return z.NEVER;
+});
+const bytes = z.instanceof(Uint8Array);
+const signedCommit = z.object({
+    ver: z.literal(COMMIT_VERSION),
+    hash: bytes,
+    ikm: bytes,
+    sig: bytes,
+    mac: bytes,
+    rev: z.string(),
+});
+// `{collection}/{rkey}` to the record's cid.
+const repoIndex = z.record(z.string(), cidSchema);
+export const def = {
+    signedCommit: {
+        name: 'signed commit',
+        schema: signedCommit,
+    },
+    repoIndex: {
+        name: 'repo index',
+        schema: repoIndex,
+    },
+};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EAAyB,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAehE,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,CAAA;AAQ/B,MAAM,SAAS,GAAG,CAAC,CAAC,OAAO,EAAE,CAAC,SAAS,CAAC,CAAC,KAAK,EAAE,GAAG,EAAO,EAAE;IAC1D,MAAM,GAAG,GAAG,KAAK,CAAC,KAAK,CAAC,CAAA;IACxB,IAAI,GAAG;QAAE,OAAO,GAAG,CAAA;IAEnB,GAAG,CAAC,QAAQ,CAAC;QACX,IAAI,EAAE,CAAC,CAAC,YAAY,CAAC,MAAM;QAC3B,OAAO,EAAE,iBAAiB;KAC3B,CAAC,CAAA;IACF,OAAO,CAAC,CAAC,KAAK,CAAA;AAChB,CAAC,CAAC,CAAA;AAEF,MAAM,KAAK,GAAG,CAAC,CAAC,UAAU,CAAC,UAA2B,CAAC,CAAA;AAEvD,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5B,GAAG,EAAE,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC;IAC9B,IAAI,EAAE,KAAK;IACX,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE;CAChB,CAAC,CAAA;AAGF,6CAA6C;AAC7C,MAAM,SAAS,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,SAAS,CAAC,CAAA;AAGjD,MAAM,CAAC,MAAM,GAAG,GAAG;IACjB,YAAY,EAAE;QACZ,IAAI,EAAE,eAAe;QACrB,MAAM,EAAE,YAAY;KACM;IAC5B,SAAS,EAAE;QACT,IAAI,EAAE,YAAY;QAClB,MAAM,EAAE,SAAS;KACM;CAC1B,CAAA","sourcesContent":["import { z } from 'zod'\nimport type { check } from '@atproto/common'\nimport { type Cid, type LexMap, ifCid } from '@atproto/lex-data'\n\nexport type SpaceRecord = LexMap\n\nexport type RecordPath = {\n  collection: string\n  rkey: string\n}\n\n// A create has no `prev`, a delete no `cid`, an update both.\nexport type RepoOp = RecordPath & {\n  cid: Cid | null\n  prev: Cid | null\n}\n\nexport const COMMIT_VERSION = 1\n\nexport type CommitCtx = {\n  space: string\n  author: string\n  rev: string\n}\n\nconst cidSchema = z.unknown().transform((input, ctx): Cid => {\n  const cid = ifCid(input)\n  if (cid) return cid\n\n  ctx.addIssue({\n    code: z.ZodIssueCode.custom,\n    message: 'Not a valid CID',\n  })\n  return z.NEVER\n})\n\nconst bytes = z.instanceof(Uint8Array<ArrayBufferLike>)\n\nconst signedCommit = z.object({\n  ver: z.literal(COMMIT_VERSION),\n  hash: bytes,\n  ikm: bytes,\n  sig: bytes,\n  mac: bytes,\n  rev: z.string(),\n})\nexport type SignedCommit = z.infer<typeof signedCommit>\n\n// `{collection}/{rkey}` to the record's cid.\nconst repoIndex = z.record(z.string(), cidSchema)\nexport type RepoIndex = z.infer<typeof repoIndex>\n\nexport const def = {\n  signedCommit: {\n    name: 'signed commit',\n    schema: signedCommit,\n  } as check.Def<SignedCommit>,\n  repoIndex: {\n    name: 'repo index',\n    schema: repoIndex,\n  } as check.Def<RepoIndex>,\n}\n"]}

package/dist/util.d.ts

@@ -0,0 +1,6 @@
+import type { Cid } from '@atproto/lex-data';
+import type { RecordPath } from './types.js';
+export declare const formatRecordPath: (collection: string, rkey: string) => string;
+export declare const parseRecordPath: (path: string) => RecordPath;
+export declare const formatSetHashElement: (collection: string, rkey: string, cid: Cid) => string;
+//# sourceMappingURL=util.d.ts.map

package/dist/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAA;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAE5C,eAAO,MAAM,gBAAgB,eAAgB,MAAM,QAAQ,MAAM,KAAG,MAEnE,CAAA;AAED,eAAO,MAAM,eAAe,SAAU,MAAM,KAAG,UAI9C,CAAA;AAGD,eAAO,MAAM,oBAAoB,eACnB,MAAM,QACZ,MAAM,OACP,GAAG,KACP,MAEF,CAAA"}

package/dist/util.js

@@ -0,0 +1,14 @@
+export const formatRecordPath = (collection, rkey) => {
+    return collection + '/' + rkey;
+};
+export const parseRecordPath = (path) => {
+    const { length, 0: collection, 1: rkey } = path.split('/');
+    if (length !== 2)
+        throw new Error(`invalid record path: ${path}`);
+    return { collection, rkey };
+};
+// The element a record contributes to a repo's set hash.
+export const formatSetHashElement = (collection, rkey, cid) => {
+    return `${collection}/${rkey}/${cid.toString()}`;
+};
+//# sourceMappingURL=util.js.map

package/dist/util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.js","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"AAGA,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,UAAkB,EAAE,IAAY,EAAU,EAAE;IAC3E,OAAO,UAAU,GAAG,GAAG,GAAG,IAAI,CAAA;AAChC,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,IAAY,EAAc,EAAE;IAC1D,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;IAC1D,IAAI,MAAM,KAAK,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,wBAAwB,IAAI,EAAE,CAAC,CAAA;IACjE,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,CAAA;AAC7B,CAAC,CAAA;AAED,yDAAyD;AACzD,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAClC,UAAkB,EAClB,IAAY,EACZ,GAAQ,EACA,EAAE;IACV,OAAO,GAAG,UAAU,IAAI,IAAI,IAAI,GAAG,CAAC,QAAQ,EAAE,EAAE,CAAA;AAClD,CAAC,CAAA","sourcesContent":["import type { Cid } from '@atproto/lex-data'\nimport type { RecordPath } from './types.js'\n\nexport const formatRecordPath = (collection: string, rkey: string): string => {\n  return collection + '/' + rkey\n}\n\nexport const parseRecordPath = (path: string): RecordPath => {\n  const { length, 0: collection, 1: rkey } = path.split('/')\n  if (length !== 2) throw new Error(`invalid record path: ${path}`)\n  return { collection, rkey }\n}\n\n// The element a record contributes to a repo's set hash.\nexport const formatSetHashElement = (\n  collection: string,\n  rkey: string,\n  cid: Cid,\n): string => {\n  return `${collection}/${rkey}/${cid.toString()}`\n}\n"]}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@atproto/space",
+  "version": "0.0.0-spaces-alpha-20260818022935",
+  "license": "MIT",
+  "description": "atproto permissioned data protocol",
+  "keywords": [
+    "atproto",
+    "space"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "homepage": "https://atproto.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bluesky-social/atproto",
+    "directory": "packages/space"
+  },
+  "dependencies": {
+    "@noble/hashes": "^1.6.1",
+    "jose": "^5.2.0",
+    "zod": "^3.23.8",
+    "@atproto/common": "^0.0.0-spaces-alpha-20260818022935",
+    "@atproto/jwk": "^0.7.4",
+    "@atproto/crypto": "^0.0.0-spaces-alpha-20260818022935",
+    "@atproto/lex-data": "^0.1.7",
+    "@atproto/lex-cbor": "^0.1.6"
+  },
+  "devDependencies": {
+    "vitest": "^4.1.10",
+    "@atproto/jwk-jose": "^0.2.4"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "test": "vitest run",
+    "build": "tsc --build tsconfig.build.json"
+  }
+}