canopycms 0.1.0 → 0.2.0-int.119

package/dist/assets/store-s3.js

@@ -2,7 +2,7 @@
  * S3-backed AssetStore. Same bucket-prefix layout as LocalAssetStore (see
  * keys.ts). Assumes an EXISTING content bucket (versioning/SSE/replication
  * already configured by the site's CDK stack). It reads and writes under the
- * five asset prefixes, plus a caller's output prefix for `copyPublicObject`.
+ * six asset prefixes, plus a caller's output prefix for `copyPublicObject`.
  */
 import { randomUUID } from 'node:crypto';
 import { CopyObjectCommand, DeleteObjectCommand, GetObjectCommand, HeadObjectCommand, ListObjectsV2Command, PutObjectCommand, S3Client, paginateListObjectsV2, } from '@aws-sdk/client-s3';
@@ -11,6 +11,8 @@ import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
 import { isHttpUrlOrSameOriginPath } from '../utils/sanitize-href.js';
 import { ASSET_PREFIXES, createKeyBuilders } from './keys.js';
 const DEFAULT_MAX_UPLOAD_BYTES = 50 * 1024 * 1024;
+/** What `metaKey` and `hiddenKey` put after the hash32. */
+const JSON_SUFFIX = '.json';
 const PRESIGN_EXPIRY_SECONDS = 15 * 60;
 /** A presigned read is followed by the browser at once; it is never stored or cached. */
 const PRESIGNED_READ_EXPIRY_SECONDS = 5 * 60;
@@ -234,7 +236,10 @@ export class S3AssetStore {
             throw err;
         }
     }
-    async *listPublicObjectKeys(prefix) {
+    listPublicObjectKeys(prefix) {
+        return this.listKeys(prefix);
+    }
+    async *listKeys(prefix) {
         const pages = paginateListObjectsV2({ client: this.client }, { Bucket: this.bucket, Prefix: prefix });
         for await (const page of pages) {
             for (const object of page.Contents ?? []) {
@@ -264,31 +269,69 @@ export class S3AssetStore {
             return null;
         return JSON.parse(Buffer.from(bytes).toString('utf-8'));
     }
+    /**
+     * One page of meta keys, filtered by a full listing of the hidden markers: few files are hidden,
+     * and a listing needs only `s3:ListBucket`. A hidden file's meta is fetched only for
+     * `includeHidden`.
+     */
     async listMeta(input) {
-        const listed = await this.client.send(new ListObjectsV2Command({
-            Bucket: this.bucket,
-            Prefix: this.keys.metaPrefix(),
-            MaxKeys: input?.limit,
-            ContinuationToken: input?.cursor,
-        }));
+        const metaPrefix = this.keys.metaPrefix();
+        const [listed, hidden] = await Promise.all([
+            this.client.send(new ListObjectsV2Command({
+                Bucket: this.bucket,
+                Prefix: metaPrefix,
+                MaxKeys: input?.limit,
+                ContinuationToken: input?.cursor,
+            })),
+            this.listHiddenHashes(),
+        ]);
         const objectKeys = (listed.Contents ?? [])
             .map((obj) => obj.Key)
             .filter((key) => Boolean(key));
         const fetched = await Promise.all(objectKeys.map(async (key) => {
+            const isHidden = hidden.has(key.slice(metaPrefix.length, -JSON_SUFFIX.length));
+            if (isHidden && !input?.includeHidden)
+                return null;
             const bytes = await this.getObjectBytes(key);
-            // A meta object deleted between LIST and GET (deleteMeta race) reads
-            // as null; skip it rather than failing the whole page.
             if (!bytes)
                 return null;
-            return JSON.parse(Buffer.from(bytes).toString('utf-8'));
+            const meta = JSON.parse(Buffer.from(bytes).toString('utf-8'));
+            return isHidden ? { ...meta, hidden: true } : meta;
         }));
         return {
             items: fetched.filter((meta) => meta !== null),
             nextCursor: listed.IsTruncated ? listed.NextContinuationToken : undefined,
         };
     }
-    async deleteMeta(hash32) {
-        await this.client.send(new DeleteObjectCommand({ Bucket: this.bucket, Key: this.keys.metaKey(hash32) }));
+    async listHiddenHashes() {
+        const prefix = this.keys.hiddenPrefix();
+        const hashes = new Set();
+        for await (const key of this.listKeys(prefix)) {
+            if (key.endsWith(JSON_SUFFIX))
+                hashes.add(key.slice(prefix.length, -JSON_SUFFIX.length));
+        }
+        return hashes;
+    }
+    async hideAsset(hash32, marker) {
+        return this.putIfAbsent({
+            Key: this.keys.hiddenKey(hash32),
+            Body: JSON.stringify(marker),
+            ContentType: 'application/json',
+        });
+    }
+    /**
+     * Lists before deleting: a DELETE of an absent key writes a delete marker on a versioned bucket.
+     * The listing needs only `s3:ListBucket` covering `asset-hidden/` (a bucket-wide grant does; a
+     * policy scoping it by prefix must name this one), no object permission, so finalize can call
+     * this on every re-upload under a role that has never hidden a file.
+     */
+    async unhideAsset(hash32) {
+        const key = this.keys.hiddenKey(hash32);
+        const listed = await this.client.send(new ListObjectsV2Command({ Bucket: this.bucket, Prefix: key, MaxKeys: 1 }));
+        if (listed.Contents?.[0]?.Key !== key)
+            return false;
+        await this.client.send(new DeleteObjectCommand({ Bucket: this.bucket, Key: key }));
+        return true;
     }
     async getObject(key) {
         try {

package/dist/assets/types.d.ts

@@ -19,6 +19,15 @@ export interface AssetMeta {
     uploadedBy?: string;
     uploadedAt: string;
 }
+/** A listed asset; `hidden` is set only on a listing that includes hidden files. */
+export type ListedAssetMeta = AssetMeta & {
+    hidden?: true;
+};
+/** The body of a hidden marker. Only the marker's presence hides a file; this records who and when. */
+export interface HiddenAssetMarker {
+    hiddenAt: string;
+    hiddenBy?: string;
+}
 export type StagedUploadTarget = {
     mode: 'direct';
     url: string;
@@ -95,14 +104,29 @@ export interface AssetStore {
     listPublicObjectKeys?(prefix: string): AsyncIterable<string>;
     /** A short-lived URL a browser can GET `key` from directly, or `null` if absent. S3 only. */
     presignPublicObjectRead?(key: string): Promise<string | null>;
+    /**
+     * Meta is create-only and never deleted: every transform not yet stored, at upload, release or
+     * after a lazy output expires, is computed from it, and content anywhere may still name the file.
+     */
     putMetaIfAbsent(hash32: string, meta: AssetMeta): Promise<CreateOnlyResult>;
     getMeta(hash32: string): Promise<AssetMeta | null>;
+    /**
+     * A page of meta, without hidden files unless `includeHidden`, which marks each hidden one
+     * `hidden: true`. A page may hold fewer than `limit` items while `nextCursor` is still set.
+     */
     listMeta(input?: {
         cursor?: string;
         limit?: number;
+        includeHidden?: boolean;
     }): Promise<{
-        items: AssetMeta[];
+        items: ListedAssetMeta[];
         nextCursor?: string;
     }>;
-    deleteMeta(hash32: string): Promise<void>;
+    /**
+     * Hide a file from `listMeta`: a create-only marker beside its meta, which stays, so every URL
+     * and transform keeps working. `already-exists` when it was hidden already.
+     */
+    hideAsset(hash32: string, marker: HiddenAssetMarker): Promise<CreateOnlyResult>;
+    /** Remove the hidden marker; `false` when there was none. Needs no permission on a store that has never hidden a file. */
+    unhideAsset(hash32: string): Promise<boolean>;
 }

package/dist/cli/cli.js

@@ -13330,6 +13330,8 @@ var init_asset_prefixes = __esm({
       originals: "asset-originals",
       staging: "asset-staging",
       meta: "asset-meta",
+      /** One marker per file removed from the media library; its meta stays (see `hideAsset`). */
+      hidden: "asset-hidden",
       public: "assets",
       /** Transform-output prefix; directive-aware key building lives in transform-directives.ts. */
       transform: "assets/t"
@@ -14115,16 +14117,18 @@ function createKeyBuilders(prefixes = ASSET_PREFIXES) {
     stagingKey: (uuid) => `${prefixes.staging}/${uuid}`,
     metaKey: (hash32) => `${prefixes.meta}/${hash32}.json`,
     metaPrefix: () => `${prefixes.meta}/`,
+    hiddenKey: (hash32) => `${prefixes.hidden}/${hash32}.json`,
+    hiddenPrefix: () => `${prefixes.hidden}/`,
     publicKey: (hash32, slug, ext) => `${prefixes.public}/${hash32}/${slug}.${ext}`
   };
 }
-var keyBuilders, originalKey, stagingKey, metaKey, publicKey, originalPrefix, metaPrefix;
+var keyBuilders, originalKey, stagingKey, metaKey, hiddenKey, publicKey, originalPrefix, metaPrefix;
 var init_keys = __esm({
   "dist/assets/keys.js"() {
     "use strict";
     init_asset_prefixes();
     keyBuilders = createKeyBuilders();
-    ({ originalKey, stagingKey, metaKey, publicKey } = keyBuilders);
+    ({ originalKey, stagingKey, metaKey, hiddenKey, publicKey } = keyBuilders);
     ({ originalPrefix, metaPrefix } = keyBuilders);
   }
 });
@@ -14140,13 +14144,14 @@ function matchesAwsError(err2, name, httpStatusCode) {
   const shaped = err2;
   return shaped.name === name || shaped.$metadata?.httpStatusCode === httpStatusCode;
 }
-var DEFAULT_MAX_UPLOAD_BYTES, PRESIGN_EXPIRY_SECONDS, PRESIGNED_READ_EXPIRY_SECONDS, isPreconditionFailed, isConditionalRequestConflict, CONFLICT_ATTEMPTS, CONFLICT_BASE_DELAY_MS, isNoSuchKey, S3AssetStore;
+var DEFAULT_MAX_UPLOAD_BYTES, JSON_SUFFIX, PRESIGN_EXPIRY_SECONDS, PRESIGNED_READ_EXPIRY_SECONDS, isPreconditionFailed, isConditionalRequestConflict, CONFLICT_ATTEMPTS, CONFLICT_BASE_DELAY_MS, isNoSuchKey, S3AssetStore;
 var init_store_s3 = __esm({
   "dist/assets/store-s3.js"() {
     "use strict";
     init_sanitize_href3();
     init_keys();
     DEFAULT_MAX_UPLOAD_BYTES = 50 * 1024 * 1024;
+    JSON_SUFFIX = ".json";
     PRESIGN_EXPIRY_SECONDS = 15 * 60;
     PRESIGNED_READ_EXPIRY_SECONDS = 5 * 60;
     isPreconditionFailed = (err2) => matchesAwsError(err2, "PreconditionFailed", 412);
@@ -14341,7 +14346,10 @@ var init_store_s3 = __esm({
           throw err2;
         }
       }
-      async *listPublicObjectKeys(prefix) {
+      listPublicObjectKeys(prefix) {
+        return this.listKeys(prefix);
+      }
+      async *listKeys(prefix) {
         const pages = paginateListObjectsV2({ client: this.client }, { Bucket: this.bucket, Prefix: prefix });
         for await (const page of pages) {
           for (const object of page.Contents ?? []) {
@@ -14371,27 +14379,67 @@ var init_store_s3 = __esm({
           return null;
         return JSON.parse(Buffer.from(bytes).toString("utf-8"));
       }
+      /**
+       * One page of meta keys, filtered by a full listing of the hidden markers: few files are hidden,
+       * and a listing needs only `s3:ListBucket`. A hidden file's meta is fetched only for
+       * `includeHidden`.
+       */
       async listMeta(input) {
-        const listed = await this.client.send(new ListObjectsV2Command({
-          Bucket: this.bucket,
-          Prefix: this.keys.metaPrefix(),
-          MaxKeys: input?.limit,
-          ContinuationToken: input?.cursor
-        }));
+        const metaPrefix2 = this.keys.metaPrefix();
+        const [listed, hidden] = await Promise.all([
+          this.client.send(new ListObjectsV2Command({
+            Bucket: this.bucket,
+            Prefix: metaPrefix2,
+            MaxKeys: input?.limit,
+            ContinuationToken: input?.cursor
+          })),
+          this.listHiddenHashes()
+        ]);
         const objectKeys = (listed.Contents ?? []).map((obj) => obj.Key).filter((key) => Boolean(key));
         const fetched = await Promise.all(objectKeys.map(async (key) => {
+          const isHidden = hidden.has(key.slice(metaPrefix2.length, -JSON_SUFFIX.length));
+          if (isHidden && !input?.includeHidden)
+            return null;
           const bytes = await this.getObjectBytes(key);
           if (!bytes)
             return null;
-          return JSON.parse(Buffer.from(bytes).toString("utf-8"));
+          const meta = JSON.parse(Buffer.from(bytes).toString("utf-8"));
+          return isHidden ? { ...meta, hidden: true } : meta;
         }));
         return {
           items: fetched.filter((meta) => meta !== null),
           nextCursor: listed.IsTruncated ? listed.NextContinuationToken : void 0
         };
       }
-      async deleteMeta(hash32) {
-        await this.client.send(new DeleteObjectCommand({ Bucket: this.bucket, Key: this.keys.metaKey(hash32) }));
+      async listHiddenHashes() {
+        const prefix = this.keys.hiddenPrefix();
+        const hashes = /* @__PURE__ */ new Set();
+        for await (const key of this.listKeys(prefix)) {
+          if (key.endsWith(JSON_SUFFIX))
+            hashes.add(key.slice(prefix.length, -JSON_SUFFIX.length));
+        }
+        return hashes;
+      }
+      async hideAsset(hash32, marker) {
+        return this.putIfAbsent({
+          Key: this.keys.hiddenKey(hash32),
+          Body: JSON.stringify(marker),
+          ContentType: "application/json"
+        });
+      }
+      /**
+       * Lists before deleting: a DELETE of an absent key writes a delete marker on a versioned bucket.
+       * The listing needs only `s3:ListBucket` covering `asset-hidden/` (a bucket-wide grant does; a
+       * policy scoping it by prefix must name this one), no object permission, so finalize can call
+       * this on every re-upload under a role that has never hidden a file.
+       */
+      async unhideAsset(hash32) {
+        const key = this.keys.hiddenKey(hash32);
+        const listed = await this.client.send(new ListObjectsV2Command({ Bucket: this.bucket, Prefix: key, MaxKeys: 1 }));
+        if (listed.Contents?.[0]?.Key !== key)
+          return false;
+        await this.client.send(new DeleteObjectCommand({ Bucket: this.bucket, Key: key }));
+        return true;
       }
       async getObject(key) {
         try {
@@ -14766,7 +14814,14 @@ var init_asset_refs = __esm({
 import fs26 from "node:fs/promises";
 import path29 from "node:path";
 import { randomUUID as randomUUID4 } from "node:crypto";
-var DEFAULT_MAX_UPLOAD_BYTES2, DEFAULT_LIST_LIMIT, HEADERS_SIDECAR_SUFFIX, TEMP_DIR, ORIGINAL_EXT_RE, LocalAssetStore;
+function compareNewestFirst(a, b) {
+  if (a.uploadedAt !== b.uploadedAt)
+    return a.uploadedAt < b.uploadedAt ? 1 : -1;
+  if (a.hash32 === b.hash32)
+    return 0;
+  return a.hash32 < b.hash32 ? 1 : -1;
+}
+var DEFAULT_MAX_UPLOAD_BYTES2, DEFAULT_LIST_LIMIT, HEADERS_SIDECAR_SUFFIX, TEMP_DIR, ORIGINAL_EXT_RE, HIDDEN_MARKER_RE, LocalAssetStore;
 var init_store_local = __esm({
   "dist/assets/store-local.js"() {
     "use strict";
@@ -14778,6 +14833,7 @@ var init_store_local = __esm({
     HEADERS_SIDECAR_SUFFIX = ".headers.json";
     TEMP_DIR = ".asset-tmp";
     ORIGINAL_EXT_RE = /^[a-z0-9]+$/;
+    HIDDEN_MARKER_RE = /^([a-f0-9]{32})\.json$/;
     LocalAssetStore = class {
       constructor(options) {
         this.capabilities = { directUpload: false };
@@ -14849,11 +14905,12 @@ var init_store_local = __esm({
         }
       }
       /**
-       * Create-only write of a blob and its headers sidecar. Each is written whole to a temp file, then
-       * `link()`ed into place, which fails with EEXIST rather than replacing (see docs/concurrency.md).
-       * The sidecar is linked first, so a reader never finds a blob without its headers. A sidecar
-       * already there was linked by an earlier writer of this key and is kept, as the blob is: the
-       * first writer's headers win, as on S3 (a static's Content-Disposition names its uploaded file).
+       * Create-only write of a blob and, when `headers` is given, its headers sidecar. Each is written
+       * whole to a temp file, then `link()`ed into place, which fails with EEXIST rather than replacing
+       * (see docs/concurrency.md). The sidecar is linked first, so a reader never finds a blob without
+       * its headers. A sidecar already there was linked by an earlier writer of this key and is kept,
+       * as the blob is: the first writer's headers win, as on S3 (a static's Content-Disposition names
+       * its uploaded file).
        */
       async createExclusive(key, data, headers) {
         const filePath = this.resolveKey(key);
@@ -14866,8 +14923,10 @@ var init_store_local = __esm({
         const tempHeaders = path29.join(tempDir, randomUUID4());
         try {
           await fs26.writeFile(tempBlob, data);
-          await fs26.writeFile(tempHeaders, JSON.stringify(headers), "utf-8");
-          await this.linkIfAbsent(tempHeaders, this.headersSidecarPath(filePath));
+          if (headers) {
+            await fs26.writeFile(tempHeaders, JSON.stringify(headers), "utf-8");
+            await this.linkIfAbsent(tempHeaders, this.headersSidecarPath(filePath));
+          }
           return await this.linkIfAbsent(tempBlob, filePath) ? "created" : "already-exists";
         } finally {
           await Promise.all([tempBlob, tempHeaders].map((temp) => fs26.unlink(temp).catch(() => {
@@ -14999,6 +15058,11 @@ var init_store_local = __esm({
           throw err2;
         }
       }
+      /**
+       * The cursor names the last item returned, and the next page starts after it in sort order, so a
+       * page boundary holds when that item is hidden in between: its meta is never deleted, and the
+       * comparison needs only its place, not its presence in the filtered list.
+       */
       async listMeta(input) {
         const limit = input?.limit ?? DEFAULT_LIST_LIMIT;
         const dir = this.resolveKey(ASSET_PREFIXES.meta);
@@ -15022,29 +15086,43 @@ var init_store_local = __esm({
             }
           }
         }
-        all.sort((a, b) => {
-          if (a.uploadedAt !== b.uploadedAt)
-            return a.uploadedAt < b.uploadedAt ? 1 : -1;
-          return a.hash32 < b.hash32 ? 1 : -1;
-        });
+        all.sort(compareNewestFirst);
+        const hidden = await this.hiddenHashes();
+        const listed = input?.includeHidden ? all.map((meta) => hidden.has(meta.hash32) ? { ...meta, hidden: true } : meta) : all.filter((meta) => !hidden.has(meta.hash32));
         let startIndex = 0;
         if (input?.cursor) {
           const afterHash32 = Buffer.from(input.cursor, "base64").toString("utf-8");
-          const idx = all.findIndex((m) => m.hash32 === afterHash32);
-          startIndex = idx === -1 ? 0 : idx + 1;
+          const anchor = all.find((m) => m.hash32 === afterHash32);
+          if (anchor) {
+            const after = listed.findIndex((m) => compareNewestFirst(m, anchor) > 0);
+            startIndex = after === -1 ? listed.length : after;
+          }
         }
-        const items = all.slice(startIndex, startIndex + limit);
-        const hasMore = startIndex + limit < all.length;
+        const items = listed.slice(startIndex, startIndex + limit);
+        const hasMore = startIndex + limit < listed.length;
         const nextCursor = hasMore ? Buffer.from(items[items.length - 1].hash32, "utf-8").toString("base64") : void 0;
         return { items, nextCursor };
       }
-      async deleteMeta(hash32) {
-        const filePath = this.resolveKey(metaKey(hash32));
+      async hiddenHashes() {
         try {
-          await fs26.unlink(filePath);
+          const names = await fs26.readdir(this.resolveKey(ASSET_PREFIXES.hidden));
+          return new Set(names.flatMap((name) => HIDDEN_MARKER_RE.exec(name)?.[1] ?? []));
         } catch (err2) {
           if (isNotFoundError(err2))
-            return;
+            return /* @__PURE__ */ new Set();
+          throw err2;
+        }
+      }
+      async hideAsset(hash32, marker) {
+        return this.createExclusive(hiddenKey(hash32), new TextEncoder().encode(JSON.stringify(marker)));
+      }
+      async unhideAsset(hash32) {
+        try {
+          await fs26.unlink(this.resolveKey(hiddenKey(hash32)));
+          return true;
+        } catch (err2) {
+          if (isNotFoundError(err2))
+            return false;
           throw err2;
         }
       }

package/dist/editor/BranchManager.js

@@ -208,5 +208,6 @@ export const BranchManager = ({ branches, mode, user, currentBranchName, current
             ...branches.filter((b) => b.name !== currentBranchName),
         ]
         : branches;
-    return (_jsxs(Stack, { h: "100%", style: { display: 'flex', flexDirection: 'column' }, gap: 0, "data-testid": "branch-manager", children: [currentUserId && onAddComment && onResolveThread && (_jsx(Stack, { pt: "sm", children: _jsx(BranchComments, { comments: comments, currentUserId: currentUserId, canResolve: canResolve, onAddComment: onAddComment, onResolveThread: onResolveThread, highlightThreadId: highlightThreadId, onGetUserMetadata: onGetCommentUserMetadata }) })), !!supportsBranching && (_jsxs(Stack, { gap: "sm", pt: "sm", children: [_jsx(Button, { variant: "light", size: "sm", fullWidth: true, onClick: () => setShowCreateForm(!showCreateForm), disabled: creating, "data-testid": "create-branch-button", children: showCreateForm ? 'Cancel' : `${EDITOR_ACTIONS.newBranch}…` }), _jsx(Collapse, { in: showCreateForm, children: _jsx(Paper, { withBorder: true, p: "md", children: _jsxs(Stack, { gap: "sm", children: [_jsx(TextInput, { label: "Branch name", placeholder: "feature/my-branch", value: newBranchName, onChange: (e) => setNewBranchName(e.target.value), required: true, disabled: creating, "data-testid": "branch-name-input" }), _jsx(TextInput, { label: "Title", placeholder: "Brief description", value: newBranchTitle, onChange: (e) => setNewBranchTitle(e.target.value), disabled: creating, "data-testid": "branch-title-input" }), _jsx(Textarea, { label: "Description", placeholder: "Detailed description of the changes", value: newBranchDescription, onChange: (e) => setNewBranchDescription(e.target.value), minRows: 2, disabled: creating, "data-testid": "branch-description-textarea" }), _jsx(Button, { size: "sm", onClick: handleCreate, disabled: !newBranchName.trim(), loading: creating, fullWidth: true, "data-testid": "create-branch-submit", children: "Create branch" })] }) }) })] })), _jsx(ScrollArea, { style: { flex: 1 }, pb: "md", children: branches.length === 0 ? (_jsx(Text, { size: "sm", c: "dimmed", py: "md", children: !supportsBranching ? 'Branch management is not available.' : 'No branches available.' })) : (_jsx(Stack, { gap: "sm", children: orderedBranches.map((b) => (_jsx(BranchCard, { branch: b, isCurrent: b.name === currentBranchName, workflowBlockedReason: b.name === currentBranchName ? currentWorkflowBlockedReason : undefined, user: user, onSelect: onSelect, onSubmit: onSubmit, onWithdraw: onWithdraw, onRequestChanges: onRequestChanges, onDelete: onDelete, onGetUserMetadata: onGetUserMetadata, onGetOwnerMetadata: onGetOwnerMetadata }, b.name))) })) })] }));
+    const hasBranchThreads = comments.some((t) => t.type === 'branch');
+    return (_jsxs(Stack, { h: "100%", style: { display: 'flex', flexDirection: 'column' }, gap: 0, "data-testid": "branch-manager", children: [currentUserId && onAddComment && onResolveThread && hasBranchThreads && (_jsx(Stack, { pt: "sm", children: _jsx(BranchComments, { comments: comments, currentUserId: currentUserId, canResolve: canResolve, onAddComment: onAddComment, onResolveThread: onResolveThread, highlightThreadId: highlightThreadId, onGetUserMetadata: onGetCommentUserMetadata }) })), !!supportsBranching && (_jsxs(Stack, { gap: "sm", pt: "sm", children: [_jsx(Button, { variant: "light", size: "sm", fullWidth: true, onClick: () => setShowCreateForm(!showCreateForm), disabled: creating, "data-testid": "create-branch-button", children: showCreateForm ? 'Cancel' : `${EDITOR_ACTIONS.newBranch}…` }), _jsx(Collapse, { in: showCreateForm, children: _jsx(Paper, { withBorder: true, p: "md", children: _jsxs(Stack, { gap: "sm", children: [_jsx(TextInput, { label: "Branch name", placeholder: "feature/my-branch", value: newBranchName, onChange: (e) => setNewBranchName(e.target.value), required: true, disabled: creating, "data-testid": "branch-name-input" }), _jsx(TextInput, { label: "Title", placeholder: "Brief description", value: newBranchTitle, onChange: (e) => setNewBranchTitle(e.target.value), disabled: creating, "data-testid": "branch-title-input" }), _jsx(Textarea, { label: "Description", placeholder: "Detailed description of the changes", value: newBranchDescription, onChange: (e) => setNewBranchDescription(e.target.value), minRows: 2, disabled: creating, "data-testid": "branch-description-textarea" }), _jsx(Button, { size: "sm", onClick: handleCreate, disabled: !newBranchName.trim(), loading: creating, fullWidth: true, "data-testid": "create-branch-submit", children: "Create branch" })] }) }) })] })), _jsx(ScrollArea, { style: { flex: 1 }, pb: "md", children: branches.length === 0 ? (_jsx(Text, { size: "sm", c: "dimmed", py: "md", children: !supportsBranching ? 'Branch management is not available.' : 'No branches available.' })) : (_jsx(Stack, { gap: "sm", children: orderedBranches.map((b) => (_jsx(BranchCard, { branch: b, isCurrent: b.name === currentBranchName, workflowBlockedReason: b.name === currentBranchName ? currentWorkflowBlockedReason : undefined, user: user, onSelect: onSelect, onSubmit: onSubmit, onWithdraw: onWithdraw, onRequestChanges: onRequestChanges, onDelete: onDelete, onGetUserMetadata: onGetUserMetadata, onGetOwnerMetadata: onGetOwnerMetadata }, b.name))) })) })] }));
 };

package/dist/editor/CommentsPanel.js

@@ -1,23 +1,17 @@
 'use client';
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { useId, useRef, useState } from 'react';
-import { Badge, Button, Drawer, Group, Paper, ScrollArea, Stack, Text, Textarea, Title, Switch, Tooltip, VisuallyHidden, } from '@mantine/core';
+import { Badge, Button, Group, Paper, ScrollArea, Stack, Text, Textarea, Switch, Tooltip, VisuallyHidden, } from '@mantine/core';
+import { IconChevronRight } from '@tabler/icons-react';
 import { UserBadge } from './components/UserBadge.js';
 import { userIdLabel } from './user-display.js';
+import { OverlayDrawer } from './shell/OverlayHeader.js';
 import { RelativeTime } from './components/RelativeTime.js';
 import { ThreadReplyControls } from './comments/ThreadReplyControls.js';
 import { useTrackedWrites } from './comments/use-tracked-writes.js';
 import { CloseRefusedNotice } from './comments/CloseRefusedNotice.js';
 import { ON_REMOVED_ITEM } from './comments/item-anchor-copy.js';
 import { CommentWriteAlert, toCommentWriteFailure, } from './comments/CommentWriteAlert.js';
-/**
- * A jump button that stays focusable while a write is in flight (`aria-disabled`, not `disabled`),
- * so its reason opens on keyboard focus and touch as well as hover.
- */
-const JumpButton = ({ blocked, onClick, children }) => (_jsx(Tooltip, { label: "Your change is still saving. Try again once it finishes.", disabled: !blocked, multiline: true, maw: 280, children: _jsx(Button, { variant: "light", onClick: () => {
-            if (!blocked)
-                onClick();
-        }, "data-disabled": blocked ? true : undefined, "aria-disabled": blocked ? true : undefined, children: children }) }));
 const THREAD_KIND_LABELS = { field: 'Field', entry: 'Entry', branch: 'Branch' };
 export const CommentsPanel = ({ opened, branchName, comments, canResolve, currentUserId, onAddComment, onResolveThread, onClose, onJumpToField, onJumpToEntry, onJumpToBranch, onGetUserMetadata, entryLabel, fieldLabel, }) => {
     const [newCommentText, setNewCommentText] = useState('');
@@ -65,27 +59,71 @@ export const CommentsPanel = ({ opened, branchName, comments, canResolve, curren
             setIsSubmitting(false);
         }
     };
-    const threadHeading = (thread) => {
-        const kind = THREAD_KIND_LABELS[thread.type];
+    // "Entry › Field", or undefined for a thread on the branch itself.
+    const threadPath = (thread) => {
         if (!thread.entryPath)
-            return kind;
+            return undefined;
         const entry = entryLabel?.(thread.entryPath) ?? thread.entryPath;
         const field = thread.canopyPath ? (fieldLabel?.(thread) ?? thread.canopyPath) : undefined;
-        return `${kind} · ${field ? `${entry} › ${field}` : entry}`;
+        return field ? `${entry} › ${field}` : entry;
+    };
+    const threadHeading = (thread) => {
+        const kind = THREAD_KIND_LABELS[thread.type];
+        const path = threadPath(thread);
+        return path ? `${kind} · ${path}` : kind;
+    };
+    const jumpTarget = (thread) => {
+        const { entryPath, canopyPath } = thread;
+        if (thread.type === 'field' &&
+            entryPath &&
+            canopyPath &&
+            !thread.onRemovedItem &&
+            onJumpToField) {
+            return { label: 'Jump to field', go: () => onJumpToField(entryPath, canopyPath, thread.id) };
+        }
+        // A removed item's thread lives on its entry.
+        if ((thread.type === 'entry' || thread.onRemovedItem) && entryPath && onJumpToEntry) {
+            return { label: 'Jump to entry', go: () => onJumpToEntry(entryPath, thread.id) };
+        }
+        if (thread.type === 'branch' && onJumpToBranch) {
+            return { label: 'Open branch discussion', go: () => onJumpToBranch(thread.id) };
+        }
+        return null;
+    };
+    const setHeadingRef = (threadId, node) => {
+        if (node)
+            headingRefs.current.set(threadId, node);
+        else
+            headingRefs.current.delete(threadId);
     };
-    return (_jsx(Drawer, { opened: opened, onClose: close, returnFocus: !jumping, position: "right", size: 420, title: _jsxs("div", { children: [_jsx(Title, { order: 4, children: "Comments" }), _jsx(Text, { size: "xs", c: "dimmed", children: branchName })] }), children: _jsxs(Stack, { gap: "md", h: "100%", style: { display: 'flex', flexDirection: 'column' }, children: [_jsx(CloseRefusedNotice, { refused: closeRefused }), _jsx(Paper, { withBorder: true, p: "md", children: _jsxs(Stack, { gap: "sm", children: [_jsxs(Text, { size: "xs", c: "dimmed", children: ["Posts a branch-level comment on \"", branchName, "\". To comment on a field, use its comment icon."] }), _jsx(Textarea, { placeholder: "Add a comment\u2026", "aria-label": "New branch comment", value: newCommentText, onChange: (e) => setNewCommentText(e.target.value), minRows: 3, disabled: isSubmitting, "data-testid": "comment-textarea" }), error && _jsx(CommentWriteAlert, { failure: error, onClose: () => setError(null) }), _jsx(Button, { onClick: handleAddComment, size: "sm", loading: isSubmitting, disabled: !newCommentText.trim(), "data-testid": "comment-submit", children: "Comment" })] }) }), _jsxs(Group, { justify: "space-between", children: [_jsxs(Text, { ref: threadCountRef, size: "sm", fw: 500, tabIndex: -1, children: [filteredThreads.length, " ", filteredThreads.length === 1 ? 'thread' : 'threads'] }), _jsx(Switch, { label: "Show resolved", checked: showResolved, onChange: (e) => setShowResolved(e.currentTarget.checked), size: "sm" })] }), _jsx(ScrollArea, { style: { flex: 1 }, children: filteredThreads.length === 0 ? (_jsx(Text, { size: "sm", c: "dimmed", ta: "center", py: "xl", children: showResolved ? 'No comments yet' : 'No unresolved comments' })) : (_jsx(Stack, { gap: "md", children: filteredThreads.map((thread) => (_jsx(Paper, { withBorder: true, p: "md", component: "article", "aria-labelledby": headingId(thread.id), bg: thread.resolved ? 'var(--mantine-color-default-hover)' : undefined, "data-testid": "comment-thread", children: _jsxs(Stack, { gap: "xs", children: [_jsxs(Group, { gap: "xs", children: [_jsxs(Text, { id: headingId(thread.id), ref: (node) => {
-                                                    if (node)
-                                                        headingRefs.current.set(thread.id, node);
-                                                    else
-                                                        headingRefs.current.delete(thread.id);
-                                                }, size: "xs", fw: 600, tabIndex: -1, "data-testid": "comment-thread-heading", children: [threadHeading(thread), thread.onRemovedItem && (_jsxs(VisuallyHidden, { children: [", ", ON_REMOVED_ITEM.toLowerCase()] }))] }), thread.resolved && (_jsx(Badge, { size: "xs", color: "green", variant: "light", children: "Resolved" })), thread.onRemovedItem && (_jsx(Badge, { size: "xs", color: "gray", variant: "light", c: "var(--mantine-color-text)", children: ON_REMOVED_ITEM }))] }), _jsxs(Group, { gap: "xs", children: [thread.type === 'field' &&
-                                                thread.entryPath &&
-                                                thread.canopyPath &&
-                                                !thread.onRemovedItem &&
-                                                onJumpToField && (_jsx(JumpButton, { blocked: inFlight > 0, onClick: () => jump(() => onJumpToField(thread.entryPath, thread.canopyPath, thread.id)), children: "Jump to field" })), (thread.type === 'entry' || thread.onRemovedItem) &&
-                                                thread.entryPath &&
-                                                onJumpToEntry && (_jsx(JumpButton, { blocked: inFlight > 0, onClick: () => jump(() => onJumpToEntry(thread.entryPath, thread.id)), children: "Jump to entry" })), thread.type === 'branch' && onJumpToBranch && (_jsx(JumpButton, { blocked: inFlight > 0, onClick: () => jump(() => onJumpToBranch(thread.id)), children: "Open branch discussion" }))] }), thread.comments.map((comment, idx) => (_jsxs("div", { children: [idx > 0 && (_jsx("div", { style: {
-                                                    borderTop: '1px solid var(--mantine-color-default-border)',
-                                                    margin: '8px 0',
-                                                } })), _jsxs(Stack, { gap: 4, children: [_jsxs(Group, { gap: "xs", children: [onGetUserMetadata ? (_jsx(UserBadge, { userId: comment.userId, getUserMetadata: onGetUserMetadata, variant: "avatar-name", size: "xs", showEmailTooltip: true, showBadge: true, badgeVariant: "light", color: "gray" })) : (_jsx(Text, { size: "xs", fw: 500, children: userIdLabel(comment.userId) })), _jsx(RelativeTime, { iso: comment.timestamp, size: "xs", c: "dimmed" })] }), _jsx(Text, { size: "sm", style: { whiteSpace: 'pre-wrap' }, children: comment.text })] })] }, comment.id))), !thread.resolved && (_jsx(ThreadReplyControls, { thread: thread, onAddReply: (text) => addComment(text, thread.type, thread.entryPath, thread.canopyPath, thread.id), onResolve: () => resolveThread(thread.id), focusAfterResolve: () => showResolved ? headingRefs.current.get(thread.id) : threadCountRef.current, currentUserId: currentUserId, canResolve: canResolve, replyText: replyDrafts[thread.id] ?? '', onReplyTextChange: (text) => setReplyDrafts((prev) => ({ ...prev, [thread.id]: text })) }))] }) }, thread.id))) })) })] }) }));
+    // The heading's text names the article; the removed-item badge beside it is outside it.
+    const headingText = (thread) => (_jsxs("span", { id: headingId(thread.id), "data-testid": "comment-thread-heading", children: [threadHeading(thread), thread.onRemovedItem && _jsxs(VisuallyHidden, { children: [", ", ON_REMOVED_ITEM.toLowerCase()] })] }));
+    return (_jsx(OverlayDrawer, { opened: opened, onClose: close, returnFocus: !jumping, position: "right", size: 420, title: "Comments", children: _jsxs(Stack, { gap: "md", h: "100%", style: { display: 'flex', flexDirection: 'column' }, children: [_jsx(Text, { size: "xs", c: "dimmed", children: "Select a comment's heading to see it where it was left." }), _jsx(CloseRefusedNotice, { refused: closeRefused }), _jsx(Paper, { withBorder: true, p: "md", children: _jsxs(Stack, { gap: "sm", children: [_jsxs(Text, { size: "xs", c: "dimmed", children: ["Posts a branch-level comment on \"", branchName, "\". To comment on a field, use its comment icon."] }), _jsx(Textarea, { placeholder: "Add a comment\u2026", "aria-label": "New branch comment", value: newCommentText, onChange: (e) => setNewCommentText(e.target.value), minRows: 3, disabled: isSubmitting, "data-testid": "comment-textarea" }), error && _jsx(CommentWriteAlert, { failure: error, onClose: () => setError(null) }), _jsx(Button, { onClick: handleAddComment, size: "sm", loading: isSubmitting, disabled: !newCommentText.trim(), "data-testid": "comment-submit", children: "Comment" })] }) }), _jsxs(Group, { justify: "space-between", children: [_jsxs(Text, { ref: threadCountRef, size: "sm", fw: 500, tabIndex: -1, children: [filteredThreads.length, " ", filteredThreads.length === 1 ? 'thread' : 'threads'] }), _jsx(Switch, { label: "Show resolved", checked: showResolved, onChange: (e) => setShowResolved(e.currentTarget.checked), size: "sm" })] }), _jsx(ScrollArea, { style: { flex: 1 }, children: filteredThreads.length === 0 ? (_jsx(Text, { size: "sm", c: "dimmed", ta: "center", py: "xl", children: showResolved ? 'No comments yet' : 'No unresolved comments' })) : (_jsx(Stack, { gap: "md", children: filteredThreads.map((thread) => {
+                            const target = jumpTarget(thread);
+                            return (_jsx(Paper, { withBorder: true, p: "md", component: "article", "aria-labelledby": headingId(thread.id), bg: thread.resolved ? 'var(--mantine-color-default-hover)' : undefined, "data-testid": "comment-thread", children: _jsxs(Stack, { gap: "xs", children: [_jsxs(Group, { gap: "xs", children: [target ? (
+                                                // The heading is the jump control, the one tab stop on the card, in an
+                                                // `h3` under the drawer's `h2` so it is reachable by heading. It stays
+                                                // focusable while a write is in flight (`aria-disabled`, not `disabled`),
+                                                // so its reason opens on keyboard focus and touch as well as hover, and
+                                                // keeps its text colour: only the cursor says it is waiting. The visible
+                                                // text is inside the button's name (WCAG 2.5.3), after a hidden prefix
+                                                // that says what it does.
+                                                _jsx(Text, { component: "h3", size: "xs", fw: 600, m: 0, children: _jsx(Tooltip, { label: "Your change is still saving. Try again once it finishes.", disabled: inFlight === 0, multiline: true, maw: 280, children: _jsxs(Button, { ref: (node) => setHeadingRef(thread.id, node), variant: "subtle", color: "neutral", h: "auto", px: 6, py: 2, mx: -6, rightSection: _jsx(IconChevronRight, { size: 14, "aria-hidden": true }), "aria-disabled": inFlight > 0 ? true : undefined, styles: {
+                                                                root: { cursor: inFlight > 0 ? 'default' : 'pointer' },
+                                                                label: {
+                                                                    whiteSpace: 'normal',
+                                                                    textAlign: 'start',
+                                                                    lineHeight: 1.35,
+                                                                    overflowWrap: 'anywhere',
+                                                                },
+                                                            }, onClick: () => {
+                                                                if (inFlight === 0)
+                                                                    jump(target.go);
+                                                            }, children: [_jsx(VisuallyHidden, { component: "span", children: `${target.label}: ` }), headingText(thread)] }) }) })) : (_jsx(Text, { component: "h3", ref: (node) => setHeadingRef(thread.id, node), size: "xs", fw: 600, m: 0, tabIndex: -1, children: headingText(thread) })), thread.resolved && (_jsx(Badge, { size: "xs", color: "green", variant: "light", children: "Resolved" })), thread.onRemovedItem && (_jsx(Badge, { size: "xs", color: "gray", variant: "light", c: "var(--mantine-color-text)", children: ON_REMOVED_ITEM }))] }), thread.comments.map((comment, idx) => (_jsxs("div", { children: [idx > 0 && (_jsx("div", { style: {
+                                                        borderTop: '1px solid var(--mantine-color-default-border)',
+                                                        margin: '8px 0',
+                                                    } })), _jsxs(Stack, { gap: 4, children: [_jsxs(Group, { gap: "xs", children: [onGetUserMetadata ? (_jsx(UserBadge, { userId: comment.userId, getUserMetadata: onGetUserMetadata, variant: "avatar-name", size: "xs", showEmailTooltip: true, showBadge: true, badgeVariant: "light", color: "gray" })) : (_jsx(Text, { size: "xs", fw: 500, children: userIdLabel(comment.userId) })), _jsx(RelativeTime, { iso: comment.timestamp, size: "xs", c: "dimmed" })] }), _jsx(Text, { size: "sm", style: { whiteSpace: 'pre-wrap' }, children: comment.text })] })] }, comment.id))), !thread.resolved && (_jsx(ThreadReplyControls, { thread: thread, onAddReply: (text) => addComment(text, thread.type, thread.entryPath, thread.canopyPath, thread.id), onResolve: () => resolveThread(thread.id), focusAfterResolve: () => showResolved
+                                                ? headingRefs.current.get(thread.id)
+                                                : threadCountRef.current, currentUserId: currentUserId, canResolve: canResolve, replyText: replyDrafts[thread.id] ?? '', onReplyTextChange: (text) => setReplyDrafts((prev) => ({ ...prev, [thread.id]: text })) }))] }) }, thread.id));
+                        }) })) })] }) }));
 };

package/dist/editor/Editor.d.ts

@@ -7,7 +7,10 @@ import type { LogicalPath, ContentId } from '../paths/types.js';
 export interface EditorEntry {
     path: LogicalPath;
     contentId: ContentId;
+    /** What the editor calls the entry: its title, or a labelled singleton's type label. */
     label: string;
+    /** The entry's title, kept where `label` is a singleton's type label: link text and search use it. */
+    title?: string;
     status?: string;
     schema: EntrySchema;
     previewSrc?: string;