@spacefast/common 0.0.23 → 0.0.26

package/dist/config/postgres-budget.js

@@ -1,140 +0,0 @@
-import { z } from "zod";
-import budgetJson from "./postgres-budget.json" with { type: "json" };
-const serviceBudgetSchema = z.object({
-    enabledInProduction: z.boolean(),
-    replicas: z.number().int().nonnegative(),
-    poolConnectionsPerReplica: z.number().int().positive(),
-    fixedConnectionsPerReplica: z.number().int().nonnegative(),
-    maxPinnedTransactionsPerReplica: z.number().int().nonnegative(),
-    rolloutOverlapReplicas: z.number().int().nonnegative(),
-    connectionBudget: z.string().min(1),
-});
-const postgresConnectionBudgetSchema = z
-    .object({
-    server: z.object({
-        maxConnections: z.number().int().positive(),
-        superuserReservedConnections: z.number().int().nonnegative(),
-    }),
-    migrationConnections: z.number().int().positive(),
-    operationalReserveConnections: z.number().int().nonnegative(),
-    transactionPools: z.record(z.string().min(1), z.object({
-        serverConnections: z.number().int().positive(),
-    })),
-    services: z.object({
-        api: serviceBudgetSchema,
-        worker: serviceBudgetSchema,
-        cast: serviceBudgetSchema,
-        scanWorker: serviceBudgetSchema,
-    }),
-})
-    .superRefine((plan, context) => {
-    for (const [serviceName, service] of Object.entries(plan.services)) {
-        if (service.connectionBudget !== "direct" &&
-            !Object.hasOwn(plan.transactionPools, service.connectionBudget)) {
-            context.addIssue({
-                code: "custom",
-                message: `service ${serviceName} references unknown transaction pool ${service.connectionBudget}`,
-                path: ["services", serviceName, "connectionBudget"],
-            });
-        }
-    }
-    for (const [poolName, pool] of Object.entries(plan.transactionPools)) {
-        const maxPinnedTransactions = Object.values(plan.services)
-            .filter((service) => service.enabledInProduction && service.connectionBudget === poolName)
-            .reduce((total, service) => total +
-            (service.replicas + service.rolloutOverlapReplicas) *
-                service.maxPinnedTransactionsPerReplica, 0);
-        if (maxPinnedTransactions >= pool.serverConnections) {
-            context.addIssue({
-                code: "custom",
-                message: `transaction pool ${poolName} can pin ${maxPinnedTransactions}/${pool.serverConnections} server connections, leaving no callback query capacity`,
-                path: ["transactionPools", poolName, "serverConnections"],
-            });
-        }
-    }
-});
-export const POSTGRES_CONNECTION_BUDGET = postgresConnectionBudgetSchema.parse(budgetJson);
-function serviceFootprint(service) {
-    return service.poolConnectionsPerReplica + service.fixedConnectionsPerReplica;
-}
-export function calculatePostgresConnectionBudget(plan, server = plan.server) {
-    const usableServerConnections = server.maxConnections - server.superuserReservedConnections;
-    if (usableServerConnections <= 0) {
-        throw new Error(`postgres_connection_budget_invalid: maxConnections=${server.maxConnections} must exceed superuserReservedConnections=${server.superuserReservedConnections}`);
-    }
-    const directServices = Object.values(plan.services).filter((service) => service.enabledInProduction && service.connectionBudget === "direct");
-    const directSteadyConnections = directServices.reduce((total, service) => total + service.replicas * serviceFootprint(service), 0);
-    const transactionPoolConnections = Object.values(plan.transactionPools).reduce((total, pool) => total + pool.serverConnections, 0);
-    const transactionPoolPinnedConnections = Object.values(plan.services)
-        .filter((service) => service.enabledInProduction && service.connectionBudget !== "direct")
-        .reduce((total, service) => total +
-        (service.replicas + service.rolloutOverlapReplicas) *
-            service.maxPinnedTransactionsPerReplica, 0);
-    const transactionPoolQueryHeadroom = transactionPoolConnections - transactionPoolPinnedConnections;
-    const steadyConnections = directSteadyConnections + transactionPoolConnections;
-    const rollingDeploySurgeConnections = directServices.reduce((total, service) => total + service.rolloutOverlapReplicas * serviceFootprint(service), 0);
-    const plannedConnections = steadyConnections +
-        rollingDeploySurgeConnections +
-        plan.migrationConnections +
-        plan.operationalReserveConnections;
-    return {
-        usableServerConnections,
-        directSteadyConnections,
-        transactionPoolConnections,
-        transactionPoolPinnedConnections,
-        transactionPoolQueryHeadroom,
-        steadyConnections,
-        rollingDeploySurgeConnections,
-        migrationConnections: plan.migrationConnections,
-        operationalReserveConnections: plan.operationalReserveConnections,
-        plannedConnections,
-        unallocatedConnections: usableServerConnections - plannedConnections,
-    };
-}
-export function assertPostgresServiceConnectionUrl(service, rawUrl, options = {}) {
-    const parsed = new URL(rawUrl);
-    const hostname = parsed.hostname.toLowerCase();
-    const isLocalDevelopmentHost = hostname === "localhost" ||
-        hostname === "127.0.0.1" ||
-        hostname === "::1" ||
-        hostname === "[::1]" ||
-        (!hostname.includes(".") && !hostname.includes(":"));
-    if (options.allowDirectDevelopmentConnection && isLocalDevelopmentHost) {
-        return;
-    }
-    const serviceBudget = POSTGRES_CONNECTION_BUDGET.services[service];
-    if (!serviceBudget.enabledInProduction) {
-        throw new Error(`postgres_connection_budget_service_disabled: service=${service}; add its replicas and rollout overlap to the shared budget before production startup`);
-    }
-    const connectionBudget = serviceBudget.connectionBudget;
-    const port = parsed.port || "5432";
-    if (connectionBudget === "direct") {
-        if (port !== "5432") {
-            throw new Error(`postgres_connection_budget_url_mismatch: service=${service} planned=direct port=${port}`);
-        }
-        return;
-    }
-    if (port !== "6432") {
-        throw new Error(`postgres_connection_budget_url_mismatch: service=${service} planned=transaction_pool pool=${connectionBudget} port=${port}`);
-    }
-}
-export function assertPostgresServicePoolBudget(service, configuredPoolConnections) {
-    const expected = POSTGRES_CONNECTION_BUDGET.services[service].poolConnectionsPerReplica;
-    if (configuredPoolConnections !== expected) {
-        throw new Error(`postgres_connection_budget_pool_mismatch: service=${service} configured=${configuredPoolConnections} planned=${expected}; update the shared budget and every affected service in one change`);
-    }
-}
-export function assertPostgresServiceNamedLockBudget(service, configuredNamedLockTransactions) {
-    const expected = POSTGRES_CONNECTION_BUDGET.services[service].maxPinnedTransactionsPerReplica;
-    if (configuredNamedLockTransactions !== expected) {
-        throw new Error(`postgres_connection_budget_named_lock_mismatch: service=${service} configured=${configuredNamedLockTransactions} planned=${expected}`);
-    }
-}
-export function assertPostgresServerBudget(server) {
-    const summary = calculatePostgresConnectionBudget(POSTGRES_CONNECTION_BUDGET, server);
-    if (summary.unallocatedConnections < 0) {
-        throw new Error(`postgres_connection_budget_exceeded: planned=${summary.plannedConnections} usable=${summary.usableServerConnections} max=${server.maxConnections} superuserReserved=${server.superuserReservedConnections}`);
-    }
-    return summary;
-}
-export const POSTGRES_CONNECTION_BUDGET_SUMMARY = assertPostgresServerBudget(POSTGRES_CONNECTION_BUDGET.server);

package/dist/config/postgres-budget.json

@@ -1,51 +0,0 @@
-{
-    "server": {
-        "maxConnections": 25,
-        "superuserReservedConnections": 3
-    },
-    "migrationConnections": 1,
-    "operationalReserveConnections": 4,
-    "transactionPools": {
-        "controlPlaneRuntime": {
-            "serverConnections": 7
-        }
-    },
-    "services": {
-        "api": {
-            "enabledInProduction": true,
-            "replicas": 2,
-            "poolConnectionsPerReplica": 4,
-            "fixedConnectionsPerReplica": 0,
-            "maxPinnedTransactionsPerReplica": 1,
-            "rolloutOverlapReplicas": 1,
-            "connectionBudget": "controlPlaneRuntime"
-        },
-        "worker": {
-            "enabledInProduction": true,
-            "replicas": 1,
-            "poolConnectionsPerReplica": 4,
-            "fixedConnectionsPerReplica": 0,
-            "maxPinnedTransactionsPerReplica": 1,
-            "rolloutOverlapReplicas": 1,
-            "connectionBudget": "controlPlaneRuntime"
-        },
-        "cast": {
-            "enabledInProduction": true,
-            "replicas": 1,
-            "poolConnectionsPerReplica": 4,
-            "fixedConnectionsPerReplica": 1,
-            "maxPinnedTransactionsPerReplica": 0,
-            "rolloutOverlapReplicas": 1,
-            "connectionBudget": "direct"
-        },
-        "scanWorker": {
-            "enabledInProduction": false,
-            "replicas": 0,
-            "poolConnectionsPerReplica": 2,
-            "fixedConnectionsPerReplica": 0,
-            "maxPinnedTransactionsPerReplica": 1,
-            "rolloutOverlapReplicas": 0,
-            "connectionBudget": "controlPlaneRuntime"
-        }
-    }
-}

package/dist/contracts/archives.d.ts

@@ -1,331 +0,0 @@
-import { z } from "zod";
-export declare const archiveListQuerySchema: z.ZodObject<{
-    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-    cursor: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export declare const spaceExportRequestSchema: z.ZodObject<{
-    versionIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    includeFiles: z.ZodDefault<z.ZodBoolean>;
-}, z.core.$strict>;
-export declare const spaceExportArchiveSchema: z.ZodObject<{
-    contentType: z.ZodLiteral<"application/zip">;
-    downloadUrl: z.ZodString;
-    expiresAt: z.ZodString;
-    sizeBytes: z.ZodOptional<z.ZodNumber>;
-    sha256: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export declare const spaceExportSchema: z.ZodObject<{
-    id: z.ZodString;
-    spaceId: z.ZodString;
-    status: z.ZodEnum<{
-        failed: "failed";
-        expired: "expired";
-        ready: "ready";
-        queued: "queued";
-        running: "running";
-    }>;
-    format: z.ZodLiteral<"spacefast_export_v1">;
-    diagnostics: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        code: z.ZodString;
-        severity: z.ZodEnum<{
-            info: "info";
-            error: "error";
-            warning: "warning";
-        }>;
-        message: z.ZodString;
-        path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-            registrar: "registrar";
-            wpcloud: "wpcloud";
-            dns: "dns";
-            runtime: "runtime";
-        }>>>;
-        details: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-        fix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        retryable: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
-    }, z.core.$strip>>>;
-    archive: z.ZodOptional<z.ZodObject<{
-        contentType: z.ZodLiteral<"application/zip">;
-        downloadUrl: z.ZodString;
-        expiresAt: z.ZodString;
-        sizeBytes: z.ZodOptional<z.ZodNumber>;
-        sha256: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    operationId: z.ZodNullable<z.ZodString>;
-    createdAt: z.ZodString;
-    updatedAt: z.ZodString;
-}, z.core.$strip>;
-export declare const spaceExportListResponseSchema: z.ZodObject<{
-    data: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        spaceId: z.ZodString;
-        status: z.ZodEnum<{
-            failed: "failed";
-            expired: "expired";
-            ready: "ready";
-            queued: "queued";
-            running: "running";
-        }>;
-        format: z.ZodLiteral<"spacefast_export_v1">;
-        diagnostics: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            code: z.ZodString;
-            severity: z.ZodEnum<{
-                info: "info";
-                error: "error";
-                warning: "warning";
-            }>;
-            message: z.ZodString;
-            path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-                registrar: "registrar";
-                wpcloud: "wpcloud";
-                dns: "dns";
-                runtime: "runtime";
-            }>>>;
-            details: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-            fix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            retryable: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
-        }, z.core.$strip>>>;
-        archive: z.ZodOptional<z.ZodObject<{
-            contentType: z.ZodLiteral<"application/zip">;
-            downloadUrl: z.ZodString;
-            expiresAt: z.ZodString;
-            sizeBytes: z.ZodOptional<z.ZodNumber>;
-            sha256: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        operationId: z.ZodNullable<z.ZodString>;
-        createdAt: z.ZodString;
-        updatedAt: z.ZodString;
-    }, z.core.$strip>>;
-    pagination: z.ZodObject<{
-        nextCursor: z.ZodNullable<z.ZodString>;
-        hasMore: z.ZodBoolean;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export declare const spaceImportSourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    kind: z.ZodLiteral<"upload">;
-}, z.core.$strip>, z.ZodObject<{
-    kind: z.ZodLiteral<"url">;
-    url: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    kind: z.ZodLiteral<"export">;
-    exportId: z.ZodString;
-}, z.core.$strip>], "kind">;
-export declare const spaceImportRequestSchema: z.ZodObject<{
-    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"upload">;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"url">;
-        url: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"export">;
-        exportId: z.ZodString;
-    }, z.core.$strip>], "kind">;
-    publish: z.ZodDefault<z.ZodBoolean>;
-}, z.core.$strip>;
-export declare const spaceImportSchema: z.ZodObject<{
-    id: z.ZodString;
-    targetSpaceId: z.ZodString;
-    status: z.ZodEnum<{
-        failed: "failed";
-        canceled: "canceled";
-        created: "created";
-        ready: "ready";
-        waiting_for_archive: "waiting_for_archive";
-        validating: "validating";
-        materializing: "materializing";
-    }>;
-    archiveUpload: z.ZodOptional<z.ZodObject<{
-        id: z.ZodString;
-        mode: z.ZodEnum<{
-            source: "source";
-            dist: "dist";
-        }>;
-        expiresAt: z.ZodString;
-        summary: z.ZodObject<{
-            upload: z.ZodNumber;
-            reused: z.ZodNumber;
-            ignored: z.ZodNumber;
-        }, z.core.$strip>;
-        targets: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            path: z.ZodString;
-            method: z.ZodEnum<{
-                POST: "POST";
-                PUT: "PUT";
-            }>;
-            url: z.ZodUnion<[z.ZodString, z.ZodString]>;
-            headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
-            body: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-                kind: z.ZodLiteral<"url">;
-                url: z.ZodString;
-            }, z.core.$strip>], "kind">>;
-            size: z.ZodOptional<z.ZodNumber>;
-            maxBytes: z.ZodOptional<z.ZodNumber>;
-            sha256: z.ZodOptional<z.ZodString>;
-            contentType: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>>;
-        links: z.ZodObject<{
-            resume: z.ZodString;
-            finalize: z.ZodString;
-        }, z.core.$strip>;
-        details: z.ZodOptional<z.ZodObject<{
-            reused: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                path: z.ZodString;
-                reason: z.ZodString;
-            }, z.core.$strip>>>;
-            ignored: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                path: z.ZodString;
-                reason: z.ZodString;
-            }, z.core.$strip>>>;
-            diagnostics: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                code: z.ZodString;
-                severity: z.ZodEnum<{
-                    info: "info";
-                    error: "error";
-                    warning: "warning";
-                }>;
-                message: z.ZodString;
-                path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-                    registrar: "registrar";
-                    wpcloud: "wpcloud";
-                    dns: "dns";
-                    runtime: "runtime";
-                }>>>;
-                details: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-                fix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                retryable: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
-            }, z.core.$strip>>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    draftVersionIds: z.ZodArray<z.ZodString>;
-    diagnostics: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        code: z.ZodString;
-        severity: z.ZodEnum<{
-            info: "info";
-            error: "error";
-            warning: "warning";
-        }>;
-        message: z.ZodString;
-        path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-            registrar: "registrar";
-            wpcloud: "wpcloud";
-            dns: "dns";
-            runtime: "runtime";
-        }>>>;
-        details: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-        fix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        retryable: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
-    }, z.core.$strip>>>;
-    operationId: z.ZodNullable<z.ZodString>;
-    createdAt: z.ZodString;
-    updatedAt: z.ZodString;
-}, z.core.$strip>;
-export declare const spaceImportListResponseSchema: z.ZodObject<{
-    data: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        targetSpaceId: z.ZodString;
-        status: z.ZodEnum<{
-            failed: "failed";
-            canceled: "canceled";
-            created: "created";
-            ready: "ready";
-            waiting_for_archive: "waiting_for_archive";
-            validating: "validating";
-            materializing: "materializing";
-        }>;
-        archiveUpload: z.ZodOptional<z.ZodObject<{
-            id: z.ZodString;
-            mode: z.ZodEnum<{
-                source: "source";
-                dist: "dist";
-            }>;
-            expiresAt: z.ZodString;
-            summary: z.ZodObject<{
-                upload: z.ZodNumber;
-                reused: z.ZodNumber;
-                ignored: z.ZodNumber;
-            }, z.core.$strip>;
-            targets: z.ZodDefault<z.ZodArray<z.ZodObject<{
-                path: z.ZodString;
-                method: z.ZodEnum<{
-                    POST: "POST";
-                    PUT: "PUT";
-                }>;
-                url: z.ZodUnion<[z.ZodString, z.ZodString]>;
-                headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
-                body: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-                    kind: z.ZodLiteral<"url">;
-                    url: z.ZodString;
-                }, z.core.$strip>], "kind">>;
-                size: z.ZodOptional<z.ZodNumber>;
-                maxBytes: z.ZodOptional<z.ZodNumber>;
-                sha256: z.ZodOptional<z.ZodString>;
-                contentType: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>>;
-            links: z.ZodObject<{
-                resume: z.ZodString;
-                finalize: z.ZodString;
-            }, z.core.$strip>;
-            details: z.ZodOptional<z.ZodObject<{
-                reused: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    path: z.ZodString;
-                    reason: z.ZodString;
-                }, z.core.$strip>>>;
-                ignored: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    path: z.ZodString;
-                    reason: z.ZodString;
-                }, z.core.$strip>>>;
-                diagnostics: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    code: z.ZodString;
-                    severity: z.ZodEnum<{
-                        info: "info";
-                        error: "error";
-                        warning: "warning";
-                    }>;
-                    message: z.ZodString;
-                    path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                    provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-                        registrar: "registrar";
-                        wpcloud: "wpcloud";
-                        dns: "dns";
-                        runtime: "runtime";
-                    }>>>;
-                    details: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-                    fix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                    retryable: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
-                }, z.core.$strip>>>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>>;
-        draftVersionIds: z.ZodArray<z.ZodString>;
-        diagnostics: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            code: z.ZodString;
-            severity: z.ZodEnum<{
-                info: "info";
-                error: "error";
-                warning: "warning";
-            }>;
-            message: z.ZodString;
-            path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-                registrar: "registrar";
-                wpcloud: "wpcloud";
-                dns: "dns";
-                runtime: "runtime";
-            }>>>;
-            details: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-            fix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            retryable: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
-        }, z.core.$strip>>>;
-        operationId: z.ZodNullable<z.ZodString>;
-        createdAt: z.ZodString;
-        updatedAt: z.ZodString;
-    }, z.core.$strip>>;
-    pagination: z.ZodObject<{
-        nextCursor: z.ZodNullable<z.ZodString>;
-        hasMore: z.ZodBoolean;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export type SpaceExport = z.infer<typeof spaceExportSchema>;
-export type SpaceImport = z.infer<typeof spaceImportSchema>;

package/dist/contracts/archives.js

@@ -1,120 +0,0 @@
-import { z } from "zod";
-import { baseDiagnosticSchema, CursorPaginationSchema, cursorListQuerySchema } from "./common.js";
-import { uploadInstructionsSchema } from "./internal.js";
-export const archiveListQuerySchema = cursorListQuerySchema;
-export const spaceExportRequestSchema = z
-    .object({
-    versionIds: z
-        .array(z.string().min(1))
-        .min(1)
-        .optional()
-        .describe("Version ids (ver_…) to export. Every id must belong to the space; omit to export all versions."),
-    includeFiles: z
-        .boolean()
-        .default(true)
-        .describe("Pass `true` to include version file trees and compiled serving artifacts. Pass `false` for a config-only archive that is not self-servable and cannot be re-imported."),
-})
-    .strict();
-export const spaceExportArchiveSchema = z.object({
-    // Zip-only contract: spacefast_export_v1 archives are always zip (the spec
-    // allows "zip or tar"; one format keeps the enum honest).
-    contentType: z.literal("application/zip").describe("Archive media type. Always zip."),
-    downloadUrl: z
-        .string()
-        .describe("API-relative URL streaming the archive while it has not expired."),
-    expiresAt: z
-        .string()
-        .datetime()
-        .describe("When the archive download expires; the export flips to `expired` afterwards."),
-    sizeBytes: z.number().int().nonnegative().optional().describe("Archive size in bytes."),
-    sha256: z
-        .string()
-        .optional()
-        .describe("SHA-256 of the archive bytes (64 lowercase hex characters), for verification."),
-});
-export const spaceExportSchema = z.object({
-    id: z.string().describe("The export handle id (`exp_…`)."),
-    spaceId: z.string().describe("The source space id (`spc_…`)."),
-    status: z
-        .enum(["queued", "running", "ready", "failed", "expired"])
-        .describe("Export lifecycle. `expired` means the archive download window has passed."),
-    format: z
-        .literal("spacefast_export_v1")
-        .describe("Archive format identifier. Always `spacefast_export_v1`."),
-    diagnostics: z
-        .array(baseDiagnosticSchema)
-        .default([])
-        .describe("Diagnostics collected while producing the export."),
-    archive: spaceExportArchiveSchema
-        .optional()
-        .describe("Archive download details; present only while status is `ready`."),
-    operationId: z
-        .string()
-        .nullable()
-        .describe("Operation (op_…) tracking the asynchronous export work."),
-    createdAt: z.string().datetime().describe("Instant when the export handle was created."),
-    updatedAt: z.string().datetime().describe("Instant when the export handle last changed."),
-});
-export const spaceExportListResponseSchema = z.object({
-    data: z.array(spaceExportSchema),
-    pagination: CursorPaginationSchema,
-});
-export const spaceImportSourceSchema = z
-    .discriminatedUnion("kind", [
-    z.object({
-        kind: z
-            .literal("upload")
-            .describe("Upload an archive; the response carries `archiveUpload` instructions."),
-    }),
-    z.object({
-        kind: z.literal("url").describe("Fetch the archive from a public HTTPS URL."),
-        url: z.string().url().describe("Public HTTPS URL of a spacefast_export_v1 archive."),
-    }),
-    z.object({
-        kind: z.literal("export").describe("Import directly from an export on this control plane."),
-        exportId: z.string().min(1).describe("Source export id (exp_…) accessible to the caller."),
-    }),
-])
-    .describe("Where the spacefast_export_v1 archive comes from.");
-export const spaceImportRequestSchema = z.object({
-    source: spaceImportSourceSchema,
-    publish: z
-        .boolean()
-        .default(false)
-        .describe("Pass `true` to promote the newest imported version to the live channel after it materializes. Imported versions never go public implicitly."),
-});
-export const spaceImportSchema = z.object({
-    id: z.string().describe("The import handle id (`imp_…`)."),
-    targetSpaceId: z.string().describe("The target space id (`spc_…`) the import materializes into."),
-    status: z
-        .enum([
-        "created",
-        "waiting_for_archive",
-        "validating",
-        "materializing",
-        "ready",
-        "failed",
-        "canceled",
-    ])
-        .describe("Import lifecycle. Upload-kind imports wait in `waiting_for_archive` until the archive is uploaded and the import is finalized."),
-    archiveUpload: uploadInstructionsSchema
-        .optional()
-        .describe("Archive upload instructions. This is the same upload contract as publish. Present while status is `waiting_for_archive`: PUT the archive to `{baseUrl}/{files[0]}` with the session token, then POST `links.finalize`. Each fetch of the import mints a fresh token."),
-    draftVersionIds: z
-        .array(z.string())
-        .describe("Version ids (ver_…) minted and owned by this import."),
-    diagnostics: z
-        .array(baseDiagnosticSchema)
-        .default([])
-        .describe("Diagnostics collected during validation and materialization, including warnings for imported config overridden by the target space/parent policy."),
-    operationId: z
-        .string()
-        .nullable()
-        .describe("Operation (op_…) tracking the asynchronous import work."),
-    createdAt: z.string().datetime().describe("Instant when the import handle was created."),
-    updatedAt: z.string().datetime().describe("Instant when the import handle last changed."),
-});
-export const spaceImportListResponseSchema = z.object({
-    data: z.array(spaceImportSchema),
-    pagination: CursorPaginationSchema,
-});