@spacefast/common 0.0.26 → 0.2.2

package/dist/contracts/runtime-app.js

@@ -3,21 +3,14 @@ import { CursorPaginationSchema } from "./common.js";
 import { functionsAppSchema } from "./functions.js";
 import { zeroAppSchema, zeroRealtimeEventSchema } from "./zero.js";
 /**
- * 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 const runtimeAppSchema = z
     .object({
@@ -29,23 +22,45 @@ export const runtimeAppSchema = z
         .describe("The live version's Functions worker, if it carries one."),
 })
     .strict();
-/**
- * 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 const runtimeRealtimeEventListQuerySchema = z
     .object({
-    afterEventId: z.string().min(1).optional(),
-    limit: z.coerce.number().int().min(1).max(100).default(50),
+    afterEventId: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Walk forward from this event id, exclusive. Omit it to start at the oldest retained event; pass the previous page's `nextAfterEventId` to continue. An id that has aged out of the retention window is rejected."),
+    limit: z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(100)
+        .default(50)
+        .describe("Maximum events to return."),
 })
     .strict();
+// Keyset, not the platform's opaque cursor: replay walks forward by event id
+// and an aged-out id is a hard error, so the response names the next
+// `afterEventId` rather than advertising a `pagination` envelope the request
+// has no `cursor` to feed. The legacy `pagination` member below is a temporary
+// back-compat exception, not the canonical shape — see its note.
 export const runtimeRealtimeEventListResponseSchema = z
     .object({
     data: z.array(zeroRealtimeEventSchema),
-    pagination: CursorPaginationSchema,
+    nextAfterEventId: z
+        .string()
+        .nullable()
+        .describe("Event id to pass as `afterEventId` for the next page; null when this page reached the newest retained event."),
+    // COMPAT (temporary back-compat, effectively durable): pre-cutover Zero
+    // capsule clients are baked per-capsule at build time and cannot be
+    // rebuilt (we don't always have capsule source). Those frozen clients page
+    // replay by reading `pagination.nextCursor` and never look at
+    // `nextAfterEventId`, so the server keeps emitting this legacy envelope
+    // alongside the flat field. `nextCursor` carries the exact same
+    // continuation value as `nextAfterEventId`, and `hasMore` mirrors it.
+    // Remove only once no frozen pre-cutover capsules remain (which may be
+    // never); until then this is the sole reason the field survives the
+    // cutover.
+    pagination: CursorPaginationSchema.describe("Legacy pagination envelope kept only for frozen pre-cutover Zero capsule clients that page by `pagination.nextCursor`. New clients read `nextAfterEventId`; `nextCursor` mirrors it exactly."),
 })
     .strict();

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

@@ -0,0 +1,143 @@
+import { z } from "zod";
+export declare const runtimeCapabilityIdSchema: z.core.$ZodBranded<z.ZodString, "RuntimeCapabilityId", "out">;
+export declare const runtimeComponentIdSchema: z.core.$ZodBranded<z.ZodString, "RuntimeComponentId", "out">;
+export type RuntimeCapabilityId = z.infer<typeof runtimeCapabilityIdSchema>;
+export type RuntimeComponentId = z.infer<typeof runtimeComponentIdSchema>;
+export declare const RUNTIME_COMPONENT_V1_REQUIRED_IDS: readonly ["wordpress-core", "runtime-engine", "immutable-loader", "content-kernel", "managed-theme", "secure-custom-fields", "redirection", "block-transformer", "quickjs-abi"];
+export declare const RUNTIME_COMPONENT_KINDS: readonly ["wordpress-core", "runtime-engine", "mu-plugin", "plugin", "theme", "block-transformer", "quickjs-abi"];
+export declare const runtimeComponentKindSchema: z.ZodEnum<{
+    plugin: "plugin";
+    theme: "theme";
+    "wordpress-core": "wordpress-core";
+    "runtime-engine": "runtime-engine";
+    "block-transformer": "block-transformer";
+    "quickjs-abi": "quickjs-abi";
+    "mu-plugin": "mu-plugin";
+}>;
+export type RuntimeComponentKind = z.infer<typeof runtimeComponentKindSchema>;
+export declare const runtimeComponentV1Schema: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "RuntimeComponentId", "out">;
+    kind: z.ZodEnum<{
+        plugin: "plugin";
+        theme: "theme";
+        "wordpress-core": "wordpress-core";
+        "runtime-engine": "runtime-engine";
+        "block-transformer": "block-transformer";
+        "quickjs-abi": "quickjs-abi";
+        "mu-plugin": "mu-plugin";
+    }>;
+    version: z.ZodString;
+    sha256: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"archive">;
+        url: z.ZodString;
+        bytes: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"embedded">;
+        path: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    provides: z.ZodArray<z.core.$ZodBranded<z.ZodString, "RuntimeCapabilityId", "out">>;
+    activation: z.ZodEnum<{
+        always: "always";
+        "on-demand": "on-demand";
+    }>;
+}, z.core.$strict>;
+export type RuntimeComponentV1 = z.infer<typeof runtimeComponentV1Schema>;
+export declare const runtimeComponentInventoryV1Schema: z.ZodObject<{
+    format: z.ZodLiteral<"spacefast.wordpress-components">;
+    version: z.ZodLiteral<1>;
+    platformRelease: z.ZodString;
+    digest: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+    components: z.ZodArray<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "RuntimeComponentId", "out">;
+        kind: z.ZodEnum<{
+            plugin: "plugin";
+            theme: "theme";
+            "wordpress-core": "wordpress-core";
+            "runtime-engine": "runtime-engine";
+            "block-transformer": "block-transformer";
+            "quickjs-abi": "quickjs-abi";
+            "mu-plugin": "mu-plugin";
+        }>;
+        version: z.ZodString;
+        sha256: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+        source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"archive">;
+            url: z.ZodString;
+            bytes: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"embedded">;
+            path: z.ZodString;
+        }, z.core.$strict>], "kind">;
+        provides: z.ZodArray<z.core.$ZodBranded<z.ZodString, "RuntimeCapabilityId", "out">>;
+        activation: z.ZodEnum<{
+            always: "always";
+            "on-demand": "on-demand";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type RuntimeComponentInventoryV1 = z.infer<typeof runtimeComponentInventoryV1Schema>;
+export declare const programRequirementsV1Schema: z.ZodObject<{
+    format: z.ZodLiteral<"spacefast.program-requirements">;
+    version: z.ZodLiteral<1>;
+    inputDigest: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+    wordpressAbi: z.ZodLiteral<1>;
+    capabilities: z.ZodArray<z.core.$ZodBranded<z.ZodString, "RuntimeCapabilityId", "out">>;
+}, z.core.$strict>;
+export type ProgramRequirementsV1 = z.infer<typeof programRequirementsV1Schema>;
+export declare const runtimeComponentPlacementTargetV1Schema: z.ZodObject<{
+    spaceId: z.ZodTemplateLiteral<`spc_${string}`>;
+    runtimeInstanceId: z.ZodString;
+    siteId: z.ZodString;
+}, z.core.$strict>;
+export type RuntimeComponentPlacementTargetV1 = z.infer<typeof runtimeComponentPlacementTargetV1Schema>;
+export declare const runtimeComponentPlacementReceiptV1Schema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"ready">;
+    observedInventoryDigest: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+    substrate: z.ZodObject<{
+        wordpress: z.ZodObject<{
+            boot: z.ZodLiteral<"ready">;
+            database: z.ZodLiteral<"ready">;
+            tables: z.ZodLiteral<"ready">;
+        }, z.core.$strict>;
+        routing: z.ZodObject<{
+            state: z.ZodLiteral<"ready">;
+            snapshotRevision: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+            inventoryDigest: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+        }, z.core.$strict>;
+        mail: z.ZodObject<{
+            state: z.ZodLiteral<"ready">;
+        }, z.core.$strict>;
+        journal: z.ZodObject<{
+            state: z.ZodLiteral<"ready">;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    format: z.ZodLiteral<"spacefast.component-placement">;
+    version: z.ZodLiteral<1>;
+    operationId: z.ZodString;
+    target: z.ZodObject<{
+        spaceId: z.ZodTemplateLiteral<`spc_${string}`>;
+        runtimeInstanceId: z.ZodString;
+        siteId: z.ZodString;
+    }, z.core.$strict>;
+    platformRelease: z.ZodString;
+    expectedInventoryDigest: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"blocked">;
+    problems: z.ZodArray<z.ZodObject<{
+        componentId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RuntimeComponentId", "out">>;
+        code: z.ZodString;
+        detail: z.ZodString;
+    }, z.core.$strict>>;
+    format: z.ZodLiteral<"spacefast.component-placement">;
+    version: z.ZodLiteral<1>;
+    operationId: z.ZodString;
+    target: z.ZodObject<{
+        spaceId: z.ZodTemplateLiteral<`spc_${string}`>;
+        runtimeInstanceId: z.ZodString;
+        siteId: z.ZodString;
+    }, z.core.$strict>;
+    platformRelease: z.ZodString;
+    expectedInventoryDigest: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+}, z.core.$strict>], "status">;
+export type RuntimeComponentPlacementReceiptV1 = z.infer<typeof runtimeComponentPlacementReceiptV1Schema>;

package/dist/contracts/runtime-components.js

@@ -0,0 +1,199 @@
+import { z } from "zod";
+import { contentProgramSha256Schema } from "./content-program.js";
+import { registeredIdSchema } from "./ids.js";
+export const runtimeCapabilityIdSchema = z
+    .string()
+    .min(1)
+    .max(160)
+    .regex(/^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/)
+    .brand();
+export const runtimeComponentIdSchema = z
+    .string()
+    .min(1)
+    .max(160)
+    .regex(/^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/)
+    .brand();
+export const RUNTIME_COMPONENT_V1_REQUIRED_IDS = [
+    "wordpress-core",
+    "runtime-engine",
+    "immutable-loader",
+    "content-kernel",
+    "managed-theme",
+    "secure-custom-fields",
+    "redirection",
+    "block-transformer",
+    "quickjs-abi",
+];
+export const RUNTIME_COMPONENT_KINDS = [
+    "wordpress-core",
+    "runtime-engine",
+    "mu-plugin",
+    "plugin",
+    "theme",
+    "block-transformer",
+    "quickjs-abi",
+];
+export const runtimeComponentKindSchema = z.enum(RUNTIME_COMPONENT_KINDS);
+const runtimeComponentV1RequiredKinds = {
+    "wordpress-core": "wordpress-core",
+    "runtime-engine": "runtime-engine",
+    "immutable-loader": "mu-plugin",
+    "content-kernel": "mu-plugin",
+    "managed-theme": "theme",
+    "secure-custom-fields": "plugin",
+    redirection: "plugin",
+    "block-transformer": "block-transformer",
+    "quickjs-abi": "quickjs-abi",
+};
+const runtimeComponentSourceSchema = z.discriminatedUnion("kind", [
+    z
+        .object({
+        kind: z.literal("archive"),
+        url: z.string().url(),
+        bytes: z.number().int().positive(),
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("embedded"),
+        path: z
+            .string()
+            .min(1)
+            .max(512)
+            .refine((path) => !path.startsWith("/") && !path.split("/").includes(".."), {
+            message: "embedded component paths must be relative and cannot traverse",
+        }),
+    })
+        .strict(),
+]);
+export const runtimeComponentV1Schema = z
+    .object({
+    id: runtimeComponentIdSchema,
+    kind: runtimeComponentKindSchema,
+    version: z.string().min(1).max(160),
+    sha256: contentProgramSha256Schema,
+    source: runtimeComponentSourceSchema,
+    provides: z.array(runtimeCapabilityIdSchema).max(100),
+    activation: z.enum(["always", "on-demand"]),
+})
+    .strict()
+    .refine((component) => new Set(component.provides).size === component.provides.length, {
+    path: ["provides"],
+    message: "provided capabilities must be unique",
+});
+export const runtimeComponentInventoryV1Schema = z
+    .object({
+    format: z.literal("spacefast.wordpress-components"),
+    version: z.literal(1),
+    platformRelease: z.string().min(1).max(160),
+    digest: contentProgramSha256Schema,
+    components: z.array(runtimeComponentV1Schema).min(1).max(100),
+})
+    .strict()
+    .superRefine((inventory, context) => {
+    const ids = inventory.components.map((component) => component.id);
+    if (new Set(ids).size !== ids.length) {
+        context.addIssue({
+            code: "custom",
+            path: ["components"],
+            message: "component ids must be unique",
+        });
+    }
+    for (const required of RUNTIME_COMPONENT_V1_REQUIRED_IDS) {
+        const matching = inventory.components.filter((component) => component.id === required);
+        if (matching.length !== 1) {
+            context.addIssue({
+                code: "custom",
+                path: ["components"],
+                message: `component inventory requires exactly one ${required} component`,
+            });
+        }
+        else if (matching[0]?.kind !== runtimeComponentV1RequiredKinds[required]) {
+            context.addIssue({
+                code: "custom",
+                path: ["components"],
+                message: `${required} must use component kind ${runtimeComponentV1RequiredKinds[required]}`,
+            });
+        }
+    }
+});
+export const programRequirementsV1Schema = z
+    .object({
+    format: z.literal("spacefast.program-requirements"),
+    version: z.literal(1),
+    inputDigest: contentProgramSha256Schema,
+    wordpressAbi: z.literal(1),
+    capabilities: z.array(runtimeCapabilityIdSchema).max(100),
+})
+    .strict()
+    .refine((requirements) => new Set(requirements.capabilities).size === requirements.capabilities.length, {
+    path: ["capabilities"],
+    message: "program capabilities must be unique",
+});
+export const runtimeComponentPlacementTargetV1Schema = z
+    .object({
+    spaceId: registeredIdSchema("spc"),
+    runtimeInstanceId: z.string().min(1).max(255),
+    siteId: z.string().min(1).max(255),
+})
+    .strict();
+const runtimeComponentPlacementReceiptFields = {
+    format: z.literal("spacefast.component-placement"),
+    version: z.literal(1),
+    operationId: z.string().min(1).max(160),
+    target: runtimeComponentPlacementTargetV1Schema,
+    platformRelease: z.string().min(1).max(160),
+    expectedInventoryDigest: contentProgramSha256Schema,
+};
+const readyPlacementSubstrateV1Schema = z
+    .object({
+    wordpress: z
+        .object({
+        boot: z.literal("ready"),
+        database: z.literal("ready"),
+        tables: z.literal("ready"),
+    })
+        .strict(),
+    routing: z
+        .object({
+        state: z.literal("ready"),
+        snapshotRevision: contentProgramSha256Schema,
+        inventoryDigest: contentProgramSha256Schema,
+    })
+        .strict(),
+    mail: z.object({ state: z.literal("ready") }).strict(),
+    journal: z.object({ state: z.literal("ready") }).strict(),
+})
+    .strict();
+export const runtimeComponentPlacementReceiptV1Schema = z
+    .discriminatedUnion("status", [
+    z
+        .object({
+        ...runtimeComponentPlacementReceiptFields,
+        status: z.literal("ready"),
+        observedInventoryDigest: contentProgramSha256Schema,
+        substrate: readyPlacementSubstrateV1Schema,
+    })
+        .strict(),
+    z
+        .object({
+        ...runtimeComponentPlacementReceiptFields,
+        status: z.literal("blocked"),
+        problems: z
+            .array(z
+            .object({
+            componentId: runtimeComponentIdSchema.optional(),
+            code: z.string().min(1).max(160),
+            detail: z.string().min(1).max(2_000),
+        })
+            .strict())
+            .min(1)
+            .max(100),
+    })
+        .strict(),
+])
+    .refine((receipt) => receipt.status !== "ready" ||
+    receipt.observedInventoryDigest === receipt.expectedInventoryDigest, {
+    path: ["observedInventoryDigest"],
+    message: "a ready receipt must observe the expected inventory digest",
+});

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

@@ -2,18 +2,29 @@ import { z } from "zod";
 /**
  * The database surface, for whichever runtime a space is carrying.
  *
- * There is one database per space — the site's own MySQL — and at most one
- * runtime with a claim on it, so these contracts are runtime-neutral by
- * default. The two exceptions are stated explicitly: a migration plan is a
- * capsule's declaration and no worker has one, and the console hand-off is a
- * property of the wp.cloud site rather than of anything a version declared.
+ * One database per space, the site's own MySQL, and at most one runtime with a
+ * claim on it, so these contracts are runtime-neutral. Two exceptions: a
+ * migration plan is a capsule's declaration and no worker has one, and the
+ * console hand-off is a property of the wp.cloud site.
  *
- * The reads answer in the capsule's declaration shapes (`zeroTableSchema`,
- * `zeroMigrationOperationSchema`) because a capsule's declared schema is the
- * richest answer either runtime can give and a worker's is the same answer with
- * the declaration-shaped fields empty. Those shapes stay Zero-named and stay in
- * `./zero.js`: a declared table is the capsule's own statement about itself.
+ * Reads answer in the capsule's declaration shapes (`zeroTableSchema`,
+ * `zeroMigrationOperationSchema`); a worker's answer is the same shape with the
+ * declaration-shaped fields empty.
  */
+/**
+ * Whether the live version's declared migration plan has actually run against
+ * the space database. `applied` compares the recorded application against the
+ * plan's target `schemaHash`; it is `null` when no application record exists —
+ * a version finalized before this record existed, or a finalize whose ready
+ * receipt was a replay — because the control plane then cannot prove the plan
+ * ran. Honest unknown, never a guess.
+ */
+export declare const runtimeDbPlanStateSchema: z.ZodObject<{
+    applied: z.ZodNullable<z.ZodBoolean>;
+    appliedSchemaHash: z.ZodNullable<z.ZodString>;
+    pendingOperationCount: z.ZodNumber;
+}, z.core.$strict>;
+export type RuntimeDbPlanState = z.infer<typeof runtimeDbPlanStateSchema>;
 export declare const runtimeDbInspectResponseSchema: z.ZodObject<{
     versionId: z.ZodNullable<z.ZodString>;
     artifactId: z.ZodNullable<z.ZodString>;
@@ -91,6 +102,11 @@ export declare const runtimeDbInspectResponseSchema: z.ZodObject<{
         to: z.ZodString;
         explicit: z.ZodLiteral<"rename">;
     }, z.core.$strict>], "op">>>;
+    plan: z.ZodNullable<z.ZodObject<{
+        applied: z.ZodNullable<z.ZodBoolean>;
+        appliedSchemaHash: z.ZodNullable<z.ZodString>;
+        pendingOperationCount: z.ZodNumber;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export type RuntimeDbInspectResponse = z.infer<typeof runtimeDbInspectResponseSchema>;
 export declare const runtimeDbInspectPublicResponseSchema: z.ZodObject<{
@@ -171,15 +187,24 @@ export declare const runtimeDbInspectPublicResponseSchema: z.ZodObject<{
             to: z.ZodString;
             explicit: z.ZodLiteral<"rename">;
         }, z.core.$strict>], "op">>>;
+        plan: z.ZodNullable<z.ZodObject<{
+            applied: z.ZodNullable<z.ZodBoolean>;
+            appliedSchemaHash: z.ZodNullable<z.ZodString>;
+            pendingOperationCount: z.ZodNumber;
+        }, z.core.$strict>>;
     }, z.core.$strict>;
 }, z.core.$strip>;
 export declare const runtimeDbDumpQuerySchema: z.ZodObject<{
     table: z.ZodOptional<z.ZodString>;
     limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
 }, z.core.$strict>;
+export type RuntimeDbCellValue = string | number | boolean | null | RuntimeDbCellValue[] | {
+    [key: string]: RuntimeDbCellValue;
+};
+export declare const runtimeDbCellValueSchema: z.ZodType<RuntimeDbCellValue>;
 export declare const runtimeDbDumpTableSchema: z.ZodObject<{
     name: z.ZodString;
-    rows: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    rows: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodType<RuntimeDbCellValue, unknown, z.core.$ZodTypeInternals<RuntimeDbCellValue, unknown>>>>>;
 }, z.core.$strict>;
 export declare const runtimeDbDumpResponseSchema: z.ZodObject<{
     versionId: z.ZodNullable<z.ZodString>;
@@ -187,7 +212,7 @@ export declare const runtimeDbDumpResponseSchema: z.ZodObject<{
     schemaHash: z.ZodNullable<z.ZodString>;
     tables: z.ZodDefault<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
-        rows: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        rows: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodType<RuntimeDbCellValue, unknown, z.core.$ZodTypeInternals<RuntimeDbCellValue, unknown>>>>>;
     }, z.core.$strict>>>;
 }, z.core.$strict>;
 export type RuntimeDbDumpResponse = z.infer<typeof runtimeDbDumpResponseSchema>;
@@ -198,7 +223,7 @@ export declare const runtimeDbDumpPublicResponseSchema: z.ZodObject<{
         schemaHash: z.ZodNullable<z.ZodString>;
         tables: z.ZodDefault<z.ZodArray<z.ZodObject<{
             name: z.ZodString;
-            rows: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+            rows: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodUnknown>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>>>;
         }, z.core.$strict>>>;
     }, z.core.$strict>;
 }, z.core.$strip>;
@@ -237,15 +262,16 @@ export declare const runtimeDbExportPageQuerySchema: z.ZodObject<{
     limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
 }, z.core.$strict>;
 export declare const runtimeDbExportPageSchema: z.ZodObject<{
-    rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodType<RuntimeDbCellValue, unknown, z.core.$ZodTypeInternals<RuntimeDbCellValue, unknown>>>>;
     cursor: z.ZodNullable<z.ZodString>;
 }, z.core.$strict>;
 export type RuntimeDbExportPage = z.infer<typeof runtimeDbExportPageSchema>;
 export declare const runtimeDbExportPagePublicResponseSchema: z.ZodObject<{
-    data: z.ZodObject<{
-        rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        cursor: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>;
+    data: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodUnknown>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>>;
+    pagination: z.ZodObject<{
+        nextCursor: z.ZodNullable<z.ZodString>;
+        hasMore: z.ZodBoolean;
+    }, z.core.$strip>;
 }, z.core.$strip>;
 export declare const runtimeDbMigrateResultSchema: z.ZodObject<{
     versionId: z.ZodString;
@@ -392,8 +418,8 @@ export declare const runtimeDbMigrateResponseSchema: z.ZodObject<{
             code: z.ZodString;
             severity: z.ZodEnum<{
                 info: "info";
-                error: "error";
                 warning: "warning";
+                error: "error";
             }>;
             message: z.ZodString;
             path: z.ZodOptional<z.ZodNullable<z.ZodString>>;