@heycys/gallery 0.2.0 → 0.2.1

package/THIRD-PARTY-NOTICES.md

@@ -1,6 +1,6 @@
 # Third-party notices
 
-@heycys/gallery 0.2.0 carries the following code and data of others, bundled into dist/ and web/, built into kit/, or as files in vendor/ and browser/.
+@heycys/gallery 0.2.1 carries the following code and data of others, bundled into dist/ and web/, built into kit/, or as files in vendor/ and browser/.
 
 ## @asamuzakjp/css-color 5.1.11
 

package/browser/editor/components/icon/page.mjs

@@ -43,9 +43,9 @@ const STYLE = `
   [data-ge-editing] main ${STEP}[data-ge-number-hover]:not(:has(> .${ICON}))::before { box-shadow: inset 0 0 0 20px light-dark(rgb(55 53 47 / 8%), rgb(255 255 255 / 8%)); }
   .ge-add-icon { position: fixed; left: 0; top: 0; z-index: ${Z.affordance}; display: flex; align-items: center; gap: 6px; height: 28px; padding: 0 8px; border-radius: 6px;
     color: var(--ge-tx3); font: 14px/1 ui-sans-serif, -apple-system, BlinkMacSystemFont, "Segoe UI", "PingFang SC", "Microsoft YaHei", sans-serif;
-    white-space: nowrap; cursor: pointer; user-select: none; opacity: 0; transition: opacity .1s ease-in, background .1s ease-in; }
+    white-space: nowrap; cursor: pointer; user-select: none; opacity: 0; visibility: hidden; pointer-events: none; transition: opacity .1s ease-in, background .1s ease-in; }
   .ge-add-icon svg { display: block; flex: none; width: 14px; height: 14px; fill: none; stroke: currentColor; stroke-width: 1.6; stroke-linecap: round; stroke-linejoin: round; }
-  .ge-add-icon[data-shown] { opacity: 1; }
+  .ge-add-icon[data-shown] { opacity: 1; visibility: visible; pointer-events: auto; }
   .ge-add-icon:hover { background: light-dark(rgb(55 53 47 / 6%), rgb(255 255 255 / 6%)); }
 `;
 
@@ -187,21 +187,23 @@ export function create({ struct, say, isEditing, openMediaPicker, assetUrl, impo
   const add = element("div", { class: "ge-add-icon", role: "button", tabindex: "0", html: t("{0}添加图标", FACE_ICON) });
   add.addEventListener("mousedown", (event) => event.preventDefault());
   add.addEventListener("click", async () => {
+    if (!shown || !isEditing() || iconOf()) return;
     await loadEmojiData();
+    if (!shown || !isEditing() || iconOf()) return;
     setIcon(randomEmoji(), t("已添加页面图标"));
   });
   let shown = false;
   function showAdd() {
     const title = titleOf();
     const header = title?.parentElement;
-    if (!title || !header) return hideAdd();
+    if (!isEditing() || !title || !header || iconOf()) return hideAdd();
     if (!add.isConnected) mount(add);
     const first = header.firstElementChild.getBoundingClientRect();
     const range = document.createRange();
     range.selectNodeContents(title);
     const text = range.getClientRects()[0] ?? title.getBoundingClientRect();
     add.style.transform = `translate(${Math.round(text.left - 8)}px, ${Math.round(first.top - 28 - 6)}px)`;
-    if (!shown) requestAnimationFrame(() => add.setAttribute("data-shown", ""));
+    if (!shown) requestAnimationFrame(() => { if (shown) add.setAttribute("data-shown", ""); });
     shown = true;
   }
   function hideAdd() {

package/browser/editor/components/icons.mjs

@@ -18,8 +18,8 @@ const LEVELS = {
 export const FORMULA_ICON = svg('<path d="M1.6 11.6 5.5 16.25 9.5 3.75h8.75"/><path d="m10.6 7.9 6.6 8.35M17.2 7.9l-6.6 8.35"/>');
 
 /** A link (two rings of a chain): the "/" menu's 链接, 链接视图, an empty link's chip, one drawing. */
-/** A page (as the workbench's tree draws one with no icon: Lucide's file-text, FinHarness's 文档, here in 20 units): the "/" menu's 页面, a page block left empty, a page with no icon in a search's rows. */
-export const PAGE_ICON = svg('<path d="M5 18.33a1.67 1.67 0 0 1-1.67-1.66V3.33a1.67 1.67 0 0 1 1.67-1.66h6.67a2 2 0 0 1 1.42.58l2.99 2.99a2 2 0 0 1 .59 1.43v10a1.67 1.67 0 0 1-1.67 1.66z"/><path d="M11.67 1.67v4.16c0 .46.37.84.83.84h4.17"/><path d="M8.33 7.5H6.67M13.33 10.83H6.67M13.33 14.17H6.67"/>');
+/** A page (the workbench's plain Lucide file outline, here in 20 units): the "/" menu's 页面, a page block left empty, a page with no icon in a search's rows. */
+export const PAGE_ICON = svg('<path d="M5 18.33a1.67 1.67 0 0 1-1.67-1.66V3.33a1.67 1.67 0 0 1 1.67-1.66h6.67a2 2 0 0 1 1.42.58l2.99 2.99a2 2 0 0 1 .59 1.43v10a1.67 1.67 0 0 1-1.67 1.66z"/><path d="M11.67 1.67v4.16c0 .46.37.84.83.84h4.17"/>');
 
 /** A section (分区): blocks gathered between brackets, the block menu's 组成新分区 and the section's line in 设置 › 组件列表. */
 export const SECTION_ICON = svg('<path d="M6 3.75h-.75a2 2 0 0 0-2 2v8.5a2 2 0 0 0 2 2H6M14 3.75h.75a2 2 0 0 1 2 2v8.5a2 2 0 0 1-2 2H14"/><path d="M7.25 7.75h5.5M7.25 12.25h5.5"/>');

package/browser/editor/page/clipboard/import/read.mjs

@@ -14,7 +14,8 @@ import { addressOf } from "../../links/address.mjs";
 //     formatting" (html.mjs containsRichFormatting; WordPress's always): spans, divs and paragraphs
 //     alone paste as their text.
 //   - Office's HTML (its namespaces) that looks like Word's goes through the Word filter (office.mjs).
-//   - A whole $$ formula $$ → a formula block; several lines from VS Code → code in its language.
+//   - A whole $$ formula $$ → a formula block; IDE Markdown → document blocks, other IDE code →
+//     code in its language. An unspecified IDE language can be Markdown by its parsed structure.
 //   - HTML: several lines of text, or a table → blocks (html.mjs htmlToBlocks); else one rich text.
 //   - No HTML: several lines → Markdown (markdown.mjs); one line → inline Markdown (bold, links,
 //     addresses, formulas) when it has any, else plain text. A whole line that is a display formula
@@ -89,6 +90,20 @@ function sameAddress(one, other) {
   }
 }
 
+// VS Code and Cursor copy syntax-colored HTML beside the source text, even for Markdown. Use
+// the same Markdown reader as an ordinary text paste, not the colored HTML. A Markdown language
+// hint is enough; for an unspecified language, require some structure or inline formatting the
+// reader actually recognizes. Unrecognized lines remain text; the whole selection need not be
+// valid Markdown. A declared programming language wins over lookalike comments and operators.
+function editorMarkdown({ text, language }) {
+  if (language !== "Markdown" && language !== "Plain Text") return null;
+  const specs = fromMarkdown(text);
+  if (language === "Markdown") return specs;
+  const marked = (blocks) => blocks.some((block) => block.type !== "text"
+    || block.title.some((piece) => piece[1]?.length) || marked(block.children));
+  return !addressOf(text) && marked(specs) ? specs : null;
+}
+
 /**
  * Another program's content as { kind: "blocks", specs } | { kind: "rich", title } | { kind: "plain",
  * text } (notion-lite readClipboard, after the editor's own formats).
@@ -98,11 +113,14 @@ export function readExternal(data, options = {}) {
   const yuque = readYuque(data, options);
   if (yuque) return yuque;
   const external = externalContent(data, options);
-  const { text, html } = external;
+  const { text } = external;
   const convert = { colors: external.colors };
   const equation = EQUATION.exec(text)?.[1];
   if (equation?.trim()) return { kind: "blocks", specs: [{ type: "equation", title: [[equation]], props: {}, children: [] }] };
+  const markdown = editorMarkdown(external);
+  if (markdown?.length && (multiline(text) || markdown.some((block) => block.type !== "text"))) return { kind: "blocks", specs: markdown };
   if (multiline(text) && external.language) return { kind: "blocks", specs: [{ type: "code", title: [[text]], props: { language: external.language }, children: [] }] };
+  const html = markdown ? "" : external.html;
   if (html) {
     if (multiline(text) || external.isTable) {
       const specs = mathifySpecs(htmlToBlocks(parseClipboardHTML(html, options), convert));

package/browser/shared/document-copy.mjs

@@ -0,0 +1,43 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { parse } from "parse5";
+import { attr, walk } from "./html-tree.mjs";
+import { escapeAttribute } from "./escape.mjs";
+import { newNames } from "./new-names.mjs";
+import { COMPONENTS_FOLDER, DOCUMENT_FOLDERS, SHARED_FOLDERS, documentFiles, packageFolders, readLink } from "./workspace.mjs";
+
+/** Files belonging to a document, excluding packages/pages sharing a legacy reserved folder. */
+export async function documentNames(root, slug) {
+  const entries = await fs.readdir(path.join(root, slug), { withFileTypes: true });
+  if (!SHARED_FOLDERS.includes(slug)) return entries.map(({ name }) => name);
+  const scopes = slug === COMPONENTS_FOLDER ? new Set(packageFolders(root).map(({ id }) => id.split("/")[0])) : new Set();
+  return entries.filter(entry => entry.isFile() || (DOCUMENT_FOLDERS.includes(entry.name) && !scopes.has(entry.name))).map(({ name }) => name);
+}
+
+/** Same copy primitive for duplicate and cross-workspace copy: local assets and metadata stay intact. */
+export async function copyEntryFiles(root, slug, destination, copy, { names = new Map() } = {}) {
+  const source = path.join(root, slug);
+  const document = await fs.access(documentFiles(source).html).then(() => true, () => false);
+  const link = document ? null : await readLink(source);
+  const own = new Set(["", ...(await documentNames(root, slug))]);
+  await fs.cp(source, destination, { recursive: true, errorOnExist: true, force: false, filter: from => own.has(path.relative(source, from).split(path.sep)[0]) });
+  if (link) return [];
+  const file = documentFiles(destination).html;
+  const html = await fs.readFile(file, "utf8");
+  const text = newNames(html);
+  const edits = new Map(), packages = new Set();
+  walk(parse(text.replace(/^\uFEFF/, " "), { sourceCodeLocationInfo: true }), node => {
+    const component = attr(node, "data-doc-component");
+    if (component) packages.add(component);
+    for (const { name, value } of node.attrs ?? []) {
+      const at = node.sourceCodeLocation?.attrs?.[name];
+      if (!at) continue;
+      const relative = /^(\.\.\/)([a-z0-9]+(?:-[a-z0-9]+)*)(\/.*)$/.exec(value);
+      const next = name === "data-doc-id" && value === slug ? copy : ["href", "src", "poster"].includes(name) && relative && names.has(relative[2]) ? `../${names.get(relative[2])}${relative[3]}` : value;
+      if (next !== value) edits.set(at.startOffset, { to: at.endOffset, text: `${name}="${escapeAttribute(next)}"` });
+    }
+  });
+  const next = [...edits].sort(([a], [b]) => b - a).reduce((text, [from, edit]) => text.slice(0, from) + edit.text + text.slice(edit.to), text);
+  await fs.writeFile(file, next);
+  return [...packages];
+}

package/browser/shared/drafts.mjs

@@ -2,13 +2,13 @@ import { existsSync } from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { descendantsIn, outlineAndFile, parentIn, placeIn, readOutline, withOutlineLock, writeOutline, writtenAs } from "./outline.mjs";
+import { descendantsIn, outlineAndFile, parentIn, placeIn, readOutline, sharedOutline, withOutlineLock, writeOutline, writtenAs } from "./outline.mjs";
 import { DOCS, GROUP_LIMITS, isForeign, isTop, newGroupId, topIn, topOf } from "./outline-shape.mjs";
 import { findPreviewServer } from "./preview-server.mjs";
 import { idsOf, shownIcon } from "./workspace-columns.mjs";
 import { nameStops, workspaceLabels, workspaceName } from "./workspace-name.mjs";
 import { isWorkspace, readRegistry, workspaceId, workspaceKey } from "./workspace-registry.mjs";
-import { defaultWorkspace, documentFiles, isSlugName, listDocumentSlugs } from "./workspace.mjs";
+import { defaultWorkspace, documentFiles, isSlugName, listDocumentSlugs, readLink } from "./workspace.mjs";
 
 // The drafts of other workspaces in a workspace's sidebar (notes/plans/workspaces-links-plan-2026-11-08.md
 // §2.2, §2.5, §7.2; docs/workbench.md "Drafts of other workspaces"): an entry of the outline written
@@ -76,6 +76,8 @@ export async function draftFacts(entry, ids = registeredIds()) {
   const none = { entry, ws, slug, root: null, folder: null, path: null, title: slug, description: "", icon: null };
   if (!found.root) return { ...none, missing: found.refused === "ambiguous" ? "ambiguous" : "workspace" };
   const folder = path.join(found.root, slug);
+  const link = existsSync(documentFiles(folder).html) ? null : await readLink(folder);
+  if (link) return { entry, ws, slug, root: found.root, folder, path: path.join(folder, 'link.json'), title: link.title, description: '', kind: 'link', url: link.url, icon: link.icon, siteIcon: link.siteIcon, missing: null };
   const { files, html, metadata } = await metadataAt(folder);
   const missing = !isWorkspace(found.root) ? "workspace" : !html || metadata?.instructions === true ? "draft" : null;
   // An untitled document says so (its title empty: the workbench names it 未命名文档); one with no doc.json to read, its slug.
@@ -226,6 +228,11 @@ export async function addDraft(treeRoot, draftRoot, slug, { changed = () => {},
       return { parent, column: top === null || top === "" ? DOCS : top.slice(1), under: parent !== null && !isTop(parent) ? parent : null };
     };
     const columnOf = (key) => outline.groups.find((each) => topOf(each.id) === topIn(outline.children, key)) ?? null;
+    if (sharedOutline(treeRoot) && holds(entry)) {
+      if (!writtenAs(outline, stored)) { await writeOutline(treeRoot, outline); changed(); }
+      const existing = pick || storedHolds;
+      return { entry, existing, added: existing ? [] : [entry], shown: false, ...where() };
+    }
     let shown = false;
     let column = outline.groups.find((each) => each.workspace === id) ?? null;
     const put = () => {
@@ -425,7 +432,7 @@ export function joinedLine(joined) {
   if (joined.failed) return `${where}：没有加进去（${joined.failed}）`;
   if (joined.existing) return `${where}里已经有它（${joined.names.under ? `在「${joined.names.under}」下面` : `「${joined.names.column}」栏`}）`;
   const more = joined.added.length > 1 ? `，连同它下面的 ${joined.added.length - 1} 篇` : "";
-  return `${where}：已加进${joined.names.under ? `「${joined.names.under}」下面` : `「${joined.names.column}」栏`}${more}（拖动只改那里的显示位置，文件不动）`;
+  return `${where}：已加进${joined.names.under ? `「${joined.names.under}」下面` : `「${joined.names.column}」栏`}${more}（工作区内排序全局同步，文件位置不变）`;
 }
 
 /** Whether a gallery.json at `folder` would be another program's or not readable (what draft-add refuses to make a workspace of). */

package/browser/shared/emoji/icon-value.mjs

@@ -73,12 +73,12 @@ export const iconUrl = (value, slug = null, { tab = false } = {}) => `/__gallery
 const [TAB_LIGHT, TAB_DARK] = ICON_COLOR_VALUES.gray;
 /**
  * The browser tab's image of a page with no icon (the workbench's and the preview page's): the page
- * the workbench's tree shows for one (its "page" icon, components/icons.ts: Lucide's file-text,
+ * the workbench's tree shows for one (its "page" icon, components/icons.ts: Lucide's plain file outline,
  * FinHarness's 文档), its box cropped to `1 1 22 22` so it fills the tab as an emoji does, in the tab
  * glyphs' gray, light or dark as the system is. An image, never none: a tab given no image, or one that does not
  * load, keeps the one it showed (Chrome), so a page with no icon opened after one with one showed that one's.
  */
-export const DEFAULT_TAB_ICON = `data:image/svg+xml,${encodeURIComponent(`<svg xmlns="http://www.w3.org/2000/svg" viewBox="1 1 22 22" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><style>svg{color:${TAB_LIGHT}}@media (prefers-color-scheme:dark){svg{color:${TAB_DARK}}}</style><path d="M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z"/><path d="M14 2v5a1 1 0 0 0 1 1h5"/><path d="M10 9H8"/><path d="M16 13H8"/><path d="M16 17H8"/></svg>`)}`;
+export const DEFAULT_TAB_ICON = `data:image/svg+xml,${encodeURIComponent(`<svg xmlns="http://www.w3.org/2000/svg" viewBox="1 1 22 22" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><style>svg{color:${TAB_LIGHT}}@media (prefers-color-scheme:dark){svg{color:${TAB_DARK}}}</style><path d="M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z"/><path d="M14 2v5a1 1 0 0 0 1 1h5"/></svg>`)}`;
 
 /** The value of an icon's element as the file (or a page) has it, or null. */
 export function iconValueOf(html) {

package/browser/shared/extensions.mjs

@@ -3,9 +3,12 @@ import path from "node:path";
 import { SIDEBAR_FILE, SIDEBAR_LIMITS, readSidebarText } from "./extension-sidebar.mjs";
 import { said } from "./i18n/index.mjs";
 import { isExtensionId } from "./outline-shape.mjs";
-import { DOCUMENT_FOLDERS, layoutOf } from "./workspace.mjs";
+import { defaultWorkspace, DOCUMENT_FOLDERS, layoutOf } from "./workspace.mjs";
+import { sameDirectory } from "./preview-server.mjs";
+import { writeAtomic } from "./files.mjs";
 
-// The extensions of a workspace (docs/workbench.md "Extension columns"): each a folder
+// The extensions visible in a workspace (docs/workbench.md "Extension columns"): public columns from
+// the default workspace plus this project's own, a project sidebar.json taking precedence by id. Each a folder
 // <workspace>/extensions/<id>/ whose sidebar.json (./extension-sidebar.mjs) gives a column of the sidebar
 // its entries; what else the folder holds (the extension's own server, its code) is none of Gallery's.
 // Read from disk each time it is asked (the workbench's list, the outline's columns, gallery extension):
@@ -26,10 +29,32 @@ export async function extensionFolders(root) {
     .sort((a, b) => (a.id < b.id ? -1 : 1));
 }
 
+/** Public columns live in the default workspace; a project's own sidebar.json overrides the same id.
+ * Empty local folders do not hide a public column. Keep one source for listing, outline and writes.
+ */
+export async function visibleExtensionFolders(root) {
+  const home = defaultWorkspace();
+  const roots = sameDirectory(home, root) ? [root] : [home, root];
+  const found = new Map();
+  for (const owner of roots) {
+    for (const entry of await extensionFolders(owner)) {
+      const file = path.join(entry.folder, SIDEBAR_FILE);
+      const present = await fs.lstat(file).then(() => true, () => false);
+      if (present || !found.has(entry.id)) found.set(entry.id, { ...entry, root: owner, file, present });
+    }
+  }
+  return [...found.values()].sort((a, b) => a.id < b.id ? -1 : 1);
+}
+
+/** Resolve an id, never a client-supplied directory, to the file this workspace actually shows. */
+export async function extensionSource(root, id) {
+  if (!isExtensionId(id)) return null;
+  return (await visibleExtensionFolders(root)).find(entry => entry.id === id) ?? null;
+}
+
 /** The ids of the extensions that have a sidebar.json (the columns the sidebar has), sorted. */
 export async function extensionColumnIds(root) {
-  const found = await Promise.all((await extensionFolders(root)).map(async ({ id, folder }) => ((await fs.stat(path.join(folder, SIDEBAR_FILE)).then(() => true, () => false)) ? id : null)));
-  return found.filter(Boolean);
+  return (await visibleExtensionFolders(root)).filter(entry => entry.present).map(entry => entry.id);
 }
 
 /**
@@ -69,11 +94,62 @@ export async function readExtension(root, id) {
 }
 
 /**
- * The extensions of workspace `root`, by id: those with a sidebar.json (the sidebar's columns), or with `all`
+ * The extensions visible in workspace `root`, by id: those with a sidebar.json (the sidebar's columns), or with `all`
  * every folder that may be one (gallery extension list). Each as readExtension says it.
  */
 export async function listExtensions(root, { all = false } = {}) {
-  const folders = await extensionFolders(root);
-  const read = await Promise.all(folders.map(({ id }) => readExtension(root, id)));
+  const folders = await visibleExtensionFolders(root);
+  const read = await Promise.all(folders.map(({ id, root: owner }) => readExtension(owner, id)));
   return all ? read : read.filter((extension) => !extension.missing);
 }
+
+/** Edit only a column's title or the order of its root entries. Called under the workspace lock.
+ * Read the latest source, keep unknown fields and whole subtrees, and refuse stale UI changes.
+ * Atomic replacement checks the original text again so an external writer is not silently overwritten.
+ */
+export async function editExtension(root, id, change) {
+  const refused = (status, reason, error) => ({ ok: false, status, reason, error });
+  const bad = () => refused(400, "body", said("请求格式不对"));
+  const stale = () => refused(409, "stale", said("扩展目录刚在别处改过，请重试"));
+  if (!isExtensionId(id) || !change || typeof change !== "object") return bad();
+  const rename = Object.hasOwn(change, "title");
+  if (rename ? (typeof change.title !== "string" || typeof change.baseTitle !== "string" || change.move !== undefined)
+    : (!change.move || !["before", "after"].includes(change.move.side) || typeof change.move.entry !== "string" || typeof change.move.ref !== "string" || !Array.isArray(change.baseOrder))) return bad();
+  const name = rename ? change.title.replace(/\s+/g, " ").trim() : null;
+  if (rename && (!name || name.length > SIDEBAR_LIMITS.column)) return bad();
+  const folder = path.join(layoutOf(root).extensions, id);
+  const file = path.join(folder, SIDEBAR_FILE);
+  // Never turn an extension path supplied by the client or a symlink into an arbitrary-file write.
+  for (const [target, directory] of [[layoutOf(root).extensions, true], [folder, true], [file, false]]) {
+    const stat = await fs.lstat(target).catch(() => null);
+    if (!stat) return refused(404, "missing", said("找不到这个扩展"));
+    if (stat.isSymbolicLink() || (directory ? !stat.isDirectory() : !stat.isFile())) return refused(409, "path", said("扩展路径不是普通文件或文件夹"));
+    if (!directory && stat.size > SIDEBAR_LIMITS.bytes) return refused(409, "extension", said("文件超过 1MB"));
+  }
+  const source = await fs.readFile(file, "utf8");
+  const read = readSidebarText(source);
+  if (read.error) return refused(409, "extension", read.error);
+  const value = JSON.parse(source.replace(/^\uFEFF/, ""));
+  if (rename) {
+    if (read.sidebar.title !== change.baseTitle) return stale();
+    if (read.sidebar.title === name) return { ok: true, written: false };
+    value.title = name;
+  } else {
+    const order = value.entries.map(entry => entry.id);
+    if (JSON.stringify(order) !== JSON.stringify(change.baseOrder)) return stale();
+    const from = order.indexOf(change.move.entry), to = order.indexOf(change.move.ref);
+    if (from < 0 || to < 0) return bad(); // Root entries only, in this file; no nesting or cross-column move.
+    if (from === to) return { ok: true, written: false };
+    const [entry] = value.entries.splice(from, 1);
+    const at = value.entries.findIndex(entry => entry.id === change.move.ref);
+    value.entries.splice(at + (change.move.side === "after" ? 1 : 0), 0, entry);
+    if (JSON.stringify(order) === JSON.stringify(value.entries.map(entry => entry.id))) return { ok: true, written: false };
+  }
+  const indent = source.match(/\n([ \t]+)"/)?.[1] ?? 2;
+  let next = JSON.stringify(value, null, indent) + "\n";
+  if (source.includes("\r\n")) next = next.replaceAll("\n", "\r\n");
+  if (source.startsWith("\uFEFF")) next = "\uFEFF" + next;
+  if (Buffer.byteLength(next) > SIDEBAR_LIMITS.bytes) return refused(409, "extension", said("文件超过 1MB"));
+  if (!(await writeAtomic(file, next, { expect: source }))) return stale();
+  return { ok: true, written: true };
+}

package/browser/shared/i18n/en.mjs

@@ -1,6 +1,9 @@
 // English for Gallery's UI, by the Chinese text the source writes (index.mjs t()), in the order the
 // sources use them. tests/unit/i18n.mjs holds every string to an entry here and every entry to a string.
 export default {
+  "扩展目录刚在别处改过，请重试": "The extension directory changed elsewhere. Please try again.",
+  "找不到这个扩展": "This extension could not be found",
+  "扩展路径不是普通文件或文件夹": "The extension path is not a regular file or directory",
   "正在读取文档…": "Loading documents…",
   "没有连上本地服务": "Not connected to the local service",
   "重试": "Retry",
@@ -153,6 +156,8 @@ export default {
   "撤销": "Undo",
   "已恢复「{0}」": "Restored “{0}”",
   "永久删除「{0}」？": "Delete “{0}” forever?",
+  "永久删除回收区中的全部 {0} 项？": "Permanently delete all {0} items in the trash?",
+  "删除全部": "Delete all",
   "这份文档": "this document",
   "删除后无法恢复。": "This can't be undone.",
   "正在导出…": "Exporting…",
@@ -1523,4 +1528,9 @@ export default {
   "选的文件不是 zip": "The file chosen is not a zip",
   "没有这个块包": "No such block pack",
   "粘贴块包的文件夹或 zip 的路径": "Paste the path of the pack's folder or zip",
+  "复制到另一个工作区？": "Copy to another workspace?",
+  "将「{0}」及其子页面复制到「{1}」，原项保留。": "Copy “{0}” and its child pages to “{1}”, keeping the originals.",
+  "已复制 {0} 项，原项保留": "Copied {0} items; originals kept",
+  "跨工作区请复制，不能只移动目录位置": "Copy items to another workspace instead of moving their tree positions",
+  "自定义块 {0} 缺失或版本冲突，未复制": "Custom block {0} is missing or has a version conflict; nothing was copied",
 };

package/browser/shared/outline-shape.mjs

@@ -55,6 +55,10 @@ export const groupOfTop = (key) => (key === "" ? DOCS : key.slice(1));
 /** Whether `entry` names a draft of another workspace. */
 export const isForeign = (entry) => entry.startsWith("~");
 
+/** File ownership is independent of which workspace's window is open. */
+export const entryWorkspace = (entry, self) => /^~(ws-[0-9a-f]{6})\//.exec(entry)?.[1] ?? self;
+export const columnWorkspaceId = (column, self) => column?.extension ? null : column?.workspace ?? column?.owner ?? self;
+
 const tidy = (value) => (typeof value === "string" ? value.replace(/\s+/g, " ").trim() : "");
 
 /** A whole column's `left` as it is kept: the slugs once each, 1000 at most; none when there are none. */
@@ -80,6 +84,7 @@ export function groupOf(value) {
     ...(title ? { title } : {}),
     ...(GROUP_ROLES.includes(role) && id !== DOCS ? { role } : {}),
     ...(isWorkspaceColumn ? { workspace } : {}),
+    ...(typeof value.owner === "string" && /^ws-[0-9a-f]{6}$/.test(value.owner) && !isWorkspaceColumn && id !== DOCS ? { owner: value.owner } : {}),
     // A workspace's column alone is picked or hidden (the user's columns and 链接 are removed, never hidden).
     ...(isWorkspaceColumn && value.picked === true ? { picked: true } : {}),
     ...(isWorkspaceColumn && value.hidden === true ? { hidden: true } : {}),
@@ -98,6 +103,7 @@ export function validGroups(groups) {
     if (value.title !== undefined && (typeof value.title !== "string" || tidy(value.title).length > GROUP_LIMITS.title)) return false;
     if (value.role !== undefined && !GROUP_ROLES.includes(value.role)) return false;
     if (value.extension !== undefined && group.extension !== value.extension) return false;
+    if (value.owner !== undefined && group.owner !== value.owner) return false;
     if (value.left !== undefined && (!Array.isArray(value.left) || value.left.length > GROUP_LIMITS.left || !value.left.every((slug) => typeof slug === "string" && slugPattern.test(slug)))) return false;
     ids.add(group.id);
   }

package/browser/shared/outline.mjs

@@ -3,11 +3,53 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { writeAtomic } from "./files.mjs";
 import { extensionColumnIds } from "./extensions.mjs";
-import { DOCS, entryPattern, extensionGroupId, GROUP_LIMITS, groupOf, isForeign, isTop, newGroupId, topIn, topOf, validGroups } from "./outline-shape.mjs";
+import { DOCS, columnWorkspaceId, entryWorkspace, entryPattern, extensionGroupId, GROUP_LIMITS, groupOf, groupOfTop, isForeign, isTop, newGroupId, topIn, topOf, validGroups } from "./outline-shape.mjs";
 import { storedHead } from "./sidebar-head.mjs";
-import { shownWorkspaces, snapshotOf } from "./workspace-columns.mjs";
-import { layoutOf, listDocumentSlugs, listLinkSlugs, pageSlug } from "./workspace.mjs";
+import { forgetSnapshot, shownWorkspaces, snapshotOf } from "./workspace-columns.mjs";
+import { defaultWorkspace, layoutOf, listDocumentSlugs, listLinkSlugs, pageSlug } from "./workspace.mjs";
+import { readRegistry, workspaceId, workspaceKey } from "./workspace-registry.mjs";
 
+/** Registered workspaces share the default workspace's existing tree. Unregistered/temporary
+ * workspaces remain standalone; no registry discovery or copying of document files is needed. */
+export function outlineRoot(root) {
+  const home = defaultWorkspace();
+  return workspaceKey(root) === workspaceKey(home) || readRegistry().workspaces.some(entry => workspaceKey(entry.root) === workspaceKey(root)) ? home : root;
+}
+
+export const sharedOutline = root => workspaceKey(outlineRoot(root)) === workspaceKey(defaultWorkspace());
+
+/** Moving a reference across owners must use the confirmed copy command. */
+export function ownsOutline(root, value) {
+  const self = workspaceId(root);
+  const available = new Set([self, ...shownWorkspaces(root).map(workspace => workspace.id)]);
+  return Object.entries(value.children).every(([parent, list]) => {
+    const owner = isTop(parent) ? columnWorkspaceId(value.groups?.find(group => topOf(group.id) === parent), self) : entryWorkspace(parent, self);
+    // Missing legacy references remain removable and must not block edits to healthy documents.
+    return list.every(entry => !available.has(entryWorkspace(entry, self)) || entryWorkspace(entry, self) === owner);
+  });
+}
+
+// Earlier versions allowed mixed-workspace nesting. Return misplaced roots to their owner,
+// retaining same-owner order and descendants. This changes directory positions, never files.
+function ownedTree(tree, self) {
+  const children = Object.fromEntries(tree.groups.map(group => [topOf(group.id), []]));
+  const ownTop = owner => { const group = tree.groups.find(group => owner === self ? group.id === DOCS : group.workspace === owner); return group ? topOf(group.id) : null; };
+  const walk = (parent, owner) => {
+    for (const entry of tree.children[parent] ?? []) {
+      const belongs = entryWorkspace(entry, self);
+      const at = belongs === owner ? parent : ownTop(belongs) ?? parent;
+      (children[at] ??= []).push(entry);
+      walk(entry, belongs);
+    }
+  };
+  for (const group of tree.groups) if (!group.extension) walk(topOf(group.id), columnWorkspaceId(group, self));
+  return { ...tree, children };
+}
+
+// Registered workspaces project one shared tree, partitioned by file owner. Their former local files
+// only seed new entries; the default workspace stores subsequent order/hierarchy edits. The format
+// below is also the standalone/legacy reader. Its picked/hidden/left rules are not applied to shared
+// trees, which list every registered document and link. Project-only extensions keep local positions.
 // The workspace's outline: the sidebar's columns and which entry sits under which, in what order
 // (<workspace>/.gallery/outline.json, docs/workbench.md "Workspace commands"; its shape: ./outline-shape.mjs).
 // The file, version 2:
@@ -56,10 +98,10 @@ const LOCK_WAIT = 15_000;
 /**
  * Run `task` holding the outline's lock of workspace `root`: a file made with "wx", which one
  * process alone can make, removed after; one older than 10 s is a crashed writer's and is taken over.
- * Waits for it 15 s at most, then takes it all the same (a writer that holds it that long holds
- * nothing any more).
+ * A live writer refreshes its lock. Waits 15 s at most and then refuses rather than stealing it.
  */
-export async function withOutlineLock(root, task) {
+export async function withOutlineLock(root, task, { local = false } = {}) {
+  if (!local) root = outlineRoot(root);
   const { gallery } = layoutOf(root);
   const lock = path.join(gallery, "outline.lock");
   const mine = `${process.pid} ${randomBytes(4).toString("hex")}`;
@@ -71,13 +113,17 @@ export async function withOutlineLock(root, task) {
     } catch (error) {
       if (error.code !== "EEXIST") throw error;
       const age = await fs.stat(lock).then(({ mtimeMs }) => Date.now() - mtimeMs, () => 0);
-      if (age > LOCK_STALE || Date.now() > until) await fs.rm(lock, { force: true });
+      if (age > LOCK_STALE) await fs.rm(lock, { force: true });
+      else if (Date.now() > until) throw Object.assign(new Error("文档目录刚在别处改过"), { code: "stale" });
       else await new Promise((resolve) => setTimeout(resolve, 20));
     }
   }
+  const heartbeat = setInterval(() => fs.utimes(lock, new Date(), new Date()).catch(() => {}), LOCK_STALE / 3);
+  heartbeat.unref();
   try {
     return await task();
   } finally {
+    clearInterval(heartbeat);
     // Removed only while it is still this writer's (one taken over meanwhile is the next writer's).
     if ((await fs.readFile(lock, "utf8").catch(() => null)) === mine) await fs.rm(lock, { force: true });
   }
@@ -98,7 +144,8 @@ export async function readOutline(root, { others = true } = {}) {
  */
 export async function otherWorkspaces(root, { env = process.env } = {}) {
   const shown = shownWorkspaces(root, { env });
-  const readOwn = (other) => readOutline(other, { others: false });
+  // Project-local files seed entries not yet in the shared tree; never recurse into its projection.
+  const readOwn = async (other) => (await localOutlineAndFile(other, { others: false })).outline;
   const unread = () => ({ documents: new Set(), order: [], parentOf: new Map(), facts: new Map(), failed: true });
   return Promise.all(shown.map(async (each) => ({ ...each, failed: false, ...(await snapshotOf(each.root, readOwn).catch(unread)) })));
 }
@@ -113,14 +160,16 @@ export async function otherWorkspaces(root, { env = process.env } = {}) {
  * place a command or the workbench gave. `others: false`: the workspace's own tree alone (no column of
  * another workspace made, none filled).
  */
-export async function outlineAndFile(root, { others: withOthers = true } = {}) {
+async function localOutlineAndFile(root, { others: withOthers = true, shared = false } = {}) {
   const instructions = await pageSlug(root);
   const documents = (await listDocumentSlugs(root)).filter((slug) => slug !== instructions);
   const links = await listLinkSlugs(root);
   const extensions = await extensionColumnIds(root);
   const stored = storedOf(await readJson(layoutOf(root).outline));
   const others = withOthers ? await otherWorkspaces(root) : [];
-  const shown = ordered(stored, documents, links, extensions, others, { drawn: withOthers });
+  const base = shared && stored ? { ...stored, groups: stored.groups.map(({ picked, hidden, left, ...group }) => group.workspace || group.extension || group.id === DOCS ? group : { ...group, owner: group.owner ?? workspaceId(root) }) } : stored;
+  let shown = ordered(base, documents, links, extensions, others, { drawn: withOthers });
+  if (shared) shown = ownedTree(shown, workspaceId(root));
   const outline = {
     version: 2, ...shown, links, drafts: Object.values(shown.children).flat().filter(isForeign),
     shown: others.map(({ id, root: other, isDefault }) => ({ id, root: other, isDefault })),
@@ -128,6 +177,54 @@ export async function outlineAndFile(root, { others: withOthers = true } = {}) {
   return { outline, stored, others };
 }
 
+/** Translate the same tree between the default workspace's ids and a project's local ids.
+ * No second ordering is kept: only the current workspace's column is displayed first. */
+function projectTree(value, from, to, { first = false } = {}) {
+  if (!value || workspaceKey(from) === workspaceKey(to)) return value;
+  const fromId = workspaceId(from), toId = workspaceId(to);
+  const own = value.groups.find(group => group.workspace === toId);
+  const ownId = own?.id ?? toId;
+  const groupId = id => id === DOCS ? fromId : id === ownId ? DOCS : id;
+  const entry = key => key.startsWith(`~${toId}/`) ? key.slice(toId.length + 2) : isForeign(key) ? key : `~${fromId}/${key}`;
+  const key = value => isTop(value) ? topOf(groupId(groupOfTop(value))) : entry(value);
+  let groups = value.groups.map(group => {
+    if (group.id === DOCS) return { ...group, id: fromId, workspace: fromId };
+    if (group.id === ownId) {
+      const { workspace, picked, hidden, left, ...rest } = group;
+      return { ...rest, id: DOCS };
+    }
+    return group;
+  });
+  if (first) groups = [...groups.filter(group => group.id === DOCS), ...groups.filter(group => group.id !== DOCS)];
+  return { ...value, groups, children: Object.fromEntries(Object.entries(value.children).map(([parent, list]) => [key(parent), list.map(entry)])) };
+}
+
+export async function outlineAndFile(root, { others: withOthers = true } = {}) {
+  const home = outlineRoot(root);
+  if (workspaceKey(home) === workspaceKey(root)) return localOutlineAndFile(root, { others: withOthers, shared: sharedOutline(root) });
+  // A command may just have created/trashed a local item before placing it in the shared tree.
+  forgetSnapshot(root);
+  const shared = await localOutlineAndFile(home, { shared: true });
+  let outline = projectTree(shared.outline, home, root, { first: true });
+  // A project's extensions remain private; public ones still come from the default workspace.
+  outline.groups = withExtensions(outline.groups, await extensionColumnIds(root));
+  const publicIds = new Set(await extensionColumnIds(home));
+  const positions = (await readJson(layoutOf(root).outline))?.extensionPositions;
+  for (const position of Array.isArray(positions) ? [...positions].reverse() : []) {
+    const group = outline.groups.find(group => group.id === position.id && group.extension && !publicIds.has(group.extension));
+    if (!group) continue;
+    outline.groups = outline.groups.filter(item => item !== group);
+    const at = outline.groups.findIndex(item => item.id === position.before);
+    outline.groups.splice(at < 0 ? outline.groups.length : at, 0, group);
+  }
+  outline.children = Object.fromEntries(Object.entries(outline.children).filter(([key]) => !isTop(key) || outline.groups.some(group => topOf(group.id) === key)));
+  for (const group of outline.groups) outline.children[topOf(group.id)] ??= [];
+  const ownLinks = await listLinkSlugs(root);
+  const others = await otherWorkspaces(root);
+  outline = { ...outline, links: ownLinks, drafts: Object.values(outline.children).flat().filter(isForeign), shown: others.map(({ id, root: other, isDefault }) => ({ id, root: other, isDefault })) };
+  return { outline, stored: projectTree(shared.stored, home, root, { first: true }), others };
+}
+
 // The own column's name before it was 默认文档 or the workspace's (文档, Documents in English), which a
 // rename of it confirmed unchanged wrote as its title (the field opens with the name shown): read as no
 // title, so that the name it goes by now shows. A title of another column, or any other, is the user's.
@@ -378,6 +475,33 @@ export function fileOf(value) {
  * the head's order the file holds kept as it is (writeHead's).
  */
 export async function writeOutline(root, value) {
+  const home = outlineRoot(root);
+  if (sharedOutline(root) && !ownsOutline(root, value)) throw Object.assign(new Error("跨工作区请复制，不能只移动目录位置"), { code: "CROSS_WORKSPACE" });
+  if (sharedOutline(root)) value = { ...value, groups: (value.groups ?? [{ id: DOCS }]).map(group => group.id === DOCS || group.workspace || group.extension ? group : { ...group, owner: group.owner ?? workspaceId(root) }) };
+  if (workspaceKey(home) !== workspaceKey(root)) {
+    const current = (await localOutlineAndFile(home)).outline;
+    const translated = projectTree(value, root, home);
+    // The current-column-first projection is presentation only. Keep the shared column order;
+    // deliberate moves of other columns use the relative order submitted by the client.
+    const ownId = workspaceId(root);
+    const at = current.groups.findIndex(group => group.workspace === ownId);
+    const own = translated.groups.find(group => group.workspace === ownId);
+    translated.groups = translated.groups.filter(group => group !== own);
+    if (own) translated.groups.splice(Math.max(0, Math.min(at, translated.groups.length)), 0, own);
+    const publicIds = new Set(await extensionColumnIds(home));
+    const privateGroup = group => group.extension && !publicIds.has(group.extension);
+    const positions = value.groups.filter(privateGroup).map(group => ({ id: group.id, before: value.groups.slice(value.groups.indexOf(group) + 1).find(group => !privateGroup(group))?.id ?? null }));
+    const localFile = layoutOf(root).outline;
+    const local = await readJson(localFile) ?? {};
+    if ((positions.length || local.extensionPositions?.length) && JSON.stringify(positions) !== JSON.stringify(local.extensionPositions)) {
+      await fs.mkdir(path.dirname(localFile), { recursive: true });
+      await writeAtomic(localFile, `${JSON.stringify({ ...local, extensionPositions: positions }, null, 2)}\n`);
+    }
+    translated.groups = translated.groups.filter(group => !group.extension || publicIds.has(group.extension));
+    for (const group of current.groups) if (group.extension && !translated.groups.some(item => item.id === group.id)) translated.groups.push(group);
+    value = translated;
+    root = home;
+  }
   const file = layoutOf(root).outline;
   await fs.mkdir(path.dirname(file), { recursive: true });
   const head = storedHead((await readJson(file))?.head);
@@ -465,6 +589,7 @@ export function moveDocument(root, slug, where) {
   return withOutlineLock(root, async () => {
     const { outline, stored } = await outlineAndFile(root);
     const result = moveIn(outline.children, slug, where);
+    if (result.ok && sharedOutline(root) && !ownsOutline(root, outline)) return { ok: false, reason: "cross-workspace" };
     const written = result.ok && !writtenAs(outline, stored);
     if (written) await writeOutline(root, outline);
     return { ...result, ...(result.ok ? { written } : {}) };