@spacefast/common 0.0.2

package/dist/contracts/zero.js

@@ -0,0 +1,755 @@
+import { z } from "zod";
+import { dataEnvelope } from "./common.js";
+export const ZERO_SOURCE_METADATA_KEY = "statticZero";
+export const ZERO_RUNTIME_KIND = "zero";
+export const ZERO_PLATFORM_ROUTE_PREFIX = "/__spacefast/zero";
+export const ZERO_CLIENT_ENTRY = "client/index.tsx";
+export const ZERO_SERVER_ENTRY = "server/index.ts";
+export const ZERO_RUNTIME_ROUTE_PATHS = {
+    config: `${ZERO_PLATFORM_ROUTE_PREFIX}/config`,
+    realtime: `${ZERO_PLATFORM_ROUTE_PREFIX}/realtime`,
+    inspect: `${ZERO_PLATFORM_ROUTE_PREFIX}/inspect`,
+    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`,
+    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_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_"];
+export const ZERO_MANAGED_TABLE_COLUMNS = ["id", "createdAt", "updatedAt"];
+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." });
+const zeroRoutePathSchema = z
+    .string()
+    .min(1)
+    .max(2048)
+    .startsWith("/")
+    .refine((path) => !path.startsWith("//") && !path.includes("\\") && !path.includes("?") && !path.includes("#"), {
+    message: "Zero capsule routes must be absolute app paths without //, \\, ?, or #.",
+})
+    .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 zeroHttpMethodSchema = z.enum([
+    "GET",
+    "HEAD",
+    "POST",
+    "PUT",
+    "PATCH",
+    "DELETE",
+    "OPTIONS",
+]);
+export const zeroEndpointSchema = z
+    .object({
+    method: zeroHttpMethodSchema,
+    path: zeroRoutePathSchema,
+})
+    .strict();
+function zeroDefaultMatchesColumnType(column, ctx) {
+    if (!Object.prototype.hasOwnProperty.call(column, "default") || column.default === null) {
+        return;
+    }
+    const valid = column.type === "string"
+        ? typeof column.default === "string"
+        : column.type === "boolean"
+            ? typeof column.default === "boolean"
+            : column.type === "number"
+                ? typeof column.default === "number" && Number.isFinite(column.default)
+                : isZeroJsonDefaultValue(column.default);
+    if (!valid) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["default"],
+            message: `Zero ${column.type} column default is invalid.`,
+        });
+    }
+}
+function isZeroJsonDefaultValue(value) {
+    if (value === null || typeof value === "string" || typeof value === "boolean") {
+        return true;
+    }
+    if (typeof value === "number") {
+        return Number.isFinite(value);
+    }
+    if (Array.isArray(value)) {
+        return value.every(isZeroJsonDefaultValue);
+    }
+    if (value && typeof value === "object") {
+        return Object.values(value).every(isZeroJsonDefaultValue);
+    }
+    return false;
+}
+export const zeroTableColumnSchema = z
+    .object({
+    name: zeroNameSchema.refine((name) => !ZERO_MANAGED_TABLE_COLUMNS.some((managed) => managed === name), { message: "Zero manages id, createdAt, and updatedAt." }),
+    type: z.enum(["string", "boolean", "number", "json"]),
+    nullable: z.boolean().default(false),
+    default: z.unknown().optional(),
+})
+    .strict()
+    .superRefine(zeroDefaultMatchesColumnType);
+export const zeroTableSchema = z
+    .object({
+    name: zeroNameSchema,
+    columns: z.array(zeroTableColumnSchema).default([]),
+})
+    .strict();
+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.",
+});
+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),
+    source: z
+        .string()
+        .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({}),
+    db: z.record(z.string(), z.unknown()).optional(),
+})
+    .strict();
+export const zeroMigrationOperationSchema = z.discriminatedUnion("op", [
+    z
+        .object({
+        op: z.literal("create_table"),
+        table: zeroNameSchema,
+    })
+        .strict(),
+    z
+        .object({
+        op: z.literal("add_column"),
+        table: zeroNameSchema,
+        column: zeroTableColumnSchema,
+    })
+        .strict(),
+    z
+        .object({
+        op: z.literal("add_index"),
+        table: zeroNameSchema,
+        columns: z.array(zeroNameSchema).min(1),
+        unique: z.boolean().default(false),
+    })
+        .strict(),
+    z
+        .object({
+        op: z.literal("drop_table"),
+        table: zeroNameSchema,
+        explicit: z.literal("drop"),
+    })
+        .strict(),
+    z
+        .object({
+        op: z.literal("drop_column"),
+        table: zeroNameSchema,
+        column: zeroNameSchema,
+        explicit: z.literal("drop"),
+    })
+        .strict(),
+    z
+        .object({
+        op: z.literal("rename_table"),
+        from: zeroNameSchema,
+        to: zeroNameSchema,
+        explicit: z.literal("rename"),
+    })
+        .strict(),
+    z
+        .object({
+        op: z.literal("rename_column"),
+        table: zeroNameSchema,
+        from: zeroNameSchema,
+        to: zeroNameSchema,
+        explicit: z.literal("rename"),
+    })
+        .strict(),
+]);
+export const zeroMigrationPlanSchema = z
+    .object({
+    format: z.literal("stattic.zero.migrations.v1"),
+    mode: z.enum(["safe", "drop", "rename"]).default("safe"),
+    schemaHash: zeroSha256Schema,
+    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"]);
+const zeroRuntimePublicPathSchema = z.string().min(1).startsWith("/");
+const zeroHttpUrlSchema = z
+    .string()
+    .url()
+    .refine((value) => {
+    const { protocol } = new URL(value);
+    return protocol === "http:" || protocol === "https:";
+}, { message: "URL must use http or https." });
+const zeroRealtimeUrlSchema = z
+    .string()
+    .url()
+    .refine((value) => {
+    const { protocol } = new URL(value);
+    return (protocol === "http:" || protocol === "https:" || protocol === "ws:" || protocol === "wss:");
+}, { message: "Realtime URL must use http, https, ws, or wss." });
+export const zeroRuntimePublicAuthConfigSchema = z
+    .object({
+    provider: z.literal("wpcom").default("wpcom"),
+    signInPath: zeroRuntimePublicPathSchema.nullable().default(null),
+    signInUrl: zeroHttpUrlSchema.nullable().default(null),
+    signOutPath: zeroRuntimePublicPathSchema.nullable().default(null),
+    signOutUrl: zeroHttpUrlSchema.nullable().default(null),
+    returnToParam: z.string().min(1).max(64).default("returnTo"),
+})
+    .strict();
+export const zeroRuntimePublicRealtimeConfigSchema = z
+    .object({
+    mode: zeroRuntimePublicRealtimeModeSchema,
+    centralUrl: zeroRealtimeUrlSchema.nullable().default(null),
+    path: zeroRuntimePublicPathSchema.optional(),
+    replayPath: zeroRuntimePublicPathSchema.nullable().optional(),
+    replayUrl: zeroHttpUrlSchema.nullable().optional(),
+    runPath: zeroRuntimePublicPathSchema.nullable().optional(),
+    runUrl: zeroHttpUrlSchema.nullable().optional(),
+    resourceKey: z.string().min(1).max(256).nullable().optional(),
+    socketPath: zeroRuntimePublicPathSchema.nullable().optional(),
+    spaceId: z.string().min(1).nullable().optional(),
+    versionId: z.string().min(1).nullable().optional(),
+})
+    .strict();
+export const zeroRuntimeClientConfigSchema = z
+    .object({
+    runtimeKind: z.literal(ZERO_RUNTIME_KIND),
+    basePath: zeroRuntimePublicPathSchema.optional(),
+    auth: zeroRuntimePublicAuthConfigSchema.optional(),
+    realtime: zeroRuntimePublicRealtimeConfigSchema.optional(),
+})
+    .strict();
+export const zeroRuntimeInstallProfileSchema = z
+    .object({
+    runtimeKind: z.literal(ZERO_RUNTIME_KIND),
+    engine: z.literal("quickjs-rust"),
+    storageRoot: z.literal(ZERO_RUNTIME_STORAGE_ROOT),
+    artifactPath: z.literal(ZERO_RUNTIME_ARTIFACT_PATH),
+    configPath: z.literal(ZERO_RUNTIME_CONFIG_PATH),
+    binary: z
+        .object({
+        path: z.literal(ZERO_RUNTIME_BINARY_PATH),
+        compatibilityTarget: z
+            .object({
+            profile: z.literal(ZERO_RUNTIME_BINARY_COMPATIBILITY_TARGET),
+            os: z.literal("linux"),
+            cpu: z.literal("x86_64"),
+            libc: z.literal("glibc"),
+            linking: z.literal("dynamic"),
+            requireExecutableBit: z.literal(true),
+        })
+            .strict(),
+        sha256: z
+            .string()
+            .regex(/^sha256:[a-f0-9]{64}$/)
+            .nullable()
+            .default(null),
+        required: z.literal(true),
+    })
+        .strict(),
+    mysql: z
+        .object({
+        migrateAtFinalize: z.literal(true),
+        blockIncompatibleRollback: z.literal(true),
+    })
+        .strict(),
+    realtime: z
+        .object({
+        production: z.literal("stattic-central"),
+        local: z.literal("foreground-cli-ws"),
+    })
+        .strict(),
+})
+    .strict();
+export const zeroRealtimeEventSchema = z
+    .object({
+    eventId: z.string().min(1),
+    spaceId: z.string().min(1),
+    versionId: z.string().min(1).nullable(),
+    runtimeKind: z.literal(ZERO_RUNTIME_KIND),
+    requestId: z.string().min(1),
+    mutationName: zeroNameSchema,
+    changedTables: z.array(zeroNameSchema).default([]),
+    changedQueries: z.array(zeroNameSchema).default([]),
+    schemaHash: zeroSha256Schema,
+    committedAt: z.string().datetime(),
+})
+    .strict();
+export const zeroSourceFileSchema = z
+    .object({
+    path: z.string().min(1),
+    size: z.number().int().nonnegative(),
+    sha256: z.string().regex(/^[a-f0-9]{64}$/),
+})
+    .strict();
+export const zeroSourceManifestSchema = z
+    .object({
+    entries: z
+        .object({
+        client: z.literal(ZERO_CLIENT_ENTRY),
+        server: z.literal(ZERO_SERVER_ENTRY),
+    })
+        .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([]),
+    })
+        .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
+    .object({
+    format: z.literal("stattic.zero.capsule.v1"),
+    appName: z.string().min(1).max(128),
+    serverRuntime: z.literal("quickjs-rust"),
+    client: z
+        .object({
+        bundlePath: z.string().min(1),
+        basePathAware: z.boolean().default(true),
+    })
+        .strict(),
+    server: z
+        .object({
+        bundlePath: z.string().min(1),
+        schema: zeroDatabaseSchema.default({}),
+        queries: z.array(zeroNameSchema).default([]),
+        mutations: z.array(zeroNameSchema).default([]),
+        endpoints: z.array(zeroEndpointSchema).default([]),
+        sockets: z.array(zeroNameSchema).default([]),
+    })
+        .strict(),
+    db: z
+        .object({
+        backend: z.literal("wpcloud-mysql"),
+        migrations: z.array(zeroMigrationOperationSchema).default([]),
+    })
+        .strict(),
+    realtime: z
+        .object({
+        mode: zeroRealtimeModeSchema,
+        mutationEvents: z.boolean().default(true),
+    })
+        .strict(),
+    limits: z.record(z.string(), z.unknown()).default({}),
+    futureCapabilities: z.array(z.enum(["blob", "ai", "generalized-js"])).default([]),
+    sourceManifest: zeroSourceManifestSchema,
+})
+    .strict();
+export const zeroRuntimeFinalizePayloadSchema = z
+    .object({
+    runtimeKind: z.literal(ZERO_RUNTIME_KIND),
+    install: zeroRuntimeInstallProfileSchema,
+    artifact: zeroCapsuleArtifactSchema,
+    bundles: z.array(zeroRuntimeBundleSchema).max(8).default([]),
+    staticFiles: z.array(zeroRuntimeStaticFileSchema).max(16).default([]),
+    runSources: z.array(zeroRuntimeRunSourceSchema).max(128).default([]),
+    migrations: zeroMigrationPlanSchema.nullable().default(null),
+    variables: z
+        .object({
+        source: z.literal("stattic-variables"),
+        names: z.array(z.string().min(1)).default([]),
+    })
+        .strict(),
+    realtime: z
+        .object({
+        mode: zeroRealtimeModeSchema,
+        centralUrl: zeroRealtimeUrlSchema.nullable().default(null),
+        replayUrl: zeroHttpUrlSchema.nullable().default(null),
+        castResourceKey: z.string().min(1).max(256).nullable().optional(),
+        eventCallback: z
+            .object({
+            url: zeroHttpUrlSchema,
+            token: z.string().min(1),
+        })
+            .strict()
+            .optional(),
+    })
+        .strict(),
+    auth: z
+        .object({
+        provider: z.literal("wpcom").default("wpcom"),
+        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),
+        signOutUrl: zeroHttpUrlSchema.nullable().default(null),
+        returnToParam: z.string().min(1).max(64).default("returnTo"),
+    })
+        .strict()
+        .default({
+        provider: "wpcom",
+        signInPath: null,
+        signInUrl: null,
+        signOutPath: null,
+        signOutUrl: null,
+        returnToParam: "returnTo",
+    }),
+    inspect: z
+        .object({
+        policy: zeroInspectPolicySchema.default("private"),
+    })
+        .strict()
+        .default({ policy: "private" }),
+})
+    .strict();
+export const zeroDeployMetadataSchema = z
+    .object({
+    artifactId: z.string().min(1).optional(),
+    finalize: zeroRuntimeFinalizePayloadSchema,
+})
+    .strict();
+export const zeroInspectResponseSchema = z
+    .object({
+    versionId: z.string().min(1).nullable(),
+    artifactId: z.string().min(1).nullable(),
+    data: 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,
+    })
+        .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(),
+    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
+        .object({
+        nextCursor: z.string().nullable(),
+    })
+        .strict(),
+})
+    .strict();
+export const zeroRealtimeEventIntakeResponseSchema = z
+    .object({
+    accepted: z.literal(true),
+    eventId: z.string().min(1),
+    delivered: z.number().int().nonnegative().default(0),
+    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),
+    root: z.string().min(1),
+    httpUrl: z.string().url(),
+    realtimeUrl: z.string().url(),
+    realtimePath: z.literal(ZERO_RUNTIME_ROUTE_PATHS.realtime),
+    stateBackend: z.enum(["memory", "sqlite", "mysql"]),
+})
+    .strict();
+export function isDestructiveZeroMigrationOperation(operation) {
+    return (operation.op === "drop_table" ||
+        operation.op === "drop_column" ||
+        operation.op === "rename_table" ||
+        operation.op === "rename_column");
+}
+export function createZeroCapsuleArtifact(input) {
+    return zeroCapsuleArtifactSchema.parse({
+        format: "stattic.zero.capsule.v1",
+        appName: input.appName,
+        serverRuntime: "quickjs-rust",
+        client: {
+            bundlePath: input.clientBundlePath ?? ZERO_RUNTIME_CLIENT_BUNDLE_PATH,
+            basePathAware: true,
+        },
+        server: {
+            bundlePath: input.serverBundlePath ?? ZERO_RUNTIME_SERVER_BUNDLE_PATH,
+            schema: input.schema ?? {},
+            queries: input.queries ?? [],
+            mutations: input.mutations ?? [],
+            endpoints: input.endpoints ?? [],
+            sockets: input.sockets ?? [],
+        },
+        db: {
+            backend: "wpcloud-mysql",
+            migrations: [],
+        },
+        realtime: {
+            mode: input.realtimeMode ?? "stattic-central",
+            mutationEvents: true,
+        },
+        limits: {},
+        futureCapabilities: ["blob", "ai"],
+        sourceManifest: input.sourceManifest ?? {
+            entries: {
+                client: ZERO_CLIENT_ENTRY,
+                server: ZERO_SERVER_ENTRY,
+            },
+            sourceRoot: ".",
+            files: [],
+        },
+    });
+}
+export function createZeroRuntimeInstallProfile(input) {
+    return zeroRuntimeInstallProfileSchema.parse({
+        runtimeKind: ZERO_RUNTIME_KIND,
+        engine: "quickjs-rust",
+        storageRoot: ZERO_RUNTIME_STORAGE_ROOT,
+        artifactPath: ZERO_RUNTIME_ARTIFACT_PATH,
+        configPath: ZERO_RUNTIME_CONFIG_PATH,
+        binary: {
+            path: ZERO_RUNTIME_BINARY_PATH,
+            compatibilityTarget: {
+                profile: ZERO_RUNTIME_BINARY_COMPATIBILITY_TARGET,
+                os: "linux",
+                cpu: "x86_64",
+                libc: "glibc",
+                linking: "dynamic",
+                requireExecutableBit: true,
+            },
+            sha256: input?.runnerSha256 ?? null,
+            required: true,
+        },
+        mysql: {
+            migrateAtFinalize: true,
+            blockIncompatibleRollback: true,
+        },
+        realtime: {
+            production: "stattic-central",
+            local: "foreground-cli-ws",
+        },
+    });
+}
+export function createZeroRuntimeFinalizePayload(input) {
+    const artifact = zeroCapsuleArtifactSchema.parse(input.artifact);
+    return zeroRuntimeFinalizePayloadSchema.parse({
+        runtimeKind: ZERO_RUNTIME_KIND,
+        install: createZeroRuntimeInstallProfile({ runnerSha256: input.runnerSha256 ?? null }),
+        artifact,
+        bundles: input.bundles ?? [],
+        staticFiles: input.staticFiles ?? [],
+        runSources: input.runSources ?? [],
+        migrations: input.migrations ?? null,
+        variables: {
+            source: "stattic-variables",
+            names: artifact.sourceManifest.env?.names ?? [],
+        },
+        realtime: {
+            mode: artifact.realtime.mode,
+            centralUrl: input.centralRealtimeUrl ?? null,
+            replayUrl: input.realtimeReplayUrl ?? null,
+            ...(input.realtimeEventCallback ? { eventCallback: input.realtimeEventCallback } : {}),
+        },
+        auth: input.auth ?? {},
+        inspect: {
+            policy: input.inspectPolicy ?? "private",
+        },
+    });
+}