@rebasepro/types 0.10.0 → 0.10.1-canary.14e53ae

package/dist/types/backend.d.ts

@@ -1,6 +1,7 @@
 import type { CollectionConfig, FilterValues, WhereFilterOp } from "./collections";
 import type { AuthAdapter } from "./auth_adapter";
 import type { HistoryConfig } from "../controllers/client";
+import type { ChannelBusSetting } from "./channel_bus";
 /**
  * Abstract database connection interface.
  * Represents a connection to any database system.
@@ -188,13 +189,23 @@ export interface ChannelRetentionRule {
      */
     ttl?: number | string;
 }
-/** Server-side realtime options. */
+/**
+ * Server-side realtime options.
+ *
+ * The channel bus contract and its config live in `./channel_bus` so that a
+ * transport shipped as its own package depends on the contract alone.
+ */
 export interface RealtimeChannelsConfig {
     /**
      * Retention rules, most specific first — the first match wins. Omitted or
      * empty means no channel retains anything.
      */
     channels?: ChannelRetentionRule[];
+    /**
+     * How channel broadcast and presence reach other backend instances.
+     * Defaults to `{ type: "memory" }` — i.e. they don't.
+     */
+    bus?: ChannelBusSetting;
 }
 /**
  * Abstract realtime provider interface.
@@ -582,6 +593,24 @@ export interface BackendBootstrapper {
      * Return admin capabilities for this driver.
      */
     getAdmin?(driverResult: InitializedDriver): DatabaseAdmin | undefined;
+    /**
+     * Bring the database's collection tables up to date, additively.
+     *
+     * Optional because it is only meaningful for schema-ful drivers. A managed
+     * runtime boots a compiled project against a database it has never seen; auth
+     * tables are ensured on boot but collection tables were created by nothing,
+     * so every data request answered 500 on a missing relation. The CLI's `db
+     * push` cannot fill the gap — it needs Atlas, and the runtime image ships no
+     * CLI.
+     *
+     * Implementations MUST be additive-only: create missing tables, columns and
+     * enum types, and never drop, narrow or rewrite anything. This runs
+     * unattended against live customer data with nobody reading a diff, so the
+     * destructive half stays a deliberate migration.
+     */
+    ensureCollectionSchema?(collections: unknown[], driverResult: InitializedDriver, log?: (message: string) => void): Promise<{
+        applied: number;
+    }>;
     /**
      * Initialize WebSocket server for realtime operations.
      */

package/dist/types/channel_bus.d.ts

@@ -0,0 +1,192 @@
+/**
+ * The cross-instance transport for channel broadcast and presence, and the
+ * contract anyone implementing one has to meet.
+ *
+ * These types live in `@rebasepro/types` rather than in the Postgres adapter on
+ * purpose: a transport package should depend on the contract, not on the
+ * database driver that happens to ship the default implementation. A
+ * `@rebasepro/channel-bus-<something>` package needs this file and nothing else.
+ *
+ * Why a transport exists at all: entity/collection realtime already spans
+ * instances (CDC, or per-mutation LISTEN/NOTIFY). Channel broadcast and presence
+ * did not — they fanned out from per-process maps, so two clients served by
+ * different replicas could not see each other, and nothing errored. The bus is
+ * the missing hop, and deliberately *only* that hop: which local clients receive
+ * a frame stays in the realtime service, so a transport never has to know what a
+ * subscription, a WebSocket or a presence roster is.
+ */
+/**
+ * A frame in flight between instances.
+ *
+ * `sid` identifies the publishing instance. The realtime service drops frames
+ * carrying its own `sid` on arrival — local fan-out already happened before the
+ * publish — so a transport that echoes a publisher's own messages back to it is
+ * still correct, merely wasteful.
+ *
+ * Keys are spelled out rather than abbreviated. The one shipped transport with a
+ * size limit has a pointer path for anything that would approach it, so shaving
+ * bytes off key names buys nothing worth the opacity.
+ */
+export type ChannelBusFrame = 
+/** A broadcast carrying its payload. */
+{
+    kind: "broadcast";
+    sid: string;
+    channel: string;
+    event: string;
+    /** Originating client, echoed so receivers can skip it if it is theirs. */
+    from?: string;
+    /** Sequence number, present only on retained channels. */
+    seq?: number;
+    payload: unknown;
+}
+/**
+ * A broadcast too large for the transport to carry inline: the body is
+ * already durable in `rebase.channel_messages`, so the frame carries only
+ * its address and each receiver reads it back. Only ever emitted for
+ * retained channels, and only by a transport with a finite
+ * {@link ChannelBus.maxFrameBytes}.
+ */
+ | {
+    kind: "broadcast_ref";
+    sid: string;
+    channel: string;
+    from?: string;
+    seq: number;
+}
+/** A presence join/leave/update, small by construction. */
+ | {
+    kind: "presence_diff";
+    sid: string;
+    channel: string;
+    joins: Record<string, Record<string, unknown>>;
+    leaves: Record<string, Record<string, unknown>>;
+};
+/** Receives frames published by *other* instances. */
+export type ChannelBusHandler = (frame: ChannelBusFrame) => void | Promise<void>;
+/**
+ * A cross-instance transport.
+ *
+ * ## What an implementation must guarantee
+ *
+ * - **`start()` rejects if the transport is unusable.** The caller falls back to
+ *   in-process delivery when it does. Resolving while disconnected produces a
+ *   cluster that believes it is connected and silently is not, which is the
+ *   exact failure this whole mechanism exists to remove.
+ * - **`publish()` reaches every *other* instance, or rejects.** Delivery back to
+ *   the publisher is permitted but pointless (see {@link ChannelBusFrame.sid}).
+ * - **`stop()` is idempotent** and releases everything, including anything
+ *   holding the event loop open.
+ * - **A malformed message never throws out of the transport.** Parsing happens
+ *   inside the implementation; drop and log what you cannot understand, so one
+ *   bad frame cannot take the listener down.
+ *
+ * ## What it does *not* have to guarantee
+ *
+ * - **Ordering.** Retained channels carry `seq`, and the client SDK orders by
+ *   it. Unsequenced broadcasts are cursor-grade traffic where order is not
+ *   meaningful.
+ * - **Durability.** A frame lost in transit is a missed live update; retained
+ *   channels repair themselves through the client's `channel_history` replay.
+ * - **Exactly-once.** Duplicates are tolerated — retained frames are deduped by
+ *   `seq`, and presence diffs are idempotent by construction.
+ */
+export interface ChannelBus {
+    /**
+     * Identifies the transport in logs and in `getChannelBusKind()`. Use your
+     * own name; the framework only compares against `"memory"` to decide
+     * whether publishing is worth attempting at all.
+     */
+    readonly kind: string;
+    /**
+     * Largest frame this transport will carry, in bytes of encoded JSON, or
+     * `Infinity` when there is no meaningful ceiling.
+     *
+     * A broadcast that exceeds it is published as a `broadcast_ref` pointer when
+     * the channel is retained, and refused with an error to the sender when it
+     * is not. Implementations with no limit should return `Infinity` rather than
+     * a large number, so the pointer path is never taken needlessly.
+     */
+    readonly maxFrameBytes: number;
+    /** Connect and begin delivering remote frames to `handler`. */
+    start(handler: ChannelBusHandler): Promise<void>;
+    /** Publish a frame to the other instances. */
+    publish(frame: ChannelBusFrame): Promise<void>;
+    /** Disconnect and release resources. Idempotent. */
+    stop(): Promise<void>;
+}
+/**
+ * Which transport to use, for the two that ship with the Postgres adapter.
+ *
+ * To use one that does not ship here — a Redis package, or your own class —
+ * pass the {@link ChannelBus} instance itself instead of a config object.
+ *
+ * There are deliberately only two built in, and neither adds a service to a
+ * deployment. Rebase deploys as Postgres + backend + frontend; a bus that
+ * required a message broker would put a second stateful service into every
+ * `docker-compose.yml` the CLI scaffolds, for a feature most applications never
+ * use. Measured across two backend instances against one Postgres container,
+ * the Postgres bus carried ~10k cross-instance messages/second with no losses,
+ * and stayed flat out to eight instances — comfortably past what live-cursor
+ * collaboration generates. The extension point below is the answer for anyone
+ * who does outgrow it.
+ */
+export type ChannelBusConfig = 
+/**
+ * In-process only — the historical behaviour. Broadcast and presence reach
+ * the clients connected to *this* instance and no further.
+ */
+{
+    type: "memory";
+}
+/**
+ * Postgres LISTEN/NOTIFY, reusing infrastructure the deployment already has.
+ *
+ * `pg_notify` caps a payload at 8000 bytes, so a broadcast larger than that
+ * is delivered cross-instance only on a *retained* channel, where the
+ * notification carries a pointer (`seq`) instead of the message and each
+ * receiver reads the body back from `rebase.channel_messages`. An oversized
+ * broadcast on an ephemeral channel is refused rather than silently
+ * delivered to half the cluster.
+ *
+ * NOTE: `LISTEN` needs a session-mode connection. Behind PgBouncer in
+ * transaction mode this must point at the database directly
+ * (`DATABASE_DIRECT_URL`), not at the pooler.
+ */
+ | {
+    type: "postgres";
+    /** Direct connection for the LISTEN client. Defaults to `DATABASE_DIRECT_URL`. */
+    connectionString?: string;
+    /**
+     * How long to coalesce outgoing frames into a single notification, in
+     * milliseconds. Defaults to 10.
+     *
+     * A notify is a query on your primary database, so under load this is
+     * the difference between one query per message and one per window. The
+     * window is leading-edge: a frame arriving when none is open goes out
+     * immediately, so an idle channel pays no added latency and only a
+     * sustained stream is batched.
+     *
+     * Set to 0 to disable coalescing and send every frame on its own.
+     */
+    batchWindowMs?: number;
+};
+/**
+ * What `realtime.bus` accepts: a built-in transport by name, or any
+ * {@link ChannelBus} instance.
+ *
+ * ```typescript
+ * realtime: { bus: { type: "postgres" } }        // shipped
+ * realtime: { bus: new MyRedisChannelBus(url) }  // a separate package, or your own
+ * ```
+ */
+export type ChannelBusSetting = ChannelBusConfig | ChannelBus;
+/**
+ * Whether `setting` is an already-constructed transport rather than a request
+ * for a built-in one.
+ *
+ * Structural rather than nominal so that an instance from a *different copy* of
+ * `@rebasepro/types` — an entirely normal outcome of a separately versioned
+ * transport package — is still recognised.
+ */
+export declare function isChannelBusInstance(setting: ChannelBusSetting | undefined): setting is ChannelBus;

package/dist/types/collection_contract.d.ts

@@ -0,0 +1,43 @@
+import type { CollectionConfig } from "./collections";
+/**
+ * Serializing collections so they survive a network hop.
+ *
+ * A collection definition is not plain data. Relations point at their target
+ * with a *function* (`target: () => usersCollection`) so two collections can
+ * reference each other without an import cycle, and collections also carry
+ * callbacks, custom views and component references. `JSON.stringify` silently
+ * drops every one of those, which matters because the SDK generator *calls*
+ * `relation.target()` to decide whether a foreign key is a string or a number.
+ * Serialize naively and remote SDK generation produces subtly wrong types
+ * instead of failing — the worst possible outcome.
+ *
+ * So relation targets are resolved to a slug reference on the way out and
+ * rebuilt into functions on the way in. Everything else that cannot cross a wire
+ * is dropped deliberately: an SDK is generated from the *shape* of the data, and
+ * server-side behaviour is neither useful to a client nor safe to publish.
+ */
+/** Marker replacing a relation's `target` function in serialized form. */
+export interface SerializedCollectionRef {
+    __collectionRef: string;
+}
+export declare function isSerializedCollectionRef(value: unknown): value is SerializedCollectionRef;
+/**
+ * Serialize collections for transport over the contract endpoint.
+ *
+ * Sorted by slug so the output — and therefore the schema hash computed from it
+ * — does not depend on filesystem ordering.
+ */
+export declare function serializeCollections(collections: CollectionConfig[]): unknown[];
+/**
+ * Rebuild collections received from a contract endpoint.
+ *
+ * Relation refs become real thunks resolving through the returned set, so
+ * downstream consumers — the SDK generator above all — see exactly the shape
+ * they would have seen had the collections been imported from source.
+ *
+ * A ref naming a collection that is not in the payload resolves to `undefined`
+ * rather than throwing: the generator already tolerates an unresolvable target
+ * by falling back to a permissive key type, and a partial contract should still
+ * produce a usable SDK.
+ */
+export declare function deserializeCollections(payload: unknown[]): CollectionConfig[];

package/dist/types/index.d.ts

@@ -14,6 +14,7 @@ export * from "./modify_collections";
 export * from "./formex";
 export * from "./websockets";
 export * from "./backend";
+export * from "./channel_bus";
 export * from "./translations";
 export * from "./plugins";
 export * from "./builders";
@@ -31,3 +32,7 @@ export * from "./database_adapter";
 export * from "./breadcrumbs";
 export * from "./component_overrides";
 export * from "./api_keys";
+export * from "./project_manifest";
+export * from "./collection_contract";
+export * from "./schema_version";
+export * from "./storage_authorize";

package/dist/types/project_manifest.d.ts

@@ -0,0 +1,336 @@
+/**
+ * The project manifest (`rebase.json`) and the build artifacts derived from it.
+ *
+ * Three separate documents live in this file, and keeping them distinct matters:
+ *
+ * 1. {@link RebaseProjectManifest} — `rebase.json`. **Authored** by the developer,
+ *    committed to the repository. Declares topology only: which runtime major the
+ *    project targets, and which apps *this repository* contributes to the project.
+ *    Schema, security rules, hooks and functions stay in TypeScript under the
+ *    config package — nothing that needs a type system belongs here.
+ *
+ * 2. {@link RebaseProjectLink} — the per-checkout link (`.rebase/cloud.json`).
+ *    **Not committed**, because it is per-developer like a git remote. Says which
+ *    deployed project this working copy points at, whether that is a Rebase Cloud
+ *    project or the base URL of a self-hosted backend.
+ *
+ * 3. {@link RebaseBundleManifest} — `manifest.json` inside a built bundle.
+ *    **Generated**, never hand-edited. It is the lockfile analogue: the exact
+ *    contract a built artifact claims to satisfy, which the runtime validates
+ *    before it boots and a control plane validates before it deploys.
+ *
+ * A repository declares only the apps it contains. The set of apps belonging to a
+ * project is held by the project itself, which is what makes multi-repo projects
+ * work: two repositories never need to know about each other, only about the
+ * project.
+ */
+/**
+ * Which kind of thing an app is.
+ *
+ * - `backend` — the collections/hooks/functions that define the project's API.
+ *   Exactly one per *project* (not per repository); the registry enforces it.
+ * - `static`  — a pre-built client bundle (SPA, static site) served over CDN.
+ * - `admin`   — the Rebase admin panel, either hosted by the platform or built
+ *   into this repository.
+ * - `mobile`  — a native app. Registration only: it gets client credentials and
+ *   configuration, and is never built or hosted here.
+ * - `custom`  — an arbitrary container image built from a Dockerfile. The eject
+ *   hatch: full control, no managed-runtime guarantees.
+ */
+export type RebaseAppType = "backend" | "static" | "admin" | "mobile" | "custom";
+/**
+ * The backend app: the project's API surface.
+ *
+ * Paths are relative to the directory holding `rebase.json`. The defaults match
+ * the layout `rebase init` scaffolds, so a stock project may declare simply
+ * `{ "type": "backend" }`.
+ */
+export interface RebaseBackendAppConfig {
+    type: "backend";
+    /** Directory of the config package (collections + index). Default `config`. */
+    config?: string;
+    /** Directory of server functions. Default `backend/functions`. */
+    functions?: string;
+    /** Directory of cron job definitions. Default `backend/crons` when present. */
+    crons?: string;
+    /**
+     * Path to the generated Drizzle schema module (tables/enums/relations).
+     * Default `backend/src/schema.generated.ts`.
+     */
+    schema?: string;
+    /**
+     * Which collections source the runtime uses.
+     *
+     * - `cms` (default) — collections come from the config package.
+     * - `baas` — collections are introspected from the live database at boot and
+     *   the config package is not required.
+     */
+    mode?: "cms" | "baas";
+    /**
+     * Module path (relative to `config`) exporting the auth users collection as
+     * its default export. Default `collections/users`.
+     */
+    usersCollection?: string;
+}
+/**
+ * A static client bundle — SPA or static site — built here and served from CDN.
+ */
+export interface RebaseStaticAppConfig {
+    type: "static";
+    /** Package directory containing the client sources. */
+    root: string;
+    /** Command that produces `output`. Run from the repository root. */
+    build?: string;
+    /** Directory of built assets, relative to the repository root. */
+    output: string;
+    /**
+     * Serve `index.html` for unmatched paths (client-side routing).
+     * Default `true` — the overwhelmingly common case for a client app, and a
+     * static *site* generator emits real files for its routes anyway.
+     */
+    spa?: boolean;
+}
+/**
+ * The admin panel.
+ *
+ * `hosted` is the default and means the platform serves it — nothing is built
+ * into this repository and nothing ships in the bundle. `bundled` builds it here,
+ * which is what a self-hosted or air-gapped deployment wants.
+ */
+export interface RebaseAdminAppConfig {
+    type: "admin";
+    mode?: "hosted" | "bundled";
+    /** Only for `bundled`: package directory containing the admin sources. */
+    root?: string;
+    /** Only for `bundled`: build command. */
+    build?: string;
+    /** Only for `bundled`: directory of built assets. */
+    output?: string;
+}
+/**
+ * A native app. Registered for credentials and configuration; never built here.
+ */
+export interface RebaseMobileAppConfig {
+    type: "mobile";
+    platform: "ios" | "android" | "other";
+}
+/**
+ * An app built from a Dockerfile into an arbitrary image.
+ *
+ * This is the deliberate escape hatch. A project containing one is not eligible
+ * for the managed runtime — the platform cannot make guarantees about an image
+ * it did not build — but it still deploys, and nothing else about the project
+ * changes.
+ */
+export interface RebaseCustomAppConfig {
+    type: "custom";
+    /** Dockerfile path relative to the repository root. */
+    dockerfile?: string;
+    /** Build context relative to the repository root. Default `.`. */
+    context?: string;
+    /** Port the container listens on. Default 8080. */
+    port?: number;
+}
+export type RebaseAppConfig = RebaseBackendAppConfig | RebaseStaticAppConfig | RebaseAdminAppConfig | RebaseMobileAppConfig | RebaseCustomAppConfig;
+/**
+ * `rebase.json` — the authored project manifest.
+ */
+export interface RebaseProjectManifest {
+    /** JSON Schema URL, for editor completion. Ignored by the tooling. */
+    $schema?: string;
+    /**
+     * The runtime **major** this project targets, as a semver range
+     * (e.g. `^1`, `~1.4`, or an exact `1.4.2` to pin).
+     *
+     * The platform upgrades patches and minors underneath a project without
+     * asking; it never crosses a major. See {@link RUNTIME_CONTRACT_VERSION}.
+     */
+    runtime: string;
+    /**
+     * Apps this repository contributes, keyed by app name. The key is the app's
+     * identity within the project: it is what `rebase deploy <app>` names, what
+     * client credentials are issued against, and what a second repository must
+     * not collide with.
+     */
+    apps: Record<string, RebaseAppConfig>;
+}
+/**
+ * The per-checkout project link.
+ *
+ * Deliberately separate from `rebase.json`: the manifest is committed and shared,
+ * while the link is per-developer. Keeping them in one file would mean either
+ * committing someone's project id or gitignoring the topology.
+ */
+export interface RebaseProjectLink {
+    /**
+     * A Rebase Cloud project id, or the base URL of any running Rebase backend
+     * (`https://api.example.com`). Both are first-class: every command that
+     * accepts a project reference accepts either, so a self-hosted project has
+     * the same tooling as a cloud one.
+     */
+    project: string;
+    /** Organization slug. Cloud projects only. */
+    org?: string;
+    /** Explicit API base URL, when it differs from the project's default. */
+    apiUrl?: string;
+}
+/**
+ * Whether a project can run on the managed runtime, and if not, precisely why.
+ *
+ * The reasons are returned rather than summarised so tooling can print something
+ * a developer can act on. "Not eligible" is never a dead end — it selects the
+ * custom-runtime path, which still deploys.
+ */
+export interface ManagedCompatibility {
+    eligible: boolean;
+    reasons: string[];
+}
+/**
+ * Version of the bundle *format* itself.
+ *
+ * Bumped only when the on-disk layout changes in a way an older runtime could
+ * not read. A runtime accepts any bundle whose `bundleFormat` is less than or
+ * equal to its own — old bundles keep booting on new runtimes, which is the
+ * whole point of separating the artifact from the engine.
+ */
+export declare const BUNDLE_FORMAT_VERSION = 1;
+/**
+ * The runtime contract major.
+ *
+ * Distinct from the `@rebasepro/server` package version: the package may release
+ * any number of minors and patches while this stays put. It changes only when
+ * the bundle/runtime contract breaks compatibility, and a project's
+ * `manifest.runtime` range is matched against *this*.
+ */
+export declare const RUNTIME_CONTRACT_VERSION = 1;
+/** Where the runtime finds each part of the bundle. Paths are bundle-relative. */
+export interface RebaseBundleEntrypoints {
+    /** Compiled config package directory (collections live under it). */
+    config?: string;
+    /** Compiled collections directory, when it differs from `<config>/collections`. */
+    collections?: string;
+    /** Compiled functions directory. */
+    functions?: string;
+    /** Compiled crons directory. */
+    crons?: string;
+    /** Compiled Drizzle schema module. */
+    schema?: string;
+    /** Module exporting the auth users collection (default export). */
+    usersCollection?: string;
+    /** Built admin assets, when the admin panel is bundled rather than hosted. */
+    admin?: string;
+    /** Built static assets to serve from the runtime, when not on a CDN. */
+    static?: string;
+}
+/**
+ * A native module found in the dependency closure.
+ *
+ * Recorded rather than merely counted so a rejection can name the offending
+ * package instead of saying "something here is native".
+ */
+export interface NativeDependency {
+    name: string;
+    /** Why it was flagged — a `.node` binary, a gyp build, or an install script. */
+    reason: string;
+}
+/**
+ * `manifest.json` — generated, and the document the runtime and control plane
+ * both validate against.
+ */
+export interface RebaseBundleManifest {
+    /** @see BUNDLE_FORMAT_VERSION */
+    bundleFormat: number;
+    runtime: {
+        /** The `runtime` range copied from `rebase.json`. */
+        range: string;
+        /** Exact `@rebasepro/server` version this bundle was built against. */
+        builtAgainst: string;
+        /** Runtime contract major this bundle requires. */
+        contract: number;
+    };
+    /**
+     * Hash of the compiled collection definitions.
+     *
+     * This is the contract stamp. A generated SDK records the value it was built
+     * from, a client sends it back, and a mismatch is what lets the platform say
+     * "this app was built against an older schema" instead of failing mysteriously
+     * at the first request. It covers collections only — a hook edit does not
+     * change a client's contract, so it must not invalidate every SDK.
+     */
+    schemaVersion: string;
+    /** Which app in `rebase.json` this bundle was built from. */
+    app: string;
+    /**
+     * What the runtime does with this bundle.
+     *
+     * - `cms` — a backend with declared collections; the runtime provisions their
+     *   tables and serves the data API.
+     * - `baas` — a backend that introspects an existing database rather than
+     *   declaring collections.
+     * - `static` — no backend at all: the bundle is a built SPA (`entry.static`),
+     *   and the runtime only serves those assets. No database, no data sources —
+     *   this is how a `static`/`admin` app runs on the same image as the backend.
+     */
+    mode: "cms" | "baas" | "static";
+    entry: RebaseBundleEntrypoints;
+    /** Collection slugs contained in the bundle, for quick inspection. */
+    collections?: string[];
+    hooks: {
+        /**
+         * Whether the dependency closure contains native code.
+         *
+         * The managed runtime refuses these: a prebuilt binary cannot be run on
+         * an image the platform did not build it for, and the honest failure is
+         * at deploy time rather than at 3am in a crash loop.
+         */
+        native: boolean;
+        nativeModules?: NativeDependency[];
+    };
+    /**
+     * What the bundle's config says about storage access control.
+     *
+     * Storage is not under RLS and its keys share one flat namespace, so a
+     * deployment with file storage enabled and no access model serves every
+     * user's files to every signed-in user. The runtime refuses to boot in that
+     * state — which, on a hosted platform that enables storage from the *console*
+     * rather than from the bundle, surfaces as a crash loop the developer cannot
+     * read.
+     *
+     * Recording it here lets a host reject the deploy with the reason instead.
+     * Absent on bundles built before this field existed.
+     */
+    storage?: {
+        /** Whether the config package exports a `storageAuthorize` hook. */
+        authorize: boolean;
+    };
+    deps: {
+        /** Runtime dependencies of user code, as declared. */
+        declared: Record<string, string>;
+    };
+    build: {
+        /** `@rebasepro/cli` version that produced this bundle. */
+        cli: string;
+        /** Node major the bundle was compiled on. */
+        node: string;
+        /** ISO-8601. */
+        createdAt: string;
+    };
+}
+/** The contract a running backend serves at `GET /api/meta/contract`. */
+export interface RebaseProjectContract {
+    /** Matches {@link RebaseBundleManifest.schemaVersion}. */
+    schemaVersion: string;
+    runtime: {
+        /** `@rebasepro/server` version currently running. */
+        version: string;
+        contract: number;
+    };
+    mode: "cms" | "baas";
+    /** Full collection definitions, serialized — the input to SDK generation. */
+    collections: unknown[];
+    /** Collection slugs, for cheap inspection without parsing the definitions. */
+    collectionSlugs: string[];
+    generatedAt: string;
+}
+/** Header carrying the schema version an SDK was generated from. */
+export declare const SCHEMA_VERSION_HEADER = "x-rebase-schema";

package/dist/types/schema_version.d.ts

@@ -0,0 +1,18 @@
+import type { CollectionConfig } from "./collections";
+/**
+ * Compute the canonical string a schema version hashes.
+ *
+ * Exposed separately so the hashing itself can differ by environment: Node has
+ * `crypto`, and callers without it can still compare canonical forms directly.
+ */
+export declare function canonicalSchemaPayload(collections: CollectionConfig[]): string;
+/**
+ * A short, non-cryptographic digest of the canonical payload.
+ *
+ * FNV-1a style, 64 bits, as two 32-bit halves. This is an identity, not a
+ * security boundary: nothing trusts a schema version to prove anything, it only
+ * answers "is this the same schema as before". A hand-rolled hash keeps this
+ * module free of `node:crypto`, so the identical function runs in the browser,
+ * in the CLI, and in the runtime — which is the property that actually matters.
+ */
+export declare function computeSchemaVersion(collections: CollectionConfig[]): string;