@spacefast/common 0.0.23 → 0.0.26

package/dist/contracts/usage.d.ts

@@ -0,0 +1,61 @@
+import { z } from "zod";
+/**
+ * Resolutions the hosting provider keeps usage at. Hour is retained about a
+ * week, day about two months, month about two years.
+ */
+export declare const USAGE_RESOLUTIONS: readonly ["hour", "day", "month"];
+export type UsageResolution = (typeof USAGE_RESOLUTIONS)[number];
+export declare const usageResolutionSchema: z.ZodEnum<{
+    day: "day";
+    hour: "hour";
+    month: "month";
+}>;
+export declare const spaceUsageMeasurementSchema: z.ZodObject<{
+    period: z.ZodObject<{
+        start: z.ZodString;
+        end: z.ZodString;
+        resolution: z.ZodEnum<{
+            day: "day";
+            hour: "hour";
+            month: "month";
+        }>;
+    }, z.core.$strip>;
+    sampledAt: z.ZodString;
+    storageBytes: z.ZodNumber;
+    computeSeconds: z.ZodNumber;
+    bandwidthBytes: z.ZodNumber;
+    emailCount: z.ZodNumber;
+    functionInvocations: z.ZodNumber;
+    functionErrors: z.ZodNumber;
+}, z.core.$strip>;
+export declare const spaceUsageResponseSchema: z.ZodObject<{
+    spaceId: z.ZodString;
+    usage: z.ZodNullable<z.ZodObject<{
+        period: z.ZodObject<{
+            start: z.ZodString;
+            end: z.ZodString;
+            resolution: z.ZodEnum<{
+                day: "day";
+                hour: "hour";
+                month: "month";
+            }>;
+        }, z.core.$strip>;
+        sampledAt: z.ZodString;
+        storageBytes: z.ZodNumber;
+        computeSeconds: z.ZodNumber;
+        bandwidthBytes: z.ZodNumber;
+        emailCount: z.ZodNumber;
+        functionInvocations: z.ZodNumber;
+        functionErrors: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SpaceUsageMeasurement = z.infer<typeof spaceUsageMeasurementSchema>;
+export type SpaceUsageResponse = z.infer<typeof spaceUsageResponseSchema>;
+export declare const functionUsagePushSchema: z.ZodObject<{
+    spaceId: z.ZodString;
+    versionId: z.ZodString;
+    invocations: z.ZodNumber;
+    errors: z.ZodNumber;
+    observedAt: z.ZodString;
+}, z.core.$strip>;
+export type FunctionUsagePush = z.infer<typeof functionUsagePushSchema>;

package/dist/contracts/usage.js

@@ -0,0 +1,64 @@
+import { z } from "zod";
+/**
+ * Resolutions the hosting provider keeps usage at. Hour is retained about a
+ * week, day about two months, month about two years.
+ */
+export const USAGE_RESOLUTIONS = ["hour", "day", "month"];
+export const usageResolutionSchema = z.enum(USAGE_RESOLUTIONS);
+// Served by `GET /v1/spaces/{spaceId}/usage`: what one Space actually consumed,
+// measured by the infrastructure that served it rather than derived from what
+// was published.
+//
+// Every number here is a MEASUREMENT OF A PAST PERIOD, not a live gauge, and the
+// contract says so out loud: `period` is the window measured and `sampledAt` is
+// when we last asked. Nothing in this response means "right now". The meter
+// behind it is a time series with real ingestion delay, so a reading is only
+// trusted once its period has settled — expect the period to end an hour or so
+// before you read it.
+export const spaceUsageMeasurementSchema = z.object({
+    period: z
+        .object({
+        start: z.string().describe("First instant of the measured period."),
+        end: z
+            .string()
+            .describe("Last instant of the measured period. The numbers are current as of here."),
+        resolution: usageResolutionSchema.describe("Length of the measured period."),
+    })
+        .describe("The window these numbers describe."),
+    sampledAt: z
+        .string()
+        .describe("When the platform last read this space's usage from the serving infrastructure."),
+    storageBytes: z
+        .number()
+        .describe("Average bytes of disk the space occupied during the period. This is what storage is billed on: bytes actually on disk, not the size of what was uploaded."),
+    computeSeconds: z.number().describe("Seconds of compute the space consumed during the period."),
+    bandwidthBytes: z.number().describe("Bytes the space served during the period."),
+    emailCount: z.number().int().describe("Emails the space sent during the period."),
+    functionInvocations: z
+        .number()
+        .int()
+        .describe("Function invocations during the period, counted where the space is known. Best-effort: counts are pushed after each request completes and may arrive late."),
+    functionErrors: z
+        .number()
+        .int()
+        .describe("Function invocations during the period that ended in an error."),
+});
+export const spaceUsageResponseSchema = z.object({
+    spaceId: z.string().describe("The space the usage was measured for."),
+    usage: spaceUsageMeasurementSchema
+        .nullable()
+        .describe("Null when this space has never been measured — a space that has not served yet, or one whose first measurement period has not settled."),
+});
+// Posted by the Functions host's tail Worker after an isolate finishes serving.
+// Counts only — never messages. Function LOGS travel a different path, into the
+// space's own log stream, and merging the two would quietly turn this into a
+// second log pipeline.
+export const functionUsagePushSchema = z.object({
+    spaceId: z.string().min(1).describe("The space whose functions ran."),
+    versionId: z.string().min(1).describe("The version whose bundle served the requests."),
+    invocations: z.number().int().nonnegative().describe("Requests the isolate served."),
+    errors: z.number().int().nonnegative().describe("Those requests that ended in an error."),
+    observedAt: z
+        .string()
+        .describe("The reporter's clock at delivery. The control plane buckets by hour on receipt."),
+});

package/dist/contracts/variables.d.ts

@@ -1,6 +1,5 @@
 import { z } from "zod";
 export declare const variableScope: z.ZodEnum<{
-    site: "site";
     space: "space";
     principal: "principal";
 }>;
@@ -8,7 +7,6 @@ export declare const variableNameSchema: z.ZodString;
 export declare const VariableSchema: z.ZodObject<{
     name: z.ZodString;
     scope: z.ZodEnum<{
-        site: "site";
         space: "space";
         principal: "principal";
     }>;
@@ -47,7 +45,6 @@ export declare const variableListResponseSchema: z.ZodObject<{
     data: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         scope: z.ZodEnum<{
-            site: "site";
             space: "space";
             principal: "principal";
         }>;
@@ -66,7 +63,6 @@ export declare const spaceVariableListResponseSchema: z.ZodObject<{
     data: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
         name: z.ZodString;
         scope: z.ZodEnum<{
-            site: "site";
             space: "space";
             principal: "principal";
         }>;
@@ -89,7 +85,6 @@ export declare const variableMutationResponseSchema: z.ZodObject<{
     data: z.ZodObject<{
         name: z.ZodString;
         scope: z.ZodEnum<{
-            site: "site";
             space: "space";
             principal: "principal";
         }>;
@@ -129,7 +124,7 @@ export declare const variableMutationResponseSchema: z.ZodObject<{
             path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
                 registrar: "registrar";
-                wpcloud: "wpcloud";
+                infra: "infra";
                 dns: "dns";
                 runtime: "runtime";
             }>>>;
@@ -173,7 +168,7 @@ export declare const variableDeleteResponseSchema: z.ZodObject<{
             path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
                 registrar: "registrar";
-                wpcloud: "wpcloud";
+                infra: "infra";
                 dns: "dns";
                 runtime: "runtime";
             }>>>;

package/dist/contracts/variables.js

@@ -1,10 +1,11 @@
 import { z } from "zod";
 import { AsyncOperationSchema, CursorPaginationSchema, cursorListQuerySchema } from "./common.js";
-// Variable (internal-docs/platform.md "Product Data Shapes"): one model for
-// every scope. Resolution order at finalize is space -> principal -> site.
-// Secret values are write-only after creation: never returned by API, CLI,
-// UI, diagnostics, logs, or activity.
-export const variableScope = z.enum(["space", "principal", "site"]);
+// Variable (the platform spec "Product Data Shapes"): one model for
+// every scope. Resolution order at finalize is space -> principal. A space IS
+// a site, so a space variable is the site variable — there is no third scope
+// underneath it. Secret values are write-only after creation: never returned
+// by API, CLI, UI, diagnostics, logs, or activity.
+export const variableScope = z.enum(["space", "principal"]);
 export const variableNameSchema = z
     .string()
     .min(1)
@@ -17,7 +18,7 @@ export const variableNameSchema = z
 });
 export const VariableSchema = z.object({
     name: variableNameSchema.describe("Variable name, referenced as {{ vars.NAME }} in templates."),
-    scope: variableScope.describe("Where the variable is defined; space wins over principal/site."),
+    scope: variableScope.describe("Where the variable is defined; space wins over principal."),
     secret: z.boolean().describe("Secret values are write-only and never returned after creation."),
     value: z.string().optional().describe("Variable value; omitted when secret=true."),
     channelValues: z
@@ -27,7 +28,7 @@ export const VariableSchema = z.object({
     createdAt: z.string().datetime().describe("Instant when the variable was created."),
     updatedAt: z.string().datetime().describe("Instant when the value was last written."),
 });
-// Version provenance (internal-docs/platform.md "Variable rules"): versions
+// Version provenance (the platform spec "Variable rules"): versions
 // record which variable names and value hashes they were finalized with —
 // never values. Stored only for internal cascade and synchronization; it is
 // never echoed on the public Version resource because historical rows cannot
@@ -66,7 +67,7 @@ export const spaceVariableListResponseSchema = z.object({
     pagination: CursorPaginationSchema,
 });
 // Variable mutations return the debounced cascade operation
-// (internal-docs/platform.md "Debounce contract"): every coalesced PUT/DELETE
+// (the platform spec "Debounce contract"): every coalesced PUT/DELETE
 // returns the same pending `op_` id, so "mutation returns `operation`" holds.
 export const variableMutationResponseSchema = z.object({
     data: VariableSchema,

package/dist/contracts/webhooks.d.ts

@@ -101,7 +101,7 @@ export declare const webhookDeliverySchema: z.ZodObject<{
         path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
             registrar: "registrar";
-            wpcloud: "wpcloud";
+            infra: "infra";
             dns: "dns";
             runtime: "runtime";
         }>>>;
@@ -142,7 +142,7 @@ export declare const webhookDeliveryListResponseSchema: z.ZodObject<{
             path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
                 registrar: "registrar";
-                wpcloud: "wpcloud";
+                infra: "infra";
                 dns: "dns";
                 runtime: "runtime";
             }>>>;

package/dist/contracts/zero.d.ts

@@ -12,6 +12,13 @@ import { type RuntimeRealtimeMode } from "./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.
+ */
 export declare const ZERO_RUNTIME_KIND = "zero";
 export declare const ZERO_PLATFORM_ROUTE_PREFIX = "/__spacefast/zero";
 /**
@@ -35,11 +42,57 @@ export declare const ZERO_RUNTIME_STORAGE_ROOT = "__spacefast/zero";
 export declare const ZERO_RUNTIME_ARTIFACT_PATH = "__spacefast/zero/artifact.json";
 export declare const ZERO_RUNTIME_CONFIG_PATH = "__spacefast/zero/config.json";
 export declare const ZERO_RUNTIME_BINARY_PATH = "__spacefast/zero/bin/stattic-runtime";
-export declare const ZERO_RUNTIME_BINARY_COMPATIBILITY_TARGET = "wpcloud-linux-x86_64-gnu-v1";
+export declare const ZERO_RUNTIME_BINARY_COMPATIBILITY_TARGET = "linux-x86_64-gnu-v1";
 export declare const ZERO_RUNTIME_BUNDLE_ROOT = "__spacefast/zero/bundles";
-export declare const ZERO_RUNTIME_CLIENT_BUNDLE_PATH = "__spacefast/zero/bundles/client.js";
 export declare const ZERO_RUNTIME_SERVER_BUNDLE_PATH = "__spacefast/zero/bundles/server.qjs.mjs";
-export declare const ZERO_RUNTIME_BUNDLE_MAX_BYTES = 786432;
+/** The compiled capsule client, served at the app root. */
+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.
+ *
+ * Underscore-prefixed by framework convention (`_next/static`, `_astro`), which
+ * 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";
+export declare const ZERO_PLATFORM_ASSET_ROOT = "_spacefast/platform";
+/** The serving path of one file in the platform build identified by `digest`. */
+export declare function zeroPlatformAssetPath(digest: string, fileName: string): 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.
+ */
+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
+ * 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.
+ *
+ * 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.
+ */
+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
@@ -58,7 +111,7 @@ export declare const ZERO_MANAGED_TABLE_COLUMNS: readonly ["id", "createdAt", "u
  * router and auth flow already do.
  */
 export declare const ZERO_RESERVED_APP_ROUTE_PATHS: readonly ["/", "/index.html", "/client.js", "/auth/callback"];
-export declare const ZERO_RESERVED_APP_ROUTE_PREFIXES: readonly ["/auth/"];
+export declare const ZERO_RESERVED_APP_ROUTE_PREFIXES: readonly ["/auth/", "/_spacefast/"];
 export declare const zeroEndpointSchema: z.ZodObject<{
     method: z.ZodEnum<{
         POST: "POST";
@@ -89,7 +142,6 @@ export declare const zeroTableIndexSchema: z.ZodObject<{
     name: z.ZodString;
     fields: z.ZodArray<z.ZodString>;
 }, z.core.$strict>;
-export type ZeroTableIndex = z.infer<typeof zeroTableIndexSchema>;
 export declare const zeroTableSchema: z.ZodObject<{
     name: z.ZodString;
     columns: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -129,10 +181,12 @@ export declare const zeroDatabaseSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
 }, z.core.$strict>>;
 export type ZeroDatabase = z.infer<typeof zeroDatabaseSchema>;
 /**
- * Zero's bundles travel inline in the finalize payload — a capsule's compiled
- * client and server fit comfortably under the ceiling, and inlining keeps the
+ * 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 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.
  */
 export declare const zeroRuntimeBundleSchema: z.ZodObject<{
     path: z.ZodString;
@@ -160,6 +214,9 @@ export declare const zeroRuntimeRunSourceSchema: z.ZodObject<{
         env: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
         realtime: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
         logging: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        gravatar: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        spam: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        email: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
     }, z.core.$strip>>;
     db: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strict>;
@@ -185,6 +242,9 @@ export declare const zeroRuntimeEndpointSourceSchema: z.ZodObject<{
         env: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
         realtime: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
         logging: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        gravatar: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        spam: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        email: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
     }, z.core.$strip>>;
     db: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strict>;
@@ -299,8 +359,8 @@ export declare const zeroMigrationPlanSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type ZeroMigrationPlan = z.infer<typeof zeroMigrationPlanSchema>;
 export declare const zeroInspectPolicySchema: z.ZodEnum<{
-    public: "public";
     private: "private";
+    public: "public";
 }>;
 export declare const zeroRuntimePublicAuthConfigSchema: z.ZodObject<{
     provider: z.ZodDefault<z.ZodLiteral<"gravatar">>;
@@ -328,7 +388,6 @@ export declare const zeroRuntimePublicRealtimeConfigSchema: z.ZodObject<{
     spaceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     versionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.core.$strict>;
-export type ZeroRuntimePublicRealtimeConfig = z.infer<typeof zeroRuntimePublicRealtimeConfigSchema>;
 export declare const zeroRuntimeClientConfigSchema: z.ZodObject<{
     runtimeKind: z.ZodLiteral<"zero">;
     basePath: z.ZodOptional<z.ZodString>;
@@ -369,7 +428,7 @@ export declare const zeroRuntimeInstallProfileSchema: z.ZodObject<{
     binary: z.ZodObject<{
         path: z.ZodLiteral<"__spacefast/zero/bin/stattic-runtime">;
         compatibilityTarget: z.ZodObject<{
-            profile: z.ZodLiteral<"wpcloud-linux-x86_64-gnu-v1">;
+            profile: z.ZodLiteral<"linux-x86_64-gnu-v1">;
             os: z.ZodLiteral<"linux">;
             cpu: z.ZodLiteral<"x86_64">;
             libc: z.ZodLiteral<"glibc">;
@@ -473,7 +532,7 @@ export declare const zeroCapsuleArtifactSchema: z.ZodObject<{
         sockets: z.ZodDefault<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>;
     db: z.ZodObject<{
-        backend: z.ZodLiteral<"wpcloud-mysql">;
+        backend: z.ZodLiteral<"mysql">;
         migrations: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
             op: z.ZodLiteral<"create_table">;
             table: z.ZodString;
@@ -570,7 +629,7 @@ export declare const zeroRuntimeFinalizePayloadSchema: z.ZodObject<{
         binary: z.ZodObject<{
             path: z.ZodLiteral<"__spacefast/zero/bin/stattic-runtime">;
             compatibilityTarget: z.ZodObject<{
-                profile: z.ZodLiteral<"wpcloud-linux-x86_64-gnu-v1">;
+                profile: z.ZodLiteral<"linux-x86_64-gnu-v1">;
                 os: z.ZodLiteral<"linux">;
                 cpu: z.ZodLiteral<"x86_64">;
                 libc: z.ZodLiteral<"glibc">;
@@ -635,7 +694,7 @@ export declare const zeroRuntimeFinalizePayloadSchema: z.ZodObject<{
             sockets: z.ZodDefault<z.ZodArray<z.ZodString>>;
         }, z.core.$strict>;
         db: z.ZodObject<{
-            backend: z.ZodLiteral<"wpcloud-mysql">;
+            backend: z.ZodLiteral<"mysql">;
             migrations: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                 op: z.ZodLiteral<"create_table">;
                 table: z.ZodString;
@@ -754,6 +813,9 @@ export declare const zeroRuntimeFinalizePayloadSchema: z.ZodObject<{
             env: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
             realtime: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
             logging: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            gravatar: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            spam: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            email: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
         }, z.core.$strip>>;
         db: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strict>>>;
@@ -768,6 +830,9 @@ export declare const zeroRuntimeFinalizePayloadSchema: z.ZodObject<{
             env: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
             realtime: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
             logging: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            gravatar: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            spam: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            email: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
         }, z.core.$strip>>;
         db: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strict>>>;
@@ -857,8 +922,8 @@ export declare const zeroRuntimeFinalizePayloadSchema: z.ZodObject<{
     }, z.core.$strict>>;
     inspect: z.ZodDefault<z.ZodObject<{
         policy: z.ZodDefault<z.ZodEnum<{
-            public: "public";
             private: "private";
+            public: "public";
         }>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
@@ -872,6 +937,10 @@ 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";
@@ -886,10 +955,6 @@ export declare const zeroRuntimeConfigSchema: z.ZodObject<{
             token: z.ZodString;
         }, z.core.$strict>>;
     }, z.core.$strict>;
-    variables: z.ZodObject<{
-        source: z.ZodLiteral<"stattic-variables">;
-        names: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>;
     artifact: z.ZodObject<{
         format: z.ZodLiteral<"stattic.zero.capsule.v1">;
         appName: z.ZodString;
@@ -936,7 +1001,7 @@ export declare const zeroRuntimeConfigSchema: z.ZodObject<{
             sockets: z.ZodDefault<z.ZodArray<z.ZodString>>;
         }, z.core.$strict>;
         db: z.ZodObject<{
-            backend: z.ZodLiteral<"wpcloud-mysql">;
+            backend: z.ZodLiteral<"mysql">;
             migrations: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                 op: z.ZodLiteral<"create_table">;
                 table: z.ZodString;
@@ -1089,7 +1154,7 @@ export declare const zeroRuntimeConfigSchema: z.ZodObject<{
         binary: z.ZodObject<{
             path: z.ZodLiteral<"__spacefast/zero/bin/stattic-runtime">;
             compatibilityTarget: z.ZodObject<{
-                profile: z.ZodLiteral<"wpcloud-linux-x86_64-gnu-v1">;
+                profile: z.ZodLiteral<"linux-x86_64-gnu-v1">;
                 os: z.ZodLiteral<"linux">;
                 cpu: z.ZodLiteral<"x86_64">;
                 libc: z.ZodLiteral<"glibc">;
@@ -1110,8 +1175,8 @@ export declare const zeroRuntimeConfigSchema: z.ZodObject<{
     }, z.core.$strict>;
     inspect: z.ZodDefault<z.ZodObject<{
         policy: z.ZodDefault<z.ZodEnum<{
-            public: "public";
             private: "private";
+            public: "public";
         }>>;
     }, z.core.$strict>>;
     variableValues: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -1134,7 +1199,7 @@ export declare const zeroDeployMetadataSchema: z.ZodObject<{
             binary: z.ZodObject<{
                 path: z.ZodLiteral<"__spacefast/zero/bin/stattic-runtime">;
                 compatibilityTarget: z.ZodObject<{
-                    profile: z.ZodLiteral<"wpcloud-linux-x86_64-gnu-v1">;
+                    profile: z.ZodLiteral<"linux-x86_64-gnu-v1">;
                     os: z.ZodLiteral<"linux">;
                     cpu: z.ZodLiteral<"x86_64">;
                     libc: z.ZodLiteral<"glibc">;
@@ -1199,7 +1264,7 @@ export declare const zeroDeployMetadataSchema: z.ZodObject<{
                 sockets: z.ZodDefault<z.ZodArray<z.ZodString>>;
             }, z.core.$strict>;
             db: z.ZodObject<{
-                backend: z.ZodLiteral<"wpcloud-mysql">;
+                backend: z.ZodLiteral<"mysql">;
                 migrations: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                     op: z.ZodLiteral<"create_table">;
                     table: z.ZodString;
@@ -1318,6 +1383,9 @@ export declare const zeroDeployMetadataSchema: z.ZodObject<{
                 env: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                 realtime: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                 logging: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+                gravatar: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+                spam: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+                email: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
             }, z.core.$strip>>;
             db: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strict>>>;
@@ -1332,6 +1400,9 @@ export declare const zeroDeployMetadataSchema: z.ZodObject<{
                 env: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                 realtime: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                 logging: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+                gravatar: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+                spam: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+                email: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
             }, z.core.$strip>>;
             db: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strict>>>;
@@ -1421,37 +1492,38 @@ export declare const zeroDeployMetadataSchema: z.ZodObject<{
         }, z.core.$strict>>;
         inspect: z.ZodDefault<z.ZodObject<{
             policy: z.ZodDefault<z.ZodEnum<{
-                public: "public";
                 private: "private";
+                public: "public";
             }>>;
         }, z.core.$strict>>;
     }, z.core.$strict>;
 }, z.core.$strict>;
 export type ZeroDeployMetadata = z.infer<typeof zeroDeployMetadataSchema>;
 /**
- * What a live Zero capsule is, as the `app` member of a space's runtime status.
+ * 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.
+ * than the publish that carries it. There is no kind tag either — the member it
+ * rides in already says which product answered.
  *
  * 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 `runtimeKind: "zero"` already said so.
+ * always owns one, so its presence already said so.
  */
 export declare const zeroAppSchema: z.ZodObject<{
-    runtimeKind: z.ZodLiteral<"zero">;
     artifactId: z.ZodString;
     appName: z.ZodString;
     serverRuntime: z.ZodLiteral<"quickjs-rust">;
     inspect: z.ZodObject<{
         policy: z.ZodEnum<{
-            public: "public";
             private: "private";
+            public: "public";
         }>;
     }, z.core.$strict>;
     install: z.ZodObject<{
@@ -1463,7 +1535,7 @@ export declare const zeroAppSchema: z.ZodObject<{
         binary: z.ZodObject<{
             path: z.ZodLiteral<"__spacefast/zero/bin/stattic-runtime">;
             compatibilityTarget: z.ZodObject<{
-                profile: z.ZodLiteral<"wpcloud-linux-x86_64-gnu-v1">;
+                profile: z.ZodLiteral<"linux-x86_64-gnu-v1">;
                 os: z.ZodLiteral<"linux">;
                 cpu: z.ZodLiteral<"x86_64">;
                 libc: z.ZodLiteral<"glibc">;
@@ -1525,49 +1597,6 @@ export declare const zeroAppSchema: z.ZodObject<{
     }, z.core.$strict>;
 }, z.core.$strict>;
 export type ZeroApp = z.infer<typeof zeroAppSchema>;
-export declare const zeroLogListQuerySchema: z.ZodObject<{
-    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-    cursor: z.ZodOptional<z.ZodString>;
-    requestId: z.ZodOptional<z.ZodString>;
-    handlerName: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export type ZeroLogListQuery = z.infer<typeof zeroLogListQuerySchema>;
-export declare const zeroLogEntrySchema: z.ZodObject<{
-    id: z.ZodString;
-    timestamp: z.ZodString;
-    level: z.ZodEnum<{
-        info: "info";
-        error: "error";
-        debug: "debug";
-        warn: "warn";
-    }>;
-    requestId: z.ZodNullable<z.ZodString>;
-    versionId: z.ZodNullable<z.ZodString>;
-    handlerName: z.ZodNullable<z.ZodString>;
-    message: z.ZodString;
-    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strict>;
-export declare const zeroLogListResponseSchema: z.ZodObject<{
-    data: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        timestamp: z.ZodString;
-        level: z.ZodEnum<{
-            info: "info";
-            error: "error";
-            debug: "debug";
-            warn: "warn";
-        }>;
-        requestId: z.ZodNullable<z.ZodString>;
-        versionId: z.ZodNullable<z.ZodString>;
-        handlerName: z.ZodNullable<z.ZodString>;
-        message: z.ZodString;
-        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strict>>;
-    pagination: z.ZodObject<{
-        nextCursor: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export type ZeroLogListResponse = z.infer<typeof zeroLogListResponseSchema>;
 export declare const zeroRealtimeEventIntakeResponseSchema: z.ZodObject<{
     accepted: z.ZodLiteral<true>;
     eventId: z.ZodString;