mdmaid-desk 0.1.29 → 0.1.31

package/README.md

@@ -128,6 +128,27 @@ node dist/cli.js workspace add /path/to/repository \
   --repository-name "Example"
 ```
 
+A canonical repository/worktree root can belong to only one workspace ID.
+Ticket and task identifiers belong in document/project metadata and must not be
+used as workspace IDs. If an older catalog contains two IDs for one root,
+inspect a dry-run reconciliation before applying it:
+
+```bash
+mdmaid-desk workspace reconcile task-derived-id \
+  --into stable-repository-id \
+  --json
+
+mdmaid-desk workspace reconcile task-derived-id \
+  --into stable-repository-id \
+  --apply
+```
+
+The operation preserves non-conflicting document and review IDs. Path
+conflicts block the repair. An archived conflicting document may be discarded
+only with `--discard-archived-conflicts`; review history is never discarded.
+The command uses the live daemon when available, so its dry run and mutation
+observe the same catalog authority.
+
 Register a document:
 
 ```bash
@@ -216,11 +237,11 @@ file does not remove the imported copy.
 Every registered-source render re-authorizes the real path and reconciles its
 content hash, revision, reading state, review state, and local-link mappings.
 When a foreground web service or daemon is running, mdmaid.desk also watches
-the parent directories of active registered sources. A committed source
-change, disappearance, or restoration publishes a document-scoped event: an
-open matching Web or TUI reader rerenders automatically, while unrelated
-readers only refresh queue metadata. The interfaces label registered documents
-as `live source` and imports as `snapshot`.
+the parent directories of active registered sources. Every committed catalog
+change publishes one metadata-free invalidation; Web, TUI, and waiting CLI
+clients then reread authoritative state for their selected Space. The
+interfaces label registered documents as `live source` and imports as
+`snapshot`.
 
 Without a running service, registration and rendering still work and a manual
 render reconciles current source state. Automatic push refresh is
@@ -248,6 +269,26 @@ node dist/cli.js list --workspace example
 node dist/cli.js list --task PROJECT-123
 ```
 
+Create persistent Spaces that classify current and future documents from one
+or more repository, repository-namespace, workspace, or tag patterns:
+
+```bash
+mdmaid-desk space add work --name "Work" \
+  --namespace github.com/example \
+  --tag work
+mdmaid-desk space add home --name "Home" --workspace personal
+mdmaid-desk space list
+mdmaid-desk repository list
+mdmaid-desk list --space work
+```
+
+An agent creating a Space must ask which patterns belong to it when none were
+provided. Matchers use OR semantics and membership is derived from current
+repository identity and tags, so later matching documents appear automatically.
+Use `space matchers set`, `space rename`, and `space delete` to manage the
+definition. Space-aware commands refuse a healthy older daemon and ask for a
+restart after upgrade instead of bypassing it with direct catalog access.
+
 Run the browser workspace as a foreground local service:
 
 ```bash
@@ -272,6 +313,10 @@ names are scoped to that token, allowing independent mdmaid.desk daemons on
 different ports to remain signed in at the same time. Stop the foreground
 service with `Ctrl-C`.
 
+Project, Space, and content type are global filters. Open the Project control
+and type any part of a project name to narrow its choices with a
+case-insensitive substring match, then select the project normally.
+
 Use `--port` to select another loopback port for intentional isolated testing.
 An advanced `--public-url` option
 accepts HTTP or HTTPS `.localhost` origins; a direct HTTP origin must use the
@@ -328,15 +373,17 @@ node dist/cli.js tui
 ```
 
 The TUI reuses the running web daemon when available, so both clients share
-catalog events and reading state. Keys are shown in its footer; the main flow
+catalog invalidations and reading state. Keys are shown in its footer; the main flow
 uses `j`/`k`, `Enter`, `/`, `m`, `u`, `a`, `b`, and `q`.
 The queue starts grouped by project; press `g` to cycle through project, tag,
-and one ordered-list view.
+and one ordered-list view. Press `x` to cycle All and named Spaces.
 Pending review requests add `r` for the Actions view and `y`, `c`, or `x` for
 Approve, Request changes, or Reject. The response composer uses `Enter` for a
 newline, `Ctrl-D` to submit, and `Esc` to cancel.
 
-Press `c` from the terminal queue to enter the dedicated Change Reviews space.
+Press `c` from the terminal queue to switch between Docs and Change reviews.
+This content mode is independent from the Actions filter, so “Waiting for you”
+can narrow either mode.
 Producers publish an implementation review and its mandatory decision with:
 
 ```bash
@@ -405,6 +452,11 @@ ${XDG_STATE_HOME:-~/.local/state}/mdmaid.desk/
   daemon.log
 ```
 
+The Spaces release upgrades existing catalogs from schema 8 to schema 9.
+Before the first upgraded start, follow the verified backup and downgrade
+procedure in [docs/RELEASING.md](docs/RELEASING.md#schema-9-backup-and-downgrade-recovery).
+In-place downgrade is not supported.
+
 ## Target Interaction
 
 ```mermaid

package/dist/api-client.d.ts

@@ -1,4 +1,5 @@
-import type { DocumentAction, DocumentImport, DocumentRegistration, HealthData, PublicDocument, PublicProject, PublicReviewRequest, PublicWorkspace, TerminalRenderPreferences, TerminalRender, WebRender, ReviewRequestRegistration, ReviewRequestResponse, ReviewStatus, WorkspaceRegistration } from "./api-types.js";
+import type { ContentScope } from "./domain.js";
+import type { BulkDocumentResult, DocumentAction, DocumentImport, DocumentRegistration, HealthData, PublicDocument, PublicProject, PublicRepository, PublicReviewRequest, PublicSpace, PublicSpaceMatcher, PublicWorkspace, PublicWorkspaceReconciliation, TerminalRenderPreferences, TerminalRender, WebRender, ReviewRequestRegistration, ReviewRequestResponse, ReviewStatus, WorkspaceRegistration, WorkspaceReconciliationRequest } from "./api-types.js";
 import type { MermaidValidationReport } from "./mermaid-validation.js";
 export declare class DeskApiError extends Error {
     readonly status: number;
@@ -6,8 +7,12 @@ export declare class DeskApiError extends Error {
     readonly validation?: MermaidValidationReport | undefined;
     constructor(status: number, code: string, message: string, validation?: MermaidValidationReport | undefined);
 }
+export declare class DaemonHealthCompatibilityError extends Error {
+    constructor(message: string);
+}
+/** @deprecated Catalog invalidations now arrive as an empty object. */
 export interface CatalogEvent {
-    action: string;
+    action?: string;
     documentId?: string;
     revision?: number;
     reviewRequestId?: string;
@@ -21,22 +26,44 @@ export declare class DeskApiClient {
     #private;
     constructor(baseUrl: string, token: string);
     health(signal?: AbortSignal): Promise<HealthData>;
-    listDocuments(): Promise<PublicDocument[]>;
-    listWorkspaces(): Promise<PublicWorkspace[]>;
-    listProjects(): Promise<PublicProject[]>;
+    requireCapabilities(...required: string[]): Promise<void>;
+    listDocuments(scope?: ContentScope, filters?: {
+        archived?: boolean;
+    }): Promise<PublicDocument[]>;
+    listWorkspaces(scope?: ContentScope): Promise<PublicWorkspace[]>;
+    listProjects(scope?: ContentScope): Promise<PublicProject[]>;
+    listSpaces(): Promise<PublicSpace[]>;
+    getSpace(id: string): Promise<PublicSpace>;
+    createSpace(input: PublicSpace): Promise<PublicSpace>;
+    renameSpace(id: string, name: string): Promise<PublicSpace>;
+    replaceSpaceMatchers(id: string, matchers: PublicSpaceMatcher[]): Promise<PublicSpace>;
+    deleteSpace(id: string): Promise<{
+        id: string;
+    }>;
+    listRepositories(): Promise<PublicRepository[]>;
     addWorkspace(input: WorkspaceRegistration): Promise<PublicWorkspace>;
+    reconcileWorkspace(sourceWorkspaceId: string, input: WorkspaceReconciliationRequest): Promise<PublicWorkspaceReconciliation>;
     registerDocument(input: DocumentRegistration): Promise<PublicDocument>;
     importDocument(input: DocumentImport): Promise<PublicDocument>;
     listReviewRequests(filters?: {
         documentId?: string;
         status?: ReviewStatus;
-    }): Promise<PublicReviewRequest[]>;
-    getReviewRequest(id: string): Promise<PublicReviewRequest>;
-    createReviewRequest(input: ReviewRequestRegistration): Promise<PublicReviewRequest>;
-    respondToReviewRequest(id: string, input: ReviewRequestResponse): Promise<PublicReviewRequest>;
-    renderDocument(id: string, target: "terminal", width?: number, preferences?: TerminalRenderPreferences): Promise<TerminalRender>;
-    renderDocument(id: string, target: "web", width?: number): Promise<WebRender>;
-    act(id: string, action: DocumentAction): Promise<PublicDocument>;
+    }, scope?: ContentScope): Promise<PublicReviewRequest[]>;
+    getReviewRequest(id: string, scope?: ContentScope): Promise<PublicReviewRequest>;
+    createReviewRequest(input: ReviewRequestRegistration, scope?: ContentScope): Promise<PublicReviewRequest>;
+    respondToReviewRequest(id: string, input: ReviewRequestResponse, scope?: ContentScope): Promise<PublicReviewRequest>;
+    renderDocument(id: string, target: "terminal", width?: number, preferences?: TerminalRenderPreferences, scope?: ContentScope): Promise<TerminalRender>;
+    renderDocument(id: string, target: "web", width?: number, preferences?: undefined, scope?: ContentScope): Promise<WebRender>;
+    act(id: string, action: DocumentAction, scope?: ContentScope): Promise<PublicDocument>;
+    bulkAct(action: "archive" | "restore", ids: string[], scope?: ContentScope): Promise<Extract<BulkDocumentResult, {
+        documents: PublicDocument[];
+    }>>;
+    bulkAct(action: "purge", ids: string[], scope?: ContentScope): Promise<Extract<BulkDocumentResult, {
+        action: "purge";
+    }>>;
+    purgeDocument(id: string, scope?: ContentScope): Promise<string>;
+    getDocument(id: string, scope?: ContentScope): Promise<PublicDocument>;
+    setDocumentTags(id: string, tags: string[], scope?: ContentScope): Promise<PublicDocument>;
     subscribeCatalog(listener: (event: CatalogEvent) => void, options?: CatalogSubscriptionOptions): Promise<void>;
 }
 export declare function isPublicReviewRequest(value: unknown): value is PublicReviewRequest;

package/dist/api-client.js

@@ -12,6 +12,12 @@ export class DeskApiError extends Error {
         this.name = "DeskApiError";
     }
 }
+export class DaemonHealthCompatibilityError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "DaemonHealthCompatibilityError";
+    }
+}
 export class DeskApiClient {
     #baseUrl;
     #token;
@@ -34,32 +40,122 @@ export class DeskApiClient {
             authenticated: false,
             ...(signal === undefined ? {} : { signal }),
         });
-        if (!isHealth(value)) {
+        if (!isCoreHealth(value)) {
             throw new Error("Daemon returned an invalid health response");
         }
-        return value;
+        if (value.capabilities !== undefined &&
+            (!Array.isArray(value.capabilities) ||
+                !value.capabilities.every((capability) => typeof capability === "string"))) {
+            throw new DaemonHealthCompatibilityError("The running mdmaid.desk daemon has incompatible capabilities; restart it after upgrading");
+        }
+        return {
+            service: "mdmaid.desk",
+            status: "ok",
+            version: value.version,
+            ...(value.capabilities === undefined
+                ? {}
+                : { capabilities: [...new Set(value.capabilities)] }),
+        };
     }
-    async listDocuments() {
-        const value = await this.#request("/api/v1/documents");
+    async requireCapabilities(...required) {
+        const health = await this.health();
+        const capabilities = new Set(health.capabilities ?? []);
+        const missing = required.filter((capability) => !capabilities.has(capability));
+        if (missing.length > 0) {
+            throw new DaemonHealthCompatibilityError(`The running mdmaid.desk daemon does not support ${missing.join(", ")}; restart it after upgrading`);
+        }
+    }
+    async listDocuments(scope = {}, filters = {}) {
+        const query = new URLSearchParams();
+        if (scope.spaceId !== undefined) {
+            assertSpaceId(scope.spaceId);
+            query.set("space", scope.spaceId);
+        }
+        if (filters.archived === true) {
+            query.set("archived", "true");
+        }
+        const suffix = query.size === 0 ? "" : `?${query.toString()}`;
+        const value = await this.#request(`/api/v1/documents${suffix}`);
         if (!Array.isArray(value) || !value.every(isPublicDocument)) {
             throw new Error("Daemon returned an invalid document list");
         }
         return value;
     }
-    async listWorkspaces() {
-        const value = await this.#request("/api/v1/workspaces");
+    async listWorkspaces(scope = {}) {
+        const value = await this.#request(withScope("/api/v1/workspaces", scope));
         if (!Array.isArray(value) || !value.every(isPublicWorkspace)) {
             throw new Error("Daemon returned an invalid workspace list");
         }
         return value;
     }
-    async listProjects() {
-        const value = await this.#request("/api/v1/projects");
+    async listProjects(scope = {}) {
+        const value = await this.#request(withScope("/api/v1/projects", scope));
         if (!Array.isArray(value) || !value.every(isPublicProject)) {
             throw new Error("Daemon returned an invalid project list");
         }
         return value;
     }
+    async listSpaces() {
+        const value = await this.#request("/api/v1/spaces");
+        if (!Array.isArray(value) || !value.every(isPublicSpace)) {
+            throw new Error("Daemon returned an invalid Space list");
+        }
+        return value;
+    }
+    async getSpace(id) {
+        assertSpaceId(id);
+        const value = await this.#request(`/api/v1/spaces/${encodeURIComponent(id)}`);
+        if (!isPublicSpace(value)) {
+            throw new Error("Daemon returned an invalid Space");
+        }
+        return value;
+    }
+    async createSpace(input) {
+        const value = await this.#request("/api/v1/spaces", {
+            method: "POST",
+            body: input,
+        });
+        if (!isPublicSpace(value)) {
+            throw new Error("Daemon returned an invalid Space");
+        }
+        return value;
+    }
+    async renameSpace(id, name) {
+        assertSpaceId(id);
+        const value = await this.#request(`/api/v1/spaces/${encodeURIComponent(id)}`, {
+            method: "PATCH",
+            body: { name },
+        });
+        if (!isPublicSpace(value)) {
+            throw new Error("Daemon returned an invalid Space");
+        }
+        return value;
+    }
+    async replaceSpaceMatchers(id, matchers) {
+        assertSpaceId(id);
+        const value = await this.#request(`/api/v1/spaces/${encodeURIComponent(id)}/matchers`, { method: "PUT", body: { matchers } });
+        if (!isPublicSpace(value)) {
+            throw new Error("Daemon returned an invalid Space");
+        }
+        return value;
+    }
+    async deleteSpace(id) {
+        assertSpaceId(id);
+        const value = await this.#request(`/api/v1/spaces/${encodeURIComponent(id)}`, {
+            method: "DELETE",
+        });
+        if (!isRecord(value) || Object.keys(value).length !== 1 || value.id !== id) {
+            throw new Error("Daemon returned an invalid Space deletion response");
+        }
+        return { id };
+    }
+    async listRepositories() {
+        const value = await this.#request("/api/v1/repositories");
+        if (!Array.isArray(value) || !value.every(isPublicRepository)) {
+            throw new Error("Daemon returned an invalid repository list");
+        }
+        return value;
+    }
     async addWorkspace(input) {
         const value = await this.#request("/api/v1/workspaces", {
             method: "POST",
@@ -70,6 +166,14 @@ export class DeskApiClient {
         }
         return value;
     }
+    async reconcileWorkspace(sourceWorkspaceId, input) {
+        assertWorkspaceId(sourceWorkspaceId);
+        const value = await this.#request(`/api/v1/workspaces/${encodeURIComponent(sourceWorkspaceId)}/reconcile`, { method: "POST", body: input });
+        if (!isPublicWorkspaceReconciliation(value)) {
+            throw new Error("Daemon returned an invalid workspace reconciliation");
+        }
+        return value;
+    }
     async registerDocument(input) {
         const value = await this.#request("/api/v1/documents", {
             method: "POST",
@@ -90,7 +194,7 @@ export class DeskApiClient {
         }
         return value;
     }
-    async listReviewRequests(filters = {}) {
+    async listReviewRequests(filters = {}, scope = {}) {
         const query = new URLSearchParams();
         if (filters.documentId !== undefined) {
             assertDocumentId(filters.documentId);
@@ -102,6 +206,7 @@ export class DeskApiClient {
             }
             query.set("status", filters.status);
         }
+        addScope(query, scope);
         const suffix = query.size === 0 ? "" : `?${query.toString()}`;
         const value = await this.#request(`/api/v1/review-requests${suffix}`);
         if (!Array.isArray(value) || !value.every(isPublicReviewRequest)) {
@@ -109,16 +214,16 @@ export class DeskApiClient {
         }
         return value;
     }
-    async getReviewRequest(id) {
+    async getReviewRequest(id, scope = {}) {
         assertReviewRequestId(id);
-        const value = await this.#request(`/api/v1/review-requests/${encodeURIComponent(id)}`);
+        const value = await this.#request(withScope(`/api/v1/review-requests/${encodeURIComponent(id)}`, scope));
         if (!isPublicReviewRequest(value)) {
             throw new Error("Daemon returned an invalid review request");
         }
         return value;
     }
-    async createReviewRequest(input) {
-        const value = await this.#request("/api/v1/review-requests", {
+    async createReviewRequest(input, scope = {}) {
+        const value = await this.#request(withScope("/api/v1/review-requests", scope), {
             method: "POST",
             body: input,
         });
@@ -127,15 +232,15 @@ export class DeskApiClient {
         }
         return value;
     }
-    async respondToReviewRequest(id, input) {
+    async respondToReviewRequest(id, input, scope = {}) {
         assertReviewRequestId(id);
-        const value = await this.#request(`/api/v1/review-requests/${encodeURIComponent(id)}/respond`, { method: "POST", body: input });
+        const value = await this.#request(withScope(`/api/v1/review-requests/${encodeURIComponent(id)}/respond`, scope), { method: "POST", body: input });
         if (!isPublicReviewRequest(value)) {
             throw new Error("Daemon returned an invalid review request");
         }
         return value;
     }
-    async renderDocument(id, target, width = 100, preferences = {}) {
+    async renderDocument(id, target, width = 100, preferences = {}, scope = {}) {
         assertDocumentId(id);
         if (!Number.isSafeInteger(width) || width < 20 || width > 1_000) {
             throw new Error("render width must be an integer between 20 and 1000");
@@ -150,6 +255,7 @@ export class DeskApiClient {
                 query.set("unicode", String(preferences.unicode));
             }
         }
+        addScope(query, scope);
         const value = await this.#request(`/api/v1/documents/${encodeURIComponent(id)}/render?${query.toString()}`);
         if (target === "terminal" && isTerminalRender(value)) {
             return value;
@@ -159,9 +265,41 @@ export class DeskApiClient {
         }
         throw new Error("Daemon returned an invalid render response");
     }
-    async act(id, action) {
+    async act(id, action, scope = {}) {
         assertDocumentId(id);
-        const value = await this.#request(`/api/v1/documents/${encodeURIComponent(id)}/${action}`, { method: "POST" });
+        const value = await this.#request(withScope(`/api/v1/documents/${encodeURIComponent(id)}/${action}`, scope), { method: "POST" });
+        if (!isPublicDocument(value)) {
+            throw new Error("Daemon returned an invalid document response");
+        }
+        return value;
+    }
+    async bulkAct(action, ids, scope = {}) {
+        assertDocumentIds(ids);
+        const value = await this.#request(withScope("/api/v1/documents/bulk", scope), { method: "POST", body: { action, ids } });
+        if (!isBulkDocumentResult(value, action)) {
+            throw new Error("Daemon returned an invalid bulk document response");
+        }
+        return value;
+    }
+    async purgeDocument(id, scope = {}) {
+        assertDocumentId(id);
+        const value = await this.#request(withScope(`/api/v1/documents/${encodeURIComponent(id)}/purge`, scope), { method: "POST" });
+        if (!isRecord(value) || value.purgedId !== id) {
+            throw new Error("Daemon returned an invalid purge response");
+        }
+        return value.purgedId;
+    }
+    async getDocument(id, scope = {}) {
+        assertDocumentId(id);
+        const value = await this.#request(withScope(`/api/v1/documents/${encodeURIComponent(id)}`, scope));
+        if (!isPublicDocument(value)) {
+            throw new Error("Daemon returned an invalid document response");
+        }
+        return value;
+    }
+    async setDocumentTags(id, tags, scope = {}) {
+        assertDocumentId(id);
+        const value = await this.#request(withScope(`/api/v1/documents/${encodeURIComponent(id)}/tags`, scope), { method: "PUT", body: { tags } });
         if (!isPublicDocument(value)) {
             throw new Error("Daemon returned an invalid document response");
         }
@@ -250,12 +388,39 @@ export class DeskApiClient {
         return body.data;
     }
 }
-function isHealth(value) {
+function isCoreHealth(value) {
     return (isRecord(value) &&
         value.service === "mdmaid.desk" &&
         value.status === "ok" &&
         typeof value.version === "number");
 }
+function isPublicSpaceMatcher(value) {
+    return isRecord(value) &&
+        Object.keys(value).length === 2 &&
+        (value.kind === "repository" ||
+            value.kind === "repository-namespace" ||
+            value.kind === "tag") &&
+        typeof value.value === "string";
+}
+function isPublicSpace(value) {
+    return isRecord(value) &&
+        Object.keys(value).length === 3 &&
+        typeof value.id === "string" &&
+        /^[a-z0-9][a-z0-9-]{0,63}$/.test(value.id) &&
+        typeof value.name === "string" &&
+        Array.isArray(value.matchers) &&
+        value.matchers.length > 0 &&
+        value.matchers.every(isPublicSpaceMatcher);
+}
+function isPublicRepository(value) {
+    return isRecord(value) &&
+        Object.keys(value).length === 4 &&
+        typeof value.key === "string" &&
+        typeof value.name === "string" &&
+        Array.isArray(value.workspaceIds) &&
+        value.workspaceIds.every((id) => typeof id === "string") &&
+        (value.kind === "remote" || value.kind === "local");
+}
 function isPublicWorkspace(value) {
     return (isRecord(value) &&
         typeof value.id === "string" &&
@@ -263,6 +428,29 @@ function isPublicWorkspace(value) {
         typeof value.documentCount === "number" &&
         typeof value.route === "string");
 }
+function isPublicWorkspaceReconciliation(value) {
+    return isRecord(value) &&
+        Object.keys(value).length === 7 &&
+        typeof value.sourceWorkspaceId === "string" &&
+        typeof value.targetWorkspaceId === "string" &&
+        typeof value.applied === "boolean" &&
+        Array.isArray(value.movedDocumentIds) &&
+        value.movedDocumentIds.every((id) => typeof id === "string") &&
+        Array.isArray(value.discardedDocumentIds) &&
+        value.discardedDocumentIds.every((id) => typeof id === "string") &&
+        Array.isArray(value.blockingConflicts) &&
+        value.blockingConflicts.every(isPublicWorkspaceReconciliationConflict) &&
+        typeof value.reviewRequestCount === "number" &&
+        Number.isSafeInteger(value.reviewRequestCount) &&
+        value.reviewRequestCount >= 0;
+}
+function isPublicWorkspaceReconciliationConflict(value) {
+    return isRecord(value) &&
+        Object.keys(value).length === 3 &&
+        typeof value.sourceDocumentId === "string" &&
+        typeof value.targetDocumentId === "string" &&
+        (value.reason === "path-conflict" || value.reason === "review-history");
+}
 function isPublicProject(value) {
     return (isRecord(value) &&
         typeof value.id === "string" &&
@@ -303,6 +491,15 @@ function isPublicDocument(value) {
         typeof value.updatedAt === "string" &&
         typeof value.route === "string");
 }
+function isBulkDocumentResult(value, action) {
+    if (!isRecord(value) || value.action !== action) {
+        return false;
+    }
+    return action === "purge"
+        ? Array.isArray(value.purgedIds) &&
+            value.purgedIds.every((id) => typeof id === "string" && isDocumentId(id))
+        : Array.isArray(value.documents) && value.documents.every(isPublicDocument);
+}
 export function isPublicReviewRequest(value) {
     if (!isRecord(value)) {
         return false;
@@ -440,7 +637,7 @@ function dispatchEventBlock(block, listener, onReady) {
         onReady?.();
         return;
     }
-    if (type !== "catalog") {
+    if (type !== "catalog-invalidated") {
         return;
     }
     let value;
@@ -450,55 +647,10 @@ function dispatchEventBlock(block, listener, onReady) {
     catch {
         throw new Error("Daemon returned an invalid catalog event");
     }
-    const liveSourceAction = isRecord(value) &&
-        (value.action === "source-changed" ||
-            value.action === "source-missing" ||
-            value.action === "source-restored");
-    if (!isRecord(value) ||
-        !Object.keys(value).every((key) => [
-            "action",
-            "documentId",
-            "revision",
-            "reviewRequestId",
-            "workspaceId",
-        ].includes(key)) ||
-        typeof value.action !== "string" ||
-        (value.documentId !== undefined &&
-            (typeof value.documentId !== "string" ||
-                !/^doc-[a-f0-9]{20}$/.test(value.documentId))) ||
-        (value.workspaceId !== undefined &&
-            (typeof value.workspaceId !== "string" ||
-                !/^[a-z0-9][a-z0-9-]{0,63}$/.test(value.workspaceId))) ||
-        (value.reviewRequestId !== undefined &&
-            (typeof value.reviewRequestId !== "string" ||
-                !/^review-[a-f0-9]{20}$/.test(value.reviewRequestId))) ||
-        (value.revision !== undefined &&
-            (typeof value.revision !== "number" ||
-                !Number.isSafeInteger(value.revision) ||
-                value.revision < 1)) ||
-        (liveSourceAction &&
-            (value.documentId === undefined || value.revision === undefined)) ||
-        (!liveSourceAction && value.revision !== undefined) ||
-        (value.documentId === undefined &&
-            value.workspaceId === undefined &&
-            value.reviewRequestId === undefined)) {
+    if (!isRecord(value) || Object.keys(value).length !== 0) {
         throw new Error("Daemon returned an invalid catalog event");
     }
-    listener({
-        action: value.action,
-        ...(value.documentId === undefined
-            ? {}
-            : { documentId: value.documentId }),
-        ...(value.revision === undefined
-            ? {}
-            : { revision: value.revision }),
-        ...(value.workspaceId === undefined
-            ? {}
-            : { workspaceId: value.workspaceId }),
-        ...(value.reviewRequestId === undefined
-            ? {}
-            : { reviewRequestId: value.reviewRequestId }),
-    });
+    listener({});
 }
 function optionalString(value) {
     return value === undefined || typeof value === "string";
@@ -515,6 +667,18 @@ function nullableInteger(value) {
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function assertDocumentIds(ids) {
+    if (!Array.isArray(ids) ||
+        ids.length === 0 ||
+        ids.length > 500 ||
+        !ids.every((id) => typeof id === "string" && isDocumentId(id)) ||
+        new Set(ids).size !== ids.length) {
+        throw new Error("document ids must contain between 1 and 500 unique ids");
+    }
+}
+function isDocumentId(value) {
+    return /^doc-[a-f0-9]{20}$/.test(value);
+}
 function assertDocumentId(id) {
     if (!/^doc-[a-f0-9]{20}$/.test(id)) {
         throw new Error("invalid document id");
@@ -525,4 +689,30 @@ function assertReviewRequestId(id) {
         throw new Error("invalid review request id");
     }
 }
+function assertSpaceId(id) {
+    if (!/^[a-z0-9][a-z0-9-]{0,63}$/.test(id)) {
+        throw new Error("invalid Space id");
+    }
+}
+function assertWorkspaceId(id) {
+    if (!/^[a-z0-9][a-z0-9-]{0,63}$/.test(id)) {
+        throw new Error("invalid workspace id");
+    }
+}
+function addScope(query, scope) {
+    if (!isRecord(scope) ||
+        !Object.keys(scope).every((key) => key === "spaceId") ||
+        (scope.spaceId !== undefined && typeof scope.spaceId !== "string")) {
+        throw new Error("invalid content scope");
+    }
+    if (scope.spaceId !== undefined) {
+        assertSpaceId(scope.spaceId);
+        query.set("space", scope.spaceId);
+    }
+}
+function withScope(path, scope) {
+    const url = new URL(path, "http://mdmaid.desk.localhost");
+    addScope(url.searchParams, scope);
+    return `${url.pathname}${url.search}${url.hash}`;
+}
 //# sourceMappingURL=api-client.js.map