@hatk/hatk 0.0.1-alpha.11 → 0.0.1-alpha.111

package/dist/spaces/signature.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The HTTP message signature a space credential travels with.
+ *
+ * RFC 9421, under the label `atproto-space`, signed ecdsa-p256-sha256 by a key
+ * made for one credential and named by its did:key. Two shapes:
+ *
+ *   exchange   the delegation token is signed alone, and the signature names
+ *              its key — that key is what the authority binds the credential
+ *              to (`cnf.kid`)
+ *   use        the credential is signed together with the DID the request is
+ *              addressed to, so a credential lifted off one request cannot be
+ *              replayed at another account by anyone without the key
+ *
+ * The signature is the raw 64-byte r || s, normalized to low-S: the reference
+ * verifier accepts either, but a stricter one (noble's default) only low-S.
+ */
+/** Encode base58btc. The inverse of `decodeBase58btc` in verify.ts. */
+export declare function encodeBase58btc(bytes: Uint8Array): string;
+export interface SpaceSigKey {
+    /** The public key as a P-256 did:key. */
+    did: string;
+    sign: (data: Uint8Array) => Promise<Uint8Array>;
+}
+/** A fresh P-256 key, held in memory only and never exported. */
+export declare function generateSpaceSigKey(): Promise<SpaceSigKey>;
+/**
+ * The bytes a signature covers: one line per covered field, then the
+ * signature parameters, joined by LF with no trailing newline.
+ */
+export declare function signatureBase(authorization: string, params: string, audience?: string): Uint8Array;
+/**
+ * Authorization, audience and signature headers for a space request. Without
+ * an audience this is the exchange; with one, a use of the credential.
+ */
+export declare function spaceSigHeaders(key: SpaceSigKey, authorization: string, audience?: string): Promise<Record<string, string>>;
+//# sourceMappingURL=signature.d.ts.map

package/dist/spaces/signature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signature.d.ts","sourceRoot":"","sources":["../../src/spaces/signature.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAQH,uEAAuE;AACvE,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAqBzD;AAED,MAAM,WAAW,WAAW;IAC1B,yCAAyC;IACzC,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,CAAA;CAChD;AAED,iEAAiE;AACjE,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC,CAYhE;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,UAAU,CAKlG;AAED;;;GAGG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,WAAW,EAChB,aAAa,EAAE,MAAM,EACrB,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAUjC"}

package/dist/spaces/signature.js

@@ -0,0 +1,83 @@
+/**
+ * The HTTP message signature a space credential travels with.
+ *
+ * RFC 9421, under the label `atproto-space`, signed ecdsa-p256-sha256 by a key
+ * made for one credential and named by its did:key. Two shapes:
+ *
+ *   exchange   the delegation token is signed alone, and the signature names
+ *              its key — that key is what the authority binds the credential
+ *              to (`cnf.kid`)
+ *   use        the credential is signed together with the DID the request is
+ *              addressed to, so a credential lifted off one request cannot be
+ *              replayed at another account by anyone without the key
+ *
+ * The signature is the raw 64-byte r || s, normalized to low-S: the reference
+ * verifier accepts either, but a stricter one (noble's default) only low-S.
+ */
+import { signEs256 } from "../oauth/crypto.js";
+const LABEL = 'atproto-space';
+const B58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+/** Encode base58btc. The inverse of `decodeBase58btc` in verify.ts. */
+export function encodeBase58btc(bytes) {
+    const digits = [0];
+    for (const byte of bytes) {
+        let carry = byte;
+        for (let i = 0; i < digits.length; i++) {
+            carry += digits[i] << 8;
+            digits[i] = carry % 58;
+            carry = (carry / 58) | 0;
+        }
+        while (carry) {
+            digits.push(carry % 58);
+            carry = (carry / 58) | 0;
+        }
+    }
+    let out = '';
+    for (const byte of bytes) {
+        if (byte !== 0)
+            break;
+        out += '1';
+    }
+    for (let i = digits.length - 1; i >= 0; i--)
+        out += B58[digits[i]];
+    return out;
+}
+/** A fresh P-256 key, held in memory only and never exported. */
+export async function generateSpaceSigKey() {
+    const pair = await crypto.subtle.generateKey({ name: 'ECDSA', namedCurve: 'P-256' }, false, ['sign', 'verify']);
+    // 0x04 || x || y. A did:key carries the compressed point behind the
+    // p256-pub multicodec prefix (0x1200, varint 0x80 0x24).
+    const raw = new Uint8Array(await crypto.subtle.exportKey('raw', pair.publicKey));
+    const compressed = new Uint8Array(33);
+    compressed[0] = raw[64] & 1 ? 0x03 : 0x02;
+    compressed.set(raw.subarray(1, 33), 1);
+    return {
+        did: `did:key:z${encodeBase58btc(new Uint8Array([0x80, 0x24, ...compressed]))}`,
+        sign: (data) => signEs256(pair.privateKey, data),
+    };
+}
+/**
+ * The bytes a signature covers: one line per covered field, then the
+ * signature parameters, joined by LF with no trailing newline.
+ */
+export function signatureBase(authorization, params, audience) {
+    const lines = [`"authorization": ${authorization}`];
+    if (audience !== undefined)
+        lines.push(`"atproto-space-audience": ${audience}`);
+    lines.push(`"@signature-params": ${params}`);
+    return new TextEncoder().encode(lines.join('\n'));
+}
+/**
+ * Authorization, audience and signature headers for a space request. Without
+ * an audience this is the exchange; with one, a use of the credential.
+ */
+export async function spaceSigHeaders(key, authorization, audience) {
+    const params = audience === undefined ? `("authorization");keyid="${key.did}"` : '("authorization" "atproto-space-audience")';
+    const signature = await key.sign(signatureBase(authorization, params, audience));
+    return {
+        Authorization: authorization,
+        ...(audience !== undefined ? { 'Atproto-Space-Audience': audience } : {}),
+        'Signature-Input': `${LABEL}=${params}`,
+        Signature: `${LABEL}=:${Buffer.from(signature).toString('base64')}:`,
+    };
+}

package/dist/spaces/store.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Sync state for permissioned spaces: which spaces this instance follows, and
+ * how far each writer's repo in them has been read.
+ *
+ * Deliberately separate from `_repos`, which is firehose and backfill
+ * bookkeeping keyed by DID alone. A writer's position is per space — the same
+ * account can hold a repo in several, at different revisions — so a DID is not
+ * a key here.
+ */
+export interface SpaceWatch {
+    space: string;
+    authority: string;
+    spaceType: string;
+    /** The account whose session last minted a credential for this space, if any. */
+    readerDid: string | null;
+    /** Expiry of the current `registerNotify` registration, ISO 8601. */
+    registeredUntil: string | null;
+    lastError: string | null;
+}
+export interface SpaceRepo {
+    space: string;
+    did: string;
+    /** The PDS holding this writer's repo — their own, not the authority's. */
+    pds: string | null;
+    /** The revision this writer's repo had been read to. */
+    rev: string | null;
+}
+export declare function listSpaceWatches(): Promise<SpaceWatch[]>;
+export declare function getSpaceWatch(space: string): Promise<SpaceWatch | null>;
+/**
+ * Start following a space, or refresh what is known about one already followed.
+ *
+ * Never clears `reader_did` or `registered_until`: a second call to watch an
+ * existing space is a re-assertion of interest, not a reset of its progress.
+ */
+export declare function putSpaceWatch(input: {
+    space: string;
+    authority: string;
+    spaceType: string;
+}): Promise<void>;
+export declare function updateSpaceWatch(space: string, patch: {
+    readerDid?: string | null;
+    registeredUntil?: string | null;
+    lastError?: string | null;
+}): Promise<void>;
+export declare function deleteSpaceWatch(space: string): Promise<void>;
+export declare function listSpaceRepos(space: string): Promise<SpaceRepo[]>;
+export declare function getSpaceRepo(space: string, did: string): Promise<SpaceRepo | null>;
+export declare function putSpaceRepo(input: SpaceRepo): Promise<void>;
+export declare function deleteSpaceRepo(space: string, did: string): Promise<void>;
+//# sourceMappingURL=store.d.ts.map

package/dist/spaces/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/spaces/store.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,iFAAiF;IACjF,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,qEAAqE;IACrE,eAAe,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;CACzB;AAED,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;IACX,2EAA2E;IAC3E,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;IAClB,wDAAwD;IACxD,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;CACnB;AA6BD,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC,CAG9D;AAED,wBAAsB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAG7E;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CAAC,KAAK,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAgBjH;AAED,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE;IAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GAC/F,OAAO,CAAC,IAAI,CAAC,CAqBf;AAED,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAGnE;AAED,wBAAsB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC,CAKxE;AAED,wBAAsB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CAMxF;AAED,wBAAsB,YAAY,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAQlE;AAED,wBAAsB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/E"}

package/dist/spaces/store.js

@@ -0,0 +1,99 @@
+/**
+ * Sync state for permissioned spaces: which spaces this instance follows, and
+ * how far each writer's repo in them has been read.
+ *
+ * Deliberately separate from `_repos`, which is firehose and backfill
+ * bookkeeping keyed by DID alone. A writer's position is per space — the same
+ * account can hold a repo in several, at different revisions — so a DID is not
+ * a key here.
+ */
+import { querySQL, runSQL } from "../database/db.js";
+const toWatch = (row) => ({
+    space: row.space,
+    authority: row.authority,
+    spaceType: row.space_type,
+    readerDid: row.reader_did,
+    registeredUntil: row.registered_until,
+    lastError: row.last_error,
+});
+const WATCH_COLS = 'space, authority, space_type, reader_did, registered_until, last_error';
+export async function listSpaceWatches() {
+    const rows = (await querySQL(`SELECT ${WATCH_COLS} FROM _space_watch ORDER BY space`));
+    return rows.map(toWatch);
+}
+export async function getSpaceWatch(space) {
+    const rows = (await querySQL(`SELECT ${WATCH_COLS} FROM _space_watch WHERE space = $1`, [space]));
+    return rows[0] ? toWatch(rows[0]) : null;
+}
+/**
+ * Start following a space, or refresh what is known about one already followed.
+ *
+ * Never clears `reader_did` or `registered_until`: a second call to watch an
+ * existing space is a re-assertion of interest, not a reset of its progress.
+ */
+export async function putSpaceWatch(input) {
+    const existing = await getSpaceWatch(input.space);
+    if (existing) {
+        await runSQL(`UPDATE _space_watch SET authority = $1, space_type = $2, updated_at = $3 WHERE space = $4`, [
+            input.authority,
+            input.spaceType,
+            new Date().toISOString(),
+            input.space,
+        ]);
+        return;
+    }
+    await runSQL(`INSERT INTO _space_watch (space, authority, space_type, reader_did, registered_until, last_error, updated_at)
+     VALUES ($1, $2, $3, NULL, NULL, NULL, $4)`, [input.space, input.authority, input.spaceType, new Date().toISOString()]);
+}
+export async function updateSpaceWatch(space, patch) {
+    const sets = [];
+    const params = [];
+    let idx = 1;
+    if (patch.readerDid !== undefined) {
+        sets.push(`reader_did = $${idx++}`);
+        params.push(patch.readerDid);
+    }
+    if (patch.registeredUntil !== undefined) {
+        sets.push(`registered_until = $${idx++}`);
+        params.push(patch.registeredUntil);
+    }
+    if (patch.lastError !== undefined) {
+        sets.push(`last_error = $${idx++}`);
+        params.push(patch.lastError);
+    }
+    if (sets.length === 0)
+        return;
+    sets.push(`updated_at = $${idx++}`);
+    params.push(new Date().toISOString());
+    params.push(space);
+    await runSQL(`UPDATE _space_watch SET ${sets.join(', ')} WHERE space = $${idx}`, params);
+}
+export async function deleteSpaceWatch(space) {
+    await runSQL(`DELETE FROM _space_watch WHERE space = $1`, [space]);
+    await runSQL(`DELETE FROM _space_repos WHERE space = $1`, [space]);
+}
+export async function listSpaceRepos(space) {
+    const rows = (await querySQL(`SELECT space, did, pds, rev FROM _space_repos WHERE space = $1 ORDER BY did`, [
+        space,
+    ]));
+    return rows;
+}
+export async function getSpaceRepo(space, did) {
+    const rows = (await querySQL(`SELECT space, did, pds, rev FROM _space_repos WHERE space = $1 AND did = $2`, [
+        space,
+        did,
+    ]));
+    return rows[0] ?? null;
+}
+export async function putSpaceRepo(input) {
+    await runSQL(`INSERT OR REPLACE INTO _space_repos (space, did, pds, rev, synced_at) VALUES ($1, $2, $3, $4, $5)`, [
+        input.space,
+        input.did,
+        input.pds,
+        input.rev,
+        new Date().toISOString(),
+    ]);
+}
+export async function deleteSpaceRepo(space, did) {
+    await runSQL(`DELETE FROM _space_repos WHERE space = $1 AND did = $2`, [space, did]);
+}

package/dist/spaces/uri.d.ts

@@ -0,0 +1,60 @@
+/**
+ * AT-URIs for permissioned spaces (proposal 0016).
+ *
+ * A space is named by a three-segment ref, and a record inside one carries the
+ * writer, collection and rkey after it:
+ *
+ *   at://{authority}/space/{type}/{skey}                              — the space
+ *   at://{authority}/space/{type}/{skey}/{writer}/{collection}/{rkey} — a record in it
+ *
+ * Seven segments where an ordinary record URI has five, and `space` sitting
+ * where a collection would. Anything that reads a collection out of a URI by
+ * position has to know the difference or it reads back the literal 'space'.
+ *
+ * The authority is always a DID rather than a handle: a space's membership is
+ * keyed on DIDs, so a handle could not be resolved to a member.
+ */
+export interface SpaceRef {
+    /** The DID the space is anchored on, and the only party that issues credentials for it. */
+    authority: string;
+    /** The space type NSID, whose lexicon declares which collections the space holds. */
+    type: string;
+    skey: string;
+}
+export interface SpaceRecordRef extends SpaceRef {
+    /** The three-segment ref of the space this record lives in. */
+    space: string;
+    /** The account whose repo holds the record. Records stay with their writer. */
+    writer: string;
+    collection: string;
+    rkey: string;
+}
+export declare function spaceRefUri(ref: SpaceRef): string;
+/** Parse `at://{authority}/space/{type}/{skey}` — the space itself, not a record in it. */
+export declare function parseSpaceRef(uri: string): SpaceRef | null;
+/** Whether a URI names a space or anything inside one. */
+export declare function isSpaceUri(uri: string): boolean;
+/** `at://{authority}/space/{type}/{skey}` from its parts; `self` is the skey a singleton space uses. */
+export declare function spaceUri(authority: string, type: string, skey?: string): string;
+/** The record key: the last segment of either URI shape. */
+export declare function rkeyOf(uri: string): string;
+export declare function spaceRecordUri(space: string, writer: string, collection: string, rkey: string): string;
+export declare function parseSpaceRecordUri(uri: string): SpaceRecordRef | null;
+/** The space a record URI belongs to, or undefined for an ordinary repo URI. */
+export declare function spaceFromUri(uri: string): string | undefined;
+/**
+ * The collection a record URI names, whichever shape it is.
+ *
+ * The one place the two URI forms are reconciled; every positional read of a
+ * collection goes through here.
+ */
+export declare function collectionFromRecordUri(uri: string): string | undefined;
+/**
+ * The audience a delegation token for this space is addressed to.
+ *
+ * An authority that publishes no `#atproto_space_host` entry is still reached
+ * at its `#atproto_pds` endpoint — the fragment names the audience, not the
+ * address.
+ */
+export declare function spaceHostAud(authority: string): string;
+//# sourceMappingURL=uri.d.ts.map

package/dist/spaces/uri.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uri.d.ts","sourceRoot":"","sources":["../../src/spaces/uri.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAKH,MAAM,WAAW,QAAQ;IACvB,2FAA2F;IAC3F,SAAS,EAAE,MAAM,CAAA;IACjB,qFAAqF;IACrF,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;CACb;AAED,MAAM,WAAW,cAAe,SAAQ,QAAQ;IAC9C,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAA;IACb,+EAA+E;IAC/E,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;IAClB,IAAI,EAAE,MAAM,CAAA;CACb;AAOD,wBAAgB,WAAW,CAAC,GAAG,EAAE,QAAQ,GAAG,MAAM,CAEjD;AAED,2FAA2F;AAC3F,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAM1D;AAED,0DAA0D;AAC1D,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAG/C;AAED,wGAAwG;AACxG,wBAAgB,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,SAAS,GAAG,MAAM,CAE/E;AAED,4DAA4D;AAC5D,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE1C;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAEtG;AAED,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CActE;AAED,gFAAgF;AAChF,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE5D;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAKvE;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEtD"}

package/dist/spaces/uri.js

@@ -0,0 +1,97 @@
+/**
+ * AT-URIs for permissioned spaces (proposal 0016).
+ *
+ * A space is named by a three-segment ref, and a record inside one carries the
+ * writer, collection and rkey after it:
+ *
+ *   at://{authority}/space/{type}/{skey}                              — the space
+ *   at://{authority}/space/{type}/{skey}/{writer}/{collection}/{rkey} — a record in it
+ *
+ * Seven segments where an ordinary record URI has five, and `space` sitting
+ * where a collection would. Anything that reads a collection out of a URI by
+ * position has to know the difference or it reads back the literal 'space'.
+ *
+ * The authority is always a DID rather than a handle: a space's membership is
+ * keyed on DIDs, so a handle could not be resolved to a member.
+ */
+const SPACE_MARKER = 'space';
+const AT_PREFIX = 'at://';
+function segments(uri) {
+    if (!uri.startsWith(AT_PREFIX))
+        return null;
+    return uri.slice(AT_PREFIX.length).split('/');
+}
+export function spaceRefUri(ref) {
+    return `${AT_PREFIX}${ref.authority}/${SPACE_MARKER}/${ref.type}/${ref.skey}`;
+}
+/** Parse `at://{authority}/space/{type}/{skey}` — the space itself, not a record in it. */
+export function parseSpaceRef(uri) {
+    const parts = segments(uri);
+    if (!parts || parts.length !== 4)
+        return null;
+    const [authority, marker, type, skey] = parts;
+    if (marker !== SPACE_MARKER || !authority.startsWith('did:') || !type || !skey)
+        return null;
+    return { authority, type, skey };
+}
+/** Whether a URI names a space or anything inside one. */
+export function isSpaceUri(uri) {
+    const parts = segments(uri);
+    return parts != null && parts.length >= 4 && parts[1] === SPACE_MARKER && parts[0].startsWith('did:');
+}
+/** `at://{authority}/space/{type}/{skey}` from its parts; `self` is the skey a singleton space uses. */
+export function spaceUri(authority, type, skey = 'self') {
+    return `${AT_PREFIX}${authority}/${SPACE_MARKER}/${type}/${skey}`;
+}
+/** The record key: the last segment of either URI shape. */
+export function rkeyOf(uri) {
+    return uri.slice(uri.lastIndexOf('/') + 1);
+}
+export function spaceRecordUri(space, writer, collection, rkey) {
+    return `${space}/${writer}/${collection}/${rkey}`;
+}
+export function parseSpaceRecordUri(uri) {
+    const parts = segments(uri);
+    if (!parts || parts.length !== 7)
+        return null;
+    const [authority, marker, type, skey, writer, collection, rkey] = parts;
+    if (marker !== SPACE_MARKER || !authority.startsWith('did:') || !collection || !rkey)
+        return null;
+    return {
+        authority,
+        type,
+        skey,
+        writer,
+        collection,
+        rkey,
+        space: `${AT_PREFIX}${authority}/${SPACE_MARKER}/${type}/${skey}`,
+    };
+}
+/** The space a record URI belongs to, or undefined for an ordinary repo URI. */
+export function spaceFromUri(uri) {
+    return parseSpaceRecordUri(uri)?.space ?? undefined;
+}
+/**
+ * The collection a record URI names, whichever shape it is.
+ *
+ * The one place the two URI forms are reconciled; every positional read of a
+ * collection goes through here.
+ */
+export function collectionFromRecordUri(uri) {
+    const parts = segments(uri);
+    if (!parts)
+        return undefined;
+    if (parts.length === 7 && parts[1] === SPACE_MARKER)
+        return parts[5];
+    return parts.length >= 3 ? parts[1] : undefined;
+}
+/**
+ * The audience a delegation token for this space is addressed to.
+ *
+ * An authority that publishes no `#atproto_space_host` entry is still reached
+ * at its `#atproto_pds` endpoint — the fragment names the audience, not the
+ * address.
+ */
+export function spaceHostAud(authority) {
+    return `${authority}#atproto_space_host`;
+}

package/dist/spaces/verify.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Verifying a signature made by somebody else's atproto signing key.
+ *
+ * Everything hatk signs, it signs with ES256, because it chose its own keys and
+ * WebCrypto implements that curve. Everything it has to *verify* here was
+ * signed by an account it does not control, and most `did:plc` accounts sign
+ * with secp256k1 — a curve WebCrypto does not implement at all. So the two
+ * curves atproto allows are handled explicitly, over @noble/curves.
+ *
+ * A key arrives as a multibase string in a DID document's verification method
+ * (`publicKeyMultibase` on a `Multikey`): base58btc, prefixed with a multicodec
+ * varint naming the curve, then the compressed point. The prefix is the only
+ * thing that says which curve it is, so it is read rather than guessed.
+ */
+export type AtprotoCurve = 'secp256k1' | 'p256';
+export declare class SignatureError extends Error {
+}
+/**
+ * Decode base58btc. Written out rather than pulled in: it is short, it is the
+ * only encoding needed, and a wrong answer here fails closed rather than
+ * silently accepting something.
+ */
+export declare function decodeBase58btc(input: string): Uint8Array;
+export interface PublicKey {
+    curve: AtprotoCurve;
+    /** The compressed point, 33 bytes. */
+    bytes: Uint8Array;
+}
+/** Read a `publicKeyMultibase` from a DID document's verification method. */
+export declare function parseMultibaseKey(multibase: string): PublicKey;
+/**
+ * Verify a raw `r || s` signature over `message`.
+ *
+ * Low-S is required — atproto mandates it and a malleable signature would let
+ * the same assertion be presented twice with different bytes — and is what
+ * @noble enforces by default.
+ *
+ * `prehash: false` says the second argument is already a digest, and is not
+ * optional: @noble/curves hashes it again without it, so every signature from
+ * a real counterparty is rejected while one this module both makes and checks
+ * still matches. A test that signs through the same call cannot see that, so
+ * the vectors in the suite are fixed bytes from the library atproto signs
+ * with rather than a round trip through this one.
+ */
+export declare function verifySignature(key: PublicKey, signature: Uint8Array, message: Uint8Array): boolean;
+//# sourceMappingURL=verify.d.ts.map

package/dist/spaces/verify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../../src/spaces/verify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAYH,MAAM,MAAM,YAAY,GAAG,WAAW,GAAG,MAAM,CAAA;AAE/C,qBAAa,cAAe,SAAQ,KAAK;CAAG;AAE5C;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAuBzD;AAED,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,YAAY,CAAA;IACnB,sCAAsC;IACtC,KAAK,EAAE,UAAU,CAAA;CAClB;AAED,6EAA6E;AAC7E,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAO9D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU,GAAG,OAAO,CAUnG"}

package/dist/spaces/verify.js

@@ -0,0 +1,94 @@
+/**
+ * Verifying a signature made by somebody else's atproto signing key.
+ *
+ * Everything hatk signs, it signs with ES256, because it chose its own keys and
+ * WebCrypto implements that curve. Everything it has to *verify* here was
+ * signed by an account it does not control, and most `did:plc` accounts sign
+ * with secp256k1 — a curve WebCrypto does not implement at all. So the two
+ * curves atproto allows are handled explicitly, over @noble/curves.
+ *
+ * A key arrives as a multibase string in a DID document's verification method
+ * (`publicKeyMultibase` on a `Multikey`): base58btc, prefixed with a multicodec
+ * varint naming the curve, then the compressed point. The prefix is the only
+ * thing that says which curve it is, so it is read rather than guessed.
+ */
+import { p256 } from '@noble/curves/nist.js';
+import { secp256k1 } from '@noble/curves/secp256k1.js';
+import { sha256 } from '@noble/hashes/sha2.js';
+const BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+/** Multicodec varints for the two curves atproto allows. */
+const SECP256K1_PREFIX = [0xe7, 0x01];
+const P256_PREFIX = [0x80, 0x24];
+export class SignatureError extends Error {
+}
+/**
+ * Decode base58btc. Written out rather than pulled in: it is short, it is the
+ * only encoding needed, and a wrong answer here fails closed rather than
+ * silently accepting something.
+ */
+export function decodeBase58btc(input) {
+    if (input.length === 0)
+        return new Uint8Array(0);
+    const bytes = [0];
+    for (const char of input) {
+        const value = BASE58_ALPHABET.indexOf(char);
+        if (value < 0)
+            throw new SignatureError(`Not base58btc: ${char}`);
+        let carry = value;
+        for (let i = 0; i < bytes.length; i++) {
+            carry += bytes[i] * 58;
+            bytes[i] = carry & 0xff;
+            carry >>= 8;
+        }
+        while (carry > 0) {
+            bytes.push(carry & 0xff);
+            carry >>= 8;
+        }
+    }
+    // Every leading '1' is a leading zero byte that the arithmetic above drops.
+    for (const char of input) {
+        if (char !== '1')
+            break;
+        bytes.push(0);
+    }
+    return new Uint8Array(bytes.reverse());
+}
+/** Read a `publicKeyMultibase` from a DID document's verification method. */
+export function parseMultibaseKey(multibase) {
+    if (!multibase.startsWith('z'))
+        throw new SignatureError('Key is not base58btc multibase');
+    const decoded = decodeBase58btc(multibase.slice(1));
+    const starts = (prefix) => prefix.every((b, i) => decoded[i] === b);
+    if (starts(SECP256K1_PREFIX))
+        return { curve: 'secp256k1', bytes: decoded.slice(SECP256K1_PREFIX.length) };
+    if (starts(P256_PREFIX))
+        return { curve: 'p256', bytes: decoded.slice(P256_PREFIX.length) };
+    throw new SignatureError('Key is neither secp256k1 nor p256');
+}
+/**
+ * Verify a raw `r || s` signature over `message`.
+ *
+ * Low-S is required — atproto mandates it and a malleable signature would let
+ * the same assertion be presented twice with different bytes — and is what
+ * @noble enforces by default.
+ *
+ * `prehash: false` says the second argument is already a digest, and is not
+ * optional: @noble/curves hashes it again without it, so every signature from
+ * a real counterparty is rejected while one this module both makes and checks
+ * still matches. A test that signs through the same call cannot see that, so
+ * the vectors in the suite are fixed bytes from the library atproto signs
+ * with rather than a round trip through this one.
+ */
+export function verifySignature(key, signature, message) {
+    if (signature.length !== 64)
+        return false;
+    const digest = sha256(message);
+    try {
+        const curve = key.curve === 'secp256k1' ? secp256k1 : p256;
+        return curve.verify(signature, digest, key.bytes, { prehash: false });
+    }
+    catch {
+        // A malformed point or scalar is a failed verification, not a crash.
+        return false;
+    }
+}

package/dist/spaces/viewer.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Which spaces a given viewer may be shown.
+ *
+ * The question has exactly one authoritative answer, and hatk is not the one
+ * holding it: a space's authority decides who may read it, at the moment it
+ * mints a credential, from records and rules that live on the community's own
+ * host. Re-deriving that here — reading the access and membership records out
+ * of the index and evaluating them — would be a second implementation of
+ * somebody else's authorization, drifting from it in exactly the cases that
+ * matter. Ejected members keep their content readable in the alpha; an invites
+ * space is write-for-anyone and read-for-owner; a host may change its rules
+ * without telling us.
+ *
+ * So the check is the real thing: ask the authority to mint a credential as
+ * this viewer, and take the answer. It succeeds precisely when the viewer may
+ * read the space, because that is the same call their own browser would make.
+ *
+ * What that costs is a round trip per space, so the answer is cached — which
+ * means revocation lags by up to the cache's lifetime. Worth stating plainly:
+ * somebody ejected from a community may still be served that community's rows
+ * for a few minutes. The alternative is two round trips on every request, and
+ * the space host itself already lets a minted credential outlive a revocation
+ * by up to ten minutes.
+ */
+import type { OAuthConfig } from '../config.ts';
+import { type SpaceCredential } from './credential.ts';
+/**
+ * The spaces this viewer may be shown, as the scope for a request.
+ *
+ * Empty for a signed-out visitor, always: obtaining a credential begins with a
+ * delegation token from the reader's own PDS, so there is no anonymous read
+ * path into a space at all. `readableBy: ["public"]` means any authenticated
+ * reader, never anyone.
+ */
+export declare function readableSpacesFor(oauth: OAuthConfig | null, viewer: {
+    did: string;
+} | null): Promise<string[]>;
+/**
+ * This viewer's own credential for a space, or null if they may not read it.
+ *
+ * For the reads that cannot go through the index — a blob, which has no public
+ * URL by design and must be fetched from the repo that holds it with the same
+ * credential as the record naming it.
+ */
+export declare function viewerCredential(oauth: OAuthConfig | null, viewer: {
+    did: string;
+} | null, space: string): Promise<SpaceCredential | null>;
+/** Drop a viewer's cached answer — after they sign out, or to stop honouring it early. */
+export declare function forgetViewerSpaces(viewerDid: string): void;
+export declare function resetViewerSpaces(): void;
+//# sourceMappingURL=viewer.d.ts.map

package/dist/spaces/viewer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viewer.d.ts","sourceRoot":"","sources":["../../src/spaces/viewer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAE/C,OAAO,EAAoC,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAsGxF;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI,EAAE,MAAM,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAIpH;AAED;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,WAAW,GAAG,IAAI,EACzB,MAAM,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,EAC9B,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAkBjC;AAED,0FAA0F;AAC1F,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAE1D;AAED,wBAAgB,iBAAiB,IAAI,IAAI,CAGxC"}