@spacefast/common 0.0.12 → 0.0.17

package/dist/contracts/zero.js

@@ -1,8 +1,24 @@
 import { z } from "zod";
-import { dataEnvelope } from "./common.js";
+import { appRoutePathSchema, EXECUTION_ENV_MAX_KEYS, executionBundleSchema, executionCapabilitiesSchema, executionEnvNameSchema, executionIdentifierSchema, executionInspectPolicySchema, executionLogEntrySchema, executionLogListQuerySchema, executionLogListResponseSchema, 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.
+ *
+ * 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.
+ */
 export const ZERO_SOURCE_METADATA_KEY = "statticZero";
 export const ZERO_RUNTIME_KIND = "zero";
-export const ZERO_PLATFORM_ROUTE_PREFIX = "/__spacefast/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.
+ */
 export const ZERO_CLIENT_ENTRY = "client/index.tsx";
 export const ZERO_SERVER_ENTRY = "server/index.ts";
 export const ZERO_RUNTIME_ROUTE_PATHS = {
@@ -12,125 +28,51 @@ export const ZERO_RUNTIME_ROUTE_PATHS = {
     db: `${ZERO_PLATFORM_ROUTE_PREFIX}/db`,
     logs: `${ZERO_PLATFORM_ROUTE_PREFIX}/logs`,
     run: `${ZERO_PLATFORM_ROUTE_PREFIX}/run`,
-    authStart: `${ZERO_PLATFORM_ROUTE_PREFIX}/auth/wpcom/start`,
+    authStart: `${ZERO_PLATFORM_ROUTE_PREFIX}/auth/gravatar/start`,
     authSignOut: `${ZERO_PLATFORM_ROUTE_PREFIX}/auth/sign-out`,
 };
 export const ZERO_RUNTIME_STORAGE_ROOT = "__spacefast/zero";
 export const ZERO_RUNTIME_ARTIFACT_PATH = `${ZERO_RUNTIME_STORAGE_ROOT}/artifact.json`;
 export const ZERO_RUNTIME_CONFIG_PATH = `${ZERO_RUNTIME_STORAGE_ROOT}/config.json`;
-export const ZERO_RUNTIME_BINARY_PATH = `${ZERO_RUNTIME_STORAGE_ROOT}/bin/stattic-zero-runner`;
+export const ZERO_RUNTIME_BINARY_PATH = `${ZERO_RUNTIME_STORAGE_ROOT}/bin/stattic-runtime`;
 export const ZERO_RUNTIME_BINARY_COMPATIBILITY_TARGET = "wpcloud-linux-x86_64-gnu-v1";
 export const ZERO_RUNTIME_BUNDLE_ROOT = `${ZERO_RUNTIME_STORAGE_ROOT}/bundles`;
 export const ZERO_RUNTIME_CLIENT_BUNDLE_PATH = `${ZERO_RUNTIME_BUNDLE_ROOT}/client.js`;
 export const ZERO_RUNTIME_SERVER_BUNDLE_PATH = `${ZERO_RUNTIME_BUNDLE_ROOT}/server.qjs.mjs`;
-export const ZERO_SOURCE_ENV_FILE = ".env.zero.server";
-export const ZERO_CONFIG_FILE = "zero.json";
-export const ZERO_DEPLOY_FILE = ".zero/deploy.json";
 export const ZERO_RUNTIME_BUNDLE_MAX_BYTES = 786_432;
-export const ZERO_ENV_MAX_KEYS = 64;
-export const ZERO_ENV_NAME_MAX_BYTES = 128;
-export const ZERO_ENV_VALUE_MAX_BYTES = 16 * 1024;
-export const ZERO_ENV_TOTAL_VALUE_MAX_BYTES = 64 * 1024;
-export const ZERO_ENV_RESERVED_PREFIXES = ["SPACEFAST_", "ZERO_"];
+/**
+ * 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.
+ */
+export const ZERO_RUNTIME_DEPLOY_PATH = `${ZERO_RUNTIME_STORAGE_ROOT}/deploy.json`;
 export const ZERO_MANAGED_TABLE_COLUMNS = ["id", "createdAt", "updatedAt"];
+/**
+ * Paths the Zero app shell itself answers, on top of the platform-reserved set
+ * in `./execution.js`. A capsule cannot claim these because its own client
+ * router and auth flow already do.
+ */
 export const ZERO_RESERVED_APP_ROUTE_PATHS = [
     "/",
     "/index.html",
     "/client.js",
     "/auth/callback",
-    "/__spacefast",
-    "/__span",
 ];
-export const ZERO_RESERVED_APP_ROUTE_PREFIXES = ["/auth/", "/__spacefast/", "/__span/"];
-export const zeroRuntimeKindSchema = z.enum(["static", "zero", "php", "node", "workers"]);
-const zeroNameSchema = z
-    .string()
-    .min(1)
-    .max(128)
-    .regex(/^[A-Za-z_][A-Za-z0-9_]*$/);
-const zeroEnvNameSchema = z
-    .string()
-    .min(1)
-    .max(ZERO_ENV_NAME_MAX_BYTES)
-    .regex(/^[A-Za-z_][A-Za-z0-9_]*$/)
-    .refine((name) => !ZERO_ENV_RESERVED_PREFIXES.some((prefix) => name.toUpperCase().startsWith(prefix)), { message: "Zero env variable name uses a reserved prefix." });
-function hasWellFormedUnicode(value) {
-    for (let index = 0; index < value.length; index++) {
-        const codeUnit = value.charCodeAt(index);
-        if (codeUnit >= 0xd800 && codeUnit <= 0xdbff) {
-            if (index + 1 >= value.length)
-                return false;
-            const next = value.charCodeAt(index + 1);
-            if (next < 0xdc00 || next > 0xdfff)
-                return false;
-            index++;
-        }
-        else if (codeUnit >= 0xdc00 && codeUnit <= 0xdfff) {
-            return false;
-        }
-    }
-    return true;
-}
-function hasNoAsciiControlCharacters(value) {
-    for (let index = 0; index < value.length; index++) {
-        const codeUnit = value.charCodeAt(index);
-        if (codeUnit <= 0x1f || codeUnit === 0x7f)
-            return false;
-    }
-    return true;
-}
-const zeroRoutePathSchema = z
-    .string()
-    .min(1)
-    .max(2048)
-    .startsWith("/")
-    .refine(hasWellFormedUnicode, {
-    message: "Zero capsule routes must contain well-formed Unicode.",
-})
-    .refine((path) => path.normalize("NFC") === path, {
-    message: "Zero capsule routes must use NFC-normalized Unicode.",
-})
-    .refine(hasNoAsciiControlCharacters, {
-    message: "Zero capsule routes must not contain ASCII control characters.",
-})
-    .refine((path) => !path.includes("//") &&
-    !path.includes("\\") &&
-    !path.includes("*") &&
-    !path.includes("?") &&
-    !path.includes("#") &&
-    !path.endsWith("/") &&
-    path
-        .split("/")
-        .every((segment, index, segments) => segment !== "." &&
-        segment !== ".." &&
-        segment !== ":" &&
-        (segment !== ":splat" || index === segments.length - 1)), {
-    message: "Zero capsule routes must be absolute app paths without empty, traversal, unnamed parameter, * wildcard, non-terminal splat, \\, ?, or # segments.",
-})
-    .refine((path) => !ZERO_RESERVED_APP_ROUTE_PATHS.some((reservedPath) => path === reservedPath), {
-    message: "Zero capsule route is reserved by the Zero app shell.",
-})
-    .refine((path) => !ZERO_RESERVED_APP_ROUTE_PREFIXES.some((reservedPrefix) => path.startsWith(reservedPrefix)), {
-    message: "Zero capsule route prefix is reserved by the Zero app shell.",
-})
-    .refine((path) => !path.startsWith(ZERO_PLATFORM_ROUTE_PREFIX), {
-    message: `Zero capsule routes cannot use ${ZERO_PLATFORM_ROUTE_PREFIX}.`,
-})
-    .refine((path) => path !== "/__stattic" && !path.startsWith("/__stattic/"), {
-    message: "Zero capsule routes cannot use Spacefast private control paths.",
+export const ZERO_RESERVED_APP_ROUTE_PREFIXES = ["/auth/"];
+const zeroNameSchema = executionIdentifierSchema;
+const zeroRoutePathSchema = appRoutePathSchema({
+    subject: "Zero capsule routes",
+    reservedPaths: ZERO_RESERVED_APP_ROUTE_PATHS,
+    reservedPrefixes: ZERO_RESERVED_APP_ROUTE_PREFIXES,
 });
-export const zeroHttpMethodSchema = z.enum([
-    "GET",
-    "HEAD",
-    "POST",
-    "PUT",
-    "PATCH",
-    "DELETE",
-    "OPTIONS",
-]);
 export const zeroEndpointSchema = z
     .object({
-    method: zeroHttpMethodSchema,
+    method: httpMethodSchema,
     path: zeroRoutePathSchema,
 })
     .strict();
@@ -220,53 +162,60 @@ export const zeroTableColumnSchema = z
 })
     .strict()
     .superRefine(zeroDefaultMatchesColumnType);
+export const zeroTableIndexSchema = z
+    .object({
+    name: zeroNameSchema.refine((name) => name !== "by_creation", {
+        message: "by_creation is a built-in Zero index.",
+    }),
+    fields: z.array(zeroNameSchema).min(1),
+})
+    .strict();
 export const zeroTableSchema = z
     .object({
     name: zeroNameSchema,
     columns: z.array(zeroTableColumnSchema).default([]),
+    indexes: z.array(zeroTableIndexSchema).default([]),
 })
-    .strict();
+    .strict()
+    .superRefine((table, context) => {
+    const columnNames = new Set(table.columns.map((column) => column.name));
+    const indexNames = new Set();
+    for (const index of table.indexes) {
+        if (indexNames.has(index.name)) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `Zero table ${table.name} declares duplicate index ${index.name}.`,
+                path: ["indexes"],
+            });
+        }
+        indexNames.add(index.name);
+        for (const field of index.fields) {
+            if (!columnNames.has(field)) {
+                context.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: `Zero index ${table.name}.${index.name} references unknown field ${field}.`,
+                    path: ["indexes"],
+                });
+            }
+        }
+    }
+});
 export const zeroDatabaseSchema = z.record(z.string(), zeroTableSchema);
-const zeroSha256Schema = z.string().regex(/^sha256:[a-f0-9]{64}$/);
-const zeroBase64Schema = z
-    .string()
-    .regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/);
-export const zeroRuntimeBundleSchema = z
-    .object({
-    path: z
-        .string()
-        .min(1)
-        .startsWith(`${ZERO_RUNTIME_BUNDLE_ROOT}/`)
-        .refine((bundlePath) => !bundlePath.split("/").includes(".."), {
-        message: "Zero bundle paths cannot traverse outside the runtime bundle root.",
-    }),
-    sha256: zeroSha256Schema,
-    size: z.number().int().nonnegative().max(ZERO_RUNTIME_BUNDLE_MAX_BYTES),
-    contentBase64: zeroBase64Schema,
-})
-    .strict();
-const zeroPublicStaticPathSchema = z
-    .string()
-    .min(1)
-    .max(2048)
-    .refine((path) => !path.startsWith("/") && !path.split("/").includes(".."), {
-    message: "Zero static file paths must be relative and cannot traverse.",
-})
-    .refine((path) => !path.startsWith(ZERO_RUNTIME_STORAGE_ROOT + "/"), {
-    message: `Zero static files cannot use ${ZERO_RUNTIME_STORAGE_ROOT}.`,
-})
-    .refine((path) => !path.startsWith("_") && !path.startsWith("."), {
-    message: "Zero static file paths cannot use private root prefixes.",
+const zeroSha256Schema = executionSha256Schema;
+/**
+ * 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
+ * whole version one atomic write. Functions bundles do the opposite and land
+ * in the content store first; see `functionsBundleRefSchema`.
+ */
+export const zeroRuntimeBundleSchema = executionBundleSchema({
+    bundleRoot: ZERO_RUNTIME_BUNDLE_ROOT,
+    maxBytes: ZERO_RUNTIME_BUNDLE_MAX_BYTES,
+});
+export const zeroRuntimeStaticFileSchema = executionStaticFileSchema({
+    storageRoot: ZERO_RUNTIME_STORAGE_ROOT,
+    maxBytes: ZERO_RUNTIME_BUNDLE_MAX_BYTES,
 });
-export const zeroRuntimeStaticFileSchema = z
-    .object({
-    path: zeroPublicStaticPathSchema,
-    contentType: z.string().min(1).max(255),
-    sha256: zeroSha256Schema,
-    size: z.number().int().nonnegative().max(ZERO_RUNTIME_BUNDLE_MAX_BYTES),
-    contentBase64: zeroBase64Schema,
-})
-    .strict();
 export const zeroRuntimeRunSourceSchema = z
     .object({
     runId: z.string().min(1).max(256),
@@ -275,23 +224,13 @@ export const zeroRuntimeRunSourceSchema = z
         .min(1)
         .max(2 * 1024 * 1024),
     schemaHash: z.string().min(1).max(256).optional(),
-    capabilities: z
-        .object({
-        db: z.boolean().default(false),
-        fetch: z.boolean().default(false),
-        auth: z.boolean().default(false),
-        env: z.boolean().default(false),
-        realtime: z.boolean().default(false),
-        logging: z.boolean().default(false),
-    })
-        .partial()
-        .default({}),
+    capabilities: executionCapabilitiesSchema,
     db: z.record(z.string(), z.unknown()).optional(),
 })
     .strict();
 export const zeroRuntimeEndpointSourceSchema = z
     .object({
-    method: zeroHttpMethodSchema,
+    method: httpMethodSchema,
     path: zeroRoutePathSchema,
     endpointId: z.string().min(1).max(256),
     source: z
@@ -321,10 +260,19 @@ export const zeroMigrationOperationSchema = z.discriminatedUnion("op", [
         .object({
         op: z.literal("add_index"),
         table: zeroNameSchema,
+        name: zeroNameSchema,
         columns: z.array(zeroNameSchema).min(1),
         unique: z.boolean().default(false),
     })
         .strict(),
+    z
+        .object({
+        op: z.literal("drop_index"),
+        table: zeroNameSchema,
+        name: zeroNameSchema,
+        explicit: z.literal("drop"),
+    })
+        .strict(),
     z
         .object({
         op: z.literal("drop_table"),
@@ -366,16 +314,7 @@ export const zeroMigrationPlanSchema = z
     operations: z.array(zeroMigrationOperationSchema),
 })
     .strict();
-const zeroRealtimeCanonicalModeSchema = z.enum(["stattic-central", "spacefast-cast", "local-dev"]);
-const zeroRuntimePublicRealtimeCanonicalModeSchema = z.enum([
-    "stattic-central",
-    "spacefast-cast",
-    "local-dev",
-    "local-websocket",
-]);
-export const zeroRealtimeModeSchema = zeroRealtimeCanonicalModeSchema;
-export const zeroRuntimePublicRealtimeModeSchema = zeroRuntimePublicRealtimeCanonicalModeSchema;
-export const zeroInspectPolicySchema = z.enum(["private", "public"]);
+export const zeroInspectPolicySchema = executionInspectPolicySchema;
 const zeroRuntimePublicPathSchema = z.string().min(1).startsWith("/");
 const zeroHttpUrlSchema = z
     .string()
@@ -393,7 +332,7 @@ const zeroRealtimeUrlSchema = z
 }, { message: "Realtime URL must use http, https, ws, or wss." });
 export const zeroRuntimePublicAuthConfigSchema = z
     .object({
-    provider: z.literal("wpcom").default("wpcom"),
+    provider: z.literal("gravatar").default("gravatar"),
     signInPath: zeroRuntimePublicPathSchema.nullable().default(null),
     signInUrl: zeroHttpUrlSchema.nullable().default(null),
     signOutPath: zeroRuntimePublicPathSchema.nullable().default(null),
@@ -403,7 +342,7 @@ export const zeroRuntimePublicAuthConfigSchema = z
     .strict();
 export const zeroRuntimePublicRealtimeConfigSchema = z
     .object({
-    mode: zeroRuntimePublicRealtimeModeSchema,
+    mode: runtimeRealtimeModeSchema,
     centralUrl: zeroRealtimeUrlSchema.nullable().default(null),
     path: zeroRuntimePublicPathSchema.optional(),
     replayPath: zeroRuntimePublicPathSchema.nullable().optional(),
@@ -411,6 +350,7 @@ export const zeroRuntimePublicRealtimeConfigSchema = z
     runPath: zeroRuntimePublicPathSchema.nullable().optional(),
     runUrl: zeroHttpUrlSchema.nullable().optional(),
     resourceKey: z.string().min(1).max(256).nullable().optional(),
+    ticketPath: zeroRuntimePublicPathSchema.nullable().optional(),
     socketPath: zeroRuntimePublicPathSchema.nullable().optional(),
     spaceId: z.string().min(1).nullable().optional(),
     versionId: z.string().min(1).nullable().optional(),
@@ -460,7 +400,7 @@ export const zeroRuntimeInstallProfileSchema = z
         .strict(),
     realtime: z
         .object({
-        production: z.literal("stattic-central"),
+        production: z.literal("central"),
         local: z.literal("foreground-cli-ws"),
     })
         .strict(),
@@ -489,42 +429,23 @@ export const zeroSourceFileSchema = z
     .strict();
 export const zeroSourceManifestSchema = z
     .object({
+    // Declared in `sf.jsonc#runtime`, so the manifest records what the author
+    // named rather than a layout the builder assumed.
     entries: z
         .object({
-        client: z.literal(ZERO_CLIENT_ENTRY),
-        server: z.literal(ZERO_SERVER_ENTRY),
+        client: z.string().min(1),
+        server: z.string().min(1),
     })
         .strict(),
     sourceRoot: z.string().min(1),
     files: z.array(zeroSourceFileSchema).default([]),
     env: z
         .object({
-        file: z.literal(ZERO_SOURCE_ENV_FILE),
-        names: z.array(zeroEnvNameSchema).max(ZERO_ENV_MAX_KEYS).default([]),
+        file: z.enum([SERVER_ENV_FILE, LAKEBED_SERVER_ENV_FILE]),
+        names: z.array(executionEnvNameSchema).max(EXECUTION_ENV_MAX_KEYS).default([]),
     })
         .nullable()
         .default(null),
-    sourceConfig: z
-        .object({
-        configFile: z
-            .object({
-            path: z.literal(ZERO_CONFIG_FILE),
-            appName: z.string().nullable().default(null),
-            deployId: z.string().nullable().default(null),
-            name: z.string().nullable().default(null),
-            title: z.string().nullable().default(null),
-        })
-            .nullable()
-            .default(null),
-        deployFile: z
-            .object({
-            path: z.literal(ZERO_DEPLOY_FILE),
-            keys: z.array(z.string()).default([]),
-        })
-            .nullable()
-            .default(null),
-    })
-        .default({ configFile: null, deployFile: null }),
 })
     .strict();
 export const zeroCapsuleArtifactSchema = z
@@ -544,6 +465,7 @@ export const zeroCapsuleArtifactSchema = z
         schema: zeroDatabaseSchema.default({}),
         queries: z.array(zeroNameSchema).default([]),
         mutations: z.array(zeroNameSchema).default([]),
+        actions: z.array(zeroNameSchema).default([]),
         endpoints: z.array(zeroEndpointSchema).default([]),
         sockets: z.array(zeroNameSchema).default([]),
     })
@@ -556,7 +478,7 @@ export const zeroCapsuleArtifactSchema = z
         .strict(),
     realtime: z
         .object({
-        mode: zeroRealtimeModeSchema,
+        mode: runtimeRealtimeModeSchema,
         mutationEvents: z.boolean().default(true),
     })
         .strict(),
@@ -583,7 +505,7 @@ export const zeroRuntimeFinalizePayloadSchema = z
         .strict(),
     realtime: z
         .object({
-        mode: zeroRealtimeModeSchema,
+        mode: runtimeRealtimeModeSchema,
         centralUrl: zeroRealtimeUrlSchema.nullable().default(null),
         replayUrl: zeroHttpUrlSchema.nullable().default(null),
         castResourceKey: z.string().min(1).max(256).nullable().optional(),
@@ -598,7 +520,7 @@ export const zeroRuntimeFinalizePayloadSchema = z
         .strict(),
     auth: z
         .object({
-        provider: z.literal("wpcom").default("wpcom"),
+        provider: z.literal("gravatar").default("gravatar"),
         signInPath: z.literal(ZERO_RUNTIME_ROUTE_PATHS.authStart).nullable().default(null),
         signInUrl: zeroHttpUrlSchema.nullable().default(null),
         signOutPath: z.literal(ZERO_RUNTIME_ROUTE_PATHS.authSignOut).nullable().default(null),
@@ -607,7 +529,7 @@ export const zeroRuntimeFinalizePayloadSchema = z
     })
         .strict()
         .default({
-        provider: "wpcom",
+        provider: "gravatar",
         signInPath: null,
         signInUrl: null,
         signOutPath: null,
@@ -635,6 +557,7 @@ export const zeroRuntimeConfigSchema = zeroRuntimeFinalizePayloadSchema
 })
     .extend({
     variableValues: z.record(z.string(), z.string()).default({}),
+    databaseUrlSource: z.enum(["application", "provider"]).default("application"),
 })
     .strict();
 export const zeroDeployMetadataSchema = z
@@ -643,101 +566,61 @@ export const zeroDeployMetadataSchema = z
     finalize: zeroRuntimeFinalizePayloadSchema,
 })
     .strict();
-export const zeroInspectResponseSchema = z
+/**
+ * What a live Zero capsule is, as the `app` 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.
+ *
+ * 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.
+ */
+export const zeroAppSchema = z
     .object({
-    versionId: z.string().min(1).nullable(),
-    artifactId: z.string().min(1).nullable(),
-    data: z
+    runtimeKind: z.literal(ZERO_RUNTIME_KIND),
+    artifactId: z.string().min(1),
+    appName: z.string().min(1),
+    serverRuntime: z.literal("quickjs-rust"),
+    inspect: z
         .object({
-        runtimeKind: z.literal(ZERO_RUNTIME_KIND),
-        appName: z.string().min(1),
-        serverRuntime: z.literal("quickjs-rust"),
-        inspect: z
-            .object({
-            policy: zeroInspectPolicySchema,
-        })
-            .strict(),
-        install: zeroRuntimeInstallProfileSchema,
-        tables: z.array(z.string()).default([]),
-        queries: z.array(z.string()).default([]),
-        mutations: z.array(z.string()).default([]),
-        endpoints: z.array(zeroEndpointSchema).default([]),
-        sockets: z.array(z.string()).default([]),
-        variables: z
-            .object({
-            source: z.literal("stattic-variables"),
-            names: z.array(z.string()).default([]),
-        })
-            .strict(),
-        realtime: zeroRuntimePublicRealtimeConfigSchema,
+        policy: zeroInspectPolicySchema,
     })
-        .nullable(),
-})
-    .strict();
-export const zeroInspectPublicResponseSchema = dataEnvelope(zeroInspectResponseSchema);
-export const zeroDbInspectResponseSchema = z
-    .object({
-    versionId: z.string().min(1).nullable(),
-    artifactId: z.string().min(1).nullable(),
-    backend: z.literal("wpcloud-mysql").nullable(),
-    migrationMode: z.enum(["safe", "drop", "rename"]).nullable(),
-    schemaHash: zeroSha256Schema.nullable(),
-    tables: z.array(zeroTableSchema).default([]),
-    migrations: z.array(zeroMigrationOperationSchema).default([]),
-})
-    .strict();
-export const zeroDbInspectPublicResponseSchema = dataEnvelope(zeroDbInspectResponseSchema);
-export const zeroDbDumpQuerySchema = z
-    .object({
-    table: zeroNameSchema.optional(),
-    limit: z.coerce.number().int().min(1).max(100).default(25),
-})
-    .strict();
-export const zeroDbDumpTableSchema = z
-    .object({
-    name: zeroNameSchema,
-    rows: z.array(z.record(z.string(), z.unknown())).default([]),
-})
-    .strict();
-export const zeroDbDumpResponseSchema = z
-    .object({
-    versionId: z.string().min(1).nullable(),
-    artifactId: z.string().min(1).nullable(),
+        .strict(),
+    install: zeroRuntimeInstallProfileSchema,
+    tables: z.array(z.string()).default([]),
+    queries: z.array(z.string()).default([]),
+    mutations: z.array(z.string()).default([]),
+    actions: z.array(z.string()).default([]),
+    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`).
+     */
+    migrationCount: z.number().int().nonnegative(),
+    /** Digest of the schema the live migration plan settled on, if it ran one. */
     schemaHash: zeroSha256Schema.nullable(),
-    tables: z.array(zeroDbDumpTableSchema).default([]),
-})
-    .strict();
-export const zeroDbDumpPublicResponseSchema = dataEnvelope(zeroDbDumpResponseSchema);
-export const zeroLogListQuerySchema = z
-    .object({
-    limit: z.coerce.number().int().min(1).max(100).default(50),
-    cursor: z.string().min(1).optional(),
-    requestId: z.string().min(1).optional(),
-    mutationName: z.string().min(1).optional(),
-})
-    .strict();
-export const zeroLogEntrySchema = z
-    .object({
-    id: z.string().min(1),
-    timestamp: z.string().datetime(),
-    level: z.enum(["debug", "info", "warn", "error"]),
-    requestId: z.string().min(1).nullable(),
-    versionId: z.string().min(1).nullable(),
-    mutationName: z.string().min(1).nullable(),
-    message: z.string(),
-    metadata: z.record(z.string(), z.unknown()).default({}),
-})
-    .strict();
-export const zeroLogListResponseSchema = z
-    .object({
-    data: z.array(zeroLogEntrySchema),
-    pagination: z
+    variables: z
         .object({
-        nextCursor: z.string().nullable(),
+        source: z.literal("stattic-variables"),
+        names: z.array(z.string()).default([]),
     })
         .strict(),
+    realtime: zeroRuntimePublicRealtimeConfigSchema,
 })
     .strict();
+// Both products emit the same log shape; `handlerName` carries the mutation
+// name here and the worker handler name on Functions.
+export const zeroLogListQuerySchema = executionLogListQuerySchema;
+export const zeroLogEntrySchema = executionLogEntrySchema;
+export const zeroLogListResponseSchema = executionLogListResponseSchema;
 export const zeroRealtimeEventIntakeResponseSchema = z
     .object({
     accepted: z.literal(true),
@@ -746,22 +629,6 @@ export const zeroRealtimeEventIntakeResponseSchema = z
     duplicate: z.boolean().default(false),
 })
     .strict();
-export const zeroRealtimeEventListQuerySchema = z
-    .object({
-    afterEventId: z.string().min(1).optional(),
-    limit: z.coerce.number().int().min(1).max(100).default(50),
-})
-    .strict();
-export const zeroRealtimeEventListResponseSchema = z
-    .object({
-    data: z.array(zeroRealtimeEventSchema),
-    pagination: z
-        .object({
-        nextCursor: z.string().min(1).nullable(),
-    })
-        .strict(),
-})
-    .strict();
 export const zeroLocalDevPlanSchema = z
     .object({
     runtimeKind: z.literal(ZERO_RUNTIME_KIND),
@@ -792,6 +659,7 @@ export function createZeroCapsuleArtifact(input) {
             schema: input.schema ?? {},
             queries: input.queries ?? [],
             mutations: input.mutations ?? [],
+            actions: input.actions ?? [],
             endpoints: input.endpoints ?? [],
             sockets: input.sockets ?? [],
         },
@@ -800,7 +668,7 @@ export function createZeroCapsuleArtifact(input) {
             migrations: [],
         },
         realtime: {
-            mode: input.realtimeMode ?? "stattic-central",
+            mode: input.realtimeMode ?? "central",
             mutationEvents: true,
         },
         limits: {},
@@ -840,7 +708,7 @@ export function createZeroRuntimeInstallProfile(input) {
             blockIncompatibleRollback: true,
         },
         realtime: {
-            production: "stattic-central",
+            production: "central",
             local: "foreground-cli-ws",
         },
     });