@spacefast/common 0.0.26 → 0.2.2

package/dist/contracts/zero.d.ts

@@ -1,30 +1,28 @@
 import { z } from "zod";
 import { type RuntimeRealtimeMode } from "./execution.js";
 /**
- * Spacefast Zero: capsules — schema, queries, mutations and endpoints that run
- * together inside one parent-owned transaction — executed by the native runner
- * on a dedicated wp.cloud site, against that site's own MySQL.
+ * Spacefast Zero: capsules of schema, queries, mutations and endpoints that run
+ * together inside one parent-owned transaction, executed by the native runner
+ * on a dedicated wp.cloud site against that site's own MySQL.
  *
- * The transaction is what makes this a separate product rather than a
- * placement option for `./functions.js`. A capsule handler's semantics depend
- * on the transaction wrapped around it, and an isolate reaching the database
- * over a relay cannot offer one. See `endpointIsPortable` in `./execution.js`
- * for the narrow surface both products can host.
+ * The transaction is what makes this a separate product rather than a placement
+ * option for `./functions.js`: an isolate reaching the database over a relay
+ * cannot offer one. See `endpointIsPortable` in `./execution.js` for the narrow
+ * surface both products can host.
  */
 export declare const ZERO_SOURCE_METADATA_KEY = "statticZero";
 /**
- * The tag a compiled capsule artifact carries — in the finalize payload, the
- * runtime config, the install profile, the client config the browser reads, and
- * every realtime event — so PHP and the Rust runner can tell what they were
- * handed. It is a property of the artifact the tree produced, not a kind a
- * space declares: a publish can carry this beside a worker.
+ * The tag a compiled capsule artifact carries everywhere it travels, so PHP and
+ * the Rust runner can tell what they were handed. It is a property of the
+ * artifact, not a kind a space declares: a publish can carry this beside a
+ * worker.
  */
 export declare const ZERO_RUNTIME_KIND = "zero";
 export declare const ZERO_PLATFORM_ROUTE_PREFIX = "/__spacefast/zero";
 /**
- * Entry paths the Zero scaffold writes into `sf.jsonc#runtime`. They are
- * starting points, not the contract: a capsule's entries are whatever its
- * `runtime.server`/`runtime.client` say, and nothing infers them.
+ * Entry paths the Zero scaffold writes into `sf.jsonc#runtime`. Starting points
+ * only: a capsule's entries are whatever its `runtime.server`/`runtime.client`
+ * say, and nothing infers them.
  */
 export declare const ZERO_CLIENT_ENTRY = "client/index.tsx";
 export declare const ZERO_SERVER_ENTRY = "server/index.ts";
@@ -51,15 +49,13 @@ export declare const ZERO_PUBLIC_CLIENT_BUNDLE_PATH = "client.js";
  * Where platform-owned client bytes serve from: same origin as the space, one
  * content-addressed directory per platform build.
  *
- * Same origin is the whole point. Browsers have partitioned the HTTP cache by
- * top-level site since 2020, so a shared third-party CDN buys nothing a
- * same-origin URL does not — and costs a `script-src` hole. What a stable,
- * content-addressed URL does buy is real: the digest changes only when the
- * platform bytes change, so publishing a capsule a hundred times re-downloads
- * the capsule's own bundle a hundred times and the platform's exactly once.
+ * Browsers have partitioned the HTTP cache by top-level site since 2020, so a
+ * shared third-party CDN buys nothing a same-origin URL does not, and costs a
+ * `script-src` hole. The digest changes only when the platform bytes change, so
+ * republishing a capsule re-downloads its own bundle but not the platform's.
  *
  * Underscore-prefixed by framework convention (`_next/static`, `_astro`), which
- * is also how the runtime recognises it as immutable — see `immutable_path` in
+ * is also how the runtime recognises it as immutable. See `immutable_path` in
  * `crates/stattic-runtime-core/src/finalize.rs`.
  */
 export declare const ZERO_PLATFORM_ASSET_NAMESPACE = "_spacefast";
@@ -69,39 +65,33 @@ export declare function zeroPlatformAssetPath(digest: string, fileName: string):
 /**
  * The compiled capsule server, which the QuickJS runner instantiates whole.
  *
- * 768 KiB is inherited, not measured: nobody has yet established what the
- * runner actually tolerates, and DS77 keeps the number only until someone does.
- * It binds a real resource — the runner holds the module graph in the site's
- * PHP-worker memory before executing anything — so it stays low deliberately;
- * server code is handlers, not an application.
+ * 768 KiB is inherited, not measured: nobody has established what the runner
+ * actually tolerates. It binds a real resource, since the runner holds the
+ * module graph in the site's PHP-worker memory before executing anything, so it
+ * stays low deliberately.
  */
 export declare const ZERO_SERVER_BUNDLE_MAX_BYTES = 786432;
 /**
  * The tenant client bundle, and every other file the compile ships as content.
  *
- * This measures what the tenant publishes, and only that: the SDK, the kit, the
+ * This measures what the tenant publishes, and only that. The SDK, the kit, the
  * chart layer, preact, recharts and lucide are externals resolved through the
  * shell's import map to {@link ZERO_PLATFORM_ASSET_ROOT}, so platform bytes are
- * never weighed here (DS42). What remains is author code plus whatever npm the
- * author chose to bundle.
+ * never weighed here.
  *
- * 8 MiB matches the Functions per-entry cap (DS77) because the same reasoning
- * applies: a client bundle is static bytes to a browser, so nothing on the
- * serving side binds it, and the cap exists to fail an accidental
- * hundred-megabyte dependency in our tooling — where the build can say which
- * modules are large — rather than at upload. It is a guardrail, not a budget;
- * the size report is what an author should be reading.
+ * 8 MiB matches the Functions per-entry cap. A client bundle is static bytes to
+ * a browser, so nothing on the serving side binds it; the cap exists to fail an
+ * accidental hundred-megabyte dependency in tooling that can say which modules
+ * are large, rather than at upload.
  */
 export declare const ZERO_CLIENT_BUNDLE_MAX_BYTES: number;
 /**
  * A capsule's compiled server travels as version metadata, not as content, so a
- * server-only change leaves the published app shell byte-identical — and the
- * version intent's manifest comparison would read it as "no changes" and never
- * deploy it. The publish writes this one small file into the version instead:
- * it holds a digest of everything the deploy would install, so any server,
- * schema, or runtime-config change moves the manifest. Same channel a Functions
- * bundle uses (`functionsBundleStoragePath`) — an ordinary manifest entry, no
- * artifact-specific plumbing.
+ * server-only change would leave the app shell byte-identical and the version
+ * intent's manifest comparison would read it as "no changes". The publish writes
+ * this one small file into the version instead: it holds a digest of everything
+ * the deploy would install, so any server, schema, or runtime-config change
+ * moves the manifest.
  */
 export declare const ZERO_RUNTIME_DEPLOY_PATH = "__spacefast/zero/deploy.json";
 export declare const ZERO_MANAGED_TABLE_COLUMNS: readonly ["id", "createdAt", "updatedAt"];
@@ -181,12 +171,12 @@ export declare const zeroDatabaseSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
 }, z.core.$strict>>;
 export type ZeroDatabase = z.infer<typeof zeroDatabaseSchema>;
 /**
- * The compiled server travels inline in the finalize payload; inlining keeps the
- * whole version one atomic write. Functions bundles do the opposite and land
- * in the content store first; see `functionsBundleRefSchema`.
+ * The compiled server travels inline in the finalize payload, which keeps the
+ * whole version one atomic write. Functions bundles land in the content store
+ * first; see `functionsBundleRefSchema`.
  *
- * The client never travels this way. It is content — the browser fetches it
- * from the version tree like any other asset — so it ships as a static file.
+ * The client never travels this way: it is content the browser fetches from the
+ * version tree, so it ships as a static file.
  */
 export declare const zeroRuntimeBundleSchema: z.ZodObject<{
     path: z.ZodString;
@@ -217,6 +207,7 @@ export declare const zeroRuntimeRunSourceSchema: z.ZodObject<{
         gravatar: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
         spam: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
         email: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        content: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
     }, z.core.$strip>>;
     db: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strict>;
@@ -245,6 +236,7 @@ export declare const zeroRuntimeEndpointSourceSchema: z.ZodObject<{
         gravatar: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
         spam: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
         email: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        content: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
     }, z.core.$strip>>;
     db: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strict>;
@@ -816,6 +808,7 @@ export declare const zeroRuntimeFinalizePayloadSchema: z.ZodObject<{
             gravatar: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
             spam: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
             email: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            content: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
         }, z.core.$strip>>;
         db: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strict>>>;
@@ -833,6 +826,7 @@ export declare const zeroRuntimeFinalizePayloadSchema: z.ZodObject<{
             gravatar: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
             spam: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
             email: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            content: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
         }, z.core.$strip>>;
         db: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strict>>>;
@@ -937,10 +931,6 @@ export declare const zeroRuntimeConfigSchema: z.ZodObject<{
         signOutUrl: z.ZodDefault<z.ZodNullable<z.ZodString>>;
         returnToParam: z.ZodDefault<z.ZodString>;
     }, z.core.$strict>>;
-    variables: z.ZodObject<{
-        source: z.ZodLiteral<"stattic-variables">;
-        names: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>;
     realtime: z.ZodObject<{
         mode: z.ZodEnum<{
             local: "local";
@@ -1086,6 +1076,10 @@ export declare const zeroRuntimeConfigSchema: z.ZodObject<{
             }, z.core.$strip>>>;
         }, z.core.$strict>;
     }, z.core.$strict>;
+    variables: z.ZodObject<{
+        source: z.ZodLiteral<"stattic-variables">;
+        names: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
     runtimeKind: z.ZodLiteral<"zero">;
     migrations: z.ZodDefault<z.ZodNullable<z.ZodObject<{
         format: z.ZodLiteral<"stattic.zero.migrations.v1">;
@@ -1386,6 +1380,7 @@ export declare const zeroDeployMetadataSchema: z.ZodObject<{
                 gravatar: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                 spam: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                 email: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+                content: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
             }, z.core.$strip>>;
             db: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strict>>>;
@@ -1403,6 +1398,7 @@ export declare const zeroDeployMetadataSchema: z.ZodObject<{
                 gravatar: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                 spam: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                 email: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+                content: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
             }, z.core.$strip>>;
             db: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strict>>>;
@@ -1503,18 +1499,13 @@ export type ZeroDeployMetadata = z.infer<typeof zeroDeployMetadataSchema>;
  * What a live Zero capsule is, as the `capsule` member of a space's runtime
  * status.
  *
- * There is no `versionId` here: this only ever describes the version the status
- * response already names as live, and repeating it would invite the two to
- * disagree. `artifactId` stays because it identifies the built capsule rather
- * than the publish that carries it. There is no kind tag either — the member it
- * rides in already says which product answered.
+ * No `versionId`: the status response already names the live version, and
+ * repeating it would invite the two to disagree. `artifactId` stays because it
+ * identifies the built capsule rather than the publish that carries it.
  *
- * Every field is derived from the version's own finalize metadata, which is
- * what makes this safe to answer for a space whose runtime is asleep,
- * mid-move, or failing: nothing here costs a call to the space's origin. It is
- * also why there are no counts of things listed here — a caller that wants
- * `tables.length` can take it — and why the database is not a field: a capsule
- * always owns one, so its presence already said so.
+ * Every field is derived from the version's own finalize metadata, so this is
+ * safe to answer for a space whose runtime is asleep, mid-move, or failing.
+ * Nothing here costs a call to the space's origin.
  */
 export declare const zeroAppSchema: z.ZodObject<{
     artifactId: z.ZodString;
@@ -1571,6 +1562,8 @@ export declare const zeroAppSchema: z.ZodObject<{
         path: z.ZodString;
     }, z.core.$strict>>>;
     sockets: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    serverBundleSize: z.ZodNullable<z.ZodNumber>;
+    clientBundleSize: z.ZodNullable<z.ZodNumber>;
     migrationCount: z.ZodNumber;
     schemaHash: z.ZodNullable<z.ZodString>;
     variables: z.ZodObject<{

package/dist/contracts/zero.js

@@ -1,30 +1,28 @@
 import { z } from "zod";
 import { appRoutePathSchema, EXECUTION_ENV_MAX_KEYS, executionBundleSchema, executionCapabilitiesSchema, executionEnvNameSchema, executionIdentifierSchema, executionInspectPolicySchema, executionSha256Schema, executionStaticFileSchema, httpMethodSchema, LAKEBED_SERVER_ENV_FILE, PLATFORM_ROUTE_PREFIX, runtimeRealtimeModeSchema, SERVER_ENV_FILE, } from "./execution.js";
 /**
- * Spacefast Zero: capsules — schema, queries, mutations and endpoints that run
- * together inside one parent-owned transaction — executed by the native runner
- * on a dedicated wp.cloud site, against that site's own MySQL.
+ * Spacefast Zero: capsules of schema, queries, mutations and endpoints that run
+ * together inside one parent-owned transaction, executed by the native runner
+ * on a dedicated wp.cloud site against that site's own MySQL.
  *
- * The transaction is what makes this a separate product rather than a
- * placement option for `./functions.js`. A capsule handler's semantics depend
- * on the transaction wrapped around it, and an isolate reaching the database
- * over a relay cannot offer one. See `endpointIsPortable` in `./execution.js`
- * for the narrow surface both products can host.
+ * The transaction is what makes this a separate product rather than a placement
+ * option for `./functions.js`: an isolate reaching the database over a relay
+ * cannot offer one. See `endpointIsPortable` in `./execution.js` for the narrow
+ * surface both products can host.
  */
 export const ZERO_SOURCE_METADATA_KEY = "statticZero";
 /**
- * The tag a compiled capsule artifact carries — in the finalize payload, the
- * runtime config, the install profile, the client config the browser reads, and
- * every realtime event — so PHP and the Rust runner can tell what they were
- * handed. It is a property of the artifact the tree produced, not a kind a
- * space declares: a publish can carry this beside a worker.
+ * The tag a compiled capsule artifact carries everywhere it travels, so PHP and
+ * the Rust runner can tell what they were handed. It is a property of the
+ * artifact, not a kind a space declares: a publish can carry this beside a
+ * worker.
  */
 export const ZERO_RUNTIME_KIND = "zero";
 export const ZERO_PLATFORM_ROUTE_PREFIX = `${PLATFORM_ROUTE_PREFIX}/zero`;
 /**
- * Entry paths the Zero scaffold writes into `sf.jsonc#runtime`. They are
- * starting points, not the contract: a capsule's entries are whatever its
- * `runtime.server`/`runtime.client` say, and nothing infers them.
+ * Entry paths the Zero scaffold writes into `sf.jsonc#runtime`. Starting points
+ * only: a capsule's entries are whatever its `runtime.server`/`runtime.client`
+ * say, and nothing infers them.
  */
 export const ZERO_CLIENT_ENTRY = "client/index.tsx";
 export const ZERO_SERVER_ENTRY = "server/index.ts";
@@ -51,15 +49,13 @@ export const ZERO_PUBLIC_CLIENT_BUNDLE_PATH = "client.js";
  * Where platform-owned client bytes serve from: same origin as the space, one
  * content-addressed directory per platform build.
  *
- * Same origin is the whole point. Browsers have partitioned the HTTP cache by
- * top-level site since 2020, so a shared third-party CDN buys nothing a
- * same-origin URL does not — and costs a `script-src` hole. What a stable,
- * content-addressed URL does buy is real: the digest changes only when the
- * platform bytes change, so publishing a capsule a hundred times re-downloads
- * the capsule's own bundle a hundred times and the platform's exactly once.
+ * Browsers have partitioned the HTTP cache by top-level site since 2020, so a
+ * shared third-party CDN buys nothing a same-origin URL does not, and costs a
+ * `script-src` hole. The digest changes only when the platform bytes change, so
+ * republishing a capsule re-downloads its own bundle but not the platform's.
  *
  * Underscore-prefixed by framework convention (`_next/static`, `_astro`), which
- * is also how the runtime recognises it as immutable — see `immutable_path` in
+ * is also how the runtime recognises it as immutable. See `immutable_path` in
  * `crates/stattic-runtime-core/src/finalize.rs`.
  */
 export const ZERO_PLATFORM_ASSET_NAMESPACE = "_spacefast";
@@ -71,39 +67,33 @@ export function zeroPlatformAssetPath(digest, fileName) {
 /**
  * The compiled capsule server, which the QuickJS runner instantiates whole.
  *
- * 768 KiB is inherited, not measured: nobody has yet established what the
- * runner actually tolerates, and DS77 keeps the number only until someone does.
- * It binds a real resource — the runner holds the module graph in the site's
- * PHP-worker memory before executing anything — so it stays low deliberately;
- * server code is handlers, not an application.
+ * 768 KiB is inherited, not measured: nobody has established what the runner
+ * actually tolerates. It binds a real resource, since the runner holds the
+ * module graph in the site's PHP-worker memory before executing anything, so it
+ * stays low deliberately.
  */
 export const ZERO_SERVER_BUNDLE_MAX_BYTES = 786_432;
 /**
  * The tenant client bundle, and every other file the compile ships as content.
  *
- * This measures what the tenant publishes, and only that: the SDK, the kit, the
+ * This measures what the tenant publishes, and only that. The SDK, the kit, the
  * chart layer, preact, recharts and lucide are externals resolved through the
  * shell's import map to {@link ZERO_PLATFORM_ASSET_ROOT}, so platform bytes are
- * never weighed here (DS42). What remains is author code plus whatever npm the
- * author chose to bundle.
+ * never weighed here.
  *
- * 8 MiB matches the Functions per-entry cap (DS77) because the same reasoning
- * applies: a client bundle is static bytes to a browser, so nothing on the
- * serving side binds it, and the cap exists to fail an accidental
- * hundred-megabyte dependency in our tooling — where the build can say which
- * modules are large — rather than at upload. It is a guardrail, not a budget;
- * the size report is what an author should be reading.
+ * 8 MiB matches the Functions per-entry cap. A client bundle is static bytes to
+ * a browser, so nothing on the serving side binds it; the cap exists to fail an
+ * accidental hundred-megabyte dependency in tooling that can say which modules
+ * are large, rather than at upload.
  */
 export const ZERO_CLIENT_BUNDLE_MAX_BYTES = 8 * 1024 * 1024;
 /**
  * A capsule's compiled server travels as version metadata, not as content, so a
- * server-only change leaves the published app shell byte-identical — and the
- * version intent's manifest comparison would read it as "no changes" and never
- * deploy it. The publish writes this one small file into the version instead:
- * it holds a digest of everything the deploy would install, so any server,
- * schema, or runtime-config change moves the manifest. Same channel a Functions
- * bundle uses (`functionsBundleStoragePath`) — an ordinary manifest entry, no
- * artifact-specific plumbing.
+ * server-only change would leave the app shell byte-identical and the version
+ * intent's manifest comparison would read it as "no changes". The publish writes
+ * this one small file into the version instead: it holds a digest of everything
+ * the deploy would install, so any server, schema, or runtime-config change
+ * moves the manifest.
  */
 export const ZERO_RUNTIME_DEPLOY_PATH = `${ZERO_RUNTIME_STORAGE_ROOT}/deploy.json`;
 export const ZERO_MANAGED_TABLE_COLUMNS = ["id", "createdAt", "updatedAt"];
@@ -118,9 +108,8 @@ export const ZERO_RESERVED_APP_ROUTE_PATHS = [
     `/${ZERO_PUBLIC_CLIENT_BUNDLE_PATH}`,
     "/auth/callback",
 ];
-// The whole platform namespace is reserved, not just the one directory a build
-// happens to write: an endpoint claiming a path under it would shadow bytes the
-// shell's import map already told the browser to fetch.
+// The whole platform namespace is reserved: an endpoint claiming a path under it
+// would shadow bytes the shell's import map already told the browser to fetch.
 export const ZERO_RESERVED_APP_ROUTE_PREFIXES = [
     "/auth/",
     `/${ZERO_PLATFORM_ASSET_NAMESPACE}/`,
@@ -264,12 +253,12 @@ export const zeroTableSchema = z
 export const zeroDatabaseSchema = z.record(z.string(), zeroTableSchema);
 const zeroSha256Schema = executionSha256Schema;
 /**
- * The compiled server travels inline in the finalize payload; inlining keeps the
- * whole version one atomic write. Functions bundles do the opposite and land
- * in the content store first; see `functionsBundleRefSchema`.
+ * The compiled server travels inline in the finalize payload, which keeps the
+ * whole version one atomic write. Functions bundles land in the content store
+ * first; see `functionsBundleRefSchema`.
  *
- * The client never travels this way. It is content — the browser fetches it
- * from the version tree like any other asset — so it ships as a static file.
+ * The client never travels this way: it is content the browser fetches from the
+ * version tree, so it ships as a static file.
  */
 export const zeroRuntimeBundleSchema = executionBundleSchema({
     bundleRoot: ZERO_RUNTIME_BUNDLE_ROOT,
@@ -636,18 +625,13 @@ export const zeroDeployMetadataSchema = z
  * What a live Zero capsule is, as the `capsule` member of a space's runtime
  * status.
  *
- * There is no `versionId` here: this only ever describes the version the status
- * response already names as live, and repeating it would invite the two to
- * disagree. `artifactId` stays because it identifies the built capsule rather
- * than the publish that carries it. There is no kind tag either — the member it
- * rides in already says which product answered.
+ * No `versionId`: the status response already names the live version, and
+ * repeating it would invite the two to disagree. `artifactId` stays because it
+ * identifies the built capsule rather than the publish that carries it.
  *
- * Every field is derived from the version's own finalize metadata, which is
- * what makes this safe to answer for a space whose runtime is asleep,
- * mid-move, or failing: nothing here costs a call to the space's origin. It is
- * also why there are no counts of things listed here — a caller that wants
- * `tables.length` can take it — and why the database is not a field: a capsule
- * always owns one, so its presence already said so.
+ * Every field is derived from the version's own finalize metadata, so this is
+ * safe to answer for a space whose runtime is asleep, mid-move, or failing.
+ * Nothing here costs a call to the space's origin.
  */
 export const zeroAppSchema = z
     .object({
@@ -667,9 +651,27 @@ export const zeroAppSchema = z
     endpoints: z.array(zeroEndpointSchema).default([]),
     sockets: z.array(z.string()).default([]),
     /**
-     * Migrations are operations, not names — `create_table`, `add_column` and
-     * friends — so a count is the honest summary here. The operations
-     * themselves are the database surface's answer (`GET /v1/spaces/{id}/db`).
+     * Compiled bundle sizes in bytes, read from the finalize payload's own
+     * declarations. Null — never 0 — when a legacy version's metadata predates
+     * size reporting, so absence stays honest. Meter these against
+     * {@link ZERO_SERVER_BUNDLE_MAX_BYTES} and {@link ZERO_CLIENT_BUNDLE_MAX_BYTES}.
+     */
+    serverBundleSize: z
+        .number()
+        .int()
+        .nonnegative()
+        .nullable()
+        .describe("Compiled server bundle size in bytes, or null when this version's metadata does not record it."),
+    clientBundleSize: z
+        .number()
+        .int()
+        .nonnegative()
+        .nullable()
+        .describe("Compiled client bundle size in bytes, or null when this version's metadata does not record it."),
+    /**
+     * Migrations are operations, not names, so a count is the summary here. The
+     * operations themselves are the database surface's answer
+     * (`GET /v1/spaces/{id}/db`).
      */
     migrationCount: z.number().int().nonnegative(),
     /** Digest of the schema the live migration plan settled on, if it ran one. */

package/dist/dashboard-paths/index.d.ts

@@ -1,46 +1,49 @@
 /**
- * Dashboard route first-segments that cannot be used as team slugs.
- *
- * Append-only: add a new top-level static dashboard route's first segment here
- * before its route module lands. A repository structural test enforces this.
+ * `connect` is held for the team-level connect page (see
+ * `reservedSegmentActivationContract` in apps/my's dashboard route ledger).
  */
-export declare const TEAM_SLUG_ROUTE_RESERVATIONS: readonly ["accept-beta-invite", "accept-invitation", "account", "access", "agent", "claim", "device", "drop", "new-team", "oauth", "push", "sign-in", "start", "terminal", "two-factor"];
-/**
- * Dashboard route first-segments that cannot be used as space slugs.
- *
- * Append-only: add a new static route directly below a team's first segment
- * here before its route module lands. A repository structural test enforces
- * this.
- */
-export declare const SPACE_SLUG_ROUTE_RESERVATIONS: readonly ["billing", "connect", "domains", "drop", "members", "new", "resume", "settings"];
+export declare const UNBUILT_SPACE_SLUG_ROUTE_RESERVATIONS: readonly ["connect"];
+/** Dashboard route first-segments that cannot be used as team slugs. */
+export declare const TEAM_SLUG_ROUTE_RESERVATIONS: readonly ["accept-beta-invite", "accept-invitation", "access", "account", "approvals", "claim", "device", "drop", "new-team", "oauth", "push", "sign-in", "start", "terminal", "two-factor"];
+/** Dashboard route first-segments that cannot be used as space slugs. */
+export declare const SPACE_SLUG_ROUTE_RESERVATIONS: readonly ["agents", "api-keys", "billing", "domains", "drop", "handoffs", "members", "new", "resume", "settings", "variables", "webhooks", "connect"];
 export type TeamSlugRouteReservation = (typeof TEAM_SLUG_ROUTE_RESERVATIONS)[number];
 export type SpaceSlugRouteReservation = (typeof SPACE_SLUG_ROUTE_RESERVATIONS)[number];
 export declare const TEAM_SLUG_ROUTE_RESERVATION_SET: ReadonlySet<string>;
 export declare const SPACE_SLUG_ROUTE_RESERVATION_SET: ReadonlySet<string>;
 /**
- * The Runtime page's sections. They are search params rather than path
- * segments, so `runtime` stays a single route (and a single ledger row) and a
- * space slugged "runtime" keeps its own Runtime page at
+ * The Runtime page's sections. Search params, not path segments, so `runtime`
+ * stays one route and a space slugged "runtime" keeps its own Runtime page at
  * `/<team>/runtime/runtime`.
  */
 export declare const SPACE_RUNTIME_SECTIONS: readonly ["overview", "database", "storage", "logs"];
 export type SpaceRuntimeSection = (typeof SPACE_RUNTIME_SECTIONS)[number];
 export declare const DEFAULT_SPACE_RUNTIME_SECTION: SpaceRuntimeSection;
-export type SpaceSettingsDestination = "access" | "advanced" | "builds" | "integrations" | "integrations/add" | "source-builds";
-export type TeamSettingsDestination = "access" | "audit" | "developer" | "developer/agents" | "developer/environment-variables" | "developer/handoffs" | "developer/webhooks" | "integrations";
+/**
+ * What is left under a Space's Settings dialog. Builds, Integrations, and
+ * Variables are top-level Space surfaces with their own builders below.
+ */
+export type SpaceSettingsDestination = "advanced" | "data-sources";
+export type TeamSettingsDestination = "access" | "activity" | "billing" | "integrations" | "usage";
+/** Top-level team surfaces; the name comes from the old Settings > Developer group. */
+export type TeamDeveloperSurface = "agents" | "api-keys" | "handoffs" | "variables" | "webhooks";
 export declare function teamPath(teamSlug: string): string;
 export declare function spacePath(teamSlug: string, spaceSlug: string): string;
 export declare function versionDetailPath(teamSlug: string, spaceSlug: string, versionRef: string): string;
 export declare function buildDetailPath(teamSlug: string, spaceSlug: string, buildId: string): string;
 export declare function spaceDomainsPath(teamSlug: string, spaceSlug: string): string;
+/** Build runs and the repository connection that produces them. */
+export declare function spaceBuildsPath(teamSlug: string, spaceSlug: string): string;
+export declare function spaceIntegrationsPath(teamSlug: string, spaceSlug: string): string;
+export declare function spaceVariablesPath(teamSlug: string, spaceSlug: string): string;
 /**
- * The space's Runtime page. The default section is the bare URL — the route
- * strips it back out of the address bar — so a link to "overview" and a link to
- * the page itself are the same link.
+ * The space's Runtime page. The route strips the default section back out of the
+ * address bar, so a link to "overview" and a link to the page are the same link.
  */
 export declare function spaceRuntimePath(teamSlug: string, spaceSlug: string, section?: SpaceRuntimeSection): string;
 export declare function spaceSettingsPath(teamSlug: string, spaceSlug: string, destination?: SpaceSettingsDestination): string;
 export declare function teamDomainsPath(teamSlug: string): string;
 export declare function teamBillingPath(teamSlug: string): string;
+export declare function teamDeveloperSurfacePath(teamSlug: string, surface: TeamDeveloperSurface): string;
 export declare function teamDomainDetailPath(teamSlug: string, domainRef: string): string;
 export declare function teamSettingsPath(teamSlug: string, destination?: TeamSettingsDestination): string;