@heycys/gallery 0.2.2 → 0.2.4

package/dist/chunk-56SVJENP.mjs

@@ -0,0 +1,966 @@
+import { createRequire as __galleryRequire } from "node:module"; import { fileURLToPath as __galleryPath } from "node:url"; const require = __galleryRequire(import.meta.url); const __filename = __galleryPath(import.meta.url); const __dirname = __galleryPath(new URL(".", import.meta.url));
+var c=e=>e.map((t,s)=>s===0?`Usage: ${t}`:`       ${t}`).join(`
+`),h=({intro:e,subs:t})=>[c(t.flatMap(s=>s.usage)),e,...t.map(s=>s.text)].join(`
+`);function w({command:e,intro:t,subs:s}){let a=Math.max(...s.map(n=>n.name.length));return[`Usage: gallery ${e} <command> [options]`,t,"",`Commands (gallery help ${e} <command> prints one in full: its usage lines, what it does and prints, its exit codes):`,...s.map(n=>`  ${n.name.padEnd(a)}  ${n.summary}`)].join(`
+`)}var p=({command:e},t)=>`${c(t.usage)}
+${t.text}
+gallery help ${e} says what a ${e} is and lists the other commands.`,l={command:"block",intro:`A custom block (\u81EA\u5B9A\u4E49\u5757) is a block to use again, kept in the workspace: components/<scope>/<name>/
+(its files keep the word component: component.json, data-doc-component). An id is <scope>/<name>, or a
+<name> alone in the scope local (but for show and check, a <name> that is none of local's and is one of
+Gallery's own is Gallery's, as for add: gallery block show heatmap shows gallery/heatmap); a document
+uses one by an element naming it. The scopes gallery and gallery-soft are Gallery's own blocks' (its two packs:
+Gallery \u98CE\u683C and \u67D4\u5149\u98CE\u683C). gallery component \u2026 is another name for gallery block \u2026, and says the same.`,subs:[{name:"new",summary:"start a block (--script --flow --data --page, or --recipe <name> from one of Gallery's own)",usage:["gallery block new <id> ([--script] [--flow] [--data] [--page] | --recipe <name>)"],text:`new starts a block: component.json, template.html, example.html, writing.md and style.css, and with
+--script a kit.js; with --flow a slot, body, in place of its paragraph, where a document writes blocks
+of its own; with --data a block that keeps what a reader enters in a part of JSON (items, a list of
+lines, written on one line as context.editJSON writes it): a kit.js that reads it with context.readJSON
+and writes it with context.editJSON, from a field (DocKit.input) and a button hidden where nothing is
+written (an export), an example() that adds a line and works on template.html's empty instance as it
+does on example.html's (--script is implied; --data and --flow do not go together); with --page a
+custom page's card (places ["page"], a card of two sizes the user may resize, its text parts edited as
+none, which a page shows as written; --page and --flow do not go together), combined with --data a
+card that keeps data; with --recipe <name> (alone: none of --script --flow --data --page goes with it, the
+recipe being a block already made: todos, weather and the other blocks of Gallery's for a custom page
+are cards for one already, places ["page"]) the files of Gallery's own block of that name, every word
+that named it naming the new id, its version 0.1.0, and a line naming what is still the recipe's:
+preview.svg, writing.md and example.html. Each passes check, and try on its field, as it stands, and
+says what to write next.
+Exits 1 when the id is taken; 2 for an id of the scope of Gallery's own packs or of a pack installed, a
+recipe Gallery has none of, or options that do not go together.`},{name:"add",summary:"put one of Gallery's own blocks into the workspace as it ships",usage:["gallery block add <name>"],text:`add puts one of Gallery's own blocks in the workspace as it ships (a <name> alone is Gallery \u98CE\u683C's,
+gallery-soft/<name> \u67D4\u5149\u98CE\u683C's), components/gallery/<name>/, no check
+or try needed, and records its version and what its files hold in .gallery/blocks.json; run again with a
+newer Gallery, it updates a copy that is as it was added, and never one changed since.
+Exits 1 when the copy there was changed since it was added (or put there by another hand), said with
+what to do: --recipe for a block of your own, or delete the folder and add it again.`},{name:"list",summary:"what the workspace has now, by where a block may stand (--json for a script)",usage:["gallery block list [--json]"],text:`list says what the workspace has now, in two groups by where a block may stand (its manifest's places):
+\u6587\u6863\u91CC\u53EF\u7528, in documents, and \u81EA\u5B9A\u4E49\u9875\u53EF\u7528, on custom pages, each with its version, what it uses (needs)
+and whether the user's switch keeps it out of the document's menus, which is still a block to write;
+then those not to use now and why: disabled, one that does not load, a manifest one level too shallow;
+then Gallery's own blocks not added yet, or added as an older version, each with its gallery block add
+line; and last the built-in blocks the user took out of the document's menus.
+--json prints one JSON object instead, 2-space indented, and nothing else: { "workspace": its absolute
+path, "blocks": [every block of the workspace, those that do not run too: { "id", "pack" (its scope),
+"name" and "description" ({ "zh", "en" }; null where its manifest does not read), "version", "state"
+("normal", "hidden", "disabled" or "broken"), "reason" ({ "zh", "en" }: why a broken one does not load,
+else null), "places" (["document"], ["page"] or both; null where unread), "needs" (its manifest's; null
+where unread), "template" (whether a menu can put it in), "menu" (the switch \u5728\u6587\u6863\u83DC\u5355\u91CC\u663E\u793A), "unlisted"
+(the master switch off: no menu or library offers it), "disabled" (\u505C\u7528), "net": { "hosts" (the websites
+its needs name), "allowed" (those the user allowed), "on" (\u5141\u8BB8\u8054\u7F51 is on: every host allowed) } }],
+"available": [Gallery's own blocks the workspace has not added, or has as an older version: { "id",
+"add" (what gallery block add takes), "title" ({ "zh", "en" }), "version", "places", "added", "workspaceVersion",
+"changed" }], "builtin": [the built-in blocks of the document's menus, what gallery block menu takes
+besides a custom block's id: { "id", "name" ({ "zh", "en" }), "hidden", "hideable" }] }. The fields
+are only ever added.`},{name:"show",summary:"how to write one block: its parts, where it may stand, writing.md and the example",usage:["gallery block show <id>"],text:`show says how to write one: its parts, where it may stand, its writing.md and its example. Of one of
+Gallery's own the workspace has not added (gallery/<name>) it prints what Gallery ships of it the same
+way, and ends with the gallery block add <name> line that puts it in.
+Exits 1 when there is no such block or it does not load.`},{name:"check",summary:"what is wrong with a block, in its files and in a browser (--documents: its instances too)",usage:["gallery block check <id> [--documents]"],text:`check says what is wrong with one, each problem ("FAIL") at its place in the block's files, each note
+never a failure, in five sections: 1 the manifest, with template.html there, text parts that hold
+words and marks alone, and a note on a Chinese name no word of its words spells whole in pinyin, a
+syllable a character, by how many syllables a word reads as; 2 kit.js: what a browser refuses, what
+an export refuses, what it registers, a type check against sdk/; 3 style.css: every selector in the
+instance, what an export cannot hold, and a note on one that goes down into a slot; 4 template.html
+and example.html, each read as a document's page by what gallery check runs, and template.html as what
+a menu can put in; 5
+both in a temporary document, exported and opened as gallery qa opens one, in Chrome or Edge under the export's
+policy: what the console and the policy say, a dialog or a window it opens, mount then dehydrate then
+mount and copies put back giving the same DOM (a drawing neither the manifest's runtime nor dehydrate
+names piles up, and what piles up outside the instance is named too), a slot the component writes in
+or moves, a text part the component redraws, a data part a mount changes, a write with no gesture
+once the page takes edits, the way back to the file (a way back line: what the component's example wrote, each part with how many of its
+lines the write took out and put in, and that the server took it; a note on a write that lays a part
+out anew (not where it is context.editJSON's own layout: a part on several lines closing to one line as
+its list empties, an entry in it opening to lines as it comes to hold an object; a part on one line
+stays on one), a FAIL at kit.js on an example() that changes nothing on template.html's empty instance, and a
+note on a list a card is dropped on that listens for dragover and not for dragenter), a note on a
+control of an instance with a data part that is still shown and enabled where nothing is written (the
+export's look: context.canEdit() false), a page wider than the window, and the pictures, in <workspace>/.gallery/qa/components/<id>/, its absolute
+path printed, emptied each run: overview-light.png and overview-dark.png, the three widths of a theme
+side by side, then each at 360, 736 and 1024px wide, light and dark, and edit-1024-light.png and
+edit-360-light.png, as the editing page draws it, said when they are the export's. Section 5 waits
+until what it needs passes; a page that stops answering or loads itself again ends it, and is said;
+with no browser, one that does not start or goes while it looks, or a folder it cannot write, it says
+so and the rest stands. A block the user turned off is checked as any, with a note saying so. A note in
+section 1 says a preview.svg that is, byte for byte, one of Gallery's own blocks' (a block made with
+--recipe keeps its recipe's picture). Last, before the verdict, a \u4E0B\u4E00\u6B65 line lists every
+picture of the run, none looked at for you, as gallery page check's does (gallery qa lists them as \u8981\u770B\u7684\u56FE).
+--documents adds a section for each document of the workspace that holds instances of it, those in
+another's slot too: each run as the example is, in a temporary document of their own, exported and
+opened under the export's policy, each problem at its line of the document's file (board/doc.html:15),
+the pictures in documents/<slug>/ of the block's folder. It writes no document.
+GALLERY_BROWSER=<executable> picks the browser.
+Exits 1 when anything fails, 3 when nothing did and no browser ran it (UNVERIFIED), else 0.
+Exits 2 for an id no block can have.`},{name:"try",summary:"make a reader's gestures on an instance in a document, and say what they wrote",usage:["gallery block try <slug> [<instance id>] --press <selector> [--then <key>] [--keep]","gallery block try <slug> [<instance id>] --drag <selector> --to <selector> [--then <key>] [--keep]","gallery block try <slug> [<instance id>] --key <selector> <key> [--then <key>] [--keep]","gallery block try <slug> [<instance id>] --type <selector> <words> [--replace] [--then <key>] [--keep]","gallery block try <slug> [<instance id>] --select <selector> <value> [--then <key>] [--keep]","gallery block try <slug> [<instance id>] --steps <file> [--keep]"],text:`try makes what a reader does on an instance in a document, with the pointer and the keys, and says
+what it wrote. It makes it on a scratch copy of the document (<workspace>/.gallery/try/try-<8 hex>/,
+gone at the end, whatever came of it): doc.html is not written, and no page of the user's shows the trial;
+--keep makes it on the document itself and leaves what it wrote. It starts the shared Gallery server (or
+uses the one running), as gallery open does, and opens the copy's page alone, editable, in Chrome or
+Edge, headless, in a profile of its own, and waits until the server has told the page of the writes
+made before it (a custom block changed), which load it again. Each selector is the first element of the
+instance it finds: --press, a press at its middle; --drag \u2026 --to, pressed there, moved in steps to the
+middle of another and released a moment after the move that comes onto it; --key, the key (Enter,
+Space, ArrowRight, a letter, Shift+Tab, Control+a) with the focus on it, as Tab gives it; --type, the
+words typed in a field or an editable element, pressed first and the caret at its end (unless the focus
+is in it already), ASCII key by key and the rest through an input method, composed then committed (the
+Gesture line says what the field held, and that the words went after it, or, with the focus in it
+already, in at the caret where a step before left it; --replace selects all it holds first, so that
+they take its place, as { "type": [".name", "\u65B0\u540D\u5B57"], "replace": true } in a step);
+--select, an option of a <select>, by its value or its words, chosen as a reader picks one. --then
+<key> presses a key after it where the focus is (--then Enter, for a field that writes on Enter).
+--steps <file> makes several, one after another in one page: a JSON list of steps, each one gesture as
+the options name them, without their --: [{ "press": ".add" }, { "key": [".name", "Control+a"] },
+{ "type": [".name", "\u591A\u559D\u6C34"], "then": "Enter" }, { "select": [".unit", "\u676F"] }, { "drag": ".card",
+"to": ".column:nth-child(3)" }], 20 at most. <slug> names the document, as its link or a whole address
+does too (gallery help says how), and the instance is named by its data-block-id, or by its block's
+id where the document holds one of it; with one instance in the document, not at all. An instance in
+another's slot is one of them, said with where it stands. Once <html>'s data-ge-save says saved again
+after each, it prints a Gesture line (Step N with --steps), what it did to which element, and a Wrote
+line: each part of the instance with how many of its lines it took out and put in, then those lines
+(- and +), and that nothing outside the instance changed, data-block-id aside, which a save gives
+(what did is someone else's, which stays); with --steps, Wrote: nothing of a step that wrote nothing.
+Then it undoes as a reader does, the focus taken off a field of the instance first (a field that
+writes as it loses the focus writes then), and Ctrl+Z pressed once for each write the page took, the
+last first (each context.edit is an undo step of its own: a step that wrote twice takes two), and an
+Undone line says the copy came back as it was before each step that wrote; --keep presses none (a Kept
+line). Then it opens what the steps wrote in a fresh page (a second copy, or doc.html with --keep),
+where the instance is to mount, write nothing as it opens (its file the same once it has come to edit)
+and show the words and the fields' values it showed after them of what they wrote (a Read back line);
+what it shows otherwise that is none of what the steps wrote (a filter or a tab chosen, an editor left
+open, words typed and not committed: what the page showed and never wrote) is a note. Last, a picture of
+the instance after the steps, <workspace>/.gallery/qa/<slug>/try/after.png, its absolute path
+printed, emptied each run: open it, as the line says; a \u4E0B\u4E00\u6B65 line then lists the pictures of the
+run (after.png, and fresh.png when it was taken), none looked at for you. A trial cut off (the page offline, a load of its
+own, the browser gone) says what the file held of it.
+Exits 1 when no step wrote anything (what came of the last said: no context.edit, one the page
+refused, an HTML5 drag dropped nowhere, a selector that finds nothing as the component failed, a
+field typed in that writes on a key or as it loses the focus), when a Ctrl+Z did not take a step's
+write back, when the fresh page shows it in its fallback, writes as it opens or shows what the steps
+wrote otherwise than the page did after them (fresh.png pictures it), or when the component failed; 2
+for a mistake in the command line: a selector that finds nothing shown in the instance, an instance the
+document has not among them, a drag that ends on what it drags, an option a <select> has not, a steps
+file that does not read (one found at a step after others were made is said after what those wrote,
+which with --keep stays in doc.html); 3 when the trial was not seen through (UNVERIFIED: no server or browser ran
+it, a page that loaded itself again; with --keep a card waiting for the reader, someone else's write
+meanwhile, which stays), the line saying what the file held.`},{name:"key",summary:"keep, show or take away the key for a site a block reaches",usage:["gallery block key [<host> [<key>]] [--remove]"],text:`key keeps the workspace's key for a site its blocks reach, by its host (a block's needs' host:
+api.example.com), in <workspace>/.gallery/keys.json, never gallery.json: where a block's address on that
+host names {key} (its path or its query: \u2026/latest?apikey={key}), Gallery's server writes the key in as it
+fetches for the block (context.fetch); no page, cache or export ever holds it. With a host and no key
+it says whether one is kept; with --remove it takes it away; with nothing, the hosts that have one and
+those the workspace's blocks name with none. A key is never printed.
+Exits 2 for a host no block's needs can name, or a key that is empty or more than one line.`},{name:"pack",summary:"block packs (\u81EA\u5B9A\u4E49\u5757\u5305): install, list, remove, switch on or off",usage:["gallery block pack install <folder|zip>","gallery block pack list [--json]","gallery block pack remove <pack>","gallery block pack on|off <pack>"],text:`pack: a block pack (\u81EA\u5B9A\u4E49\u5757\u5305) is a scope of blocks, components/<pack>/, with its pack.json (id, name,
+description, version, author, homepage, icon), to share as its folder or a zip of it. pack install copies
+one in (a folder, or a zip with the pack's folder or what it holds at its top), each block's manifest
+last, and records its version and what its files hold in .gallery/blocks.json; installed again (a newer
+version), a block as it was installed is replaced and one changed since is kept, said with what to do.
+Refused, exit 1, with why: no pack.json at its top or one that does not read, a block folder whose
+component.json does not name it <pack>/<name>, a file that points out of it, more than 2000 files or 64
+MB, the id of one of Gallery's own packs, or one the workspace has a folder of that no install put
+there. pack list says the workspace's packs: Gallery's own (installed as a workspace first starts:
+Gallery \u98CE\u683C on, \u67D4\u5149\u98CE\u683C off), those installed and the scopes of its own blocks, each with its version,
+whether its switch in \u8BBE\u7F6E \u203A \u7EC4\u4EF6\u5217\u8868 is on (off: no menu or library offers its blocks; what is written of
+them shows as ever), how many blocks and who made it. pack remove takes out a pack installed, its
+folder and records (exit 1 for one of Gallery's own, which its switch turns off, or a scope no install
+put there).
+pack list --json prints one JSON object instead, 2-space indented, and nothing else: { "workspace": its
+absolute path, "packs": [{ "id", "name" ({ "zh", "en" }), "kind" ("default", "official", "installed" or
+"own"), "version", "enabled" (its switch), "blocks" (how many), "author", "description", "homepage",
+"icon", "problem" ({ "zh", "en" }: why its pack.json does not read, else null), "changed" (the blocks
+changed since they were installed), "newer" }] } in the order pack list says them; the fields are only
+ever added.
+pack on and pack off turn a pack's switch on or off, the switch of its card in \u8BBE\u7F6E \u203A \u7EC4\u4EF6\u5217\u8868
+(gallery.json's components.packs): off, no menu or library offers its blocks ("/" and \u6DFB\u52A0\u81EA\u5B9A\u4E49\u5757),
+and what is written of them shows as ever; on offers them again. <pack> is its id (gallery block pack
+list says each: gallery for Gallery \u98CE\u683C, gallery-soft for \u67D4\u5149\u98CE\u683C, local for the default pack). One of
+Gallery's own the workspace has not got yet (no server has started in it, gallery init has not run) is
+installed first, as they install it; the user turns the packs on and off, so do it when they ask. It is
+written through the workspace's running server when there is one (the open pages follow at once), else
+here, and says whether it changed anything (a pack on already is not an error).
+Exits 1 when the workspace has no such pack (or gallery.json cannot be read or written); 2 for a pack id
+that is none.`},{name:"menu",summary:"show a block in the document's menus or take it out (\u8BBE\u7F6E \u203A \u7EC4\u4EF6\u5217\u8868 \u203A \u5728\u6587\u6863\u83DC\u5355\u91CC\u663E\u793A)",usage:["gallery block menu on|off <block>"],text:`menu on and menu off turn the block's switch \u5728\u6587\u6863\u83DC\u5355\u91CC\u663E\u793A of \u8BBE\u7F6E \u203A \u7EC4\u4EF6\u5217\u8868 on or off: off, "/", \u5728\u4E0B\u65B9\u65B0\u5EFA
+and the handle's grid no longer offer it, and what is written of it in documents still runs and exports as
+ever (the switch is about the menus alone, a document still writes the block); on offers it again. <block>
+is a custom block's id (a <name> alone is local's, else Gallery's own: as show takes it) or the name of a
+built-in block (callout, quote, table\u2026: gallery block list --json lists them as "builtin", with the ones that
+cannot be taken out). A block that stands on custom pages alone (its places hold page, not document) is out
+of the document's menus until menu on. A built-in block that must stay in the menus (text, headings,
+lists\u2026) is refused. It is written through the workspace's running server when there is one (the open pages
+follow at once), else here, and says whether it changed anything.
+Exits 1 when there is no such block or the block cannot be hidden (or gallery.json cannot be read or
+written); 2 for a block id that is none, or a missing on or off.`},{name:"net",summary:"let a block reach the websites its needs name, or take that back (only when the user asks)",usage:["gallery block net on|off <block>"],text:`net on lets a custom block reach the websites its manifest's needs name (net:<host>), the switch \u5141\u8BB8\u8054\u7F51 of
+\u8BBE\u7F6E \u203A \u7EC4\u4EF6\u5217\u8868: Gallery fetches for the block, only from those sites, with none of the user's logins, and
+what it gets is shown in Gallery and kept in an export. It goes beyond the workspace, so turn it on only
+when the user asked for it, never to make a block work on your own say. net on prints the websites first
+(all of them are allowed together; one that a later version of the block adds needs a new net on), then
+writes the consent in gallery.json (components.net). net off takes it back at once (the block shows what
+it last had, or asks the reader again). It is written through the workspace's running server when there is
+one (the open pages follow at once), else here, and says whether it changed anything.
+Exits 1 when there is no such block, its needs name no website, or gallery.json cannot be read or written;
+2 for a block id that is none, or a missing on or off.`}]},d={command:"page",intro:`A custom page (\u81EA\u5B9A\u4E49\u9875) is a page the workbench lists in its sidebar with \u65B0\u5EFA and \u641C\u7D22, kept in the
+workspace: pages/<slug>/, page.html (free HTML: its look, its own scripts, and boards of cards, each card
+one custom block's instance, where it has them) and page.json ({ "title", "icon" }). An Agent writes them
+(the user may make a blank one for an Agent to write); the user orders, renames and trashes them, and an
+Agent does so when the user asks (page set, page move, gallery trash <slug>), not on its own.
+Documents and custom pages share one set of slugs: neither takes the other's, nor pages (the folder).
+The home page (\u9996\u9875) is pages/home, a page as any.`,subs:[{name:"new",summary:"make a page: page.html with one empty board, and page.json",usage:['gallery page new <slug> "<title>"'],text:`new makes one: page.html with its title (in <title>: a page draws no big title) and one empty board (data-board-id="main"), and
+page.json with the title; it goes last in the sidebar's head. The server puts in the scripts and styles
+of the blocks its cards hold. Says where it wrote and what to write next, and with the shared Gallery server
+running ends with the \u4EA4\u7ED9\u7528\u6237 line gallery open has: the page's whole address, to send the user at once
+(without one, gallery page open <slug> --no-browser gives it).
+Exits 1 when the slug is taken (a document's, a page's, the trash's) or kept (exports, components, pages,
+assets, materials\u2026). Before the server's first start in the workspace makes the default home page (with
+its own cards; gallery open --no-browser starts one), gallery page open, add, try and check of home say
+so in place of "no such page".`},{name:"list",summary:"the pages in the sidebar's order, each with its address (--json for a script)",usage:["gallery page list [--json]"],text:`list says the workspace's custom pages in the sidebar's order (the order the user dragged them to, then
+gallery.json's pages.order, then by title): each one's slug, icon and title, its address (\u5730\u5740\uFF1A, the whole address with
+the shared Gallery server running, else /#@<slug>, after the port of a server) and where its page.html is;
+in a workspace with no page whose home page is not made yet, only that the home page waits for the server.
+A page in the trash (gallery trash, the sidebar's \u79FB\u81F3\u56DE\u6536\u533A) is not listed.
+--json prints one JSON object instead, 2-space indented, and nothing else: { "workspace": its absolute
+path, "server": { "port" } of the shared Gallery server (null when none runs), "pages": [{ "slug",
+"title", "icon" (null for none), "defaultCards" (whether page reset-cards works on it), "address" (as
+\u5730\u5740 says it), "file" (the absolute path of its page.html) }] in the sidebar's order, "homeNotMade": whether
+the default home page waits for the server's first start }; the fields are only ever added.`},{name:"open",summary:"start the server if none runs and open the page in the browser",usage:["gallery page open <slug> [--no-browser]"],text:`open starts this workspace's Gallery server (or uses the one running), as gallery open does, and opens
+the default browser at the page in the workbench (--no-browser, or GALLERY_NO_BROWSER=1, opens none).
+Prints the workspace, the server, the page alone (the Agent's own: /pages/<slug>) and last the address
+to give the user (/#@<slug>).
+Exits 1 when there is no such page or no server answers.`},{name:"add",summary:"put a card of a block on a page, its settings written with it (--set)",usage:["gallery page add <slug> <block> [--board <id>] [--x <n> --y <n>] [--w <n>] [--h <n>] [--set <key>=<value>]\u2026"],text:`add puts a card of a custom block on a board of the page (--board, else main, else its first): the
+block's id (local/water) or the name of one of Gallery's own the workspace has (gallery block add puts
+one in), a block whose manifest's places hold page. The card takes the block's default size (its
+card.sizes' first, else card.w and card.h; one with no h 2 high, where the page's own \u6DFB\u52A0\u81EA\u5B9A\u4E49\u5757 makes it
+as high as its content) at the first free spot (the topmost row it fits in, its leftmost column), or the cells --x and
+--y (and --w, --h, held to the block's sizes or its min and max: one that writes a min or a max beside its sizes takes any whole size between them) say, the cards it meets pushed down,
+never one moved up; its data-card-id is the lowest c<n> no card holds, and every card of the page gets
+one it lacks. Written through the workspace's running server when there is one (the queue an open
+page's own gestures go through: the page shows the card at once; a block put in a moment ago is
+waited for until the server takes it, a few seconds at most), else into page.html, which is kept
+first (.gallery/state/pages/<slug>/, the last 20), every other byte of it as it was. Prints the card's
+id and cells, and the cards it pushed. Each --set <key>=<value> writes a setting of the block (its manifest's
+settings: weather's city, countdown's date) into the card's settings part as it is added, in the same
+write, as the card's own grip \u203A \u8BBE\u7F6E\u2026 would, the value held to the setting's type (a number, a date as
+YYYY-MM-DD, a select's one of its options, a switch's true or false): --set city=\u4E0A\u6D77 --set unit=\u2109. The
+words after the first "=" are the value, whatever the shell does to quotes (no JSON to quote). A block that
+has a setting it cannot show anything without (required: weather's city, countdown's date), added with
+none, says so after the card: ask the user for it, or take it from what the workspace says.
+Exits 1 when there is no such page or board, or the block is not in the workspace, is turned off or is a
+document's alone; 2 for a --set of a setting the block has not, or a value its type refuses, nothing written.`},{name:"set",summary:"change a page's title or icon (the sidebar's \u91CD\u547D\u540D)",usage:['gallery page set <slug> [--title "<title>"] [--icon <emoji|icon|none>]'],text:`set changes a custom page's title or icon as the sidebar's \u91CD\u547D\u540D does: its page.json's title (the
+same function the workbench's rename calls) and icon (none takes it away), every other field of page.json
+as it was; at least one of --title and --icon. An icon is an emoji or an icon of the \u56FE\u6807 tab
+(/icons/<name>_<color>.svg, Tabler's /icons/tabler/<name>_<color>.svg, the colors gray, lightgray, brown,
+yellow, orange, green, blue, purple, pink, red), not a picture. page.html is not touched: its own <title> is
+the page's, which an Agent writes. The sidebar shows the change at once (the server watches page.json).
+A title that starts with "-" and a letter is written --title="-Q3 \u56DE\u987E".
+Prints what changed, then the file to re-read (\u91CD\u8BFB\uFF1A).
+Exits 1 when the page is not there or page.json does not read; 2 for a title that is empty or over 200
+characters, or an icon that is none of these.`},{name:"move",summary:"move a page's row in the sidebar's head (--after another page, or --first)",usage:["gallery page move <slug> (--after <page> | --first)"],text:`move puts a custom page's row in the sidebar's head (\u65B0\u5EFA, \u641C\u7D22 and each page, in the order the user
+drags them to) right after another page's row (--after), or before the first page's row (--first; \u65B0\u5EFA
+and \u641C\u7D22 stay where they are). Written through the workspace's running server when there is one (an open
+workbench shows it at once), else here, in the outline file under its lock, every other thing of it as it
+was. Prints the pages in their new order (as list says them). A page that is where it is asked to be
+changes nothing (exit 0).
+Exits 1 when a page named is not there, or --after names the page itself; 2 for none or both of --after
+and --first.`},{name:"card",summary:"change one card of a page: its settings, its place or size, or take it off",usage:["gallery page card <slug> <card id> [--set <key>=<value>]\u2026 [--move <x>,<y>] [--size <w>,<h>]","gallery page card <slug> <card id> --remove"],text:`card changes one card of the page, as the card's own gestures do, through the page service (every gesture
+of the page and page add go through it: the open page shows the change at once; no server running, the same
+code writes page.html here, the file kept first as add keeps it). The card is named by its data-card-id (page
+check lists them; a card with none has the lowest c<n> its page gives it). --set <key>=<value> writes a
+setting of its block into the card's settings part, as page add --set does (each value held to its
+setting's type; the words after the first "=" are the value); --move <x>,<y> puts it at other cells
+(whole numbers, x from 0 and y from 0, on its board), --size <w>,<h> gives it another size (w 1 to 12, h at
+least 1, held to the block's sizes or its min and max; a block that is not resizable refuses): both in one
+write, the cards it then meets pushed down, never one moved up. --remove takes the card off the page
+(alone: nothing goes with it): its data goes with it (page.html as it was is kept in
+.gallery/state/pages/<slug>/, the last 20 versions), and gallery page add puts a new card of its block
+in. With --move or --size and --set together the place is written first, then the settings. A card another writer changed between the read and the write is read again (three tries).
+Prints the card's cells, the settings now and the file to re-read (\u91CD\u8BFB\uFF1A).
+Exits 1 when the page, the card or its block is not there, or the service refuses (the card is not
+resizable, page.html would grow past 1,000,000 bytes); 2 for a --set of a setting the block has not or a
+value its type refuses (nothing written), cells that are not whole numbers, none of the options, or
+--remove with another.`},{name:"reset-cards",summary:"put back the default cards a page misses (the page's menu \u6062\u590D\u9ED8\u8BA4\u5361\u7247)",usage:["gallery page reset-cards <slug>"],text:`reset-cards does for a page what its menu's \u6062\u590D\u9ED8\u8BA4\u5361\u7247 does, through the page service (restore-defaults): of
+the default blocks the page has (its page.json says "defaultCards": true, as the default home page's does;
+Gallery's today, weather, countdown, habit, stats, todos, heatmap, recent, note and static) it puts a card of
+each that no card of the page holds, at the first free spot by its default size, Gallery's own block put into
+the workspace first; every other card and byte as it was, nothing pushed. Prints the cards it put back
+(id, block, cells) and the default blocks it could not (turned off, not there), or that the page holds
+them all. Written through the workspace's running server when there is one (the open page shows them at
+once), else here.
+Exits 1 when the page is not there or has no default cards.`},{name:"try",summary:"make a reader's gestures on one card, and say what they wrote",usage:["gallery page try <slug> <card id> --press <selector> [--then <key>] [--keep]","gallery page try <slug> <card id> --drag <selector> --to <selector> [--keep]","gallery page try <slug> <card id> --key <selector> <key> [--keep]","gallery page try <slug> <card id> --type <selector> <words> [--replace] [--then <key>] [--keep]","gallery page try <slug> <card id> --select <selector> <value> [--then <key>] [--keep]","gallery page try <slug> <card id> --steps <file> [--keep]"],text:`try makes what a reader does on one card of the page, named by its data-card-id, and says what it wrote:
+gallery block try's gestures (--press, --drag \u2026 --to, --key, --type, --select, --then) and steps
+(--steps <file>), made in the page with the pointer and the keys on the card's instance, each selector
+the first element of the instance it finds (gallery block --help says each). It makes them on a scratch
+copy of the page (<workspace>/.gallery/try/try-<8 hex>/, gone at the end, whatever came of it):
+page.html is not written, and no page of the user's shows the trial; --keep makes them on the page itself
+and leaves what they wrote. It starts the shared Gallery server (or uses the one running) and opens the
+copy's page alone (/pages/<slug>), editable, in Chrome or Edge, headless, in a profile of its own. A
+write is what the page's board sends the page service, as the user's gestures go: once each is
+answered, a Gesture line (Step N with --steps) and a Wrote line say each data part of the card's
+instance (its settings among them) with the lines it took out and put in, those lines under it (- and
++), and that nothing else in page.html changed (card ids aside, which the page service gives the cards
+that have none). Only the card's data parts may change: a write anywhere else (the card's place, its
+own markup, another card, the page's own HTML) is a problem, said with what it changed. Then the page's
+own undo, Ctrl+Z pressed once for each write it took, the last first, the focus taken off a field of the
+card first (an Undone line: the copy as it was, card ids aside); --keep presses none (a Kept line). Then
+a fresh page of what the steps wrote (a second copy, or page.html with --keep), where the card is to
+mount, write nothing as it opens and show what it showed after them of what they wrote (a Read back
+line). Last, a picture of the card's instance after the steps, <workspace>/.gallery/qa/<slug>/try/after.png,
+its absolute path printed: open it, and the \u4E0B\u4E00\u6B65 line lists it. --replace goes with --type, as
+gallery block try's does.
+Exits as gallery block try does: 0 the steps wrote, the undo took it back (or --keep kept it) and a fresh
+page read it back; 1 a problem of the block's (gestures that wrote nothing, a write outside the card's
+data parts, an undo that left part of a write, a fresh page that shows it otherwise or writes as it
+opens), or no such page, a card holding no instance, a block that does not load, is turned off or is a
+document's alone; 2 a mistake in the command line (a card the page has not, a selector that finds
+nothing in the instance, a steps file that does not read); 3 when the trial was not seen through
+(UNVERIFIED: no server or browser, a page that loaded itself again).`},{name:"check",summary:"what is wrong with a page, what changed in it, and its pictures",usage:["gallery page check <slug>"],text:`check says what is wrong with the page, each problem a FAIL line with its line in page.html, and what
+changed in it. Its structure (a page's own scripts, frames and stylesheets are none of its problems):
+where it has boards or cards, its boards in <main class="gallery-page">, each board's data-board-id and each
+card's data-card-id there, of lowercase letters, digits and hyphens, and once in the page, each card a
+board's child holding one instance, its data-x, data-y, data-w and data-h whole numbers on the board
+(0 <= x, 1 <= w <= 12, x + w <= 12, 0 <= y, 1 <= h <= 24) and sharing a cell with no other card of its
+board, its block in the workspace, loading, not turned off and with page in its places; and each file of
+the page's own named (assets/<file>: the folder pages/<slug>/assets/, which the server serves at
+/pages/<slug>/assets/<file>) there, and no frame's but a picture's (the server serves a page's own
+pictures by their type, its stylesheets and scripts as such, and any other file as bytes for saving: a
+frame of a file there downloads it, while a link, a font, a video or audio uses the bytes), a picture,
+stylesheet or script written relative any other way being one nothing serves. Then the cards with their ids and cells, and the changes since the page as
+the last check that found nothing saw it (or, before any, since the version the page service kept before
+its last write): cards added, removed, moved (to another board too), resized, their data parts changed
+(with the lines), a card's own markup, the page's own HTML; each change the page wrote since, a gesture
+of the user's there (not gallery page add's), ends "(the user's, on the page)": leave it as it is. Then
+the page itself, a scratch copy of it on the shared Gallery server (started
+or used, as gallery page open does), in Chrome or Edge at 1280, 1920 and 600px wide (a narrow board: fewer
+columns of the same 64px cells), light and dark: a card whose content does not fit it, a card drawn out of its board, the page
+wider than the window, a block that failed, a picture that does not load, what the console says; each
+look pictured whole, <workspace>/.gallery/qa/<slug>/check/<width>-<theme>.png (emptied each run), the
+pictures listed and then, on a line of their own, those not opened yet: open them.
+Exits 1 when anything is wrong (or there is no such page); 3 when nothing is and the page could not be
+looked at (UNVERIFIED: no server or browser), its structure checked all the same; else 0, the page then
+what the next check tells its changes against.`}]};var y=["init","new","import","open","serve","stop","sandbox","preview","preferences","startup","check","export","qa","list","workspaces","move","set","link","extension","block","page","skill","trash","duplicate","copy","favorite","column","notes","status","history","revert","doctor","emoji"],g={component:"block"},u=`The workspace (the folder of your documents) is --workspace <dir>, else GALLERY_WORKSPACE, else the
+nearest folder up from here holding gallery.json (gallery init makes one), else ~/Documents/Gallery (on Windows
+the Documents folder Explorer shows, OneDrive's when OneDrive backs it up): the default workspace, the
+sidebar's \u9ED8\u8BA4\u6587\u6863 (GALLERY_DEFAULT_WORKSPACE names another folder in its place).`,o=`A document is named by its slug, by its link (\u5468\u62A5-k3xv9q2a, what gallery list shows after /#) or by a
+whole address, as a user hands one over (http://127.0.0.1:8080/#\u5468\u62A5-k3xv9q2a, a block's id after a / or not): the
+words in a link are a label, and a title changed since leaves the address good.`,r={preview:`Usage: gallery preview <page.html> [--out <file>] [--open] [--shots <dir>] [--only <names>]
+       gallery preview new <name>
+Build a standalone interactive HTML preview with current Gallery styles, theme and width controls.
+Local scripts/styles are embedded. --shots uses the same Chrome/Edge tooling as gallery qa.
+It executes trusted page code only in its isolated browser profile; it edits no Gallery documents.
+See references/previews.md for configuration and screenshots.`,preferences:`Usage: gallery preferences list [--json] [--all]
+       gallery preferences on|off <name>
+With no arguments, list is the default. List enabled global writing preference files in their configured order. Read the files relevant to
+this writing task by title and scope. --all also shows disabled files (for managing preferences).
+The default is the existing <home>/preferences.md only; additional files live in <home>/preferences/.
+Names may be the displayed title or relative path. Only change files, order or enabled state when
+asked by the user. Files are never moved when disabled.`,sandbox:`Usage: gallery sandbox [start] [--name <name>] [--extension <dir>]... [--from <workspace>] [--demo] [--open] [--keep]
+       gallery sandbox list
+       gallery sandbox env <name>
+       gallery sandbox stop <name>
+Start an isolated Gallery in the foreground on a free loopback port and print its URL and folder.
+--open opens the URL. Ctrl+C or sandbox stop closes the service and removes its temporary files.
+--keep leaves the files for inspection. --demo makes sample documents. --from copies a workspace's
+documents and content settings, leaving out links to other workspaces, Gallery's network keys and runtime state.
+Each --extension copies and enables a trusted source directory. Changes reinstall the copy and keep
+its current enable setting. Legacy workbench scripts need a refresh. Installed extension backends
+run with your OS permissions. Use sandbox env in a separate shell to point Gallery CLI at the sandbox.
+Sandbox start chooses its own workspace. Use --from to try a copy of another workspace.`,startup:`Usage: gallery startup [status|enable|disable|run]
+Show or change this user's login startup setting (JSON). Windows and macOS installed packages
+enable it on the first service start by default. enable/disable also update the operating system;
+the choice persists across upgrades. run is the silent login launcher: reuse the shared service
+and saved port, never open a browser. gallery stop stops it until the next login or gallery open.
+Source checkouts, npx caches and GALLERY_NO_AUTOSTART=1 never register login items.
+Exits 1 if the system cannot apply the setting; 2 for an unknown action.`,init:`Usage: gallery init [<dir>] [--from <old reports dir>] [--name "<name>"]
+Makes a workspace: <dir> (else the workspace found as every command finds it) with its gallery.json
+only (never over a gallery.json that is there); the home workspace also gets its application folders. Prints \u5DE5\u4F5C\u533A\uFF1A<abs>\uFF08\u65B0\u5EFA or \u5DF2\u6709\uFF09.
+--name writes the workspace's name in its gallery.json (the project's: what the sidebar and gallery
+workspaces call it; else its folder's), said as \u540D\u5B57\uFF1A<name>; gallery workspaces --name changes it.
+The workspace goes on this machine's registry, as every command's does (gallery workspaces).
+--from copies the documents of an older Gallery (its reports/ folder: one folder a document, each
+holding report.html or doc.html) into the workspace: every document whose slug is free here (the
+others listed as skipped), its preferences.md when the workspace has none, the sidebar's order, the
+\u5199\u4F5C\u504F\u597D page, the custom emoji and the documents' recent versions. The old folder is only read:
+nothing there is changed, moved or deleted.
+Only the default workspace gets its home page (\u9996\u9875, pages/home/: Gallery's today and note cards),
+as a server's first start gives it, said in a line; once made, nothing makes it again.
+Exits 1 when the workspace cannot be written or --from names no folder; 2 for a name that is empty,
+over 80 characters or more than one line.`,new:`Usage: gallery new <slug> "<title>" ["<description>"] [--under <document> | --column "<column>"] [--after <document> | --first] [--no-preview] [--no-browser]
+A new document in <workspace>/<slug>/ from the starter: its doc.html, holding the starter's section
+to replace, and doc.json, with the title and the description (\u65B0\u6587\u6863 when none is given). Where it goes
+in the sidebar's tree: under --under's document, last (first with --first), or right after --after's
+(at that one's level); --column "<column>" puts it last (first with --first) at the top of that
+sidebar column (gallery column new makes one; a column of this workspace's, not another workspace's or
+an extension's); neither, at the top level of the own column, last. A document is named there by its
+slug, link or address (gallery help says how), and must be there, not in the trash; the \u5199\u4F5C\u504F\u597D page
+holds none.
+Then says where it went (Placed it \u2026), where it wrote (the workspace), where the user's writing preferences are (\u5199\u4F5C\u504F\u597D,
+<home>/preferences.md, to read first: made from Gallery's default when there are none yet) and
+the next steps (\u4E0B\u4E00\u6B65\uFF1A, the first: send the user the address now; \u63D0\u793A\uFF1A the hand-in), and last starts the one Gallery
+server (or uses the one running: it runs on after this command), opens the default browser at the
+document and prints the address to give the user, as gallery open does. In a workspace other than the
+default one, the document also joins the default workspace's sidebar (when there is one), in its
+workspace's column: a line says where, \u9ED8\u8BA4\u5DE5\u4F5C\u533A\uFF08\u2026\uFF09\u7684\u4FA7\u8FB9\u680F\uFF1A\u5DF2\u52A0\u8FDB\u2026; it is a display only, the file stays in
+its own workspace. --no-preview (or
+GALLERY_NO_PREVIEW=1) leaves the server alone; --no-browser (or GALLERY_NO_BROWSER=1) opens no
+browser. Editing needs Chrome or Edge.
+A title or a description that starts with "-" and a letter would be read as an option: put "--"
+before the arguments (gallery new q3-review -- "-Q3 \u56DE\u987E").
+Exits 1 when the document exists, or the slug is the workspace's own (exports, the \u5199\u4F5C\u504F\u597D page's) or
+a document's in the trash, or a document --under or --after names is not there (nothing made), or
+the new one could not be placed (made, at the top level); 2 for a document named that is in the trash.`,import:`Usage: gallery import <file> [<slug> ["<title>"]] [--no-preview] [--no-browser]
+New documents made of a file, as the workbench's \u5BFC\u5165 makes them: Markdown (.md .markdown .mdx .txt
+.text), HTML (.html .htm .xhtml, a Gallery export too), a table (.csv .tsv), Word (.docx), PDF (.pdf,
+its text), EPUB (.epub) or a .zip of them (a Notion export: one document a page, nested as there).
+The first document's title is the argument's, else the file's (front matter, first heading, name);
+its slug the argument's, else made of the title's Latin words (lowercase kebab-case, a number added
+when it is taken, as gallery new would refuse it). The pictures a Markdown file links to by relative addresses are copied into
+<slug>/assets/. Then says what it made, what it could not bring as the file has it (by line), the
+text the preview leaves read-only, the workspace, \u5199\u4F5C\u504F\u597D, the next steps (the first: send the user
+the address now), and last, as gallery new does, the browser opened at the first document and the
+server's address to give the user (--no-preview, or GALLERY_NO_PREVIEW=1, leaves the server alone;
+--no-browser, or GALLERY_NO_BROWSER=1, opens no browser).
+Put "--" before a title that starts with "-" and a letter.
+Exits 1 when the file is not there, cannot be read, or gallery new would refuse the slug; 2 for a
+kind it does not take.`,open:`Usage: gallery open [<slug>] [--no-browser] [--present] [--settings extensions]
+Starts this workspace's Gallery server (or uses the one running: it runs on after this command, its
+log in <data>/logs/server.log), waits until it answers, and opens the default browser
+at the workbench, or at the document <slug>, at its block when an address names one (--no-browser,
+or GALLERY_NO_BROWSER=1, opens none).
+--settings extensions opens the extension list in Settings.
+--present (with a document) opens the document in the workbench's \u6F14\u793A\u89C6\u56FE (full-screen show, no editor): the address
+to give the user is the workbench's with ?present before the #; the workbench shows the document that way once it has
+opened it, and takes ?present off the address (a browser goes full screen only on the reader's own click, so the show
+fills the window instead). The Agent's own page and the other lines are the same.
+${o}
+Prints the workspace, a line on the server only when there is news (it started now, an older one
+was replaced, or it is on another port than the last command found it on: an address given before
+no longer works), the document's page alone (the Agent's own, with a slug) and last
+the address to give the user. With a slug in a workspace other than the default one, a line before
+them says the document joined the default workspace's sidebar (as gallery new's does). Editing needs Chrome or Edge: open the address there.
+With a slug and no qa baseline yet, it first keeps one of the document as it is now, so that the
+first gallery qa after the changes pictures what changed.
+Exits 1 when there is no such document, no server answers, or the shared Gallery server takes the
+request and gives no answer (a second server is never started beside it); 2 for --present without a document or
+with --settings.`,serve:`Usage: gallery serve [--port <n>]
+Runs the shared Gallery server in the foreground until Ctrl+C (gallery open runs one in the
+background instead). Prints the address once it answers. --port picks the port (else the last one
+this Gallery data directory used, else the first free one from 8080).
+Exits 1 when this shared server runs already (its address said) or the port is taken.`,stop:`Usage: gallery stop
+Stops this workspace's Gallery server, the one gallery open or gallery new started: it finishes the
+saves in its queue first. A server npm run dev runs (Gallery's own development) is stopped where it runs.
+Exits 0 when it stopped or none runs, 1 when it could not be stopped.`,check:`Usage: gallery check [<slug>...] [--allow-failures]
+Checks each named document (none named: every document of the workspace) on its own.
+${o}
+Reads it as its preview shows it (natural HTML made the kit's in memory) and writes nothing: what the export will
+write as the kit's markup is printed by line, and the blocks it will give an id (each at its line
+when they are ten at most); first, once, what the preview wrote as the kit's markup when the reader
+edited the document, and the \u6279\u6CE8 it deleted because their words are gone. Problems to act on first
+("fix") come before the others ("note").
+It also holds a document to what must stay whole in it, each failure saying how to mend it: a
+data-block-id that is not an id Gallery made (eight lowercase letters and digits, a letter first: only
+Gallery makes one, so take the attribute off and let gallery export give the block one), an id moved
+off a list item onto the paragraph in it (put it back on the <li>), and a folder of the workspace whose
+doc.json says "instructions": true (that marks the \u5199\u4F5C\u504F\u597D page, which hides the folder from Gallery:
+take it out; naming such a folder, or naming none, checks it). A doc.json title or icon that is not the
+page's is noted with the command that changes both together (gallery set <slug> --title/--icon).
+Exits 1 when a document fails, unless --allow-failures.`,export:`Usage: gallery export <slug>... [--allow-failures]
+       gallery export --all [--allow-failures]
+       gallery export <slug>... --format pdf|markdown|html [--paper A4|A3|Letter|Legal|Tabloid] [--scale <percent>]
+               [--no-files] [--subpages [--folders]] [--out <folder>]
+Hands each named document in: its doc.html (report.html in an older document) written as its
+preview shows it, natural HTML as the kit's markup and every block given an id (through the
+shared Gallery server while one runs); then checks it and writes one standalone offline file per
+passing document, <workspace>/exports/<slug>.html. A document the quick checks fail is not handed in.
+${o}
+It says first, once, what the preview wrote when the reader edited a document and the \u6279\u6CE8 it deleted;
+then the failures ("FAIL <slug>: N problems"), the exports made, the notes to act on first ("fix")
+and the others ("note"), what the hand-in wrote by line, the files to re-read before editing them (\u91CD\u8BFB\uFF1A),
+and last, for each document exported, \u4EA4\u7ED9\u7528\u6237\uFF08\u79BB\u7EBF\u6587\u4EF6\uFF09\uFF1A and the export's absolute path.
+Exits 1 when a document fails, unless --allow-failures.
+--format makes the file the workbench's \u5BFC\u51FA dialog makes, by the same function, with the dialog's options:
+  --format pdf|markdown|html   the page as a PDF (Chrome or Edge prints it), as Notion-style Markdown, or as the
+                               offline file (--format html alone, with its files, is the export above)
+  --paper, --scale             a PDF's paper (A4, the default, A3, Letter, Legal, Tabloid) and scale, a percentage
+                               above 10 and below 200 (100, the default); for --format pdf only
+  --no-files                   the document's pictures and files left out (the dialog's \u6587\u4EF6\u548C\u56FE\u7247\u9664\u5916; their links stay)
+  --subpages [--folders]       the documents under it in the sidebar's tree too, each its own file (\u5305\u542B\u5B50\u9875\u9762), each page's
+                               subpages in a folder named as it with --folders (\u4E3A\u5B50\u9875\u9762\u521B\u5EFA\u6587\u4EF6\u5939; else all at the top)
+  --out <folder>               the folder to write in (made when it is not there) instead of <workspace>/exports/
+With --format the file is written as the workbench's \u5BFC\u51FA writes it, whatever the checks find: each document (and,
+with --subpages, each under it) is handed in and checked first, and what fails is said after the failures as
+\u95EE\u9898\uFF1A<slug> \u6CA1\u901A\u8FC7\u68C0\u67E5\u2026 with its lines, exit 0 (mend it, gallery check says it again, and export again); only an
+export that cannot be made fails (exit 1). One file is written as it is, named by the slug:
+<slug>.md, <slug>.pdf, <slug>.html; a Markdown page that links pictures or files, a chart's picture, or subpages make
+<slug>.zip, as the dialog downloads one: its pages named by their titles, the pictures and files in assets/ beside
+them. An html file without its files (--no-files) is <slug>-no-files.html, never the offline file's name. A PDF needs
+Chrome or Edge (GALLERY_BROWSER names one). Without --format, --no-files, --subpages, --folders and --out imply
+--format html.
+Prints, after the failures and notes, each file made ("Exported <absolute path> (<bytes> bytes)", a zip's files
+listed), the hand-in's lines, and last \u4EA4\u7ED9\u7528\u6237\uFF08PDF\uFF09\uFF1A, \uFF08Markdown\uFF09\uFF1A, \uFF08Markdown \u538B\u7F29\u5305\uFF09\uFF1A, \uFF08\u79BB\u7EBF\u6587\u4EF6\uFF09\uFF1A or
+\uFF08\u79BB\u7EBF\u6587\u4EF6\uFF0C\u4E0D\u542B\u6587\u4EF6\u548C\u56FE\u7247\uFF09\uFF1A with the file's absolute path, for each document.
+Exits 1 when a document fails, unless --allow-failures; 2 for options that do not go together (--paper without
+--format pdf, --folders without --subpages) or a value it does not take.`,qa:`Usage: gallery qa <slug>... [--tiles] [--blocks <id,\u2026>] [--no-export]
+       gallery qa --all [--tiles] [--no-export]
+Looks at each named document's export (<workspace>/exports/<slug>.html; one with none yet, or one not
+made from its doc.html and its custom blocks as they are now, is exported first, as gallery
+export does, unless --no-export) as a reader's browser shows it: Chrome or Edge, headless, at 1024, 736 and 360px wide
+and in a laptop's 1024\xD7768 window, every disclosure open, each Sheet and detail card shown in turn.
+${o}
+Each finding is said with its place in the document's file (doc.html:<line>, report.html:<line> in
+an older document): fail (errors, broken pictures, charts that drew nothing, the page wider than the
+window\u2026), warn (columns or rows out of sight, overlapping text\u2026), info, unverified (no browser, a
+wait that ran out\u2026). It takes every picture it needs in this one run, and leaves no second run to
+make: the flagged elements; every block changed or moved since the last look (a moved one with the
+edges of the blocks around it; a block held by one of them that its picture did not show at a width,
+pictured on its own there); the cards not changed yet not pictured before (all of them the first time,
+and when nothing changed: the twelve a run pictures at most, changed blocks among them; the rest need no
+look, and stay for a later run); --tiles: the page in tiles; --blocks <id,\u2026> (one document only; the ids
+split at commas or spaces, and one the document has not refused before anything is looked at): the
+blocks named. Each run's pictures go to a folder of their own,
+<workspace>/.gallery/qa/<slug>/<the run's time>/ (2026-11-11_14-02-33; flagged/, changed/, cards/,
+blocks/, tiles/ in it), and qa keeps the last 5 runs of each document and takes the earlier ones away as a
+run ends, so nothing needs remembering of what is emptied. First, once, as gallery check says them, what the
+preview wrote when the reader edited the document and the \u6279\u6CE8 it deleted. Then the findings, each look's
+counts, and (a --blocks run) the changed blocks and cards it did not picture, which a plain run does. The
+pictures are named once, last before the verdict, in ONE list: \u8981\u770B\u7684\u56FE\uFF08N \u5F20\uFF09 with each picture to open
+numbered, in the order to open them (the flagged elements first, then the blocks changed, the cards, the
+tiles), by its whole path with its looks in braces and what it is; then \u4E0D\u7528\u770B\uFF1A, what needs no look (the
+cards past the twelve, INFO notes, blocks hidden from readers); then the verdict, and last, on a line of its
+own, the export's absolute path after \u4EA4\u7ED9\u7528\u6237\uFF08\u79BB\u7EBF\u6587\u4EF6\uFF09\uFF1A. Open every picture listed, fix the FAILs, run it
+again, and in the handoff say which you opened.
+GALLERY_BROWSER=<executable> picks the browser. A browser that does not start is tried once more
+with a fresh profile.
+Exit codes: 0 nothing failed (a warning never fails); 1 something failed (or the export it ran first did);
+2 an export is missing or stale with --no-export, or --blocks names an id the document has not; 3 nothing
+could be looked at at all (UNVERIFIED <why>: no Chrome or Edge, or one that did not start); 4 the pages
+were looked at and some places could not be verified (an UNVERIFIED line among the findings names each: a
+wait that ran out, a picture not taken).`,list:`Usage: gallery list [<words>...] [--json]
+       gallery list --tree [<document>] [--json]
+       gallery list [<words>...] --all [--json]
+The workspace's documents, for an Agent to find the one the user means: each one's slug and title,
+its description, where it is in the sidebar's tree when it is under another (\u4F4D\u7F6E\uFF1Athe documents above
+it, from the top), its address (\u5730\u5740\uFF1A/#<link>, after the port of the shared Gallery server), when its file
+was last written and where that file is, the one edited last first.
+With words, only those whose title, description or slug holds any of them (case alike, Chinese found
+inside words), the best first, then those whose text holds them, each with its first place there
+(\u6B63\u6587\uFF1A\u2026); with a document's link or whole address, that document, or that it is in the trash.
+When exactly one document is found by those words, the last line is the address to give the user (\u4EA4\u7ED9\u7528\u6237\uFF08\u2026\uFF09\uFF1A
+and the workbench's whole address, while a server runs; else a \u63D0\u793A line saying none runs and how to start it).
+--tree lists them as the sidebar shows them, in its order, each under the one it is under, indented
+two spaces a level: a line each, its slug, its title (its emoji before it), its description and its
+last edit. --tree <document>: that document and the documents under it, after its \u4F4D\u7F6E line.
+The sidebar's web links (gallery link) are listed too, each with \u7F51\u9875\u94FE\u63A5\uFF1Aits address: after the
+documents (with words, those whose name, address or slug holds one), and in their place in --tree.
+With columns besides the own one (the sidebar's \u680F: each other registered workspace has one, with its
+documents; \u9ED8\u8BA4\u6587\u6863 is the default workspace's), --tree lists them column by column, each under its name
+(one removed from the sidebar is left out), and \u4F4D\u7F6E starts with the column's (\u4F4D\u7F6E\uFF1A\u56E2\u961F\u680F \u203A \u2026) for an
+entry outside the own column; a document outside its own column says that column (\u300C\u9ED8\u8BA4\u6587\u6863\u300D\u7684\u6587\u6863).
+${o}
+First, the workspace and where \u5199\u4F5C\u504F\u597D is (made from Gallery's default when there is none yet).
+--all searches every workspace of this machine (gallery workspaces lists them, the current one
+always among them) by the title, description and slug of each document (not its text), the best
+first (no words: all, the one edited last first), each after the line \u5DE5\u4F5C\u533A\uFF1A<path> of its
+workspace, which --workspace takes to work on it there; it only reads: nothing is written in any of
+them, and \u5199\u4F5C\u504F\u597D is not made. A workspace no longer there is named at the end, not searched.
+--json prints one object instead (an Agent reads it, not the text; fields are only ever added to):
+{ "workspace": path, "documents": [{ "slug", "title", "icon" (or null), "description", "link" (the
+words and page id of its address), "address" (/#<link>), "path" (its doc.html), "parent" (the slug
+it is under, or null), "column" (its sidebar column's name), "columnId", "favorite" (true when the
+sidebar's \u6536\u85CF holds it), "look" (the font and layout of its own: doc.json's look, { "font": "serif" },
+none left out when it follows the workspace), "edited" (ISO time), "hit" (with words: the first place
+its text holds them) }], "links": [{ "slug", "title", "url", "icon", "parent", "column", "columnId",
+"favorite" }] }. --tree: the same in the sidebar's order, each with its "depth", and "drafts" (the
+other workspaces' documents the sidebar holds: "entry", "title", "workspace", "path", "missing",
+"parent", "column", "favorite", "depth"). --all: each document with its "workspace" and the
+"workspaces" searched. The trash is never in it (gallery trash list --json).
+Exits 1 when --tree names a document that is not there, 2 one in the trash.`,workspaces:`Usage: gallery workspaces [--json]
+       gallery workspaces --scan [<folder>]
+       gallery workspaces --name "<name>"
+       gallery workspaces --forget <path>
+       gallery workspaces --show <path or id> [--doc <slug>] [--register]
+       gallery workspaces --hide <path or id> [--doc <slug>]
+The workspaces of this machine: every workspace a gallery command or a Gallery server has worked in
+is registered in a file of the user's (GALLERY_DATA_DIR,
+else %LOCALAPPDATA%\\gallery\\workspaces.json on Windows, ~/Library/Application Support/gallery on macOS,
+$XDG_STATE_HOME/gallery or ~/.local/state/gallery elsewhere). Lists them, the current one first (*),
+then the one edited last first: each one's name (its gallery.json's, else its folder's; the folder
+above it, or its own path, after the name when two are called alike), its id (ws- and six hex
+digits), its path (\u8DEF\u5F84\uFF1A), how many documents it has and when one was last edited (\u6587\u6863\uFF1A), and its
+one shared service address printed above the list (\u670D\u52A1\uFF1A); one whose folder or gallery.json is gone is marked \u4E0D\u5728\u4E86
+and stays registered (a drive may come back).
+--scan registers the workspaces in <folder> and below it, 6 levels down at most (not in node_modules,
+.git, a dot folder or the recycle bin): the Documents folder when none is named. --name names the
+current workspace (gallery.json's name, the workspace made first when it is not there). --forget
+takes a workspace off the registry, named by its path or its id; nothing on disk changes (a command
+run in it registers it again). Nothing else is written, and no file of a workspace is ever removed.
+gallery list <words> --all searches the documents of every one.
+--json prints the list as one object (fields only ever added to): { "current": path, "service": { "port",
+"pid", "address" } or null, "workspaces": [{ "id", "name", "path", "current", "default", "named" (it has a
+name of its own), "exists", "documents" (count), "lastEdited" (ISO time or null) }] }.
+--show is the sidebar's \u6DFB\u52A0\u5176\u4ED6 Gallery \u9879\u76EE\u2026: the workspace named by its folder or its id, whole, as a
+column of the sidebar (its folder is registered now when it is a workspace not yet on the registry;
+a folder that holds Gallery documents but is no workspace is made one only with --register); with --doc
+<slug> that one document of it (and those under it). --hide is \u4ECE\u4FA7\u8FB9\u680F\u79FB\u9664: the workspace's column hidden
+(its workspace, files and registry untouched: what --forget is not), or with --doc <slug> that one
+document taken out of the tree (\u4ECE\u6587\u6863\u6811\u79FB\u9664; the document is not touched). Both are written as the
+sidebar's menu writes them, through the running server when there is one. This Gallery's sidebar lists
+every registered workspace and does not read those hidden marks: --hide then says so (\u63D0\u793A\uFF1A), exits 1
+and names --forget as the way to take a workspace off every sidebar.
+Exits 1 when --scan names no folder, --forget no registered workspace, --show or --hide a workspace or
+document that is not there, or the name cannot be written; 2 for a name that is empty, over 80
+characters or more than one line, and for two of --scan, --name, --forget, --show and --hide at once.`,move:`Usage: gallery move <document> (--under <document> | --top | --column "<column>") [--after <document> | --first]
+Moves a document in the sidebar's tree, with the documents under it: under --under's document, to the
+top level (--top), the top level of a sidebar column (--column "<column>", a column of this workspace's),
+or where it is now (none of them); right after --after's document (one at that level, whose level it is
+when none of them says one), first (--first), else last. Written
+through the workspace's running server when there is one (an open workbench shows it at once), else
+here. Nothing in the documents' files changes: links between documents go by their folders, which
+stay where they are.
+${o}
+Prints where it went and where it was, then its place (\u4F4D\u7F6E\uFF1A\u2026, as gallery list says it).
+Exits 0 when it moved or is there already; 1 when a document named is not there or is the \u5199\u4F5C\u504F\u597D page
+(listed apart: it moves nowhere and holds none), when the place is under itself or a document under
+it, or --after names one at another level, or --column names no column of this workspace's; 2 for a
+document in the trash.`,set:`Usage: gallery set <document> [--title "<title>"] [--icon <icon>|none] [--description "<text>"]
+                         [--font sans|serif|mixed] [--size small|default|large] [--spacing compact|default|loose]
+                         [--width narrow|default|wide] [--full on|off] [--all]
+Changes a document's title, page icon, description or look as the workbench's \u91CD\u547D\u540D, the page's icon
+picker and its \u5B57\u4F53\u4E0E\u5E03\u5C40 menu do: the title in doc.html (the h1 of its header, and <title> where that holds the h1's words,
+else the whole of it) and in doc.json; the icon in the header (div.doc-icon before the h1: made,
+changed, or taken away with none) and in doc.json; the description in doc.json. An icon is an emoji,
+an icon of the \u56FE\u6807 tab (/icons/<name>_<color>.svg, Tabler's /icons/tabler/<name>_<color>.svg, the
+colors gray, lightgray, brown, yellow, orange, green, blue, purple, pink, red), a picture of the
+document's folder (assets/<file>) or the name of a custom emoji of the workspace (\u81EA\u5B9A\u4E49\u8868\u60C5, gallery emoji
+list; :name: too), whose image is copied into the document's assets/ as the icon picker copies it.
+doc.html is written as an Agent writes it, the rest of it as it
+is: the page open in the browser shows it, and the workbench's sidebar the new title and icon.
+A title that starts with "-" and a letter is written --title="-Q3 \u56DE\u987E".
+--font (\u7B49\u7EBF\u4F53 sans, \u886C\u7EBF\u4F53 serif, \u6DF7\u5408\u4F53 mixed: the title and headings serif), --size (\u5B57\u4F53\u5927\u5C0F), --spacing (\u6B63\u6587\u95F4\u8DDD),
+--width (\u6B63\u6587\u5BBD\u5EA6) and --full on|off (\u5168\u5BBD: the page at the full width of its area) set the look the document
+shows, in the look of its doc.json, as the \u5B57\u4F53\u4E0E\u5E03\u5C40 menu does, and the page open in the browser changes at
+once (the command goes through the shared Gallery server while one runs). Only the choices named are written: the
+document's other choices of its own stay, and a choice that is the default (--font sans) is a choice all the same,
+kept in doc.json against the user's default look. --all (\u5E94\u7528\u5230\u5168\u90E8\u6587\u6863) makes the look the document shows (these
+choices included; alone it applies the look it has now) the default look of every document, kept with the
+user's settings, no document's file: the documents with choices of their own keep them.
+${o}
+Prints what changed, then the files to re-read before editing them (\u91CD\u8BFB\uFF1A; doc.json when the look changed).
+Exits 1 when the document is not there or is the \u5199\u4F5C\u504F\u597D page, its page has no h1.doc-title, its
+doc.json does not read, or the picture is not in its folder; 2 for an icon that is none of these or a look value
+that is not one of the choices.`,link:`Usage: gallery link add <url> "<name>" [--column "<column>"] [--under <entry>] [--after <entry> | --first] [--icon <emoji>]
+       gallery link set <link> [--url <url>] [--title "<name>"] [--icon <icon>|none]
+       gallery link remove <link>
+A web link of the sidebar: a page of the web (http or https) the workbench shows beside the sidebar,
+in a frame (a site that refuses frames is offered \u5728\u6D4F\u89C8\u5668\u4E2D\u6253\u5F00), in the tree with the documents. It is
+a folder <workspace>/<slug>/link.json (no document: nothing checks, exports or searches it), its slug
+made of the name's Latin words, else the site's name. A link is named by its slug or its link (what the
+workbench's address holds after #).
+add puts it first in the own column (the workspace's own documents'; as the sidebar's \u6DFB\u52A0\u5728\u7EBF\u7F51\u9875\u2026
+puts one first in its column); --column first in the column of that name (as the sidebar calls it, or
+one the user named), --under last under an entry (a document or a link), --after right after one.
+Prints where it went (\u4F4D\u7F6E\uFF1A\u2026, as gallery list says it). The site's own icon (its page's <link rel=icon>,
+else /favicon.ico; 16 KB at most) is fetched once and kept in link.json, shown when no --icon is given.
+An address of this workspace's own server (its host and port) is refused: link the document instead.
+set changes its address, its name or its icon (an emoji or an icon of the \u56FE\u6807 tab; none takes it away).
+remove moves it to the trash, which the workbench's \u8BBE\u7F6E \u203A \u56DE\u6536\u533A restores it from, where it was.
+Each is written through the workspace's running server when there is one (an open workbench shows it
+at once), else here.
+Exits 1 when a link, a column or an entry named is not there or the server refuses it; 2 for an
+address that is not http or https, an empty name, or two places at once.`,extension:`Usage: gallery extension new <id> "<name>" [--ui] [--server]
+       gallery extension list [--json]
+       gallery extension check <id> [--shot <file>] [--press <button>]
+       gallery extension install <folder | .zip> [--enable]
+       gallery extension enable <id>
+       gallery extension disable <id>
+       gallery extension remove <id>
+Extensions live in <home>/extensions/<id>/ and are shared across workspaces.
+A sidebar.json supplies a column of links. An extension.json declares workbench script/style,
+backend server.command, icon and Agent instructions. Either or both may be present.
+new without flags creates sidebar.json. --ui and/or --server create a program template,
+version 0.1.0, AGENT.md, activate/dispose UI and/or a Node HTTP backend with GET /health; with both,
+the UI's button asks the backend's GET /hello through Gallery's proxy and toasts the answer.
+Edit the files, run check, then enable. check validates the manifest and every declared file,
+starts an isolated sandbox copy (even if disabled), waits for the backend to listen and checks UI
+errors and slot buttons in Chrome/Edge. --shot writes a screenshot. --press clicks the slot button with
+that label (or text) and prints each request it makes to the backend's api/ with its status and answer,
+the toasts shown and errors thrown; a failed request, an error toast or a throw fails the check.
+Failures include backend exit code and the last 20 log lines, paths and script addresses given as the
+extension's own files. A sidebar-only check prints its tree and notes as before.
+check never enables the original extension or writes its workspace. It runs the extension's code
+with the user's OS permissions, as sandbox does. Check only extensions you trust.
+Install replaces extension files, preserving the enabled setting unless --enable is passed.
+list prints capabilities and AGENT.md paths; --json includes backend and workbenchError status.
+Changed files reload activate/dispose UI and restart a running backend; legacy scripts need a page refresh.
+Exits 0 on success, 1 when validation/runtime fails, 2 for invalid arguments.
+See references/extensions.md for the public UI API, manifest and sidebar.json format.`,block:h(l),page:h(d),trash:`Usage: gallery trash <entry>...
+       gallery trash list [--json]
+       gallery trash restore <item>...
+       gallery trash empty [<item>...]
+Deletion goes through the trash: never rm a document's folder (that leaves the sidebar's tree and the
+history holding it). Moves entries of the sidebar to the trash as the workbench's \u79FB\u81F3\u56DE\u6536\u533A does (its
+trash command, written through the workspace's running server when there is one, so that an open
+workbench shows it at once, else here): a document with its files, a custom page (gallery page list) or
+a web link, each named by its slug, its link or whole address, or its whole title when only one has
+it. A document keeps its place in what the trash records; the documents under it move up to where it
+was, none goes with it (as in the sidebar). Prints each one with its trash id and where it was, and
+that gallery trash restore puts it back.
+list: what the trash holds, the one moved last first: each item's id, kind, slug, title and where it
+was. --json prints one object: { "workspace": path, "items": [{ "id", "kind" ("document", "page" or
+"link"), "slug", "title", "trashed" (ISO time), "at" (ms), "parent" (the document it was under, or
+null), "column" (its column's name, or null), "place" (words), "workspace" (whose trash holds it) }] }.
+A custom page lives in the default workspace, so its trash is that workspace's.
+restore puts items back where they were (named by id, slug or whole title): under the same document,
+else at the top level of the column, else at the top level; under the next free slug when theirs was
+taken meanwhile. Prints the place (\u4F4D\u7F6E\uFF1A\u2026, as gallery list says it).
+empty deletes items of the trash for good, all of it with none named: the one command of Gallery that
+deletes anything and cannot be undone. Use it only when the user explicitly asks for it.
+A document of another workspace (an entry ~ws-\u2026/<slug>) is trashed in its own workspace: --workspace.
+Exits 1 when an entry or item named is not there, is the \u5199\u4F5C\u504F\u597D page or is another workspace's (nothing
+is moved when one of them is wrong); 2 for a name that is no slug, link or address, and for a document
+named that is in the trash already.`,duplicate:`Usage: gallery duplicate <document> [<new slug>] [--title "<title>"] [--no-preview] [--no-browser]
+A copy of a document, as the document menu's \u521B\u5EFA\u526F\u672C makes one (its duplicate command, through the
+workspace's running server when there is one, else here): the whole folder, assets included, under a
+new slug (doc-<a new page id>, or <new slug>), with a new page id and none of the original's
+annotations, history or review of the Agent's changes, titled the original's with \uFF08\u526F\u672C\uFF09 after it (or
+--title's words as they are), right after the original in the sidebar's tree. Never copy the folder
+yourself: that copies its block ids, annotations and history too.
+${o}
+Prints where the copy is (\u4F4D\u7F6E\uFF1A\u2026) and its file, then ends as gallery new does: the next step (\u4E0B\u4E00\u6B65\uFF1A
+send the user the address now), the one Gallery server found or started (--no-preview leaves it alone),
+the default browser opened there (--no-browser opens none), and last the address to give the user
+(\u4EA4\u7ED9\u7528\u6237\u2026\uFF1A).
+Exits 1 when the document is not there, is a web link or the \u5199\u4F5C\u504F\u597D page, or the new slug is taken
+(nothing is copied); 2 for a slug that is not lowercase kebab-case or is a name the workspace keeps, an
+empty title, and a document in the trash.`,copy:`Usage: gallery copy <document> --to <workspace> [--under <document>]
+Copies a document, with the documents under it, to another workspace, as the sidebar's drag into
+another workspace's column does once it is confirmed (\u590D\u5236\u5230\u53E6\u4E00\u4E2A\u5DE5\u4F5C\u533A\uFF1F): new documents there (new
+slugs and page ids, their files, assets and metadata), the originals and their history staying where
+they are. <workspace> is a registered workspace's ws- id or its folder (gallery workspaces lists
+them; a folder that is a workspace is registered now). The copy goes last at the top level of that
+workspace, or last under --under's document there (a slug or link of that workspace). Made by the
+receiving workspace's own copy-from command, through the machine's running server when there is one,
+else here.
+${o}
+Prints what was copied and where, the copy's file and, as the next step (\u4E0B\u4E00\u6B65\uFF1A), how to work on the
+copy: every command takes --workspace <its folder>.
+Exits 1 when the document is not there, is a web link or the \u5199\u4F5C\u504F\u597D page, is in that workspace
+already, or --to names no workspace or --under no document there (nothing is copied); 2 for a document
+in the trash.`,favorite:`Usage: gallery favorite <entry> [--off]
+Puts an entry of the sidebar (a document or a web link, named by its slug, link or whole address, or
+its whole title when only one has it) in its \u6536\u85CF section, or takes it out with --off, as the entry's
+menu does. The list is kept in the outline file (.gallery/outline.json, beside the tree), by the
+workspace's own favorite command (through the running server when there is one), and the workbench's
+browsers show it besides the favorites each keeps itself; gallery list --json says "favorite" for
+each entry. Says what changed, or that nothing needed to.
+Exits 1 when the entry is not there or is a custom page (which has no \u6536\u85CF); 2 for a document in the
+trash.`,column:`Usage: gallery column new "<column>"
+       gallery column rename "<column>" "<new name>"
+       gallery column remove "<column>"
+The sidebar's columns (\u680F), made, renamed and removed as the column's menu (\u65B0\u5EFA\u680F, \u91CD\u547D\u540D, \u4ECE\u4FA7\u8FB9\u680F\u79FB\u9664) does,
+written through the workspace's running server when there is one (an open workbench shows it at once),
+else here. A column is named by its name as the sidebar shows it (case alike) or its id (gallery list
+--tree shows them). new makes one last in the sidebar (nothing when a column of that name is there
+already). rename changes a column's name. remove deletes a column the user made, the entries in it with
+those under them going last to the workspace's own column, no file deleted; a workspace's column is
+hidden instead (gallery workspaces --hide); the own column (\u9ED8\u8BA4\u6587\u6863 in the default workspace) and an
+extension's column are never removed. gallery new and gallery move take --column "<column>" to put a
+document in one. Prints what changed and the columns now.
+Exits 1 when a column is not there, is the own column or an extension's, or the outline cannot be
+written; 2 for an empty name.`,notes:`Usage: gallery notes <document> [--json]
+       gallery notes done <document> <id>... [--undo] [--json]
+       gallery notes remove <document> <id>... | --done | --all [--json]
+The reader's \u6279\u6CE8 (annotations) of a document: suggestions for you, each about words of the document or
+blocks of it, kept in <document>/annotations.json (never edit that file: these commands are the way).
+A document is named by its slug, its link or its address, as for every command of documents.
+gallery notes <document> lists them in page order: each one's id, the blocks it is about (their
+data-block-id; "whole" when it is the blocks themselves), where it is (the headings above it), the words
+it is about (quote), the suggestion (text), and whether it is done. Act on the suggestion in the file by the
+block ids, then mark it: that is how the reader sees what you have dealt with.
+gallery notes done <document> <id>... marks them as acted on: on the page their cards go grey, and the
+reader can delete all the done ones at once (the menu of the \u6279\u6CE8 button: \u5220\u9664\u5DF2\u5904\u7406). \u590D\u5236\u6279\u6CE8 leaves them
+out. --undo takes the mark off. A suggestion the reader rewrites afterwards is a new one: no longer done.
+gallery notes remove deletes: the ids named, every one marked done (--done), or all of the document's
+(--all, as \u5168\u90E8\u5220\u9664 does). Only when the reader asks you to; marking done is the default way to finish
+with one. A removal can be taken back: with the page open the reader sees \u5DF2\u5220\u9664 N \u6761\u6279\u6CE8 with \u64A4\u9500 (a few
+seconds); with no page open it cannot be undone, so say what you removed.
+Each is written through the workspace's running server when there is one (an open page shows it at once:
+the edit service's route, in the queue the page's saves go through), else here, by the same code, on the
+file as it is (nothing is checked against the document, so nothing is deleted or reordered by it).
+Every id named must exist, else nothing changes. --json prints one object, then adds fields, never
+changes them: for the list { "document": <slug>, "title", "file": <the document's path>, "notes": [ { "id",
+"text", "quote", "blocks": [data-block-id...], "whole": <the blocks themselves>, "where": [<headings>],
+"done", "created", "updated" } ] }; for done { "document", "done": [ids] } (or "undone"); for remove
+{ "document", "removed": [ { "id", "text", "quote", "done" } ] }.
+Exits 1 when the document or an id is not there or the server refuses; 2 for a command line that is
+wrong (no ids, two ways to remove at once).`,status:`Usage: gallery status [--json]
+What the reader has open in the browser, from the running server: every document and custom page open in
+a tab of the workbench, the one used last first. Use it when the reader says "this document", "this
+paragraph", "here" without naming it: the first one is that, at the selection (else at the caret). It
+only asks: it starts no server and makes no workspace. With none running it says so (exit 0).
+For each: its slug and title, its file (the one to edit), whether the tab is shown and the window has the
+focus, how long ago the reader last did something there, where saving stands (\u5DF2\u4FDD\u5B58, \u6709\u4FEE\u6539\u8FD8\u6CA1\u4FDD\u5B58, \u6709\u51B2\u7A81,
+or \u6CA1\u8FDE\u4E0A\u670D\u52A1), how many \u6279\u6CE8 it has, the caret's block (its data-block-id, null for a block the file has
+no id for yet, and its words) or the words and blocks selected (200 characters at most), as the file
+names them. \u95EE\u9898\uFF1A lines name an open document that is not saved (changes waiting, or a conflict): ask the
+reader to settle it on the page first, then change the file, or he gets a conflict card for your write.
+The tabs report to the server every 20 seconds and when something changes; a tab that closed is gone at
+once, one that stopped reporting after 90 seconds. Everything stays in the server's memory, on this
+computer (the selected words need the server's token to read).
+--json prints one object, then adds fields, never changes them: { "running": false, "open": [] } when no
+server runs, else { "running": true, "port", "open": [ { "tab", "kind": "document" | "page", "slug",
+"title", "file", "workspace", "visible", "focused", "idle": <seconds>, "save": "saved" | "pending" |
+"conflict" | "offline", "conflicts": <number>, "notes": <number of \u6279\u6CE8>, "caret": { "block", "text" } |
+null, "selection": { "kind": "text" | "blocks", "blocks": [data-block-id...], "text", "truncated",
+"length" } | null } ], "last": <the first of open, or null> }. A page of another workspace has
+"~ws-<id>/<slug>" for its slug (its "file" is where it is).
+Exits 0; 1 when the server does not answer.`,history:`Usage: gallery history <document> [--json]
+       gallery history <document> --restore <version> [--json]
+A document's recent versions, as the workbench's \u5386\u53F2\u7248\u672C lists them (the document's \xB7\xB7\xB7 menu): Gallery
+keeps the file as it was before and after each of its own writes (the user's edits on the page, a
+revert, a restore, an export's block ids, a rename) and as each write of anyone else's left it (the
+Agent's Write or Edit, a write while no server ran, which the next server keeps as it starts), the last
+30 of them and the last of each hour before those, 80 at most, in <workspace>/.gallery/state/history/.
+Lists them, the newest first: its version (the first 8 characters, what --restore takes), when it was
+kept (local time), who made it (\u7528\u6237: the user's edit on the page, \u64A4\u56DE, \u6062\u590D in the workbench; Agent: a
+write of the file, a command of an Agent's, a page opened with ?agent; \u672A\u77E5: the first one kept, and one
+kept before Gallery said who), what made it, and what it changed of the one before it: how many blocks
+it added, changed and deleted, and the first of those blocks with their kind, data-block-id and first
+words. The one the file holds now says \uFF08\u73B0\u5728\u7684\u6837\u5B50\uFF09.
+--restore writes that version as the file (a version is named by those 8 characters, 6 at least, or its
+whole id or version), through the workspace's running server when there is one (its queue: an open page
+shows it at once; a page with edits not saved yet keeps them), else here: what the file was is kept as a
+version first, so a restore is taken back by restoring that one (said on the \u63D0\u793A line); doc.json's
+title and icon follow the page's. The restore is the Agent's write: the page marks what it changed as
+the Agent's changes, for the user to keep or revert (gallery revert takes it back too). Prints the
+blocks it took back of the file (\u53BB\u6389\u4E86 what the version has not, \u6539\u56DE\u4E86, \u653E\u56DE\u4E86 what the file had not),
+then the files to re-read (\u91CD\u8BFB\uFF1A\u2026).
+${o}
+--json: one object. The list: { "document": { "slug", "title", "file" }, "current" (the file's version
+now), "versions": [ { "id", "version" (16 hex), "short", "time" (ISO), "by" ("user", "agent" or null),
+"kind" ("commit", "write", "revert", "undo", "restore", "hand-in", "rename", or null), "from" (a restore's:
+the id restored), "current" (true for the newest, when the file holds it), "counts" ({ "added",
+"changed", "removed" }, null for the first), "blocks" ([{ "change" ("added", "changed", "removed"),
+"kind", "name", "tag", "id" (data-block-id; null for none and for one deleted), "text", "title" }], 8 at
+most), "more" (how many blocks besides) } ] }, the newest first. With --restore: { "document",
+"restored" (the id restored), "same" (the file said it already: nothing written), "kept" (the id of the
+version that holds what the file was), "id" (the version it made), "counts", "blocks" } (40 blocks at most).
+Exits 1 when the document is not there, no version has that name or several do (the \u95EE\u9898 line names
+them), or the file kept changing (an Agent writing it: nothing written); 2 for a mistake in the command line.`,revert:`Usage: gallery revert <document>
+Takes back the Agent's changes since the user last kept (\u786E\u8BA4) or reverted them, as the page's
+\u300C\u64A4\u56DE\u300D does (the bar at the page's bottom): the document as the user had it before the Agent's first
+write since, with the user's own edits saved meanwhile kept in it; doc.json's title and icon follow the
+page's. Through the workspace's running server when there is one (its queue: an open page shows it at
+once; a page with edits not saved yet keeps them), else here by the same code, on the same state. What
+the file was is kept as a version first: gallery history <document> --restore <version> brings it back
+(the \u63D0\u793A line says which); the page's own \u64A4\u9500 stays the page's, for the tab that reverted there. A
+document whose first writing lasts (the Agent writing it from nothing, which the page marks nothing of:
+until gallery open of it, the user's first edit, or 30 minutes with no write) has that writing taken back
+the same way: the file restored to the newest version that is no write of the Agent's.
+${o}
+Prints what it took back (how many writes, how many blocks), a line each block (\u53BB\u6389\u4E86\u52A0\u7684 what the
+Agent added, \u6539\u56DE\u4E86 what it changed, \u653E\u56DE\u4E86\u5220\u7684 what it deleted, with its kind, data-block-id and first
+words), then the files to re-read (\u91CD\u8BFB\uFF1A\u2026).
+Exits 1 when there is nothing to take back (\u95EE\u9898 and \u4E0B\u4E00\u6B65 lines say so: the user kept or reverted the
+Agent's changes, or no Agent wrote the document since; gallery history is the way to an older version
+then), when the document is not there, or the file kept changing (an Agent writing it: nothing written);
+2 for a mistake in the command line.`,doctor:`Usage: gallery doctor [--json]
+Is this machine ready for Gallery: one line each, and the one thing to do first. Run it when a command is
+not found or prints \u9700\u8981\u5904\u7406\uFF1A\u2026, and do what its last line says.
+Looks at: Node (22.13 or newer); this Gallery, and whether npm has a newer one (read from the small cache
+gallery --version keeps, never waited for: a stale cache starts the background check, and the next run
+knows); the Gallery skills installed where gallery skill install writes them (Claude Code's and Codex's
+homes, and this folder's .claude/ and .codex/), older or newer than this gallery; whether the workspace
+can be written (when it is not made yet, the folder it would be made in; another program's gallery.json
+is a problem); a Chrome or Edge to look at pages with (GALLERY_BROWSER=<executable> picks one).
+Each line starts \u597D (nothing to do), \u95EE\u9898 (something to do) or \u63D0\u793A (worth knowing, nothing to do). The last
+line is \u4E0B\u4E00\u6B65\uFF1A, the one thing to do first, by this order: Node, the workspace, the skill, a newer Gallery
+(ask the user first: it changes their machine), the browser; when nothing is a \u95EE\u9898 it says \u4E00\u5207\u6B63\u5E38\u3002
+It makes no workspace and changes nothing (it writes a file into the workspace's folder to know that it can,
+and takes it away).
+--json: one object { "ok": whether nothing is a problem, "version", "workspace", "checks": [{ "id": "node",
+"gallery", "skill", "workspace" or "browser"; "status": "ok", "problem" or "note"; "text"; and its own
+fields: node and gallery "version" (gallery also "latest": the newest npm is known to have, or null), node
+"required"; skill "installed": [{ "folder", "project", "version", "older" }]; workspace "path", "exists",
+"writable"; browser "path" (null when none) }], "next": the one thing to do, or null }. Fields are only
+ever added.
+The other commands say \u9700\u8981\u5904\u7406\uFF1A\u2026 (\u8FD0\u884C gallery doctor) as their last line when a skill installed is older
+than this gallery or npm has a newer one (as the cache knows it; stdout, or stderr when the command failed;
+never with --json, help, --version or doctor; nothing with GALLERY_NO_UPDATE_CHECK, CI or NO_UPDATE_NOTIFIER).
+Exits 0 when nothing is a problem, 1 else.`,emoji:`Usage: gallery emoji add <name> <image>
+       gallery emoji list [--json]
+The workspace's custom emoji (\u81EA\u5B9A\u4E49\u8868\u60C5: the page icon picker's "+"; kept in <workspace>/.gallery/emoji-library/).
+add puts an image in the library under <name>, as the workbench's picker does: lower-case letters, digits, - and _
+(under 50 characters; white space becomes -, :name: is read as name), a name neither the library nor a standard
+emoji has. The image is a PNG, JPEG, GIF, WebP, AVIF, SVG or ICO file of 2 MB at most, a path on this computer
+or an http(s) address the image is downloaded from. Prints the library's file and, \u4E0B\u4E00\u6B65\uFF1A, how to use it:
+gallery set <document> --icon <name> copies the image into the document's assets/ and makes it the page's icon.
+list prints the emoji (name and file); --json prints one object, { "workspace": <absolute path>, "emojis": [ { "name",
+"id", "file" (in the library folder), "path" (absolute), "created" (ISO time) } ] }; the fields are only ever added to.
+Exits 1 when the image is not there, is not an image or is over 2 MB, the address gives none, or the name is
+taken; 2 for a name it does not take.`,skill:`Usage: gallery skill install [--agent claude|codex] [--project] [--dir <path>]
+Writes the Gallery skill that matches this gallery command (what an Agent reads to write documents
+with it: SKILL.md, references/, sdk/) where the Agent reads skills:
+  Claude Code   ~/.claude/skills/gallery (CLAUDE_CONFIG_DIR/skills/gallery when that is set)
+  Codex         ~/.codex/skills/gallery (CODEX_HOME/skills/gallery when that is set)
+for each of them whose folder is there (neither: Claude Code's), or the one --agent names. --project
+writes it into this folder's .claude/skills/gallery (.codex/skills/gallery for Codex) instead, for
+this project alone; --dir <path> writes it into <path> itself, the skill's own folder, for any other agent.
+A Gallery skill there is replaced (nothing done when it holds the same files). An older Gallery's
+skill (the whole tools: package.json and src/, or reports/, its SKILL.md named gallery or
+html-report-studio), there or anywhere in that skills folder, has its documents copied into the
+workspace first, as gallery init --from copies them, and its exports into <workspace>/exports/ where
+the name is free; then it is moved to <workspace>/.gallery/old-skill-<date>/ (never deleted), so that
+the Agent sees one Gallery skill. Says what it did and where; then open a new Agent session.
+Exits 1, changing nothing, when a target holds something else or an older skill's preview server
+still runs (stop it first); 1 too when an older skill cannot be moved (its documents are copied).`};r.component=r.block;var m={block:l,page:d};function b(e,t=void 0){let s=g[e]??e,a=m[s];if(!a)return{text:r[s]};if(t===void 0)return{text:w(a)};let n=a.subs.find(i=>i.name===t);return n?{text:p(a,n)}:{unknown:a.subs.map(i=>i.name)}}function v(e,t){let s=m[g[e]??e]?.subs.find(a=>a.name===t);return s?s.usage.map((a,n)=>n===0?`Usage: ${a}`:`       ${a}`).join(`
+`):null}var x=r.block.split(`
+`).filter(e=>/^(?:Usage:)?\s*gallery block try /.test(e)).map((e,t)=>t===0?`Usage: ${e.trimStart()}`:e).join(`
+`),E=r.block.split(`
+`).filter(e=>/^(?:Usage:)?\s*gallery block pack /.test(e)).map((e,t)=>t===0?`Usage: ${e.trimStart()}`:e).join(`
+`),j=r.page.split(`
+`).filter(e=>/^(?:Usage:)?\s*gallery page try /.test(e)).map((e,t)=>t===0?`Usage: ${e.trimStart()}`:e).join(`
+`),A=`Usage: gallery <command> [options] [--workspace <dir>]
+Gallery: documents written as HTML, edited in the browser, exported as one offline file.
+
+  gallery init [<dir>] [--from <old reports dir>]   make a workspace (copy an older Gallery's documents)
+  gallery new <slug> "<title>" [--under|--column]      a new document; starts the server, opens the browser
+  gallery import <file> [<slug> ["<title>"]]         documents made of a file (Markdown, HTML, Word, PDF\u2026)
+  gallery open [<slug>] [--no-browser] [--present]   start or reuse the server and open the browser
+  gallery serve [--port <n>]                         run the server in the foreground
+  gallery stop                                       stop the shared Gallery server
+  gallery sandbox [start|list|env|stop]               test in an isolated Gallery instance
+  gallery preview <page.html> [--open] [--shots <dir>] build an interactive UI preview
+  gallery preferences list|on|off                    discover or manage writing preferences
+  gallery check [<slug>...]                          check documents (none named: all)
+  gallery export <slug>... [--format pdf|markdown]   write <workspace>/exports/<slug>.html (.pdf, .md)
+  gallery qa <slug>... [--blocks a,b] [--tiles]      look at exports in Chrome or Edge; lists the pictures to open
+  gallery list [<words>...] | --tree [<slug>] [--json]  the documents, those the words name, or the tree
+  gallery list <words>... --all                      search the documents of every workspace of this machine
+  gallery workspaces [--json|--show|--hide|--name|--forget]  this machine's workspaces; show or hide one in the sidebar
+  gallery move <slug> --under <slug> | --top | --column "<c>"  move a document (and those under it) in the tree
+  gallery set <slug> --title|--icon|--description|--font\u2026  a document's title, icon, description or \u5B57\u4F53\u4E0E\u5E03\u5C40
+  gallery link add <url> "<name>" | set | remove     a web link in the sidebar, shown beside it
+  gallery trash <entry>... | list | restore | empty  the trash: move to it, list it, put back, delete for good
+  gallery duplicate <slug> [<new slug>] [--title]    a copy of a document, after it, titled \uFF08\u526F\u672C\uFF09
+  gallery copy <slug> --to <workspace> [--under]     copy a document (with those under it) to another workspace
+  gallery favorite <entry> [--off]                   put an entry in the sidebar's \u6536\u85CF, or take it out
+  gallery column new|rename|remove "<column>"        the sidebar's columns (\u680F)
+  gallery notes <slug> [done|remove <id>...|--done|--all]  a document's annotations (\u6279\u6CE8): list, mark done, remove
+  gallery status [--json]                            what the browser has open and selected, and what is unsaved
+  gallery history <slug> [--json] [--restore <version>]  a document's earlier versions; restore one
+  gallery revert <slug>                              take back the Agent's changes since the user last confirmed
+  gallery doctor [--json]                            check Node, Gallery, the skill, the workspace and the browser
+  gallery emoji add <name> <image> | list            the workspace's own emoji (\u81EA\u5B9A\u4E49\u8868\u60C5)
+  gallery extension list | check <id>                the sidebar columns extensions provide, as shown
+  gallery block new|add|list|show|check [<id>]       make, add, list, read and check custom blocks
+  gallery block try <slug> --press <selector>        a reader's gestures on an instance, and what they wrote
+  gallery block pack|menu|net on|off <name>          \u8BBE\u7F6E \u203A \u7EC4\u4EF6\u5217\u8868's switches: a pack, a block in the menus, a block online
+  gallery page new|list|open|set|move [<slug>]       make, list, open, rename and order custom pages (boards of cards)
+  gallery page add <slug> <block> [--x --y --w --h] [--set k=v]  put a card of a block on a page, its id given
+  gallery page try <slug> <card id> --press <sel>    a reader's gestures on a card, and what they wrote
+  gallery page check <slug>                          what is wrong with a page, what changed, its pictures
+  gallery page card|reset-cards <slug> [<card id>]   change, move, resize or remove a card; the home page's default cards
+  gallery skill install [--agent claude|codex]       write the Agent's skill for this version
+  gallery help [<command> [<subcommand>]]            this, a command's usage, or one subcommand's
+  gallery startup status|enable|disable             background service at login (Windows/macOS)
+  gallery --version                                  the version, then what is newer than it
+
+${o}
+${u}
+gallery --version prints the version first, then a line for each installed Gallery skill older than this
+gallery (\u6280\u80FD\uFF1A\u2026, with the gallery skill install that updates it) and one when npm has a newer Gallery
+(\u65B0\u7248\u672C\uFF1A\u2026), which a cache knows: checked in the background once a day, never waited for;
+GALLERY_NO_UPDATE_CHECK=1 (or CI, NO_UPDATE_NOTIFIER) turns that check off. No other command says them.
+Editing in the browser and gallery qa need Chrome or Edge. Node 22.13 or newer.`;export{y as a,g as b,r as c,b as d,v as e,x as f,E as g,j as h,A as i};