@appsoftwareltd/etherpk-mcp 0.8.2 → 0.8.3

package/dist/main.js

@@ -20,7 +20,7 @@ import * as Y from "yjs";
 import { z } from "zod";
 import { Awareness, applyAwarenessUpdate, encodeAwarenessUpdate, removeAwarenessStates } from "y-protocols/awareness";
 import * as encoding from "lib0/encoding";
-import { parse, stringify } from "yaml";
+import { Document, Scalar, YAMLMap, isMap, isScalar, isSeq, parse, parseDocument, visit } from "yaml";
 import "fake-indexeddb/auto";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { classHighlighter, highlightTree } from "@lezer/highlight";
@@ -34,7 +34,7 @@ import { request } from "node:https";
 import { BlockList, isIP } from "node:net";
 var package_default = {
 	name: "@appsoftwareltd/etherpk-mcp",
-	version: "0.8.2",
+	version: "0.8.3",
 	license: "Elastic-2.0",
 	description: "EtherPK Headless Client: an MCP server over a synced knowledge graph, run beside the agent on the user's own machine.",
 	type: "module",
@@ -2511,6 +2511,119 @@ function snippetSegments(snippet) {
 	}
 	return segments.filter((s) => s.text !== "");
 }
+/** Letters, digits, `_`, `.` and `-`: a key a person can type, dot paths included. */
+var PROPERTY_KEY_PATTERN = /^[\p{L}\p{N}_][\p{L}\p{N}_.-]*$/u;
+/**
+* Whitespace-separated tokens. A quote opens a run that spaces do not end, whether it starts the
+* token (`"a phrase"`) or follows a key (`status:"in progress"`); an unclosed one runs to the end.
+*/
+function searchTokens(input) {
+	const out = [];
+	let index = 0;
+	while (index < input.length) {
+		if (/\s/.test(input[index])) {
+			index++;
+			continue;
+		}
+		const from = index;
+		while (index < input.length && !/\s/.test(input[index])) {
+			if (input[index] === "\"") {
+				const close = input.indexOf("\"", index + 1);
+				index = close === -1 ? input.length : close + 1;
+				continue;
+			}
+			index++;
+		}
+		out.push({
+			text: input.slice(from, index),
+			from,
+			to: index
+		});
+	}
+	return out;
+}
+/**
+* The filters in `input`, and the words left for name and text matching.
+*
+* A term is a filter only when its key is one at least one searchable document carries
+* (`knownKeys`, lower-cased): anything else shaped like `x:y` stays words, which keeps a URL, a
+* time or `note:` in prose as text. A fully quoted term is always words. A known key with no
+* value yet (`status:` mid-typing) is dropped from both, so the key is never searched as a word
+* a moment before the value arrives.
+*/
+function parseSearchQuery(input, knownKeys) {
+	const filters = [];
+	const terms = [];
+	const cut = [];
+	if (knownKeys.size > 0) for (const token of searchTokens(input)) {
+		if (token.text.startsWith("\"")) continue;
+		const colon = token.text.indexOf(":");
+		if (colon <= 0) continue;
+		const negated = token.text.startsWith("-");
+		const key = token.text.slice(negated ? 1 : 0, colon);
+		if (!PROPERTY_KEY_PATTERN.test(key) || !knownKeys.has(key.toLowerCase())) continue;
+		const filter = filterValue(key, token.text.slice(colon + 1), negated);
+		cut.push({
+			from: token.from,
+			to: token.to
+		});
+		if (filter === null) continue;
+		filters.push(filter);
+		terms.push({
+			filter,
+			from: token.from,
+			to: token.to
+		});
+	}
+	return {
+		words: withoutRanges(input, cut),
+		filters,
+		terms
+	};
+}
+/** The filter for a value as typed, or null when there is no value yet. */
+function filterValue(key, raw, negated) {
+	if (raw === "*") return {
+		key,
+		value: null,
+		prefix: false,
+		negated
+	};
+	if (raw.startsWith("\"")) {
+		const close = raw.indexOf("\"", 1);
+		const value = (close === -1 ? raw.slice(1) : raw.slice(1, close)).trim();
+		return value === "" ? null : {
+			key,
+			value,
+			prefix: false,
+			negated
+		};
+	}
+	if (raw.length > 1 && raw.endsWith("*")) return {
+		key,
+		value: raw.slice(0, -1),
+		prefix: true,
+		negated
+	};
+	return raw === "" ? null : {
+		key,
+		value: raw,
+		prefix: false,
+		negated
+	};
+}
+/** `input` with the ranges removed and the gaps they leave closed to single spaces. */
+function withoutRanges(input, ranges) {
+	if (ranges.length === 0) return input;
+	const parts = [];
+	let at = 0;
+	for (const range of ranges) {
+		parts.push(input.slice(at, range.from));
+		at = range.to;
+	}
+	parts.push(input.slice(at));
+	return parts.map((part) => part.trim()).filter((part) => part !== "").join(" ");
+}
 //#endregion
 //#region ../client/src/lib/document/index-db.ts
 /**
@@ -2572,6 +2685,15 @@ CREATE TABLE IF NOT EXISTS passages (
   page_id INTEGER NOT NULL, ord INTEGER NOT NULL, start_line INTEGER NOT NULL,
   end_line INTEGER NOT NULL, first_block_local_id INTEGER NOT NULL,
   content_hash TEXT NOT NULL, text TEXT NOT NULL);
+-- [[Property]] rows for [[Property Filter]]s (ADR 0107): one per value, keys as dot paths. key and
+-- value keep their spelling for display; key_lc and value_lc are lower-cased in JS, because
+-- SQLite's lower() folds ASCII only and a filter matches ignoring case in any script. value is
+-- NULL on a mapping's presence row. title and aliases rows come from the graph's names. A
+-- protected document has none.
+CREATE TABLE IF NOT EXISTS properties (
+  page_id INTEGER NOT NULL, key TEXT NOT NULL, key_lc TEXT NOT NULL,
+  value TEXT, value_lc TEXT);
+CREATE INDEX IF NOT EXISTS properties_key ON properties(key_lc, value_lc);
 CREATE INDEX IF NOT EXISTS passages_hash ON passages(content_hash);
 CREATE INDEX IF NOT EXISTS links_concept_key ON links(concept_key);
 CREATE INDEX IF NOT EXISTS blocks_page ON blocks(page_id);
@@ -2620,7 +2742,7 @@ function createSchema(db) {
 	db.exec(SCHEMA$1);
 	db.run("INSERT OR IGNORE INTO index_metadata (key, value) VALUES ('active_generation', 1)");
 	db.run("INSERT OR IGNORE INTO index_metadata (key, value) VALUES ('revision', 0)");
-	db.exec(`PRAGMA user_version = 13`);
+	db.exec(`PRAGMA user_version = 14`);
 }
 function activeIndexGeneration(db) {
 	return db.all("SELECT value FROM index_metadata WHERE key = 'active_generation'")[0]?.value ?? 1;
@@ -2641,7 +2763,7 @@ function advanceIndexRevision(db) {
 */
 function isUsableIndex(db) {
 	try {
-		return db.all("PRAGMA user_version")[0]?.user_version === 13;
+		return db.all("PRAGMA user_version")[0]?.user_version === 14;
 	} catch {
 		return false;
 	}
@@ -2661,8 +2783,11 @@ function documentHash(db, key) {
 */
 function indexDocHash(doc) {
 	const includes = doc.includes ?? [];
-	if (includes.length === 0) return hashText(doc.text);
-	return hashText(`${doc.text}\u0000${includes.map((i) => `${i.publication}\u0001${i.slot}\u0001${i.concept}`).join("\0")}`);
+	const properties = doc.properties ?? [];
+	if (includes.length === 0 && properties.length === 0) return hashText(doc.text);
+	const includeText = includes.map((i) => `${i.publication}\u0001${i.slot}\u0001${i.concept}`).join("\0");
+	const propertyText = properties.map((p) => `${p.key}\u0001${p.value ?? ""}`).join("\0");
+	return hashText(`${doc.text}\u0000${includeText}\u0003${propertyText}`);
 }
 function hashText(text) {
 	let h1 = 3735928559;
@@ -2703,6 +2828,7 @@ function insertDerived(db, pageId, doc) {
 		conceptKey$1(alias),
 		alias
 	]);
+	insertProperties(db, pageId, doc);
 	for (const include of doc.includes ?? []) db.run("INSERT INTO publication_includes (page_id, publication_id, slot, concept_key, concept) VALUES (?,?,?,?,?)", [
 		pageId,
 		include.publication,
@@ -2779,12 +2905,40 @@ function insertDerived(db, pageId, doc) {
 	return searchable;
 }
 /**
+* Write one document's [[Property]] rows (ADR 0107): its name as `title`, each alias as
+* `aliases`, then what its Frontmatter carries. A [[Protected Document]] writes none. Its
+* Frontmatter is stored in plaintext, but no kind of matching in Search reaches protected
+* content, and a document with no rows cannot match a filter, not even a negated one, because
+* every filtered query also requires `protected = 0`.
+*/
+function insertProperties(db, pageId, doc) {
+	if (protectedFlag(doc) === 1) return;
+	const rows = [
+		{
+			key: "title",
+			value: doc.concept
+		},
+		...doc.aliases.map((alias) => ({
+			key: "aliases",
+			value: alias
+		})),
+		...doc.properties ?? []
+	];
+	for (const row of rows) db.run("INSERT INTO properties (page_id, key, key_lc, value, value_lc) VALUES (?,?,?,?,?)", [
+		pageId,
+		row.key,
+		row.key.toLowerCase(),
+		row.value,
+		row.value === null ? null : row.value.toLowerCase()
+	]);
+}
+/**
 * Write one document's [[Task Concept]] rows (ADR 0051).
 *
 * Derivation supplies the wikilinked half; the document's own concept is added HERE, as the
 * virtual root of every task's ancestry chain, because derivation reads text and never learns
 * the document's identity. Without that row, filtering to a project page returns nothing for
-* the tasks written directly on it — the case the "Use <active tab>" shortcut exists for.
+* the tasks written directly on it — the case the "Filter to <active tab>" shortcut exists for.
 *
 * Only the document's own concept goes in, never its aliases: the query resolves a filtered
 * name to its page and matches on every name that page answers to, so an alias row here would
@@ -2879,7 +3033,8 @@ function deleteGeneration(db, generation) {
 		"links",
 		"tasks",
 		"task_concepts",
-		"passages"
+		"passages",
+		"properties"
 	]) db.run(`DELETE FROM ${table} WHERE page_id IN (SELECT id FROM pages WHERE generation = ?)`, [generation]);
 	db.run("DELETE FROM pages WHERE generation = ?", [generation]);
 }
@@ -2954,6 +3109,7 @@ function ingestOne(db, doc) {
 			db.run("DELETE FROM tasks WHERE page_id = ?", [pageId]);
 			db.run("DELETE FROM task_concepts WHERE page_id = ?", [pageId]);
 			db.run("DELETE FROM passages WHERE page_id = ?", [pageId]);
+			db.run("DELETE FROM properties WHERE page_id = ?", [pageId]);
 			db.run("UPDATE pages SET concept = ?, kind = ?, text_hash = ?, protected = ? WHERE id = ?", [
 				doc.concept,
 				doc.kind,
@@ -3366,25 +3522,27 @@ var SNIPPET_TOKENS = 24;
 * scores merely reintroduces the long-document bias bm25 exists to remove. Counting is cruder,
 * robust, and explainable in one sentence - and it orders by a number the row displays.
 */
-function searchText$1(db, query, offset, limit) {
+function searchText$1(db, query, offset, limit, filters = []) {
 	const match = buildFtsMatch(query);
 	if (match === null) return {
 		groups: [],
 		hasMore: false
 	};
 	const generation = activeIndexGeneration(db);
+	const narrow = propertyFilterSql(filters);
 	const ranked = db.all(`WITH hits AS MATERIALIZED (
            SELECT rowid / ${BLOCK_FTS_STRIDE} AS page_id, bm25(block_fts) AS score
            FROM block_fts WHERE block_fts MATCH ?
          )
          SELECT h.page_id AS page_id, COUNT(*) AS matches, MIN(h.score) AS best
          FROM hits h
-         JOIN pages p ON p.id = h.page_id AND p.generation = ?
+         JOIN pages p ON p.id = h.page_id AND p.generation = ?${narrow.sql}
          GROUP BY h.page_id
          ORDER BY matches DESC, best ASC, h.page_id ASC
          LIMIT ? OFFSET ?`, [
 		match,
 		generation,
+		...narrow.params,
 		limit + 1,
 		offset
 	]);
@@ -3462,21 +3620,23 @@ function searchBreadcrumb(blocks, localId) {
 * Capped rather than exact because a prefix query - which is every query, mid-typing - can
 * match most of the graph, and this runs beside the rows it must never delay.
 */
-function searchTextCount(db, query) {
+function searchTextCount(db, query, filters = []) {
 	const match = buildFtsMatch(query);
 	if (match === null) return {
 		total: 0,
 		capped: false
 	};
+	const narrow = propertyFilterSql(filters);
 	const n = db.all(`SELECT COUNT(*) AS n FROM (
            SELECT m.page_id FROM (
              SELECT DISTINCT rowid / 1048576 AS page_id FROM block_fts
              WHERE block_fts MATCH ?
            ) m
-           JOIN pages p ON p.id = m.page_id AND p.generation = ?
+           JOIN pages p ON p.id = m.page_id AND p.generation = ?${narrow.sql}
            LIMIT ?)`, [
 		match,
 		activeIndexGeneration(db),
+		...narrow.params,
 		1001
 	])[0]?.n ?? 0;
 	return n > 1e3 ? {
@@ -3487,6 +3647,106 @@ function searchTextCount(db, query) {
 		capped: false
 	};
 }
+/** Documents a filtered name listing returns at most: well past any graph Search serves. */
+var PROPERTY_MATCH_CAP = 5e3;
+/**
+* The SQL that narrows a query over `pages AS p` to the documents passing every filter, as an
+* `AND …` suffix, with its parameters in order. Empty when there are no filters. A filtered
+* query never returns a [[Protected Document]], which has no property rows; the explicit
+* `protected = 0` is what keeps a NEGATED filter from matching one.
+*/
+function propertyFilterSql(filters) {
+	if (filters.length === 0) return {
+		sql: "",
+		params: []
+	};
+	const clauses = ["p.protected = 0"];
+	const params = [];
+	for (const filter of filters) {
+		let test = "x.key_lc = ?";
+		params.push(filter.key.toLowerCase());
+		if (filter.value !== null) {
+			const value = filter.value.toLowerCase();
+			if (filter.prefix) {
+				test += " AND substr(x.value_lc, 1, ?) = ?";
+				params.push(Array.from(value).length, value);
+			} else {
+				test += " AND x.value_lc = ?";
+				params.push(value);
+			}
+		}
+		clauses.push(`${filter.negated ? "NOT " : ""}EXISTS (SELECT 1 FROM properties x WHERE x.page_id = p.id AND ${test})`);
+	}
+	return {
+		sql: ` AND ${clauses.join(" AND ")}`,
+		params
+	};
+}
+/**
+* Every key a searchable document carries, once per spelling, most used first: what decides
+* whether a typed `x:y` is a filter, and what the key suggestions offer.
+*/
+function propertyKeys(db) {
+	return db.all(`SELECT pr.key AS key, COUNT(DISTINCT pr.page_id) AS documents
+         FROM properties pr JOIN pages p ON p.id = pr.page_id
+         WHERE p.generation = ?
+         GROUP BY pr.key
+         ORDER BY documents DESC, pr.key_lc, pr.key`, [activeIndexGeneration(db)]);
+}
+/** The values `key` has across the graph, grouped ignoring case, most used first. */
+function propertyValues(db, key, limit = 50) {
+	return db.all(`SELECT MIN(pr.value) AS value, COUNT(DISTINCT pr.page_id) AS documents
+         FROM properties pr JOIN pages p ON p.id = pr.page_id
+         WHERE p.generation = ? AND pr.key_lc = ? AND pr.value IS NOT NULL
+         GROUP BY pr.value_lc
+         ORDER BY documents DESC, pr.value_lc
+         LIMIT ?`, [
+		activeIndexGeneration(db),
+		key.toLowerCase(),
+		limit
+	]);
+}
+/**
+* Every document that passes all `filters`, in name order, with the values of the keys the
+* positive filters name (not `title`, which the row already shows). Empty without a filter:
+* listing the whole graph is [[All Documents]]' job.
+*/
+function documentsMatchingProperties(db, filters, limit = PROPERTY_MATCH_CAP) {
+	if (filters.length === 0) return [];
+	const narrow = propertyFilterSql(filters);
+	const pages = db.all(`SELECT p.id AS id, p.concept AS concept, p.kind AS kind FROM pages p
+         WHERE p.generation = ?${narrow.sql}
+         ORDER BY p.concept_key
+         LIMIT ?`, [
+		activeIndexGeneration(db),
+		...narrow.params,
+		limit
+	]);
+	if (pages.length === 0) return [];
+	const shown = [...new Set(filters.filter((f) => !f.negated).map((f) => f.key.toLowerCase()))].filter((key) => key !== "title");
+	const values = /* @__PURE__ */ new Map();
+	if (shown.length > 0) {
+		const rows = db.all(`SELECT page_id, key, value FROM properties
+             WHERE page_id IN (SELECT value FROM json_each(?))
+               AND key_lc IN (SELECT value FROM json_each(?))
+               AND value IS NOT NULL
+             ORDER BY rowid`, [JSON.stringify(pages.map((page) => page.id)), JSON.stringify(shown)]);
+		for (const row of rows) {
+			const list = values.get(row.page_id);
+			const entry = {
+				key: row.key,
+				value: row.value
+			};
+			if (list) list.push(entry);
+			else values.set(row.page_id, [entry]);
+		}
+	}
+	return pages.map((page) => ({
+		concept: page.concept,
+		kind: page.kind,
+		properties: values.get(page.id) ?? []
+	}));
+}
 /** Escape a literal for a LIKE pattern, so an asset name can never behave as a wildcard. */
 function likeLiteral(needle) {
 	return needle.replace(/[\\%_]/g, (c) => `\\${c}`);
@@ -4010,7 +4270,7 @@ function cacheRoot(env) {
 * recovered from a joined path (see there).
 */
 var CACHE_FILE_NAME = `local-cache.v${CACHE_DB_VERSION}.bin`;
-var INDEX_FILE_NAME = `index.v13.sqlite`;
+var INDEX_FILE_NAME = `index.v14.sqlite`;
 var VECTORS_FILE_NAME = `vectors.v1.sqlite`;
 function cacheFile(dir) {
 	return join(dir, CACHE_FILE_NAME);
@@ -6396,6 +6656,172 @@ function parseFrontmatter(text) {
 	}
 }
 //#endregion
+//#region ../client/src/lib/document/frontmatter/frontmatter-yaml.ts
+/**
+* Reading, editing and writing a [[Frontmatter]] block's YAML in the one style EtherPK writes
+* (ADR 0108).
+*
+* Every writer goes through here: the identity write-back, publishing, the arbitrary-key patch,
+* the importers, Add frontmatter and the editor's tidy when an editing episode ends. Edits go
+* through the `yaml` library's document model rather than a plain object, so a comment, and any
+* key the edit does not touch, survives. The block is then written in the EtherPK style:
+*
+* - two-space indentation, a list under its key as `  - item`, one item per line;
+* - an inline list (`[a, b]`) written as a block list; an empty `[]` written bare on a key EtherPK
+*   reads (`publications:`), where empty means not set, and kept on any other key;
+* - quotes only where a value needs them (`"true"` stays quoted, `"hello"` does not);
+* - no line wrapping, no blank lines, key order as found, comments kept;
+* - an empty value written bare (`slug:`), which reads as "fill this in".
+*
+* Restyling never changes what the block says: the value is compared before and after, and a
+* rewrite that would change it is dropped. A block that does not parse is never rewritten.
+*
+* Pure: no store, no editor. What counts as a block comes from `frontmatter-span.ts`.
+*/
+/** The `yaml` serialiser options that make up the EtherPK style. */
+var STYLE = {
+	indent: 2,
+	indentSeq: true,
+	lineWidth: 0,
+	minContentWidth: 0,
+	nullStr: ""
+};
+/**
+* The block's YAML parsed as a document, or null when it does not parse or is not a mapping.
+* An empty block (or one holding only comments) is an empty mapping.
+*/
+function parseBlock(body) {
+	const doc = parseDocument(body);
+	if (doc.errors.length > 0) return null;
+	if (doc.contents === null) {
+		doc.contents = new YAMLMap();
+		return doc;
+	}
+	return isMap(doc.contents) ? doc : null;
+}
+/** The block's YAML as a plain object, or null when it does not parse to a mapping. */
+function frontmatterData(body) {
+	const doc = parseBlock(body);
+	return doc === null ? null : doc.toJS();
+}
+/**
+* The keys EtherPK reads, on which an empty value means the key is not set (ADR 0108, point 5).
+* On these an empty `[]` and a bare key say the same thing, so the style writes it bare. Another
+* key's `[]` is kept: to a tool that reads it, an empty list and no value may differ.
+*/
+var NOT_SET_WHEN_EMPTY = new Set([
+	"title",
+	"aliases",
+	"public",
+	"publications",
+	"slug",
+	"date",
+	"publication"
+]);
+/** Apply the EtherPK style to a document in place. */
+function applyStyle(doc) {
+	visit(doc, {
+		Pair(_, pair, path) {
+			if (path.length !== 2) return;
+			const key = isScalar(pair.key) ? pair.key.value : pair.key;
+			if (typeof key === "string" && NOT_SET_WHEN_EMPTY.has(key) && isSeq(pair.value) && pair.value.items.length === 0) pair.value = new Scalar(null);
+		},
+		Scalar(_, node) {
+			node.spaceBefore = false;
+			if (typeof node.value === "string" && !node.value.includes("\n") && (node.type === "QUOTE_DOUBLE" || node.type === "QUOTE_SINGLE")) node.type = "PLAIN";
+		},
+		Map(_, node) {
+			node.spaceBefore = false;
+			if (node.items.length > 0) node.flow = false;
+		},
+		Seq(_, node) {
+			node.spaceBefore = false;
+			if (node.items.length > 0) node.flow = false;
+		}
+	});
+}
+/** The styled YAML of a document, ending in a newline, or '' when it has no keys and no comment. */
+function styledYaml(doc) {
+	applyStyle(doc);
+	const map = doc.contents;
+	if (isMap(map) && map.items.length === 0) return doc.commentBefore ? `${doc.commentBefore.replace(/^/gm, "#")}\n` : "";
+	return doc.toString(STYLE);
+}
+/** Deep equality over the plain values a block parses to. */
+function sameValue(a, b) {
+	return JSON.stringify(a) === JSON.stringify(b);
+}
+/**
+* A new block holding `data`, in the EtherPK style: `---\n…---\n`, or '' when `data` has no keys.
+* For a document that has no block yet; to change a block that exists use {@link editFrontmatter},
+* which keeps what the block already says.
+*/
+function renderFrontmatter(data) {
+	if (Object.keys(data).length === 0) return "";
+	return `---\n${styledYaml(new Document(data))}---\n`;
+}
+/** The line terminator a block uses, so a rewrite does not mix endings in a CRLF file. */
+function eolOf(text, end) {
+	return text.slice(0, end).includes("\r\n") ? "\r\n" : "\n";
+}
+function withEol(yaml, eol) {
+	return eol === "\n" ? yaml : yaml.replace(/\n/g, eol);
+}
+function editorFor(doc) {
+	const map = doc.contents;
+	const keyOf = (item) => String(isScalar(item.key) ? item.key.value : item.key);
+	return {
+		has: (key) => map.has(key),
+		get: (key) => map.has(key) ? doc.toJS()[key] : void 0,
+		set(key, value, where = "last") {
+			if (map.has(key)) {
+				const current = doc.toJS()[key];
+				if (sameValue(current, value)) return;
+				map.set(key, doc.createNode(value));
+				return;
+			}
+			const pair = doc.createPair(key, value);
+			if (where === "first") map.items.unshift(pair);
+			else map.items.push(pair);
+		},
+		delete: (key) => {
+			map.delete(key);
+		},
+		keys: () => map.items.map(keyOf)
+	};
+}
+/**
+* The text with its block changed by `edit`, then written in the EtherPK style. The same string
+* comes back when the edit changes nothing the block says, so a writer that runs on every save
+* never restyles a block it agrees with. A block whose YAML does not parse is left alone: rewriting
+* it would destroy whatever the person was typing. A block the edit empties of every key is
+* removed.
+*/
+function editFrontmatter(text, edit, options = {}) {
+	const span = frontmatterSpan(text);
+	if (!span && !options.addBlock) return text;
+	const doc = span ? parseBlock(span.body) : parseBlock("");
+	if (doc === null) return text;
+	const before = doc.toJS();
+	edit(editorFor(doc));
+	if (sameValue(doc.toJS(), before)) return text;
+	const body = span ? text.slice(span.end) : text;
+	if (doc.contents.items.length === 0) return body;
+	const eol = span ? eolOf(text, span.end) : "\n";
+	return `---${eol}${withEol(styledYaml(doc), eol)}---${eol}${body}`;
+}
+/**
+* Whether a value counts as not set (ADR 0108): nothing, a blank string, an empty list, or a
+* mapping whose every value is itself empty. `false` and `0` are values.
+*/
+function isEmptyValue(value) {
+	if (value === null || value === void 0) return true;
+	if (typeof value === "string") return value.trim() === "";
+	if (Array.isArray(value)) return value.length === 0;
+	if (typeof value === "object" && !(value instanceof Date)) return Object.values(value).every(isEmptyValue);
+	return false;
+}
+//#endregion
 //#region ../client/src/lib/document/publish/publication.ts
 /** A publication id: kebab-case, what `publications:` entries and `theme:` graph ids look like. */
 var PUBLICATION_ID = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
@@ -6411,13 +6837,19 @@ function readMembership(text, concept) {
 	const { data } = parseFrontmatter(text);
 	const issues = [];
 	const isPublic = data.public === true;
+	if (!isEmptyValue(data.public) && typeof data.public !== "boolean") issues.push({
+		level: "warning",
+		code: "public-not-a-boolean",
+		message: `\`public\` is the text "${String(data.public)}", not \`true\` or \`false\`, so the document is not public. Write \`public: true\` without quotes to publish it.`,
+		concept
+	});
 	const publications = [];
-	const raw = data.publications;
-	const entries = raw === void 0 ? [] : Array.isArray(raw) ? raw : typeof raw === "string" ? [raw] : null;
+	const raw = isEmptyValue(data.publications) ? void 0 : data.publications;
+	const entries = raw === void 0 ? [] : Array.isArray(raw) ? raw : null;
 	if (entries === null) issues.push({
 		level: "warning",
 		code: "publications-not-a-list",
-		message: "`publications` must be a list of publication ids, like `publications: [docs, blog]`.",
+		message: "`publications` must be a list of publication ids, each on its own line under the key as `- docs`, even when there is one.",
 		concept
 	});
 	else for (const entry of entries) if (isPublicationId(entry)) {
@@ -6434,13 +6866,33 @@ function readMembership(text, concept) {
 		issues
 	};
 }
+var DATE = /^\d{4}-\d{2}-\d{2}$/;
+/**
+* The day a page is dated on a blog, from its `date:` key, and a warning when the key holds
+* something that is not a calendar day. A journal entry is dated by its name, never by this key.
+*/
+function readPageDate(doc) {
+	const date = parseFrontmatter(doc.text).data.date;
+	if (isEmptyValue(date)) return { issues: [] };
+	const text = date instanceof Date ? date.toISOString().slice(0, 10) : String(date);
+	if (DATE.test(text)) return {
+		date: text,
+		issues: []
+	};
+	return { issues: [{
+		level: "warning",
+		code: "invalid-date",
+		message: `"${doc.concept}" has \`date: ${String(date)}\`, which is not a calendar day (YYYY-MM-DD); the document is undated.`,
+		concept: doc.concept
+	}] };
+}
 var KINDS$1 = ["docs", "blog"];
 var SELECTIONS = ["named", "all-public"];
 /** The publication a page defines through its `publication:` mapping, validated. */
 function readPublicationDefinition(doc) {
 	const { data, body } = parseFrontmatter(doc.text);
 	const raw = data.publication;
-	if (raw === void 0) return {
+	if (isEmptyValue(raw)) return {
 		publication: null,
 		issues: []
 	};
@@ -6465,7 +6917,7 @@ function readPublicationDefinition(doc) {
 			issues
 		};
 	}
-	const def = raw;
+	const def = Object.fromEntries(Object.entries(raw).filter(([, value]) => !isEmptyValue(value)));
 	const id = def.id;
 	if (id === void 0 || id === null || id === "") issue("publication-missing-id", "`publication` needs an `id`: lower-case letters, digits and hyphens, like `docs`.");
 	else if (!isPublicationId(id)) issue("publication-invalid-id", `"${String(id)}" is not a publication id: use lower-case letters, digits and hyphens, like \`docs\`.`);
@@ -6486,13 +6938,16 @@ function readPublicationDefinition(doc) {
 	if (def.recent !== void 0) if (typeof def.recent === "number" && Number.isInteger(def.recent) && def.recent > 0) recent = def.recent;
 	else issue("publication-invalid-recent", "`recent` must be a whole number above zero: how many posts the front page lists (10 unless set).");
 	const includes = {};
-	if (def.includes !== void 0) if (typeof def.includes === "object" && def.includes !== null && !Array.isArray(def.includes)) for (const [slot, value] of Object.entries(def.includes)) if (typeof value === "string" && value.trim() !== "") includes[slot] = value.trim();
-	else issues.push({
-		level: "warning",
-		code: "publication-invalid-include",
-		message: `Include \`${slot}\` must name the page that fills it; it is ignored.`,
-		concept: doc.concept
-	});
+	if (def.includes !== void 0) if (typeof def.includes === "object" && def.includes !== null && !Array.isArray(def.includes)) for (const [slot, value] of Object.entries(def.includes)) {
+		if (isEmptyValue(value)) continue;
+		if (typeof value === "string" && value.trim() !== "") includes[slot] = value.trim();
+		else issues.push({
+			level: "warning",
+			code: "publication-invalid-include",
+			message: `Include \`${slot}\` must name the page that fills it; it is ignored.`,
+			concept: doc.concept
+		});
+	}
 	else issue("publication-invalid-includes", "`includes` must be a mapping of include slot to the page that fills it.");
 	if (issues.some((i) => i.level === "error")) return {
 		publication: null,
@@ -8557,7 +9012,7 @@ function createIndexCore(host) {
 				}];
 			}
 			case "search-text": {
-				const page = db ? searchText$1(db, request.query, request.offset, request.limit) : {
+				const page = db ? searchText$1(db, request.query, request.offset, request.limit, request.filters ?? []) : {
 					groups: [],
 					hasMore: false
 				};
@@ -8569,7 +9024,7 @@ function createIndexCore(host) {
 				}];
 			}
 			case "search-count": {
-				const count = db ? searchTextCount(db, request.query) : {
+				const count = db ? searchTextCount(db, request.query, request.filters ?? []) : {
 					total: 0,
 					capped: false
 				};
@@ -8580,6 +9035,21 @@ function createIndexCore(host) {
 					capped: count.capped
 				}];
 			}
+			case "property-keys": return [{
+				type: "property-keys",
+				id: request.id,
+				keys: db ? propertyKeys(db) : []
+			}];
+			case "property-values": return [{
+				type: "property-values",
+				id: request.id,
+				values: db ? propertyValues(db, request.key) : []
+			}];
+			case "property-match": return [{
+				type: "property-match",
+				id: request.id,
+				documents: db ? documentsMatchingProperties(db, request.filters) : []
+			}];
 			case "tasks": {
 				const page = db ? tasksMatching(db, request.query, request.offset, request.limit) : {
 					hits: [],
@@ -9297,30 +9767,52 @@ function createRemoteGraphIndex(source, transport, options) {
 				needles: [...needles]
 			}))).usage;
 		},
-		async searchText(query, offset, limit) {
+		async searchText(query, offset, limit, filters) {
 			const response = await request((id) => ({
 				type: "search-text",
 				id,
 				query,
 				offset,
-				limit
+				limit,
+				...filters?.length ? { filters: [...filters] } : {}
 			}));
 			return {
 				groups: response.groups,
 				hasMore: response.hasMore
 			};
 		},
-		async searchTextCount(query) {
+		async searchTextCount(query, filters) {
 			const response = await request((id) => ({
 				type: "search-count",
 				id,
-				query
+				query,
+				...filters?.length ? { filters: [...filters] } : {}
 			}));
 			return {
 				total: response.total,
 				capped: response.capped
 			};
 		},
+		async propertyKeys() {
+			return (await request((id) => ({
+				type: "property-keys",
+				id
+			}))).keys;
+		},
+		async propertyValues(key) {
+			return (await request((id) => ({
+				type: "property-values",
+				id,
+				key
+			}))).values;
+		},
+		async propertyMatch(filters) {
+			return (await request((id) => ({
+				type: "property-match",
+				id,
+				filters: [...filters]
+			}))).documents;
+		},
 		async tasks(query, offset, limit) {
 			const response = await request((id) => ({
 				type: "tasks",
@@ -10067,7 +10559,7 @@ async function deleteGraphTheme(adapter, id) {
 /** What the block claims. An unterminated block is not a block, as everywhere else. */
 function frontmatterIdentity(text) {
 	const span = frontmatterSpan(text);
-	const data = span ? parseBlock$2(span.body) : {};
+	const data = span ? frontmatterData(span.body) : {};
 	if (data === null) return {
 		title: null,
 		aliases: [],
@@ -10119,37 +10611,19 @@ function sameAliases(a, b) {
 */
 function withFrontmatterIdentity(text, patch, options = {}) {
 	const span = frontmatterSpan(text);
-	if (!span) {
-		if (!options.addBlock) return text;
-		const data = {};
-		if (typeof patch.title === "string" && patch.title.trim() !== "") data.title = patch.title;
-		const aliases = patch.aliases ? [...patch.aliases] : [];
-		if (aliases.length > 0) data.aliases = aliases;
-		if (Object.keys(data).length === 0) return text;
-		return `---\n${stringify(data)}---\n${text}`;
-	}
-	const data = parseBlock$2(span.body);
-	if (data === null) return text;
-	const currentTitle = titleOf(data);
-	const currentAliases = aliasesOf({ data });
-	const wantTitle = patch.title === void 0 ? currentTitle : patch.title;
-	const wantAliases = patch.aliases === void 0 ? currentAliases : [...patch.aliases];
-	if (wantTitle === currentTitle && sameAliases(wantAliases, currentAliases)) return text;
-	const next = {};
-	if (wantTitle !== null && !("title" in data)) next.title = wantTitle;
-	for (const [key, value] of Object.entries(data)) {
-		if (key === "title") {
-			if (wantTitle !== null) next.title = wantTitle;
-			continue;
-		}
-		if (key === "aliases") {
-			if (wantAliases.length > 0) next.aliases = wantAliases;
-			continue;
-		}
-		next[key] = value;
+	if (span) {
+		const data = frontmatterData(span.body);
+		if (data === null) return text;
+		const wantTitle = patch.title === void 0 ? titleOf(data) : patch.title;
+		const wantAliases = patch.aliases === void 0 ? aliasesOf({ data }) : patch.aliases;
+		if (wantTitle === titleOf(data) && sameAliases(wantAliases, aliasesOf({ data }))) return text;
 	}
-	if (wantAliases.length > 0 && !("aliases" in data)) next.aliases = wantAliases;
-	return `---\n${serialise(next)}---\n${text.slice(span.end)}`;
+	return editFrontmatter(text, (block) => {
+		if (patch.title !== void 0) if (patch.title === null || patch.title.trim() === "") block.delete("title");
+		else block.set("title", patch.title, "first");
+		if (patch.aliases !== void 0) if (patch.aliases.length > 0) block.set("aliases", [...patch.aliases]);
+		else block.delete("aliases");
+	}, options);
 }
 /**
 * `after` - a writer's rewrite of `before` - with the document's aliases carried into the block
@@ -10164,19 +10638,83 @@ function withAliasesInAddedBlock(before, after, aliases) {
 	if (aliases.length === 0 || frontmatterSpan(before) !== null || frontmatterSpan(after) === null) return after;
 	return withFrontmatterIdentity(after, { aliases });
 }
-/** The block's YAML as a plain object, or null when it is malformed or not an object. */
-function parseBlock$2(yaml) {
-	try {
-		const parsed = parse(yaml);
-		if (parsed === null || parsed === void 0) return {};
-		if (typeof parsed !== "object" || Array.isArray(parsed)) return null;
-		return parsed;
-	} catch {
-		return null;
+//#endregion
+//#region ../client/src/lib/document/properties.ts
+/**
+* Keys a Property Filter answers from the graph's names rather than the block: the registry on
+* a Server Backend holds them, and a page created in the app there has no block to read.
+*/
+var NAME_PROPERTY_KEYS = new Set(["title", "aliases"]);
+/** Rows per document at most. Frontmatter is metadata; a block past this is not a label set. */
+var MAX_ROWS = 256;
+/** Characters of one value kept. Longer text is prose, which Search's text group covers. */
+var MAX_VALUE_LENGTH = 1e3;
+/**
+* Whether a value counts as not set (ADR 0108): null, blank text, a list with no set item, or a
+* mapping with no set value. `false` and `0` are values.
+*/
+function isEmptyPropertyValue(value) {
+	if (value === null || value === void 0) return true;
+	if (typeof value === "string") return value.trim() === "";
+	if (Array.isArray(value)) return value.every(isEmptyPropertyValue);
+	if (isMapping(value)) return Object.values(value).every(isEmptyPropertyValue);
+	return false;
+}
+/**
+* The rows for one document's parsed Frontmatter, in the block's order. Empty values are left
+* out, and so are `title` and `aliases` in any spelling: those filters read the graph's names.
+*/
+function propertiesOf(data) {
+	const out = [];
+	for (const [key, value] of Object.entries(data)) {
+		if (NAME_PROPERTY_KEYS.has(key.toLowerCase())) continue;
+		collect(key, value, out);
+		if (out.length >= MAX_ROWS) break;
+	}
+	return out.slice(0, MAX_ROWS);
+}
+/** Append the rows for `value` under `path`; a mapping adds its presence row before its values. */
+function collect(path, value, out) {
+	if (isEmptyPropertyValue(value)) return;
+	if (Array.isArray(value)) {
+		let presence = false;
+		for (const item of value) if (isMapping(item)) {
+			if (!presence && !isEmptyPropertyValue(item)) {
+				out.push({
+					key: path,
+					value: null
+				});
+				presence = true;
+			}
+			for (const [key, child] of Object.entries(item)) collect(`${path}.${key}`, child, out);
+		} else collect(path, item, out);
+		return;
+	}
+	if (isMapping(value)) {
+		out.push({
+			key: path,
+			value: null
+		});
+		for (const [key, child] of Object.entries(value)) collect(`${path}.${key}`, child, out);
+		return;
 	}
+	out.push({
+		key: path,
+		value: textOf(value).slice(0, MAX_VALUE_LENGTH)
+	});
 }
-function serialise(data) {
-	return Object.keys(data).length === 0 ? "" : stringify(data);
+function isMapping(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
+}
+/** A scalar as the text a person would type to find it. */
+function textOf(value) {
+	if (value instanceof Date) {
+		const iso = value.toISOString();
+		return iso.endsWith("T00:00:00.000Z") ? iso.slice(0, 10) : iso;
+	}
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return String(value);
+	return JSON.stringify(value) ?? "";
 }
 //#endregion
 //#region ../client/src/lib/document/calendar/month-grid-core.ts
@@ -10757,23 +11295,6 @@ async function scanGraph(adapter, options = {}) {
 //#endregion
 //#region ../client/src/lib/storage/fs/filesystem-store.ts
 /**
-* A {@link DocumentStore} over a real directory (via a {@link DirectoryAdapter}):
-* the Filesystem Backend. The files *are* the state — this holds only a live
-* buffer per open document plus a derived registry, and reconciles external
-* changes (git checkout, Syncthing) the way DESIGN.md → The git workflow requires.
-*
-* Assembled entirely from the pure pieces (scan, identity, reconcileDecision,
-* debounce) so it is exercised in Node over createMemoryDirectoryAdapter before
-* any browser code exists.
-*
-* Async-seam note: the seam's
-* `getText()` is synchronous but disk reads are async, so `open()` returns a
-* handle whose buffer is empty on first open and is hydrated by an internal
-* awaited read that then notifies subscribers the *external* way — which is safe
-* because DocumentView registers its `subscribe` listener in the same synchronous
-* onMount tick as its `getText()` seed, before the read resolves.
-*/
-/**
 * The snapshot for one document's full text: identity from the registry, aliases and include
 * facts from the frontmatter, the body for the index. Both backends build theirs this way, so
 * the index sees one shape whatever holds the document.
@@ -10786,12 +11307,14 @@ function indexSnapshotOf(identity, text) {
 		text,
 		aliases: []
 	}) : [];
+	const properties = propertiesOf(fm.data);
 	return {
 		concept: identity.concept,
 		kind: identity.kind,
 		aliases: aliasesOf(fm),
 		text: fm.body,
-		...includes.length > 0 ? { includes } : {}
+		...includes.length > 0 ? { includes } : {},
+		...properties.length > 0 ? { properties } : {}
 	};
 }
 function applyTextChange(text, change) {
@@ -10964,7 +11487,7 @@ function createFilesystemDocumentStore(adapter, options = {}) {
 		const fm = parseFrontmatter(text);
 		let aliases = aliasesOf(fm);
 		let body = fm.body;
-		let data = { ...fm.data };
+		let blockSource = text;
 		if (strategy === "alias") {
 			if (!aliases.some((a) => conceptKey(a) === conceptKey(step.from))) aliases = [...aliases, step.from];
 		}
@@ -10983,15 +11506,17 @@ function createFilesystemDocumentStore(adapter, options = {}) {
 			});
 			body = merged.body;
 			aliases = merged.aliases;
-			data = { ...existingFm.data };
+			blockSource = existing.text;
 		}
 		aliases = normaliseAliases(aliases, step.into);
-		data.title = step.into;
-		if (aliases.length > 0) data.aliases = aliases;
-		else delete data.aliases;
+		const blockSpan = frontmatterSpan(blockSource);
+		const content = withFrontmatterIdentity((blockSpan ? blockSource.slice(0, blockSpan.end) : "") + body, {
+			title: step.into,
+			aliases
+		}, { addBlock: true });
 		const subdir = survivor?.subdir ?? entry.subdir;
 		const fileName = survivor?.fileName ?? await allocateFileName(subdir, step.into, entry);
-		const written = await adapter.write(subdir, fileName, `---\n${stringify(data)}---\n${body}`);
+		const written = await adapter.write(subdir, fileName, content);
 		if (!(subdir === entry.subdir && fileName === entry.fileName)) await adapter.remove(entry.subdir, entry.fileName);
 		registry.delete(entry.key);
 		if (survivor) registry.delete(survivor.key);
@@ -11354,7 +11879,7 @@ function createFilesystemDocumentStore(adapter, options = {}) {
 			if (registry.get(key)) throw new Error(`A document for "${concept}" already exists.`);
 			await adapter.ensureSkeleton();
 			const fileName = await allocateFileName("pages", concept);
-			const content = `---\n${stringify({ title: concept })}---\n${body}`;
+			const content = renderFrontmatter({ title: concept }) + body;
 			await adapter.write("pages", fileName, content);
 			await refreshRegistry();
 			return concept;
@@ -11847,12 +12372,14 @@ function createServerDocumentStore(graph, options) {
 			text,
 			aliases: []
 		}) : [];
+		const properties = propertiesOf(parseFrontmatter(text).data);
 		return {
 			concept,
 			kind: entry.kind,
 			aliases: entry.aliases ?? [],
 			text: bodyForIndex(text),
-			...includes.length > 0 ? { includes } : {}
+			...includes.length > 0 ? { includes } : {},
+			...properties.length > 0 ? { properties } : {}
 		};
 	}
 	/**
@@ -13005,8 +13532,9 @@ function assembleHeadlessGraph(parts) {
 }
 /** Open a synced graph, scan its registry and build the index; resolves once tools can answer. */
 async function openHeadlessGraph(deps) {
-	const cache = await openGraphCache(deps.graphId);
-	if (deps.persistDir) await loadLocalCache(deps.persistDir, deps.graphId);
+	const cacheName = deps.localCacheName ?? deps.graphId;
+	const cache = await openGraphCache(cacheName);
+	if (deps.persistDir) await loadLocalCache(deps.persistDir, cacheName);
 	const indexHost = deps.persistDir ? nodeIndexHost(deps.persistDir) : void 0;
 	const sync = createGraphSync({
 		graphId: deps.graphId,
@@ -13135,7 +13663,7 @@ async function openHeadlessGraph(deps) {
 			embeddingModel: deps.embeddingModel,
 			onSemanticProgress: deps.onSemanticProgress,
 			onError: deps.onError,
-			persistBackend: deps.persistDir ? () => persistLocalCache(deps.persistDir, deps.graphId) : void 0,
+			persistBackend: deps.persistDir ? () => persistLocalCache(deps.persistDir, cacheName) : void 0,
 			onChange: (schedule) => sync.onDocUpdate(schedule),
 			async settle(schedulePersist) {
 				await sync.flushAll();
@@ -13989,134 +14517,43 @@ function bundledThemeList() {
 //#region ../client/src/lib/document/frontmatter/patch.ts
 /**
 * Rewriting arbitrary keys of a document's [[Frontmatter]] block, the way `withFrontmatterIdentity`
-* rewrites identity: other keys keep their values and order, the same string comes back when
-* nothing would change, and a block whose YAML does not parse is left alone rather than
+* rewrites identity: other keys keep their values, order and comments, the same string comes back
+* when nothing would change, and a block whose YAML does not parse is left alone rather than
 * destroyed. `null` removes a key. A block emptied of every key is removed with it. Identity keys
 * are not this function's business: pass them through `withFrontmatterIdentity` so the registry
 * rules (ADR 0061) apply.
 */
-function parseBlock$1(yaml) {
-	try {
-		const parsed = parse(yaml);
-		if (parsed === null || parsed === void 0) return {};
-		if (typeof parsed !== "object" || Array.isArray(parsed)) return null;
-		return parsed;
-	} catch {
-		return null;
-	}
-}
-function same(a, b) {
-	return JSON.stringify(a) === JSON.stringify(b);
-}
 function withFrontmatterPatch(text, patch, options = {}) {
-	const span = frontmatterSpan(text);
-	if (!span) {
-		if (!options.addBlock) return text;
-		const data = {};
-		for (const [key, value] of Object.entries(patch)) if (value !== null && value !== void 0) data[key] = value;
-		if (Object.keys(data).length === 0) return text;
-		return `---\n${stringify(data)}---\n${text}`;
-	}
-	const data = parseBlock$1(span.body);
-	if (data === null) return text;
-	const next = {};
-	let changed = false;
-	for (const [key, value] of Object.entries(data)) {
-		if (key in patch) {
-			const wanted = patch[key];
-			if (wanted === null || wanted === void 0) {
-				changed = true;
-				continue;
-			}
-			next[key] = wanted;
-			if (!same(wanted, value)) changed = true;
-			continue;
-		}
-		next[key] = value;
-	}
-	for (const [key, value] of Object.entries(patch)) {
-		if (key in data || value === null || value === void 0) continue;
-		next[key] = value;
-		changed = true;
-	}
-	if (!changed) return text;
-	if (Object.keys(next).length === 0) return text.slice(span.end);
-	return `---\n${stringify(next)}---\n${text.slice(span.end)}`;
+	return editFrontmatter(text, (block) => {
+		for (const [key, value] of Object.entries(patch)) if (value === null || value === void 0) block.delete(key);
+		else block.set(key, value);
+	}, options);
 }
 //#endregion
 //#region ../client/src/lib/document/frontmatter/publishing.ts
 /**
 * The publishing keys of a document's [[Frontmatter]] (ADR 0082): `public: true` is the consent
-* switch, `publications: [docs, blog]` routes. A public document with an empty list keeps the
-* key as `publications: []`: public with nowhere to go is a state worth a prompt, and the empty
-* key is that prompt to whoever edits the file by hand. Not public, the empty key is removed. Rewritten the way `withFrontmatterIdentity`
-* rewrites identity: other keys keep their values and order, the same string comes back when
-* nothing would change, and a block whose YAML does not parse is left alone rather than
-* destroyed. Read through `readMembership` in `publish/publication.ts`; this file only writes.
-*/
-function parseBlock(yaml) {
-	try {
-		const parsed = parse(yaml);
-		if (parsed === null || parsed === void 0) return {};
-		if (typeof parsed !== "object" || Array.isArray(parsed)) return null;
-		return parsed;
-	} catch {
-		return null;
-	}
-}
-function sameList(a, b) {
-	return Array.isArray(a) && a.length === b.length && a.every((v, i) => v === b[i]);
-}
+* switch, and `publications`, a list of publication ids, routes. A public document with no
+* publication keeps the key, written bare (`publications:`): public with nowhere to go is a state
+* worth a prompt, and the empty key is that prompt to whoever edits the file by hand. Bare rather
+* than `[]` because that is how the EtherPK style writes every empty value (ADR 0108), and because
+* Enter after a bare key opens the next line one level in, ready for the first `- id`. Not public, the empty key is
+* removed. Rewritten the way `withFrontmatterIdentity` rewrites identity: other keys keep their
+* values and order, the same string comes back when nothing would change, and a block whose YAML
+* does not parse is left alone rather than destroyed. Read through `readMembership` in
+* `publish/publication.ts`, which reads a bare key and `[]` alike; this file only writes.
+*/
 /** The text with its publishing keys rewritten. `addBlock` adds a block to a document without one. */
 function withPublishing(text, patch, options = {}) {
 	const publications = patch.publications === void 0 || patch.publications === null ? patch.publications : [...new Set(patch.publications.filter(isPublicationId))];
-	const span = frontmatterSpan(text);
-	if (!span) {
-		if (!options.addBlock) return text;
-		const data = {};
-		if (patch.public === true || patch.public === false) data.public = patch.public;
-		if (publications && (publications.length > 0 || patch.public === true)) data.publications = publications;
-		if (Object.keys(data).length === 0) return text;
-		return `---\n${stringify(data)}---\n${text}`;
-	}
-	const data = parseBlock(span.body);
-	if (data === null) return text;
-	const next = {};
-	let changed = false;
-	const wantPublic = patch.public === void 0 ? data.public : patch.public;
-	const keepEmpty = wantPublic === true;
-	const wantPublications = publications === void 0 ? data.publications : publications && (publications.length > 0 || keepEmpty) ? publications : null;
-	for (const [key, value] of Object.entries(data)) {
-		if (key === "public") {
-			if (wantPublic === null || wantPublic === void 0) changed = true;
-			else {
-				next.public = wantPublic;
-				if (wantPublic !== value) changed = true;
-			}
-			continue;
-		}
-		if (key === "publications") {
-			if (wantPublications === null || wantPublications === void 0) changed = true;
-			else {
-				next.publications = wantPublications;
-				if (!sameList(value, wantPublications)) changed = true;
-			}
-			continue;
-		}
-		next[key] = value;
-	}
-	if (!("public" in data) && (wantPublic === true || wantPublic === false)) {
-		next.public = wantPublic;
-		changed = true;
-	}
-	if (!("publications" in data) && Array.isArray(wantPublications) && (wantPublications.length > 0 || keepEmpty)) {
-		next.publications = wantPublications;
-		changed = true;
-	}
-	if (!changed) return text;
-	const yaml = Object.keys(next).length === 0 ? "" : stringify(next);
-	if (yaml === "") return text.slice(span.end);
-	return `---\n${yaml}---\n${text.slice(span.end)}`;
+	return editFrontmatter(text, (block) => {
+		if (patch.public === null) block.delete("public");
+		else if (patch.public !== void 0) block.set("public", patch.public);
+		if (publications === void 0) return;
+		const keepEmpty = (patch.public === void 0 ? block.get("public") : patch.public) === true;
+		if (publications === null || publications.length === 0 && !keepEmpty) block.delete("publications");
+		else block.set("publications", publications.length === 0 ? null : publications);
+	}, options);
 }
 //#endregion
 //#region ../client/src/lib/document/publish/seeded.ts
@@ -15211,7 +15648,7 @@ function allocate(documents) {
 	const derived = [];
 	for (const doc of documents) {
 		const value = parseFrontmatter(doc.text).data.slug;
-		if (value === void 0) {
+		if (isEmptyValue(value)) {
 			derived.push(doc);
 			continue;
 		}
@@ -15298,7 +15735,6 @@ function createThemeRenderer(theme, includes) {
 * a pre-render pass for the asynchronous bits (diagrams, code); then rendering, includes, the
 * theme, the derived files. Everything derived is computed from the included documents alone.
 */
-var DATE = /^\d{4}-\d{2}-\d{2}$/;
 function assetHrefOf(name) {
 	return `assets/${encodeURIComponent(name)}`;
 }
@@ -15542,17 +15978,9 @@ async function publishPublication(source, publication, env, options = {}) {
 		};
 		if (doc.kind === "journal") page.date = doc.concept;
 		else {
-			const date = parseFrontmatter(doc.text).data.date;
-			if (date !== void 0) {
-				const text = date instanceof Date ? date.toISOString().slice(0, 10) : String(date);
-				if (DATE.test(text)) page.date = text;
-				else warnings.push({
-					level: "warning",
-					code: "invalid-date",
-					message: `"${doc.concept}" has \`date: ${String(date)}\`, which is not a calendar day (YYYY-MM-DD); the document is undated.`,
-					concept: doc.concept
-				});
-			}
+			const dated = readPageDate(doc);
+			if (dated.date !== void 0) page.date = dated.date;
+			take(dated.issues);
 		}
 		for (const link of linksOf(bodyOf(doc), resolver, doc)) report.missingLinks.push(link);
 		pages.push(page);
@@ -16765,7 +17193,7 @@ function agentFrontmatter(rawText) {
 /**
 * The block after a patch. `public` and `publications` go through the publishing writer, so its
 * rules hold whoever writes them: an id is lower-case letters, digits and hyphens, and a public
-* document with an empty list keeps `publications: []` as the prompt it is. Everything else is a
+* document with an empty list keeps the key, written bare, as the prompt it is. Everything else is a
 * plain key. An invalid publication id is refused rather than dropped, which is what the
 * writer would do: an agent that misspells an id must hear about it.
 */
@@ -16948,7 +17376,24 @@ function round(similarity) {
 	return Math.round(similarity * 1e3) / 1e3;
 }
 async function searchText(graph, query, offset, limit) {
-	const [result, count] = await Promise.all([graph.index.searchText(query, offset, limit), graph.index.searchTextCount(query)]);
+	const keys = await graph.index.propertyKeys();
+	const { words, filters } = parseSearchQuery(query, new Set(keys.map((info) => info.key.toLowerCase())));
+	if (filters.length > 0 && words.trim() === "") {
+		const documents = await graph.index.propertyMatch(filters);
+		return {
+			results: documents.slice(offset, offset + limit).map((doc) => ({
+				concept: doc.concept,
+				kind: doc.kind,
+				matches: 0,
+				hits: [],
+				properties: doc.properties
+			})),
+			total: documents.length,
+			totalCapped: false,
+			hasMore: offset + limit < documents.length
+		};
+	}
+	const [result, count] = await Promise.all([graph.index.searchText(words, offset, limit, filters), graph.index.searchTextCount(words, filters)]);
 	return {
 		results: result.groups.map((group) => ({
 			concept: group.concept,
@@ -18518,7 +18963,7 @@ function createMcpServer(graph, info) {
 	}, async (args) => run(() => readDocuments(graph, args)));
 	server.registerTool("search", {
 		title: "Search",
-		description: `Search every unprotected document. mode "text" (default): words match by prefix, "quoted phrases" match exactly; documents come most-matches-first with the matching lines. mode "semantic": the passages closest in MEANING to the query, best first, each with its text, a similarity 0..1 and where it is (concept, breadcrumb of headings and parent bullets, start and end line) - finds a note that says "self-assessment is due 31 January" for "tax deadline". Line numbers are 0-based in every mode. Passage text is the note's own words with bullet markers and [[ ]] stripped: quote and cite it, but anchor edit_document on text from read_document. Use semantic for questions and descriptions, text for names, identifiers and exact phrases; mode "hybrid" returns both as separate groups. Semantic results carry complete: false while this computer is still embedding the graph (rerun later for more). If semantic mode answers error semantic_unavailable, it is not set up on this computer: tell the user the command in the message. At most 50 documents per call.`,
+		description: `Search every unprotected document. mode "text" (default): words match by prefix, "quoted phrases" match exactly; documents come most-matches-first with the matching lines. In text mode a term key:value is a property filter on the documents' frontmatter when some document has that key (keys and values ignore case; key:"two words", -key:value excludes, key:* means the key is set, key:va* matches the start of a value, publication.id:docs reaches a nested key, title: and aliases: match the document's names); filters alone list every matching document with the values they matched and no hits. mode "semantic": the passages closest in MEANING to the query, best first, each with its text, a similarity 0..1 and where it is (concept, breadcrumb of headings and parent bullets, start and end line) - finds a note that says "self-assessment is due 31 January" for "tax deadline". Line numbers are 0-based in every mode. Passage text is the note's own words with bullet markers and [[ ]] stripped: quote and cite it, but anchor edit_document on text from read_document. Use semantic for questions and descriptions, text for names, identifiers and exact phrases; mode "hybrid" returns both as separate groups. Semantic results carry complete: false while this computer is still embedding the graph (rerun later for more). If semantic mode answers error semantic_unavailable, it is not set up on this computer: tell the user the command in the message. At most 50 documents per call.`,
 		inputSchema: {
 			query: z.string().min(1),
 			mode: z.enum([