@rebasepro/cli 0.21.2-canary.g1ea48be → 0.23.0

package/dist/bundle.d.ts

@@ -37,6 +37,11 @@ export interface BuildBundleOptions {
     skipSchema?: boolean;
     /** Emit progress. */
     log?: (message: string) => void;
+    /**
+     * Keep stdout for the caller's result: the compiler's output, and every
+     * warning the build prints, go to stderr. See `toolStdio`.
+     */
+    quietStdout?: boolean;
 }
 export interface BuildBundleResult {
     outDir: string;
@@ -247,6 +252,11 @@ export interface ComposeManifestInput {
  * declared bucket arriving as nothing, with both suites green.
  */
 export declare function composeBundleManifest(input: ComposeManifestInput): RebaseBundleManifest;
+/**
+ * What a build refusing on {@link detectDeclaredDepConflicts} says: every name,
+ * both ranges and where each is declared.
+ */
+export declare function describeDepConflicts(conflicts: DeclaredDepConflict[]): string;
 export declare function buildBundle(options: BuildBundleOptions): Promise<BuildBundleResult>;
 /** Default install target: what the published runtime image runs. */
 export declare const VENDOR_TARGET_OS = "linux";

package/dist/cli.d.ts

@@ -18,6 +18,24 @@ export declare const ROOT_FLAGS: {
     readonly "-v": "--version";
     readonly "-h": "--help";
 };
+/**
+ * The command and subcommand words as `cli.error` may send them: each one is a
+ * word this CLI dispatches, `"none"` when nothing was typed, or `"other"`.
+ *
+ * The words come from what was typed, and what is typed after a command is
+ * only sometimes a subcommand. `rebase init acme-payroll-internal`, `rebase
+ * cloud --project acme-prod deploy` and `rebase db psuh` put a project name, a
+ * slug and a typo in the subcommand's position — the consent screen promises
+ * "never project names", and `sanitize` cannot tell one of those from a
+ * subcommand because neither has a separator in it. So the words are held
+ * against the vocabulary here, where it is known, and nothing else survives.
+ *
+ * Exported for `cli.test.ts`.
+ */
+export declare function telemetryCommandWords(command: string | undefined, subcommand: string | undefined): {
+    command: string;
+    subcommand: string;
+};
 export declare function entry(args: string[]): Promise<void>;
 /** The global help. Exported so its Options block can be held against {@link ROOT_FLAGS}. */
 export declare function printHelp(): void;

package/dist/commands/api-keys.d.ts

@@ -1,3 +1,5 @@
+/** Everything the switch below dispatches, for the did-you-mean. */
+export declare const API_KEYS_SUBCOMMANDS: readonly ["list", "create", "revoke"];
 export declare function apiKeysCommand(subcommand: string | undefined, rawArgs: string[]): Promise<void>;
 /** The flags `rebase api-keys create` takes. */
 export declare const CREATE_KEY_FLAGS: {

package/dist/commands/apps.d.ts

@@ -1 +1,3 @@
+/** Everything the switch below dispatches, for the did-you-mean. */
+export declare const APPS_SUBCOMMANDS: readonly ["list", "init", "config"];
 export declare function appsCommand(subcommand: string | undefined, rawArgs?: string[]): Promise<void>;

package/dist/commands/auth.d.ts

@@ -1,3 +1,5 @@
+/** Everything the switch below dispatches, for the did-you-mean. */
+export declare const AUTH_SUBCOMMANDS: readonly ["reset-password"];
 /** A user as the admin API returns it, reduced to what this command needs. */
 export interface ResolvedUser {
     id: string;
@@ -74,3 +76,13 @@ export declare function resolveResetPasswordArgs(rawArgs: string[]): {
  * hazard, and nothing that reads like a placeholder somebody might keep.
  */
 export declare function generatePassword(): string;
+/**
+ * The script the direct-database fallback runs under the project's own tsx, so
+ * it resolves the project's `@rebasepro/server-postgres` and schema.
+ *
+ * It exits 0 only when a row was updated: a missing user and a thrown error are
+ * both exit 1. `echoPassword` prints the new password, for a generated one.
+ *
+ * Exported so its tests can run it.
+ */
+export declare function resetPasswordScript(echoPassword: boolean): string;

package/dist/commands/build.d.ts

@@ -33,5 +33,13 @@ export declare function buildCommand(rawArgs?: string[]): Promise<void>;
  * packages that output into a `static`-kind bundle — the same deployable shape as
  * a backend bundle, so a frontend or admin app deploys through the identical
  * path and runs on the identical image, just serving files instead of an API.
+ *
+ * Throws when the build fails or produces nothing usable, so the caller answers
+ * in its own way: `rebase build` with a red line, `rebase cloud deploy --json`
+ * with its JSON error.
  */
-export declare function buildAssetApp(projectRoot: string, name: string, app: RebaseAppConfig, runtimeRange: string, outOverride?: string): Promise<string | undefined>;
+export declare function buildAssetApp(projectRoot: string, name: string, app: RebaseAppConfig, runtimeRange: string, outOverride?: string, 
+/** `quietStdout`: every line, the build command's included, goes to stderr. See `toolStdio`. */
+options?: {
+    quietStdout?: boolean;
+}): Promise<string | undefined>;

package/dist/commands/cloud/bundle-deploy.d.ts

@@ -2,15 +2,44 @@ import type { RebaseBundleManifest } from "@rebasepro/types";
 import type { RebuildSource } from "./rebuild-source.js";
 /** Read and shallow-validate a built bundle's manifest. */
 export declare function readBundleManifest(bundleDir: string): RebaseBundleManifest;
+/**
+ * The control plane's cap on an uploaded bundle: its `MAX_BUNDLE_BYTES`, which
+ * it checks before reading the body.
+ */
+export declare const MAX_BUNDLE_UPLOAD_BYTES: number;
 /**
  * Tar a built bundle into a gzipped archive.
  *
- * `node_modules` is excluded on purpose: the bundle ships a `package.json`, and
- * the managed runtime installs the declared dependencies at boot. Uploading an
- * installed `node_modules` would bloat the archive and could carry a
- * platform-specific build that will not run on the runtime image.
+ * `node_modules` goes in only with `withModules`: a tree the build vendored for
+ * the runtime's platform is the point of vendoring, while one installed into a
+ * prebuilt bundle by hand was installed for whatever machine ran it.
+ */
+export declare function packBundle(bundleDir: string, outPath: string, options?: {
+    withModules?: boolean;
+}): Promise<void>;
+/**
+ * Pack a bundle for upload — without `node_modules`, even a vendored tree.
+ *
+ * Vendoring exists so a pod untars and boots rather than spending 35-55s of
+ * every start in `npm install`, and a deploy did carry the tree for one night
+ * (c36ea4637). It is left out again because of what the control plane does
+ * with the archive: `GET /bundle/:projectId/:bundleId` reads the whole object
+ * into memory on every pod start, and a runtime rollout restarts every tenant's
+ * pods at once. Bundles it was sized against are a few hundred kB; a vendored
+ * one is tens of MB, up to the 100 MB cap — N pods starting together would hold
+ * N of them. A slower cold start per pod is the status quo every deploy has
+ * shipped with; a control plane out of memory is every tenant's outage. The
+ * platform's own rebuilds build with `--no-vendor` for the same shape of
+ * reason. When the control plane streams bundles, this is the one switch to
+ * flip, and `rebase cloud deploy` builds with `vendor: false` until then.
+ *
+ * `modulesLeftOut` says a tree the build DID vendor was not uploaded — a
+ * prebuilt `--bundle-dir` from a plain `rebase build`, which vendors by default.
  */
-export declare function packBundle(bundleDir: string, outPath: string): Promise<void>;
+export declare function packBundleForUpload(bundleDir: string, outPath: string, manifest: RebaseBundleManifest, maxBytes?: number): Promise<{
+    bytes: number;
+    modulesLeftOut: boolean;
+}>;
 /**
  * Assemble the deploy-trigger body for a bundle deploy.
  *

package/dist/commands/cloud/context.d.ts

@@ -18,7 +18,26 @@ export declare function setContextOrg(url: string, org: string | undefined): voi
 export declare function getContextOrg(url: string): string | undefined;
 /** Mark a host as the active context (called on login). */
 export declare function setCurrentContext(url: string): void;
+/**
+ * Where the control-plane URL came from. `link` is the one a repository chose
+ * rather than the user — see {@link isKnownControlPlane}.
+ */
+export type CloudUrlSource = "flag" | "env" | "link" | "context" | "default";
 export declare function resolveCloudUrl(rawArgs: string[]): string;
+/** The control-plane URL, and which rung of the ladder above supplied it. */
+export declare function resolveCloudTarget(rawArgs: string[]): {
+    url: string;
+    source: CloudUrlSource;
+};
+/**
+ * Whether a control-plane host is one the user chose: the platform's own, or a
+ * host already in their credentials file because they signed in to it.
+ *
+ * A link file is part of the repository, and a cloned repository is not the
+ * user's to trust with their password. `login` asks before sending one to a
+ * linked host that is neither.
+ */
+export declare function isKnownControlPlane(url: string): boolean;
 /**
  * Refuse to run a control-plane command in a directory linked straight at a
  * backend.
@@ -40,6 +59,30 @@ export type CloudClient = ReturnType<typeof createRebaseClient>;
  * by `requireClient`.
  */
 export declare function createCloudClient(url: string): CloudClient;
+/** The half of a client that holds its session — all {@link freshAccessToken} reads. */
+export interface SessionHolder {
+    auth: {
+        getSession(): {
+            accessToken: string;
+            expiresAt: number;
+        } | null;
+        refreshSession(): Promise<{
+            accessToken: string;
+        }>;
+    };
+}
+/**
+ * An access token with time left on it, refreshed first if it is close to
+ * expiry. Rejects when there is no session, or it cannot be refreshed.
+ *
+ * For the requests the SDK does not make itself. Its own calls refresh and
+ * retry on a 401; a raw `fetch` or a tunnel handshake presents whatever token
+ * it was handed, and `createCloudClient` never refreshes in the background. A
+ * token read once at the start of a command that runs for longer than it
+ * lives — a deploy's build, a `db connect` left open — is refused by the time
+ * it is used, so it is read here at the moment it is sent.
+ */
+export declare function freshAccessToken(client: SessionHolder): Promise<string>;
 /**
  * Return an authenticated client for the resolved host, refreshing the access
  * token if it is close to expiry. Exits with a helpful message when there is no

package/dist/commands/cloud/db-connect.d.ts

@@ -32,6 +32,7 @@
  * unreachable from a browser too.
  */
 import net from "node:net";
+import { type SessionHolder } from "./context.js";
 /** Documented in `action-help.ts`, and paired with it by `action-help.test.ts`. */
 export declare const DB_CONNECT_FLAGS: {
     readonly "--port": NumberConstructor;
@@ -53,6 +54,20 @@ export declare function localDsn(opts: {
     password?: string;
 }): string;
 export declare function dbConnect(rawArgs: string[]): Promise<void>;
+/**
+ * The local listener: each connection it accepts gets its own tunnel, signed in
+ * with a token that is current when the connection arrives.
+ *
+ * The command is left running for as long as the developer works, and the
+ * access token it started with lapses within the hour. Every connection is
+ * authenticated on its own, so each one reads the token then, refreshing it
+ * first when it is close to expiry — rather than the one read at startup, which
+ * the control plane refuses for every connection opened after it expires.
+ *
+ * The socket is paused while the token is read, so a client's first bytes wait
+ * for the tunnel exactly as they do once it is being established.
+ */
+export declare function tunnelListener(client: SessionHolder, endpoint: string): net.Server;
 /**
  * One accepted connection, carried over one WebSocket.
  *

package/dist/commands/cloud/deploy.d.ts

@@ -59,8 +59,22 @@ export declare function timeAgo(value: string | Date | undefined, now: Date): st
  * path.
  */
 export declare function isManagedProject(project: DeployProjectRow | undefined, latest: DeploySourceRow | undefined): boolean;
-/** What a `deploy` with nothing attached will build, in the words to print. */
-export declare function planBareDeploy(project: DeployProjectRow | undefined, latest: DeploySourceRow | undefined, now: Date): BareDeployPlan;
+/**
+ * The deployment whose uploaded archive a bare deploy rebuilds, if any.
+ *
+ * The control plane's own rule (`reusableSourceRef`, over the newest 25 rows):
+ * the newest row, by its own `createdAt`, carrying a build-context ref. Not the
+ * newest row — a rollback or a bundle deploy carries none, and the upload
+ * rebuilt then is the one before it.
+ */
+export declare function snapshotDeployment(recent: readonly DeploySourceRow[]): DeploySourceRow | undefined;
+/**
+ * What a `deploy` with nothing attached will build, in the words to print.
+ *
+ * `recent` is the project's newest deployments, newest first — the same page
+ * the control plane reads to choose an archive.
+ */
+export declare function planBareDeploy(project: DeployProjectRow | undefined, recent: readonly DeploySourceRow[], now: Date): BareDeployPlan;
 /**
  * A warning attached to a deploy: printed for the human, carried in the JSON.
  *
@@ -186,6 +200,8 @@ export declare const DEPLOY_FLAGS: {
     readonly "--bundle": BooleanConstructor;
     readonly "--bundle-dir": StringConstructor;
     readonly "--skip-type-check": BooleanConstructor;
+    readonly "--no-static": BooleanConstructor;
+    readonly "--skip-schema": BooleanConstructor;
     readonly "--eject": BooleanConstructor;
     readonly "--no-source": BooleanConstructor;
     readonly "--allow-downgrade": BooleanConstructor;
@@ -223,6 +239,8 @@ export declare function resolveDeployArgs(rawArgs: string[]): {
         readonly "--bundle": BooleanConstructor;
         readonly "--bundle-dir": StringConstructor;
         readonly "--skip-type-check": BooleanConstructor;
+        readonly "--no-static": BooleanConstructor;
+        readonly "--skip-schema": BooleanConstructor;
         readonly "--eject": BooleanConstructor;
         readonly "--no-source": BooleanConstructor;
         readonly "--allow-downgrade": BooleanConstructor;
@@ -290,6 +308,41 @@ export declare function deployedUrl(client: CloudClient, opts: {
     projectId?: string;
     url?: string;
 }): Promise<string | undefined>;
+/**
+ * The line an in-progress build keeps rewriting at the end of its log, to prove
+ * to the control plane that it is still alive.
+ *
+ * The control plane's own format — `HEARTBEAT_MARKER` and `heartbeatSuffix` in
+ * its `functions/deploy.ts` — which appends `\n<marker><ISO time>\n` to the log
+ * on every write and every 30 seconds, and drops it on the terminal write.
+ */
+export declare const BUILD_HEARTBEAT_MARKER = "\u23F3 Build in progress \u2014 control-plane heartbeat ";
+/**
+ * A deployment's log without its trailing heartbeat line: the build log itself.
+ *
+ * Only a heartbeat that is the last line is one. The same text anywhere else is
+ * the build quoting it.
+ */
+export declare function withoutHeartbeat(logs: string): string;
+/**
+ * What to print of a deployment's log, given everything printed so far.
+ *
+ * The `logs` column is not append-only. Its heartbeat line is rewritten at the
+ * end on every write, and a failed static deploy replaces its whole log with
+ * one line. Diffing the raw column by length therefore cut the start off every
+ * new chunk — as many characters as the heartbeat that had been there — and
+ * printed heartbeat fragments in their place: a failed managed deploy lost the
+ * first half of its reason.
+ *
+ * So the heartbeat is stripped first, and the log printed so far is compared
+ * with the log now. When it has only grown, the new text is printed. When it
+ * was rewritten, printing resumes from the start of the first line that
+ * differs, on a line of its own.
+ */
+export declare function nextLogChunk(printed: string, rowLogs: string): {
+    chunk: string;
+    printed: string;
+};
 /** What `rebase cloud logs` parses. Its page pairs against this. */
 export declare const LOGS_FLAGS: {
     readonly "--runtime": BooleanConstructor;

package/dist/commands/cloud/domains.d.ts

@@ -1,11 +1,11 @@
 export declare function domainsCommand(action: string | undefined, rawArgs: string[]): Promise<void>;
 /**
- * The domain `domains add` was asked to register.
+ * The domain an action was given, or undefined.
  *
  * Exported so its tests drive the real parser. Under the old operand filter
  * `rebase cloud domains add -p acme` registered a domain called "acme" — the
  * project slug, read out of `--project`'s own value — and a registered domain
  * is a project-record write, not a no-op.
  */
-export declare function resolveDomainArg(rawArgs: string[]): string | undefined;
+export declare function resolveDomainArg(rawArgs: string[], action?: string): string | undefined;
 export declare function printDomainsHelp(): void;

package/dist/commands/cloud/env.d.ts

@@ -57,4 +57,18 @@ export declare function resolveEnvSetArgs(rawArgs: string[]): {
  * count of command words is the same for all of them.
  */
 export declare function resolveEnvKeyArg(rawArgs: string[], action: string): string | undefined;
+/**
+ * One `KEY=value` line that dotenv reads back as exactly `value`, or null when
+ * no quoting can carry it.
+ *
+ * dotenv's quoting is not JSON's, and `JSON.stringify` was what this used: a
+ * double-quoted value has only `\n` and `\r` unescaped, so every other
+ * backslash stayed and `{"a":1}` came back as `{\"a\":1}`. Single quotes and
+ * backticks are literal — nothing inside is unescaped, and either may span
+ * lines — so they carry any value without their own quote character. Double
+ * quotes come last: they cannot hold a `"` or a literal backslash-n, and they
+ * are the only way to carry a carriage return, which dotenv folds into a
+ * newline everywhere else.
+ */
+export declare function dotenvLine(key: string, value: string): string | null;
 export declare function printEnvHelp(): void;

package/dist/commands/cloud/rebuild-source.d.ts

@@ -14,6 +14,12 @@ export declare const MAX_SOURCE_UPLOAD_BYTES: number;
  * bundles are never source. Every `.env` and `.env.*` is excluded except the
  * three template names, and so is direnv's `.envrc`, which is the same thing
  * under another name.
+ *
+ * So is what the CLI keeps on this machine: `.rebase/`, which holds the
+ * development database, and the `.rebase-dev-*` files beside it, one of which
+ * is the development signing secrets. And so is a `*.dump`, which is what
+ * `rebase db backup` writes: every row of the database, `rebase.users`
+ * password hashes included.
  */
 export declare function neverUploaded(relativePath: string): boolean;
 export interface SourceListing {
@@ -45,6 +51,21 @@ export type GitRunner = (cwd: string, args: string[]) => string;
  * archive with `../`.
  */
 export declare function listSourceFiles(projectRoot: string, git?: GitRunner): SourceListing;
+/**
+ * The files of a `--source` build context: `dir` and what is under it, relative
+ * to it, POSIX, sorted.
+ *
+ * The same rules as the rebuild source — git decides, and {@link neverUploaded}
+ * after it — restricted to `dir`, which is the context's root, so a Dockerfile
+ * in it still reads its paths from there. A `dir` that is a subfolder of a
+ * repository is held to that repository's `.gitignore`, which is where a
+ * monorepo keeps it.
+ *
+ * `.rebaseignore` in `dir` leaves out more, read with `.gitignore` syntax and
+ * anchored at `dir`. It needs git to be read, like `.gitignore` outside a
+ * repository; without git, a context that has one is refused.
+ */
+export declare function listContextFiles(dir: string, git?: GitRunner): string[];
 /**
  * Pack a listing into a gzipped tarball at `outPath`.
  *
@@ -54,7 +75,7 @@ export declare function listSourceFiles(projectRoot: string, git?: GitRunner): S
  * archive, as `packBundle` does; GNU tar accepts both. Every path handed to tar
  * is absolute, because GNU tar resolves a `-T` file after it has applied `-C`.
  */
-export declare function packSource(listing: SourceListing, outPath: string): Promise<void>;
+export declare function packSource(listing: Pick<SourceListing, "root" | "files">, outPath: string): Promise<void>;
 /** Upload a source archive; returns the control plane's id for it. */
 export declare function uploadRebuildSource(url: string, token: string, projectId: string, tarPath: string): Promise<string>;
 /**
@@ -100,7 +121,8 @@ export interface RebuildSourceSteps {
 export declare function prepareRebuildSource(opts: {
     projectRoot: string;
     url: string;
-    token: string;
+    /** The access token, read when the upload is sent rather than before the packing. */
+    token: () => Promise<string>;
     projectId: string;
     manifest?: RebaseProjectManifest;
     progress: (line: string) => void;

package/dist/commands/db.d.ts

@@ -157,6 +157,8 @@ export declare function runDriverDbCommand(rawArgs: string[], options?: {
     quiet?: boolean;
 }): Promise<void>;
 export declare function dbCommand(subcommand: string | undefined, rawArgs: string[]): Promise<void>;
+/** Every subcommand the family dispatches — the help table's keys. */
+export declare const DB_SUBCOMMANDS: string[];
 /**
  * The examples, which are not the same on the managed development database.
  *

package/dist/commands/schema.d.ts

@@ -1 +1,3 @@
 export declare function schemaCommand(subcommand: string | undefined, rawArgs: string[]): Promise<void>;
+/** Every subcommand the family dispatches — the help table's keys. */
+export declare const SCHEMA_SUBCOMMANDS: string[];

package/dist/commands/skills.d.ts

@@ -141,6 +141,8 @@ export declare function installForAgent(agentKey: AgentKey, skills: LoadedSkill[
     skills: number;
     assets: number;
 };
+/** Everything the switch below dispatches, for the did-you-mean. */
+export declare const SKILLS_SUBCOMMANDS: readonly ["install"];
 export declare function skillsCommand(subcommand: string | undefined, rawArgs: string[]): Promise<void>;
 /**
  * Agents named explicitly on the command line, e.g. `--agent claude --agent cursor`

package/dist/commands/telemetry.d.ts

@@ -1 +1,11 @@
+/**
+ * `rebase telemetry` — the command that makes the rest of it inspectable.
+ *
+ * The whole subsystem asks for trust it cannot otherwise earn, and the cheapest
+ * way to earn it is to stop describing the payload and print it. `show` runs
+ * the same builder the sender uses, so what appears here is what would go, not
+ * a documentation comment that quietly fell out of date two releases ago.
+ */
+/** Everything the switch below dispatches, for the did-you-mean. */
+export declare const TELEMETRY_SUBCOMMANDS: readonly ["status", "show", "enable", "disable"];
 export declare function telemetryCommand(rawArgs: string[]): Promise<void>;

package/dist/dev-db/pull.d.ts

@@ -116,5 +116,34 @@ export declare function dumpArgs(plan: PullPlan): string[];
  * them. `--no-owner` for the same reason as the dump.
  */
 export declare function restoreArgs(plan: PullPlan, dumpFile: string): string[];
-/** Is `pg_dump` on PATH, and what version? Checked before anything destructive. */
-export declare function findPgDump(): Promise<string | null>;
+/**
+ * Is this PostgreSQL client tool on PATH, and what version? Both are checked
+ * before anything destructive: discovering `pg_restore` is missing after the
+ * dump has been taken — or after `--clean` has emptied the target — is the
+ * worst possible ordering.
+ */
+export declare function findPgTool(tool: "pg_dump" | "pg_restore"): Promise<string | null>;
+/** The fields of a finished `pg_restore` run that decide {@link restoreOutcome}. */
+export interface RestoreRun {
+    exitCode?: number;
+    signal?: string;
+    /** A spawn failure's code — `ENOENT` when the binary vanished. */
+    code?: string;
+    stderr?: string;
+}
+/**
+ * What a finished `pg_restore` says about the copy.
+ *
+ * `--clean` empties the target before anything is written, so every way this
+ * can end short of exit 0 leaves a partial or empty local database, and none of
+ * them may be reported as a copy. A non-zero exit is pg_restore saying it
+ * skipped statements — "errors ignored on restore: N" — and whatever those
+ * statements created (a table, its rows, an RLS policy) is missing locally.
+ *
+ * `started` says whether anything can have arrived, which is what decides
+ * whether an anonymization pass still has data to redact.
+ */
+export declare function restoreOutcome(run: RestoreRun): {
+    started: boolean;
+    failure: string | null;
+};

package/dist/dev-db/resolve.d.ts

@@ -13,7 +13,7 @@
  *   2. `DATABASE_URL` in the shell environment
  *   3. the database branch this checkout is switched to
  *   4. `DATABASE_URL` in the project's `.env`
- *   5. `--docker` / a manifest preference of `docker`
+ *   5. `--docker`
  *   6. the managed PGlite database
  *
  * An explicit connection string always wins. That is the whole point of the
@@ -44,7 +44,7 @@ export type DevDatabaseSource =
  | "env-file"
 /** The branch this checkout is switched to, over the base connection. */
  | "branch"
-/** `--docker`, or `devDatabase: "docker"` in the manifest. */
+/** `--docker`. */
  | "docker"
 /** Nobody said anything, so the managed database fills in. */
  | "managed";
@@ -79,8 +79,6 @@ export interface ResolveDevDatabaseInput {
     env?: Record<string, string | undefined>;
     /** Parsed `.env` from the project root. Only `DATABASE_URL` is read. */
     envFile?: Record<string, string> | null;
-    /** `devDatabase` from `rebase.json`, if the project recorded a preference. */
-    manifestPreference?: "managed" | "docker" | null;
     /**
      * The compose `db` service's connection string, when the project has one.
      *

package/dist/fold-static.d.ts

@@ -17,6 +17,8 @@ export interface FoldOptions {
     /** Skip running each app's own build command; fold what is already built. */
     skipBuild?: boolean;
     log?: (message: string) => void;
+    /** Send each app's build output to stderr: the caller's stdout carries a result. See `toolStdio`. */
+    quietStdout?: boolean;
 }
 export interface FoldOutcome {
     appName: string;