@bud.sh/app 0.5.0 → 0.6.0

package/dist/server/migration.js

@@ -1,7 +1,562 @@
-import { Kt as mapError, Lt as flatMap, On as try_, Ut as gen, _ as resolveStorage, f as Project, p as createProjectContext, sn as runPromise, u as Git } from "./assets/branch-previews-ClkoJ0lM.js";
-import { H as make, I as WorkError, O as AdapterRegistry } from "./assets/server-DxK-UB_Z.js";
-import { j as parseThread, z as parseThreadSnapshot } from "./assets/events-iHpLGr3k.js";
-import { n as storageLayer, r as readGitThreadImports } from "./assets/services-BRrgXYlT.js";
+import { $t as map, Cr as TaggedError, Ct as isPattern, Fn as try_, Gt as flatMap, Hn as currentTimeMillis, M as Path, N as FileSystem, St as isNonEmpty, Zt as gen, _ as createProjectContext, _t as Struct, b as withPlugins, bt as decodeEffect, en as mapError, g as Project, gt as String$1, m as Git, mn as runPromise, mr as Service, mt as ArraySchema, y as configPlugins } from "./assets/branch-previews-DedrpnVR.js";
+import { F as AdapterRegistry, H as WorkError, J as make, z as parseThreadImport } from "./assets/server-Dkbp5stG.js";
+import { En as parseMessage, R as parseThreadSnapshot, a as CommentMergeError, c as parseCommentInput, d as parseCommentThread, f as revision, j as parseThread, l as conversationId, o as mergeThreads, p as text, s as stableJson, u as object } from "./assets/events-BH_rAu7O.js";
+import { n as storageLayer } from "./assets/services-BTfig8A8.js";
+import { createHash, randomUUID } from "node:crypto";
+//#region ../comments/src/server/records.ts
+/**
+* Validates a persisted thread record of any version.
+* @param value - Untrusted data.
+* @returns The record.
+*/
+function parseStoredThread(value) {
+	let input = object(value);
+	if (input.version !== 3) return parseCommentThread(value);
+	for (let key of Object.keys(input)) if (![
+		"version",
+		"id",
+		"project",
+		"branch",
+		"createdCommit",
+		"anchor",
+		"itemIds",
+		"comments",
+		"status",
+		"createdAt",
+		"updatedAt",
+		"metadata"
+	].includes(key)) throw new Error(`Unsupported discussion field ${key}.`);
+	let project = text(input.project, "Project", 4096);
+	if (project !== "." && (project.startsWith("/") || project.includes("\\") || project.split("/").some((part) => !part || part === ".." || part === "."))) throw new Error("Invalid discussion project path.");
+	let createdCommit = input.createdCommit === "" ? "" : revision(input.createdCommit);
+	if (createdCommit === null) throw new Error("Invalid source commit.");
+	if (!Array.isArray(input.comments)) throw new Error("A discussion needs messages.");
+	let comments = input.comments.map(parseMessage);
+	let parents = new Map(comments.map((message) => [message.id, message.parentId]));
+	if (parents.size !== comments.length) throw new Error("Duplicate discussion message ID.");
+	for (let message of comments) {
+		let parent = message.parentId;
+		let seen = /* @__PURE__ */ new Set([message.id]);
+		while (parent !== null) {
+			if (seen.has(parent) || !parents.has(parent)) throw new Error("Invalid discussion reply ancestry.");
+			seen.add(parent);
+			parent = parents.get(parent);
+		}
+	}
+	let thread = parseThread({
+		id: conversationId(input.id),
+		status: input.status,
+		anchor: input.anchor,
+		itemIds: input.itemIds,
+		messages: comments.slice(0, 200),
+		messageCount: comments.length,
+		messagesLoaded: true,
+		messagesTruncated: comments.length > 200,
+		createdAt: input.createdAt,
+		updatedAt: input.updatedAt,
+		revision: null,
+		...input.metadata === void 0 ? {} : { metadata: input.metadata }
+	});
+	return {
+		version: 3,
+		id: thread.id,
+		project,
+		branch: text(input.branch, "Source branch", 1024),
+		createdCommit,
+		anchor: thread.anchor,
+		itemIds: thread.itemIds,
+		comments,
+		status: thread.status,
+		createdAt: thread.createdAt,
+		updatedAt: thread.updatedAt,
+		...thread.metadata === void 0 ? {} : { metadata: thread.metadata }
+	};
+}
+/**
+* Tracks this record's content, independent of writes to other threads.
+* @param record - The validated persisted discussion.
+* @returns An opaque revision for compare-and-swap updates.
+*/
+function threadRevision(record) {
+	return createHash("sha256").update(stableJson(record)).digest("hex");
+}
+/**
+* Turns a persisted record into the `@bud.sh/work` thread the app shows.
+* @param record - The validated persisted record.
+* @param loaded - Whether to include its messages, up to the limit, or only the first.
+* @returns The thread.
+*/
+function projectThread(record, loaded = true) {
+	let thread = {
+		id: record.id,
+		status: record.status,
+		anchor: record.anchor,
+		itemIds: record.version === 3 ? record.itemIds : [],
+		messages: record.comments.slice(0, loaded ? 200 : 1),
+		messageCount: record.comments.length,
+		messagesLoaded: loaded,
+		messagesTruncated: loaded && record.comments.length > 200,
+		createdAt: record.createdAt,
+		updatedAt: record.updatedAt,
+		revision: threadRevision(record),
+		...record.version === 3 ? record.metadata === void 0 ? {} : { metadata: record.metadata } : { metadata: { git: {
+			project: record.project,
+			branch: record.branch,
+			createdCommit: record.createdCommit
+		} } }
+	};
+	return parseThread(thread);
+}
+/**
+* Promotes a legacy record without changing its capture or messages.
+* @param record - The current stored record.
+* @returns Its version 3 representation; persistence removes the old path in the same commit.
+*/
+function promoteThread(record) {
+	if (record.version === 3) return record;
+	return {
+		...record,
+		version: 3,
+		itemIds: [],
+		metadata: projectThread(record).metadata
+	};
+}
+//#endregion
+//#region ../comments/src/server/merge.ts
+function changed(local, remote, base, field, hasBase = base !== void 0) {
+	if (stableJson(local) === stableJson(remote)) return local;
+	if (hasBase && stableJson(local) === stableJson(base)) return remote;
+	if (hasBase && stableJson(remote) === stableJson(base)) return local;
+	throw new CommentMergeError(`Conflicting discussion ${field}. Resolve the record in Git before syncing.`);
+}
+/**
+* Merges new records and mixed-version history while preserving captures.
+* @param local - The locally stored record.
+* @param remote - The validated incoming record.
+* @param base - The common ancestor, when one exists.
+* @returns The merged record, or a conflict when both sides changed the same value.
+*/
+function mergeStoredThreads(local, remote, base) {
+	if (local.version !== 3 && remote.version !== 3 && base?.version !== 3) return mergeThreads(local, remote, base);
+	let left = promoteThread(local);
+	let right = promoteThread(remote);
+	let ancestor = base && promoteThread(base);
+	function identity(record) {
+		let { comments, status, updatedAt, itemIds, metadata, ...identity } = record;
+		return identity;
+	}
+	if (stableJson(identity(left)) !== stableJson(identity(right)) || ancestor && stableJson(identity(left)) !== stableJson(identity(ancestor))) throw new CommentMergeError("Conflicting discussion anchors. Resolve the record in Git before syncing.");
+	let messages = /* @__PURE__ */ new Map();
+	for (let message of [...left.comments, ...right.comments]) {
+		let existing = messages.get(message.id);
+		if (existing && stableJson(existing) !== stableJson(message)) throw new CommentMergeError("Conflicting versions of a message. Resolve the record in Git before syncing.");
+		messages.set(message.id, message);
+	}
+	let itemIds = [.../* @__PURE__ */ new Set([
+		...left.itemIds,
+		...right.itemIds,
+		...ancestor?.itemIds ?? []
+	])].filter((id) => changed(left.itemIds.includes(id), right.itemIds.includes(id), ancestor?.itemIds.includes(id), "links")).sort();
+	let metadata = changed(left.metadata, right.metadata, ancestor?.metadata, "metadata", ancestor !== void 0);
+	return parseStoredThread({
+		...left,
+		status: changed(left.status, right.status, ancestor?.status, "status"),
+		itemIds,
+		updatedAt: left.updatedAt > right.updatedAt ? left.updatedAt : right.updatedAt,
+		comments: [...messages.values()].sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id)),
+		metadata
+	});
+}
+//#endregion
+//#region ../comments/src/server/errors.ts
+/** Safe domain messages; nested diagnostics stay on the trusted server. */
+var CommentsError = class extends TaggedError("CommentsError") {};
+//#endregion
+//#region ../comments/src/server/persistence.ts
+var commentsRef = "refs/heads/bud/comments";
+var threadPath = /^comments\/v(\d+)\/threads\/([a-f0-9-]{36})\/thread\.json$/;
+var optionsSchema = Struct({
+	root: String$1.check(isNonEmpty(), isPattern(/^[^\0]*$/)),
+	remote: String$1.check(isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]*$/)),
+	routes: ArraySchema(Struct({
+		id: String$1.check(isNonEmpty()),
+		path: String$1.check(isNonEmpty())
+	}))
+});
+function fromGit(cause) {
+	if (cause._tag === "GitIdentityError") return new CommentsError({
+		reason: "identity",
+		message: "Set git config user.name and user.email in this project before commenting.",
+		cause
+	});
+	if (cause._tag === "GitRepositoryError") return new CommentsError({
+		reason: "repository",
+		message: "Initialize a Git repository for this project to save comments.",
+		cause
+	});
+	if (cause._tag === "GitConflictError") return new CommentsError({
+		reason: "conflict",
+		message: "Comments changed elsewhere. Reload the conversation and try again.",
+		cause
+	});
+	return new CommentsError({
+		reason: "storage",
+		message: "The Git operation failed. Your existing comments remain saved. Check the repository and Git configuration.",
+		cause
+	});
+}
+function attempt(tryValue, reason = "input", message) {
+	return try_({
+		try: tryValue,
+		catch: (cause) => new CommentsError({
+			reason,
+			message: message ?? (cause instanceof Error ? cause.message : "Invalid comment."),
+			cause
+		})
+	});
+}
+function failure(reason, message) {
+	return (cause) => new CommentsError({
+		reason,
+		message,
+		cause
+	});
+}
+/**
+* Captures shared persistence for legacy comments and the thread adapter.
+* @param options - The trusted project, remote and configured routes.
+* @returns Scoped operations; repository access starts only when an operation runs.
+*/
+function createCommentStorage(options) {
+	return gen(function* () {
+		let input = yield* decodeEffect(optionsSchema, { onExcessProperty: "error" })(options).pipe(mapError(failure("input", "Invalid comment store configuration.")));
+		let git = yield* Git;
+		let fs = yield* FileSystem;
+		let paths = yield* Path;
+		function location() {
+			return gen(function* () {
+				let repo = yield* git.discover(input.root).pipe(mapError(fromGit));
+				if (repo.info.bare) return yield* new CommentsError({
+					reason: "repository",
+					message: "Open a source worktree before editing comments."
+				});
+				if ((yield* repo.symbolicRef.pipe(mapError(fromGit))) === "refs/heads/bud/comments") return yield* new CommentsError({
+					reason: "repository",
+					message: "Switch to your source branch before editing comments."
+				});
+				let root = yield* fs.realPath(input.root).pipe(mapError(failure("repository", "Unable to resolve the project directory.")));
+				let projectId = paths.relative(repo.info.root, root).replaceAll("\\", "/") || ".";
+				if (projectId === ".." || projectId.startsWith("../") || paths.isAbsolute(projectId)) return yield* new CommentsError({
+					reason: "repository",
+					message: "The project must be inside its Git repository."
+				});
+				return {
+					repo,
+					projectId
+				};
+			});
+		}
+		function headAt(repo, ref = commentsRef) {
+			return repo.resolve(ref).pipe(mapError(fromGit));
+		}
+		function author(repo) {
+			return repo.identity.pipe(mapError(fromGit), map(({ name, email }) => ({
+				name,
+				email,
+				id: createHash("sha256").update(`${name}\0${email}`).digest("hex").slice(0, 16)
+			})));
+		}
+		function source(repo) {
+			return gen(function* () {
+				return {
+					branch: (yield* repo.symbolicRef.pipe(mapError(fromGit)))?.replace(/^refs\/heads\//, "") ?? "detached",
+					createdCommit: (yield* headAt(repo, "HEAD")) ?? ""
+				};
+			});
+		}
+		function recordsAt(repo, head) {
+			return gen(function* () {
+				let records = /* @__PURE__ */ new Map();
+				let blobs = /* @__PURE__ */ new Map();
+				if (!head) return {
+					threads: records,
+					blobs
+				};
+				let entries = yield* repo.listTree(head, "comments").pipe(mapError(fromGit));
+				for (let entry of entries) {
+					let match = threadPath.exec(entry.path);
+					if (!match) continue;
+					if (entry.type !== "blob") return yield* new CommentsError({
+						reason: "conflict",
+						message: "The comments branch contains an unsupported or invalid thread."
+					});
+					let bytes = yield* repo.readBlob(entry.oid).pipe(mapError(fromGit));
+					let value = yield* attempt(() => JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes)), "conflict", "The comments branch contains invalid JSON. Repair that record before syncing.");
+					let thread = yield* attempt(() => {
+						let thread = parseStoredThread(value);
+						if (thread.id !== match[2] || String(thread.version) !== match[1]) throw new Error("Mismatched thread ID or storage version.");
+						if (records.has(thread.id)) throw new Error("Duplicate thread across versions.");
+						return thread;
+					}, "conflict", "The comments branch contains an unsupported or invalid thread.");
+					records.set(thread.id, thread);
+					blobs.set(thread.id, bytes);
+				}
+				return {
+					threads: records,
+					blobs
+				};
+			});
+		}
+		function snapshot(repo, projectId) {
+			return gen(function* () {
+				let head = yield* headAt(repo);
+				return {
+					head,
+					threads: [...(yield* recordsAt(repo, head)).threads.values()].filter((thread) => thread.project === projectId).sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id))
+				};
+			});
+		}
+		function commitRecords(repo, parent, records, message, previous) {
+			return gen(function* () {
+				let files = yield* attempt(() => records.flatMap((record) => {
+					let validated = parseStoredThread(record);
+					let contents = stableJson(validated);
+					let existing = previous.records.threads.get(validated.id);
+					if (existing && stableJson(existing) === contents) return [];
+					let remote = previous.remote?.threads.get(validated.id);
+					let original = remote && stableJson(remote) === contents ? previous.remote?.blobs.get(validated.id) : void 0;
+					return [...existing && existing.version !== validated.version ? [{
+						path: `comments/v${existing.version}/threads/${existing.id}/thread.json`,
+						contents: null
+					}] : [], {
+						path: `comments/v${validated.version}/threads/${validated.id}/thread.json`,
+						contents: original ?? `${contents}\n`
+					}];
+				}));
+				return yield* repo.commitSnapshot({
+					ref: commentsRef,
+					expectedHead: parent,
+					files,
+					message,
+					extraParents: previous.extraParent && previous.extraParent !== parent ? [previous.extraParent] : void 0
+				}).pipe(mapError(fromGit));
+			});
+		}
+		function list() {
+			return gen(function* () {
+				let { repo, projectId } = yield* location();
+				return yield* snapshot(repo, projectId);
+			});
+		}
+		function write(expectedHead, value) {
+			return gen(function* () {
+				let command = yield* attempt(() => {
+					if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Invalid comment change.");
+					return parseCommentInput({
+						...value,
+						head: expectedHead
+					}, input.routes, value.id);
+				});
+				let { repo, projectId } = yield* location();
+				let head = yield* headAt(repo);
+				if (head !== command.head) return yield* new CommentsError({
+					reason: "conflict",
+					message: "Comments changed elsewhere. Reload the conversation and try again."
+				});
+				let records = yield* recordsAt(repo, head);
+				let change = command.change;
+				let identity = yield* author(repo);
+				let now = new Date(yield* currentTimeMillis).toISOString();
+				let comment = change.body ? {
+					id: randomUUID(),
+					body: change.body,
+					author: identity,
+					createdAt: now,
+					parentId: change.parentId ?? null
+				} : void 0;
+				let thread;
+				if (change.id) {
+					let previous = records.threads.get(change.id);
+					if (!previous || previous.project !== projectId || previous.version === 3) return yield* new CommentsError({
+						reason: "not-found",
+						message: "This conversation no longer exists."
+					});
+					if (change.parentId && !previous.comments.some((comment) => comment.id === change.parentId)) return yield* new CommentsError({
+						reason: "input",
+						message: "Reply to a comment in this conversation."
+					});
+					thread = {
+						...previous,
+						comments: comment ? [...previous.comments, comment] : previous.comments,
+						status: change.status ?? previous.status,
+						updatedAt: now
+					};
+				} else {
+					let { branch, createdCommit } = yield* source(repo);
+					thread = yield* attempt(() => parseCommentThread({
+						version: "type" in change.anchor && change.anchor.type === "code" ? 2 : 1,
+						id: randomUUID(),
+						project: projectId,
+						branch,
+						createdCommit,
+						anchor: change.anchor,
+						comments: [comment],
+						status: "open",
+						createdAt: now,
+						updatedAt: now
+					}));
+				}
+				yield* commitRecords(repo, head, [thread], change.id ? "bud: update conversation" : "bud: start conversation", { records });
+				return yield* snapshot(repo, projectId);
+			});
+		}
+		function sync(direction = "both") {
+			return gen(function* () {
+				let { repo, projectId } = yield* location();
+				let remote = input.remote;
+				if (!(yield* repo.remoteUrl(remote).pipe(mapError(fromGit)))) return yield* new CommentsError({
+					reason: "remote-missing",
+					message: `Add the Git remote “${remote}” before syncing comments.`
+				});
+				let remoteExists = yield* repo.remoteHead(remote, commentsRef).pipe(mapError(failure("remote-read", "Cannot reach the Git remote. Check your connection and Git credentials; local comments are saved.")));
+				let localHead = yield* headAt(repo);
+				let localRecords = yield* recordsAt(repo, localHead);
+				if (remoteExists && direction !== "push") {
+					let remoteHead = yield* repo.fetchRef(remote, commentsRef, `refs/bud/remotes/${remote}/comments`).pipe(mapError(failure("remote-fetch", "Could not fetch comments from the Git remote. Local comments are saved.")));
+					if (!remoteHead) return yield* new CommentsError({
+						reason: "remote-fetch",
+						message: "Remote comments changed during fetch. Try syncing again."
+					});
+					let remoteRecords = yield* recordsAt(repo, remoteHead);
+					if (localHead !== remoteHead) {
+						if (!localHead) yield* repo.compareAndSwapRef(commentsRef, remoteHead, null).pipe(mapError(fromGit));
+						else {
+							let base = yield* repo.mergeBase(localHead, remoteHead).pipe(mapError(fromGit));
+							if (base === localHead) {
+								yield* attempt(() => {
+									for (let [id, local] of localRecords.threads) {
+										let remote = remoteRecords.threads.get(id);
+										if (remote) mergeStoredThreads(local, remote, local);
+									}
+								}, "conflict");
+								yield* repo.compareAndSwapRef(commentsRef, remoteHead, localHead).pipe(mapError(fromGit));
+							} else if (base !== remoteHead) {
+								let baseRecords = yield* recordsAt(repo, base);
+								yield* commitRecords(repo, localHead, yield* attempt(() => [.../* @__PURE__ */ new Set([...localRecords.threads.keys(), ...remoteRecords.threads.keys()])].map((id) => {
+									let local = localRecords.threads.get(id);
+									let remote = remoteRecords.threads.get(id);
+									return local && remote ? mergeStoredThreads(local, remote, baseRecords.threads.get(id)) : local ?? remote;
+								}), "conflict"), "bud: sync conversations", {
+									records: localRecords,
+									remote: remoteRecords,
+									extraParent: remoteHead
+								});
+							}
+						}
+					}
+				}
+				let publishHead = yield* headAt(repo);
+				if (publishHead && direction !== "pull") {
+					yield* recordsAt(repo, publishHead);
+					yield* repo.pushRef(remote, commentsRef, publishHead).pipe(mapError(failure("remote-push", "Comments are saved locally. The remote rejected the push; check Git access or sync again to include newer comments.")));
+				}
+				return yield* snapshot(repo, projectId);
+			});
+		}
+		function seed(seeds) {
+			return gen(function* () {
+				yield* attempt(() => {
+					if (!Array.isArray(seeds) || seeds.length > 1e3) throw new Error("Invalid seed conversations.");
+					if (new Set(seeds.map((seed) => seed.id)).size !== seeds.length) throw new Error("Duplicate seed conversation ID.");
+				});
+				let { repo, projectId } = yield* location();
+				let head = yield* headAt(repo);
+				let records = yield* recordsAt(repo, head);
+				let missing = yield* attempt(() => seeds.filter((seed) => {
+					let existing = records.threads.get(seed.id);
+					if (existing && existing.project !== projectId) throw new Error("That seed conversation belongs to another project.");
+					return !existing;
+				}), "conflict");
+				if (!missing.length) return yield* snapshot(repo, projectId);
+				let identity = yield* author(repo);
+				let now = new Date(yield* currentTimeMillis).toISOString();
+				let { branch, createdCommit } = yield* source(repo);
+				yield* commitRecords(repo, head, yield* attempt(() => missing.map((seed) => {
+					if (seed.anchor.element !== null || !input.routes.some((route) => route.id === seed.anchor.pageId && route.path === seed.anchor.pagePath)) throw new Error("Seed comments need coordinates on a configured route.");
+					return parseCommentThread({
+						version: 1,
+						id: seed.id,
+						project: projectId,
+						branch,
+						createdCommit,
+						anchor: seed.anchor,
+						comments: seed.messages.map((body) => ({
+							id: randomUUID(),
+							body,
+							author: identity,
+							createdAt: now,
+							parentId: null
+						})),
+						status: "open",
+						createdAt: now,
+						updatedAt: now
+					});
+				})), "bud: seed development conversations", { records });
+				return yield* snapshot(repo, projectId);
+			});
+		}
+		return {
+			list: list(),
+			write,
+			sync,
+			seed,
+			root: input.root,
+			paths,
+			location,
+			source,
+			author,
+			headAt,
+			recordsAt,
+			snapshot,
+			commitRecords
+		};
+	});
+}
+Service()("@bud.sh/comments/Comments");
+//#endregion
+//#region ../comments/src/server/migration.ts
+/**
+* Reads complete migration history under the Git runtime's existing tree and blob byte limits.
+* @param options - The trusted source project, remote and configured canvas routes.
+* @returns Complete source records and their immutable ref head, without writing any Git object or
+*   ref.
+*/
+function readGitThreadImports(options) {
+	return gen(function* () {
+		let snapshot = yield* (yield* createCommentStorage(options)).list;
+		let threads = yield* try_({
+			try: () => snapshot.threads.map((record) => parseThreadImport({
+				source: "bud-git",
+				sourceId: record.id,
+				thread: {
+					...projectThread(record),
+					messages: record.comments,
+					messagesTruncated: false
+				}
+			})),
+			catch: (cause) => new CommentsError({
+				reason: "storage",
+				message: "The Git discussion history could not be validated for migration.",
+				cause
+			})
+		});
+		return {
+			head: snapshot.head,
+			threads
+		};
+	});
+}
+//#endregion
 //#region app/server/comment-migration.ts
 function identity(metadata) {
 	if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) return null;
@@ -26,7 +581,7 @@ function migrateComments(dryRun = false) {
 		let target = registry.threads;
 		if (!target) return yield* new WorkError({
 			reason: "unavailable",
-			message: "Configure storage.threads or pass --to bud:beads before migrating comments."
+			message: "Discussions are off; pass --to bud:beads before migrating comments."
 		});
 		if (!target.import) return yield* new WorkError({
 			reason: "refused",
@@ -105,18 +660,20 @@ function migrateComments(dryRun = false) {
 * @returns The migration summary after the runtime and all native processes have been released.
 */
 async function runCommentMigration(options) {
-	let storage = resolveStorage({
-		work: false,
-		threads: options.to ?? options.config.storage.threads
-	});
-	let config = {
+	let plugins = configPlugins(options.config);
+	let threads = options.to ?? options.config.storage.threads;
+	if (threads !== "bud:beads" && !plugins.some((plugin) => plugin.name === threads && plugin.threads !== void 0)) throw new Error(threads ? `--to ${threads} names no plugin of this project that stores discussions; use bud:beads or one in plugins.` : "The project’s discussions are off; pass --to with the store to migrate into.");
+	let config = withPlugins({
 		...options.config,
-		storage,
+		storage: {
+			work: false,
+			threads
+		},
 		designs: {
 			...options.config.designs,
 			tasks: "bud:beads"
 		}
-	};
+	}, plugins);
 	let project = await runPromise(createProjectContext(options.root, config, config.targetOrigin ?? "http://localhost"), { signal: options.signal });
 	let runtime = make(storageLayer(project));
 	try {

package/dist/server/runtime.js

@@ -1,7 +1,7 @@
-import { An as uninterruptible, Dn as tryPromise, Kt as mapError, Rn as effect, Ut as gen, Zt as promise, p as createProjectContext, qn as provideMerge, sn as runPromise, sr as Service, vt as acquireRelease, x as readText } from "./assets/branch-previews-ClkoJ0lM.js";
-import { B as sharedModules, H as make } from "./assets/server-DxK-UB_Z.js";
-import { n as listen, r as createApp, t as ServerError } from "./assets/listener-DN5TyOjJ.js";
-import { t as applicationLayer } from "./assets/services-BRrgXYlT.js";
+import { Et as acquireRelease, Gn as effect, Ln as uninterruptible, O as readText, Pn as tryPromise, Zt as gen, _ as createProjectContext, an as promise, en as mapError, er as provideMerge, mn as runPromise, mr as Service } from "./assets/branch-previews-DedrpnVR.js";
+import { J as make, K as sharedModules, v as rememberOrigin } from "./assets/server-Dkbp5stG.js";
+import { n as listen, r as createApp, t as ServerError } from "./assets/listener-D61O6PzF.js";
+import { t as applicationLayer } from "./assets/services-BTfig8A8.js";
 import { fileURLToPath } from "node:url";
 //#region app/server/runtime.ts
 var BudListener = class extends Service()("bud/Listener") {};
@@ -86,8 +86,10 @@ async function startBud(options) {
 	};
 	options.signal?.addEventListener("abort", abort, { once: true });
 	try {
+		let listener = await runtime.runPromise(BudListener, { signal: options.signal });
+		rememberOrigin(project, listener.origin);
 		return {
-			origin: (await runtime.runPromise(BudListener, { signal: options.signal })).origin,
+			origin: listener.origin,
 			close
 		};
 	} catch (error) {

package/dist/server/server.js

@@ -1,6 +1,6 @@
-import { Kn as provide, Rn as effect, Ut as gen, b as nodeLayer, sr as Service, x as readText } from "./assets/branch-previews-ClkoJ0lM.js";
-import { H as make } from "./assets/server-DxK-UB_Z.js";
-import { n as listen, r as createApp } from "./assets/listener-DN5TyOjJ.js";
+import { $n as provide, D as nodeLayer, Gn as effect, O as readText, Zt as gen, mr as Service } from "./assets/branch-previews-DedrpnVR.js";
+import { J as make } from "./assets/server-Dkbp5stG.js";
+import { n as listen, r as createApp } from "./assets/listener-D61O6PzF.js";
 import { fileURLToPath } from "node:url";
 //#region server.ts
 var Listener = class extends Service()("bud/StandaloneListener") {};