@bud.sh/app 0.5.1 → 0.6.0

package/dist/node/assets/load-config.server-CMVtRVmO.js

@@ -0,0 +1,261 @@
+import { n as normalizeOrigin, r as resolveBudConfig } from "./config-9_jWwNBh.js";
+import { A as await_, At as runPromise, Ct as provideContext, Dt as runCallbackWith, Et as runCallback, Ft as runSyncExit, Gt as tryPromise, Ht as sync, It as runSyncExitWith, Jt as withFiber, K as catchIf, Kt as try_, Ln as scopeRemoveFinalizerUnsafe, Lt as runSyncWith, Mn as void_$1, Mt as runPromiseExitWith, Nt as runPromiseWith, Ot as runFork, Pt as runSync, Sn as makeUnsafe, Ur as TaggedError, Ut as tap, X as die, Y as context, _n as provideMerge, _t as mapError, at as flatten, bn as close, dn as buildWithMemoMap, fn as effect, ft as gen, hn as mergeAll, j as runIn, jt as runPromiseExit, kt as runForkWith, mn as makeMemoMapUnsafe, pr as Service, qt as void_, rt as flatMap, vn as succeed, xn as forkUnsafe } from "./Stream-CAm1eJ2n.js";
+import { C as Path, n as readText, t as nodeLayer, w as FileSystem } from "./src-DysjfbM8.js";
+import { randomUUID } from "node:crypto";
+import { pathToFileURL } from "node:url";
+//#region ../project/src/server/errors.ts
+/** Expected project startup/configuration failure; nested causes remain server-only. */
+var ProjectError = class extends TaggedError("ProjectError") {};
+//#endregion
+//#region ../project/src/server/config.ts
+/** Trusted executable configuration; tests replace evaluation independently of filesystem I/O. */
+var ConfigModuleLoader = class extends Service()("@bud.sh/project/ConfigModuleLoader") {};
+var configModuleLoaderLayer = succeed(ConfigModuleLoader, { load: (filename) => tryPromise({
+	try: async () => {
+		let url = pathToFileURL(filename);
+		url.searchParams.set("bud", randomUUID());
+		return (await import(
+			/* @vite-ignore */
+			url.href
+)).default;
+	},
+	catch: (cause) => new ProjectError({
+		reason: "evaluate",
+		filename,
+		message: `Could not evaluate ${filename}: ${cause instanceof Error ? cause.message : "the config module failed"}`,
+		cause
+	})
+}) });
+/** Finds, evaluates and validates a project's bud.config.ts. */
+var ProjectConfig = class extends Service()("@bud.sh/project/ProjectConfig") {};
+function projectError(reason, message, filename) {
+	return (cause) => new ProjectError({
+		reason,
+		message,
+		filename,
+		cause
+	});
+}
+/** Discovers exactly one config and validates it before any companion listener is opened. */
+var projectConfigLayer = effect(ProjectConfig, gen(function* () {
+	let fs = yield* FileSystem;
+	let path = yield* Path;
+	let loader = yield* ConfigModuleLoader;
+	let boundedRead = yield* context();
+	return { load: (directory) => gen(function* () {
+		if (typeof directory !== "string" || !directory.trim() || directory.includes("\0")) return yield* new ProjectError({
+			reason: "root",
+			message: "A valid project directory is required."
+		});
+		let root = yield* fs.realPath(path.resolve(directory)).pipe(mapError(projectError("root", `Cannot open project directory ${directory}.`)));
+		if ((yield* fs.stat(root).pipe(mapError(projectError("root", `Cannot inspect project directory ${root}.`)))).type !== "Directory") return yield* new ProjectError({
+			reason: "root",
+			message: `${root} is not a project directory.`
+		});
+		let files = [];
+		for (let name of ["bud.config.ts", "bud.config.js"]) {
+			let filename = path.join(root, name);
+			let info = yield* fs.stat(filename).pipe(catchIf((error) => error.reason._tag === "NotFound", () => void_), mapError(projectError("read", `Cannot inspect ${filename}.`, filename)));
+			if (!info) continue;
+			if (info.type !== "File") return yield* new ProjectError({
+				reason: "invalid",
+				filename,
+				message: `${filename} must be a regular config file.`
+			});
+			files.push(filename);
+		}
+		if (files.length !== 1) return yield* new ProjectError({
+			reason: files.length === 0 ? "missing" : "ambiguous",
+			message: files.length === 0 ? `Add bud.config.ts or bud.config.js in ${root}.` : "Keep exactly one bud.config.ts or bud.config.js."
+		});
+		let filename = files[0];
+		yield* readText(filename).pipe(provideContext(boundedRead), mapError((cause) => new ProjectError({
+			reason: "read",
+			filename,
+			message: `Cannot read ${filename}: ${cause.message}`,
+			cause
+		})));
+		let value = yield* loader.load(filename);
+		return {
+			root,
+			filename,
+			config: yield* try_({
+				try: () => resolveBudConfig(value),
+				catch: (cause) => new ProjectError({
+					reason: "invalid",
+					filename,
+					message: cause instanceof Error ? cause.message : "Invalid Bud configuration.",
+					cause
+				})
+			})
+		};
+	}) };
+}));
+Service()("@bud.sh/project/Project");
+var invalidTarget = "The target must be an HTTP(S) origin without a path or credentials.";
+/**
+* Resolves the actual bound target port, retaining an explicit target override.
+* @param config - Validated project configuration.
+* @param address - The live target listener address.
+* @param options - Target transport and host settings.
+* @returns A validated preview origin or a typed startup failure.
+*/
+function resolveTargetOrigin(config, address, options = {}) {
+	return try_({
+		try: () => {
+			if (config.targetOrigin) return normalizeOrigin(config.targetOrigin, invalidTarget);
+			if (!address || typeof address === "string" || !Number.isInteger(address.port) || address.port < 1 || address.port > 65535) throw new Error("Bud needs a listening Vite HTTP server to discover its port.");
+			let wildcard = (value) => [
+				"0.0.0.0",
+				"::",
+				""
+			].includes(value);
+			let host = typeof options.host === "string" && !wildcard(options.host) ? options.host : address.address && !wildcard(address.address) ? address.address : "127.0.0.1";
+			if (host.includes(":") && !host.startsWith("[")) host = `[${host}]`;
+			return normalizeOrigin(`${options.https ? "https" : "http"}://${host}:${address.port}`, invalidTarget);
+		},
+		catch: (cause) => new ProjectError({
+			reason: "target",
+			message: cause instanceof Error ? cause.message : "Cannot resolve the preview origin.",
+			cause
+		})
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/ManagedRuntime.js
+var TypeId = "~effect/ManagedRuntime";
+/**
+* Creates a `ManagedRuntime` from a layer.
+*
+* **When to use**
+*
+* Use to create a reusable runtime from a `Layer` for application entry points
+* or integration code that runs many effects without rebuilding services.
+*
+* **Details**
+*
+* The layer is built lazily on first use and its context is cached for
+* subsequent runs. Resources acquired by the layer are owned by the runtime and
+* are released when `dispose` or `disposeEffect` is run. `options.memoMap` can
+* be used to share layer memoization with other layer builds.
+*
+* **Gotchas**
+*
+* Dispose the runtime when it is no longer needed. A runtime cannot be reused
+* after disposal.
+*
+* **Example** (Creating a managed runtime)
+*
+* ```ts import.meta.vitest
+* import { Context, Effect, Layer, ManagedRuntime } from "effect"
+*
+* const notifications: Array<string> = []
+*
+* class Notifications extends Context.Service<Notifications, {
+*   readonly notify: (message: string) => Effect.Effect<void>
+* }>()("Notifications") {
+*   static readonly layer = Layer.succeed(this)({
+*     notify: Effect.fn("Notifications.notify")((message) =>
+*       Effect.sync(() => notifications.push(message))
+*     )
+*   })
+* }
+*
+* const runtime = ManagedRuntime.make(Notifications.layer)
+*
+* const program = Effect.flatMap(
+*   Notifications,
+*   (_) => _.notify("Hello, world!")
+* ).pipe(Effect.ensuring(runtime.disposeEffect))
+*
+* await runtime.runPromise(program)
+* notifications // => ["Hello, world!"]
+* ```
+*
+* @see {@link ManagedRuntime} for the returned runtime interface
+* @see {@link Layer.MemoMap} for shared layer memoization
+* @see {@link Layer.build} for lower-level scoped layer construction
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+var make = (layer, options) => {
+	const memoMap = options?.memoMap ?? makeMemoMapUnsafe();
+	const scope = makeUnsafe("sequential");
+	const layerScope = forkUnsafe(scope, "sequential");
+	const fiberScope = forkUnsafe(scope, "parallel");
+	const defaultRunOptions = { onFiberStart: runIn(fiberScope) };
+	const mergeRunOptions = (options) => options ? {
+		...options,
+		onFiberStart: options.onFiberStart ? (fiber) => {
+			defaultRunOptions.onFiberStart(fiber);
+			options.onFiberStart(fiber);
+		} : defaultRunOptions.onFiberStart
+	} : defaultRunOptions;
+	let buildFiber;
+	const contextEffect = withFiber((fiber) => {
+		if (!buildFiber) buildFiber = runFork(tap(buildWithMemoMap(layer, memoMap, layerScope), (context) => sync(() => {
+			self.cachedContext = context;
+		})), {
+			...defaultRunOptions,
+			scheduler: fiber.cache.scheduler
+		});
+		return flatten(await_(buildFiber));
+	});
+	const self = {
+		[TypeId]: TypeId,
+		memoMap,
+		scope,
+		contextEffect,
+		cachedContext: void 0,
+		context() {
+			return self.cachedContext === void 0 ? runPromise(self.contextEffect) : Promise.resolve(self.cachedContext);
+		},
+		dispose() {
+			return runPromise(self.disposeEffect);
+		},
+		[Symbol.asyncDispose]() {
+			return self.dispose();
+		},
+		disposeEffect: withFiber((fiber) => {
+			for (let current = fiber; current; current = current._parent) scopeRemoveFinalizerUnsafe(fiberScope, current);
+			self.contextEffect = die("ManagedRuntime disposed");
+			self.cachedContext = void 0;
+			return close(self.scope, void_$1);
+		}),
+		runFork(effect, options) {
+			return self.cachedContext === void 0 ? runFork(provide(self, effect), mergeRunOptions(options)) : runForkWith(self.cachedContext)(effect, mergeRunOptions(options));
+		},
+		runCallback(effect, options) {
+			return self.cachedContext === void 0 ? runCallback(provide(self, effect), mergeRunOptions(options)) : runCallbackWith(self.cachedContext)(effect, mergeRunOptions(options));
+		},
+		runSyncExit(effect) {
+			return self.cachedContext === void 0 ? runSyncExit(provide(self, effect)) : runSyncExitWith(self.cachedContext)(effect);
+		},
+		runSync(effect) {
+			return self.cachedContext === void 0 ? runSync(provide(self, effect)) : runSyncWith(self.cachedContext)(effect);
+		},
+		runPromiseExit(effect, options) {
+			return self.cachedContext === void 0 ? runPromiseExit(provide(self, effect), mergeRunOptions(options)) : runPromiseExitWith(self.cachedContext)(effect, mergeRunOptions(options));
+		},
+		runPromise(effect, options) {
+			return self.cachedContext === void 0 ? runPromise(provide(self, effect), mergeRunOptions(options)) : runPromiseWith(self.cachedContext)(effect, mergeRunOptions(options));
+		}
+	};
+	return self;
+};
+function provide(managed, effect) {
+	return flatMap(managed.contextEffect, (context) => provideContext(effect, context));
+}
+//#endregion
+//#region src/host/load-config.server.ts
+/**
+* A Node runtime that loads and resolves a project's bud.config.ts; dispose it when done.
+* @returns The managed runtime.
+*/
+function createConfigRuntime() {
+	return make(provideMerge(projectConfigLayer, mergeAll(nodeLayer(), configModuleLoaderLayer)));
+}
+//#endregion
+export { ProjectError as i, resolveTargetOrigin as n, ProjectConfig as r, createConfigRuntime as t };

package/dist/node/assets/module-3GgtT4Xs.js

@@ -0,0 +1,308 @@
+//#region ../picker-react-grab/src/lib/adapter.ts
+/**
+* The page side of `bud:react` and `bud:react-grab`: an element's component and source come from
+* React's development build, its block is the component's outermost element, and with React Grab
+* its own selection picks. It runs in the project's pages as module or script text, so it must not
+* reference anything outside its own body. The line comes from React's own stack, mapped through
+* the module's source map, so it is exact whichever React Grab a project runs; React Grab's own
+* answer fills in what that can't find. Production builds keep no source, so only the DOM picker's
+* own description remains.
+* @param grab - The project's `react-grab` module, or null to read React alone. Importing it
+*   starts React Grab if it isn't yet.
+* @param helpers - Resolves file names and source map positions.
+* @returns The picker adapter.
+*/
+function reactGrabAdapter(grab, helpers) {
+	let { sourceFile, projectFrames, sourceMapLookup } = helpers;
+	let plugin = "bud:picker";
+	let maps = /* @__PURE__ */ new Map();
+	let host = 5;
+	function fiberOf(element) {
+		let key = Object.keys(element).find((name) => name.startsWith("__reactFiber$"));
+		return key ? element[key] ?? null : null;
+	}
+	function outermost(component) {
+		let node = component.child;
+		while (node && node.tag !== host) node = node.child;
+		return node?.stateNode instanceof Element ? node.stateNode : null;
+	}
+	function sourceMap(url) {
+		let cached = maps.get(url);
+		if (cached) return cached;
+		cached = fetch(url).then((response) => response.ok ? response.text() : "").then(async (text) => {
+			let reference = /\/\/[#@] sourceMappingURL=(\S+)\s*$/.exec(text)?.[1];
+			let address = new URL(reference ?? `${url.replace(/[?#].*$/, "")}.map`, url);
+			if (address.protocol !== "data:" && address.origin !== location.origin) return null;
+			let response = await fetch(address);
+			let map = response.ok ? await response.json() : null;
+			let lookup = map && typeof map === "object" ? sourceMapLookup(map) : null;
+			return lookup ? {
+				lookup,
+				base: address.protocol === "data:" ? url : address.href
+			} : null;
+		}).catch(() => null);
+		maps.set(url, cached);
+		if (maps.size > 50) maps.delete(maps.keys().next().value);
+		return cached;
+	}
+	function servedPath(source, base, stack) {
+		if (source.startsWith("/") && !source.startsWith("//")) return sourceFile(source, stack, location.origin);
+		let url = new URL(source, base);
+		return url.origin === location.origin && !url.pathname.startsWith("/@") && !url.pathname.includes("/node_modules/") ? url.pathname : null;
+	}
+	async function written(stack) {
+		let frames = projectFrames(stack, location.origin);
+		for (let frame of frames) {
+			let map = await sourceMap(frame.url);
+			let position = map ? map.lookup(frame.line, frame.column) : {
+				source: frame.url,
+				line: frame.line,
+				column: frame.column
+			};
+			if (!position) continue;
+			let file = servedPath(position.source, map?.base ?? frame.url, stack);
+			if (file) return {
+				name: frame.name,
+				file,
+				line: position.line,
+				column: position.column
+			};
+		}
+		return frames[0] ? {
+			name: frames[0].name,
+			file: null,
+			line: null,
+			column: null
+		} : null;
+	}
+	function ownerName(element) {
+		let type = fiberOf(element)?._debugOwner?.type;
+		let name = type && typeof type === "object" ? type.displayName ?? type.name : null;
+		return typeof name === "string" && name ? name : null;
+	}
+	let adapter = {
+		async describe(element) {
+			let api = grab?.getGlobalApi() ?? null;
+			let stack = fiberOf(element)?._debugStack?.stack ?? "";
+			let mapped = stack ? await written(stack).catch(() => null) : null;
+			let found = !mapped?.file && api ? await api.getSource(element).catch(() => null) : null;
+			let component = mapped?.name ?? found?.componentName ?? api?.getDisplayName(element) ?? ownerName(element);
+			if (!mapped?.file && !found && !component) return null;
+			if (mapped?.file) return { source: {
+				component: component || null,
+				file: mapped.file,
+				line: mapped.line,
+				column: mapped.column
+			} };
+			let file = found?.filePath ? sourceFile(found.filePath, stack, location.origin) : null;
+			let line = found?.lineNumber && found.lineNumber > 0 ? found.lineNumber : null;
+			let column = found?.columnNumber != null && found.columnNumber >= 0 ? found.columnNumber + 1 : null;
+			return { source: {
+				component: component || null,
+				file,
+				line,
+				column
+			} };
+		},
+		block(element) {
+			for (let owner = fiberOf(element)?._debugOwner; owner; owner = owner._debugOwner) {
+				let outer = outermost(owner);
+				if (outer && outer !== document.body && outer.contains(element)) return outer;
+			}
+			return null;
+		}
+	};
+	if (!grab) return adapter;
+	return {
+		...adapter,
+		pick(signal) {
+			let api = grab.getGlobalApi();
+			if (!api || signal.aborted) return Promise.resolve(null);
+			return new Promise((resolve) => {
+				let settled = false;
+				let tidy = () => {
+					api.unregisterPlugin(plugin);
+					if (api.isActive()) api.deactivate();
+				};
+				let finish = (element, during) => {
+					if (settled) return;
+					settled = true;
+					signal.removeEventListener("abort", cancel);
+					resolve(element);
+					if (during) setTimeout(tidy, 1e3);
+					else tidy();
+				};
+				let cancel = () => finish(null, false);
+				signal.addEventListener("abort", cancel, { once: true });
+				api.unregisterPlugin(plugin);
+				api.registerPlugin({
+					name: plugin,
+					theme: { grabbedBoxes: { enabled: false } },
+					hooks: {
+						onElementSelect(element) {
+							finish(element, true);
+							return true;
+						},
+						onDeactivate: () => finish(null, true)
+					}
+				});
+				api.activate();
+			});
+		}
+	};
+}
+//#endregion
+//#region ../picker-react-grab/src/lib/source-map.ts
+/**
+* The frames of React's stack for an element that may have run in the project's own code, in
+* order: the first one whose source is the project's is the component that rendered it.
+* Dependencies the dev server serves apart, Vite's own modules and other origins are left out; a
+* build bundles dependencies with the project, so their frames stay for their source maps to
+* tell apart. It runs in the project's pages as module text, so it must not reference anything
+* outside its own body.
+* @param stack - React's stack for the element, as `Error.stack` text.
+* @param origin - The page's origin.
+* @returns The frames, possibly none.
+*/
+function projectFrames(stack, origin) {
+	let frames = [];
+	for (let text of stack.split("\n")) {
+		let match = /^\s*at (?:(.+?) \()?(https?:\/\/[^\s()]+?):(\d+):(\d+)\)?\s*$/.exec(text);
+		if (!match) continue;
+		let url = new URL(match[2]);
+		if (url.origin !== origin || url.pathname.startsWith("/@") || url.pathname.includes("/node_modules/")) continue;
+		let name = match[1]?.replace(/^Object\./, "") ?? null;
+		frames.push({
+			name,
+			url: url.href,
+			line: Number(match[3]),
+			column: Number(match[4])
+		});
+	}
+	return frames;
+}
+/**
+* Decodes a module's source map once, for looking up many positions in it. It runs in the
+* project's pages as module text, so it must not reference anything outside its own body.
+* @param map - The source map, as parsed JSON.
+* @returns Maps a generated line and column, counted from one, to the original position; null
+*   for a map that can't be read.
+*/
+function sourceMapLookup(map) {
+	if (typeof map.mappings !== "string" || !Array.isArray(map.sources)) return null;
+	let sources = map.sources;
+	let root = typeof map.sourceRoot === "string" && map.sourceRoot ? map.sourceRoot : "";
+	let digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+	let lines = [];
+	let source = 0;
+	let sourceLine = 0;
+	let sourceColumn = 0;
+	for (let text of map.mappings.split(";")) {
+		let generated = 0;
+		let segments = [];
+		for (let segment of text.split(",")) {
+			if (!segment) continue;
+			let values = [];
+			let value = 0;
+			let shift = 0;
+			for (let character of segment) {
+				let digit = digits.indexOf(character);
+				if (digit < 0) return null;
+				value += (digit & 31) << shift;
+				if (digit & 32) shift += 5;
+				else {
+					values.push(value & 1 ? -(value >>> 1) : value >>> 1);
+					value = 0;
+					shift = 0;
+				}
+			}
+			generated += values[0] ?? 0;
+			if (values.length < 4) continue;
+			source += values[1];
+			sourceLine += values[2];
+			sourceColumn += values[3];
+			segments.push([
+				generated,
+				source,
+				sourceLine,
+				sourceColumn
+			]);
+		}
+		lines.push(segments);
+	}
+	return (line, column) => {
+		let found = null;
+		for (let segment of lines[line - 1] ?? []) if (segment[0] <= column - 1) found = segment;
+		let name = found ? sources[found[1]] : null;
+		if (!found || typeof name !== "string") return null;
+		return {
+			source: root ? `${root.replace(/\/$/, "")}/${name}` : name,
+			line: found[2] + 1,
+			column: found[3] + 1
+		};
+	};
+}
+//#endregion
+//#region ../picker-react-grab/src/lib/source.ts
+/**
+* The project path of a file React Grab names. React Grab maps React's stack through the dev
+* server's source maps, whose sources are relative to the module that names them (Vite writes
+* `card.tsx` for `/src/components/card.tsx`). The module's address is still in React's own stack,
+* so the file resolves against the first frame from the page's origin that shares its name. It runs
+* in the project's pages as module text, so it must not reference anything outside its own body.
+* @param file - The file React Grab reported: a name, a relative or absolute path, or a URL.
+* @param stack - React's stack for the element, as `Error.stack` text.
+* @param origin - The page's origin; frames from elsewhere are never the project's.
+* @returns A path as the dev server serves it, such as `/src/components/card.tsx`, or null.
+*/
+function sourceFile(file, stack, origin) {
+	let served = (url) => url.origin === origin && !url.pathname.startsWith("/@") && !url.pathname.includes("/node_modules/") && !/[\\\u0000-\u001f\u007f]/.test(url.pathname);
+	if (/^https?:\/\//.test(file)) {
+		let url = new URL(file);
+		return served(url) ? url.pathname : null;
+	}
+	let name = file.split("/").pop();
+	for (let line of stack.split("\n")) {
+		let match = /(https?:\/\/[^\s()]+?)(?::\d+){1,2}\)?\s*$/.exec(line);
+		if (!match) continue;
+		let frame = new URL(match[1]);
+		if (!served(frame) || frame.pathname.split("/").pop() !== name) continue;
+		if (file.startsWith("/")) return file.endsWith(frame.pathname) ? frame.pathname : null;
+		let resolved = new URL(file, frame);
+		return served(resolved) ? resolved.pathname : null;
+	}
+	return null;
+}
+//#endregion
+//#region ../picker-react-grab/src/lib/module.ts
+/** The React Grab picker's name in `bud.config`. */
+var REACT_GRAB_PICKER = "bud:react-grab";
+/** The picker that reads React alone, without React Grab, in `bud.config`. */
+var REACT_PICKER = "bud:react";
+function helpers() {
+	return [
+		"{",
+		`  sourceFile: ${sourceFile.toString()},`,
+		`  projectFrames: ${projectFrames.toString()},`,
+		`  sourceMapLookup: ${sourceMapLookup.toString()},`,
+		"}"
+	].join("\n");
+}
+/**
+* The adapter's page module text. It imports `react-grab` from the project, so React Grab must be
+* installed there; the dev server serves the same instance the project's pages use.
+* @returns ES module text whose default export is the picker adapter.
+*/
+function reactGrabAdapterModule() {
+	return ["import * as grab from 'react-grab'", `export default (${reactGrabAdapter.toString()})(grab, ${helpers()})`].join("\n");
+}
+/**
+* An expression that builds the React adapter without React Grab, for module or script text.
+* It needs nothing from the project, so pages without a dev server can run it too.
+* @returns JavaScript expression text evaluating to the picker adapter.
+*/
+function reactAdapterExpression() {
+	return `(${reactGrabAdapter.toString()})(null, ${helpers()})`;
+}
+//#endregion
+export { reactGrabAdapterModule as i, REACT_PICKER as n, reactAdapterExpression as r, REACT_GRAB_PICKER as t };