@heycys/gallery 0.2.2 → 0.2.4

package/dist/chunk-7UZUQQ7Q.mjs

@@ -1,554 +0,0 @@
-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 n=["init","new","import","open","serve","stop","check","export","qa","list","workspaces","move","set","link","extension","block","page","skill"],r={component:"block"},o=`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).`,t=`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:4317/#\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.`,a={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>] [--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); neither, at the top level, 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 (the first: send the user the address now), 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]
-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).
-${t}
-Prints the workspace, the server, 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).`,serve:`Usage: gallery serve [--port <n>]
-Runs this workspace's 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 workspace used, else the first free one from 4317).
-Exits 1 when a server of this workspace 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.
-${t}
-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").
-Exits 1 when a document fails, unless --allow-failures.`,export:`Usage: gallery export <slug>... [--allow-failures]
-       gallery export --all [--allow-failures]
-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.
-${t}
-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, which files to re-read before editing them,
-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.`,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.
-${t}
-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). Pictures go to <workspace>/.gallery/qa/<slug>/ (its absolute path printed):
-flagged/, changed/ and cards/ (the blocks changed since the last look, and the cards not pictured
-yet), blocks/ (--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), tiles/ (--tiles: the page in tiles). Each run
-empties its own folders first: flagged/ every run, changed/ and cards/ a plain run, blocks/ a --blocks
-run, tiles/ a --tiles run. A --blocks run says, before its verdict, the changed blocks and the cards
-it did not picture: a plain run pictures them. First, once, as gallery check says them, what the
-preview wrote when the reader edited the document and the \u6279\u6CE8 it deleted. Then a Not opened yet line,
-every picture of the run in one place, none opened for you; 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.
-GALLERY_BROWSER=<executable> picks the browser. A browser that does not start is tried once more
-with a fresh profile.
-Exits 1 when anything fails (or the export it ran first did), 3 when something could not be
-verified (UNVERIFIED: no browser, or one that did not start), 2 when an export is missing or stale
-with --no-export or --blocks names an id the document has not, else 0. A warning never fails.`,list:`Usage: gallery list [<words>...]
-       gallery list --tree [<document>]
-       gallery list [<words>...] --all
-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.
---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).
-${t}
-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.
-Exits 1 when --tree names a document that is not there, 2 one in the trash.`,workspaces:`Usage: gallery workspaces
-       gallery workspaces --scan [<folder>]
-       gallery workspaces --name "<name>"
-       gallery workspaces --forget <path>
-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.
-Exits 1 when --scan names no folder, --forget no registered workspace, 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
-and --forget at once.`,move:`Usage: gallery move <document> (--under <document> | --top) [--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), or where it is now (neither); right after --after's document (one at that level,
-whose level it is when neither --under nor --top 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.
-${t}
-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; 2 for a document in the trash.`,set:`Usage: gallery set <document> [--title "<title>"] [--icon <icon>|none] [--description "<text>"]
-Changes a document's title, page icon or description as the workbench's \u91CD\u547D\u540D and the page's icon
-picker 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) or a picture of the
-document's folder (assets/<file>). 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".
-${t}
-Prints what changed, then the files to re-read before editing them.
-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.`,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> "<title>"
-       gallery extension list
-       gallery extension check <id>
-       gallery extension install <folder | .zip>
-       gallery extension remove <id>
-An extension (\u6269\u5C55) gives the sidebar a column of entries of its own, beside \u6587\u6863: a folder
-<workspace>/extensions/<id>/ whose sidebar.json lists them (a title, an optional icon, and entries each with
-an id, a title, an optional address (http or https), an optional icon and optional children). The workbench
-reads the file again within a second of every change; a click on an entry with an address opens that page beside
-the sidebar (as a web link's), one without opens and closes what is under it. The user may drag the column to
-another place, rename it and reorder its root entries; title/order edits write back to sidebar.json.
-A file that does not read shows the column with one row, \u6761\u76EE\u8BFB\u4E0D\u51FA\u6765\uFF1A<why>.
-new creates an empty sidebar.json in the default workspace. Project-local extensions are not read.
-install <folder | .zip> validates and replaces an extension; remove <id> removes it.
-list prints capabilities and AGENT.md paths. Executable extensions require user confirmation in Settings > Extensions.
-Every sidebar reads only the default workspace's extensions. No files are copied or moved automatically.
-list prints the visible extensions, their source paths, titles and entry counts, or why they show none.
-check <id> resolves the same default-workspace source as the sidebar and prints what the sidebar will show:
-the column, then each entry with its id, title and address, one under another indented; notes (an icon that
-is no emoji and no icon of the \u56FE\u6807 tab, which is left out) follow. Writes nothing.
-Exits 0 when the file reads; 1 when the extension is not there, has no sidebar.json or its file does not
-read (FAIL <file>: <why>, and the row the sidebar shows); 2 for an id that is no extension's id.`,block:`Usage: gallery block new <id> ([--script] [--flow] [--data] [--page] | --recipe <name>)
-       gallery block add <name>
-       gallery block list
-       gallery block show <id>
-       gallery block check <id> [--documents]
-       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]
-       gallery block key [<host> [<key>]] [--remove]
-       gallery block pack install <folder|zip>
-       gallery block pack list
-       gallery block pack remove <pack>
-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.
-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.
-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.
-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.
-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).
-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.
-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 Not opened yet line lists every
-picture of the run, none looked at for you, as gallery qa's and gallery page check's do.
---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.
-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 Not opened yet line then lists the pictures of the
-run (after.png, and fresh.png when it was taken), none looked at for you, as gallery qa's does. 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.
-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.`,page:`Usage: gallery page new <slug> "<title>"
-       gallery page list
-       gallery page open <slug> [--no-browser]
-       gallery page add <slug> <block> [--board <id>] [--x <n> --y <n>] [--w <n>] [--h <n>] [--set <key>=<value>]\u2026
-       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]
-       gallery page check <slug>
-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.
-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.
-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".
-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.
-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.
-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.
-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 Not opened yet 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).
-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.`,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).`};a.component=a.block;var i=a.block.split(`
-`).filter(e=>/^(?:Usage:)?\s*gallery block try /.test(e)).map((e,s)=>s===0?`Usage: ${e.trimStart()}`:e).join(`
-`),h=a.block.split(`
-`).filter(e=>/^(?:Usage:)?\s*gallery block pack /.test(e)).map((e,s)=>s===0?`Usage: ${e.trimStart()}`:e).join(`
-`),l=a.page.split(`
-`).filter(e=>/^(?:Usage:)?\s*gallery page try /.test(e)).map((e,s)=>s===0?`Usage: ${e.trimStart()}`:e).join(`
-`),d=`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>" ["<description>"]    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]               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 check [<slug>...]                          check documents (none named: all)
-  gallery export <slug>... | --all                   write <workspace>/exports/<slug>.html
-  gallery qa <slug>... [--blocks a,b] [--tiles]      look at exports in Chrome or Edge
-  gallery list [<words>...] | --tree [<slug>]        the documents, those the words name, or the tree
-  gallery list <words>... --all                      search the documents of every workspace of this machine
-  gallery workspaces [--scan|--name|--forget]        this machine's workspaces; register, name, forget one
-  gallery move <slug> --under <slug> | --top         move a document (and those under it) in the tree
-  gallery set <slug> --title|--icon|--description    change a document's title, icon or description
-  gallery link add <url> "<name>" | set | remove     a web link in the sidebar, shown beside it
-  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 page new|list|open [<slug>]                make, list and open 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 skill install [--agent claude|codex]       write the Agent's skill for this version
-  gallery help [<command>]                           this, or a command's whole usage
-  gallery --version                                  the version, then what is newer than it
-
-${t}
-${o}
-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{n as a,r as b,a as c,i as d,h as e,l as f,d as g};

package/dist/chunk-ALZ6ZENZ.mjs

@@ -1,3 +0,0 @@
-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));
-import{a as q,b as B}from"./chunk-IA4PSIMD.mjs";import{b as C}from"./chunk-ZTHICSSF.mjs";import x from"node:fs/promises";import W from"node:path";import{MENTION as L}from"../browser/shared/components/mention.mjs";import{writeAtomic as R}from"../browser/shared/files.mjs";import{reportLines as U}from"../browser/shared/search.mjs";import{countWords as Q}from"../browser/shared/words.mjs";import{FACT_KINDS as V,QUERY_KINDS as Y,SNAPSHOT_LIMITS as y,queryOptions as G}from"../browser/shared/workspace-query.mjs";import{documentDirectory as M,documentFiles as T,layoutOf as X,listDocumentSlugs as _,listTrash as Z}from"../browser/shared/workspace.mjs";var ut=f=>c=>f.readTaken(c,{wait:0}),z=({todos:f})=>{let c=new Map,g=d=>JSON.stringify([d.text,d.path]);for(let d of f)c.set(g(d),(c.get(g(d))??0)+1);return f.some(d=>!d.block&&c.get(g(d))>1)},tt=(f,c)=>({hash:B(f),words:Q(c),todos:q(c)});function et(f){let c=new Date(f);return c.setHours(0,0,0,0),c.setDate(c.getDate()-(c.getDay()+6)%7),c.getTime()}function mt({root:f,read:c,draw:g=u=>u,activity:d=null,now:I=()=>new Date}){let u=new Map,m=new Map,b=t=>x.stat(t).then(({mtimeMs:e})=>e,()=>null);async function J(t,e=null){let o=T(M(t,f)),[a,n]=await Promise.all([b(o.html),b(o.json)]);if(a===null)return null;let s=e??await c(t);if(!s)return null;let r={};try{r=JSON.parse(await x.readFile(o.json,"utf8"))??{}}catch{}let{title:i,icon:h}=r,w={slug:t,title:typeof i=="string"&&i.trim()?i:t,icon:typeof h=="string"&&h?h:null,edited:Math.round(a),...tt(s.source,s.text)};return u.set(t,{html:a,json:n,facts:w,held:s.held===!0}),m.has(t)||m.set(t,w),w}async function O(t){let e=u.get(t);if(e&&!e.held){let o=T(M(t,f)),[a,n]=await Promise.all([b(o.html),b(o.json)]);if(a===e.html&&n===e.json)return e.facts}return J(t)}async function S(){let t=await _(f);for(let e of u.keys())t.includes(e)||u.delete(e);for(let e of m.keys())t.includes(e)||m.delete(e);return(await Promise.all(t.map(e=>O(e).catch(()=>null)))).filter(Boolean)}let P={async todos({done:t,slugs:e,limit:o}){let a=(await S()).filter(s=>!e||e.includes(s.slug)).sort((s,r)=>r.edited-s.edited||s.slug.localeCompare(r.slug)),n=[];for(let{slug:s,title:r,icon:i,todos:h,hash:w}of a)for(let l of h)if(!(t!==void 0&&l.done!==t)){if(n.length>=o)return n;n.push({ref:{slug:s,block:l.block,text:l.text,path:l.path,nth:l.nth,version:w},text:l.text,done:l.done,slug:s,title:r,icon:i,path:l.path})}return n},async recent({limit:t}){return(await S()).sort((e,o)=>o.edited-e.edited||e.slug.localeCompare(o.slug)).slice(0,t).map(({slug:e,title:o,icon:a,edited:n})=>({slug:e,title:o,icon:a,edited:new Date(n).toISOString()}))},async stats(){let t=await S(),e=et(I()),o=t.flatMap(a=>a.todos);return{documents:t.length,todos:{done:o.filter(a=>a.done).length,total:o.length},words:t.reduce((a,n)=>a+n.words,0),editedThisWeek:t.filter(a=>a.edited>=e).length}},async activity({days:t}){return d?(await d.load(),await $,d.days(t)):[]},async table({slug:t,key:e,where:o,limit:a},{words:n=!1}={}){let s=await O(t).catch(()=>null),r=u.get(t);if(!s||!r)return k(404,"missing",`no document "${t}"`);if(r.tables??=new Map,!r.tables.has(e)){let l=await c(t);if(!l)return k(404,"missing",`no document "${t}"`);r.tables.set(e,C(l.text,e,t))}let i=r.tables.get(e);if(i.error==="missing")return k(404,"missing",`"${t}" holds no table whose frame carries data-doc-chart-source="${e}"`);if(i.error)return k(422,"missing",`the table "${e}" of "${t}" has merged cells, which no view reads: write each value in its own cell`);let h=Object.keys(o).filter(l=>!i.columns.includes(l));if(h.length>0)return k(400,"options",`table: the table "${e}" of "${t}" has no column ${h.map(l=>JSON.stringify(l)).join(", ")} (its columns: ${i.columns.map(l=>JSON.stringify(l)).join(", ")})`);let w=i.rows.filter(l=>Object.entries(o).every(([D,v])=>l.words[D]===v.replace(/\s+/g," ").trim()));return{columns:[...i.columns],rows:w.slice(0,a).map(({values:l,links:D,words:v})=>({values:{...l},links:D.map(K=>({...K})),...n?{words:{...v}}:{}})),total:w.length}}},k=(t,e,o)=>{throw Object.assign(new Error(o),{refusal:[t,{ok:!1,reason:e,message:o}]})},p=new Map,j=t=>W.join(X(f).gallery,"cache","workspace",`${t}.json`),A=async t=>{if(!p.has(t)){let e=[];try{let o=JSON.parse(await x.readFile(j(t),"utf8"));Array.isArray(o?.tables)&&(e=o.tables.filter(a=>typeof a=="string").slice(-y.tables))}catch{}p.has(t)||p.set(t,e)}return p.get(t)},N=Promise.resolve(),H=async(t,e)=>{let o=await A(t);if(o.at(-1)===e)return;let a=[...o.filter(n=>n!==e),e].slice(-y.tables);p.set(t,a),N=N.then(async()=>{await x.mkdir(W.dirname(j(t)),{recursive:!0}),await R(j(t),`${JSON.stringify({tables:p.get(t)})}
-`)}).catch(()=>{})},F=/^[a-z0-9]+(?:-[a-z0-9]+)*$/,$=Promise.resolve(),E={facts:O,all:S,async lines(t,e){let o=u.get(t);if(!await O(t))return null;let n=u.get(t);if(n!==o||!n.lines||n.lines.titles!==null&&n.lines.titles!==e){let s=await c(t);if(!s)return null;n.lines={titles:s.text.includes(L)?e:null,value:U(g(s.text,t))}}return n.lines.value},async query(t,e,{doc:o=null}={}){if(!Y.includes(t))return[400,{ok:!1,reason:"kind",message:`no kind "${t}": todos, recent, stats, activity or table`}];let{problem:a,options:n}=G(t,e);if(a)return[400,{ok:!1,reason:"options",message:`${t}: ${a}`}];let s;try{s=await P[t](n)}catch(r){if(r.refusal)return r.refusal;throw r}return t==="table"&&typeof o=="string"&&F.test(o)&&await H(o,`${n.slug}#${n.key}`),[200,{ok:!0,kind:t,data:s,at:new Date(I()).toISOString()}]},async snapshot(t){let e=async(n,s)=>{let[r,i]=await E.query(n,s);return r===200?i.data:null},o={todos:await e("todos",{limit:y.todos}),recent:await e("recent",{limit:y.recent}),stats:await e("stats"),activity:await e("activity",{days:y.activity})},a={};for(let n of F.test(t)?await A(t):[]){let[s,r]=n.split("#"),i=await P.table({slug:s,key:r,where:{},limit:y.rows},{words:!0}).catch(()=>null);i&&(a[n]=i)}return Object.keys(a).length>0&&(o.tables=a),Object.fromEntries(Object.entries(o).filter(([,n])=>n!==null))},stored:()=>N,async changed(t,{source:e=null,text:o=null,by:a="agent"}={}){let n=m.get(t)??u.get(t)?.facts??null;u.delete(t);let s=e===null?null:await J(t,{source:e,text:o??e}).catch(()=>null);s?m.set(t,s):m.delete(t);let r=new Set;if(!!n!=!!s)for(let i of["todos","recent","stats","table"])r.add(i);return n&&s&&n.hash!==s.hash&&r.add("table"),n&&s&&n.hash!==s.hash&&(z(n)||z(s))&&r.add("todos"),n&&s&&((n.title!==s.title||JSON.stringify(n.todos)!==JSON.stringify(s.todos))&&r.add("todos"),(n.title!==s.title||n.icon!==s.icon||n.edited!==s.edited)&&r.add("recent"),(n.words!==s.words||n.todos.length!==s.todos.length||n.todos.filter(i=>i.done).length!==s.todos.filter(i=>i.done).length||n.edited!==s.edited)&&r.add("stats")),!n&&s&&r.add("recent"),d&&s&&(await d.load(),await $,d.record(t,{hash:s.hash,words:s.words,mtime:s.edited,by:a})&&r.add("activity")),V.filter(i=>r.has(i))},start(){return d?($=(async()=>{await d.load();let t=await _(f),e=(await Promise.all(t.map(async a=>({slug:a,mtime:await b(T(M(a,f)).html)})))).filter(({mtime:a})=>a!==null),o=(await Z(f).catch(()=>[])).map(a=>a.slug);return d.catchUp(e.map(({slug:a,mtime:n})=>({slug:a,mtime:Math.round(n)})),O,{kept:o})})().catch(()=>0),$):Promise.resolve(0)},forget(t){u.delete(t),m.delete(t)}};return E}export{ut as a,mt as b};