@pithy-sh/vite 0.1.1 → 0.1.3

package/dist/plugin.js

@@ -0,0 +1,96 @@
+import { capabilityNameFromResolvedId, isResolvedVirtualId, renderVirtualModule, resolveVirtualId } from "./virtualModule.js";
+import { loadWorkerConfig } from "./workerConfig.js";
+import { resolve } from "node:path";
+import { resolveClientProjection } from "@pithy-sh/core/src/capability/client";
+import { normalizePath } from "vite";
+//#region src/plugin.ts
+/**
+* Every hook {@link pithy} defines, by name.
+*
+* **The one thing about the hooks an adopter's checker can be given for free.** {@link PithyPlugin}
+* deliberately names no Vite type, so nothing in the return says which hooks exist — and a hook Vite
+* never calls is dead code that looks like a feature. A name is not a Vite type: `tooling/vite-adopter`
+* asserts each of these is a `keyof Plugin` in 6, 7 and 8, which costs an adopter nothing and catches
+* the regression that matters here. Adding a `buildApp` hook, which Vite 7 introduced and Vite 6 has no
+* name for, reddens the fixture rather than shipping under a range that claims 6.
+*
+* `plugin.test.ts` holds this list to the object itself, both directions, at runtime — a hook added
+* without listing it is a failure there, and a name listed that no longer exists is one too. A list
+* that can drift from what it lists is a worse gate than none.
+*/
+const PITHY_PLUGIN_HOOKS = [
+	"configResolved",
+	"configureServer",
+	"resolveId",
+	"load",
+	"hotUpdate"
+];
+/**
+* Serve one `virtual:pithy/<capability>` module per capability, projected from the Worker's own
+* `pithy.config.ts`.
+*
+* A screen imports what it needs — `import auth from "virtual:pithy/auth"` — and gets that
+* capability's client-safe projection inlined at build time. A capability the Worker does not compose
+* resolves to `{ enabled: false }` rather than failing the import, including a name nobody has ever
+* heard of: a screen branches on `enabled`, it does not guard on whether the module exists.
+*/
+function pithy(options = {}) {
+	const environment = options.environment ?? process.env.ENVIRONMENT ?? "dev";
+	let configFile = "";
+	let loading = null;
+	let server;
+	const watched = /* @__PURE__ */ new Set();
+	function watch(files) {
+		for (const file of files) {
+			const path = normalizePath(file);
+			if (watched.has(path)) continue;
+			watched.add(path);
+			server?.watcher.add(path);
+		}
+	}
+	function loadOnce() {
+		loading ??= loadWorkerConfig(configFile).then((loaded) => {
+			watch(loaded.dependencies);
+			return loaded;
+		}).catch((cause) => {
+			loading = null;
+			throw cause;
+		});
+		return loading;
+	}
+	return {
+		name: "pithy",
+		enforce: "pre",
+		configResolved(config) {
+			configFile = normalizePath(resolve(config.root, options.configFile ?? "pithy.config.ts"));
+			watch([configFile]);
+		},
+		configureServer(devServer) {
+			server = devServer;
+			for (const path of watched) devServer.watcher.add(path);
+		},
+		resolveId(id) {
+			return resolveVirtualId(id);
+		},
+		async load(id) {
+			const name = capabilityNameFromResolvedId(id);
+			if (name === null) return null;
+			const { capabilities } = await loadOnce();
+			return renderVirtualModule(resolveClientProjection(capabilities.get(name), { environment }));
+		},
+		hotUpdate({ file }) {
+			if (!watched.has(normalizePath(file))) return;
+			loading = null;
+			const invalidated = [];
+			for (const [id, module] of this.environment.moduleGraph.idToModuleMap) {
+				if (!isResolvedVirtualId(id)) continue;
+				this.environment.moduleGraph.invalidateModule(module);
+				invalidated.push(module);
+			}
+			this.environment.hot.send({ type: "full-reload" });
+			return invalidated;
+		}
+	};
+}
+//#endregion
+export { PITHY_PLUGIN_HOOKS, pithy };

package/dist/testPlugin.d.ts

@@ -0,0 +1,54 @@
+import { type PithyPlugin, type PithyPluginOptions } from "./plugin";
+/**
+ * The Pithy plugin, for a test runner's config.
+ *
+ * **It is not a second plugin.** It calls {@link pithy} and hands back what that returns — same config,
+ * same `resolveClientProjection`, same `renderVirtualModule`, same bytes. There is no fixture here, and
+ * therefore nothing that can drift from the projection.
+ *
+ * ## It is now a one-line redirect, and it was not always — Jim, #476
+ *
+ * Vitest loads its config by bundling it and leaving every **bare** specifier to node. Until this
+ * package shipped a build, `import { pithy } from "@pithy-sh/vite/src/plugin"` in a `vitest.config.ts`
+ * therefore handed node `plugin.ts` — TypeScript, under `node_modules`, where node refuses to strip
+ * types — and its `@pithy-sh/core/src/capability/client` import had no extension for node to resolve
+ * either. The config never loaded and no test ran, transitively taking every screen that read a
+ * projection with it. Three lanes in `pithy-sh/dashboard` hit it independently, and this module was the
+ * way round: its whole static graph was `vite` and `node:url`, and the plugin was reached through
+ * vite's own loader rather than node's.
+ *
+ * `dist/plugin.js` is JavaScript with real extensions on its imports, so node loads it, and
+ * `vitestConfig.test.ts` makes a real child `vitest` run say so — it drives the **build** plugin from a
+ * bare specifier in an adopter-shaped project. The wall is gone and the loader hop with it.
+ *
+ * **What stays is the name.** `pithyTest` is exported from 0.1.0 and `pithy-sh/dashboard` names it in
+ * its own configs, so removing it would break a working install to save a line. It is kept as the
+ * documented spelling for a test config, and can be dropped whenever nothing imports it — there is no
+ * behavior behind it left to maintain.
+ *
+ * ## What an adopter writes
+ *
+ * One line, in the test project that mounts client modules — never per consumer:
+ *
+ * ```ts
+ * import { pithyTest } from "@pithy-sh/vite/src/testPlugin";
+ *
+ * export default defineConfig({
+ *   plugins: [pithyTest({ configFile: "apps/board/pithy.config.ts" })],
+ *   test: { environment: "happy-dom" },
+ * });
+ * ```
+ *
+ * `configFile` resolves against the Vite root, which for a test run is usually the repository root
+ * rather than the Worker's directory — so a monorepo names the Worker, and a single-Worker project takes
+ * the default.
+ *
+ * Still a promise, and still `Promise<PithyPlugin>` rather than `Promise<Plugin>`. The promise is part
+ * of the published signature and a documented `PluginOption`, so awaiting nothing is cheaper than
+ * changing what an adopter's config is typed against; the return type is for the reason
+ * {@link PithyPlugin} gives (#414) — a Vite type in this signature is *this package's* Vite type, and an
+ * adopter's `vitest.config.ts` cannot be checked against it unless their install happened to
+ * deduplicate onto the same copy.
+ */
+export declare function pithyTest(options?: PithyPluginOptions): Promise<PithyPlugin>;
+//# sourceMappingURL=testPlugin.d.ts.map

package/dist/testPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testPlugin.d.ts","sourceRoot":"","sources":["../src/testPlugin.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,kBAAkB,EAAS,MAAM,UAAU,CAAC;AAE5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,wBAAgB,SAAS,CAAC,OAAO,GAAE,kBAAuB,GAAG,OAAO,CAAC,WAAW,CAAC,CAEhF"}

package/dist/testPlugin.js

@@ -0,0 +1,58 @@
+import { pithy } from "./plugin.js";
+//#region src/testPlugin.ts
+/**
+* The Pithy plugin, for a test runner's config.
+*
+* **It is not a second plugin.** It calls {@link pithy} and hands back what that returns — same config,
+* same `resolveClientProjection`, same `renderVirtualModule`, same bytes. There is no fixture here, and
+* therefore nothing that can drift from the projection.
+*
+* ## It is now a one-line redirect, and it was not always — Jim, #476
+*
+* Vitest loads its config by bundling it and leaving every **bare** specifier to node. Until this
+* package shipped a build, `import { pithy } from "@pithy-sh/vite/src/plugin"` in a `vitest.config.ts`
+* therefore handed node `plugin.ts` — TypeScript, under `node_modules`, where node refuses to strip
+* types — and its `@pithy-sh/core/src/capability/client` import had no extension for node to resolve
+* either. The config never loaded and no test ran, transitively taking every screen that read a
+* projection with it. Three lanes in `pithy-sh/dashboard` hit it independently, and this module was the
+* way round: its whole static graph was `vite` and `node:url`, and the plugin was reached through
+* vite's own loader rather than node's.
+*
+* `dist/plugin.js` is JavaScript with real extensions on its imports, so node loads it, and
+* `vitestConfig.test.ts` makes a real child `vitest` run say so — it drives the **build** plugin from a
+* bare specifier in an adopter-shaped project. The wall is gone and the loader hop with it.
+*
+* **What stays is the name.** `pithyTest` is exported from 0.1.0 and `pithy-sh/dashboard` names it in
+* its own configs, so removing it would break a working install to save a line. It is kept as the
+* documented spelling for a test config, and can be dropped whenever nothing imports it — there is no
+* behavior behind it left to maintain.
+*
+* ## What an adopter writes
+*
+* One line, in the test project that mounts client modules — never per consumer:
+*
+* ```ts
+* import { pithyTest } from "@pithy-sh/vite/src/testPlugin";
+*
+* export default defineConfig({
+*   plugins: [pithyTest({ configFile: "apps/board/pithy.config.ts" })],
+*   test: { environment: "happy-dom" },
+* });
+* ```
+*
+* `configFile` resolves against the Vite root, which for a test run is usually the repository root
+* rather than the Worker's directory — so a monorepo names the Worker, and a single-Worker project takes
+* the default.
+*
+* Still a promise, and still `Promise<PithyPlugin>` rather than `Promise<Plugin>`. The promise is part
+* of the published signature and a documented `PluginOption`, so awaiting nothing is cheaper than
+* changing what an adopter's config is typed against; the return type is for the reason
+* {@link PithyPlugin} gives (#414) — a Vite type in this signature is *this package's* Vite type, and an
+* adopter's `vitest.config.ts` cannot be checked against it unless their install happened to
+* deduplicate onto the same copy.
+*/
+function pithyTest(options = {}) {
+	return Promise.resolve(pithy(options));
+}
+//#endregion
+export { pithyTest };

package/dist/virtualModule.d.ts

@@ -0,0 +1,28 @@
+import type { ClientProjection } from "@pithy-sh/core/src/capability/client";
+/**
+ * The import specifier a screen writes: `import auth from "virtual:pithy/auth"`. One module per
+ * capability, resolved from the Worker's own `pithy.config.ts` — so a front end reads the backend it
+ * is served by, and never a hand-copied duplicate of its config.
+ */
+export declare const VIRTUAL_PREFIX = "virtual:pithy/";
+/**
+ * The resolved id. The leading NUL is Rollup's convention for "this module has no file" — it stops
+ * other plugins and the filesystem resolver from touching it.
+ */
+export declare const RESOLVED_PREFIX = "\0virtual:pithy/";
+/** Map an import specifier to its resolved id, or `null` when the specifier is not a Pithy virtual module. */
+export declare function resolveVirtualId(id: string): string | null;
+/** The capability name carried by a resolved id, or `null` when the id is not one of ours. */
+export declare function capabilityNameFromResolvedId(id: string): string | null;
+/** Whether a module id is a resolved Pithy virtual module — used to sweep the dev module graph. */
+export declare function isResolvedVirtualId(id: string): boolean;
+/**
+ * Render a projection as module source. Both shapes are emitted on purpose: the default export for
+ * `import auth from "virtual:pithy/auth"`, and one named export per key so a bundler can tree-shake
+ * `import { enabled } from "virtual:pithy/auth"` down to a single inlined literal.
+ *
+ * Every value is emitted through `JSON.stringify`, which is the second half of the security boundary
+ * — the projection was already validated as JSON, and nothing but JSON can be written here.
+ */
+export declare function renderVirtualModule(projection: ClientProjection): string;
+//# sourceMappingURL=virtualModule.d.ts.map

package/dist/virtualModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"virtualModule.d.ts","sourceRoot":"","sources":["../src/virtualModule.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAE7E;;;;GAIG;AACH,eAAO,MAAM,cAAc,mBAAmB,CAAC;AAE/C;;;GAGG;AACH,eAAO,MAAM,eAAe,qBAAqB,CAAC;AAiElD,8GAA8G;AAC9G,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAK1D;AAED,8FAA8F;AAC9F,wBAAgB,4BAA4B,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAItE;AAED,mGAAmG;AACnG,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,gBAAgB,GAAG,MAAM,CAQxE"}

package/dist/virtualModule.js

@@ -0,0 +1,108 @@
+//#region src/virtualModule.ts
+/**
+* The import specifier a screen writes: `import auth from "virtual:pithy/auth"`. One module per
+* capability, resolved from the Worker's own `pithy.config.ts` — so a front end reads the backend it
+* is served by, and never a hand-copied duplicate of its config.
+*/
+const VIRTUAL_PREFIX = "virtual:pithy/";
+/**
+* The resolved id. The leading NUL is Rollup's convention for "this module has no file" — it stops
+* other plugins and the filesystem resolver from touching it.
+*/
+const RESOLVED_PREFIX = "\0virtual:pithy/";
+/**
+* A capability name as it may appear after the prefix: one segment, the same lowercase-hyphenated
+* shape as `pithy add <capability>`. Anything else (a path, an empty name, a traversal) is not ours,
+* so `resolveVirtualId` declines it and Vite reports its usual unresolved-import error.
+*/
+const CAPABILITY_NAME = /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/;
+/** A key that can legally be re-exported as `export const <key>`. */
+const IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+/**
+* Keys that are valid object keys but not valid binding names. A projection carrying one still
+* reaches the default export; only its named export is skipped, so nothing is silently lost.
+*/
+const RESERVED = /* @__PURE__ */ new Set([
+	"await",
+	"break",
+	"case",
+	"catch",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"enum",
+	"export",
+	"extends",
+	"false",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"implements",
+	"import",
+	"in",
+	"instanceof",
+	"interface",
+	"let",
+	"new",
+	"null",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"return",
+	"static",
+	"super",
+	"switch",
+	"this",
+	"throw",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"while",
+	"with",
+	"yield"
+]);
+/** Map an import specifier to its resolved id, or `null` when the specifier is not a Pithy virtual module. */
+function resolveVirtualId(id) {
+	if (!id.startsWith("virtual:pithy/")) return null;
+	const name = id.slice(14);
+	if (!CAPABILITY_NAME.test(name)) return null;
+	return `${RESOLVED_PREFIX}${name}`;
+}
+/** The capability name carried by a resolved id, or `null` when the id is not one of ours. */
+function capabilityNameFromResolvedId(id) {
+	if (!id.startsWith("\0virtual:pithy/")) return null;
+	const name = id.slice(15);
+	return CAPABILITY_NAME.test(name) ? name : null;
+}
+/** Whether a module id is a resolved Pithy virtual module — used to sweep the dev module graph. */
+function isResolvedVirtualId(id) {
+	return capabilityNameFromResolvedId(id) !== null;
+}
+/**
+* Render a projection as module source. Both shapes are emitted on purpose: the default export for
+* `import auth from "virtual:pithy/auth"`, and one named export per key so a bundler can tree-shake
+* `import { enabled } from "virtual:pithy/auth"` down to a single inlined literal.
+*
+* Every value is emitted through `JSON.stringify`, which is the second half of the security boundary
+* — the projection was already validated as JSON, and nothing but JSON can be written here.
+*/
+function renderVirtualModule(projection) {
+	const lines = [`export default ${JSON.stringify(projection)};`];
+	for (const [key, value] of Object.entries(projection)) {
+		if (value === void 0) continue;
+		if (!IDENTIFIER.test(key) || RESERVED.has(key)) continue;
+		lines.push(`export const ${key} = ${JSON.stringify(value)};`);
+	}
+	return `${lines.join("\n")}\n`;
+}
+//#endregion
+export { RESOLVED_PREFIX, VIRTUAL_PREFIX, capabilityNameFromResolvedId, isResolvedVirtualId, renderVirtualModule, resolveVirtualId };

package/dist/workerConfig.d.ts

@@ -0,0 +1,58 @@
+import type { Capability } from "@pithy-sh/core/src/capability/capability";
+/** One Worker's composed capabilities, indexed by name, plus the files the config was built from. */
+export interface LoadedWorkerConfig {
+    /** Capability name → the capability, library capabilities first and the app capability last. */
+    capabilities: Map<string, Capability>;
+    /** Every file the config transitively imported — what the dev server watches so an edit reloads. */
+    dependencies: readonly string[];
+}
+/**
+ * Why a `pithy.config.ts` would not load — and therefore what may be said about it (#217).
+ *
+ * This loader built the same refusal the CLI's did, with the same defect. #207 fixed the CLI's
+ * (`packages/cli/src/project/config.ts`, `classifyConfigLoadFailure`); this file could not import that
+ * fix, because `@pithy-sh/vite` depends on `@pithy-sh/core` and must not depend on the CLI. So it is
+ * restated here, with the same rule behind it: **a `catch` reachable by more than one underlying failure
+ * may not name a single specific remedy.** Classify, or hedge. The convention is in `docs/CONVENTIONS.md`.
+ *
+ * What the copies *cannot* be allowed to disagree about is anything that is not a sentence. Two kinds of
+ * that were found, one issue apart, and both live in `@pithy-sh/core` — the one package this plugin
+ * already depends on. What a runtime does to an error on its way out is the first: `rootCause`, `prop`
+ * and `isBuildFailureWrapper`, facts no copy can derive and every copy got wrong (#223). Whether one of
+ * its strings is safe to show is the second: `safeReason`, `failurePosition`, `unresolvedSpecifier` and
+ * `causeMessage`, because a path or a stack frame is a property of the string and not of the surface
+ * quoting it — three near-verbatim copies of that filter meant the hole #223 found in it had to be closed
+ * three times (#228).
+ *
+ * What stays restated here is the policy: which causes this loader recognizes, and what it says about
+ * each. Those are genuinely per-surface, and this plugin still cannot import the CLI's.
+ */
+export type WorkerConfigFailureKind = 
+/** An import in the config does not resolve. `bun install`, or a corrected specifier. */
+"unresolved-import"
+/** The file does not parse. Installing will not help, and the adopter has read the opposite for years. */
+ | "parse-error"
+/** The config loaded far enough to throw its own error. Neither of the above. */
+ | "threw-on-load"
+/** None of the above. No remedy: a wrong action is worse than no action, because it is followed. */
+ | "unknown";
+/** What may be said about a config that would not load. */
+export interface WorkerConfigFailure {
+    /** Which failure this was, decided from the cause and never asserted over it. */
+    kind: WorkerConfigFailureKind;
+    /** The remedy, chosen from the kind. Carries no absolute path, no source line, no stack. */
+    action: string;
+}
+/** Choose the refusal's `action` **from** the failure rather than asserting one over it (#217). */
+export declare function classifyWorkerConfigFailure(wrapped: unknown): WorkerConfigFailure;
+/**
+ * Load a Worker's `pithy.config.ts` and index the capabilities it composes.
+ *
+ * `runnerImport` is Vite's own loader: it builds a throwaway runnable environment with
+ * `configFile: false`, so the config's TypeScript, its extensionless relative imports, and its
+ * `@pithy-sh/*` source imports all resolve — none of which a bare dynamic `import()` handles — and it
+ * behaves identically under `vite dev` and `vite build`. It also reports the transitive files it
+ * touched, which is what makes HMR on a config edit possible.
+ */
+export declare function loadWorkerConfig(configFile: string): Promise<LoadedWorkerConfig>;
+//# sourceMappingURL=workerConfig.d.ts.map

package/dist/workerConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workerConfig.d.ts","sourceRoot":"","sources":["../src/workerConfig.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0CAA0C,CAAC;AAkB3E,qGAAqG;AACrG,MAAM,WAAW,kBAAkB;IACjC,gGAAgG;IAChG,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACtC,oGAAoG;IACpG,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;CACjC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,MAAM,uBAAuB;AACjC,yFAAyF;AACvF,mBAAmB;AACrB,0GAA0G;GACxG,aAAa;AACf,iFAAiF;GAC/E,eAAe;AACjB,oGAAoG;GAClG,SAAS,CAAC;AAEd,2DAA2D;AAC3D,MAAM,WAAW,mBAAmB;IAClC,iFAAiF;IACjF,IAAI,EAAE,uBAAuB,CAAC;IAC9B,4FAA4F;IAC5F,MAAM,EAAE,MAAM,CAAC;CAChB;AA4CD,mGAAmG;AACnG,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,OAAO,GAAG,mBAAmB,CAqCjF;AAMD;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAkDtF"}

package/dist/workerConfig.js

@@ -0,0 +1,117 @@
+import { access } from "node:fs/promises";
+import { runnerImport } from "vite";
+import { causeMessage, failurePosition, isBuildFailureWrapper, prop, rootCause, safeReason, unresolvedSpecifier } from "@pithy-sh/core/src/error/cause";
+import { InternalError, NotFoundError } from "@pithy-sh/core/src/error/pithyError";
+//#region src/workerConfig.ts
+/**
+* The message, de-colored, for this classifier's own pattern tests — never for output.
+*
+* What may be *said* is core's {@link safeReason}, and only core's. This plugin cannot import the CLI's
+* refusals and never could, which is why the sentences below are restated here — but the *filter* those
+* sentences pass a string through is not a sentence. Whether a string carries an absolute path or half a
+* parser's ANSI box is a property of the string, so it is decided in `@pithy-sh/core`, the one package
+* this plugin depends on, and the suppression #223 had to write three times is written once (#228).
+*/
+function rawMessage(cause) {
+	return causeMessage(cause) ?? "";
+}
+function isUnresolvedImport(cause) {
+	const code = prop(cause, "code");
+	if (code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND" || code === "ERR_PACKAGE_PATH_NOT_EXPORTED" || code === "ERR_UNSUPPORTED_DIR_IMPORT") return true;
+	if (prop(cause, "name") === "ResolveMessage") return true;
+	return /Cannot find (?:package|module) |Failed to resolve (?:import|module)|Failed to load url /.test(rawMessage(cause));
+}
+function isParseError(cause) {
+	const name = prop(cause, "name");
+	if (name === "SyntaxError" || name === "BuildMessage") return true;
+	if (prop(cause, "code") === "PARSE_ERROR") return true;
+	if (isBuildFailureWrapper(cause)) return true;
+	return /Transform failed|\[PARSE_ERROR]|Parse (?:error|failure)|Unexpected (?:token|end of input)/.test(rawMessage(cause));
+}
+/** Choose the refusal's `action` **from** the failure rather than asserting one over it (#217). */
+function classifyWorkerConfigFailure(wrapped) {
+	const cause = rootCause(wrapped);
+	if (isUnresolvedImport(cause)) {
+		const specifier = unresolvedSpecifier(cause);
+		return {
+			kind: "unresolved-import",
+			action: specifier ? `Nothing resolves "${specifier}". Install the project's dependencies (bun install), or correct that import.` : "An import in the config does not resolve. Install the project's dependencies (bun install), then check its imports."
+		};
+	}
+	if (isParseError(cause)) {
+		const reason = safeReason(cause);
+		const at = failurePosition(cause);
+		const where = at ? ` Line ${at.line}, column ${at.column}.` : "";
+		return {
+			kind: "parse-error",
+			action: `The config does not parse${reason ? `: ${reason}` : ""}.${where} Fix the file — installing dependencies will not help.`
+		};
+	}
+	if (causeMessage(cause) !== void 0) {
+		const reason = safeReason(cause);
+		return {
+			kind: "threw-on-load",
+			action: reason ? `The config threw while loading: ${reason}. Fix that in the config.` : "The config threw while loading. Run the file directly to see what it throws."
+		};
+	}
+	return {
+		kind: "unknown",
+		action: "Check pithy.config.ts. Run the file directly to see how it fails."
+	};
+}
+function isCapability(value) {
+	return typeof value === "object" && value !== null && typeof value.name === "string";
+}
+/**
+* Load a Worker's `pithy.config.ts` and index the capabilities it composes.
+*
+* `runnerImport` is Vite's own loader: it builds a throwaway runnable environment with
+* `configFile: false`, so the config's TypeScript, its extensionless relative imports, and its
+* `@pithy-sh/*` source imports all resolve — none of which a bare dynamic `import()` handles — and it
+* behaves identically under `vite dev` and `vite build`. It also reports the transitive files it
+* touched, which is what makes HMR on a config edit possible.
+*/
+async function loadWorkerConfig(configFile) {
+	try {
+		await access(configFile);
+	} catch {
+		throw new NotFoundError({
+			message: `No pithy.config.ts at ${configFile}.`,
+			action: "Run pithy ui add from the project root, or point the plugin at it with pithy({ configFile })."
+		});
+	}
+	let module;
+	let dependencies;
+	try {
+		const imported = await runnerImport(configFile);
+		module = imported.module;
+		dependencies = imported.dependencies.filter((file) => typeof file === "string" && file.length > 0);
+	} catch (cause) {
+		const { kind, action } = classifyWorkerConfigFailure(cause);
+		throw new InternalError({
+			message: `Could not load ${configFile}.`,
+			action,
+			detail: `${kind}: ${cause instanceof Error ? cause.message : String(cause)}`
+		});
+	}
+	const config = module.default;
+	if (!config || !Array.isArray(config.capabilities)) throw new InternalError({
+		message: `${configFile} doesn't default-export a worker config.`,
+		action: "Export default { capabilities, app }."
+	});
+	const capabilities = /* @__PURE__ */ new Map();
+	for (const entry of config.capabilities) {
+		if (!isCapability(entry)) throw new InternalError({
+			message: `${configFile} lists something that isn't a capability.`,
+			action: "Every entry in capabilities is a capability object with a name. Remove the odd one out."
+		});
+		capabilities.set(entry.name, entry);
+	}
+	if (isCapability(config.app)) capabilities.set(config.app.name, config.app);
+	return {
+		capabilities,
+		dependencies
+	};
+}
+//#endregion
+export { classifyWorkerConfigFailure, loadWorkerConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pithy-sh/vite",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -8,19 +8,24 @@
     "directory": "packages/vite"
   },
   "files": [
+    "dist",
     "src",
-    "!src/**/*.test.*"
+    "!src/**/*.test.*",
+    "!dist/**/*.test.*"
   ],
   "type": "module",
   "engines": {
     "node": ">=22"
   },
   "exports": {
-    "./src/*": "./src/*.ts"
+    "./src/*": {
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    }
   },
   "scripts": {
     "generate": "bun scripts/generateClientEnv.ts",
-    "build": "bun run generate && tsc -p tsconfig.json --noEmit false --outDir dist",
+    "build": "bun run generate && tsdown && tsc -p tsconfig.build.json",
     "typecheck": "tsc -p tsconfig.json",
     "test": "vitest run",
     "test:node": "vitest run --project=node",
@@ -31,7 +36,7 @@
     "vite": "^6.1.0 || ^7.0.0 || ^8.0.0"
   },
   "dependencies": {
-    "@pithy-sh/core": "workspace:*"
+    "@pithy-sh/core": "^0.1.3"
   },
   "devDependencies": {
     "@pithy-sh/auth": "workspace:*",
@@ -43,9 +48,10 @@
     "@pithy-sh/ui-react": "workspace:*",
     "@types/node": "^22.15.0",
     "@vitest/coverage-v8": "^4.1.0",
+    "tsdown": "^0.23.0",
     "typescript": "^7.0.2",
     "vite": "^8.0.16",
     "vitest": "^4.1.0",
-    "zod": "^4.0.0"
+    "zod": "^4.4.0"
   }
 }