@astralarium/repo-dev 0.0.0-stage → 0.1.0

package/dist/vite.js

@@ -0,0 +1,254 @@
+/**
+ * Vite plugins and config: the launcher's listener, Cloudflare plugin
+ * options, the build guard, the Tailwind dev-source exclusion, the
+ * prerender runtime and worker config, and rename recovery.
+ */
+import { existsSync, globSync, readFileSync, realpathSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { parseLocalOrigins, parseOrigin } from "@astralarium/repo-env";
+import { isDevFile, isServerFile, isTestFile, workspacePackageDirs, workspaceRoot, } from "@astralarium/repo-package-files";
+import { ExpectedError } from "@astralarium/repo-telemetry";
+import { normalizePath, } from "vite";
+/**
+ * Listener of a launched app (`listenerEnv`): dev servers serve on
+ * `SITE_ORIGIN`'s port, over HTTPS with `SSL_KEY` / `SSL_CERT`; every
+ * server binds `DEV_SERVER_HOST` (default `localhost`) on a strict port
+ * and allows the `LOCAL_ORIGINS` hostnames. Config comes from process env:
+ * Vite reads no dot-env file.
+ */
+export function devListener({ command, isPreview, mode }, env = process.env) {
+    // Vitest runs in mode `test`.
+    const development = command === "serve" && !isPreview && mode !== "test";
+    const origin = development
+        ? new URL(parseOrigin(env.SITE_ORIGIN))
+        : undefined;
+    const key = development && env.SSL_KEY;
+    const cert = development && env.SSL_CERT;
+    return {
+        envDir: false,
+        server: {
+            port: origin
+                ? Number(origin.port || (origin.protocol === "https:" ? 443 : 80))
+                : undefined,
+            // Blank from `appProcessEnv` outside a `host` server.
+            host: env.DEV_SERVER_HOST === undefined || env.DEV_SERVER_HOST === ""
+                ? "localhost"
+                : env.DEV_SERVER_HOST,
+            strictPort: true,
+            https: key && cert
+                ? { key: readFileSync(key, "utf8"), cert: readFileSync(cert, "utf8") }
+                : undefined,
+            allowedHosts: parseLocalOrigins(env.LOCAL_ORIGINS).hostnames,
+        },
+    };
+}
+/**
+ * Cloudflare Vite plugin options of a launched app: a `testEnv` build
+ * (`CLOUDFLARE_ENV`, the Vitest fixtures') keeps no state and opens no
+ * inspector; other servers open `DEV_INSPECTOR_PORT` (`listenerEnv`), or
+ * none when it is blank or unset.
+ */
+export function cloudflareDevOptions({ testEnv = "test", env = process.env, } = {}) {
+    if (env.CLOUDFLARE_ENV === testEnv)
+        return { persistState: false, inspectorPort: false };
+    return {
+        inspectorPort: env.DEV_INSPECTOR_PORT
+            ? Number(env.DEV_INSPECTOR_PORT)
+            : false,
+    };
+}
+/** Inline limits the check set, across instances: a config may evaluate
+ *  and resolve more than once. */
+const inlineLimits = new WeakSet();
+/**
+ * Fails a build shipping dev files or test support, or server-only
+ * modules in a client environment (`isDevFile`, `isTestFile`,
+ * `isServerFile` from `@astralarium/repo-package-files`). Dev assets never inline,
+ * so they emit and fail; library builds inline every asset, skipping
+ * the check.
+ */
+export function buildGuard() {
+    let config;
+    let configured = false;
+    return {
+        name: "repo:build-guard",
+        apply: "build",
+        config(user) {
+            const limit = user.build?.assetsInlineLimit;
+            const inlineLimit = (file, content) => {
+                if (isDevFile(file))
+                    return false;
+                if (typeof limit === "function")
+                    return limit(file, content);
+                return limit === undefined ? undefined : content.length < limit;
+            };
+            inlineLimits.add(inlineLimit);
+            configured = true;
+            return {
+                build: { assetsInlineLimit: inlineLimit },
+                // Vite appends these to the user's worker plugins.
+                worker: { plugins: () => [buildGuard()] },
+            };
+        },
+        configResolved(resolved) {
+            config = resolved;
+            // Worker builds inherit the main build's limit, checked there.
+            const limit = resolved.build.assetsInlineLimit;
+            if (configured &&
+                !resolved.isWorker &&
+                !(typeof limit === "function" && inlineLimits.has(limit)))
+                throw new ExpectedError("repo:build-guard: a later plugin replaced build.assetsInlineLimit; dev assets could inline unchecked");
+            if (resolved.publicDir && isDevFile(join(resolved.publicDir, "_")))
+                throw new ExpectedError(`repo:build-guard: publicDir ${resolved.publicDir} is a dev folder`);
+        },
+        generateBundle(_, bundle) {
+            const assets = Object.values(bundle).flatMap((output) => output.type === "asset"
+                ? output.originalFileNames.map((name) => resolve(config.root, name))
+                : []);
+            const modules = [...this.getModuleIds()];
+            const found = (files, test) => [
+                ...new Set(files
+                    .filter(test)
+                    .map((id) => relative(config.root, id.replace(/^\0/, "").split("?")[0] ?? id))),
+            ].sort();
+            const failures = [];
+            const dev = found([...modules, ...assets], isDevFile);
+            if (dev.length > 0)
+                failures.push(`dev-only files in the build${config.isProduction ? "" : " (build with NODE_ENV=production)"}: ${dev.join(", ")}`);
+            const test = found(modules, isTestFile);
+            if (test.length > 0)
+                failures.push(`test support in the build: ${test.join(", ")}`);
+            // Web workers build apart from the environment that starts them.
+            const client = config.isWorker || this.environment.config.consumer === "client";
+            const server = client ? found(modules, isServerFile) : [];
+            if (server.length > 0)
+                failures.push(`server-only modules in the client build: ${server.join(", ")}`);
+            if (failures.length > 0)
+                this.error(failures.join("\n"));
+        },
+    };
+}
+/**
+ * Keeps dev classes out of built CSS: appends `@source not` for each
+ * workspace package's dev folders (`isDevFile`) to every Tailwind entry
+ * (CSS importing `tailwindcss`). Precedes `tailwindcss()`. Skips
+ * `?url`/`?raw`, which wrap the CSS as JS.
+ */
+export function tailwindDevSources() {
+    let devDirs = [];
+    return {
+        name: "repo:tailwind-dev-sources",
+        apply: "build",
+        enforce: "pre",
+        configResolved(resolved) {
+            devDirs = workspaceDevDirs(resolved.root);
+        },
+        transform: {
+            filter: {
+                id: { include: /\.css(?:\?|$)/, exclude: /[?&](?:url|raw)\b/ },
+                code: /@import\s+["']tailwindcss["']/,
+            },
+            handler(code, id) {
+                const dir = dirname(id.split("?")[0] ?? id);
+                const sources = devDirs.map((devDir) => `@source not "${normalizePath(relative(dir, devDir))}";`);
+                return `${code}\n${sources.join("\n")}\n`;
+            },
+        },
+    };
+}
+/** Dev folders of the packages in `root`'s pnpm workspace, at any depth;
+ *  `root` alone outside one. */
+function workspaceDevDirs(root) {
+    const workspace = workspaceRoot(realpathSync(root));
+    const packages = workspace ? workspacePackageDirs(workspace) : [root];
+    return packages.flatMap((dir) => globSync("**/dev", { cwd: dir, exclude: ["**/node_modules/**"] })
+        .sort()
+        .map((path) => join(dir, path))
+        .filter((path) => isDevFile(join(path, "_"))));
+}
+/**
+ * Reuses the compiled SSR bundle inside an isolated prerender worker: the
+ * prerender environment's `entry` re-exports the SSR build's
+ * `wrangler.json` `main`, emitted under `runtime/`. Requires the Cloudflare
+ * Vite plugin: its entry worker builds as the `ssr` environment (TanStack
+ * Start's server) and writes `wrangler.json`; its
+ * `experimental.prerenderWorker` builds as `environment`.
+ */
+export function prerenderRuntime({ entry, environment = "prerender", }) {
+    let entryPath;
+    let runtime;
+    return {
+        name: "repo:prerender-runtime",
+        apply: "build",
+        enforce: "pre",
+        applyToEnvironment: ({ name }) => name === environment,
+        configEnvironment(name) {
+            // Server environments drop emitted assets by default.
+            if (name === environment)
+                return { build: { emitAssets: true } };
+        },
+        configResolved(config) {
+            const server = config.environments.ssr;
+            if (!server)
+                throw new ExpectedError("repo:prerender-runtime: prerender requires the ssr environment");
+            // Module ids are normalized paths, `/`-separated on every platform.
+            entryPath = normalizePath(resolve(config.root, entry));
+            runtime = resolve(config.root, server.build.outDir);
+        },
+        resolveId(source) {
+            if (source !== "virtual:prerender-runtime")
+                return;
+            const config = join(runtime, "wrangler.json");
+            if (!existsSync(config))
+                this.error(`${config} is missing: prerender needs the Cloudflare Vite plugin's entry worker as the ssr environment`);
+            const { main } = JSON.parse(readFileSync(config, "utf8"));
+            return { id: `./runtime/${main}`, external: true };
+        },
+        load(id) {
+            if (id === entryPath)
+                return 'export { default } from "virtual:prerender-runtime";';
+        },
+        generateBundle() {
+            for (const file of globSync("**/*.{js,mjs,wasm}", { cwd: runtime }))
+                this.emitFile({
+                    type: "asset",
+                    fileName: `runtime/${file}`,
+                    source: readFileSync(join(runtime, file)),
+                });
+        },
+    };
+}
+/**
+ * Isolates the prerender worker from runtime bindings and secrets: the
+ * Cloudflare Vite plugin's `experimental.prerenderWorker.config`. The
+ * worker runs the entry worker's bundle (`main`, compatibility date and
+ * flags) with `vars` as its whole environment; the entry worker's
+ * bindings, other vars, and required secrets stay behind.
+ */
+export function prerenderWorkerConfig({ name, vars, }) {
+    return (_, { entryWorkerConfig }) => ({
+        name,
+        main: entryWorkerConfig.main,
+        compatibility_date: entryWorkerConfig.compatibility_date,
+        compatibility_flags: entryWorkerConfig.compatibility_flags,
+        secrets: { required: [] },
+        vars: vars(entryWorkerConfig.vars),
+    });
+}
+/**
+ * Re-transforms a deleted file's importers, so a rename reaches them.
+ * Vite soft-invalidates them: their code keeps the deleted import path.
+ */
+export function renameRecovery() {
+    return {
+        name: "repo:rename-recovery",
+        apply: "serve",
+        hotUpdate({ type, modules }) {
+            if (type !== "delete")
+                return;
+            const importers = modules.flatMap((mod) => [...mod.importers]);
+            if (importers.length > 0)
+                return [...modules, ...importers];
+        },
+    };
+}

package/dist/wait.d.ts

@@ -0,0 +1,9 @@
+/** Default `waitFor` deadline. */
+export declare const READY_TIMEOUT_MS = 120000;
+/** TCP connect succeeds within 1s. */
+export declare function isPortOpen(port: number, host?: string): Promise<boolean>;
+/** Polls `probe` each second until true; rejects with `message` at the deadline. */
+export declare function waitFor(probe: () => boolean | Promise<boolean>, message: string, timeoutMs?: number, signal?: AbortSignal): Promise<void>;
+/** Polls until localhost `port` refuses connections; rejects with
+ *  `message` after 15s. */
+export declare function waitForPortClose(port: number, message: string, signal?: AbortSignal): Promise<void>;

package/dist/wait.js

@@ -0,0 +1,38 @@
+/** Readiness polling: TCP probes and a deadline loop. */
+import { connect } from "node:net";
+import { setTimeout as sleep } from "node:timers/promises";
+import { ExpectedError } from "@astralarium/repo-telemetry";
+/** Default `waitFor` deadline. */
+export const READY_TIMEOUT_MS = 120_000;
+/** TCP connect succeeds within 1s. */
+export function isPortOpen(port, host = "127.0.0.1") {
+    return new Promise((done) => {
+        const sock = connect({ host, port, timeout: 1_000 });
+        sock.once("connect", () => {
+            sock.destroy();
+            done(true);
+        });
+        sock.once("error", () => done(false));
+        sock.once("timeout", () => {
+            sock.destroy();
+            done(false);
+        });
+    });
+}
+/** Polls `probe` each second until true; rejects with `message` at the deadline. */
+export async function waitFor(probe, message, timeoutMs = READY_TIMEOUT_MS, signal) {
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        signal?.throwIfAborted();
+        if (await probe())
+            return;
+        if (Date.now() > deadline)
+            throw new ExpectedError(message);
+        await sleep(1_000, undefined, { signal });
+    }
+}
+/** Polls until localhost `port` refuses connections; rejects with
+ *  `message` after 15s. */
+export function waitForPortClose(port, message, signal) {
+    return waitFor(async () => !(await isPortOpen(port, "localhost")), message, 15_000, signal);
+}

package/package.json

@@ -1,6 +1,74 @@
 {
   "name": "@astralarium/repo-dev",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "license": "MIT",
+  "homepage": "https://github.com/astralarium/repo/tree/main/packages/repo-dev#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/astralarium/repo.git",
+    "directory": "packages/repo-dev"
+  },
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": "./dist/index.js",
+    "./launcher": "./dist/launcher/launcher.js",
+    "./testkit": "./dist/testkit/index.js",
+    "./vite": "./dist/vite.js"
+  },
+  "bin": {
+    "db-image": "./dist/bin/db-image.js",
+    "run-dev": "./dist/bin/run-dev.js",
+    "siblings-inputs": "./dist/bin/siblings-inputs.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "json5": "^2.2.3",
+    "undici": "^7.29.0",
+    "zod": "^4.6.7",
+    "@astralarium/repo-telemetry": "^0.1.0",
+    "@astralarium/repo-env": "^0.1.0",
+    "@astralarium/repo-package-files": "^0.1.0",
+    "@astralarium/repo-deploy-info": "^0.1.0"
+  },
+  "devDependencies": {
+    "@cloudflare/vite-plugin": "^1.54.10",
+    "@types/node": "^24.2.0",
+    "eslint": "^10.2.1",
+    "turbo": "^2.10.13",
+    "typescript": "^6.0.3",
+    "vite": "^8.3.4",
+    "vitest": "^5.0.3",
+    "wrangler": "^4.132.0",
+    "@astralarium/repo-config-typescript": "^0.1.0",
+    "@astralarium/repo-config-eslint": "^0.1.0"
+  },
+  "peerDependencies": {
+    "turbo": "^2.10.13",
+    "vite": "^8.3.4",
+    "vitest": "^5.0.3"
+  },
+  "peerDependenciesMeta": {
+    "turbo": {
+      "optional": true
+    },
+    "vite": {
+      "optional": true
+    },
+    "vitest": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=24.2"
+  },
+  "scripts": {
+    "check-types": "tsc --noEmit && tsc -p tsconfig.build.json --noEmit",
+    "lint": "eslint",
+    "test": "vitest"
+  }
 }