@pithy-sh/vite 0.1.1 → 0.1.3

package/src/clientEnvDeclaration.ts

@@ -246,18 +246,33 @@ function reindent(text: string, indent: string): string {
 /**
  * Move a block from the column it was written at to the one it is emitted at.
  *
- * The alias text arrives at whatever depth its source file put it — a union's arms at two spaces, its
- * members at six. Inside a `declare module` block those want four and eight. So the block is dedented
- * by its own first line's indent and then pushed out uniformly, which keeps every relative depth,
- * including the ` *` continuation of a doc comment.
+ * The alias text arrives at whatever depth its file put it — `tsc` prints a union's arms at zero and
+ * their members at four — and inside a `declare module` block those want four and eight. So the block
+ * is dedented to column zero and then pushed out uniformly, which keeps every relative depth, including
+ * the ` *` continuation of a doc comment.
+ *
+ * **The first line is trimmed rather than measured, and the rest are dedented by their common indent.**
+ * A type alias's body begins on the `=` line, so its first line arrives as `{` behind a single space
+ * that says nothing about the block's depth. Taking that space as the base — which is what this did
+ * until #476 changed the input from source to emitted declaration — shifted every following line one
+ * column left of where it belonged, and the misalignment was invisible in the old input only because a
+ * hand-written union happened to start on a line of its own.
  */
 function shift(text: string, indent: string): string {
   const lines = text.split("\n");
   while (lines.length > 0 && (lines[0] ?? "").trim() === "") lines.shift();
   while (lines.length > 0 && (lines.at(-1) ?? "").trim() === "") lines.pop();
-  const base = /^[ ]*/.exec(lines[0] ?? "")?.[0] ?? "";
+
+  const rest = lines.slice(1).filter((line) => line.trim() !== "");
+  const base = rest.reduce((width, line) => Math.min(width, (/^[ ]*/.exec(line)?.[0] ?? "").length), Infinity);
+  const dedent = Number.isFinite(base) ? (base as number) : 0;
+
   return lines
-    .map((line) => (line.startsWith(base) ? `${indent}${line.slice(base.length)}` : `${indent}${line.trimStart()}`))
+    .map((line, position) => {
+      if (line.trim() === "") return "";
+      const body = position === 0 ? line.trim() : line.slice(dedent);
+      return `${indent}${body}`;
+    })
     .join("\n");
 }
 
@@ -298,12 +313,34 @@ export function renderClientEnv(
   return `${PREAMBLE}\n${blocks.join("\n")}`;
 }
 
-/** Read the four projection sources through their own packages' exports maps. */
+/**
+ * Read the four projections' sources through their own packages' exports maps.
+ *
+ * **Resolved, then mirrored back to `src` — Jim, #476.** Until every package shipped a build,
+ * `@pithy-sh/auth/src/client/projection` resolved to the TypeScript itself. It resolves to
+ * `dist/client/projection.js` now, where the types are stripped and `AuthClientProjection` does not
+ * exist, so the resolved path is walked back to the module it was emitted from.
+ *
+ * The declaration beside it, `dist/client/projection.d.ts`, is the other candidate and was tried first.
+ * It is arguably the more truthful input — it is the type an adopter can actually see — but it makes
+ * this generator's build wait on five capability packages' builds, and `@pithy-sh/vite` depends on none
+ * of them. That is five cross-package `dependsOn` edges in `turbo.jsonc` that a sixth capability's
+ * projection would silently need and silently not have: the generator would read a stale declaration,
+ * emit a stale template, and say nothing. Source has no such ordering, `turbo.jsonc` already names
+ * every `packages/<name>/src/client/projection.ts` as this build's input, and the authored text is
+ * what the file's own header promises an adopter is emitted verbatim.
+ *
+ * `dist/x.js` → `src/x.ts` is not a guess about the layout: `tsdown` and `tsc -p tsconfig.build.json`
+ * both mirror `src/` into `dist/`, so the two are the same path under a different root, and
+ * `packaging.test.ts` fails on any published module missing either half.
+ */
 export async function readProjectionSources(): Promise<Map<string, string>> {
   const sources = new Map<string, string>();
   for (const declared of DECLARED_MODULES) {
-    const path = fileURLToPath(import.meta.resolve(declared.specifier));
-    sources.set(declared.module, await readFile(path, "utf8"));
+    const built = fileURLToPath(import.meta.resolve(declared.specifier));
+    const source = built.replace(/([\\/])dist\1(.+)\.js$/, "$1src$1$2.ts");
+    if (source === built) throw new Error(`${declared.specifier} did not resolve into a build: ${built}`);
+    sources.set(declared.module, await readFile(source, "utf8"));
   }
   return sources;
 }

package/src/testPlugin.ts

@@ -1,42 +1,34 @@
 // SPDX-FileCopyrightText: 2026 Pithy
 // SPDX-License-Identifier: MIT
 
-import { fileURLToPath } from "node:url";
-import { runnerImport } from "vite";
-import type { PithyPlugin, PithyPluginOptions } from "./plugin";
-
-/**
- * `./plugin.ts`, as an absolute path.
- *
- * From `import.meta.url` rather than from a bare specifier: this file's own realpath is the one place
- * the build plugin is certainly beside, whatever an adopter's `node_modules` looks like — a symlinked
- * checkout, a hoisted install, a worktree.
- */
-const BUILD_PLUGIN = fileURLToPath(new URL("./plugin.ts", import.meta.url));
+import { type PithyPlugin, type PithyPluginOptions, pithy } from "./plugin";
 
 /**
  * The Pithy plugin, for a test runner's config.
  *
- * **It is not a second plugin.** It resolves to the object {@link pithy} returns, built from
- * `./plugin.ts` itself, so a test imports the module a build inlines — same config, same
- * `resolveClientProjection`, same `renderVirtualModule`, same bytes. There is no fixture here, and
- * therefore nothing that can drift from the projection. `testPlugin.test.ts` holds that: it renders a
- * module through the build plugin's own `load` hook and makes a real child `vitest` run compare what it
- * imports against it.
+ * **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
  *
- * ## Why the indirection exists at all
+ * 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.
  *
- * Vitest loads its config by bundling it and leaving every **bare** specifier to node. So
- * `import { pithy } from "@pithy-sh/vite/src/plugin"` in a `vitest.config.ts` is handed to node, which
- * loads `plugin.ts` — and stops at its `@pithy-sh/core/src/capability/client` import, whose own
- * `../error/pithyError` has no extension for node to resolve. The config never loads and no test runs.
- * `vitest.shared.ts` in this repository documents the same wall from the other side, for the same reason.
+ * `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.
  *
- * This module's whole static graph is `vite` and `node:url` — both things node loads — and the kit
- * source is reached through {@link runnerImport}, which is vite's own loader and resolves extensionless
- * TypeScript the way every other Pithy import site does. That constraint is load-bearing: **any
- * `@pithy-sh/*` import added to this file breaks every adopter's test run at config load.** The child
- * run in `testPlugin.test.ts` is what says so out loud.
+ * **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
  *
@@ -55,14 +47,13 @@ const BUILD_PLUGIN = fileURLToPath(new URL("./plugin.ts", import.meta.url));
  * rather than the Worker's directory — so a monorepo names the Worker, and a single-Worker project takes
  * the default.
  *
- * A promise, because vite awaits a plugin. That is a documented `PluginOption`, and it is what lets the
- * real plugin be built by vite's loader instead of restated for node's.
- *
- * `Promise<PithyPlugin>` rather than `Promise<Plugin>` 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 typechecked against it unless their install happened to deduplicate onto the same copy.
- * The test config is the same surface as the build config and takes the same rule.
+ * 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 function pithyTest(options: PithyPluginOptions = {}): Promise<PithyPlugin> {
-  return runnerImport<typeof import("./plugin")>(BUILD_PLUGIN).then(({ module }) => module.pithy(options));
+  return Promise.resolve(pithy(options));
 }