@spacefast/common 0.0.26 → 0.2.2

package/dist/contracts/runtime-api.d.ts

@@ -14,9 +14,6 @@ export declare const runtimePurgeReceiptSchema: z.ZodObject<{
     }>;
     urls: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
-export declare const runtimeSpacePurgeRequestSchema: z.ZodObject<{
-    urls: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
 export declare const runtimeSpacePurgeResponseSchema: z.ZodObject<{
     space_id: z.ZodString;
     purge: z.ZodObject<{
@@ -82,6 +79,32 @@ export declare const runtimeVersionCreateRequestSchema: z.ZodObject<{
     expires_at: z.ZodOptional<z.ZodString>;
     metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>;
+export declare const runtimeStaticZipIngestResponseSchema: z.ZodObject<{
+    space_id: z.ZodString;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        size: z.ZodNumber;
+        sha256: z.ZodString;
+        sniff: z.ZodEnum<{
+            text: "text";
+            binary: "binary";
+            png: "png";
+            jpeg: "jpeg";
+            gif: "gif";
+            webp: "webp";
+            avif: "avif";
+            ico: "ico";
+            pdf: "pdf";
+            gzip: "gzip";
+            woff: "woff";
+            woff2: "woff2";
+            ttf: "ttf";
+            otf: "otf";
+        }>;
+    }, z.core.$strip>>;
+    pin_expires_at: z.ZodString;
+}, z.core.$strip>;
+export type RuntimeStaticZipIngestResponse = z.infer<typeof runtimeStaticZipIngestResponseSchema>;
 export declare const runtimeVersionCreateResponseSchema: z.ZodObject<{
     space_id: z.ZodString;
     version_id: z.ZodString;
@@ -118,10 +141,9 @@ export declare const runtimeUploadSessionDescriptorSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type RuntimeUploadSessionDescriptor = z.infer<typeof runtimeUploadSessionDescriptorSchema>;
 /**
- * The retention half of a create-version body or session descriptor, spelled
- * once. `retained_files` is omitted when empty — with an explicit `retention`
- * that omission is unambiguous: it means retain nothing beyond what `all`
- * materializes.
+ * The retention half of a create-version body or session descriptor.
+ * `retained_files` is omitted when empty; with an explicit `retention` that
+ * omission means retain nothing beyond what `all` materializes.
  */
 export declare function runtimeRetentionFields(input: {
     retention: RuntimeRetentionMode;
@@ -337,6 +359,7 @@ export declare const runtimeVersionFinalizeRequestSchema: z.ZodObject<{
         reusable_version_id: z.ZodOptional<z.ZodString>;
         metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strip>>;
+    previous_version_id: z.ZodOptional<z.ZodString>;
     zero: z.ZodOptional<z.ZodObject<{
         auth: z.ZodDefault<z.ZodObject<{
             provider: z.ZodDefault<z.ZodLiteral<"gravatar">>;
@@ -346,10 +369,6 @@ export declare const runtimeVersionFinalizeRequestSchema: 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";
@@ -495,6 +514,10 @@ export declare const runtimeVersionFinalizeRequestSchema: 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">;
@@ -638,6 +661,7 @@ export declare const runtimeVersionFinalizeRequestSchema: 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>>;
             platform: z.ZodDefault<z.ZodObject<{
                 nextCache: z.ZodDefault<z.ZodBoolean>;
@@ -724,6 +748,19 @@ export declare const runtimeVersionFinalizeRequestSchema: z.ZodObject<{
                     index: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>>;
                 previews: z.ZodRecord<z.ZodString, z.ZodString>;
+                platform: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+                    legal: "legal";
+                    login: "login";
+                    suspended: "suspended";
+                    undeployed: "undeployed";
+                    gone: "gone";
+                    "runtime-error": "runtime-error";
+                    "rate-limited": "rate-limited";
+                    "tier-unavailable": "tier-unavailable";
+                    "proxy-error": "proxy-error";
+                    "method-not-allowed": "method-not-allowed";
+                    "content-too-large": "content-too-large";
+                }>, z.ZodString>>;
                 collab: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>;
             experimental_gutenberg: z.ZodOptional<z.ZodBoolean>;
@@ -968,14 +1005,44 @@ export declare const runtimeCatalogDeltaSchema: z.ZodObject<{
 export declare const runtimeCompileDiagnosticSchema: z.ZodObject<{
     severity: z.ZodEnum<{
         info: "info";
-        error: "error";
         warning: "warning";
+        error: "error";
     }>;
     code: z.ZodString;
     message: z.ZodString;
     path: z.ZodOptional<z.ZodString>;
     details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>;
+export declare const runtimeRouteInventorySchema: z.ZodObject<{
+    format: z.ZodLiteral<"stattic.route-inventory.v1">;
+    routes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            proxy: "proxy";
+            functions: "functions";
+            redirect: "redirect";
+            rewrite: "rewrite";
+            "not-found": "not-found";
+            "php-function": "php-function";
+            "zero-control": "zero-control";
+            "zero-endpoint": "zero-endpoint";
+        }>;
+        source: z.ZodString;
+        runtime: z.ZodEnum<{
+            routing: "routing";
+            php: "php";
+            "cloudflare-worker": "cloudflare-worker";
+            "quick-js": "quick-js";
+        }>;
+        host: z.ZodString;
+        path: z.ZodString;
+        methods: z.ZodArray<z.ZodString>;
+        auth: z.ZodLiteral<"inherit">;
+        cache: z.ZodOptional<z.ZodLiteral<"shared">>;
+        destination: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export declare const runtimeCompiledRoutingSchema: z.ZodObject<{
     redirect_rule_count: z.ZodNumber;
     header_rule_count: z.ZodNumber;
@@ -1023,8 +1090,8 @@ export declare const runtimeVersionFinalizeResponseSchema: z.ZodObject<{
     diagnostics: z.ZodDefault<z.ZodArray<z.ZodObject<{
         severity: z.ZodEnum<{
             info: "info";
-            error: "error";
             warning: "warning";
+            error: "error";
         }>;
         code: z.ZodString;
         message: z.ZodString;
@@ -1040,6 +1107,36 @@ export declare const runtimeVersionFinalizeResponseSchema: z.ZodObject<{
             destination: z.ZodString;
         }, z.core.$strip>>>;
     }, z.core.$strip>>;
+    route_inventory: z.ZodOptional<z.ZodObject<{
+        format: z.ZodLiteral<"stattic.route-inventory.v1">;
+        routes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                proxy: "proxy";
+                functions: "functions";
+                redirect: "redirect";
+                rewrite: "rewrite";
+                "not-found": "not-found";
+                "php-function": "php-function";
+                "zero-control": "zero-control";
+                "zero-endpoint": "zero-endpoint";
+            }>;
+            source: z.ZodString;
+            runtime: z.ZodEnum<{
+                routing: "routing";
+                php: "php";
+                "cloudflare-worker": "cloudflare-worker";
+                "quick-js": "quick-js";
+            }>;
+            host: z.ZodString;
+            path: z.ZodString;
+            methods: z.ZodArray<z.ZodString>;
+            auth: z.ZodLiteral<"inherit">;
+            cache: z.ZodOptional<z.ZodLiteral<"shared">>;
+            destination: z.ZodOptional<z.ZodString>;
+            status: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     variable_digests: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
     system_variable_dependencies: z.ZodDefault<z.ZodArray<z.ZodString>>;
     manifest: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -1340,26 +1437,6 @@ export declare const runtimeTombstonesUpdateResponseSchema: z.ZodObject<{
     space_id: z.ZodString;
     tombstone_count: z.ZodNumber;
 }, z.core.$strip>;
-export declare const runtimeRetentionPolicyUpdateRequestSchema: z.ZodObject<{
-    prunable_version_ids: z.ZodArray<z.ZodString>;
-}, z.core.$strip>;
-export declare const runtimeRetentionPolicyUpdateResponseSchema: z.ZodObject<{
-    purge: z.ZodOptional<z.ZodObject<{
-        status: z.ZodEnum<{
-            failed: "failed";
-            queued: "queued";
-            pending: "pending";
-            ok: "ok";
-        }>;
-        mode: z.ZodEnum<{
-            domain: "domain";
-            urls: "urls";
-        }>;
-        urls: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    space_id: z.ZodString;
-    prunable_count: z.ZodNumber;
-}, z.core.$strip>;
 export declare const runtimeVersionDeleteResponseSchema: z.ZodObject<{
     purge: z.ZodOptional<z.ZodObject<{
         status: z.ZodEnum<{
@@ -1458,6 +1535,7 @@ export declare const runtimeCallbackEventSchema: z.ZodObject<{
     operation_action: z.ZodOptional<z.ZodString>;
     space_id: z.ZodOptional<z.ZodString>;
     version_id: z.ZodOptional<z.ZodString>;
+    version_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
     route_name: z.ZodOptional<z.ZodString>;
     hostnames: z.ZodOptional<z.ZodArray<z.ZodString>>;
     changed_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -1513,6 +1591,7 @@ export declare const runtimeEventsDrainResponseSchema: z.ZodObject<{
             operation_action: z.ZodOptional<z.ZodString>;
             space_id: z.ZodOptional<z.ZodString>;
             version_id: z.ZodOptional<z.ZodString>;
+            version_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
             route_name: z.ZodOptional<z.ZodString>;
             hostnames: z.ZodOptional<z.ZodArray<z.ZodString>>;
             changed_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -1667,7 +1746,6 @@ export declare const runtimeEngineJobTickResponseSchema: z.ZodObject<{
     drained: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type RuntimeVersionCreateRequest = z.infer<typeof runtimeVersionCreateRequestSchema>;
-export type RuntimeSpacePurgeRequest = z.infer<typeof runtimeSpacePurgeRequestSchema>;
 export type RuntimeVersionFinalizeRequest = z.infer<typeof runtimeVersionFinalizeRequestSchema>;
 export type RuntimeVersionFinalizeResponse = z.infer<typeof runtimeVersionFinalizeResponseSchema>;
 export type RuntimeFinalizeTelemetry = z.infer<typeof runtimeFinalizeTelemetrySchema>;
@@ -1675,7 +1753,6 @@ export type RuntimeReadinessTarget = z.infer<typeof runtimeReadinessTargetSchema
 export type RuntimeHostnameIntentUpdateRequest = z.infer<typeof runtimeHostnameIntentUpdateRequestSchema>;
 export type RuntimeRouteUpdateRequest = z.infer<typeof runtimeRouteUpdateRequestSchema>;
 export type RuntimeTombstonesUpdateRequest = z.infer<typeof runtimeTombstonesUpdateRequestSchema>;
-export type RuntimeRetentionPolicyUpdateRequest = z.infer<typeof runtimeRetentionPolicyUpdateRequestSchema>;
 export type RuntimeSpaceState = z.infer<typeof runtimeSpaceStateSchema>;
 export type RuntimeCallbackEvent = z.infer<typeof runtimeCallbackEventSchema>;
 export type RuntimeEventsDrainRequest = z.infer<typeof runtimeEventsDrainRequestSchema>;

package/dist/contracts/runtime-api.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { CONTENT_SNIFF_KINDS } from "../utils/content-type.js";
 import { accessFenceKindSchema } from "./access.js";
 import { functionsRuntimeConfigSchema } from "./functions.js";
 import { grantSchema } from "./grants.js";
@@ -38,7 +39,7 @@ const previousVersionIdSchema = z
     .string()
     .min(1)
     .optional()
-    .describe("The pointer target this activation replaces (diff baseline).");
+    .describe("The previous live version used as the catalog diff baseline.");
 export const runtimePurgeReceiptSchema = z.object({
     status: runtimePurgeStatusSchema,
     mode: z.enum(["urls", "domain"]),
@@ -47,15 +48,11 @@ export const runtimePurgeReceiptSchema = z.object({
 const runtimeMutationPurgeFields = {
     purge: runtimePurgeReceiptSchema.optional(),
 };
-export const runtimeSpacePurgeRequestSchema = z.object({
-    urls: z.array(z.string().startsWith("/")).optional(),
-});
 export const runtimeSpacePurgeResponseSchema = z.object({
     space_id: z.string().min(1),
     purge: runtimePurgeReceiptSchema,
 });
-// One bounded page of a version's file catalog — the runtime's own answer to
-// "which files does this version have". `view=source` is the uploaded,
+// One bounded page of a version's file catalog. `view=source` is the uploaded,
 // pre-substitution object; `view=served` is the immutable byte a visitor
 // receives, and `variant_route` marks a channel's substituted bytes within it.
 export const runtimeVersionFilesResponseSchema = z.object({
@@ -77,16 +74,15 @@ export const runtimeVersionCreateRequestSchema = z.object({
     version_id: z.string().min(1).optional(),
     files: z.array(manifestFileSchema),
     // Retention is stated, never inferred. `all` carries every path of
-    // `reusable_version_id` forward — the runtime materializes that list from the
-    // base version's own catalog at finalize, under the space lock, which is what
-    // keeps the lazy publish path free of a pre-upload round trip. `list` retains
-    // exactly `retained_files`, and an EMPTY list is meaningful: it is a publish
-    // that drops every path the base held. `none` retains nothing.
+    // `reusable_version_id` forward, materialized from the base catalog at
+    // finalize under the space lock, which keeps the lazy publish path free of a
+    // pre-upload round trip. `list` retains exactly `retained_files`, and an EMPTY
+    // list is meaningful: it drops every path the base held. `none` retains
+    // nothing.
     //
-    // `all` and `list` both require `reusable_version_id`. Only `list` may carry
-    // `retained_files`. Inferring `all` from "base named + empty list" used to
-    // silently undo deletes — the runtime has no delete list, so deletion IS
-    // omission from the retained set.
+    // `all` and `list` both require `reusable_version_id`; only `list` may carry
+    // `retained_files`. The runtime has no delete list, so deletion IS omission
+    // from the retained set.
     retention: runtimeRetentionModeSchema,
     retained_files: z.array(manifestFileSchema).optional(),
     reusable_version_id: z.string().min(1).optional(),
@@ -94,6 +90,16 @@ export const runtimeVersionCreateRequestSchema = z.object({
     expires_at: z.string().optional(),
     metadata: z.record(z.string(), z.unknown()).default({}),
 });
+export const runtimeStaticZipIngestResponseSchema = z.object({
+    space_id: z.string().min(1),
+    files: z.array(z.object({
+        path: z.string().min(1),
+        size: z.number().int().nonnegative(),
+        sha256: z.string().regex(/^[a-f0-9]{64}$/),
+        sniff: z.enum(CONTENT_SNIFF_KINDS),
+    })),
+    pin_expires_at: z.string().datetime({ offset: true }),
+});
 export const runtimeVersionCreateResponseSchema = z.object({
     space_id: z.string(),
     version_id: z.string(),
@@ -107,20 +113,18 @@ export const runtimeUploadSessionDescriptorSchema = z.object({
     expires_at: z.string(),
     manifest_hash: z.string().optional(),
     files: z.array(manifestFileSchema),
-    // Retained files only travel in the authenticated finalize request: they are
-    // unbounded and unused while accepting a PUT, which is also what keeps a lazy
-    // session's descriptor inside its JWT budget. Retention itself is stated on
-    // the wire — see the create request.
+    // Retained files travel only in the authenticated finalize request: they are
+    // unbounded and unused while accepting a PUT, which keeps a lazy session's
+    // descriptor inside its JWT budget.
     retention: runtimeRetentionModeSchema,
     retained_files: z.array(manifestFileSchema).optional(),
     reusable_version_id: z.string().min(1).optional(),
     metadata: z.record(z.string(), z.unknown()).default({}),
 });
 /**
- * The retention half of a create-version body or session descriptor, spelled
- * once. `retained_files` is omitted when empty — with an explicit `retention`
- * that omission is unambiguous: it means retain nothing beyond what `all`
- * materializes.
+ * The retention half of a create-version body or session descriptor.
+ * `retained_files` is omitted when empty; with an explicit `retention` that
+ * omission means retain nothing beyond what `all` materializes.
  */
 export function runtimeRetentionFields(input) {
     return {
@@ -221,9 +225,9 @@ export const runtimeAuthorizationProjectionSchema = z
 // The space-level Comments projection the runtime serves as the whole answer
 // for `/__spacefast/comments/config`; the runtime adds only per-request fields.
 const runtimeSdkCommentsSchema = z.object({
-    // Comments boot on the live/published host.
+    // Which hosts Comments boot on: the live/published host, and the immutable
+    // version (preview) host.
     live: z.boolean(),
-    // ...and on an immutable version (preview) host.
     preview: z.boolean(),
     // Null before the Space has ever published.
     live_url: z.string().url().max(2000).nullable(),
@@ -432,17 +436,17 @@ const runtimeSubstitutionChannelSchema = z.object({
 export const runtimeVersionFinalizeRequestSchema = z.object({
     upload_id: z.string().min(1),
     session: runtimeUploadSessionDescriptorSchema.optional(),
+    // Capsule versions finalize and activate in separate calls, but still need
+    // the same publish delta as the combined path.
+    previous_version_id: previousVersionIdSchema,
     zero: zeroRuntimeConfigSchema.optional(),
     // Dispatch configuration for a Functions version. Absent for static versions,
-    // and absent when no execution host is configured — the version then serves
-    // as pure static content, because this config is what makes the origin
-    // dispatch at all.
+    // and absent when no execution host is configured; this config is what makes
+    // the origin dispatch at all.
     functions: functionsRuntimeConfigSchema.optional(),
-    // Variable resolution is the control plane's half of substitution and stays
-    // there: scopes come from its database, secret values are never decrypted for
-    // it, and `SPACEFAST_*` names are platform-provided. The finalizer owns the
-    // substitution itself — it has the staged bytes and the config that declares
-    // which paths are templates, so nothing pre-substituted crosses this wire.
+    // The control plane resolves variable scopes; secret values are never
+    // decrypted for it. The finalizer performs the substitution itself, so
+    // nothing pre-substituted crosses this wire.
     variable_scopes: z.array(runtimeVariableScopeSchema).optional(),
     system_variables: z.record(z.string().min(1), z.string()).optional(),
     // The space's channels, so the finalizer can compile each one's variant files
@@ -467,11 +471,9 @@ export const runtimeVersionFinalizeRequestSchema = z.object({
         noindexHost: z.boolean().optional(),
         config: runtimeServingConfigSchema.optional(),
         // Origins the platform's own browser code loads from, keyed by the CSP
-        // directive each belongs in. Which origins those are is a control-plane
-        // decision — they come from its environment and are validated against the
-        // host this version will serve from — while the merge itself belongs to
-        // the finalizer, which is the only side that sees every CSP the version
-        // sets, in `_headers` and in config rules alike.
+        // directive each belongs in. The control plane picks them, validated
+        // against the host this version will serve from; the finalizer merges
+        // them, because only it sees every CSP the version sets.
         platform_csp_sources: z
             .record(z.string().min(1).max(64), z.array(z.string().min(1).max(512)).max(16))
             .optional(),
@@ -530,9 +532,8 @@ export const runtimeCatalogDeltaSchema = z.object({
 });
 // One compiled diagnostic from the finalizer. `path` is the committed file it
 // points at, carrying `file:line` when the compiler knew a line; `details` is
-// what it points at INSIDE that file — the variable, the channel, the colliding
-// routes — which is the difference between a publish failure you can act on and
-// one you can only retry.
+// what it points at INSIDE that file: the variable, the channel, or the
+// colliding routes.
 export const runtimeCompileDiagnosticSchema = z.object({
     severity: z.enum(["info", "warning", "error"]),
     code: z.string().min(1),
@@ -540,6 +541,31 @@ export const runtimeCompileDiagnosticSchema = z.object({
     path: z.string().optional(),
     details: z.record(z.string(), z.unknown()).optional(),
 });
+export const runtimeRouteInventorySchema = z.object({
+    format: z.literal("stattic.route-inventory.v1"),
+    routes: z.array(z.object({
+        id: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+        kind: z.enum([
+            "redirect",
+            "rewrite",
+            "proxy",
+            "not-found",
+            "functions",
+            "php-function",
+            "zero-control",
+            "zero-endpoint",
+        ]),
+        source: z.string().min(1),
+        runtime: z.enum(["routing", "cloudflare-worker", "php", "quick-js"]),
+        host: z.string().min(1),
+        path: z.string().startsWith("/"),
+        methods: z.array(z.string().min(1)).min(1),
+        auth: z.literal("inherit"),
+        cache: z.literal("shared").optional(),
+        destination: z.string().min(1).optional(),
+        status: z.number().int().min(200).max(599).optional(),
+    })),
+});
 // What the version's conventions and config compiled TO. The counts are the
 // control plane's version-row projection; `proxy_rules` is what it overlays the
 // publishing team's plan onto, because the compiled artifact never bakes a plan
@@ -554,11 +580,9 @@ export const runtimeCompiledRoutingSchema = z.object({
         .default([]),
 });
 // What one finalize RUN cost, stage by stage, straight off the native
-// finalizer's envelope — which is why these keys are camelCase while the rest of
-// this receipt is not: PHP passes the object through rather than restating it.
-// Everything else here is read back from the version's immutable metadata;
-// timings cannot be, because they differ on every run. `skippedFiles` is the
-// incrementality gauge: it stays 0 while every finalize rebuilds everything.
+// finalizer's envelope, which is why these keys are camelCase while the rest of
+// this receipt is not. `skippedFiles` is the incrementality gauge: it stays 0
+// while every finalize rebuilds everything.
 export const runtimeFinalizeTelemetrySchema = z.object({
     stagedFiles: z.number().int().nonnegative(),
     generatedFiles: z.number().int().nonnegative(),
@@ -583,11 +607,13 @@ export const runtimeVersionFinalizeResponseSchema = z.object({
     version_id: z.string(),
     status: z.literal("ready"),
     zero_endpoint_count: z.number().int().nonnegative().optional(),
-    // The finalizer is the one conventions/config compiler, so what it compiled is
-    // reported back rather than recomputed: the control plane runs no second
-    // compile pass to learn its own version row.
+    // The finalizer is the one conventions/config compiler, so the control plane
+    // runs no second compile pass to learn its own version row.
     diagnostics: z.array(runtimeCompileDiagnosticSchema).default([]),
     routing: runtimeCompiledRoutingSchema.optional(),
+    // Versioned, finalizer-owned route declarations. Optional while runtimes
+    // finalized before the inventory ships remain replayable.
+    route_inventory: runtimeRouteInventorySchema.optional(),
     // Provenance for the substitution the finalizer performed: dependency name
     // (`NAME` or `NAME@channel`) -> SHA-256 of the value it resolved to. This is
     // what answers "does changing this variable require a republish?".
@@ -622,9 +648,10 @@ export const runtimeZeroMigrationsApplyResponseSchema = z.object({
 export const runtimeRouteUpdateRequestSchema = z.object({
     version_id: z.string().min(1),
     config: runtimeRouteConfigSchema.optional(),
-    // The engine stores this with the route pointer and no-ops the whole PUT — no
-    // policy store, no journal event, no edge purge — when version, digest, and
-    // hostname intent all match the stored route. Absent = always write.
+    // The engine stores this with the route pointer. When version, digest, and
+    // hostname intent all match the stored route, the engine no-ops the whole
+    // PUT: no policy store, no journal event, no edge purge. Absent = always
+    // write.
     config_digest: z.string().min(1).optional(),
     // No `changed_paths`: the runtime holds both catalogs and scopes the purge
     // from `previous_version_id` itself.
@@ -673,17 +700,6 @@ export const runtimeTombstonesUpdateResponseSchema = z.object({
     tombstone_count: z.number().int().nonnegative(),
     ...runtimeMutationPurgeFields,
 });
-// The control plane computes prunable version ids; the engine stores the list
-// and its housekeeping tick prunes trees after re-checking live route pointers.
-// An empty list clears the policy.
-export const runtimeRetentionPolicyUpdateRequestSchema = z.object({
-    prunable_version_ids: z.array(z.string()),
-});
-export const runtimeRetentionPolicyUpdateResponseSchema = z.object({
-    space_id: z.string(),
-    prunable_count: z.number().int().nonnegative(),
-    ...runtimeMutationPurgeFields,
-});
 export const runtimeVersionDeleteResponseSchema = z.object({
     space_id: z.string(),
     version_id: z.string(),
@@ -758,7 +774,7 @@ export const runtimeZeroDbImportResponseSchema = z.object({
 });
 // Per-space generation state reported by the authed state endpoint. The
 // reconciliation sweep compares it against control-plane expectations and
-// repairs targeted mismatches — never a blanket re-sync.
+// repairs targeted mismatches, never a blanket re-sync.
 export const runtimeSpaceStateSchema = z.object({
     space_id: z.string().min(1).describe("Space whose runtime route pointers follow."),
     routes: z
@@ -832,6 +848,10 @@ export const runtimeCallbackEventSchema = z.looseObject({
         .describe("Runtime management action authorized for the operation."),
     space_id: z.string().optional().describe("Space the event applies to, when space-scoped."),
     version_id: z.string().optional().describe("Version the event applies to, when version-scoped."),
+    version_ids: z
+        .array(z.string().min(1))
+        .optional()
+        .describe("Exact versions covered by a completed space-scoped runtime operation."),
     route_name: z.string().optional().describe("Route pointer the event updated, when route-scoped."),
     hostnames: z
         .array(z.string().min(1))
@@ -903,7 +923,7 @@ export const runtimeEventsDrainRequestSchema = z
 });
 export const runtimeEventsDrainResponseSchema = z.object({
     // Cursor runtimes keep these at zero. Older engines report their legacy
-    // delivery counters here while a rolling bundle update is still converging.
+    // delivery counters here while a rolling bundle update is still syncing.
     delivered_count: z.number().int().nonnegative(),
     failed_count: z.number().int().nonnegative(),
     expired_count: z.number().int().nonnegative().optional(),
@@ -979,7 +999,7 @@ export const runtimeEngineJobRecordSchema = z.object({
 export const runtimeEngineJobCreateRequestSchema = z.object({
     type: z.string().min(1),
     payload: z.record(z.string(), z.unknown()).default({}),
-    // Unique per (type, space, operation) — create is upsert-by-key.
+    // Unique per (type, space, operation). Create is upsert-by-key.
     idempotency_key: z.string().min(1),
 });
 export const runtimeEngineJobResponseSchema = z.object({

package/dist/contracts/runtime-app.d.ts

@@ -1,20 +1,13 @@
 import { z } from "zod";
 /**
- * The one answer to "what is running on this space".
+ * What is running on this space.
  *
- * One published tree can carry static files, a worker and a capsule at once —
- * every space owns a site, so what answers a request is a routing decision, not
- * a kind the space declared. This is therefore two independent members rather
- * than a discriminated union: each is `null` when the live tree carries none of
- * that product, and both `null` is the overwhelmingly common answer. A static
- * space is not a degenerate app, it is the absence of one.
+ * A published tree can carry a worker and a capsule at once, so these are two
+ * independent nullable members rather than a discriminated union. Each is
+ * `null` when the live tree carries none of that product.
  *
- * When both are present the capsule wins a path conflict — it is the one that
- * owns the space's database and its transaction.
- *
- * It lives in its own module because it is the only place that needs to know
- * about both products at once. `spaces.ts` imports it to describe runtime
- * status; neither `zero.ts` nor `functions.ts` has to learn about the other.
+ * When both are present the capsule wins a path conflict: it owns the space's
+ * database and its transaction.
  */
 export declare const runtimeAppSchema: z.ZodObject<{
     capsule: z.ZodNullable<z.ZodObject<{
@@ -72,6 +65,8 @@ export declare const runtimeAppSchema: 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<{
@@ -126,6 +121,7 @@ export declare const runtimeAppSchema: 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>>;
         executionState: z.ZodEnum<{
             ready: "ready";
@@ -141,14 +137,7 @@ export declare const runtimeAppSchema: z.ZodObject<{
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export type RuntimeApp = z.infer<typeof runtimeAppSchema>;
-/**
- * Replay of the invalidation events a live runtime emitted.
- *
- * The event shape itself is Zero's — it names mutations, changed tables and
- * changed queries, which only a capsule has — but the route that serves it is
- * the runtime family's, so the page contract lives here beside the rest of the
- * unified surface rather than inside one product.
- */
+/** Replay of the invalidation events a live runtime emitted, in Zero's event shape. */
 export declare const runtimeRealtimeEventListQuerySchema: z.ZodObject<{
     afterEventId: z.ZodOptional<z.ZodString>;
     limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
@@ -167,6 +156,7 @@ export declare const runtimeRealtimeEventListResponseSchema: z.ZodObject<{
         schemaHash: z.ZodString;
         committedAt: z.ZodString;
     }, z.core.$strict>>;
+    nextAfterEventId: z.ZodNullable<z.ZodString>;
     pagination: z.ZodObject<{
         nextCursor: z.ZodNullable<z.ZodString>;
         hasMore: z.ZodBoolean;