@devdogsuga/devtools 0.1.25 → 0.1.27

package/dist/repo/peers.js

@@ -1,139 +0,0 @@
-/**
- * Loads devtools' optional-peer `@devdogsuga/*` libraries — the ones
- * published to npm and consumed by the TARGET repo, which devtools reads at
- * runtime rather than bundling its own copy of (see this package's
- * `package.json`: `peerDependencies` + `peerDependenciesMeta.optional`, and
- * `FINDINGS.md` experiment 2).
- *
- * Every export here is memoized per module (one dynamic `import()` per
- * process, not per call) — this is what makes the module-identity guarantee
- * in FINDINGS experiment 3 hold: every devtools call site that needs
- * `@devdogsuga/env`'s registry gets the exact same module instance the
- * repo's own manifests populated via `declare()`/`define()`, because both
- * resolve to the identical absolute file path and Node's ESM cache is keyed
- * by resolved URL.
- */
-import { pathToFileURL } from "node:url";
-import { findRepoRoot, RepoNotFoundError } from "./root.js";
-import { findDependent, resolveFromRepo } from "./resolve.js";
-const moduleCache = new Map();
-/** The file URL each peer resolved to through the target repo, set only on
- *  that path (not on either plain bare-specifier fallback). See
- *  `repoPeerUrl()`. */
-const resolvedUrls = new Map();
-/**
- * Dynamically imports `specifier` as the repo would resolve it, memoized so
- * repeated calls in one process return the SAME module instance (required
- * for the env-registry identity guarantee above).
- *
- * Falls back to a plain bare-specifier `import()` when devtools is not
- * running inside a DevDogsUGA checkout at all (`findRepoRoot()` throws
- * `RepoNotFoundError`). That is not a production affordance — under real
- * `pnpm dlx` use, `specifier` is an optional peer devtools' own package
- * never installs, so the fallback import fails with the ordinary
- * `MODULE_NOT_FOUND` either way. It exists so devtools' OWN test suite
- * (which has no target repo to discover, but does have every one of these
- * peers as a real Backstage workspace package) exercises this code against
- * the genuine package rather than needing every test to mock this module.
- */
-function loadPeer(specifier) {
-    const cached = moduleCache.get(specifier);
-    if (cached)
-        return cached;
-    const promise = (async () => {
-        // See `findRepoRoot()`'s own comment: Backstage's test suite sets this
-        // so every peer resolves to the real Backstage-workspace copy instead
-        // of a nonexistent target repo, without a per-test mock.
-        if (process.env.DEVTOOLS_TEST_REPO_ROOT) {
-            return import(specifier);
-        }
-        let repoRoot;
-        try {
-            repoRoot = findRepoRoot();
-        }
-        catch (err) {
-            if (err instanceof RepoNotFoundError) {
-                return import(specifier);
-            }
-            throw err;
-        }
-        const resolutionBase = findDependent(repoRoot, specifier);
-        if (!resolutionBase) {
-            throw new Error(`Nothing in this repo depends on ${specifier} — expected an app or package under apps/*` +
-                ` or packages/* to declare it (dependencies/devDependencies/peerDependencies).`);
-        }
-        const { resolvedPath } = resolveFromRepo(repoRoot, resolutionBase, specifier);
-        const url = pathToFileURL(resolvedPath).href;
-        resolvedUrls.set(specifier, url);
-        return import(url);
-    })();
-    moduleCache.set(specifier, promise);
-    return promise;
-}
-/** Test-only: clears the memoized peer modules so a test can re-resolve with a fresh mock. */
-export function resetPeerCacheForTests() {
-    moduleCache.clear();
-    resolvedUrls.clear();
-}
-/**
- * The file URL `specifier` was loaded from through the target repo, or
- * undefined if it has not been loaded yet or came from a plain bare-specifier
- * `import()` (the test-suite and not-in-a-repo fallbacks above).
- *
- * For code devtools imports that itself names a peer by bare specifier --
- * today only devtools' own `env.ts` manifest. From an installed copy that
- * specifier cannot resolve at all (an optional peer is never installed next
- * to devtools under `pnpm dlx`), and even where it can, the only copy that
- * keeps module identity is this one. `repo/peer-redirect.ts` uses it to
- * point the import here.
- */
-export function repoPeerUrl(specifier) {
-    return resolvedUrls.get(specifier);
-}
-let resolvedEnvModule;
-export function loadEnv() {
-    return loadPeer("@devdogsuga/env").then((mod) => {
-        resolvedEnvModule = mod;
-        return mod;
-    });
-}
-/**
- * The synchronous companion to `loadEnv()`, for the handful of call sites
- * (`gh/environments.ts`'s `GITHUB_ENVIRONMENT_SPECS` getters) that cannot
- * become async without changing their own callers' contract — they read a
- * plain array off a getter, not a Promise. Safe ONLY after `loadEnv()` has
- * resolved at least once; every caller of these getters already requires
- * `env/discovery.ts`'s `loadRegistry()` (which calls `loadEnv()` itself) to
- * have run first, via `assertRegistryLoaded()`'s own guard.
- */
-export function getEnvSync() {
-    if (!resolvedEnvModule) {
-        throw new Error("getEnvSync() called before loadEnv() ever resolved — call loadRegistry() " +
-            "(env/discovery.ts) first.");
-    }
-    return resolvedEnvModule;
-}
-/** Test-only: clears the sync cache alongside `resetPeerCacheForTests()`. */
-export function resetEnvSyncCacheForTests() {
-    resolvedEnvModule = undefined;
-}
-export function loadEnvLoad() {
-    return loadPeer("@devdogsuga/env/load");
-}
-export function loadEnvSession() {
-    return loadPeer("@devdogsuga/env/session");
-}
-export function loadDbTypegen() {
-    return loadPeer("@devdogsuga/db/typegen");
-}
-export function loadBrandEvent() {
-    return loadPeer("@devdogsuga/brand/event");
-}
-export function loadEvents() {
-    return loadPeer("@devdogsuga/events");
-}
-// `@devdogsuga/newsletter` used to be an optional peer here, read by
-// devtools' own `newsletter` command. Wave 2, stage A2 moved that command to
-// a plain Backstage script (`packages/newsletter-cli`) — see its README —
-// since the content it exports lives in Backstage already; devtools has no
-// reason to load it at all any more.

package/dist/repo/resolve.d.ts

@@ -1,41 +0,0 @@
-export interface ResolvedFromRepo {
-    /** Absolute path to the resolved module entry point. */
-    resolvedPath: string;
-    /** The version declared in the resolved package's own `package.json`. */
-    version: string;
-    /** Absolute path to the resolved package's `package.json`. */
-    pkgJsonPath: string;
-}
-/**
- * The installable package name a (possibly subpath) specifier belongs to:
- * `@devdogsuga/env/load` → `@devdogsuga/env`, `foo/bar` → `foo`. A repo's
- * package.json declares the PACKAGE as a dependency, never a subpath, so
- * `findDependent` has to search on this rather than the literal specifier a
- * caller wants to import.
- */
-export declare function packageNameOf(specifier: string): string;
-/**
- * Scans `apps/*` and `packages/*` under `repoRoot` for the first
- * `package.json` whose `dependencies`/`devDependencies`/`peerDependencies`
- * names `specifier`'s package (see `packageNameOf`). Returns its path
- * relative to `repoRoot`, or `null` if nothing in the repo depends on it.
- *
- * Re-scans the filesystem on every call — fine for a short-lived CLI
- * invocation calling this a handful of times; see FINDINGS item 5 if this
- * is ever called in a hot loop.
- */
-export declare function findDependent(repoRoot: string, specifier: string): string | null;
-/**
- * Resolves `specifier` as `resolutionBase` (a workspace-relative
- * `package.json` path known to depend on it, from `findDependent()`) would
- * see it.
- *
- * `opts.condition`, when given, is NOT passed through to Node's resolver —
- * `require.resolve` ignores tsx's `register({ conditions })` entirely (see
- * this module's header). Instead the target package's own
- * `exports["."]` map is read directly and `exports["."][condition]` is
- * picked, falling back to `.default`.
- */
-export declare function resolveFromRepo(repoRoot: string, resolutionBase: string, specifier: string, opts?: {
-    condition?: string;
-}): ResolvedFromRepo;

package/dist/repo/resolve.js

@@ -1,152 +0,0 @@
-/**
- * Resolves an `@devdogsuga/*` package FROM the target repo, not from
- * devtools' own (dlx-isolated) `node_modules`.
- *
- * Ported from the `devtools-dlx` prototype
- * (`/home/sloan/scratchpad/devdogs/prototypes/devtools-dlx/FINDINGS.md`,
- * experiments 2 and 4 — read that file for the two gotchas this module
- * exists to avoid). The short version:
- *
- *   - `require.resolve(\`${specifier}/package.json\`)` throws
- *     `ERR_PACKAGE_PATH_NOT_EXPORTED` on packages (like `@devdogsuga/env`,
- *     `@devdogsuga/open-graph`) whose `exports` map does not list
- *     `"./package.json"`, even though the file is on disk.
- *   - A resolved path cannot be assumed to contain a literal
- *     `node_modules/<specifier>` segment — pnpm workspace-linked packages
- *     resolve to their REALPATH (e.g. `packages/open-graph/dist/index.js`),
- *     which has no such segment at all.
- *   - `require.resolve` ignores whatever `conditions` a caller has set on
- *     `tsx`'s `register()` — condition-based resolution (the
- *     `devdogs-source` condition) has to be done by hand, reading the
- *     target package's own `exports["."]` map.
- *
- * Both problems are solved the same way: walk up from the resolved file's
- * directory to the nearest `package.json` whose own `"name"` field matches
- * the specifier. That works for a real installed dependency AND a
- * workspace symlink, uniformly.
- */
-import { createRequire } from "node:module";
-import { existsSync, readFileSync, readdirSync } from "node:fs";
-import { dirname, join } from "node:path";
-/**
- * The installable package name a (possibly subpath) specifier belongs to:
- * `@devdogsuga/env/load` → `@devdogsuga/env`, `foo/bar` → `foo`. A repo's
- * package.json declares the PACKAGE as a dependency, never a subpath, so
- * `findDependent` has to search on this rather than the literal specifier a
- * caller wants to import.
- */
-export function packageNameOf(specifier) {
-    const parts = specifier.split("/");
-    return specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
-}
-/**
- * Scans `apps/*` and `packages/*` under `repoRoot` for the first
- * `package.json` whose `dependencies`/`devDependencies`/`peerDependencies`
- * names `specifier`'s package (see `packageNameOf`). Returns its path
- * relative to `repoRoot`, or `null` if nothing in the repo depends on it.
- *
- * Re-scans the filesystem on every call — fine for a short-lived CLI
- * invocation calling this a handful of times; see FINDINGS item 5 if this
- * is ever called in a hot loop.
- */
-export function findDependent(repoRoot, specifier) {
-    const packageName = packageNameOf(specifier);
-    const groups = ["apps", "packages"];
-    for (const group of groups) {
-        const groupDir = join(repoRoot, group);
-        let entries;
-        try {
-            entries = readdirSync(groupDir);
-        }
-        catch {
-            continue;
-        }
-        for (const entry of entries) {
-            const pkgJsonPath = join(groupDir, entry, "package.json");
-            if (!existsSync(pkgJsonPath))
-                continue;
-            let pkg;
-            try {
-                pkg = JSON.parse(readFileSync(pkgJsonPath, "utf8"));
-            }
-            catch {
-                continue;
-            }
-            const deps = {
-                ...pkg.dependencies,
-                ...pkg.devDependencies,
-                ...pkg.peerDependencies,
-            };
-            if (packageName in deps) {
-                return join(group, entry, "package.json");
-            }
-        }
-    }
-    return null;
-}
-/** Walks up from `startDir` to the nearest `package.json` whose `"name"` matches `specifier`. */
-function findOwningPackageJson(startDir, specifier) {
-    const packageName = packageNameOf(specifier);
-    let dir = startDir;
-    for (;;) {
-        const candidate = join(dir, "package.json");
-        if (existsSync(candidate)) {
-            try {
-                const pkg = JSON.parse(readFileSync(candidate, "utf8"));
-                if (pkg.name === packageName)
-                    return candidate;
-            }
-            catch {
-                // fall through and keep walking
-            }
-        }
-        const parent = dirname(dir);
-        if (parent === dir) {
-            throw new Error(`resolveFromRepo: could not find ${specifier}'s own package.json by walking up from ${startDir}`);
-        }
-        dir = parent;
-    }
-}
-/**
- * Resolves `specifier` as `resolutionBase` (a workspace-relative
- * `package.json` path known to depend on it, from `findDependent()`) would
- * see it.
- *
- * `opts.condition`, when given, is NOT passed through to Node's resolver —
- * `require.resolve` ignores tsx's `register({ conditions })` entirely (see
- * this module's header). Instead the target package's own
- * `exports["."]` map is read directly and `exports["."][condition]` is
- * picked, falling back to `.default`.
- */
-export function resolveFromRepo(repoRoot, resolutionBase, specifier, opts) {
-    const baseFile = join(repoRoot, resolutionBase);
-    const require = createRequire(baseFile);
-    let resolvedPath;
-    if (opts?.condition) {
-        // Find the package's own package.json first (via a plain resolve of the
-        // specifier itself, which DOES work through node's default conditions),
-        // then read its exports map by hand.
-        const defaultEntry = require.resolve(specifier);
-        const pkgJsonPath = findOwningPackageJson(dirname(defaultEntry), specifier);
-        const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf8"));
-        const rootExport = pkg.exports?.["."];
-        const conditioned = rootExport && typeof rootExport === "object"
-            ? (rootExport[opts.condition] ??
-                rootExport.default)
-            : undefined;
-        if (typeof conditioned !== "string") {
-            throw new Error(`resolveFromRepo: ${specifier} has no "${opts.condition}" (or "default") export in its exports["."] map`);
-        }
-        resolvedPath = join(dirname(pkgJsonPath), conditioned);
-    }
-    else {
-        resolvedPath = require.resolve(specifier);
-    }
-    const pkgJsonPath = findOwningPackageJson(dirname(resolvedPath), specifier);
-    const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf8"));
-    return {
-        resolvedPath,
-        version: pkg.version ?? "0.0.0",
-        pkgJsonPath,
-    };
-}

package/dist/repo/root.d.ts

@@ -1,23 +0,0 @@
-export declare class RepoNotFoundError extends Error {
-    constructor();
-}
-/**
- * Walks up from `startDir` (default `process.cwd()`) looking for the repo
- * marker. Returns `null` rather than throwing — `findRepoRoot()` below is
- * the throwing convenience most callers want; this is exported for callers
- * (like `setup`) that need to know without failing.
- */
-export declare function discoverRepoRoot(startDir?: string): string | null;
-/**
- * The memoized, throwing repo-root lookup. Lazy on purpose: importing this
- * module must never fail just because nothing has called it yet (`setup`
- * and `completions` in `launch.ts` never need a repo at all, and must stay
- * that way — see that file's header comment on why).
- *
- * Resolved once per process: `process.cwd()` does not change mid-invocation
- * for this CLI, and re-walking the filesystem on every call would be pure
- * waste.
- */
-export declare function findRepoRoot(): string;
-/** Test-only: clears the memoized root so a test can point `process.cwd()` elsewhere. */
-export declare function resetRepoRootCacheForTests(): void;

package/dist/repo/root.js

@@ -1,91 +0,0 @@
-/**
- * Where devtools finds the DevDogsUGA checkout it is running against.
- *
- * devtools used to live inside `packages/devtools` of that repo, so its own
- * `import.meta.url` WAS a path into the repo (`PROJECT_ROOT` /
- * `REPO_ROOT` walked up a fixed number of `..` segments from this file).
- * Published as its own package and run through `pnpm dlx`, that assumption
- * breaks: this file's `import.meta.url` points into a dlx cache directory
- * or an isolated `node_modules` tree that has nothing to do with the repo
- * the contributor is standing in.
- *
- * So repo discovery walks up from `process.cwd()` instead, looking for the
- * marker validated in the `devtools-dlx` prototype
- * (`/home/sloan/scratchpad/devdogs/prototypes/devtools-dlx/FINDINGS.md`,
- * experiment 1): a directory containing `pnpm-workspace.yaml` AND whose
- * `package.json` has `"name": "devdogs-monorepo"`. The name check is not
- * redundant — a bare `pnpm-workspace.yaml` also matches a Backstage
- * checkout (a separate pnpm workspace), which devtools should refuse
- * rather than silently "find".
- */
-import { existsSync, readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-/** The `package.json` name every real DevDogsUGA checkout carries at its root. */
-const REPO_MARKER_NAME = "devdogs-monorepo";
-export class RepoNotFoundError extends Error {
-    constructor() {
-        super("run this from inside a DevDogsUGA clone");
-        this.name = "RepoNotFoundError";
-    }
-}
-function looksLikeRepoRoot(dir) {
-    if (!existsSync(join(dir, "pnpm-workspace.yaml")))
-        return false;
-    try {
-        const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
-        return pkg.name === REPO_MARKER_NAME;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Walks up from `startDir` (default `process.cwd()`) looking for the repo
- * marker. Returns `null` rather than throwing — `findRepoRoot()` below is
- * the throwing convenience most callers want; this is exported for callers
- * (like `setup`) that need to know without failing.
- */
-export function discoverRepoRoot(startDir = process.cwd()) {
-    let dir = startDir;
-    for (;;) {
-        if (looksLikeRepoRoot(dir))
-            return dir;
-        const parent = dirname(dir);
-        if (parent === dir)
-            return null;
-        dir = parent;
-    }
-}
-let cachedRoot;
-/**
- * The memoized, throwing repo-root lookup. Lazy on purpose: importing this
- * module must never fail just because nothing has called it yet (`setup`
- * and `completions` in `launch.ts` never need a repo at all, and must stay
- * that way — see that file's header comment on why).
- *
- * Resolved once per process: `process.cwd()` does not change mid-invocation
- * for this CLI, and re-walking the filesystem on every call would be pure
- * waste.
- */
-export function findRepoRoot() {
-    if (cachedRoot === undefined) {
-        // Backstage's own test suite has no DevDogsUGA checkout to discover —
-        // it IS a different pnpm workspace — but most of devtools' unit tests
-        // exercise code that calls `findRepoRoot()` only to build a path string
-        // that a mocked `node:fs/promises` never actually reads. Rather than
-        // adding a `vi.mock("../repo/root.js", ...)` to every one of those
-        // files, `vitest.config.ts` sets this one env var for the whole run so
-        // `findRepoRoot()` resolves to a stable fake path instead of throwing.
-        // A test that specifically wants the real "not in a repo" refusal
-        // (`RepoNotFoundError`) unsets it locally — see `root.test.ts`.
-        cachedRoot = process.env.DEVTOOLS_TEST_REPO_ROOT ?? discoverRepoRoot();
-    }
-    if (cachedRoot === null) {
-        throw new RepoNotFoundError();
-    }
-    return cachedRoot;
-}
-/** Test-only: clears the memoized root so a test can point `process.cwd()` elsewhere. */
-export function resetRepoRootCacheForTests() {
-    cachedRoot = undefined;
-}

package/dist/repo/source.d.ts

@@ -1,14 +0,0 @@
-/** Test-only: clears the memoized source modules. */
-export declare function resetSourceCacheForTests(): void;
-import type { OpenGraphModule } from "../images/open-graph-types.js";
-export declare function loadOpenGraph(): Promise<OpenGraphModule>;
-import type { EmailTemplates } from "../emails/email-types.js";
-export interface EmailModule {
-    render: <K extends keyof EmailTemplates>(name: K, props: EmailTemplates[K]) => {
-        subject: string;
-        html: string;
-        text: string;
-    };
-}
-export declare function loadEmail(): Promise<EmailModule>;
-export declare function loadDocs(): Promise<unknown>;

package/dist/repo/source.js

@@ -1,54 +0,0 @@
-/**
- * Loads the repo-local, never-published `@devdogsuga/*` packages devtools
- * needs at runtime: `open-graph`, `email`, `docs`. Unlike the
- * `peers.ts` set, these are `"private": true` in the target repo and never
- * reach npm — devtools resolves them straight out of the repo's own
- * `node_modules` (a pnpm workspace symlink) using the `devdogs-source`
- * export condition, picked by hand (see `resolve.ts`'s header and
- * FINDINGS.md experiment 4 for why this can't go through
- * `require.resolve`/tsx's `register({ conditions })`).
- *
- * `open-graph` and `email` both declare a `"devdogs-source"` entry in their
- * `exports["."]` map, pointing at TS source. `docs` does not (its `default`
- * points straight at a built `dist/index.js`, produced by
- * `docs-compiler`) — `resolveFromRepo` falls back to `.default` for it,
- * and routing the result through the same tsx-backed import as the other
- * two is harmless: tsx passes plain `.js` through unchanged.
- */
-import { findRepoRoot } from "./root.js";
-import { findDependent, resolveFromRepo } from "./resolve.js";
-import { importRepoTs } from "./tsx-loader.js";
-const CONDITION = "devdogs-source";
-const cache = new Map();
-function loadSource(specifier) {
-    const cached = cache.get(specifier);
-    if (cached)
-        return cached;
-    const promise = (async () => {
-        const repoRoot = findRepoRoot();
-        const resolutionBase = findDependent(repoRoot, specifier);
-        if (!resolutionBase) {
-            throw new Error(`Nothing in this repo depends on ${specifier} — expected an app or package under apps/*` +
-                ` or packages/* to declare it.`);
-        }
-        const { resolvedPath } = resolveFromRepo(repoRoot, resolutionBase, specifier, {
-            condition: CONDITION,
-        });
-        return importRepoTs(resolvedPath);
-    })();
-    cache.set(specifier, promise);
-    return promise;
-}
-/** Test-only: clears the memoized source modules. */
-export function resetSourceCacheForTests() {
-    cache.clear();
-}
-export function loadOpenGraph() {
-    return loadSource("@devdogsuga/open-graph");
-}
-export function loadEmail() {
-    return loadSource("@devdogsuga/email");
-}
-export function loadDocs() {
-    return loadSource("@devdogsuga/docs");
-}

package/dist/repo/supabase-project.d.ts

@@ -1,60 +0,0 @@
-/**
- * Reads `project_id` out of `<repoRoot>/supabase/config.toml`, or `null`
- * when the file is missing or unparsable.
- *
- * Regex, not a TOML parser: it is one line, the shape has been stable
- * across every CLI version this repo has seen, and a parser on a path some
- * callers pay before their first real subprocess is a cost that stays
- * invisible until it is why the tool feels slow.
- */
-export declare function readProjectId(repoRoot: string): string | null;
-/**
- * The Supabase CLI's container name prefix for a project id, or the bare
- * `supabase_db_` fallback when the id could not be read.
- *
- * Falling back to the bare prefix means a machine whose `config.toml`
- * cannot be read still detects *a* stack, at the cost of over-matching a
- * differently-named project — deliberate, and unchanged from this
- * function's original home in `environment.ts`: over-matching offers
- * `stop`/a foreign-stack hint for a stack that turns out to be this
- * project's own, which is harmless to see and decline, while
- * under-matching hides a real signal entirely.
- */
-export declare function containerPrefix(projectId: string | null): string;
-/**
- * The local stack's API port, published by its Kong container. Mirrors
- * `@devdogsuga/env/load`'s `LOCAL_STACK_PORT`, which this module cannot import
- * statically (that package is an optional peer, loaded on demand).
- */
-export declare const STACK_API_PORT = 54321;
-/**
- * `docker ps --format '{{.Names}}'`, split into trimmed, non-empty names —
- * or `null` when Docker could not be read at all (no daemon, not
- * installed, timed out). With `publish`, only the containers publishing that
- * host port. `execute` is injectable for tests, mirroring `environment.ts`'s
- * own probes.
- */
-export declare function listContainerNames(publish?: number, execute?: (file: string, args: string[]) => string | null): string[] | null;
-/**
- * Finds the `supabase_kong_<id>` container among `names` whose id differs
- * from `projectId` — the signature of a stack started from a DIFFERENT
- * Supabase project (this same repo before/after a rename, or another
- * project entirely) holding the shared ports. Kong is the container that
- * publishes the API port, so callers pass the names `listContainerNames`
- * returns for `STACK_API_PORT`: that names the stack actually on 54321,
- * not just any Supabase stack on the machine.
- *
- * Returns that foreign id, or `null` when every matching container belongs
- * to this project, none match at all, or `projectId` itself could not be
- * read — with no known id of our own, there is nothing to compare against,
- * and guessing would risk telling a contributor their OWN stack is
- * foreign.
- */
-export declare function foreignStackProjectId(names: readonly string[], projectId: string | null): string | null;
-/**
- * The actionable message for a detected foreign stack — shared by
- * `db/generated-env.ts` (a failed `supabase status -o env`) and `stack.ts`
- * (a failed `supabase start`), so both name the same fix in the same
- * words.
- */
-export declare function foreignStackMessage(foreignProjectId: string): string;