/** The apps section of a project manifest, as much of it as folding needs. */
export interface FoldableManifest {
    apps?: Record<string, {
        type?: string;
        build?: string;
        output?: string;
        path?: string;
        spa?: boolean;
    }>;
}
export interface FoldOptions {
    projectRoot: string;
    manifest: FoldableManifest;
    /** The backend bundle directory, already written. */
    bundleDir: string;
    /** Skip running each app's own build command; fold what is already built. */
    skipBuild?: boolean;
    log?: (message: string) => void;
}
export interface FoldOutcome {
    appName: string;
    fileCount: number;
    /** Public base path this app was folded in at. */
    path: string;
}
/** A static app as folding sees it, with the manifest's defaults applied. */
export interface FoldableApp {
    name: string;
    build?: string;
    output?: string;
    /** Public base path, defaulted to `/`. */
    path: string;
    /** SPA fallback, defaulted to `true`. */
    spa: boolean;
}
/**
 * Every static app in the manifest, in mount order.
 *
 * Longest path first, so the `/`-rooted app is registered last — its catch-all
 * would otherwise claim its siblings' URLs. Pure, so the ordering is testable
 * without a filesystem.
 */
export declare function foldableApps(manifest: FoldableManifest): {
    apps: FoldableApp[];
    /** Apps that cannot be folded, and why. */
    skipped: {
        name: string;
        reason: string;
    }[];
};
/**
 * Assert a built app's assets are actually rooted at the path it is served from.
 *
 * An app mounted at `/admin` but built with Vite's default `base: "/"` emits
 * `<script src="/assets/index-a1b2.js">`. The server serves `index.html` fine
 * and 404s every asset: a blank page, no server error, nothing in the logs. It
 * is the single most expensive silent failure in this design, so it is a build
 * error rather than a runtime surprise.
 *
 * Only `<script src>` and `<link href>` are inspected — those are what a bundler
 * rewrites through `base`. Author-written anchors and canonical URLs are not
 * evidence of a misbuild.
 */
export declare function assertBuiltForPath(indexHtml: string, basePath: string, appName: string): void;
/**
 * The environment every static app is built with, wherever that build is driven from.
 *
 * Shared because there are two drivers — `foldFrontendIntoBundle` here, and
 * `buildAssetApp` in `build.ts` for a standalone `type: "static"` app — and they
 * had already drifted: the path variables were duplicated into both, so a fix
 * applied to one shipped a bundle built the old way from the other. One function
 * makes that impossible rather than merely unlikely.
 *
 * ## REBASE_APP_*
 *
 * The declared path is a build-time input, not only a serving concern: Vite
 * reads `base` from REBASE_APP_BASE, and the trailing slash is that field's
 * convention. See `assertBuiltForPath`.
 *
 * ## NODE_ENV
 *
 * A built app is a production artifact by construction, so build it as one. Not
 * a formality: the scaffold's `.env` carries `NODE_ENV=development` for the dev
 * backend, and Vite's `loadEnv` promotes a `NODE_ENV` found in an env file into
 * the build unless the environment already sets one. So `rebase build` and
 * `rebase cloud deploy` shipped a *development* bundle — `import.meta.env.DEV
 * === true`, development React, dev-only branches live — from commands whose
 * whole purpose is to produce something deployable. Setting it here is what
 * closes it: Vite consults the env file's NODE_ENV only when `process.env`
 * has none.
 *
 * ## VITE_API_URL
 *
 * An app served by the backend it talks to has its API on its own origin by
 * construction, so a baked-in absolute URL can only be wrong. It was: that same
 * `.env` carries `VITE_API_URL=http://localhost:3001` and
 * `frontend/vite.config.ts` reads the project root via `envDir: ".."`, so a
 * stock deploy shipped a site whose every request went to whoever ran the build
 * — passing every server-side health check on the way out. Blanking it here
 * fixes the bundle even for a project whose `.env` predates the `init` fix, or
 * was written by hand. Empty is the right value rather than a missing one: the
 * client falls back to `window.location.origin`, which keeps working when a
 * custom domain is added.
 *
 * Vite prioritises `process.env.VITE_*` over `.env` files, so an explicit
 * `VITE_API_URL=https://api.example.com rebase cloud deploy` still wins — the
 * cross-origin escape hatch stays open, it just has to be deliberate. Nothing on
 * this path loads the project `.env` into `process.env`, so a value inherited
 * here really was set by the caller.
 */
export declare function staticBuildEnv(appPath: string, appName: string): Record<string, string>;
/**
 * Build the project's static apps and fold them into the backend bundle.
 *
 * Throws rather than exiting, so the caller decides whether a missing frontend
 * should fail its command — a `build` may reasonably want to stop, and so should
 * a deploy, but that is not this function's call to make.
 */
export declare function foldFrontendIntoBundle(options: FoldOptions): Promise<FoldOutcome[]>;