@bud.sh/app 0.5.0 → 0.6.0

package/dist/node/assets/server-DTQFuoX2.js

@@ -0,0 +1,846 @@
+import { A as parseWorkValue, B as statusCategory, C as parseWorkMutationResult, E as parseWorkSnapshot, F as parseMessage, G as record$1, H as identifier, I as parseMessageAuthor, K as strict, L as withoutMessages, M as workRunSummary, N as messageDeletionRefusal, P as messageDeletionRefusals, R as fieldByRole, S as parseWorkItemRef, T as parseWorkQuery, U as nonempty, V as WorkValidationError, W as parseWork, a as parseThreadDeleteInput, b as parseWorkDetail, c as parseThreadLinkInput, f as parseThreadStatusInput, g as parseWorkActionInput, h as parseSectionData, i as parseThreadCapabilities, j as valueByRole, k as parseWorkUpdate, l as parseThreadReplyInput, o as parseThreadFilter, r as parseThread, s as parseThreadInput, t as MAX_THREADS, u as parseThreadSnapshot, x as parseWorkItem, y as parseWorkCreate, z as parseWorkSchema } from "./src-Dwe9APUx.js";
+import { F as offerUnsafe, Ht as sync, I as acquireRelease, Kt as try_, Ur as TaggedError, Yt as yieldNow, Zt as currentTimeMillis, _r as make, ft as gen, mr as add, n as callback, pn as effectContext, pr as Service } from "./Stream-CAm1eJ2n.js";
+import { any } from "remix/data-schema";
+import { isAbsolute, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+//#region ../work/src/server/errors.ts
+var WorkErrorBase = TaggedError("WorkError");
+/** Safe messages cross the HTTP boundary; diagnostics and credentials do not. */
+var WorkError = class extends WorkErrorBase {};
+//#endregion
+//#region ../work/src/server/services.ts
+var WorkAdapterBase = Service()("@bud.sh/work/WorkAdapter");
+/** A backend's work items. Run programs at a request boundary with its AbortSignal. */
+var WorkAdapter = class extends WorkAdapterBase {};
+var ThreadAdapterBase = Service()("@bud.sh/work/ThreadAdapter");
+/** Discussions receive trusted server attribution separately from browser input. */
+var ThreadAdapter = class extends ThreadAdapterBase {};
+var ThreadImportSchema = strict({
+	source: identifier,
+	sourceId: nonempty(512),
+	thread: any()
+});
+function history(value) {
+	let input = parseWork(record$1, value, "import.thread");
+	if (!Array.isArray(input.messages) || input.messages.length === 0 || input.messages.length > 67108864 || input.messagesLoaded !== true || input.messagesTruncated !== false || input.messageCount !== input.messages.length) throw new WorkValidationError("import.thread.messages");
+	let encoder = new TextEncoder();
+	let bytes = 0;
+	let messages = Array.from(input.messages, (value) => {
+		let message = parseMessage(value);
+		bytes += encoder.encode(JSON.stringify(message)).byteLength + 1;
+		if (bytes > 67108864) throw new WorkValidationError("import.thread.bytes");
+		return message;
+	});
+	let parents = new Map(messages.map((message) => [message.id, message.parentId]));
+	if (parents.size !== messages.length) throw new WorkValidationError("import.thread.messages");
+	let complete = /* @__PURE__ */ new Set();
+	for (let message of messages) {
+		let path = /* @__PURE__ */ new Set();
+		let id = message.id;
+		while (id !== null && !complete.has(id)) {
+			if (path.has(id) || !parents.has(id)) throw new WorkValidationError("import.thread.messages.parentId");
+			path.add(id);
+			id = parents.get(id);
+		}
+		for (let id of path) complete.add(id);
+	}
+	let thread = parseThread({
+		...input,
+		messages: messages.slice(0, 200),
+		messagesTruncated: messages.length > 200
+	});
+	bytes += encoder.encode(JSON.stringify({
+		...thread,
+		messages: []
+	})).byteLength;
+	if (bytes > 67108864) throw new WorkValidationError("import.thread.bytes");
+	return {
+		...thread,
+		messages,
+		messagesTruncated: false
+	};
+}
+/**
+* Validates complete source history before a server-side migration writes anything.
+* @param value - The source identity and fully loaded discussion.
+* @returns Complete, byte-bounded history, independent of the browser's message-count limit.
+*/
+function parseThreadImport(value) {
+	let input = parseWork(ThreadImportSchema, value, "import");
+	return {
+		...input,
+		thread: history(input.thread)
+	};
+}
+//#endregion
+//#region ../work/src/server/memory-state.ts
+var expectedRevision = nonempty(256);
+var projectRoot = nonempty(4096);
+/**
+* Runs a parser over caller input, turning its failure into an `input` work error.
+* @param parse - Parses the input.
+* @returns The parsed input.
+*/
+function input(parse) {
+	try {
+		return parse();
+	} catch (cause) {
+		if (cause instanceof WorkError) throw cause;
+		throw new WorkError({
+			reason: "input",
+			message: "Check the supplied values.",
+			cause
+		});
+	}
+}
+/**
+* Runs a parser over stored data, turning its failure into a `storage` work error.
+* @param parse - Parses the stored data.
+* @returns The parsed data.
+*/
+function output(parse) {
+	try {
+		return parse();
+	} catch (cause) {
+		if (cause instanceof WorkError) throw cause;
+		throw new WorkError({
+			reason: "storage",
+			message: "The adapter returned invalid data.",
+			cause
+		});
+	}
+}
+/**
+* Throws a `refused` work error.
+* @param message - The reason, safe to show.
+*/
+function refused(message) {
+	throw new WorkError({
+		reason: "refused",
+		message
+	});
+}
+/**
+* Throws a `conflict` work error unless a record is still at the revision the caller saw.
+* @param current - The stored record.
+* @param revision - The caller's expected revision.
+*/
+function expected(current, revision) {
+	input(() => parseWork(expectedRevision, revision, "expectedRevision"));
+	if (current.revision !== revision) throw new WorkError({
+		reason: "conflict",
+		message: "This record changed. Refresh and review your changes before saving.",
+		currentRevision: current.revision
+	});
+}
+/**
+* A loaded section, cut to its limit.
+* @param items - The section's entries.
+* @param max - The most entries to return.
+* @param count - How many entries exist in all.
+* @returns The available section, truncated when more exist than it holds.
+*/
+function available(items, max, count = items.length) {
+	return {
+		state: "available",
+		items: items.slice(0, max),
+		truncated: count > max
+	};
+}
+/**
+* A section the store does not provide.
+* @returns The unsupported section.
+*/
+function unsupported() {
+	return {
+		state: "unsupported",
+		items: [],
+		truncated: false
+	};
+}
+/** The items, discussions and watchers behind the in-memory work and thread adapters. */
+var MemoryStore = class {
+	identity = randomUUID();
+	schema;
+	author;
+	defaults;
+	capabilities;
+	options;
+	workspaces = /* @__PURE__ */ new Map();
+	#watchers = /* @__PURE__ */ new Map();
+	seed;
+	constructor(options) {
+		this.schema = parseWorkSchema(options.schema);
+		this.author = parseMessageAuthor(options.author ?? {
+			id: "memory",
+			name: "Memory adapter",
+			email: ""
+		});
+		this.defaults = Object.fromEntries(Object.entries(options.defaults ?? {}).map(([key, value]) => {
+			let field = this.schema.fields.find((field) => field.id === key);
+			if (!field) refused("A default refers to an undeclared field.");
+			return [key, parseWorkValue(value, field, this.schema)];
+		}));
+		this.options = {
+			...options,
+			actions: { ...options.actions },
+			sections: { ...options.sections }
+		};
+		this.capabilities = parseThreadCapabilities({
+			create: this.schema.capabilities.threads,
+			reply: this.schema.capabilities.threads,
+			status: this.schema.capabilities.threads,
+			link: this.schema.capabilities.threads,
+			delete: this.schema.capabilities.threads,
+			...options.threadCapabilities,
+			sync: false,
+			edit: false
+		});
+		if (this.schema.capabilities.sync) refused("Memory storage has no remote synchronization.");
+		for (let action of this.schema.actions) if (action.kind === "custom" && !this.options.actions?.[action.id]) refused("Declare an implementation for each custom memory action.");
+		for (let id of Object.keys(this.options.actions ?? {})) if (!this.schema.actions.some((action) => action.id === id)) refused("An action implementation has no declaration.");
+		for (let id of Object.keys(this.options.sections ?? {})) if (!this.schema.sections.some((section) => section.id === id)) refused("A section implementation has no declaration.");
+		this.seed = {
+			sequence: 0,
+			items: /* @__PURE__ */ new Map(),
+			threads: /* @__PURE__ */ new Map()
+		};
+		for (let value of options.items ?? []) {
+			let item = parseWorkItem(value, this.schema);
+			if (!item.contentLoaded || !item.revision || this.seed.items.has(item.id)) refused("Seed work items need complete content and unique identities with revisions.");
+			this.seed.items.set(item.id, {
+				item,
+				activity: [],
+				activityCount: 0,
+				history: [],
+				historyCount: 0
+			});
+		}
+		for (let value of options.threads ?? []) {
+			let thread = parseThread(value);
+			if (!thread.messagesLoaded || thread.messagesTruncated || !thread.revision || this.seed.threads.has(thread.id)) refused("Seed threads need complete messages and unique identities with revisions.");
+			for (let id of thread.itemIds) this.item(this.seed, id);
+			this.seed.threads.set(thread.id, thread);
+		}
+		for (let row of this.seed.items.values()) for (let relation of row.item.relations) this.item(this.seed, relation.item.id);
+	}
+	/**
+	* Signals every write to one workspace while the stream runs.
+	* @param root - The project directory.
+	* @returns One element per write.
+	*/
+	watch(root) {
+		return callback((queue) => acquireRelease(try_({
+			try: () => {
+				let key = input(() => resolve(root));
+				let notify = () => void offerUnsafe(queue, void 0);
+				let watchers = this.#watchers.get(key) ?? /* @__PURE__ */ new Set();
+				this.#watchers.set(key, watchers.add(notify));
+				return () => watchers.delete(notify);
+			},
+			catch: (cause) => cause instanceof WorkError ? cause : new WorkError({
+				reason: "input",
+				message: "Invalid project directory.",
+				cause
+			})
+		}), (stop) => sync(stop)));
+	}
+	run(root, write, operation) {
+		return gen({ self: this }, function* () {
+			yield* yieldNow;
+			let now = yield* currentTimeMillis;
+			return yield* try_({
+				try: () => {
+					let key = input(() => {
+						parseWork(projectRoot, root, "root");
+						if (!isAbsolute(root)) throw new TypeError("The project directory must be absolute.");
+						return resolve(root);
+					});
+					let current = this.workspaces.get(key) ?? structuredClone(this.seed);
+					let data = write ? structuredClone(current) : current;
+					let result = structuredClone(operation(data, new Date(now).toISOString()));
+					if (write) {
+						this.workspaces.set(key, data);
+						for (let notify of [...this.#watchers.get(key) ?? []]) notify();
+					}
+					return result;
+				},
+				catch: (cause) => cause instanceof WorkError ? cause : new WorkError({
+					reason: "storage",
+					message: "Memory storage failed.",
+					cause
+				})
+			});
+		});
+	}
+	next(data, prefix) {
+		return `${prefix}-${this.identity}-${++data.sequence}`;
+	}
+	item(data, id) {
+		input(() => parseWork(identifier, id, "id"));
+		let item = data.items.get(id);
+		if (!item) throw new WorkError({
+			reason: "not-found",
+			message: "This work item does not exist."
+		});
+		return item;
+	}
+	thread(data, id) {
+		input(() => parseWork(identifier, id, "id"));
+		let thread = data.threads.get(id);
+		if (!thread) throw new WorkError({
+			reason: "not-found",
+			message: "This discussion does not exist."
+		});
+		return thread;
+	}
+	done(item) {
+		let status = valueByRole(item, this.schema, "status");
+		return typeof status === "string" && ["done", "cancelled"].includes(statusCategory(this.schema, status) ?? "");
+	}
+	view(data, id) {
+		let item = this.item(data, id).item;
+		let children = [...data.items.values()].filter((row) => row.item.relations.some((relation) => relation.direction === "out" && relation.item.id === id && this.schema.relations.find((kind) => kind.type === relation.type)?.kind === "parent"));
+		let discussion = [...data.threads.values()].filter((thread) => thread.itemIds.includes(id)).reduce((count, thread) => count + thread.messageCount, 0);
+		let blocked = item.relations.some((relation) => relation.direction === "out" && this.schema.relations.find((kind) => kind.type === relation.type)?.kind === "blocks" && !this.done(this.item(data, relation.item.id).item));
+		return output(() => parseWorkItem({
+			...item,
+			counts: {
+				...this.schema.capabilities.discussion ? { discussion } : {},
+				children: children.length,
+				childrenDone: children.filter((row) => this.done(row.item)).length
+			},
+			...this.schema.capabilities.ready ? { ready: !this.done(item) && !blocked } : {}
+		}, this.schema));
+	}
+	save(data, value, at, summary) {
+		let prior = data.items.get(value.id);
+		let revision = this.next(data, "revision");
+		let values = { ...value.values };
+		for (let [role, entry] of [
+			["identifier", value.id],
+			["revision", revision],
+			["updated", at],
+			...!prior ? [["created", at]] : []
+		]) {
+			let field = this.schema.fields.find((field) => field.role === role);
+			if (field) values[field.id] = entry;
+		}
+		let item = output(() => parseWorkItem({
+			...value,
+			revision,
+			values
+		}, this.schema));
+		let row = prior ?? {
+			item,
+			history: [],
+			historyCount: 0,
+			activity: [],
+			activityCount: 0
+		};
+		row.item = item;
+		data.items.set(item.id, row);
+		item = this.view(data, item.id);
+		row.item = item;
+		row.history.unshift({
+			revision,
+			author: this.author.name,
+			at,
+			item: structuredClone(item)
+		});
+		row.history = row.history.slice(0, 50);
+		row.historyCount++;
+		row.activity.unshift({
+			id: this.next(data, "activity"),
+			actor: this.author.name,
+			at,
+			verb: prior ? "changed" : "created",
+			summary
+		});
+		row.activity = row.activity.slice(0, 200);
+		row.activityCount++;
+		return item;
+	}
+	touchThreads(data, ids, at) {
+		for (let id of new Set(ids)) this.save(data, this.item(data, id).item, at, "Discussion changed");
+	}
+	initialValues(id, at, supplied) {
+		let values = {
+			...this.defaults,
+			...supplied
+		};
+		let status = fieldByRole(this.schema, "status");
+		if (status && values[status.id] === void 0 && this.schema.statuses.length) values[status.id] = this.schema.statuses[0].value;
+		for (let role of [
+			"identifier",
+			"created",
+			"updated"
+		]) {
+			let field = fieldByRole(this.schema, role);
+			if (field) values[field.id] = role === "identifier" ? id : at;
+		}
+		return values;
+	}
+};
+//#endregion
+//#region ../work/src/server/memory-threads.ts
+/**
+* The thread adapter over an in-memory store.
+* @param store - The store shared with the work adapter.
+* @returns The `ThreadAdapter` implementation.
+*/
+function memoryThreads(store) {
+	function view(thread, brief = false) {
+		let limit = brief ? 1 : 200;
+		return output(() => parseThread({
+			...thread,
+			messages: thread.messages.slice(0, limit),
+			messagesLoaded: !brief,
+			messagesTruncated: !brief && thread.messages.length > limit
+		}));
+	}
+	function save(data, thread, at, oldIds = []) {
+		let changed = {
+			...thread,
+			revision: store.next(data, "thread-revision"),
+			updatedAt: new Date(Math.max(Date.parse(at), Date.parse(thread.updatedAt))).toISOString(),
+			messageCount: thread.messages.length
+		};
+		let result = view(changed);
+		data.threads.set(changed.id, changed);
+		store.touchThreads(data, [...oldIds, ...changed.itemIds], at);
+		return result;
+	}
+	function snapshot(data, filter) {
+		let threads = [...data.threads.values()].filter((thread) => {
+			if (filter.itemId && !thread.itemIds.includes(filter.itemId)) return false;
+			let kind = thread.anchor ? "type" in thread.anchor ? "code" : "canvas" : null;
+			if (filter.anchorKind && filter.anchorKind !== kind) return false;
+			return !filter.pagePath || thread.anchor && !("type" in thread.anchor) && thread.anchor.pagePath === filter.pagePath;
+		});
+		return output(() => parseThreadSnapshot({
+			connection: {
+				state: "ready",
+				adapter: store.schema.adapter
+			},
+			capabilities: store.capabilities,
+			threads: threads.slice(0, MAX_THREADS).map((thread) => view(thread, true)),
+			truncated: threads.length > MAX_THREADS
+		}));
+	}
+	function link(root, id, ids, expectedRevision, remove) {
+		return store.run(root, true, (data, at) => {
+			if (!store.capabilities.link) refused("This adapter does not allow linking discussions.");
+			let request = input(() => parseThreadLinkInput({
+				itemIds: ids,
+				expectedRevision
+			}));
+			let thread = store.thread(data, id);
+			expected(thread, request.expectedRevision);
+			for (let id of request.itemIds) store.item(data, id);
+			let itemIds = remove ? thread.itemIds.filter((id) => !request.itemIds.includes(id)) : [.../* @__PURE__ */ new Set([...thread.itemIds, ...request.itemIds])];
+			if (itemIds.length > 100) refused("This discussion has too many linked work items.");
+			if (!thread.anchor && !itemIds.length) refused("An unanchored discussion needs a linked work item.");
+			return save(data, {
+				...thread,
+				itemIds
+			}, at, thread.itemIds);
+		});
+	}
+	return {
+		watch: (root) => store.watch(root),
+		list: (root, value) => store.run(root, false, (data) => snapshot(data, input(() => parseThreadFilter(value)))),
+		get: (root, id) => store.run(root, false, (data) => view(store.thread(data, id))),
+		create: (root, value, author) => store.run(root, true, (data, at) => {
+			if (!store.capabilities.create) refused("This adapter does not allow creating discussions.");
+			let request = input(() => parseThreadInput(value));
+			let trusted = input(() => parseMessageAuthor(author));
+			for (let id of request.itemIds) store.item(data, id);
+			return save(data, {
+				id: store.next(data, "thread"),
+				revision: null,
+				status: "open",
+				anchor: request.anchor,
+				itemIds: request.itemIds,
+				messages: [{
+					id: store.next(data, "message"),
+					body: request.body,
+					author: trusted,
+					createdAt: at,
+					parentId: null
+				}],
+				messageCount: 1,
+				messagesLoaded: true,
+				messagesTruncated: false,
+				createdAt: at,
+				updatedAt: at
+			}, at);
+		}),
+		reply: (root, id, value, author) => store.run(root, true, (data, at) => {
+			if (!store.capabilities.reply) refused("This adapter does not allow replying to discussions.");
+			let request = input(() => parseThreadReplyInput(value));
+			let trusted = input(() => parseMessageAuthor(author));
+			let thread = store.thread(data, id);
+			expected(thread, request.expectedRevision);
+			if (request.parentId && !thread.messages.some((message) => message.id === request.parentId)) refused("The reply parent must belong to this discussion.");
+			return save(data, {
+				...thread,
+				messages: [...thread.messages, {
+					id: store.next(data, "message"),
+					body: request.body,
+					author: trusted,
+					createdAt: at,
+					parentId: request.parentId
+				}]
+			}, at);
+		}),
+		setStatus: (root, id, status, expectedRevision) => store.run(root, true, (data, at) => {
+			if (!store.capabilities.status) refused("This adapter does not allow changing discussion status.");
+			let request = input(() => parseThreadStatusInput({
+				status,
+				expectedRevision
+			}));
+			let thread = store.thread(data, id);
+			expected(thread, request.expectedRevision);
+			return save(data, {
+				...thread,
+				status: request.status
+			}, at);
+		}),
+		deleteMessage: (root, id, value, author) => store.run(root, true, (data, at) => {
+			if (!store.capabilities.delete) refused("This adapter does not allow deleting messages.");
+			let request = input(() => parseThreadDeleteInput(value));
+			let trusted = input(() => parseMessageAuthor(author));
+			let thread = store.thread(data, id);
+			expected(thread, request.expectedRevision);
+			let refusal = messageDeletionRefusal(thread.messages, request.messageId, trusted.id);
+			if (refusal === "missing") throw new WorkError({
+				reason: "not-found",
+				message: messageDeletionRefusals.missing
+			});
+			if (refusal) refused(messageDeletionRefusals[refusal]);
+			if (thread.messages[0].id === request.messageId) {
+				data.threads.delete(id);
+				store.touchThreads(data, thread.itemIds, at);
+				return null;
+			}
+			return save(data, {
+				...thread,
+				messages: withoutMessages(thread.messages, [request.messageId])
+			}, at);
+		}),
+		link: (root, id, ids, revision) => link(root, id, ids, revision, false),
+		unlink: (root, id, ids, revision) => link(root, id, ids, revision, true)
+	};
+}
+//#endregion
+//#region ../work/src/server/memory-actions.ts
+/**
+* Computes what a declared action changes on an item, using its custom implementation or the
+* built-in status, claim and relation behaviour.
+* @param store - The memory store, with its schema, author and action implementations.
+* @param item - The item the action runs on.
+* @param action - The action's declaration.
+* @param values - The action's validated input.
+* @param at - When the action runs, for close timestamps.
+* @returns The new values or outgoing relations.
+*/
+function actionChange(store, item, action, values, at) {
+	let custom = store.options.actions?.[action.id];
+	if (custom) return custom(structuredClone({
+		item,
+		input: values,
+		schema: store.schema,
+		author: store.author
+	}));
+	let patch = {};
+	let status = fieldByRole(store.schema, "status");
+	if (action.kind === "close" || action.kind === "reopen" || action.kind === "transition") {
+		if (!status) refused("This schema has no status field.");
+		let destination = action.kind === "transition" ? values[action.input?.find((field) => field.role === "status" || field.kind === "status")?.id ?? ""] : store.schema.statuses.find((status) => action.kind === "close" ? status.category === "done" : ["unstarted", "backlog"].includes(status.category))?.value;
+		if (typeof destination !== "string" || !store.schema.statuses.some((status) => status.value === destination)) refused("This action has no valid destination status.");
+		patch[status.id] = destination;
+		let closed = fieldByRole(store.schema, "closed");
+		if (closed && action.kind === "close") patch[closed.id] = at;
+		if (closed && !closed.required && action.kind === "reopen") patch[closed.id] = null;
+		let reason = fieldByRole(store.schema, "closeReason");
+		let reasonInput = action.input?.find((field) => field.role === "closeReason");
+		if (reason && reasonInput && values[reasonInput.id] !== void 0) patch[reason.id] = values[reasonInput.id];
+		return { values: patch };
+	}
+	if (action.kind === "claim" || action.kind === "unclaim") {
+		let assignee = fieldByRole(store.schema, "assignee");
+		if (!assignee) refused("This schema has no assignee field.");
+		let current = item.values[assignee.id];
+		if (action.kind === "claim" && current !== null && current !== void 0 && current !== "" && !(Array.isArray(current) && !current.length) && !(typeof current === "string" && current === store.author.name) && !(typeof current === "object" && !Array.isArray(current) && current.id === store.author.id)) refused("This work item is already assigned.");
+		let person = {
+			id: store.author.id,
+			name: store.author.name,
+			email: store.author.email
+		};
+		let claimed = action.kind === "claim";
+		if (assignee.kind === "person") patch[assignee.id] = claimed ? person : null;
+		else if (assignee.kind === "people") patch[assignee.id] = claimed ? [person] : [];
+		else if (assignee.kind === "text") patch[assignee.id] = claimed ? person.name : "";
+		else refused("This assignee field cannot represent a claim.");
+		return { values: patch };
+	}
+	if (action.kind === "relate" || action.kind === "unrelate") {
+		let targetField = action.input?.find((field) => field.kind === "item");
+		if (!targetField) refused("A relation action requires an item input.");
+		let target = input(() => parseWorkItemRef(values[targetField.id]));
+		let editable = store.schema.relations.filter((relation) => relation.editable);
+		let relationField = action.input?.find((field) => field.kind === "enum");
+		let type = relationField ? values[relationField.id] : editable.length === 1 ? editable[0].type : void 0;
+		if (typeof type !== "string" || !editable.some((relation) => relation.type === type)) refused("Select an editable relation type.");
+		let remaining = item.relations.filter((relation) => !(relation.direction === "out" && relation.type === type && relation.item.id === target.id));
+		return { relations: action.kind === "unrelate" ? remaining : [...remaining, {
+			type,
+			direction: "out",
+			item: target
+		}] };
+	}
+	refused("This action needs an implementation.");
+}
+function reference(store, item) {
+	let title = valueByRole(item, store.schema, "title");
+	let status = valueByRole(item, store.schema, "status");
+	return {
+		id: item.id,
+		...typeof title === "string" ? { title: title.slice(0, 1e3) } : {},
+		...typeof status === "string" ? { status } : {}
+	};
+}
+/**
+* Rebuilds every item's incoming relations and link summaries from the outgoing ones, refusing
+* self-links and parent or blocking cycles, and saves the items that changed.
+* @param store - The memory store.
+* @param data - The project's items.
+* @param at - When the change happens.
+*/
+function reconcileRelations(store, data, at) {
+	let incoming = /* @__PURE__ */ new Map();
+	for (let row of data.items.values()) for (let relation of row.item.relations.filter((relation) => relation.direction === "out")) {
+		store.item(data, relation.item.id);
+		if (relation.item.id === row.item.id) refused("A work item cannot relate to itself.");
+		let relations = incoming.get(relation.item.id) ?? [];
+		relations.push({
+			type: relation.type,
+			direction: "in",
+			item: reference(store, row.item)
+		});
+		incoming.set(relation.item.id, relations);
+		let kind = store.schema.relations.find((kind) => kind.type === relation.type)?.kind;
+		if (kind !== "parent" && kind !== "blocks") continue;
+		let pending = [relation.item.id];
+		let seen = /* @__PURE__ */ new Set();
+		while (pending.length) {
+			let id = pending.pop();
+			if (id === row.item.id) refused("This relationship would create a cycle.");
+			if (seen.has(id)) continue;
+			seen.add(id);
+			for (let edge of store.item(data, id).item.relations) if (edge.direction === "out" && edge.type === relation.type) pending.push(edge.item.id);
+		}
+	}
+	for (let row of data.items.values()) {
+		let relations = [...row.item.relations.filter((relation) => relation.direction === "out").map((relation) => ({
+			...relation,
+			item: reference(store, store.item(data, relation.item.id).item)
+		})), ...incoming.get(row.item.id) ?? []];
+		if (JSON.stringify(row.item.relations) !== JSON.stringify(relations)) store.save(data, {
+			...row.item,
+			relations
+		}, at, "Relationships changed");
+	}
+}
+//#endregion
+//#region ../work/src/server/memory-work.ts
+var actionResult = strict({
+	values: any(),
+	relations: any()
+});
+/**
+* The work adapter over an in-memory store.
+* @param store - The store shared with the thread adapter.
+* @returns The `WorkAdapter` implementation.
+*/
+function memoryWork(store) {
+	let schema = store.schema;
+	let connection = {
+		state: "ready",
+		adapter: schema.adapter
+	};
+	function detail(data, id) {
+		let row = store.item(data, id);
+		let messages = [...data.threads.values()].filter((thread) => thread.itemIds.includes(id)).flatMap((thread) => thread.messages);
+		return output(() => parseWorkDetail({
+			connection,
+			item: store.view(data, id),
+			discussion: schema.capabilities.discussion ? available(messages, 200) : unsupported(),
+			history: schema.capabilities.history ? available(row.history, 50, row.historyCount) : unsupported(),
+			activity: schema.capabilities.activity ? available(row.activity, 200, row.activityCount) : unsupported()
+		}, schema));
+	}
+	function result(data, id) {
+		return output(() => parseWorkMutationResult({ item: store.view(data, id) }, schema));
+	}
+	return {
+		watch: (root) => store.watch(root),
+		describe: (root) => store.run(root, false, () => connection),
+		schema: (root) => store.run(root, false, () => schema),
+		list: (root, value) => store.run(root, false, (data) => {
+			let query = input(() => parseWorkQuery(value));
+			let search = query.search?.trim().toLowerCase();
+			let rows = [...data.items.values()].map((row) => row.item).filter((item) => {
+				if (query.status && valueByRole(item, schema, "status") !== query.status) return false;
+				return !search || [item.id, ...Object.values(item.values).filter((value) => typeof value === "string")].some((value) => value.toLowerCase().includes(search));
+			});
+			let items = rows.slice(0, query.limit).map((row) => {
+				let item = store.view(data, row.id);
+				return {
+					...item,
+					values: Object.fromEntries(Object.entries(item.values).filter(([key]) => schema.fields.find((field) => field.id === key)?.kind !== "markdown")),
+					contentLoaded: false
+				};
+			});
+			return output(() => parseWorkSnapshot({
+				connection,
+				items,
+				truncated: rows.length > query.limit,
+				schemaVersion: schema.adapter.version
+			}, schema));
+		}),
+		get: (root, id) => store.run(root, false, (data) => detail(data, id)),
+		section: (root, id, sectionId) => store.run(root, false, (data) => {
+			input(() => parseWork(identifier, sectionId, "sectionId"));
+			let item = store.view(data, id);
+			let declared = schema.sections.find((section) => section.id === sectionId);
+			if (!declared) return {
+				kind: "custom",
+				data: unsupported()
+			};
+			let custom = store.options.sections?.[sectionId];
+			let result;
+			if (custom) result = custom(structuredClone(item));
+			else if (declared.kind === "activity") result = {
+				kind: "activity",
+				data: schema.capabilities.activity ? available(store.item(data, id).activity, 200, store.item(data, id).activityCount) : unsupported()
+			};
+			else if (declared.kind === "history") result = {
+				kind: "history",
+				data: schema.capabilities.history ? available(store.item(data, id).history, 50, store.item(data, id).historyCount) : unsupported()
+			};
+			else if (declared.kind === "metadata") result = {
+				kind: "metadata",
+				data: available([item.extra], 1)
+			};
+			else result = {
+				kind: declared.kind,
+				data: unsupported()
+			};
+			return output(() => {
+				if (result.kind !== declared.kind) throw new TypeError("The section renderer changed.");
+				return parseSectionData(result, schema);
+			});
+		}),
+		create: (root, value) => store.run(root, true, (data, at) => {
+			if (!schema.capabilities.create) refused("This adapter does not allow creating work items.");
+			let request = input(() => parseWorkCreate(value, schema));
+			let id = store.next(data, "work");
+			store.save(data, {
+				id,
+				revision: null,
+				values: store.initialValues(id, at, request.values),
+				relations: [],
+				counts: {},
+				contentLoaded: true,
+				extra: null
+			}, at, "Work item created");
+			return result(data, id);
+		}),
+		readItemData: (root, id, key) => store.run(root, false, (data) => {
+			let row = store.item(data, id);
+			return {
+				value: row.data?.[key] ?? null,
+				revision: row.item.revision
+			};
+		}),
+		writeItemData: (root, id, key, value, expectedRevision) => store.run(root, true, (data, at) => {
+			let row = store.item(data, id);
+			expected(row.item, expectedRevision);
+			row.data = {
+				...row.data,
+				[key]: value
+			};
+			let { run: _run, ...rest } = row.item;
+			let run = key === "budRun" ? workRunSummary(value) : row.item.run;
+			return { revision: store.save(data, run ? {
+				...rest,
+				run
+			} : rest, at, "Bud record updated").revision };
+		}),
+		update: (root, id, patch, expectedRevision) => store.run(root, true, (data, at) => {
+			if (!schema.capabilities.update) refused("This adapter does not allow editing work items.");
+			let request = input(() => parseWorkUpdate({
+				values: patch,
+				expectedRevision
+			}, schema));
+			let item = store.item(data, id).item;
+			expected(item, request.expectedRevision);
+			store.save(data, {
+				...item,
+				values: {
+					...item.values,
+					...request.values
+				}
+			}, at, "Work item updated");
+			reconcileRelations(store, data, at);
+			return result(data, id);
+		}),
+		act: (root, id, actionId, values, expectedRevision) => store.run(root, true, (data, at) => {
+			let request = input(() => parseWorkActionInput({
+				action: actionId,
+				input: values,
+				expectedRevision
+			}, schema));
+			let item = store.item(data, id).item;
+			expected(item, request.expectedRevision);
+			let action = schema.actions.find((action) => action.id === request.action);
+			let changed = actionChange(store, item, action, request.input, at);
+			output(() => parseWork(actionResult, changed, "actionResult"));
+			let next = {
+				...item,
+				values: {
+					...item.values,
+					...changed.values
+				},
+				relations: changed.relations ?? item.relations
+			};
+			store.save(data, next, at, action.label);
+			reconcileRelations(store, data, at);
+			return result(data, id);
+		})
+	};
+}
+//#endregion
+//#region ../work/src/server/memory.ts
+/**
+* Creates isolated work and discussion services for each layer and project root.
+* @param options - The schema, complete seed records and trusted behavior for this adapter.
+* @returns A layer with atomic in-memory writes and no filesystem or process requirements.
+*/
+function memoryAdapterLayer(options) {
+	return effectContext(try_({
+		try: () => {
+			let store = new MemoryStore(options);
+			return make(WorkAdapter, memoryWork(store)).pipe(add(ThreadAdapter, memoryThreads(store)));
+		},
+		catch: (cause) => new WorkError({
+			reason: "input",
+			message: "The memory adapter configuration is invalid.",
+			cause
+		})
+	}));
+}
+//#endregion
+export { WorkError as a, WorkAdapter as i, parseThreadImport as n, ThreadAdapter as r, memoryAdapterLayer as t };