@somewhere-tech/cli 0.31.17 → 0.31.19

package/dist/local/compiler.js

@@ -1,683 +0,0 @@
-/**
- * The platform's compiler, running on your machine.
- *
- * `somewhere dev` does not build your app with a second toolchain that
- * resembles the platform's. It runs the SAME compiler the compile container
- * runs on deploy — `runtime/compiler/compile-core.cjs`, vendored verbatim out
- * of the monorepo with a drift guard (scripts/extract-runtime.mjs,
- * test/compiler-vendor.test.mjs) — so what renders on localhost is the deploy
- * artifact, not an approximation of it. The parity fixture
- * (test/compiler-parity.test.mjs) asserts that byte for byte.
- *
- * The compiler is host-parameterized: everything that differs between the
- * container and this machine goes in one `host` object. Concretely, three
- * things differ.
- *
- *   esbuild.  The container runs native esbuild; the CLI runs esbuild-wasm at
- *   the SAME pinned version. Not a preference — the published CLI's
- *   supply-chain rule is that every production dependency sits inside the
- *   signed artifact, and native esbuild ships 24 optional platform packages of
- *   which only the build machine's own can ever be installed. esbuild-wasm is
- *   one platform-independent package. Same version in, same bytes out; the
- *   parity fixture proves it every run.
- *
- *   Where the app's dependencies come from.  The container has a baked
- *   node_modules; you have YOUR node_modules, which is better — it is the
- *   exact tree you installed. When it is absent or does not satisfy a pin, the
- *   CLI resolves the way the container does, into a cache under
- *   ~/.somewhere/dev-deps, silently. See resolveAppDependencies below.
- *
- *   Where the BUILD toolchain comes from.  Never your project. The compiler
- *   treats typescript / postcss / autoprefixer / tailwind as its own
- *   machinery, not your app's (it deliberately refuses to install them from
- *   your package.json), so the CLI runs the container's EXACT pins from
- *   runtime/compiler/VENDOR.json into ~/.somewhere/dev-toolchain. Borrowing
- *   your tailwind 3.3 or typescript 5.2 would compile different CSS and
- *   resolve aliases differently — the precise local-vs-deploy divergence this
- *   whole loop exists to remove.
- */
-import { execFile } from 'node:child_process';
-import { createHash } from 'node:crypto';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import { homedir } from 'node:os';
-import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { promisify } from 'node:util';
-import semver from 'semver';
-import { readPlatformModules } from './compiler-core.js';
-const execFileAsync = promisify(execFile);
-/** A compile that failed, located in the developer's own source. */
-export class CompileFailure extends Error {
-    locations;
-    constructor(message, locations) {
-        super(message);
-        this.locations = locations;
-        this.name = 'CompileFailure';
-    }
-}
-function packageRoot() {
-    // dist/local/compiler.js → package root is two levels up.
-    return join(dirname(fileURLToPath(import.meta.url)), '..', '..');
-}
-/**
- * esbuild-wasm, forbidden from writing to its own stderr.
- *
- * esbuild-wasm is not a library call: it is a child `node` process running the
- * WASM build, spoken to over a length-prefixed stdio protocol. That child is
- * spawned by esbuild's own code as `stdio: ['pipe', 'pipe', 'inherit']` — its
- * stderr is OUR file descriptor 2, whatever ours happens to be.
- *
- * The child's entry shim monkey-patches `fs.writeSync` to route fd 1 and fd 2
- * through `process.stdout.write` / `process.stderr.write`. That patch is only
- * sound while those streams are sockets or TTYs. When fd 2 is a plain FILE —
- * `somewhere dev 2> dev.log`, any agent or CI harness that captures output to a
- * file, a session recorder — node backs `process.stderr` with a SyncWriteStream
- * whose `_write` calls `fs.writeSync`, which the patch has redirected back to
- * `process.stderr.write`. Each write re-enters the stream it is servicing, the
- * pending-write array grows without bound, and `Array.push` finally throws
- * `RangeError: Invalid array length` — an unhandled 'error' event that kills the
- * child. To the CLI the service simply stopped, and every later rebuild fails
- * with "The service is no longer running": one bad import took the loop down for
- * the rest of the session (tsk_d63b3b6a).
- *
- * Which builds write to stderr decides which builds crash, and that is exactly
- * the reported split. The core parses every source file with
- * `logLevel: 'silent'`, so a SYNTAX error is reported cleanly and the loop
- * survives. The bundle step passes no logLevel, so esbuild's default ('warning')
- * prints the "Could not resolve" banner — and any warning — to stderr. An
- * unresolvable import therefore crashed on every input.
- *
- * We cannot choose the child's stdio, so we remove its reason to write.
- * `logLevel: 'silent'` costs nothing: errors and warnings come back over the
- * protocol in `result.errors` / `result.warnings`, which is where the CLI has
- * always read them from — the banner was duplicate output that only ever
- * appeared on a terminal. This is a host difference, so it belongs here with the
- * other three, not in the vendored core.
- */
-export function silenceEsbuild(esbuild) {
-    const silent = (options) => ({ ...(options ?? {}), logLevel: 'silent' });
-    return {
-        ...esbuild,
-        build: (options) => esbuild.build(silent(options)),
-        context: (options) => esbuild.context(silent(options)),
-        transform: (input, options) => esbuild.transform(input, silent(options)),
-    };
-}
-/**
- * True when the error says the bridge itself is gone rather than the source is
- * bad. esbuild reports both service death and post-mortem calls with these two
- * sentences and no structured errors.
- */
-export function isServiceDeath(err) {
-    const message = err instanceof Error ? err.message : typeof err === 'string' ? err : '';
-    return /The service (?:was stopped|is no longer running)/i.test(message);
-}
-export function readVendorManifest(root = packageRoot()) {
-    return JSON.parse(readFileSync(join(root, 'runtime', 'compiler', 'VENDOR.json'), 'utf8'));
-}
-// ─── Dependency resolution, with zero steps for the developer ───────────────
-function cacheHome() {
-    return join(process.env.SOMEWHERE_DEV_CACHE ?? join(homedir(), '.somewhere'), '');
-}
-/**
- * Install `specs` into `dir` as a bare node_modules tree.
- *
- * `--ignore-scripts` is the same supply-chain guard the container uses, and it
- * matters MORE here: this runs on your machine, not in a throwaway container.
- * A dependency's postinstall never executes. esbuild bundles a package's files
- * without running them, so frontend dependencies do not need install scripts.
- */
-async function installInto(dir, specs) {
-    mkdirSync(dir, { recursive: true });
-    const manifest = join(dir, 'package.json');
-    if (!existsSync(manifest)) {
-        writeFileSync(manifest, JSON.stringify({ name: 'somewhere-dev-cache', private: true }, null, 2));
-    }
-    try {
-        await execFileAsync('npm', ['install', '--ignore-scripts', '--no-bin-links', '--no-audit', '--no-fund',
-            '--no-package-lock', '--prefix', dir, ...specs], { cwd: dir, maxBuffer: 32 * 1024 * 1024, env: { ...process.env, npm_config_ignore_scripts: 'true' } });
-    }
-    catch (err) {
-        const detail = err instanceof Error
-            ? (err.stderr ?? err.message).toString().slice(-600)
-            : String(err);
-        throw new Error(`Could not resolve ${specs.join(', ')}: ${detail}`);
-    }
-}
-/** True when `dir/node_modules/<name>` is a package esbuild would resolve. */
-function installed(dir, name) {
-    return existsSync(join(dir, 'node_modules', name, 'package.json'));
-}
-/**
- * The build toolchain, at the container's exact pins, in the CLI's cache.
- *
- * One directory per group because tailwind v3 and v4 are the same package NAME
- * at incompatible majors — the container isolates them for that reason and so
- * does this. Groups are prepared only when the project needs them: a project
- * with no Tailwind never installs a Tailwind engine.
- *
- * Returns the group directories, already populated.
- */
-async function prepareToolchain(manifest, groups, onFirstInstall) {
-    const dirs = {};
-    for (const group of groups) {
-        const pins = manifest.toolchain[group];
-        if (!pins)
-            throw new Error(`the vendored compiler declares no "${group}" toolchain group`);
-        const dir = join(cacheHome(), 'dev-toolchain', `${group}-${digestOf(pins)}`);
-        dirs[group] = dir;
-        const missing = Object.entries(pins)
-            .filter(([name]) => !installed(dir, name))
-            .map(([name, range]) => `${name}@${range}`);
-        if (!missing.length)
-            continue;
-        onFirstInstall?.(`build toolchain (${missing.map((s) => s.split('@')[0] || s).join(', ')})`);
-        await installInto(dir, missing);
-    }
-    return dirs;
-}
-/**
- * Install a dependency at the version the compile image BAKES, not the floor of
- * the declared range (tsk_0312cf17 for React, tsk_a8cb3d23 for the rest of the
- * baked set).
- *
- * The image keeps React 19 in a tree of its own and prefers it over installing
- * the app's range; locally that set does not exist, so the compiler took its
- * other branch and floor-pinned instead — `react: ^19.2.0` became exactly
- * 19.2.0 while the image served 19.2.7. The same tree, compiled by the same
- * compiler, against two different Reacts.
- *
- * That was never only about React. The image bakes ~20 more packages (router,
- * query, forms, validation, dates, charts, icons…), and `ensureDeps` prefers a
- * baked copy whenever its version satisfies the declared range — so `zod:
- * ^3.23.0` served the image's baked 3.24.x on deploy and a floor-pinned 3.23.0
- * locally. Same divergence, same fix: every group the vendor records is offered
- * here, in the container's own order (baked first, then the isolated React 19
- * set), each guarded by imagePinSatisfies so a pin is only ever taken when the
- * container itself would have taken the baked copy.
- *
- * WHAT THIS DOES NOT COVER, stated plainly: when the project has its own
- * node_modules, that tree is first on the search path and the local build uses
- * the copy the developer installed. Deliberate — it is the exact tree they
- * installed, and it is why a local loop beats a cloud one. These pins decide
- * what the CLI's own dependency cache installs when a package is NOT already
- * on the search path.
- *
- * The fix is to rewrite the spec, NOT to add a second node_modules tree. That
- * was tried and is actively worse: a package that physically lives inside the
- * dependency cache resolves `react` to its own sibling before any search path
- * is consulted, so a separate pinned tree gets bundled ALONGSIDE the cache's
- * copy — two Reacts in one bundle, which renders a blank page. The image has no
- * such problem because it ends up with one flat tree, and this keeps one too.
- *
- * Pinning the spec also stops npm resolving React on its own as a peer of
- * something else (react-router-dom pulls one in), which is how a warm cache
- * ended up serving a third version again.
- */
-export function applyImagePins(specs, deps, pinGroups) {
-    const groups = pinGroups.filter((g) => g && Object.keys(g).length > 0);
-    if (!groups.length)
-        return specs;
-    return specs.map((spec) => {
-        const at = spec.lastIndexOf('@');
-        const name = at > 0 ? spec.slice(0, at) : spec;
-        const range = deps[name];
-        for (const group of groups) {
-            const version = group[name];
-            if (version && imagePinSatisfies(version, range))
-                return `${name}@${version}`;
-        }
-        return spec;
-    });
-}
-/**
- * May the image's baked VERSION stand in for the project's declared RANGE?
- *
- * This is `bakedSatisfies` from the compile core, asked from the other side:
- * the container prefers its baked copy only when that copy satisfies the range,
- * so the local loop may pin to it only under the same condition. Without the
- * check a project that declares `react-router-dom: ^7.9.5` would be pinned to
- * the image's baked 6.x — a build that works today refused tomorrow.
- *
- * The bias is the core's, one-directional: anything we cannot POSITIVELY prove
- * satisfies — an unparseable range (`latest`, a git or alias spec), a version
- * semver rejects, semver itself unavailable — returns false and leaves the
- * core's own spec alone. A false negative costs an install of the floor-pin,
- * which is exactly today's behaviour; a false positive would compile the
- * developer's app against a library they did not ask for.
- */
-export function imagePinSatisfies(version, range) {
-    const wanted = typeof range === 'string' && range.trim() ? range.trim() : '*';
-    try {
-        if (semver.validRange(wanted) === null)
-            return false;
-        return semver.satisfies(version, wanted, { includePrerelease: false });
-    }
-    catch {
-        return false;
-    }
-}
-function digestOf(value) {
-    return createHash('sha256').update(JSON.stringify(value)).digest('hex').slice(0, 12);
-}
-/**
- * Where the APP's own dependencies come from, in resolution order.
- *
- * 1. The project's own node_modules, when it exists. This is the whole reason
- *    a local loop can beat a cloud one: the tree is already on disk and it is
- *    the exact tree the developer installed.
- * 2. A CLI-managed cache keyed by the project's dependency map, for the case
- *    where node_modules is absent (a fresh `somewhere init`, a clone with no
- *    install) or a declared pin is not satisfied by what is installed.
- *
- * Keying the cache on the dependency map rather than sharing one flat tree
- * means two projects on incompatible majors of the same package never
- * overwrite each other, and two projects with identical dependencies share the
- * install for free.
- */
-function resolveAppDependencies(cwd, pkg, pinGroups) {
-    const search = [];
-    const projectModules = join(cwd, 'node_modules');
-    if (existsSync(projectModules))
-        search.push(projectModules);
-    const deps = pkg.dependencies ?? {};
-    // The pins are part of the cache identity (tsk_0312cf17): when the image
-    // bumps a baked package and the CLI re-vendors, the old cache is simply not
-    // reused, so a warm cache can never keep serving the version we moved off.
-    const cacheDir = join(cacheHome(), 'dev-deps', digestOf([Object.entries(deps).sort(), pinGroups]));
-    // The core decides what is actually missing (its baked-satisfies rules run
-    // against this exact search path) and calls host.installPackages for the
-    // rest. All we do here is make the cache dir part of the search path.
-    search.push(join(cacheDir, 'node_modules'));
-    return search;
-}
-// ─── Entry detection — the same rule the deploy pipeline uses ───────────────
-//
-// The HTML's `<script type="module" src>` tags are the single source of truth
-// for what the compiler is allowed to touch. Mirrors
-// worker/src/utils/module-entry.ts; a divergence here would compile a
-// different entry locally than on deploy, which is the one thing this loop
-// must never do.
-export function isCompilableEntry(path) {
-    return /\.(?:tsx?|jsx|mts|cts)$/i.test(path);
-}
-export function collectModuleEntryScripts(files) {
-    const entries = new Set();
-    for (const [path, content] of Object.entries(files)) {
-        if (typeof content !== 'string')
-            continue;
-        if (!path.toLowerCase().endsWith('.html'))
-            continue;
-        const tagRe = /<script\b[^>]*>/gi;
-        let m;
-        while ((m = tagRe.exec(content)) !== null) {
-            const tag = m[0];
-            if (!/\btype\s*=\s*["']module["']/i.test(tag))
-                continue;
-            const srcMatch = /\bsrc\s*=\s*["']([^"']+)["']/i.exec(tag);
-            if (!srcMatch)
-                continue;
-            let src = srcMatch[1];
-            if (src.startsWith('/'))
-                src = src.slice(1);
-            if (isCompilableEntry(src) && files[src] !== undefined)
-                entries.add(src);
-        }
-    }
-    return entries;
-}
-export function detectBundleEntry(files) {
-    const entries = collectModuleEntryScripts(files);
-    const indexHtml = files['index.html'];
-    if (typeof indexHtml === 'string') {
-        for (const src of moduleScriptSrcs(indexHtml)) {
-            if (entries.has(src))
-                return src;
-        }
-    }
-    for (const e of entries)
-        return e;
-    return null;
-}
-/** Every `<script type="module" src>` in one HTML document, root-relative
- *  paths normalized to deploy keys. Shared by every entry rule below so they
- *  cannot disagree about what counts as a module script. */
-function moduleScriptSrcs(html) {
-    const out = [];
-    const tagRe = /<script\b[^>]*>/gi;
-    let m;
-    while ((m = tagRe.exec(html)) !== null) {
-        const tag = m[0];
-        if (!/\btype\s*=\s*["']module["']/i.test(tag))
-            continue;
-        const srcMatch = /\bsrc\s*=\s*["']([^"']+)["']/i.exec(tag);
-        if (!srcMatch)
-            continue;
-        let src = srcMatch[1];
-        if (src.startsWith('/'))
-            src = src.slice(1);
-        out.push(src);
-    }
-    return out;
-}
-/**
- * A module entry the platform serves EXACTLY as written: plain JavaScript.
- *
- * Deliberately the complement of isCompilableEntry, not an oversight in it.
- * The deploy pipeline compiles the TypeScript family and .jsx and serves
- * .js/.mjs/.cjs raw as native ESM, which is what protects browser-Babel
- * projects from being compiled twice. Both are entries; they differ only in
- * whether the platform compiles them.
- */
-export function isRawServedEntry(path) {
-    return /\.[mc]?js$/i.test(path);
-}
-/** The client entry forms `somewhere dev` and `somewhere deploy` both accept,
- *  for the message a project with no usable entry gets. */
-export const ACCEPTED_ENTRY_FORMS = '.tsx / .ts / .jsx / .mts / .cts are compiled by the platform; .js / .mjs / .cjs are served as written';
-/**
- * What the local loop should do with this project's frontend, decided from
- * index.html exactly as the deploy pipeline decides it.
- *
- * `somewhere dev` used to refuse any project whose entry was not compilable,
- * so a project with `<script type="module" src="/src/main.js">` could be
- * deployed and served but not run locally (pfb_e32a4e630c45). Deploy does not
- * refuse it — `bundleProject` simply returns null and the file is served raw
- * — and the local loop's whole promise is that it is the same build. So:
- *
- *   compiled → index.html points at a TS-family/.jsx entry: compile it.
- *   raw      → index.html points at a .js/.mjs/.cjs entry that exists on
- *              disk: serve it untouched, which is what deploy does.
- *   none     → index.html declares module scripts but none of them is a file
- *              in this directory. `declared` carries what it asked for, so
- *              the message can name the missing path.
- *
- * An index.html with NO module script at all is `raw` with no entry to name:
- * a browser-Babel page or a plain static site is a legitimate project that
- * deploys and must therefore run here too.
- */
-export function resolveDevEntry(files) {
-    const compiled = detectBundleEntry(files);
-    if (compiled)
-        return { kind: 'compiled', entry: compiled };
-    const htmlFiles = Object.entries(files).filter(([path, content]) => typeof content === 'string' && path.toLowerCase().endsWith('.html'));
-    // index.html first — it is the document the deploy serves at the root.
-    htmlFiles.sort(([a], [b]) => (a === 'index.html' ? -1 : b === 'index.html' ? 1 : 0));
-    const declared = [];
-    for (const [, content] of htmlFiles) {
-        for (const src of moduleScriptSrcs(content)) {
-            declared.push(src);
-            if (isRawServedEntry(src) && files[src] !== undefined)
-                return { kind: 'raw', entry: src };
-        }
-    }
-    if (declared.length)
-        return { kind: 'none', declared };
-    return { kind: 'raw', entry: '' };
-}
-/**
- * Point index.html at the compiled bundle instead of the raw entry, and add a
- * <link> for each CSS chunk esbuild split out. The deploy pipeline does exactly
- * this rewrite before serving (jsx-compile.ts) — the browser must receive the
- * same HTML locally or the page it renders is not the page deploy renders.
- */
-export function rewriteIndexHtml(html, entry, entryChunk, chunkNames) {
-    const escaped = entry.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    const reSourceEntry = new RegExp(`(<script\\b[^>]*\\bsrc\\s*=\\s*)(["'])/?${escaped}\\2`, 'i');
-    const reCompiledEntry = /(<script\b[^>]*\bsrc\s*=\s*)(["'])\/_compiled\/[^"']+\.js\2/i;
-    const newUrl = `/_compiled/${entryChunk}`;
-    let next = html.replace(reSourceEntry, `$1$2${newUrl}$2`);
-    if (next === html)
-        next = html.replace(reCompiledEntry, `$1$2${newUrl}$2`);
-    const cssChunks = chunkNames.filter((name) => name.endsWith('.css'));
-    const reCompiledCssLink = /<link\b[^>]*\brel\s*=\s*(["'])stylesheet\1[^>]*\bhref\s*=\s*(["'])\/_compiled\/[^"']+\.css\2[^>]*>/gi;
-    next = next.replace(reCompiledCssLink, '');
-    if (cssChunks.length) {
-        const linkTags = cssChunks.map((name) => `<link rel="stylesheet" href="/_compiled/${name}">`).join('\n');
-        const headClose = /<\/head\s*>/i;
-        const bodyOpen = /<body\b/i;
-        if (headClose.test(next))
-            next = next.replace(headClose, `${linkTags}\n</head>`);
-        else if (bodyOpen.test(next))
-            next = next.replace(bodyOpen, `${linkTags}\n<body`);
-        else
-            next = `${linkTags}\n${next}`;
-    }
-    return next;
-}
-export class LocalCompiler {
-    opts;
-    core = null;
-    searchPath = [];
-    depCacheDir = '';
-    esbuild = null;
-    constructor(opts) {
-        this.opts = opts;
-    }
-    /**
-     * Resolve everything the compiler needs before the first build, so every
-     * rebuild afterwards is pure compile time. Idempotent.
-     */
-    /**
-     * The node_modules dirs the compiler resolves the app's dependencies from,
-     * in order. The local FUNCTION runtime resolves against the same list, so a
-     * function and a component import the same copy of a package (tsk_3269026d).
-     * Empty until prepare() has run.
-     */
-    get moduleSearchPath() {
-        return this.searchPath;
-    }
-    async prepare(pkg, tailwindVersion) {
-        if (this.core)
-            return;
-        const root = packageRoot();
-        const manifest = readVendorManifest(root);
-        const requireVendored = createRequire(join(root, 'runtime', 'compiler', 'compile-core.cjs'));
-        const requireCli = createRequire(join(root, 'package.json'));
-        const groups = ['base', ...(tailwindVersion === 4 ? ['tw4'] : tailwindVersion === 3 ? ['tw3'] : [])];
-        const toolchainDirs = await prepareToolchain(manifest, groups, this.opts.onPrepare);
-        // The image's own versions, in the container's preference order: the baked
-        // tree first, the isolated React 19 set second (ensureDeps only reaches
-        // react19 when the baked React 18 does not satisfy the pin).
-        const imagePinGroups = [manifest.toolchain.baked ?? {}, manifest.toolchain.react19 ?? {}];
-        this.searchPath = resolveAppDependencies(this.opts.cwd, pkg, imagePinGroups);
-        this.depCacheDir = resolve(this.searchPath[this.searchPath.length - 1], '..');
-        const requireToolchain = (group) => createRequire(join(toolchainDirs[group], 'package.json'));
-        const requireBase = requireToolchain('base');
-        const requireTw3 = toolchainDirs.tw3 ? requireToolchain('tw3') : null;
-        const requireTw4 = toolchainDirs.tw4 ? requireToolchain('tw4') : null;
-        const { createCompileCore } = requireVendored('./compile-core.cjs');
-        // esbuild-wasm at the container's exact version. Loaded through the CLI's
-        // own require so it comes from the CLI's bundled tree, never the project's,
-        // and silenced so the WASM child never writes to an inherited stderr —
-        // see silenceEsbuild.
-        this.esbuild = requireCli('esbuild-wasm');
-        this.core = createCompileCore({
-            esbuild: silenceEsbuild(this.esbuild),
-            imageNodeModules: this.searchPath,
-            // No isolated React-19 set locally: it exists in the image to skip a cold
-            // install of react/react-dom, and here those either sit in the project's
-            // node_modules already or land in the dependency cache once and stay.
-            react19NodeModules: null,
-            tw4TailwindDir: toolchainDirs.tw4 ? join(toolchainDirs.tw4, 'node_modules', 'tailwindcss') : null,
-            requireImage: (spec) => {
-                // tailwindcss means v3 here, exactly as it does in the image; the v4
-                // engine is reached only through requireTw4.
-                if (spec === 'tailwindcss' && requireTw3)
-                    return requireTw3(spec);
-                // semver rides along in the CLI's own dependencies already.
-                if (spec === 'semver')
-                    return requireCli(spec);
-                return requireBase(spec);
-            },
-            requireTw4: requireTw4 ? (spec) => requireTw4(spec) : undefined,
-            // The container refuses to install without its per-build scoped proxy
-            // because it is egress-locked. This is the developer's own machine
-            // running their own npm; the proxy does not exist here and its absence
-            // is not a safety signal.
-            requiresPackageProxy: false,
-            installPackages: async ({ specs }) => {
-                const pinned = applyImagePins(specs, pkg.dependencies ?? {}, imagePinGroups);
-                this.opts.onPrepare?.(`${pinned.length} ${pinned.length === 1 ? 'dependency' : 'dependencies'} (${pinned.join(', ')})`);
-                await installInto(this.depCacheDir, pinned);
-            },
-            // The local loop is not a publication: no artifact upload capability, and
-            // an identity that says plainly where this build came from.
-            stamp: { source: `cli-vendored-${manifest.commit}`, toolchain: digestOf(manifest.files) },
-        });
-    }
-    /** Compile the project. Throws CompileFailure for an error in the developer's source. */
-    async compile(sources) {
-        const { files, binaryFiles } = sources;
-        const entry = detectBundleEntry(files);
-        if (!entry) {
-            throw new CompileFailure('No app entry found. index.html needs a <script type="module" src="/src/main.tsx"> pointing at your app entry — that tag is what the platform compiles, locally and on deploy.', []);
-        }
-        const transformEntries = [...collectModuleEntryScripts(files)].filter((path) => path !== entry);
-        if (!this.core)
-            throw new Error('LocalCompiler.prepare() must run before compile()');
-        const body = {
-            project_id: 'somewhere-dev-local',
-            build_id: 'somewhere-dev-local',
-            entry,
-            files,
-            binary_files: binaryFiles,
-            function_entries: [],
-            transform_entries: transformEntries,
-            package_json: files['package.json'],
-            tsconfig: files['tsconfig.json'],
-            vite_env: this.opts.viteEnv ?? {},
-        };
-        let result;
-        try {
-            result = await this.core.compile(body);
-        }
-        catch (err) {
-            // A dead bridge is not the developer's bug and must not end the session.
-            // esbuild caches one long-lived service per process, so once its child
-            // is gone EVERY later rebuild fails with the same sentence until the
-            // service is dropped. Drop it and build again: one save should never cost
-            // more than one build (tsk_d63b3b6a).
-            if (!isServiceDeath(err))
-                throw toCompileFailure(err);
-            try {
-                this.esbuild?.stop?.();
-            }
-            catch {
-                // stop() is best-effort teardown of an already-dead child.
-            }
-            try {
-                result = await this.core.compile(body);
-            }
-            catch (retryErr) {
-                if (!isServiceDeath(retryErr))
-                    throw toCompileFailure(retryErr);
-                throw new CompileFailure('The local compiler service stopped and could not be restarted. Re-run `somewhere dev`; if it keeps happening, `somewhere feedback` with this message.', []);
-            }
-        }
-        if (!result.entry_chunk)
-            throw new CompileFailure('The compiler produced no entry chunk.', []);
-        const html = typeof files['index.html'] === 'string'
-            ? rewriteIndexHtml(files['index.html'], entry, result.entry_chunk, Object.keys(result.chunks))
-            : null;
-        return {
-            entryChunk: result.entry_chunk,
-            chunks: result.chunks,
-            html,
-            entry,
-            warnings: result.warnings ?? [],
-            sourceDigest: result.source_digest,
-            artifacts: result.artifact_manifest.artifacts,
-        };
-    }
-}
-/**
- * Turn a compiler error into something with a file and a line.
- *
- * The compiler reports a syntax error as SOURCE_PARSE_ERROR with every bad
- * file joined into one message (`src/App.tsx: Expected ";" ...`). esbuild's own
- * errors carry a structured location. Both become a list of
- * {file, line, column, text} so the terminal and the browser overlay can point
- * at the exact line instead of printing a paragraph.
- */
-/**
- * Root package name for a specifier: `@scope/pkg/sub` → `@scope/pkg`,
- * `pkg/sub` → `pkg`. Mirrors the vendored core's specRootPkg, so the CLI and
- * the compiler agree on what "the package" is in an import.
- */
-function rootPackage(spec) {
-    return spec.startsWith('@') ? spec.split('/').slice(0, 2).join('/') : spec.split('/')[0];
-}
-/**
- * One sentence saying what to do about an unresolvable import.
- *
- * Two cases, and they need opposite advice. A normal npm package is missing
- * from the tree and `npm install` fixes it. A PLATFORM specifier is not on npm
- * at all — `npm install somewhere` fetches an unrelated package — so the fix is
- * always the import path, never an install. Which is which comes from the
- * vendored compiler's own PLATFORM_MODULES list (readPlatformModules), the same
- * enumeration that builds the compiler's virtual-module resolver, so the CLI
- * cannot drift into calling one of our own modules a missing dependency.
- *
- * Returns undefined for anything that is not an unresolved-import error, which
- * leaves every other message exactly as esbuild wrote it.
- */
-export function resolutionHint(text) {
-    const match = /^Could not resolve "([^"]+)"/.exec(text);
-    if (!match)
-        return undefined;
-    const spec = match[1];
-    const platformRoots = new Set(readPlatformModules().map(rootPackage));
-    if (platformRoots.has(rootPackage(spec)) || readPlatformModules().includes(spec)) {
-        return `\`${spec}\` is provided by the platform, not npm — do not add it to package.json. Check the import path: platform modules are only available where the platform supplies them (\`somewhere/db\` belongs in db/schema.ts, which the deploy reads as data and never bundles).`;
-    }
-    return `Add \`${rootPackage(spec)}\` to the dependencies in your package.json and run \`npm install\`.`;
-}
-export function toCompileFailure(err) {
-    const locations = [];
-    // The compiler's own parse phase hands back {file, line, column, message}
-    // per bad file (source_errors). Use it verbatim — it is the most precise
-    // location available, and it is what a syntax error produces.
-    const sourceErrors = err?.source_errors;
-    if (Array.isArray(sourceErrors) && sourceErrors.length) {
-        for (const e of sourceErrors) {
-            locations.push({ file: e.file, line: e.line, column: e.column, text: e.message });
-        }
-        return new CompileFailure(sourceErrors[0].message, locations);
-    }
-    const esbuildErrors = err?.errors;
-    if (Array.isArray(esbuildErrors) && esbuildErrors.length) {
-        for (const e of esbuildErrors) {
-            locations.push({
-                file: e.location?.file ?? '',
-                line: e.location?.line,
-                column: e.location ? e.location.column + 1 : undefined,
-                text: e.text,
-                hint: resolutionHint(e.text),
-            });
-        }
-        return new CompileFailure(esbuildErrors[0].text, locations);
-    }
-    const message = err instanceof Error ? err.message : String(err);
-    for (const part of message.split('; ')) {
-        // `src/App.tsx:12:4: Expected ";" but found "}"` and the shorter
-        // `src/App.tsx: Expected ...` the parse phase produces.
-        const withPos = /^([^\s:]+\.[a-z]+):(\d+):(\d+):\s*(.+)$/i.exec(part);
-        if (withPos) {
-            locations.push({
-                file: withPos[1],
-                line: Number(withPos[2]),
-                column: Number(withPos[3]),
-                text: withPos[4],
-                hint: resolutionHint(withPos[4]),
-            });
-            continue;
-        }
-        const fileOnly = /^([^\s:]+\.[a-z]+):\s*(.+)$/i.exec(part);
-        if (fileOnly)
-            locations.push({ file: fileOnly[1], text: fileOnly[2], hint: resolutionHint(fileOnly[2]) });
-    }
-    return new CompileFailure(message, locations);
-}
-//# sourceMappingURL=compiler.js.map