dsh-tiddlywiki 0.22.4 → 0.22.5

package/lib/index.js

@@ -893,6 +893,91 @@ function parseSince(since) {
 	return Number.isNaN(ms) ? void 0 : ms;
 }
 //#endregion
+//#region src/host/ready-policy.ts
+/**
+* TiddlyWiki child readiness policy (v0.22.5).
+*
+* WHY THIS MODULE EXISTS — the production incident it fixes:
+* a 5000-tiddler / 26MB wiki on a cold file cache needed ~44s from `spawn` to
+* TW's own "Serving on http://127.0.0.1:…" line (verified from the /status ring
+* buffer: spawn 01:43:51 → first stdout 01:44:35). The old code had a single
+* hard 20s deadline, so it threw `wiki server did not become ready in time`,
+* which:
+*   1. aborted the whole startup pipeline (config load / seeds / clip bridge)
+*      even though the wiki WAS coming up;
+*   2. wrote `health = 'failed'` + a sticky error that nothing ever cleared —
+*      no one re-probed after the deadline, so `/status` (panel, FAB, tooltip)
+*      kept reporting a fault while TW served normally.
+*
+* The policy is now three-staged:
+*   soft window  (default 60s, configurable 5s–600s) — ONE warning, keep waiting;
+*   hard window  (3× the soft window)                — the attempt fails;
+*   late watch   (see wiki.ts)                       — a live child that answers
+*                                                      later still clears the fault.
+*
+* The loop is deliberately pure: `probe` / `isAlive` / clock / `sleep` are all
+* injected, so `scripts/verify-ready-policy.mjs` drives it with a virtual clock
+* (no real TW, no wall-clock flakiness).
+*
+* @module dsh-tiddlywiki/host/ready-policy
+*/
+/** Default soft readiness window: a slow boot only warns, it does not fail. */
+const READY_TIMEOUT_DEFAULT_MS = 6e4;
+/** Lower bound accepted from config (below this a big wiki would still be flaky). */
+const READY_TIMEOUT_MIN_MS = 5e3;
+/** Upper bound accepted from config. */
+const READY_TIMEOUT_MAX_MS = 6e5;
+/** Hard window = soft × this factor; only then is the attempt declared failed. */
+const READY_HARD_FACTOR = 3;
+/** Poll cadence while inside the soft window. */
+const READY_POLL_MS = 500;
+/** Slower cadence once the soft window passed (a slow boot needs patience, not 2 Hz). */
+const READY_SLOW_POLL_MS = 2e3;
+/**
+* Normalize a configured readiness window. Anything non-finite / non-positive
+* falls back to the default; the result is clamped into [MIN, MAX] so a typo in
+* the settings page can neither fail at 0ms nor hold startup for hours.
+*/
+function normalizeReadyTimeoutMs(value) {
+	return Math.min(READY_TIMEOUT_MAX_MS, Math.max(READY_TIMEOUT_MIN_MS, typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : READY_TIMEOUT_DEFAULT_MS));
+}
+/** The hard deadline derived from a (possibly unnormalized) soft window. */
+function readyHardTimeoutMs(softMs) {
+	return normalizeReadyTimeoutMs(softMs) * 3;
+}
+/**
+* Poll until the child answers, exits, or the hard deadline passes.
+*
+* Returns instead of throwing so the caller owns the health/error bookkeeping;
+* a probe that rejects counts as "not ready yet" (TW closes the socket while it
+* is still loading, and that is not an error).
+*/
+async function awaitReady(deps) {
+	const now = deps.now ?? (() => Date.now());
+	const sleep = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+	const soft = normalizeReadyTimeoutMs(deps.softTimeoutMs);
+	const hard = soft * 3;
+	const startedAt = now();
+	let warned = false;
+	for (;;) {
+		if (!deps.isAlive()) return "exited";
+		let ok = false;
+		try {
+			ok = await deps.probe();
+		} catch {
+			ok = false;
+		}
+		if (ok) return "ready";
+		const elapsed = now() - startedAt;
+		if (!warned && elapsed >= soft) {
+			warned = true;
+			deps.onSlow?.(elapsed, hard);
+		}
+		if (elapsed >= hard) return "timeout";
+		await sleep(elapsed >= soft ? READY_SLOW_POLL_MS : 500);
+	}
+}
+//#endregion
 //#region src/host/wiki.ts
 /**
 * WikiServer — the TiddlyWiki 5 child-process lifecycle (design doc §9, D3).
@@ -927,10 +1012,10 @@ const PATH_PREFIX = "/dsh-tiddlywiki";
 const TW_PROXY_PREFIX = `${PATH_PREFIX}/tw`;
 /** The proxy base path (trailing slash) handed to browsers / TW's frontend. */
 const TW_PROXY_PATH = `${TW_PROXY_PREFIX}/`;
-/** How long to wait for the wiki to answer /status. */
-const READY_TIMEOUT_MS = 2e4;
-/** Poll cadence while waiting for readiness. */
-const READY_POLL_MS = 500;
+/** Late-ready watch: cadence and lifetime after the hard deadline passed. */
+const LATE_READY_POLL_MS = 5e3;
+/** How long the late-ready watch keeps probing a child that outlived the deadline. */
+const LATE_READY_WINDOW_MS = 10 * 6e4;
 /** Backoff ceiling for crash restarts. */
 const MAX_RESTART_BACKOFF_MS = 3e4;
 /** SIGTERM → SIGKILL escalation grace. */
@@ -967,6 +1052,12 @@ var WikiServer = class {
 	/** Set by a successful readiness probe; a crash BEFORE readiness means the
 	*  auto-chosen port may have been taken, so it is re-probed on restart. */
 	wasReady = false;
+	/** Soft readiness window (ms, default 60s) — runtime-editable via {@link setReadyTimeout}. */
+	readyTimeoutMs;
+	/** Pending tick of the late-ready watch (v0.22.5), unref'ed. */
+	lateReadyTimer;
+	/** End timestamp of the armed late-ready watch (undefined = not armed). */
+	lateReadyWatchUntil;
 	constructor(options) {
 		this.options = options;
 		this.wikiPath = resolve(options.wikiRoot, options.wiki);
@@ -975,6 +1066,7 @@ var WikiServer = class {
 			name: options.wiki
 		};
 		this.logLimit = options.logBufferLimit ?? LOG_BUFFER_LIMIT;
+		this.readyTimeoutMs = normalizeReadyTimeoutMs(options.readyTimeoutMs);
 	}
 	/**
 	* The wiki folder this server currently serves (v0.22.0: mutable — a runtime
@@ -1021,6 +1113,24 @@ var WikiServer = class {
 	get url() {
 		return this.port === void 0 ? void 0 : `http://127.0.0.1:${this.port}`;
 	}
+	/**
+	* Update the readiness window (v0.22.5).
+	*
+	* Applies to the NEXT start()/restart(): the settings page saves
+	* `startup.readyTimeoutMs` and the host calls this on every config change, so
+	* a user with an even slower wiki can raise it without restarting dsh web.
+	* Values are clamped by ready-policy.ts (5s–600s; anything invalid → default).
+	*/
+	setReadyTimeout(value) {
+		const next = normalizeReadyTimeoutMs(value);
+		if (next === this.readyTimeoutMs) return;
+		this.readyTimeoutMs = next;
+		this.log(`ready timeout → ${next}ms (hard deadline ${readyHardTimeoutMs(next)}ms)`);
+	}
+	/** The soft readiness window currently in effect (settings page / diagnostics). */
+	get currentReadyTimeoutMs() {
+		return this.readyTimeoutMs;
+	}
 	/** The currently bound port (undefined until first spawn). */
 	get currentPort() {
 		return this.port;
@@ -1092,6 +1202,7 @@ var WikiServer = class {
 	async startOnce() {
 		this.stopping = false;
 		this.restartDelay = 1e3;
+		this.clearLateReadyWatch();
 		this.error = void 0;
 		await this.ensureWiki();
 		if (this.child !== void 0) return this.status();
@@ -1150,32 +1261,118 @@ var WikiServer = class {
 		await this.waitReady();
 		return this.status();
 	}
-	/** Poll /status until 200 or the deadline; throws only on deadline/crash. */
+	/**
+	* Preemptive Basic header for the readiness probe. Locked-down mode
+	* (`username` configured) puts /status behind TW's `readers` list: an
+	* anonymous probe gets 401 forever and the wiki would never be reported
+	* ready. Shared with the late-ready watch below.
+	*/
+	authHeaders() {
+		if (this.options.username === void 0 || this.options.username.length === 0) return void 0;
+		return { authorization: `Basic ${Buffer.from(`${this.options.username}:${this.options.password ?? ""}`, "utf8").toString("base64")}` };
+	}
+	/** One /status probe: true = 200 OK. Never throws (a refused socket while TW
+	*  is still loading is "not ready yet", not an error). */
+	async probeStatus(headers) {
+		if (this.port === void 0) return false;
+		try {
+			return (await fetch(`http://127.0.0.1:${this.port}/status`, {
+				signal: AbortSignal.timeout(2e3),
+				...headers !== void 0 ? { headers } : {}
+			})).ok;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Wait for readiness (v0.22.5 policy, see ready-policy.ts).
+	*
+	* Throws only when the child EXITED before ready, or when the HARD deadline
+	* (3× the soft window) passed with the child still silent. Passing the soft
+	* window is a warning, not a verdict: a 5000-tiddler wiki can legitimately
+	* need 40s+ on a cold cache, and failing there aborted seeding/config/clip
+	* bridge for a wiki that was about to serve. On a hard timeout the child is
+	* LEFT RUNNING and a bounded late-ready watch is armed, so `/status` stops
+	* reporting a fault the moment TW really answers.
+	*/
 	async waitReady() {
-		const deadline = Date.now() + READY_TIMEOUT_MS;
-		const headers = this.options.username !== void 0 && this.options.username.length > 0 ? { authorization: `Basic ${Buffer.from(`${this.options.username}:${this.options.password ?? ""}`, "utf8").toString("base64")}` } : void 0;
-		for (;;) {
-			if (this.child === void 0) throw new Error("wiki process exited before ready");
-			try {
-				if ((await fetch(`${this.url}/status`, {
-					signal: AbortSignal.timeout(2e3),
-					...headers !== void 0 ? { headers } : {}
-				})).ok) {
-					this.health = "running";
-					this.wasReady = true;
-					this.error = void 0;
-					this.log("ready: /status 200");
-					return;
-				}
-			} catch {}
-			if (Date.now() > deadline) {
-				this.health = "failed";
-				this.error = "wiki server did not become ready in time";
-				this.log(this.error);
-				throw new Error(this.error);
+		const headers = this.authHeaders();
+		const outcome = await awaitReady({
+			probe: () => this.probeStatus(headers),
+			isAlive: () => this.child !== void 0,
+			softTimeoutMs: this.readyTimeoutMs,
+			onSlow: (elapsedMs, hardTimeoutMs) => {
+				this.health = "starting";
+				this.error = void 0;
+				this.log(`slow start: /status not ready after ${Math.round(elapsedMs / 1e3)}s — still loading (hard deadline ${Math.round(hardTimeoutMs / 1e3)}s)`);
+			}
+		});
+		if (outcome === "ready") {
+			this.health = "running";
+			this.wasReady = true;
+			this.error = void 0;
+			this.log("ready: /status 200");
+			return;
+		}
+		if (outcome === "timeout") {
+			const hard = readyHardTimeoutMs(this.readyTimeoutMs);
+			this.health = "failed";
+			this.error = `wiki server did not become ready in time (${Math.round(hard / 1e3)}s)`;
+			this.log(this.error);
+			this.armLateReadyWatch();
+			throw new Error(this.error);
+		}
+		throw new Error("wiki process exited before ready");
+	}
+	/**
+	* Keep a low-frequency probe on a child that outlived the readiness deadline
+	* (v0.22.5). Bounded and `unref`ed (never holds the process open); cancelled
+	* by stop() and superseded by the next start(). It only ever PROMOTES the
+	* status — it never spawns, kills, or writes anything.
+	*/
+	armLateReadyWatch() {
+		const child = this.child;
+		if (child === void 0 || this.stopping || this.lateReadyTimer !== void 0 || this.lateReadyWatchUntil !== void 0) return;
+		const deadline = Date.now() + LATE_READY_WINDOW_MS;
+		this.lateReadyWatchUntil = deadline;
+		const headers = this.authHeaders();
+		this.log(`late-ready watch armed (up to ${Math.round(LATE_READY_WINDOW_MS / 6e4)}min)`);
+		const tick = async () => {
+			this.lateReadyTimer = void 0;
+			if (this.stopping || this.child !== child || this.health === "running") {
+				this.lateReadyWatchUntil = void 0;
+				return;
+			}
+			if (await this.probeStatus(headers)) {
+				this.health = "running";
+				this.wasReady = true;
+				this.error = void 0;
+				this.lateReadyWatchUntil = void 0;
+				this.log("ready (late): /status 200 — cleared the stale startup failure");
+				return;
+			}
+			if (Date.now() >= deadline) {
+				this.lateReadyWatchUntil = void 0;
+				this.log("late-ready watch gave up (child never answered /status)");
+				return;
 			}
-			await new Promise((r) => setTimeout(r, READY_POLL_MS));
+			this.lateReadyTimer = setTimeout(() => {
+				tick();
+			}, LATE_READY_POLL_MS);
+			this.lateReadyTimer.unref?.();
+		};
+		this.lateReadyTimer = setTimeout(() => {
+			tick();
+		}, LATE_READY_POLL_MS);
+		this.lateReadyTimer.unref?.();
+	}
+	/** Cancel a pending late-ready watch (stop / new attempt / teardown). */
+	clearLateReadyWatch() {
+		if (this.lateReadyTimer !== void 0) {
+			clearTimeout(this.lateReadyTimer);
+			this.lateReadyTimer = void 0;
 		}
+		this.lateReadyWatchUntil = void 0;
 	}
 	scheduleRestart() {
 		if (this.stopping || this.restartTimer !== void 0) return;
@@ -1221,6 +1418,7 @@ var WikiServer = class {
 			clearTimeout(this.restartTimer);
 			this.restartTimer = void 0;
 		}
+		this.clearLateReadyWatch();
 		const child = this.child;
 		this.child = void 0;
 		if (child !== void 0 && child.exitCode === null && child.signalCode === null) {
@@ -9124,6 +9322,7 @@ const DEFAULTS = {
 		sendToAgent: { enabled: true },
 		allArticles: { pageSize: 10 }
 	},
+	startup: { readyTimeoutMs: READY_TIMEOUT_DEFAULT_MS },
 	uiLanguage: "",
 	auth: {
 		username: "",
@@ -9254,6 +9453,10 @@ function apply(ctx, rawConfig = {}) {
 		auth: {
 			...DEFAULTS.auth,
 			...rawConfig.auth ?? {}
+		},
+		startup: {
+			...DEFAULTS.startup,
+			...rawConfig.startup ?? {}
 		}
 	};
 	let wikiPath = join(config.wikiRoot, config.wiki);
@@ -9265,7 +9468,8 @@ function apply(ctx, rawConfig = {}) {
 		git: config.git,
 		ui: config.ui,
 		uiLanguage: config.uiLanguage,
-		bridge: config.bridge
+		bridge: config.bridge,
+		startup: config.startup
 	});
 	const eff = () => configStore.get();
 	const effectiveNoteTag = () => {
@@ -9348,8 +9552,18 @@ function apply(ctx, rawConfig = {}) {
 		wiki: config.wiki,
 		port: config.port,
 		username: config.auth.username,
-		password: config.auth.password
+		password: config.auth.password,
+		readyTimeoutMs: config.startup.readyTimeoutMs
 	});
+	/**
+	* Readiness window from the EFFECTIVE config (v0.22.5): the settings page
+	* saves `startup.readyTimeoutMs`, and this re-applies it to the running
+	* server — it takes effect on the next start()/restart() without a dsh web
+	* restart. Values are clamped by host/ready-policy.ts.
+	*/
+	const applyServerTuning = () => {
+		server.setReadyTimeout(eff().startup?.readyTimeoutMs);
+	};
 	let clientCache;
 	let clientPort;
 	const client = () => {
@@ -9508,6 +9722,7 @@ function apply(ctx, rawConfig = {}) {
 			}
 			await configStore.load(client());
 			applyPrompt();
+			applyServerTuning();
 			if (disposed) {
 				await server.stop().catch(() => void 0);
 				return;
@@ -9673,7 +9888,10 @@ function apply(ctx, rawConfig = {}) {
 			getWikiPath: () => wikiPath,
 			twRoot: resolveTwRoot,
 			config: configStore,
-			onConfigChanged: () => applyPrompt(),
+			onConfigChanged: () => {
+				applyPrompt();
+				applyServerTuning();
+			},
 			getPrompt: () => ({
 				enabled: eff().prompt?.enabled !== false,
 				mode: normalizePromptMode(eff().prompt?.mode),
@@ -9718,6 +9936,6 @@ function apply(ctx, rawConfig = {}) {
 	}, "dsh-tiddlywiki: host teardown");
 }
 //#endregion
-export { AGENT_WRITTEN_TAG, ALL_ARTICLES_MARKER_TITLE, ALL_ARTICLES_TEXT, ALL_ARTICLES_TITLE, AutoCommitter, CLIP_BRIDGE_BOOKMARKLET, CLIP_BRIDGE_DEFAULT_PORT, CLIP_BRIDGE_DOC_TEXT, CLIP_BRIDGE_DOC_TITLE, CLIP_BRIDGE_DRAG_HREF, CLIP_BRIDGE_MARKER_TITLE, ClipBridge, ConfigStore, DEFAULT_NOTE_TYPE, DEFAULT_PROMPT_MODE, DOC_NOTE_TAG, DOC_NOTE_TEXT, DOC_NOTE_TITLE, DSH_DOCS_TAG, GitFace, HOME_DEFAULT_TIDDLERS, HOME_INDEX_ITEMS, HOME_INDEX_MARKER_TITLE, HUMAN_EDITED_TAG, LOCATION_STATE_VERSION, MARKDOWN_PLUGIN, MASKED_SECRET, MENUBAR_THEME_MARKER_TITLE, MENUBAR_THEME_TEXT, MENUBAR_THEME_TIDDLER, MISSING_TYPE_FILTER, PATH_PREFIX, PROMPT_GOVERNANCE_BLOCKS, PROMPT_MODES, PROMPT_SECTION_NAME, PROMPT_SECTION_ORDER, RENDER_BUNDLE_TEXT, RENDER_MARKER_TITLE, RENDER_PLUGIN_FILE, RENDER_PLUGIN_TITLE, SEED_DEFS, SEED_MARKER_VERSION, SEND_TO_AGENT_BUNDLE_TEXT, SEND_TO_AGENT_MARKER_TITLE, SEND_TO_AGENT_PLUGIN_TITLE, SESSION_SUMMARY_PREFIX, STARTER_DOCS_ITEMS, STARTER_DOCS_MARKER_TITLE, TEXT_LIST_FILTER, TRASH_INDEX_TITLE, TRASH_PREFIX, TW_PROXY_PATH, TW_PROXY_PREFIX, TW_WEB_HOST_DEFAULT, TW_WEB_HOST_TIDDLER, TiddlyWebClient, TrashIndexUnavailableError, UI_STYLES_MARKER_TITLE, UI_STYLE_ITEMS, WikiServer, WriteConflictError, apply, assertNoConflict, assertPublicImageUrl, buildBinaryTiddler, buildClipTiddler, buildImageNoteTiddler, buildPromptText, buildWriteTiddler, bundledCatalog, checkAllSeeds, cleanTiddler, clearLocationState, deepMerge, defaultLocationStateFile, defineTool, docNoteText, downloadClipImage, dshHomePath, ensureLanguage, ensurePlugin, ensureTwWebHost, escapeInline, escapePromptBraces, expandEnvPath, flattenTiddlerFields, flushPendingWrites, hashText, hostAllowed, imageExtensionForMime, inject, isBinaryType, isPrivateAddress, isSafeUrl, listWikiCandidates, locationPath, maskConfigSecrets, name, needsRestartAfterSeeds, normalizeLocation, normalizePromptMode, normalizeThemes, openInTwEditor, parseClipPayload, parseSeedMarker, pickImageMime, readActiveThemeName, readLocationState, readSeedMarker, readWikiInfo, registerAdminRoutes, registerRoutes, registerTiddlywikiTools, removeSeedById, resolveClipTitle, resolveTwRoot, runAllSeeds, runSeedById, sanitizeTwFragment, seedAllArticles, seedClipBridge, seedDocNote, seedHomeIndex, seedMenubarTheme, seedRenderRoute, seedSendToAgent, seedStarterDocs, seedUiStyles, stripMaskedSecrets, switchWiki, tiddlywikiToolSummary, toolSignatureLines, unseedClipBridge, waitForFileWrite, writeLocationState, writeSeedMarker, writeSessionSummary, writeWikiInfo };
+export { AGENT_WRITTEN_TAG, ALL_ARTICLES_MARKER_TITLE, ALL_ARTICLES_TEXT, ALL_ARTICLES_TITLE, AutoCommitter, CLIP_BRIDGE_BOOKMARKLET, CLIP_BRIDGE_DEFAULT_PORT, CLIP_BRIDGE_DOC_TEXT, CLIP_BRIDGE_DOC_TITLE, CLIP_BRIDGE_DRAG_HREF, CLIP_BRIDGE_MARKER_TITLE, ClipBridge, ConfigStore, DEFAULT_NOTE_TYPE, DEFAULT_PROMPT_MODE, DOC_NOTE_TAG, DOC_NOTE_TEXT, DOC_NOTE_TITLE, DSH_DOCS_TAG, GitFace, HOME_DEFAULT_TIDDLERS, HOME_INDEX_ITEMS, HOME_INDEX_MARKER_TITLE, HUMAN_EDITED_TAG, LOCATION_STATE_VERSION, MARKDOWN_PLUGIN, MASKED_SECRET, MENUBAR_THEME_MARKER_TITLE, MENUBAR_THEME_TEXT, MENUBAR_THEME_TIDDLER, MISSING_TYPE_FILTER, PATH_PREFIX, PROMPT_GOVERNANCE_BLOCKS, PROMPT_MODES, PROMPT_SECTION_NAME, PROMPT_SECTION_ORDER, READY_HARD_FACTOR, READY_POLL_MS, READY_SLOW_POLL_MS, READY_TIMEOUT_DEFAULT_MS, READY_TIMEOUT_MAX_MS, READY_TIMEOUT_MIN_MS, RENDER_BUNDLE_TEXT, RENDER_MARKER_TITLE, RENDER_PLUGIN_FILE, RENDER_PLUGIN_TITLE, SEED_DEFS, SEED_MARKER_VERSION, SEND_TO_AGENT_BUNDLE_TEXT, SEND_TO_AGENT_MARKER_TITLE, SEND_TO_AGENT_PLUGIN_TITLE, SESSION_SUMMARY_PREFIX, STARTER_DOCS_ITEMS, STARTER_DOCS_MARKER_TITLE, TEXT_LIST_FILTER, TRASH_INDEX_TITLE, TRASH_PREFIX, TW_PROXY_PATH, TW_PROXY_PREFIX, TW_WEB_HOST_DEFAULT, TW_WEB_HOST_TIDDLER, TiddlyWebClient, TrashIndexUnavailableError, UI_STYLES_MARKER_TITLE, UI_STYLE_ITEMS, WikiServer, WriteConflictError, apply, assertNoConflict, assertPublicImageUrl, awaitReady, buildBinaryTiddler, buildClipTiddler, buildImageNoteTiddler, buildPromptText, buildWriteTiddler, bundledCatalog, checkAllSeeds, cleanTiddler, clearLocationState, deepMerge, defaultLocationStateFile, defineTool, docNoteText, downloadClipImage, dshHomePath, ensureLanguage, ensurePlugin, ensureTwWebHost, escapeInline, escapePromptBraces, expandEnvPath, flattenTiddlerFields, flushPendingWrites, hashText, hostAllowed, imageExtensionForMime, inject, isBinaryType, isPrivateAddress, isSafeUrl, listWikiCandidates, locationPath, maskConfigSecrets, name, needsRestartAfterSeeds, normalizeLocation, normalizePromptMode, normalizeReadyTimeoutMs, normalizeThemes, openInTwEditor, parseClipPayload, parseSeedMarker, pickImageMime, readActiveThemeName, readLocationState, readSeedMarker, readWikiInfo, readyHardTimeoutMs, registerAdminRoutes, registerRoutes, registerTiddlywikiTools, removeSeedById, resolveClipTitle, resolveTwRoot, runAllSeeds, runSeedById, sanitizeTwFragment, seedAllArticles, seedClipBridge, seedDocNote, seedHomeIndex, seedMenubarTheme, seedRenderRoute, seedSendToAgent, seedStarterDocs, seedUiStyles, stripMaskedSecrets, switchWiki, tiddlywikiToolSummary, toolSignatureLines, unseedClipBridge, waitForFileWrite, writeLocationState, writeSeedMarker, writeSessionSummary, writeWikiInfo };
 
 //# sourceMappingURL=index.js.map