@bud.sh/app 0.5.0 → 0.6.0

package/dist/node/assets/config-9_jWwNBh.js

@@ -0,0 +1,1067 @@
+import { any, array, boolean, createSchema, defaulted, enum_, fail, number, object, optional, parseSafe, string } from "remix/data-schema";
+import { RoutePattern } from "remix/route-pattern";
+//#region ../project/src/lib/validate.ts
+var errors = /* @__PURE__ */ new WeakMap();
+/**
+* Validates config, throwing its first problem as the `Error` the config checks report.
+* @param schema - The config schema.
+* @param value - The project's untrusted setting.
+* @returns The validated, normalized setting.
+*/
+function parseConfig(schema, value) {
+	let result = parseSafe(schema, value, { abortEarly: true });
+	if (result.success) return result.value;
+	let issue = result.issues[0];
+	throw errors.get(issue) ?? new Error(issue.message);
+}
+/**
+* Reports any failure of `schema` with one message.
+* @param schema - The schema to run.
+* @param message - The message for any of its failures.
+* @returns The described schema.
+*/
+function described(schema, message) {
+	return createSchema((value, context) => {
+		let result = schema["~run"](value, context);
+		return result.issues ? fail(message, context.path) : result;
+	});
+}
+/**
+* Applies a rule after `schema` validates.
+* @param schema - The schema to run first.
+* @param rule - Returns a message, or undefined when the value is valid.
+* @returns The checked schema.
+*/
+function check(schema, rule) {
+	return createSchema((value, context) => {
+		let result = schema["~run"](value, context);
+		if (result.issues) return result;
+		let message = rule(result.value);
+		return message === void 0 ? result : fail(message, context.path);
+	});
+}
+/**
+* Validates with a function that throws, such as a URL or route map parser, keeping its error.
+* @param schema - The schema to run first.
+* @param parse - Turns its value into the output, or throws.
+* @returns The delegating schema.
+*/
+function delegate(schema, parse) {
+	return createSchema((value, context) => {
+		let result = schema["~run"](value, context);
+		if (result.issues) return result;
+		try {
+			return { value: parse(result.value) };
+		} catch (error) {
+			if (!(error instanceof Error)) throw error;
+			let failure = fail(error.message, context.path);
+			errors.set(failure.issues[0], error);
+			return failure;
+		}
+	});
+}
+/**
+* Chooses a schema from the unvalidated value.
+* @param choose - Picks the schema for a value.
+* @returns The selecting schema.
+*/
+function select(choose) {
+	return createSchema((value, context) => choose(value)["~run"](value, context));
+}
+/**
+* Substitutes a default for null or undefined.
+* @param schema - The schema for present values.
+* @param value - Makes the default.
+* @returns The schema with its default.
+*/
+function fallback(schema, value) {
+	return createSchema((input, context) => input == null ? { value: value() } : schema["~run"](input, context));
+}
+/**
+* A settings object that names its unsupported keys before validating its fields.
+* @param name - The setting's name in messages, such as `previews`.
+* @param shape - The schema for each supported key.
+* @returns The settings schema.
+*/
+function settings(name, shape) {
+	let schema = object(shape);
+	return createSchema((value, context) => {
+		if (!value || typeof value !== "object" || Array.isArray(value)) return fail(`${name} must be an object.`, context.path);
+		for (let key of Object.keys(value)) if (!Object.hasOwn(shape, key)) return fail(`${name}.${key} is not a supported setting.`, [...context.path, key]);
+		return schema["~run"](value, context);
+	});
+}
+/**
+* A list whose length is checked before its entries.
+* @param item - The schema for each entry.
+* @param message - The message when it is not a list or is too short.
+* @param minimum - The fewest entries it may have.
+* @returns The list schema.
+*/
+function list(item, message, minimum = 0) {
+	let items = array(item);
+	return createSchema((value, context) => !Array.isArray(value) || value.length < minimum ? fail(message, context.path) : items["~run"](value, context));
+}
+//#endregion
+//#region ../project/src/lib/files.ts
+/** The Files settings, with their defaults filled in. */
+var BudFilesSchema = defaulted(settings("files", { edit: fallback(described(boolean(), "files.edit must be true or false."), () => true) }), () => ({ edit: true }));
+//#endregion
+//#region ../project/src/lib/flows.ts
+var message$1 = "flows must be [{ id, title, start, script, steps: [{ id, title }], block? }] with short ids, local paths and unique steps.";
+var slug = (value) => typeof value === "string" && /^[a-z0-9][a-z0-9-]{0,62}$/.test(value);
+var text = (value) => typeof value === "string" && value.trim() !== "" && value.length <= 200;
+function flow(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	let { id, title, start, script, steps, block = [] } = value;
+	if (!slug(id) || !text(title) || !text(script) || script.includes("\0")) return null;
+	if (typeof start !== "string" || !start.startsWith("/") || start.startsWith("//")) return null;
+	if (new URL(start, "http://bud.invalid").origin !== "http://bud.invalid") return null;
+	if (!Array.isArray(steps) || !steps.length || steps.length > 50) return null;
+	let resolved = steps.map((step) => {
+		let { id: stepId, title: stepTitle } = step ?? {};
+		return slug(stepId) && text(stepTitle) ? {
+			id: stepId,
+			title: stepTitle.trim()
+		} : null;
+	});
+	if (resolved.some((step) => !step)) return null;
+	let ids = resolved.map((step) => step.id);
+	if (new Set(ids).size !== ids.length) return null;
+	if (!Array.isArray(block) || block.some((part) => !text(part))) return null;
+	return {
+		id,
+		title: title.trim(),
+		start,
+		script: script.trim(),
+		steps: resolved,
+		block
+	};
+}
+/** The flows, none when omitted. */
+var BudFlowsSchema = createSchema((value, context) => {
+	if (value === void 0) return { value: [] };
+	if (!Array.isArray(value)) return fail(message$1, context.path);
+	let flows = value.map(flow);
+	if (flows.some((resolved) => !resolved)) return fail(message$1, context.path);
+	let ids = flows.map((resolved) => resolved.id);
+	if (new Set(ids).size !== ids.length) return fail(message$1, context.path);
+	return { value: flows };
+});
+/**
+* Where a flow's step is pictured: a route of its own, named `<flow>/<step>`, in a group named
+* after the flow. Its path is the start page with the step as its fragment, unique among routes.
+* @param flow - The flow.
+* @param step - One of its steps.
+* @returns The step's route.
+*/
+function flowStepRoute(flow, step) {
+	return {
+		id: `${flow.id}/${step.id}`,
+		path: `${flow.start.replace(/#.*$/, "")}#${flow.id}-${step.id}`,
+		title: step.title,
+		group: flow.title,
+		flow: {
+			id: flow.id,
+			step: step.id
+		}
+	};
+}
+//#endregion
+//#region ../project/src/lib/logo.ts
+/** The image types a logo may be, by extension. */
+var LOGO_TYPES = Object.freeze({
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".webp": "image/webp",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".ico": "image/x-icon"
+});
+var logoMessage = "logo must be an image path inside the project (.svg, .png, .webp, .jpg, .gif or .ico), or { light, dark }.";
+function image(value) {
+	if (typeof value !== "string" || value.length > 1024 || value.includes("\0")) return null;
+	let path = value.trim().replaceAll("\\", "/");
+	if (!path || path.startsWith("/") || /^[a-z]:/i.test(path)) return null;
+	if (path.split("/").includes("..")) return null;
+	let extension = path.slice(path.lastIndexOf(".")).toLowerCase();
+	return Object.hasOwn(LOGO_TYPES, extension) ? path : null;
+}
+/** A logo in its one resolved form, or null for Bud's own mark. */
+var BudLogoSchema = createSchema((value, context) => {
+	if (value === void 0) return { value: null };
+	let light = image(typeof value === "object" && value ? value.light : value);
+	let raw = typeof value === "object" && value ? value.dark : void 0;
+	let dark = raw === void 0 ? null : image(raw);
+	let keys = typeof value === "object" && value ? Object.keys(value) : [];
+	if (light && (raw === void 0 || dark) && keys.every((key) => key === "light" || key === "dark")) return { value: {
+		light,
+		dark
+	} };
+	return fail(logoMessage, context.path);
+});
+//#endregion
+//#region ../project/src/lib/factory.ts
+/** The steps of a factory task, each a status in the project's task store. */
+var FACTORY_STATUS_ROLES = [
+	"open",
+	"inProgress",
+	"needsApproval",
+	"readyToMerge",
+	"merged"
+];
+/** The default status names, as Beads stores them. */
+var DEFAULT_FACTORY_STATUSES = {
+	open: "open",
+	inProgress: "in_progress",
+	needsApproval: "needs_approval",
+	readyToMerge: "ready_to_merge",
+	merged: "merged"
+};
+/**
+* The model an agent uses when the config names none: DeepSeek V4.1 Flash on OpenCode Zen's free
+* tier, which needs no key; enough for trying the factory, slower than a paid model.
+*/
+var DEFAULT_FACTORY_MODEL = "opencode/deepseek-v4.1-flash-free";
+var factoryMessage = "factory must be false or an object with statuses, setup, dev, branchPrefix, sleepAfter, instructions and push as documented.";
+var statusName = /^[A-Za-z][\w-]{0,63}$/;
+var keys = [
+	"statuses",
+	"setup",
+	"dev",
+	"branchPrefix",
+	"sleepAfter",
+	"instructions",
+	"push"
+];
+var modulePath$1 = /^\.\/(?!.*(?:^|\/)\.\.?(?:\/|$))[\w./-]+$/;
+function short(value, max) {
+	return typeof value === "string" && value.trim().length > 0 && value.length <= max;
+}
+function push(value) {
+	if (value === void 0) value = {};
+	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+	let { remote = "origin", credential = null, username = "x-access-token", ...rest } = value;
+	if (Object.keys(rest).length || typeof remote !== "string" || !/^[\w][\w.-]{0,99}$/.test(remote) || !(credential === null || typeof credential === "string" && /^[A-Z_][A-Z0-9_]{0,99}$/.test(credential)) || typeof username !== "string" || !/^[\w][\w.@-]{0,99}$/.test(username)) return void 0;
+	return {
+		remote,
+		credential,
+		username
+	};
+}
+function dev(value) {
+	if (value === void 0) return null;
+	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+	let { command, port, path = "/", env = {}, ...rest } = value;
+	if (Object.keys(rest).length || !short(command, 4e3)) return void 0;
+	if (typeof path !== "string" || !/^\/(?!\/)[^\s#?]{0,500}$/.test(path)) return void 0;
+	if (typeof port !== "number" || !Number.isInteger(port) || port < 1 || port > 65535) return void 0;
+	if (!env || typeof env !== "object" || Array.isArray(env)) return void 0;
+	let entries = Object.entries(env);
+	if (entries.some(([key, entry]) => !/^[A-Z_][A-Z0-9_]*$/.test(key) || typeof entry !== "string")) return void 0;
+	return {
+		command,
+		port,
+		path,
+		env: Object.fromEntries(entries)
+	};
+}
+/** `factory` in bud.config.ts: off by default, with Beads' status names unless mapped. */
+var BudFactorySchema = createSchema((value, context) => {
+	if (value === void 0 || value === false) return { value: null };
+	if (!value || typeof value !== "object" || Array.isArray(value)) return fail(factoryMessage, context.path);
+	let input = value;
+	let statuses = input.statuses ?? {};
+	if (Object.keys(input).some((key) => !keys.includes(key)) || !statuses || typeof statuses !== "object") return fail(factoryMessage, context.path);
+	let given = statuses;
+	if (Object.keys(given).some((key) => !FACTORY_STATUS_ROLES.includes(key))) return fail(factoryMessage, context.path);
+	let resolved = { ...DEFAULT_FACTORY_STATUSES };
+	for (let role of FACTORY_STATUS_ROLES) {
+		let name = given[role];
+		if (name === void 0) continue;
+		if (typeof name !== "string" || !statusName.test(name)) return fail(factoryMessage, context.path);
+		resolved[role] = name;
+	}
+	if (new Set(Object.values(resolved)).size !== FACTORY_STATUS_ROLES.length) return fail(factoryMessage, context.path);
+	let server = dev(input.dev);
+	let pushing = push(input.push);
+	if (server === void 0 || pushing === void 0) return fail(factoryMessage, context.path);
+	let prefix = input.branchPrefix ?? "dev/";
+	if (typeof prefix !== "string" || !/^[a-z0-9][a-z0-9._-]*\/$/i.test(prefix) || prefix.length > 50 || input.sleepAfter !== void 0 && !(typeof input.sleepAfter === "number" && Number.isInteger(input.sleepAfter) && input.sleepAfter >= 0 && input.sleepAfter <= 1440) || input.setup !== void 0 && !short(input.setup, 4e3) || input.instructions !== void 0 && !(typeof input.instructions === "string" && modulePath$1.test(input.instructions))) return fail(factoryMessage, context.path);
+	return { value: {
+		statuses: resolved,
+		sandbox: null,
+		agent: {
+			harness: "bud:opencode",
+			model: DEFAULT_FACTORY_MODEL,
+			keys: []
+		},
+		setup: input.setup ?? null,
+		dev: server,
+		branchPrefix: prefix,
+		sleepAfter: input.sleepAfter ?? 5,
+		instructions: input.instructions ?? null,
+		push: pushing
+	} };
+});
+/**
+* What the factory keeps of a harness plugin: its name, model and keys, checked.
+* @param name - The plugin's name.
+* @param harness - The plugin's `harness`.
+* @returns The agent settings for the resolved factory.
+*/
+function factoryAgent(name, harness) {
+	let { model, keys = [] } = harness ?? {};
+	if (!short(model, 200) || !Array.isArray(keys) || keys.length > 20 || keys.some((key) => typeof key !== "string" || !/^[A-Z_][A-Z0-9_]{0,99}$/.test(key))) throw new Error(`Plugin ${name}: harness needs a model and at most 20 keys naming server environment variables, such as DEEPSEEK_API_KEY.`);
+	return {
+		harness: name,
+		model,
+		keys: [...new Set(keys)]
+	};
+}
+//#endregion
+//#region ../project/src/lib/theme.ts
+/**
+* Bud's colors and shadows a theme may set, as `--bud-<name>` in its styles. Everything else
+* Bud derives from them.
+*/
+var THEME_TOKENS = Object.freeze([
+	"background",
+	"shell",
+	"main",
+	"canvas",
+	"panel",
+	"board",
+	"editor",
+	"editor-tabs",
+	"foreground",
+	"muted",
+	"primary",
+	"primary-hover",
+	"primary-foreground",
+	"border",
+	"tab-divider",
+	"hover",
+	"selected",
+	"control",
+	"control-active",
+	"control-selected",
+	"card",
+	"menu",
+	"menu-hover",
+	"card-frame",
+	"card-surface",
+	"card-border",
+	"card-frame-border",
+	"card-badge",
+	"overlay-shadow",
+	"tooltip",
+	"board-control",
+	"board-control-hover",
+	"board-card",
+	"control-elevation",
+	"board-elevation",
+	"board-card-elevation",
+	"card-elevation",
+	"board-card-lift",
+	"frame-control",
+	"modal-elevation",
+	"segment-elevation",
+	"control-open-elevation",
+	"board-segment",
+	"scrollbar",
+	"focus",
+	"scrollbar-hover",
+	"tooltip-border",
+	"tooltip-shadow",
+	"terminal",
+	"terminal-foreground",
+	"terminal-cursor",
+	"terminal-selection",
+	"terminal-black",
+	"terminal-red",
+	"terminal-green",
+	"terminal-yellow",
+	"terminal-blue",
+	"terminal-magenta",
+	"terminal-cyan",
+	"terminal-white",
+	"terminal-bright-black",
+	"terminal-bright-red",
+	"terminal-bright-green",
+	"terminal-bright-yellow",
+	"terminal-bright-blue",
+	"terminal-bright-magenta",
+	"terminal-bright-cyan",
+	"terminal-bright-white"
+]);
+var themeMessage = `theme must be { light, dark }, each mapping Bud's tokens (${THEME_TOKENS.slice(0, 3).join(", ")}, …) to CSS colors or shadows.`;
+function cssValue(value) {
+	if (typeof value !== "string") return null;
+	let trimmed = value.trim();
+	if (!trimmed || trimmed.length > 300) return null;
+	if (!/^[#a-zA-Z0-9(),.%\s/+-]+$/.test(trimmed) || /url\s*\(/i.test(trimmed)) return null;
+	return trimmed;
+}
+function colors(value) {
+	if (value === void 0) return {};
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	let result = {};
+	for (let [name, raw] of Object.entries(value)) {
+		let checked = cssValue(raw);
+		if (!THEME_TOKENS.includes(name) || checked === null) return null;
+		result[name] = checked;
+	}
+	return Object.freeze(result);
+}
+/** A theme in its one resolved form; Bud's own colors when absent. */
+var BudThemeSchema = createSchema((value, context) => {
+	if (value === void 0) return { value: {
+		light: {},
+		dark: {}
+	} };
+	if (!value || typeof value !== "object" || Array.isArray(value)) return fail(themeMessage, context.path);
+	let { light, dark, ...rest } = value;
+	let resolved = {
+		light: colors(light),
+		dark: colors(dark)
+	};
+	if (Object.keys(rest).length || !resolved.light || !resolved.dark) return fail(themeMessage, context.path);
+	return { value: {
+		light: resolved.light,
+		dark: resolved.dark
+	} };
+});
+//#endregion
+//#region ../project/src/lib/branches.ts
+var message = "branches must be { main?, build?: { install?, build?, serve? } } with a branch name and nonempty shell commands.";
+function branch(value) {
+	return typeof value === "string" && value.length <= 255 && /^[A-Za-z0-9._/-]+$/.test(value) && !value.startsWith("-") && !value.startsWith("/") && !value.endsWith("/") && !value.endsWith(".lock") && !value.includes("..") && !value.includes("//") ? value : null;
+}
+function command(value) {
+	return typeof value === "string" && value.trim() && value.length <= 4096 && !value.includes("\0") ? value.trim() : null;
+}
+/** The branch settings, defaults filled in. */
+var BudBranchesSchema = createSchema((value, context) => {
+	let empty = {
+		main: null,
+		install: null,
+		build: null,
+		serve: null
+	};
+	if (value === void 0) return { value: empty };
+	if (!value || typeof value !== "object" || Array.isArray(value)) return fail(message, context.path);
+	let input = value;
+	let build = input.build ?? {};
+	if (!build || typeof build !== "object" || Array.isArray(build) || Object.keys(input).some((key) => key !== "main" && key !== "build")) return fail(message, context.path);
+	let steps = build;
+	if (Object.keys(steps).some((key) => ![
+		"install",
+		"build",
+		"serve"
+	].includes(key))) return fail(message, context.path);
+	let resolved = {
+		main: input.main === void 0 ? null : branch(input.main),
+		install: steps.install === void 0 ? null : command(steps.install),
+		build: steps.build === void 0 ? null : command(steps.build),
+		serve: steps.serve === void 0 ? null : command(steps.serve)
+	};
+	if (input.main !== void 0 && !resolved.main || [
+		"install",
+		"build",
+		"serve"
+	].some((key) => steps[key] !== void 0 && !resolved[key])) return fail(message, context.path);
+	return { value: resolved };
+});
+/**
+* Validates the branch settings.
+* @param value - The config's optional `branches` setting.
+* @returns The settings with null defaults.
+*/
+function resolveBranches(value) {
+	return parseConfig(BudBranchesSchema, value);
+}
+//#endregion
+//#region ../project/src/lib/storage.ts
+/**
+* A project module named in the config: a ./ path inside the project, outside node_modules.
+* @param name - The config option, for the error message.
+* @param server - Whether it runs on the server (.server.ts) rather than in the browser.
+* @param message - What to say instead of the default when it is invalid.
+* @returns A schema for the module's path.
+*/
+function modulePath(name, server, message) {
+	let extension = server ? /\.server\.ts$/ : /\.(?:ts|tsx|js|jsx)$/;
+	return described(string().refine((value) => value.length <= 1024 && value.startsWith("./") && !/[\u0000-\u001f\u007f\\?#%]/.test(value) && extension.test(value) && (server || !/\.server\.[cm]?[jt]sx?$/.test(value)) && !value.slice(2).split("/").some((part) => !part || part === "." || part === ".." || part === "node_modules")), message ?? (server ? `${name} must be a built-in adapter or a ./ module ending in .server.ts inside the project.` : `${name} must be bud:beads or a ./ browser module ending in .ts, .tsx, .js or .jsx inside the project.`));
+}
+function store(kind) {
+	return defaulted(select((value) => value === false ? enum_([false]) : described(string().refine((name) => /^[\w@:./-]{1,100}$/.test(name)), `storage.${kind} is false, or a store named by its plugin, such as bud:beads.`)), "bud:beads");
+}
+/** The selected work and discussion stores, with Beads as the default for both. */
+var BudStorageSchema = defaulted(settings("storage", {
+	work: store("work"),
+	threads: store("threads")
+}), () => ({
+	work: "bud:beads",
+	threads: "bud:beads"
+}));
+/** Task presentation, chosen separately from its storage. */
+var BudDesignsSchema = defaulted(settings("designs", {
+	tasks: defaulted(select((value) => value === "bud:beads" ? enum_(["bud:beads"]) : modulePath("designs.tasks", false)), "bud:beads"),
+	pages: defaulted(enum_(["path", "title"]), "path")
+}), () => ({
+	tasks: "bud:beads",
+	pages: "path"
+}));
+//#endregion
+//#region ../project/src/lib/picker.ts
+var builtIn = /* @__PURE__ */ new Set([
+	"bud:dom",
+	"bud:react",
+	"bud:react-grab"
+]);
+var projectPicker = modulePath("picker", false, "picker must be bud:dom, bud:react, bud:react-grab or a ./ browser module ending in .ts, .tsx, .js or .jsx inside the project.");
+/** The picker, with Bud's DOM picker as the default. */
+var BudPickerSchema = createSchema((value, context) => {
+	if (value === void 0) return { value: {
+		name: "bud:dom",
+		module: null
+	} };
+	if (typeof value === "string" && builtIn.has(value)) return { value: {
+		name: value,
+		module: null
+	} };
+	let result = projectPicker["~run"](value, context);
+	return result.issues ? result : { value: {
+		name: result.value,
+		module: result.value
+	} };
+});
+/**
+* Validates the picker setting.
+* @param value - The config's optional `picker` setting.
+* @returns The picker and its project module, if it is the project's own.
+*/
+function resolvePicker(value) {
+	return parseConfig(BudPickerSchema, value);
+}
+//#endregion
+//#region ../project/src/lib/screen-routes.ts
+/**
+* Validates a screen's route map without importing its component module.
+* @param routes - A Remix route map shared with the screen's definition.
+* @param path - The configured screen's static path.
+* @returns Named patterns confined to the screen's path.
+*/
+function resolveScreenRoutes(routes, path) {
+	let result = [];
+	let seen = /* @__PURE__ */ new Set();
+	function visit(value, prefix) {
+		if (!value || typeof value !== "object" || Array.isArray(value) || seen.has(value)) throw new Error("Screen routes must be a Remix route map.");
+		seen.add(value);
+		for (let [key, entry] of Object.entries(value)) {
+			let name = prefix ? `${prefix}.${key}` : key;
+			if (!entry || typeof entry !== "object") throw new Error(`Screen route ${name} must be a Remix route.`);
+			if (!("pattern" in entry)) {
+				visit(entry, name);
+				continue;
+			}
+			if (!["GET", "ANY"].includes(entry.method) || typeof entry.href !== "function" || typeof entry.pattern?.source !== "string") throw new Error(`Screen route ${name} must be a GET route.`);
+			let pattern = RoutePattern.parse(entry.pattern.source);
+			let parts = pattern.toJSON();
+			let pathname = `/${parts.pathname}`;
+			if (parts.protocol || parts.hostname || parts.port || parts.pathname.split("/").some((segment) => /^\.{1,2}$/.test(decodeURIComponent(segment))) || pathname !== path && !pathname.startsWith(`${path}/`) && !pathname.startsWith(`${path}(/`)) throw new Error(`Screen route ${name} must stay under ${path}.`);
+			result.push({
+				name,
+				pattern: pattern.source
+			});
+		}
+		seen.delete(value);
+	}
+	visit(routes, "");
+	if (!result.length) throw new Error("Screen routes must contain at least one route.");
+	return result;
+}
+//#endregion
+//#region ../project/src/lib/screens.ts
+/**
+* Bud's browser of your live pages, with their comments.
+* @returns The built-in screen, ready to relabel by spreading.
+*/
+function pages() {
+	return {
+		id: "pages",
+		label: "Pages",
+		icon: "browser",
+		path: "/pages",
+		module: "bud:pages"
+	};
+}
+/**
+* Bud's canvas of every route's screenshot.
+* @returns The built-in screen, ready to relabel by spreading.
+*/
+function canvas() {
+	return {
+		id: "canvas",
+		label: "Canvas",
+		icon: "grid",
+		path: "/canvas",
+		module: "bud:canvas"
+	};
+}
+/**
+* Bud's Beads task board.
+* @returns The built-in screen, ready to relabel by spreading.
+*/
+function tasks() {
+	return {
+		id: "tasks",
+		label: "Tasks",
+		icon: "tasks",
+		path: "/tasks",
+		module: "bud:tasks"
+	};
+}
+/**
+* Bud's file browser and review.
+* @returns The built-in screen, ready to relabel by spreading.
+*/
+function files() {
+	return {
+		id: "files",
+		label: "Files",
+		icon: "files",
+		path: "/files",
+		module: "bud:files"
+	};
+}
+/** The screens shown when the config doesn't list any. */
+var defaultScreens = [
+	pages(),
+	canvas(),
+	tasks(),
+	files()
+];
+var builtIns = new Map(defaultScreens.map((screen) => [screen.module, screen]));
+/** First path segments owned by Bud's routes, its development server and its public assets. */
+var reservedScreenPaths = [
+	"/comments",
+	...defaultScreens.map((screen) => screen.path),
+	"/api",
+	"/health",
+	"/__bud",
+	"/assets",
+	"/app",
+	"/src",
+	"/node_modules",
+	"/agents",
+	"/brand",
+	"/fonts",
+	"/frameworks",
+	"/licenses"
+];
+var ScreenSchema = check(described(any().refine((value) => !!value && typeof value === "object"), "Each screen must be an object."), ({ id, label, icon = "layers", module, path }) => {
+	if (typeof id !== "string" || !/^[a-z][a-z0-9-]{0,31}$/.test(id)) return "Screen ids are 1-32 lowercase letters, digits and hyphens.";
+	if (typeof label !== "string" || !label.trim()) return `Screen ${id} needs a label.`;
+	if (typeof icon !== "string" || !icon) return `Screen ${id} needs an icon name.`;
+	if (typeof module !== "string") return `Screen ${id} needs a module.`;
+	let builtIn = builtIns.get(module);
+	path ??= builtIn?.path ?? `/${id}`;
+	if (builtIn) {
+		if (id !== builtIn.id || path !== builtIn.path) return `${module} keeps id "${builtIn.id}" and path "${builtIn.path}".`;
+		return;
+	}
+	if (!/^\.\/[^\0\\]+\.(?:ts|tsx|js|jsx)$/.test(module)) return `Screen ${id} must be a ./ module ending in .ts, .tsx, .js or .jsx.`;
+	if (typeof path !== "string" || !/^\/[a-z0-9][a-z0-9-]*$/.test(path)) return `Screen ${id} needs one static path segment, such as /${id}.`;
+	if (defaultScreens.some((screen) => screen.id === id)) return `Screen id "${id}" is reserved for a built-in screen.`;
+	if (reservedScreenPaths.includes(path)) return `Bud reserves the path ${path}.`;
+});
+/** Bud's navigation in order; file and icon checks need the app and happen at startup. */
+var BudScreensSchema = defaulted(delegate(described(array(any()).refine((screens) => screens.length > 0), "screens must list at least one screen."), (screens) => {
+	let ids = /* @__PURE__ */ new Set();
+	let paths = /* @__PURE__ */ new Set();
+	return screens.map((value) => {
+		let input = parseConfig(ScreenSchema, value);
+		let { id, label, icon = "layers", module } = input;
+		let path = input.path ?? builtIns.get(module)?.path ?? `/${id}`;
+		if (ids.has(id) || paths.has(path)) throw new Error("Screen ids and paths must be unique.");
+		ids.add(id);
+		paths.add(path);
+		if (input.routes !== void 0) resolveScreenRoutes(input.routes, path);
+		return {
+			id,
+			label,
+			icon,
+			path,
+			module,
+			...input.routes === void 0 ? {} : { routes: input.routes }
+		};
+	});
+}), () => defaultScreens.map((screen) => ({ ...screen })));
+//#endregion
+//#region ../project/src/lib/plugins.ts
+var registry = globalThis;
+var key = Symbol.for("@bud.sh/project/plugins");
+registry[key] ??= /* @__PURE__ */ new WeakMap();
+var known = registry[key];
+/**
+* Remembers the plugins a resolved config came from.
+* @param config - The resolved config.
+* @param plugins - Its plugins.
+* @returns The config.
+*/
+function withPlugins(config, plugins) {
+	known.set(config, plugins);
+	return config;
+}
+function flatten(option, into) {
+	if (option === false || option === null || option === void 0) return;
+	if (Array.isArray(option)) {
+		for (let entry of option) flatten(entry, into);
+		return;
+	}
+	let plugin = option;
+	if (!plugin || typeof plugin !== "object" || typeof plugin.name !== "string" || !/^[\w@:./-]{1,100}$/.test(plugin.name)) throw new Error("Each plugin must be an object with a name such as bud:beads.");
+	if (plugin.enforce !== void 0 && plugin.enforce !== "pre" && plugin.enforce !== "post") throw new Error(`Plugin ${plugin.name}: enforce must be pre or post.`);
+	if (plugin.config !== void 0 && typeof plugin.config !== "function") throw new Error(`Plugin ${plugin.name}: config must be a function.`);
+	into.push(plugin);
+}
+function isObject(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function merge(config, partial) {
+	let merged = { ...config };
+	for (let [key, value] of Object.entries(partial)) {
+		if (key === "plugins") continue;
+		merged[key] = isObject(merged[key]) && isObject(value) ? {
+			...merged[key],
+			...value
+		} : value;
+	}
+	return merged;
+}
+/**
+* Runs the config's plugins: flattens `plugins`, orders them, applies their `config` hooks, and
+* finds which plugin provides each store, the picker, the task design and the sandbox.
+* @param value - The config module's default export.
+* @returns The config after the hooks, without `plugins`, the plugins in order and what they
+*   provide.
+*/
+function applyPlugins(value) {
+	if (!isObject(value)) return {
+		config: value,
+		plugins: [],
+		provides: none()
+	};
+	let found = [];
+	flatten(value.plugins, found);
+	let names = /* @__PURE__ */ new Set();
+	for (let plugin of found) {
+		if (names.has(plugin.name)) throw new Error(`Two plugins are named ${plugin.name}.`);
+		names.add(plugin.name);
+	}
+	let plugins = [
+		...found.filter((plugin) => plugin.enforce === "pre"),
+		...found.filter((plugin) => !plugin.enforce),
+		...found.filter((plugin) => plugin.enforce === "post")
+	];
+	let { plugins: _plugins, ...config } = value;
+	for (let plugin of plugins) {
+		let partial = plugin.config?.(config);
+		if (partial !== void 0 && partial !== null) {
+			if (!isObject(partial)) throw new Error(`Plugin ${plugin.name}: config must return an object or nothing.`);
+			config = merge(config, partial);
+		}
+	}
+	let screens = plugins.flatMap((plugin) => plugin.screens ?? []);
+	if (screens.length) config.screens = [...config.screens ?? defaultScreens.map((screen) => ({ ...screen })), ...screens];
+	let one = (key, what) => {
+		let providers = plugins.filter((plugin) => plugin[key] !== void 0);
+		if (providers.length > 1) throw new Error(`Only one plugin may provide ${what}; ${providers.map((plugin) => plugin.name).join(" and ")} both do.`);
+		return providers[0] ?? null;
+	};
+	return {
+		config,
+		plugins,
+		provides: {
+			work: one("work", "the task store"),
+			threads: one("threads", "the discussion store"),
+			picker: one("picker", "the picker"),
+			taskDesign: one("taskDesign", "the task design"),
+			sandbox: one("sandbox", "the factory’s sandboxes"),
+			harness: one("harness", "the agent harness")
+		}
+	};
+}
+function none() {
+	return {
+		work: null,
+		threads: null,
+		picker: null,
+		taskDesign: null,
+		sandbox: null,
+		harness: null
+	};
+}
+/**
+* Fails for settings that moved into plugins, naming the plugin that replaces each.
+* @param config - The config after the plugins' hooks.
+*/
+function rejectMovedSettings(config) {
+	if (!isObject(config)) return;
+	let storage = config.storage;
+	if (isObject(storage)) for (let kind of ["work", "threads"]) {
+		let value = storage[kind];
+		if (value !== void 0 && value !== false) throw new Error(`storage.${kind} no longer names a store: add the store's plugin to plugins, such as beads(), gitComments() or memory() from @bud.sh/app/plugins, or your own; storage.${kind}: false still turns it off.`);
+	}
+	if (isObject(config.designs) && config.designs.tasks !== void 0) throw new Error("designs.tasks moved into a plugin: add taskDesign(\"./your-design.tsx\") from @bud.sh/app/plugins to plugins.");
+	if (config.picker !== void 0) throw new Error("picker moved into a plugin: add reactGrab(), react() or picker(\"./your-picker.ts\") from @bud.sh/app/plugins to plugins.");
+	if (isObject(config.factory) && config.factory.sandbox !== void 0) throw new Error("factory.sandbox moved into a plugin: add local() or boat() from @bud.sh/app/plugins to plugins.");
+	if (isObject(config.factory) && config.factory.agent !== void 0) throw new Error("factory.agent moved into a plugin: add opencode({ model, keys }) from @bud.sh/app/plugins to plugins.");
+}
+/**
+* A task design from the project: a `./` browser module whose default export designs the Tasks
+* screen.
+* @param module - The module, such as `./designs/compact-card.tsx`.
+* @returns The plugin.
+*/
+function taskDesign(module) {
+	return {
+		name: `design:${module}`,
+		taskDesign: module
+	};
+}
+/**
+* A picker from the project: a `./` browser module whose default export is a picker adapter.
+* @param module - The module, such as `./bud/picker.ts`.
+* @returns The plugin.
+*/
+function picker(module) {
+	return {
+		name: `picker:${module}`,
+		picker: module
+	};
+}
+//#endregion
+//#region ../project/src/lib/previews.ts
+var readyMessage = "ready must be a CSS selector, { selector } or { expression }.";
+/** A readiness condition; a string is a selector. */
+var PreviewReadySchema = createSchema((value, context) => {
+	let ready = typeof value === "string" ? { selector: value } : value;
+	if (ready && typeof ready === "object" && !Array.isArray(ready)) {
+		let entries = Object.entries(ready);
+		let [key, text] = entries[0] ?? [];
+		if (entries.length === 1 && (key === "selector" || key === "expression") && typeof text === "string" && text.trim() && text.length <= 4096) return { value: key === "selector" ? { selector: text.trim() } : { expression: text.trim() } };
+	}
+	return fail(readyMessage, context.path);
+});
+var defaultThemes = () => ["light", "dark"];
+var defaultViewports = () => [{
+	id: "desktop",
+	name: "Desktop",
+	width: 1440,
+	height: 900,
+	mobile: false
+}];
+var viewportsMessage = "previews.viewports must list up to 4 { name, width, height?, mobile? } with distinct names, widths from 240 to 3840 and heights from 240 to 4000.";
+function viewportId(name) {
+	return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32);
+}
+var ViewportsSchema = createSchema((value, context) => {
+	if (!Array.isArray(value) || value.length === 0 || value.length > 4) return fail(viewportsMessage, context.path);
+	let viewports = [];
+	for (let entry of value) {
+		if (!entry || typeof entry !== "object" || Array.isArray(entry)) return fail(viewportsMessage, context.path);
+		let { name, width, height, mobile, ...rest } = entry;
+		let size = (pixels, from, to) => typeof pixels === "number" && Number.isInteger(pixels) && pixels >= from && pixels <= to;
+		if (Object.keys(rest).length || typeof name !== "string" || !name.trim() || name.length > 40 || !viewportId(name) || !size(width, 240, 3840) || height !== void 0 && !size(height, 240, 4e3) || mobile !== void 0 && typeof mobile !== "boolean") return fail(viewportsMessage, context.path);
+		let phone = mobile ?? width < 800;
+		viewports.push({
+			id: viewportId(name),
+			name: name.trim(),
+			width,
+			height: height ?? (phone ? Math.round(width * 844 / 390) : 900),
+			mobile: phone
+		});
+	}
+	if (new Set(viewports.map((viewport) => viewport.id)).size !== viewports.length) return fail(viewportsMessage, context.path);
+	return { value: viewports };
+});
+/** The preview settings, with their defaults filled in. */
+var BudPreviewsSchema = defaulted(settings("previews", {
+	scale: fallback(described(number().refine((scale) => Number.isInteger(scale) && scale >= 1 && scale <= 3), "previews.scale must be 1, 2 or 3."), () => 2),
+	themes: fallback(described(array(enum_(["light", "dark"])).refine((themes) => themes.length > 0 && new Set(themes).size === themes.length), "previews.themes must list light, dark or both, once each."), defaultThemes),
+	viewports: fallback(ViewportsSchema, defaultViewports),
+	ready: fallback(PreviewReadySchema, () => null),
+	readyTimeout: fallback(described(number().refine((ms) => Number.isInteger(ms) && ms >= 1e3 && ms <= 6e5), "previews.readyTimeout must be whole milliseconds from 1000 to 600000."), () => 6e4),
+	css: fallback(described(string().refine((css) => css.length <= 2e4 && !css.includes("<")), "previews.css must be CSS text without <, up to 20000 characters."), () => "")
+}), () => ({
+	scale: 2,
+	themes: defaultThemes(),
+	viewports: defaultViewports(),
+	ready: null,
+	readyTimeout: 6e4,
+	css: ""
+}));
+//#endregion
+//#region ../project/src/lib/config.ts
+/**
+* Keeps bud.config.js and bud.config.ts typed without changing their values.
+* @param config - The project's routes and development settings.
+* @returns The same configuration.
+*/
+function defineConfig(config) {
+	return config;
+}
+var objectLike = (value) => !!value && typeof value === "object";
+function section(message, shape) {
+	let schema = object(shape);
+	return createSchema((value, context) => objectLike(value) ? schema["~run"](Array.isArray(value) ? { ...value } : value, context) : fail(message, context.path));
+}
+var ConfigFields = check(section("Bud config must export an object.", {
+	routes: described(array(any()).refine((routes) => routes.length > 0), "bud.config must define at least one route."),
+	name: optional(described(string().refine((name) => !!name.trim()), "name must be a nonempty string.")),
+	target: optional(section("target must be an object.", {
+		origin: any(),
+		port: any()
+	})),
+	comments: optional(section("comments must be an object.", { remote: any() })),
+	port: any(),
+	screens: any(),
+	storage: any(),
+	designs: any(),
+	previews: any(),
+	files: any(),
+	logo: any(),
+	theme: any(),
+	locale: any(),
+	factory: any(),
+	picker: any(),
+	branches: any(),
+	flows: any()
+}), ({ target }) => {
+	if (target?.port === 0) return "target.port must be a listening port, not zero.";
+	if (target?.origin !== void 0 && (typeof target.origin !== "string" || !target.origin.trim())) return "target.origin must be an HTTP(S) origin.";
+});
+var RouteSchema = check(any().transform((input) => typeof input === "string" ? {
+	path: input,
+	title: input === "/" ? "Home" : input
+} : input), (route) => {
+	if (!route || typeof route.path !== "string" || !route.path.startsWith("/") || route.path.startsWith("//")) return "Canvas routes must be local paths beginning with a single /.";
+	if (new URL(route.path, "http://bud.invalid").origin !== "http://bud.invalid" || route.path.includes("\\")) return "Canvas routes must stay on the target origin.";
+	let id = route.id ?? routePath(route.path);
+	if (typeof id !== "string" || !id.trim()) return "Canvas route IDs and paths must be unique.";
+	if (typeof route.title !== "string" || !route.title.trim()) return "Each route needs a title.";
+	if (route.pattern !== void 0 && (typeof route.pattern !== "string" || !route.pattern.startsWith("/"))) return "A route pattern must be a path beginning with /.";
+	if (route.group !== void 0 && (typeof route.group !== "string" || !route.group.trim() || route.group.length > 120)) return "A route group must be a short name.";
+	if (route.ready !== void 0 && route.ready !== false && !parseSafe(PreviewReadySchema, route.ready).success) return "A route ready must be false, a CSS selector, { selector } or { expression }.";
+}).transform((route) => {
+	let path = routePath(route.path);
+	return {
+		id: route.id ?? path,
+		path,
+		title: route.title,
+		...route.pattern === void 0 ? {} : { pattern: route.pattern },
+		...route.group === void 0 ? {} : { group: route.group.trim() },
+		...route.ready === void 0 ? {} : { ready: route.ready === false ? null : parseConfig(PreviewReadySchema, route.ready) }
+	};
+});
+function routePath(path) {
+	let url = new URL(path, "http://bud.invalid");
+	let search = url.searchParams.toString();
+	return `${url.pathname}${search ? `?${search}` : ""}${url.hash}`;
+}
+/** Canvas routes with unique IDs and normalized paths. */
+var BudRoutesSchema = check(list(RouteSchema, "bud.config must define at least one route.", 1), (routes) => new Set(routes.map((route) => route.id)).size !== routes.length || new Set(routes.map((route) => route.path)).size !== routes.length ? "Canvas route IDs and paths must be unique." : void 0);
+var port = (value) => value === void 0 || Number.isInteger(value) && value >= 0 && value <= 65535;
+var remote = (value) => typeof value === "string" && /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(value);
+/** A project's config, validated and normalized before Bud starts any listeners. */
+var BudConfigSchema = delegate(check(delegate(check(check(delegate(check(delegate(ConfigFields, (config) => ({
+	...config,
+	routes: parseConfig(BudRoutesSchema, config.routes)
+})), ({ port: companion, target }) => port(companion ?? 0) && port(target?.port) ? void 0 : "Ports must be integers between 0 and 65535."), ({ target, ...config }) => {
+	let origin = target?.origin ?? (target?.port ? `http://127.0.0.1:${target.port}` : void 0);
+	return {
+		...config,
+		targetOrigin: origin ? normalizeOrigin(origin, "target.origin must be an HTTP(S) origin without a path or credentials.") : origin
+	};
+}), ({ locale }) => locale === void 0 || locale === "en" || locale === "de" ? void 0 : "locale must be \"en\" or \"de\"."), ({ comments }) => remote(comments?.remote ?? "origin") ? void 0 : "comments.remote must be a Git remote name."), (config) => {
+	let flows = parseConfig(BudFlowsSchema, config.flows);
+	let steps = flows.flatMap((flow) => flow.steps.map((step) => flowStepRoute(flow, step)));
+	let home = config.routes.findIndex((route) => route.path === "/") + 1;
+	return {
+		...config,
+		flows,
+		routes: [
+			...config.routes.slice(0, home),
+			...steps,
+			...config.routes.slice(home)
+		]
+	};
+}), ({ routes }) => new Set(routes.map((route) => route.id)).size !== routes.length || new Set(routes.map((route) => route.path)).size !== routes.length ? "A flow step must not reuse a route’s id or path." : void 0), (config) => ({
+	name: config.name ?? "Your project",
+	routes: config.routes,
+	flows: config.flows,
+	port: config.port ?? 0,
+	targetOrigin: config.targetOrigin,
+	remote: config.comments?.remote ?? "origin",
+	screens: parseConfig(BudScreensSchema, config.screens),
+	storage: parseConfig(BudStorageSchema, config.storage),
+	designs: parseConfig(BudDesignsSchema, config.designs),
+	previews: parseConfig(BudPreviewsSchema, config.previews),
+	files: parseConfig(BudFilesSchema, config.files),
+	logo: parseConfig(BudLogoSchema, config.logo),
+	theme: parseConfig(BudThemeSchema, config.theme),
+	locale: config.locale === void 0 ? "en" : config.locale,
+	factory: parseConfig(BudFactorySchema, config.factory),
+	picker: parseConfig(BudPickerSchema, config.picker),
+	branches: parseConfig(BudBranchesSchema, config.branches)
+}));
+/**
+* Validates executable project config before starting any listeners.
+* @param value - The config module's default export.
+* @returns Normalized route IDs, ports, and URLs.
+*/
+function resolveBudConfig(value) {
+	let { config, plugins, provides } = applyPlugins(value);
+	rejectMovedSettings(config);
+	let resolved = parseConfig(BudConfigSchema, config);
+	let store = (kind) => resolved.storage[kind] === false ? false : provides[kind]?.name ?? "bud:beads";
+	let design = provides.taskDesign;
+	let picker = provides.picker;
+	return withPlugins({
+		...resolved,
+		storage: {
+			work: store("work"),
+			threads: store("threads")
+		},
+		designs: {
+			...resolved.designs,
+			tasks: design ? parseConfig(modulePath(`Plugin ${design.name}: taskDesign`, false), design.taskDesign) : "bud:beads"
+		},
+		picker: picker ? picker.picker ? {
+			name: picker.name,
+			module: parseConfig(modulePath(`Plugin ${picker.name}: picker`, false), picker.picker)
+		} : resolvePicker(picker.name) : resolvePicker(void 0),
+		factory: resolved.factory ? {
+			...resolved.factory,
+			sandbox: provides.sandbox?.name ?? null,
+			agent: provides.harness ? factoryAgent(provides.harness.name, provides.harness.harness) : resolved.factory.agent
+		} : null
+	}, plugins);
+}
+/**
+* Returns a bare HTTP(S) origin, rejecting credentials, paths, queries and fragments.
+* @param origin - The URL to check.
+* @param message - The error's message when it is not a bare origin.
+* @returns The URL's origin.
+*/
+function normalizeOrigin(origin, message) {
+	let url = new URL(origin);
+	if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.pathname !== "/" || url.search || url.hash) throw new Error(message);
+	return url.origin;
+}
+//#endregion
+export { taskDesign as a, pages as c, DEFAULT_FACTORY_MODEL as d, picker as i, tasks as l, normalizeOrigin as n, canvas as o, resolveBudConfig as r, files as s, defineConfig as t, resolveBranches as u };