@rebasepro/cli 0.25.1 → 0.26.0

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

@@ -94,27 +94,31 @@ export declare function describeRuntime(project: {
 export declare function statusCommand(rawArgs: string[]): Promise<void>;
 export declare function metricsCommand(rawArgs: string[]): Promise<void>;
 /**
- * The webhook `webhooks delete` names.
+ * `rebase cloud webhooks` is retired, and says where to go instead.
  *
- * The worst instance of the operand-filter bug in this family, because the
- * argument is consumed by a DELETE and the wrong value looks entirely
- * plausible: `rebase cloud webhooks delete --project acme 42` filtered out
- * `--project` and kept "acme", so the id it deleted was the project slug rather
- * than the 42 the caller wrote. Strict parsing consumes the flag with its
- * value, leaving `["42"]`.
+ * It never worked. It wrote rows to a data collection named `webhooks` on the
+ * control plane, whose real slug is `database-webhooks` — and nothing on the
+ * control plane ever delivered those rows anyway. What people reached for it
+ * to do is now two other things:
  *
- * Exported so its tests drive the real parser.
+ *  - a project's own events (a deploy failed, backups stopped, a payment was
+ *    declined, usage passed 80%) to Slack, Discord or any URL:
+ *    `rebase cloud notifications`;
+ *  - a POST when rows of your app's own tables change: a `WebhookDispatcher`
+ *    in your app's code, which your backend delivers itself.
+ *
+ * Every action answers the same refusal, exit 1, code `command_retired`, with
+ * both routes — a retired command that still exits 0 would tell a script its
+ * webhook exists.
  */
-export declare function resolveWebhookIdArg(rawArgs: string[]): string | undefined;
-/** The action words `rebase cloud webhooks` dispatches. No word means `list`. */
-export declare const WEBHOOKS_ACTIONS: readonly ["list", "create", "delete"];
-export declare function webhooksCommand(subcommand: string | undefined, rawArgs: string[]): Promise<void>;
+export declare const WEBHOOKS_RETIRED_HINT: string;
+export declare function webhooksCommand(_subcommand: string | undefined, _rawArgs: string[]): Promise<void>;
 /** The action words `rebase cloud storage` dispatches. No word means `list`. */
 export declare const STORAGE_ACTIONS: readonly ["list", "create", "attach"];
 export declare function storageCommand(action: string | undefined, rawArgs: string[]): Promise<void>;
 export declare function printStorageHelp(): void;
 /** The action words `rebase cloud clusters` dispatches. No word means `list`. */
-export declare const CLUSTERS_ACTIONS: readonly ["list", "add", "verify"];
+export declare const CLUSTERS_ACTIONS: readonly ["list", "add", "verify", "registry"];
 /**
  * `rebase cloud clusters` — list, register and verify the clusters tenants run on.
  *
@@ -192,6 +196,46 @@ export interface ClusterAddArgs {
  * so it is refused here, where the operator can still fix the command.
  */
 export declare function resolveClusterAddArgs(rawArgs: string[]): ClusterAddArgs;
+/** The flags `clusters registry` declares; exported for its help page's test. */
+export declare const CLUSTER_REGISTRY_FLAGS: {
+    "--repository": StringConstructor;
+    "--push-service-account": StringConstructor;
+    "--pull-key-file": StringConstructor;
+    "--clear": BooleanConstructor;
+};
+/**
+ * What `clusters registry` was asked to record: a customer cluster's own image
+ * repository, the account its builds push as, and the file holding the key of
+ * its read-only account — or `--clear`, to go back to the shared registry.
+ */
+export type ClusterRegistryArgs = {
+    id: string;
+    clear: true;
+} | {
+    id: string;
+    clear: false;
+    repository: string;
+    pushServiceAccount: string;
+    pullKeyFile: string;
+};
+/**
+ * Parse `rebase cloud clusters registry <id> …`.
+ *
+ * All three values or `--clear`, never a part: the control plane ignores a
+ * partial set (and keeps handing the cluster the shared credentials), so a
+ * command that wrote one would look done and change nothing.
+ */
+export declare function resolveClusterRegistryArgs(rawArgs: string[]): ClusterRegistryArgs;
+/**
+ * The reader's key from `--pull-key-file`, checked before it leaves this
+ * machine: a service-account key, and not the pusher's — the pull secret sits
+ * where the customer's cluster admin can read it, so it must not be able to
+ * write. Returns the key text and the account it belongs to.
+ */
+export declare function readPullKey(text: string, pushServiceAccount: string): {
+    key: string;
+    account: string;
+};
 /**
  * The action words `rebase cloud billing` dispatches. No word at all is the
  * account view, which is why it is not in the list.
@@ -202,7 +246,7 @@ export declare function resolveClusterAddArgs(rawArgs: string[]): ClusterAddArgs
  * the account — a help page describing a command that does not exist, and a typo
  * exiting 0.
  */
-export declare const BILLING_ACTIONS: readonly ["setup", "checkout"];
+export declare const BILLING_ACTIONS: readonly ["setup", "checkout", "invoices", "upcoming"];
 export declare function billingCommand(rawArgs: string[]): Promise<void>;
 /**
  * The action words `rebase cloud compute` dispatches. No word, or `show`,
@@ -222,6 +266,16 @@ export declare const COMPUTE_ACTIONS: readonly ["show", "set"];
  * — so this is a description of that line, not a second parser for it.
  */
 export declare const COMPUTE_SET_FLAGS: Record<string, unknown>;
+/**
+ * The flag that used to set `scaleToZero`. Still parsed, so a script that passes
+ * it is told what happened rather than failing on an unknown option.
+ *
+ * The dial never did anything: it resolved to a request-billed substrate no
+ * deploy built, and every backend kept running as an always-on pod. The control
+ * plane refuses `true` now; this refuses it before the round trip, and lets
+ * `false` — what every project already gets — through with a warning.
+ */
+export declare const RETIRED_SCALE_TO_ZERO = "--scale-to-zero";
 /**
  * `rebase cloud compute` — show what a project reserves, and change it.
  *

package/dist/commands/cloud/runtime-logs.d.ts

@@ -0,0 +1,176 @@
+import { type CloudClient } from "./context.js";
+import { type RuntimeLogsPod } from "./debug.js";
+/** The control-plane function this module reads. */
+export declare const RUNTIME_LOGS_FUNCTION = "runtime-logs";
+/** How often a follow polls. The console polls at the same rate. */
+export declare const FOLLOW_INTERVAL_MS = 2000;
+/** The longest a follow waits between retries of a failed poll. */
+export declare const MAX_BACKOFF_MS = 30000;
+/** A poll with no answer by then is treated as a dropped connection. */
+export declare const POLL_TIMEOUT_MS = 30000;
+/** What one request asks the route for. `sinceTime` and `sinceSeconds` are exclusive. */
+export interface RuntimeLogsQuery {
+    sinceSeconds?: number;
+    /** RFC3339. */
+    sinceTime?: string;
+    tailLines?: number;
+    previous?: boolean;
+    /** One backend preview's pod instead of production's. */
+    preview?: string;
+}
+export interface RuntimeLogsPodState extends RuntimeLogsPod {
+    /** The container's restart count. Absent from control planes before it was reported; null when unknown. */
+    restarts?: number | null;
+}
+/** The route's answer, read defensively: every field may be missing on an older control plane. */
+export interface RuntimeLogsPage {
+    logs?: string;
+    pods?: RuntimeLogsPodState[];
+    ordering?: string;
+    truncated?: boolean;
+    previous?: boolean;
+    /** Echoed by control planes that understand `?preview=`. */
+    preview?: string | null;
+    nextSinceTime?: string | null;
+    state?: "ok" | "no_pods" | "error" | string;
+    message?: string | null;
+}
+/** The request path for a query: `<projectId>?…`. Timestamps are always asked for — the cursor is built from them. */
+export declare function runtimeLogsPath(projectId: string, q: RuntimeLogsQuery): string;
+/**
+ * Read one page, refusing to pass off production's log as a preview's.
+ *
+ * A control plane from before `?preview=` ignores the parameter and answers with
+ * production's pods. It does not echo `preview`, and that silence is the tell.
+ */
+export declare function fetchRuntimeLogsPage(client: CloudClient, projectId: string, q: RuntimeLogsQuery): Promise<RuntimeLogsPage>;
+/**
+ * `--since`: a duration (`30s`, `5m`, `1h`, `2d`) or an RFC3339 instant.
+ * Returns null for anything else.
+ */
+export declare function parseSinceFlag(input: string): {
+    sinceSeconds: number;
+} | {
+    sinceTime: string;
+} | null;
+/** Severity, as the console's log explorer reads it. */
+export type LogLevel = "error" | "warn" | "info" | "debug" | "unknown";
+/** `--level` names a floor: `warn` keeps warnings and errors. */
+export declare const LEVEL_FLOOR: Record<Exclude<LogLevel, "unknown">, number>;
+/**
+ * A line's severity: the structured field when the payload is a JSON object
+ * (a Rebase backend logs `{"severity":"ERROR",…}`), else a level token at the
+ * head of the line — the console explorer's rules. A line with neither that
+ * `cloud debug errors` would flag (`Error:`, `EACCES`, a refusal) counts as an
+ * error, because an unstructured stack trace is exactly what `--level error`
+ * is run to find.
+ */
+export declare function lineLevel(text: string): LogLevel;
+/**
+ * `--grep`: a case-insensitive substring of the whole line (timestamp and pod
+ * included, as in the console), or a regular expression written `/re/flags`.
+ */
+export declare function grepMatcher(pattern: string): (line: string) => boolean;
+/** Read `--level`, refusing anything that is not a level. */
+export declare function parseLevelFlag(value: string): Exclude<LogLevel, "unknown">;
+/** One printed line, parsed. */
+export interface LogRecord {
+    /** The kubelet's RFC3339(Nano) timestamp, or null when the line carried none. */
+    ts: string | null;
+    pod: string | null;
+    text: string;
+    /** The line exactly as the control plane rendered it. */
+    raw: string;
+}
+export declare function parseRecords(logs: string | undefined): LogRecord[];
+/** The lines `--grep` and `--level` keep. Both unset keeps everything. */
+export declare function recordFilter(opts: {
+    grep?: string;
+    level?: Exclude<LogLevel, "unknown">;
+}): (rec: LogRecord) => boolean;
+/**
+ * The newest line printed so far, and which lines share its millisecond.
+ *
+ * Polls overlap by design (see the module docs), so a line can arrive twice.
+ * A line older than the cursor was printed by an earlier poll — every pod is
+ * read at the same instant, so nothing older can still be on its way. A line
+ * in the cursor's own millisecond was printed if it is one of the lines
+ * remembered there. A line with no timestamp cannot be placed and is printed:
+ * a duplicate is a kinder failure than a lost line.
+ */
+export declare class FollowCursor {
+    private ms;
+    private boundary;
+    /** Keep the lines of one page that have not been printed, and move the cursor past them. */
+    admit(records: LogRecord[]): LogRecord[];
+    /** Where the next poll starts: one millisecond before the newest line, or null before any. */
+    sinceTime(): string | null;
+}
+/** Something a follower says besides a log line. */
+export type FollowEvent = {
+    event: "no_pods";
+    message: string;
+} | {
+    event: "pod_added";
+    pod: string;
+} | {
+    event: "pod_removed";
+    pod: string;
+} | {
+    event: "pod_state";
+    pod: string;
+    state: string;
+    message: string | null;
+} | {
+    event: "pod_restarted";
+    pod: string;
+    restarts: number;
+    missed: number;
+} | {
+    event: "truncated";
+    message: string;
+} | {
+    event: "server_error";
+    message: string;
+} | {
+    event: "reconnecting";
+    message: string;
+    retryInMs: number;
+} | {
+    event: "reconnected";
+};
+export interface FollowSink {
+    line(rec: LogRecord): void;
+    event(e: FollowEvent): void;
+}
+export interface FollowDeps {
+    fetch(q: RuntimeLogsQuery): Promise<RuntimeLogsPage>;
+    /** Resolves after `ms`, or as soon as `signal` aborts. */
+    sleep(ms: number, signal: AbortSignal): Promise<void>;
+    signal: AbortSignal;
+    sink: FollowSink;
+    /** A monotonic clock, in milliseconds. */
+    now(): number;
+    /** Whether a failed poll is worth retrying. */
+    isTransient(e: unknown): boolean;
+    intervalMs?: number;
+    pollTimeoutMs?: number;
+}
+export interface FollowOptions {
+    /** The first poll, as the flags asked for it. */
+    initial: RuntimeLogsQuery;
+    filter: (rec: LogRecord) => boolean;
+}
+/** The delay before retry `attempt` (1-based): 2s, 4s, 8s, 16s, then 30s. */
+export declare function backoffMs(attempt: number, base?: number): number;
+/**
+ * Poll until `deps.signal` aborts. Returns normally then; throws only a
+ * failure that is not worth retrying (the caller reports it).
+ */
+export declare function followRuntimeLogs(deps: FollowDeps, opts: FollowOptions): Promise<void>;
+/** Colour a line by its severity on a terminal; the text itself is never changed. */
+export declare function paintLine(rec: LogRecord): string;
+/** The human sentence for an event, or null for one that needs none. */
+export declare function describeEvent(e: FollowEvent, opts?: {
+    preview?: string;
+}): string | null;

package/dist/commands/cloud/service-key.d.ts

@@ -0,0 +1,15 @@
+export declare const SERVICE_KEY_FLAGS: {};
+export declare const SERVICE_KEY_ACTIONS: readonly ["rotate"];
+/** What `GET /credentials/:projectId/service-key` answers. Never the key. */
+export interface CliServiceKeyStatus {
+    generation: number;
+    liveGeneration: number;
+    rotatedAt: string | null;
+    pending: boolean;
+}
+/** What a rotation answers. */
+export interface CliServiceKeyRotation {
+    generation: number;
+    state: "restarting" | "pending";
+}
+export declare function serviceKeyCommand(rawArgs: string[]): Promise<void>;

package/dist/commands/cloud/token-capabilities.d.ts

@@ -15,18 +15,33 @@
  * hold:
  *
  * - `deploy`   — `rebase cloud deploy` (bundle and source paths, uploads, the
- *                build follow) and `rebase cloud deployments`.
- * - `logs`     — `rebase cloud logs` (build, `--follow`, `--runtime`),
- *                `rebase cloud metrics` and `rebase cloud cron` — whose
- *                `runtime-token` call is how a token reads the app's own
- *                cron history.
- * - `env`      — `rebase cloud env list|set|unset|reveal|pull`.
+ *                build follow, `--preview`), `rebase cloud deployments` and
+ *                `rebase cloud previews`.
+ * - `logs`     — `rebase cloud logs` (build, `--follow`, `--runtime`,
+ *                `--preview`),
+ *                `rebase cloud metrics`, `rebase cloud usage` and
+ *                `rebase cloud cron` — whose `runtime-token` call is how a
+ *                token reads the app's own cron history.
+ * - `env`      — `rebase cloud env list|set|unset|reveal|pull`, and the
+ *                same with `--preview` (and `env reset --preview`).
  * - `database` — `rebase cloud db list|info|connect`.
  * - `backups`  — `rebase cloud db backup list|create|status|download` and
  *                `db pitr status`. Restoring takes `project:restore`, which no
  *                capability grants: putting old data over a live database is
  *                for a signed-in person.
  *
+ * Three more capabilities act on one ORGANIZATION rather than a project, and a
+ * token holds one only when it is asked for ({@link ORG_CAPABILITIES}):
+ *
+ * - `billing`       — `rebase cloud billing`, `billing invoices|upcoming`.
+ * - `audit`         — `rebase cloud activity`.
+ * - `notifications` — `rebase cloud notifications` on the organization's
+ *                     projects (adding and removing one still takes the
+ *                     owner or admin role).
+ *
+ * Each holds its `org:*` scope narrowed to the organization
+ * (`org:billing:<organizationId>`).
+ *
  * Every project-level scope is narrowed to the one project the token is for
  * (`project:deploy:<projectId>`). The data and function scopes cannot be: they
  * name a collection or a function, not a row, and the control plane's
@@ -43,8 +58,9 @@ export type TokenCapability = "deploy" | "logs" | "env" | "database" | "backups"
 export declare const TOKEN_CAPABILITY_NAMES: readonly TokenCapability[];
 /**
  * Scopes every token holds, whatever it was created for: resolving a project
- * by its slug, reading the deployment a command follows, the organization a
- * project belongs to, and the control plane's public description of itself.
+ * by its slug, reading the deployment a command follows (a production one, or
+ * a preview's), the organization a project belongs to, and the control plane's
+ * public description of itself.
  */
 export declare const ALWAYS_SCOPES: string[];
 /** Each capability: what it lets a token do, and the scopes that does on one project. */
@@ -74,3 +90,40 @@ export declare function capabilitiesInScopes(scopes: readonly string[]): Array<{
     projectId: string;
     capabilities: TokenCapability[];
 }>;
+/**
+ * Whether a token's scopes reach one project: a project scope narrowed to it,
+ * or an unnarrowed one, which reaches every project.
+ *
+ * What decides, in a directory `rebase cloud init --claim` linked, whether
+ * `REBASE_TOKEN` or the token stored for that project acts on it: a
+ * `REBASE_TOKEN` made for other projects would be refused on this one.
+ */
+export declare function scopesReachProject(scopes: readonly string[], projectId: string): boolean;
+/** A capability on one organization. A token holds one only when asked for. */
+export type OrgCapability = "billing" | "audit" | "notifications";
+/** Every organization capability, in the order they are offered. */
+export declare const ORG_CAPABILITY_NAMES: readonly OrgCapability[];
+/** Each organization capability: what it lets a token do, and the scopes that does on one organization. */
+export declare const ORG_CAPABILITIES: Record<OrgCapability, {
+    label: string;
+    scopes: (organizationId: string) => string[];
+}>;
+/** Whether a word names an organization capability. */
+export declare function isOrgCapability(value: string): value is OrgCapability;
+/**
+ * The scopes `capabilities` hold on one organization, each once — added to a
+ * token's project scopes, so not {@link ALWAYS_SCOPES}.
+ *
+ * Throws on an organization id a scope cannot carry, and on an unknown
+ * capability.
+ */
+export declare function scopesForOrgCapabilities(organizationId: string, capabilities: readonly OrgCapability[]): string[];
+/**
+ * Read a token's `org:*` scopes back as organization capabilities: the
+ * organizations they name, and, for each, the capabilities it holds every
+ * scope of.
+ */
+export declare function orgCapabilitiesInScopes(scopes: readonly string[]): Array<{
+    organizationId: string;
+    capabilities: OrgCapability[];
+}>;

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

@@ -1,4 +1,4 @@
-import { type TokenCapability } from "./token-capabilities.js";
+import { type OrgCapability, type TokenCapability } from "./token-capabilities.js";
 /** Every action the group dispatches. */
 export declare const TOKENS_ACTIONS: readonly ["list", "create", "revoke"];
 /** What `rebase cloud tokens create` parses, beside the global flags (`--project` among them). */
@@ -6,14 +6,21 @@ export declare const CREATE_TOKEN_FLAGS: {
     "--can": [StringConstructor];
     "--name": StringConstructor;
     "--expires-in": StringConstructor;
+    "--org": StringConstructor;
 };
 export declare function tokensCommand(action: string | undefined, rawArgs: string[]): Promise<void>;
+/** What `--can` names: capabilities on one project, and on one organization. */
+export interface RequestedCapabilities {
+    project: TokenCapability[];
+    org: OrgCapability[];
+}
 /**
- * The capabilities `--can` names, comma-separated or repeated, each once.
+ * The capabilities `--can` names, comma-separated or repeated, each once —
+ * split into the project's and the organization's.
  *
  * Exported so its tests can drive it without a session.
  */
-export declare function parseCapabilities(values: readonly string[] | undefined): TokenCapability[];
+export declare function parseCapabilities(values: readonly string[] | undefined): RequestedCapabilities;
 /**
  * `--expires-in <days>` as an ISO timestamp, or null for a token that does not
  * expire.
@@ -21,3 +28,11 @@ export declare function parseCapabilities(values: readonly string[] | undefined)
  * Exported so its tests can drive it without a session.
  */
 export declare function resolveTokenExpiry(value: string | undefined, now?: Date): string | null;
+/**
+ * What a token was created for, read back from its scopes:
+ * `deploy, logs on proj_1; billing on organization org_1`. Undefined when no
+ * capability explains them.
+ *
+ * Exported for `whoami`, which reads a token back the same way.
+ */
+export declare function describeGrants(scopes: readonly string[]): string | undefined;

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

@@ -0,0 +1,63 @@
+export declare const USAGE_FLAGS: {
+    readonly "--month": StringConstructor;
+};
+export declare const USAGE_ACTIONS: readonly ["org"];
+/** A caveat on the figures, as the control plane sends it. */
+export interface CliUsageCaveat {
+    code: string;
+    message: string;
+    count?: number;
+}
+/** One project's month, as `GET /usage/:projectId` answers it. */
+export interface CliProjectUsage {
+    projectId: string;
+    month: string;
+    complete: boolean;
+    days: {
+        day: string;
+        requests: number;
+        errors: number;
+        missedSamples: number;
+    }[];
+    totals: {
+        requests: number;
+        errors: number;
+        daysRecorded: number;
+        daysWithGaps: number;
+    };
+    quotas: {
+        requestsPerMonth: number | null;
+    };
+    fraction: number;
+    warn: boolean;
+    overageEur: number;
+    billed: boolean;
+    projection: {
+        requests: number;
+        fraction: number;
+        overageEur: number;
+    } | null;
+    enforcement: {
+        kind: string;
+        message: string;
+    };
+    caveats: CliUsageCaveat[];
+}
+export interface CliOrgUsage {
+    organizationId: string;
+    month: string;
+    complete: boolean;
+    projects: (CliProjectUsage & {
+        name: string | null;
+    })[];
+    totals: {
+        requests: number;
+        errors: number;
+        overageEur: number;
+        projectedOverageEur: number | null;
+    };
+    truncated: boolean;
+}
+/** The allowance as a bar of 20 cells, coloured like the console: amber from 80%, red past it. */
+export declare function usageBar(fraction: number): string;
+export declare function usageCommand(rawArgs: string[]): Promise<void>;

package/dist/commands/dev.d.ts

@@ -380,6 +380,16 @@ export type SchemaGeneration = "generated" | "skipped" | "failed";
  * failed, the preflight is the remaining safety net and still runs.
  */
 export declare function needsStaleSchemaPreflight(generation: SchemaGeneration): boolean;
+/**
+ * What dev prints once a collection edit's regeneration is done.
+ *
+ * The green "regenerated" box only when neither half failed. It used to be
+ * printed unconditionally, right under "⚠ Could not regenerate the database
+ * schema … nothing was applied" — and then the backend refused to boot over
+ * the same collection error, so the success line was the one wrong thing on
+ * the screen.
+ */
+export declare function collectionChangeSummary(schema: SchemaGeneration, sdk: SchemaGeneration): string[];
 /**
  * One variable's value out of `.env` text, or undefined when it has none.
  *

package/dist/commands/doctor.d.ts

@@ -61,5 +61,5 @@ export declare const DOCTOR_FLAGS: {
  * The line handed to the driver, every path on it resolved from where the
  * command was run — the driver runs in `backend/`. See `utils/path-flags.ts`.
  */
-export declare function doctorDriverArgs(rawArgs: string[], cwd: string): string[];
+export declare function doctorDriverArgs(rawArgs: string[], cwd: string, projectRoot?: string): string[];
 export declare function doctorCommand(rawArgs: string[]): Promise<void>;

package/dist/commands/generate-view.d.ts

@@ -0,0 +1,94 @@
+import { resolveCollectionsDir } from "../utils/collections-dir.js";
+/** What `rebase generate` dispatches. Read by `cli.ts` to name the subcommand. */
+export declare const GENERATE_SUBCOMMANDS: readonly ["view"];
+export interface GenerateViewOptions {
+    projectRoot: string;
+    slug: string;
+    /** Register as a tab on this collection's records instead of as a screen. */
+    collection?: string;
+    /** The label in the sidebar or on the tab. Defaults to the slug in sentence case. */
+    name?: string;
+    /** A Lucide icon name for the sidebar. Screens only. */
+    icon?: string;
+    /** Replace an existing view file. Registration is never duplicated. */
+    force?: boolean;
+}
+export interface PlannedFile {
+    /** Absolute path. */
+    path: string;
+    contents: string;
+    action: "create" | "update" | "replace";
+}
+export interface GenerateViewPlan {
+    kind: "app" | "entity";
+    componentName: string;
+    viewFile: string;
+    files: PlannedFile[];
+    /** Steps the command could not take itself, as sentences to print. */
+    manualSteps: string[];
+}
+/** `orders-board` → `OrdersBoardView`; `sales-view` → `SalesView`, not `SalesViewView`. */
+export declare function viewComponentName(slug: string): string;
+/** `orders-board` → `Orders board`: labels are sentence case in the admin. */
+export declare function viewLabel(slug: string): string;
+/**
+ * The source with every string, template literal, regular expression and
+ * comment blanked out, character for character, so brackets and keys can be
+ * found by position without being fooled by a `{` inside a string. String
+ * contents become `_` (they are still "something"), comments become spaces.
+ *
+ * Exported for its tests.
+ */
+export declare function maskCode(source: string): string;
+/** The admin's frontend directory: the static app that mounts the CMS, or `frontend/`. */
+export declare function resolveFrontendDir(projectRoot: string): string | undefined;
+/** `<config>/collections`, as the backend app declares it — one resolver for every command. */
+export { resolveCollectionsDir };
+type ViewTemplateOptions = {
+    slug: string;
+    componentName: string;
+    label: string;
+    collection: string;
+};
+export declare function appViewSource(options: ViewTemplateOptions): string;
+export declare function entityViewSource(options: ViewTemplateOptions): string;
+/**
+ * Everything `rebase generate view` would write, without writing it.
+ *
+ * @throws UsageError when the slug is not a slug, there is no admin panel, the
+ *   view already exists (without `force`), or `--collection` names nothing.
+ */
+export declare function planGenerateView(options: GenerateViewOptions): GenerateViewPlan;
+/**
+ * `views/index.ts` with one more entry, `"already"` when the slug is listed, or
+ * `undefined` when the file has no `export const views … = [`.
+ *
+ * Exported for its tests.
+ */
+export declare function registerAppView(source: string, options: {
+    slug: string;
+    label: string;
+    icon: string;
+    componentName: string;
+}): string | "already" | undefined;
+/**
+ * `App.tsx` with `views={views}` on `<RebaseCMS>` and its import, `"already"`
+ * when it passes exactly that, or `undefined` when it cannot be done safely:
+ * no `<RebaseCMS`, a `views` prop of its own, or a `views` name already in scope.
+ *
+ * Exported for its tests.
+ */
+export declare function wireViewsIntoApp(source: string): string | "already" | undefined;
+/**
+ * The collection file with a `{ key, name, Builder }` entry in the
+ * `admin.entityViews` of the collection whose `slug:` is at `slugAt`;
+ * `"already"` when that key is there; `undefined` when the shape cannot be read.
+ *
+ * Exported for its tests.
+ */
+export declare function registerEntityView(source: string, slugAt: number, view: {
+    key: string;
+    name: string;
+    builder: string;
+}): string | "already" | undefined;
+export declare function generateCommand(subcommand: string | undefined, rawArgs?: string[]): Promise<void>;

package/dist/commands/generate_sdk.d.ts

@@ -50,6 +50,21 @@ export declare const REGISTER_FILE = "register.ts";
  * the registration rather than imported from the SDK.
  */
 export declare function registrationDir(collectionsDir: string): string;
+/**
+ * Write the server-side registration from the collection files in
+ * `collectionsDir`, exactly as `rebase generate-sdk` writes it, for a build.
+ *
+ * Only for a project that asked for it: `registerDatabase` in `rebase.json`,
+ * or a registration an earlier `--register` left, which is kept current. The
+ * registration lives in gitignored `config/generated/`, so a fresh clone (a CI
+ * job) has none until something writes it, and a bundle compiled without it
+ * types `context.data` as untyped rows: callbacks that read a typed column
+ * fail to compile there while they compile locally.
+ *
+ * Returns the directory written, or null when there was nothing to do.
+ * Throws when a `register.ts` there is not ours, as `generate-sdk` refuses.
+ */
+export declare function writeRegistrationForBuild(collectionsDir: string, registerDatabase: boolean): Promise<string | null>;
 /**
  * The base URL to show in the printed usage example.
  *