@camerontaylor/paseo-server 0.8.0-fork.1

package/dist/server/server/workspace-labels/index.d.ts

@@ -0,0 +1,14 @@
+import type { FileBackedWorkspaceRegistry } from "../workspace-registry.js";
+import { WorkspaceLabelService } from "./internal/service.js";
+import type { WorkspaceLabelDefinition } from "@camerontaylor/paseo-protocol/workspace-labels";
+export { WorkspaceLabelError, WorkspaceLabelService } from "./internal/service.js";
+export { WorkspaceLabelStorageUncertainError } from "./internal/catalog-store.js";
+export declare function createWorkspaceLabelService(input: {
+    paseoHome: string;
+    workspaceRegistry: FileBackedWorkspaceRegistry;
+    writeCatalog?: (filePath: string, labels: readonly WorkspaceLabelDefinition[]) => Promise<void>;
+    writeTransaction?: (filePath: string, transaction: unknown) => Promise<void>;
+    removeTransaction?: (filePath: string) => Promise<void>;
+    journalLimit?: number;
+}): WorkspaceLabelService;
+//# sourceMappingURL=index.d.ts.map

package/dist/server/server/workspace-labels/index.js

@@ -0,0 +1,10 @@
+import { join } from "node:path";
+import { WorkspaceLabelCatalogStore } from "./internal/catalog-store.js";
+import { WorkspaceLabelService } from "./internal/service.js";
+import { WorkspaceLabelSequence } from "./internal/sequence.js";
+export { WorkspaceLabelError, WorkspaceLabelService } from "./internal/service.js";
+export { WorkspaceLabelStorageUncertainError } from "./internal/catalog-store.js";
+export function createWorkspaceLabelService(input) {
+    return new WorkspaceLabelService(new WorkspaceLabelCatalogStore(join(input.paseoHome, "projects", "workspace-labels.json"), join(input.paseoHome, "projects", "workspace-labels.transaction.json"), input.workspaceRegistry, input.writeCatalog, input.writeTransaction, input.removeTransaction), new WorkspaceLabelSequence(input.journalLimit));
+}
+//# sourceMappingURL=index.js.map

package/dist/server/server/workspace-labels/internal/catalog-store.d.ts

@@ -0,0 +1,50 @@
+import type { WorkspaceLabelDefinition } from "@camerontaylor/paseo-protocol/workspace-labels";
+import type { PersistedWorkspaceRecord } from "../../workspace-registry.js";
+interface WorkspaceLabelCompoundRegistry {
+    blockAllMutationsUntilRestart(): void;
+    commitWorkspaceLabelMutation<TResult>(input: {
+        stage: (records: ReadonlyMap<string, PersistedWorkspaceRecord>) => {
+            updates: readonly PersistedWorkspaceRecord[];
+            result: TResult;
+            forcePersist: boolean;
+        };
+        beforeWorkspaceWrite: (records: readonly PersistedWorkspaceRecord[]) => Promise<void>;
+        afterWorkspaceWrite: () => Promise<void>;
+        afterCommit: () => void;
+        publish?: boolean;
+    }): Promise<TResult>;
+}
+interface WorkspaceLabelMutation<TResult> {
+    labels: WorkspaceLabelDefinition[];
+    workspaceUpdates: PersistedWorkspaceRecord[];
+    result: TResult;
+}
+export declare class WorkspaceLabelStorageUncertainError extends Error {
+    readonly code = "workspace_label_storage_uncertain";
+    constructor();
+}
+export declare class WorkspaceLabelCatalogStore {
+    private readonly filePath;
+    private readonly transactionPath;
+    private readonly workspaces;
+    private readonly writeCatalog;
+    private readonly writeTransaction;
+    private readonly removeTransaction;
+    private loaded;
+    private initializing;
+    private labels;
+    private blocked;
+    constructor(filePath: string, transactionPath: string, workspaces: WorkspaceLabelCompoundRegistry, writeCatalog?: (filePath: string, labels: readonly WorkspaceLabelDefinition[]) => Promise<void>, writeTransaction?: (filePath: string, transaction: unknown) => Promise<void>, removeTransaction?: (filePath: string) => Promise<void>);
+    initialize(): Promise<void>;
+    list(): Promise<WorkspaceLabelDefinition[]>;
+    commit<TResult>(planner: (labels: readonly WorkspaceLabelDefinition[], workspaces: ReadonlyMap<string, PersistedWorkspaceRecord>) => WorkspaceLabelMutation<TResult>): Promise<TResult>;
+    private resolveFailedCommit;
+    private blockUntilRestart;
+    private loadAndRecover;
+    private readCatalog;
+    private readTransaction;
+    private requireTransaction;
+    private recover;
+}
+export {};
+//# sourceMappingURL=catalog-store.d.ts.map

package/dist/server/server/workspace-labels/internal/catalog-store.js

@@ -0,0 +1,203 @@
+import { promises as fs } from "node:fs";
+import { z } from "zod";
+import { WorkspaceLabelDefinitionSchema } from "@camerontaylor/paseo-protocol/messages";
+import { writeJsonFileAtomic } from "../../atomic-file.js";
+const WorkspaceLabelWorkspaceStateSchema = z.object({
+    workspaceId: z.string(),
+    labels: z.array(z.string()).optional(),
+    updatedAt: z.string(),
+});
+const WorkspaceLabelTransactionSchema = z.object({
+    phase: z.enum(["prepared", "committed"]),
+    beforeLabels: z.array(WorkspaceLabelDefinitionSchema),
+    afterLabels: z.array(WorkspaceLabelDefinitionSchema),
+    beforeWorkspaces: z.array(WorkspaceLabelWorkspaceStateSchema),
+    afterWorkspaces: z.array(WorkspaceLabelWorkspaceStateSchema),
+});
+export class WorkspaceLabelStorageUncertainError extends Error {
+    constructor() {
+        super("Workspace label storage outcome is uncertain; restart the daemon before retrying");
+        this.code = "workspace_label_storage_uncertain";
+        this.name = "WorkspaceLabelStorageUncertainError";
+    }
+}
+export class WorkspaceLabelCatalogStore {
+    constructor(filePath, transactionPath, workspaces, writeCatalog = writeJsonFileAtomic, writeTransaction = writeJsonFileAtomic, removeTransaction = fs.rm) {
+        this.filePath = filePath;
+        this.transactionPath = transactionPath;
+        this.workspaces = workspaces;
+        this.writeCatalog = writeCatalog;
+        this.writeTransaction = writeTransaction;
+        this.removeTransaction = removeTransaction;
+        this.loaded = false;
+        this.initializing = null;
+        this.labels = [];
+        this.blocked = false;
+    }
+    async initialize() {
+        if (this.loaded)
+            return;
+        if (!this.initializing) {
+            this.initializing = this.loadAndRecover().finally(() => {
+                this.initializing = null;
+            });
+        }
+        await this.initializing;
+    }
+    async list() {
+        await this.initialize();
+        return this.labels.map((label) => ({ ...label }));
+    }
+    async commit(planner) {
+        await this.initialize();
+        if (this.blocked)
+            throw new WorkspaceLabelStorageUncertainError();
+        let mutation;
+        let transaction = null;
+        const result = await this.workspaces
+            .commitWorkspaceLabelMutation({
+            stage: (workspaces) => {
+                mutation = planner(this.labels, workspaces);
+                transaction = transactionFor(this.labels, mutation, workspaces);
+                return {
+                    updates: mutation.workspaceUpdates,
+                    result: mutation.result,
+                    forcePersist: mutation.workspaceUpdates.length > 0 || !catalogsEqual(this.labels, mutation.labels),
+                };
+            },
+            beforeWorkspaceWrite: async () => {
+                if (!transaction)
+                    throw new Error("Workspace label transaction was not staged");
+                await this.writeTransaction(this.transactionPath, transaction);
+                await this.writeCatalog(this.filePath, transaction.afterLabels);
+            },
+            afterWorkspaceWrite: async () => {
+                if (!transaction)
+                    throw new Error("Workspace label transaction was not staged");
+                transaction = { ...transaction, phase: "committed" };
+                await this.writeTransaction(this.transactionPath, transaction);
+            },
+            afterCommit: () => {
+                this.labels = [...mutation.labels];
+            },
+        })
+            .catch(async (error) => {
+            await this.resolveFailedCommit(error);
+        });
+        await this.removeTransaction(this.transactionPath).catch(() => undefined);
+        return result;
+    }
+    async resolveFailedCommit(error) {
+        let durable;
+        try {
+            durable = await this.readTransaction();
+        }
+        catch {
+            this.blockUntilRestart();
+        }
+        if (!durable)
+            throw error;
+        if (durable.phase === "committed") {
+            this.blockUntilRestart();
+        }
+        try {
+            await this.recover(durable);
+        }
+        catch {
+            this.blockUntilRestart();
+        }
+        throw error;
+    }
+    blockUntilRestart() {
+        this.blocked = true;
+        this.workspaces.blockAllMutationsUntilRestart();
+        throw new WorkspaceLabelStorageUncertainError();
+    }
+    async loadAndRecover() {
+        const transaction = await this.readTransaction();
+        if (transaction) {
+            await this.recover(transaction);
+            this.loaded = true;
+            return;
+        }
+        this.labels = await this.readCatalog();
+        this.loaded = true;
+    }
+    async readCatalog() {
+        try {
+            const raw = await fs.readFile(this.filePath, "utf8");
+            return z.array(WorkspaceLabelDefinitionSchema).parse(JSON.parse(raw));
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return [];
+            throw error;
+        }
+    }
+    async readTransaction() {
+        try {
+            return await this.requireTransaction();
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return null;
+            throw error;
+        }
+    }
+    async requireTransaction() {
+        const raw = await fs.readFile(this.transactionPath, "utf8");
+        return WorkspaceLabelTransactionSchema.parse(JSON.parse(raw));
+    }
+    async recover(transaction) {
+        if (transaction.phase === "committed") {
+            // The marker exists only after both data files are durable. It is cleanup state, never an
+            // instruction to replay stale after-images over newer workspace mutations.
+            this.labels = await this.readCatalog();
+            await this.removeTransaction(this.transactionPath).catch(() => undefined);
+            return;
+        }
+        const labels = transaction.beforeLabels;
+        const workspaceStates = transaction.beforeWorkspaces;
+        await this.workspaces.commitWorkspaceLabelMutation({
+            stage: (workspaces) => ({
+                updates: workspaceStates.flatMap((state) => {
+                    const current = workspaces.get(state.workspaceId);
+                    return current ? [{ ...current, labels: state.labels, updatedAt: state.updatedAt }] : [];
+                }),
+                result: undefined,
+                forcePersist: true,
+            }),
+            beforeWorkspaceWrite: () => this.writeCatalog(this.filePath, labels),
+            afterWorkspaceWrite: () => this.removeTransaction(this.transactionPath),
+            afterCommit: () => {
+                this.labels = [...labels];
+            },
+            publish: false,
+        });
+    }
+}
+function transactionFor(currentLabels, mutation, workspaces) {
+    const beforeWorkspaces = mutation.workspaceUpdates.flatMap((workspace) => {
+        const current = workspaces.get(workspace.workspaceId);
+        return current ? [workspaceState(current)] : [];
+    });
+    return {
+        phase: "prepared",
+        beforeLabels: currentLabels.map((label) => ({ ...label })),
+        afterLabels: mutation.labels.map((label) => ({ ...label })),
+        beforeWorkspaces,
+        afterWorkspaces: mutation.workspaceUpdates.map(workspaceState),
+    };
+}
+function workspaceState(workspace) {
+    return {
+        workspaceId: workspace.workspaceId,
+        ...(workspace.labels ? { labels: [...workspace.labels] } : {}),
+        updatedAt: workspace.updatedAt,
+    };
+}
+function catalogsEqual(left, right) {
+    return (left.length === right.length &&
+        left.every((label, index) => label.name === right[index]?.name && label.color === right[index]?.color));
+}
+//# sourceMappingURL=catalog-store.js.map

package/dist/server/server/workspace-labels/internal/sequence.d.ts

@@ -0,0 +1,43 @@
+import type { WorkspaceLabelDefinition } from "@camerontaylor/paseo-protocol/workspace-labels";
+export type WorkspaceLabelChange = {
+    kind: "upsert";
+    label: WorkspaceLabelDefinition;
+    previousName?: string;
+} | {
+    kind: "remove";
+    name: string;
+};
+interface SequencedChange {
+    generation: string;
+    seq: number;
+    change: WorkspaceLabelChange;
+}
+export interface WorkspaceLabelCursor {
+    generation: string;
+    afterSeq: number;
+}
+export interface WorkspaceLabelSync {
+    labels: WorkspaceLabelDefinition[];
+    sync: {
+        mode: "snapshot" | "changes";
+        generation: string;
+        headSeq: number;
+        removals: Array<{
+            name: string;
+            seq: number;
+        }>;
+    };
+}
+export declare class WorkspaceLabelSequence {
+    private readonly journalLimit;
+    private readonly generation;
+    private headSeq;
+    private readonly journal;
+    private readonly subscribers;
+    constructor(journalLimit?: number);
+    subscribe(listener: (change: SequencedChange) => void): () => void;
+    publish(change: WorkspaceLabelChange): void;
+    synchronize(catalog: readonly WorkspaceLabelDefinition[], cursor?: WorkspaceLabelCursor): WorkspaceLabelSync;
+}
+export {};
+//# sourceMappingURL=sequence.d.ts.map

package/dist/server/server/workspace-labels/internal/sequence.js

@@ -0,0 +1,80 @@
+import { randomUUID } from "node:crypto";
+export class WorkspaceLabelSequence {
+    constructor(journalLimit = 256) {
+        this.journalLimit = journalLimit;
+        this.generation = randomUUID();
+        this.headSeq = 0;
+        this.journal = [];
+        this.subscribers = new Set();
+    }
+    subscribe(listener) {
+        this.subscribers.add(listener);
+        return () => this.subscribers.delete(listener);
+    }
+    publish(change) {
+        const entry = { generation: this.generation, seq: ++this.headSeq, change };
+        this.journal.push(entry);
+        if (this.journal.length > this.journalLimit)
+            this.journal.shift();
+        for (const subscriber of this.subscribers) {
+            try {
+                subscriber(entry);
+            }
+            catch {
+                // Publication follows durable persistence and cannot fail the mutation.
+            }
+        }
+    }
+    synchronize(catalog, cursor) {
+        const oldestSeq = this.journal[0]?.seq ?? this.headSeq + 1;
+        const canCatchUp = cursor?.generation === this.generation &&
+            cursor.afterSeq <= this.headSeq &&
+            cursor.afterSeq >= oldestSeq - 1;
+        if (!canCatchUp) {
+            return {
+                labels: catalog.map((label) => ({ ...label })),
+                sync: {
+                    mode: "snapshot",
+                    generation: this.generation,
+                    headSeq: this.headSeq,
+                    removals: [],
+                },
+            };
+        }
+        const changes = this.journal.filter((entry) => entry.seq > cursor.afterSeq);
+        const upserts = new Map();
+        const removals = new Map();
+        for (const entry of changes) {
+            if (entry.change.kind === "remove") {
+                const key = entry.change.name.toLowerCase();
+                const wasCreatedDuringCatchUp = upserts.delete(key);
+                if (!wasCreatedDuringCatchUp) {
+                    removals.set(key, { name: entry.change.name, seq: entry.seq });
+                }
+                continue;
+            }
+            if (entry.change.previousName) {
+                const previousKey = entry.change.previousName.toLowerCase();
+                const wasCreatedDuringCatchUp = upserts.delete(previousKey);
+                if (!wasCreatedDuringCatchUp) {
+                    removals.set(previousKey, {
+                        name: entry.change.previousName,
+                        seq: entry.seq,
+                    });
+                }
+            }
+            removals.delete(entry.change.label.name.toLowerCase());
+            upserts.set(entry.change.label.name.toLowerCase(), entry.change.label);
+        }
+        return {
+            labels: [...upserts.values()],
+            sync: {
+                mode: "changes",
+                generation: this.generation,
+                headSeq: this.headSeq,
+                removals: [...removals.values()],
+            },
+        };
+    }
+}
+//# sourceMappingURL=sequence.js.map

package/dist/server/server/workspace-labels/internal/service.d.ts

@@ -0,0 +1,57 @@
+import { type WorkspaceLabelDefinition } from "@camerontaylor/paseo-protocol/workspace-labels";
+import { WorkspaceLabelCatalogStore } from "./catalog-store.js";
+import { WorkspaceLabelSequence, type WorkspaceLabelChange, type WorkspaceLabelCursor } from "./sequence.js";
+export declare class WorkspaceLabelError extends Error {
+    readonly code: "label_name_empty" | "label_not_found" | "label_name_taken" | "workspace_not_found";
+    constructor(code: "label_name_empty" | "label_not_found" | "label_name_taken" | "workspace_not_found", message: string);
+}
+export declare class WorkspaceLabelService {
+    private readonly catalog;
+    private readonly sequence;
+    private operations;
+    constructor(catalog: WorkspaceLabelCatalogStore, sequence?: WorkspaceLabelSequence);
+    initialize(): Promise<void>;
+    subscribe(input: {
+        cursor?: WorkspaceLabelCursor;
+        onChange: (change: WorkspaceLabelChange & {
+            generation: string;
+            seq: number;
+        }) => void;
+    }): Promise<{
+        snapshot: ReturnType<WorkspaceLabelSequence["synchronize"]>;
+        unsubscribe: () => void;
+    }>;
+    setAssignment(input: {
+        workspaceId: string;
+        label: WorkspaceLabelDefinition;
+        assigned: boolean;
+    }): Promise<{
+        label: WorkspaceLabelDefinition;
+        workspaceLabels: string[];
+    }>;
+    /**
+     * Edit a label: a new name, a new colour, or both, in one catalog commit.
+     *
+     * Both fields are optional and an omitted field is left alone. They travel together because
+     * the alternative — a rename that succeeds and a recolour that then fails — leaves the catalog
+     * in a state nobody asked for and no client can describe.
+     *
+     * Renaming onto a name the host already has is rejected, not merged. Merging would fold two
+     * labels' assignments together with no way back, and the user asked to edit one label. The
+     * check happens inside the planner, so a rejected collision applies neither field.
+     */
+    update(input: {
+        name: string;
+        newName?: string;
+        color?: WorkspaceLabelDefinition["color"];
+    }): Promise<{
+        label: WorkspaceLabelDefinition;
+        affectedWorkspaceCount: number;
+    }>;
+    delete(nameInput: string): Promise<{
+        affectedWorkspaceCount: number;
+    }>;
+    countAffectedWorkspaces(nameInput: string): Promise<number>;
+    private exclusive;
+}
+//# sourceMappingURL=service.d.ts.map

package/dist/server/server/workspace-labels/internal/service.js

@@ -0,0 +1,224 @@
+import { normalizeWorkspaceLabelName, workspaceLabelKey, } from "@camerontaylor/paseo-protocol/workspace-labels";
+import { WorkspaceLabelSequence, } from "./sequence.js";
+export class WorkspaceLabelError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "WorkspaceLabelError";
+    }
+}
+export class WorkspaceLabelService {
+    constructor(catalog, sequence = new WorkspaceLabelSequence()) {
+        this.catalog = catalog;
+        this.sequence = sequence;
+        this.operations = Promise.resolve();
+    }
+    async initialize() {
+        await this.catalog.initialize();
+    }
+    async subscribe(input) {
+        return this.exclusive(async () => {
+            const unsubscribe = this.sequence.subscribe((entry) => input.onChange({ ...entry.change, generation: entry.generation, seq: entry.seq }));
+            try {
+                const labels = await this.catalog.list();
+                return { snapshot: this.sequence.synchronize(labels, input.cursor), unsubscribe };
+            }
+            catch (error) {
+                unsubscribe();
+                throw error;
+            }
+        });
+    }
+    async setAssignment(input) {
+        return this.exclusive(async () => {
+            const name = requireName(input.label.name);
+            const committed = await this.catalog.commit((catalog, workspaces) => {
+                const workspace = workspaces.get(input.workspaceId);
+                if (!workspace || workspace.archivedAt) {
+                    throw new WorkspaceLabelError("workspace_not_found", "Workspace not found");
+                }
+                const key = workspaceLabelKey(name);
+                const existing = catalog.find((label) => workspaceLabelKey(label.name) === key);
+                const definition = existing ?? { name, color: input.label.color };
+                const current = workspace.labels ?? [];
+                const workspaceLabels = updateAssignmentLabels(current, key, definition.name, input.assigned);
+                const workspaceChanged = workspaceLabels !== current;
+                const catalogChanged = !existing && input.assigned;
+                return {
+                    labels: catalogChanged ? [...catalog, definition] : [...catalog],
+                    workspaceUpdates: workspaceChanged
+                        ? [
+                            {
+                                ...workspace,
+                                labels: workspaceLabels.length > 0 ? workspaceLabels : undefined,
+                                updatedAt: new Date().toISOString(),
+                            },
+                        ]
+                        : [],
+                    result: { definition, workspaceLabels, catalogChanged },
+                };
+            });
+            if (committed.catalogChanged) {
+                this.sequence.publish({ kind: "upsert", label: committed.definition });
+            }
+            return { label: committed.definition, workspaceLabels: committed.workspaceLabels };
+        });
+    }
+    /**
+     * Edit a label: a new name, a new colour, or both, in one catalog commit.
+     *
+     * Both fields are optional and an omitted field is left alone. They travel together because
+     * the alternative — a rename that succeeds and a recolour that then fails — leaves the catalog
+     * in a state nobody asked for and no client can describe.
+     *
+     * Renaming onto a name the host already has is rejected, not merged. Merging would fold two
+     * labels' assignments together with no way back, and the user asked to edit one label. The
+     * check happens inside the planner, so a rejected collision applies neither field.
+     */
+    async update(input) {
+        return this.exclusive(async () => {
+            const fromKey = workspaceLabelKey(requireName(input.name));
+            const newName = input.newName === undefined ? null : requireName(input.newName);
+            const committed = await this.catalog.commit((catalog, workspaces) => {
+                const existing = catalog.find((label) => workspaceLabelKey(label.name) === fromKey);
+                if (!existing)
+                    throw new WorkspaceLabelError("label_not_found", "Label not found");
+                // A label keeping its own key is not colliding with itself, so case-only edits pass.
+                if (newName !== null && workspaceLabelKey(newName) !== fromKey) {
+                    const toKey = workspaceLabelKey(newName);
+                    if (catalog.some((label) => workspaceLabelKey(label.name) === toKey)) {
+                        throw new WorkspaceLabelError("label_name_taken", "A label with that name already exists");
+                    }
+                }
+                const nameChanged = newName !== null && newName !== existing.name;
+                const colorChanged = input.color !== undefined && input.color !== existing.color;
+                if (!nameChanged && !colorChanged) {
+                    return {
+                        labels: [...catalog],
+                        workspaceUpdates: [],
+                        result: { label: existing, affectedWorkspaceCount: 0, changed: false },
+                    };
+                }
+                const label = {
+                    name: nameChanged && newName !== null ? newName : existing.name,
+                    color: input.color ?? existing.color,
+                };
+                // Workspaces store names, so only a rename rewrites assignments; a recolour is catalog-only.
+                const workspaceUpdates = nameChanged
+                    ? rewriteAssignments(workspaces, fromKey, label.name)
+                    : [];
+                return {
+                    labels: catalog.map((candidate) => (candidate === existing ? label : candidate)),
+                    workspaceUpdates,
+                    result: {
+                        label,
+                        affectedWorkspaceCount: workspaceUpdates.length,
+                        changed: true,
+                        ...(nameChanged ? { previousName: existing.name } : {}),
+                    },
+                };
+            });
+            if (committed.changed) {
+                this.sequence.publish({
+                    kind: "upsert",
+                    label: committed.label,
+                    previousName: committed.previousName,
+                });
+            }
+            return {
+                label: committed.label,
+                affectedWorkspaceCount: committed.affectedWorkspaceCount,
+            };
+        });
+    }
+    async delete(nameInput) {
+        return this.exclusive(async () => {
+            const key = workspaceLabelKey(requireName(nameInput));
+            const committed = await this.catalog.commit((catalog, workspaces) => {
+                const existing = catalog.find((label) => workspaceLabelKey(label.name) === key);
+                if (!existing) {
+                    return {
+                        labels: [...catalog],
+                        workspaceUpdates: [],
+                        result: { affectedWorkspaceCount: 0, deletedName: null },
+                    };
+                }
+                const workspaceUpdates = rewriteAssignments(workspaces, key);
+                return {
+                    labels: catalog.filter((label) => label !== existing),
+                    workspaceUpdates,
+                    result: {
+                        affectedWorkspaceCount: workspaceUpdates.length,
+                        deletedName: existing.name,
+                    },
+                };
+            });
+            if (committed.deletedName) {
+                this.sequence.publish({ kind: "remove", name: committed.deletedName });
+            }
+            return { affectedWorkspaceCount: committed.affectedWorkspaceCount };
+        });
+    }
+    async countAffectedWorkspaces(nameInput) {
+        return this.exclusive(() => {
+            const key = workspaceLabelKey(requireName(nameInput));
+            return this.catalog.commit((catalog, workspaces) => ({
+                labels: [...catalog],
+                workspaceUpdates: [],
+                result: [...workspaces.values()].filter((workspace) => workspaceHasLabel(workspace, key))
+                    .length,
+            }));
+        });
+    }
+    async exclusive(operation) {
+        const previous = this.operations;
+        let release;
+        this.operations = new Promise((resolve) => {
+            release = resolve;
+        });
+        await previous;
+        try {
+            return await operation();
+        }
+        finally {
+            release();
+        }
+    }
+}
+function updateAssignmentLabels(current, key, displayName, assigned) {
+    const assignedIndex = current.findIndex((label) => workspaceLabelKey(label) === key);
+    if (assigned)
+        return assignedIndex === -1 ? [...current, displayName] : current;
+    return assignedIndex === -1 ? current : current.filter((_, index) => index !== assignedIndex);
+}
+function workspaceHasLabel(workspace, key) {
+    return (workspace.labels ?? []).some((label) => workspaceLabelKey(label) === key);
+}
+function rewriteAssignments(workspaces, fromKey, to) {
+    const now = new Date().toISOString();
+    return [...workspaces.values()].flatMap((workspace) => {
+        const labels = workspace.labels ?? [];
+        if (!labels.some((label) => workspaceLabelKey(label) === fromKey))
+            return [];
+        const next = labels.flatMap((label) => {
+            if (workspaceLabelKey(label) !== fromKey)
+                return [label];
+            return to ? [to] : [];
+        });
+        return [
+            {
+                ...workspace,
+                labels: next.length > 0 ? next : undefined,
+                updatedAt: now,
+            },
+        ];
+    });
+}
+function requireName(raw) {
+    const name = normalizeWorkspaceLabelName(raw);
+    if (name.length === 0) {
+        throw new WorkspaceLabelError("label_name_empty", "Label name cannot be empty");
+    }
+    return name;
+}
+//# sourceMappingURL=service.js.map