@spacefast/common 0.0.2

package/dist/contracts/sites.d.ts

@@ -0,0 +1,393 @@
+import { z } from "zod";
+export declare const SiteCapacitySchema: z.ZodObject<{
+    maxSpaces: z.ZodOptional<z.ZodNumber>;
+    usedSpaces: z.ZodOptional<z.ZodNumber>;
+    storageBytes: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type SiteCapacity = z.infer<typeof SiteCapacitySchema>;
+export declare const SiteSchema: z.ZodObject<{
+    id: z.ZodString;
+    tenantId: z.ZodString;
+    principal: z.ZodNullable<z.ZodObject<{
+        tenantId: z.ZodString;
+        principalType: z.ZodEnum<{
+            external: "external";
+            team: "team";
+        }>;
+        principalId: z.ZodString;
+    }, z.core.$strip>>;
+    kind: z.ZodEnum<{
+        static_runtime: "static_runtime";
+    }>;
+    isolation: z.ZodEnum<{
+        space: "space";
+        site: "site";
+    }>;
+    status: z.ZodEnum<{
+        active: "active";
+        provisioning: "provisioning";
+        deleted: "deleted";
+        degraded: "degraded";
+        ready_pool: "ready_pool";
+        suspended: "suspended";
+    }>;
+    region: z.ZodString;
+    managementHostname: z.ZodNullable<z.ZodString>;
+    runtimeInstanceId: z.ZodNullable<z.ZodString>;
+    provider: z.ZodLiteral<"wpcloud">;
+    capacity: z.ZodNullable<z.ZodObject<{
+        maxSpaces: z.ZodOptional<z.ZodNumber>;
+        usedSpaces: z.ZodOptional<z.ZodNumber>;
+        storageBytes: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    operation: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodString;
+        status: z.ZodEnum<{
+            failed: "failed";
+            queued: "queued";
+            running: "running";
+            succeeded: "succeeded";
+            canceled: "canceled";
+        }>;
+        resources: z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$strip>>;
+        progress: z.ZodOptional<z.ZodObject<{
+            total: z.ZodNumber;
+            completed: z.ZodNumber;
+            failed: z.ZodNumber;
+        }, z.core.$strip>>;
+        diagnostics: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            severity: z.ZodEnum<{
+                info: "info";
+                warning: "warning";
+                error: "error";
+            }>;
+            message: z.ZodString;
+            path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                wpcloud: "wpcloud";
+                dns: "dns";
+                registrar: "registrar";
+                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>>>;
+        createdAt: z.ZodString;
+        finishedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type Site = z.infer<typeof SiteSchema>;
+export declare const siteProvisioningSchema: z.ZodOptional<z.ZodObject<{
+    importProviderSiteId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+export declare const siteCreateSchema: z.ZodObject<{
+    kind: z.ZodDefault<z.ZodEnum<{
+        static_runtime: "static_runtime";
+    }>>;
+    isolation: z.ZodDefault<z.ZodEnum<{
+        space: "space";
+        site: "site";
+    }>>;
+    region: z.ZodOptional<z.ZodString>;
+    provisioning: z.ZodOptional<z.ZodObject<{
+        importProviderSiteId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const siteListSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        tenantId: z.ZodString;
+        principal: z.ZodNullable<z.ZodObject<{
+            tenantId: z.ZodString;
+            principalType: z.ZodEnum<{
+                external: "external";
+                team: "team";
+            }>;
+            principalId: z.ZodString;
+        }, z.core.$strip>>;
+        kind: z.ZodEnum<{
+            static_runtime: "static_runtime";
+        }>;
+        isolation: z.ZodEnum<{
+            space: "space";
+            site: "site";
+        }>;
+        status: z.ZodEnum<{
+            active: "active";
+            provisioning: "provisioning";
+            deleted: "deleted";
+            degraded: "degraded";
+            ready_pool: "ready_pool";
+            suspended: "suspended";
+        }>;
+        region: z.ZodString;
+        managementHostname: z.ZodNullable<z.ZodString>;
+        runtimeInstanceId: z.ZodNullable<z.ZodString>;
+        provider: z.ZodLiteral<"wpcloud">;
+        capacity: z.ZodNullable<z.ZodObject<{
+            maxSpaces: z.ZodOptional<z.ZodNumber>;
+            usedSpaces: z.ZodOptional<z.ZodNumber>;
+            storageBytes: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        operation: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodString;
+            status: z.ZodEnum<{
+                failed: "failed";
+                queued: "queued";
+                running: "running";
+                succeeded: "succeeded";
+                canceled: "canceled";
+            }>;
+            resources: z.ZodArray<z.ZodObject<{
+                type: z.ZodString;
+                id: z.ZodString;
+            }, z.core.$strip>>;
+            progress: z.ZodOptional<z.ZodObject<{
+                total: z.ZodNumber;
+                completed: z.ZodNumber;
+                failed: z.ZodNumber;
+            }, z.core.$strip>>;
+            diagnostics: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                code: z.ZodString;
+                severity: z.ZodEnum<{
+                    info: "info";
+                    warning: "warning";
+                    error: "error";
+                }>;
+                message: z.ZodString;
+                path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                    wpcloud: "wpcloud";
+                    dns: "dns";
+                    registrar: "registrar";
+                    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>>>;
+            createdAt: z.ZodString;
+            finishedAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        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 siteListQuerySchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    cursor: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        static_runtime: "static_runtime";
+    }>>;
+}, z.core.$strip>;
+export declare const SuperadminSiteSchema: z.ZodObject<{
+    id: z.ZodString;
+    tenantId: z.ZodString;
+    principal: z.ZodNullable<z.ZodObject<{
+        tenantId: z.ZodString;
+        principalType: z.ZodEnum<{
+            external: "external";
+            team: "team";
+        }>;
+        principalId: z.ZodString;
+    }, z.core.$strip>>;
+    kind: z.ZodEnum<{
+        static_runtime: "static_runtime";
+    }>;
+    isolation: z.ZodEnum<{
+        space: "space";
+        site: "site";
+    }>;
+    status: z.ZodEnum<{
+        active: "active";
+        provisioning: "provisioning";
+        deleted: "deleted";
+        degraded: "degraded";
+        ready_pool: "ready_pool";
+        suspended: "suspended";
+    }>;
+    region: z.ZodString;
+    managementHostname: z.ZodNullable<z.ZodString>;
+    runtimeInstanceId: z.ZodNullable<z.ZodString>;
+    provider: z.ZodLiteral<"wpcloud">;
+    capacity: z.ZodNullable<z.ZodObject<{
+        maxSpaces: z.ZodOptional<z.ZodNumber>;
+        usedSpaces: z.ZodOptional<z.ZodNumber>;
+        storageBytes: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    operation: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodString;
+        status: z.ZodEnum<{
+            failed: "failed";
+            queued: "queued";
+            running: "running";
+            succeeded: "succeeded";
+            canceled: "canceled";
+        }>;
+        resources: z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$strip>>;
+        progress: z.ZodOptional<z.ZodObject<{
+            total: z.ZodNumber;
+            completed: z.ZodNumber;
+            failed: z.ZodNumber;
+        }, z.core.$strip>>;
+        diagnostics: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            severity: z.ZodEnum<{
+                info: "info";
+                warning: "warning";
+                error: "error";
+            }>;
+            message: z.ZodString;
+            path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                wpcloud: "wpcloud";
+                dns: "dns";
+                registrar: "registrar";
+                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>>>;
+        createdAt: z.ZodString;
+        finishedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    class: z.ZodEnum<{
+        anonymous_pool: "anonymous_pool";
+        shared_org: "shared_org";
+        dedicated_space: "dedicated_space";
+    }>;
+    providerClientId: z.ZodNullable<z.ZodString>;
+    providerRef: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const SuperadminSiteListSchema: z.ZodObject<{
+    sites: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        tenantId: z.ZodString;
+        principal: z.ZodNullable<z.ZodObject<{
+            tenantId: z.ZodString;
+            principalType: z.ZodEnum<{
+                external: "external";
+                team: "team";
+            }>;
+            principalId: z.ZodString;
+        }, z.core.$strip>>;
+        kind: z.ZodEnum<{
+            static_runtime: "static_runtime";
+        }>;
+        isolation: z.ZodEnum<{
+            space: "space";
+            site: "site";
+        }>;
+        status: z.ZodEnum<{
+            active: "active";
+            provisioning: "provisioning";
+            deleted: "deleted";
+            degraded: "degraded";
+            ready_pool: "ready_pool";
+            suspended: "suspended";
+        }>;
+        region: z.ZodString;
+        managementHostname: z.ZodNullable<z.ZodString>;
+        runtimeInstanceId: z.ZodNullable<z.ZodString>;
+        provider: z.ZodLiteral<"wpcloud">;
+        capacity: z.ZodNullable<z.ZodObject<{
+            maxSpaces: z.ZodOptional<z.ZodNumber>;
+            usedSpaces: z.ZodOptional<z.ZodNumber>;
+            storageBytes: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        operation: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodString;
+            status: z.ZodEnum<{
+                failed: "failed";
+                queued: "queued";
+                running: "running";
+                succeeded: "succeeded";
+                canceled: "canceled";
+            }>;
+            resources: z.ZodArray<z.ZodObject<{
+                type: z.ZodString;
+                id: z.ZodString;
+            }, z.core.$strip>>;
+            progress: z.ZodOptional<z.ZodObject<{
+                total: z.ZodNumber;
+                completed: z.ZodNumber;
+                failed: z.ZodNumber;
+            }, z.core.$strip>>;
+            diagnostics: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                code: z.ZodString;
+                severity: z.ZodEnum<{
+                    info: "info";
+                    warning: "warning";
+                    error: "error";
+                }>;
+                message: z.ZodString;
+                path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                    wpcloud: "wpcloud";
+                    dns: "dns";
+                    registrar: "registrar";
+                    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>>>;
+            createdAt: z.ZodString;
+            finishedAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        class: z.ZodEnum<{
+            anonymous_pool: "anonymous_pool";
+            shared_org: "shared_org";
+            dedicated_space: "dedicated_space";
+        }>;
+        providerClientId: z.ZodNullable<z.ZodString>;
+        providerRef: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const superadminSiteCreateSchema: z.ZodObject<{
+    kind: z.ZodDefault<z.ZodEnum<{
+        static_runtime: "static_runtime";
+    }>>;
+    isolation: z.ZodDefault<z.ZodEnum<{
+        space: "space";
+        site: "site";
+    }>>;
+    region: z.ZodOptional<z.ZodString>;
+    provisioning: z.ZodOptional<z.ZodObject<{
+        importProviderSiteId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    tenantId: z.ZodString;
+}, z.core.$strip>;
+export declare const siteRebalanceRequestSchema: z.ZodObject<{
+    spaceIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const SiteRebalanceResultSchema: z.ZodObject<{
+    siteId: z.ZodString;
+    moves: z.ZodArray<z.ZodObject<{
+        spaceId: z.ZodString;
+        operationId: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;

package/dist/contracts/sites.js

@@ -0,0 +1,121 @@
+import { z } from "zod";
+import { AsyncOperationSchema, CursorPaginationSchema, cursorListQuerySchema } from "./common.js";
+import { siteClass, siteIsolation, siteKind, siteStatus } from "./enums.js";
+import { PrincipalRefSchema } from "./resources.js";
+// Capacity accounting for shared-pool sites (internal-docs/platform.md "Site").
+// `usedSpaces` counts spaces currently placed on the site.
+export const SiteCapacitySchema = z
+    .object({
+    maxSpaces: z
+        .number()
+        .int()
+        .nonnegative()
+        .optional()
+        .describe("Maximum spaces this site may host."),
+    usedSpaces: z
+        .number()
+        .int()
+        .nonnegative()
+        .optional()
+        .describe("Spaces currently placed on this site."),
+    storageBytes: z
+        .number()
+        .int()
+        .nonnegative()
+        .optional()
+        .describe("Storage budget for the site in bytes."),
+})
+    .describe("Capacity accounting for shared-pool sites.");
+// A Site is THE placement unit (internal-docs/platform.md "Site", `site_`):
+// one WP.Cloud site per row. Spaces are placed onto a site via `space.siteId`.
+// Provider linkage (`providerClientId`, `providerRef`) is operator-only and
+// never appears in this tenant-facing shape.
+export const SiteSchema = z.object({
+    id: z.string().describe("Site id (`site_...`)."),
+    tenantId: z.string().describe("Owning tenant id (`ten_...`)."),
+    principal: PrincipalRefSchema.nullable().describe("Owning principal within the tenant; null for tenant-level and pool sites."),
+    kind: siteKind.describe("Runtime kind. Only the Spacefast static runtime exists today."),
+    isolation: siteIsolation.describe("Whether settings/access default to the site or to each space."),
+    status: siteStatus.describe("Site lifecycle status. `ready_pool` is a warm pre-provisioned pool site."),
+    region: z.string().describe('Placement region; `"auto"` lets placement decide.'),
+    managementHostname: z
+        .string()
+        .nullable()
+        .describe("Hostname the control plane manages the site runtime through."),
+    runtimeInstanceId: z.string().nullable().describe("Runtime instance identity for this site."),
+    provider: z.literal("wpcloud").describe("Hosting provider."),
+    capacity: SiteCapacitySchema.nullable().describe("Capacity accounting; null when the site has no explicit budget."),
+    operation: AsyncOperationSchema.nullable(),
+    createdAt: z.string().datetime(),
+    updatedAt: z.string().datetime(),
+});
+// How a site connects to WP.Cloud on creation: provision a fresh provider site
+// (optional region override, falling back to the tenant's WP.Cloud client
+// defaults), or import an existing one by its WP.Cloud site id (atomic_site_id).
+// Runtime-owned knobs such as filesystem mode, static miss handling, PHP
+// workers, and alias canonicalization are intentionally not exposed here; the
+// control plane sets them from Spacefast runtime invariants.
+export const siteProvisioningSchema = z
+    .object({
+    importProviderSiteId: z
+        .string()
+        .trim()
+        .min(1)
+        .optional()
+        .describe("Import an existing WP.Cloud site by its atomic_site_id (operator flows)."),
+})
+    .optional();
+export const siteCreateSchema = z.object({
+    kind: siteKind.default("static_runtime"),
+    isolation: siteIsolation.default("site"),
+    region: z.string().trim().min(1).optional().describe('Placement region; defaults to `"auto"`.'),
+    provisioning: siteProvisioningSchema,
+});
+export const siteListSchema = z.object({
+    data: z.array(SiteSchema),
+    pagination: CursorPaginationSchema,
+});
+export const siteListQuerySchema = cursorListQuerySchema.extend({
+    kind: siteKind.optional().describe("Filter to sites with this runtime kind."),
+});
+// Superadmin site view: the tenant SiteSchema plus the internal provider
+// linkage and placement class (hidden from tenant callers).
+export const SuperadminSiteSchema = SiteSchema.extend({
+    class: siteClass.describe("Placement class: pool partition, shared team site, or dedicated."),
+    providerClientId: z
+        .string()
+        .nullable()
+        .describe("WP.Cloud client identity (`pvc_...`) the site is provisioned under."),
+    providerRef: z.string().nullable().describe("WP.Cloud atomic_site_id."),
+});
+export const SuperadminSiteListSchema = z.object({
+    sites: z.array(SuperadminSiteSchema),
+});
+// Superadmin site create targets an explicit tenant (the tenant-facing
+// `siteCreateSchema` derives the tenant from the principal).
+export const superadminSiteCreateSchema = siteCreateSchema.extend({
+    tenantId: z.string().trim().min(1),
+});
+// Operator rebalance trigger (internal-docs/platform.md "Space placement and
+// moves": operator rebalancing is a move trigger). Queues `space_move`
+// operations off the site for the selected (default: all) live spaces.
+export const siteRebalanceRequestSchema = z
+    .object({
+    spaceIds: z
+        .array(z.string().trim().min(1))
+        .max(100)
+        .optional()
+        .describe("Limit the rebalance to these space ids; omitted means every live space on the site."),
+})
+    .describe("Operator-only rebalance trigger: move spaces off this site.");
+export const SiteRebalanceResultSchema = z
+    .object({
+    siteId: z.string().describe("The site spaces are being moved off."),
+    moves: z
+        .array(z.object({
+        spaceId: z.string().describe("Space queued to move."),
+        operationId: z.string().describe("The queued `space_move` operation id (`op_...`)."),
+    }))
+        .describe("One queued move operation per affected space."),
+})
+    .describe("Queued rebalance moves; track each operation for completion.");

package/dist/contracts/slugs.d.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+export declare const slugResourceKindValues: readonly ["team", "space"];
+export declare const slugResourceKind: z.ZodEnum<{
+    space: "space";
+    team: "team";
+}>;
+export declare const slugAvailabilityQuerySchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        space: "space";
+        team: "team";
+    }>;
+    slug: z.ZodDefault<z.ZodString>;
+    currentSlug: z.ZodOptional<z.ZodString>;
+    teamId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const slugAvailabilityResponseSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        space: "space";
+        team: "team";
+    }>;
+    normalizedSlug: z.ZodString;
+    available: z.ZodBoolean;
+    suggestion: z.ZodNullable<z.ZodString>;
+    hostnameAvailable: z.ZodOptional<z.ZodBoolean>;
+    hostnameSuggestion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    selectedHostname: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    hostnameConflictReason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    globalHostnameAvailable: z.ZodOptional<z.ZodBoolean>;
+    globalHostname: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    globalHostnameSuggestion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;

package/dist/contracts/slugs.js

@@ -0,0 +1,47 @@
+import { z } from "zod";
+export const slugResourceKindValues = ["team", "space"];
+export const slugResourceKind = z.enum(slugResourceKindValues);
+export const slugAvailabilityQuerySchema = z.object({
+    kind: slugResourceKind,
+    slug: z.string().default(""),
+    currentSlug: z.string().optional(),
+    teamId: z.string().optional(),
+});
+export const slugAvailabilityResponseSchema = z.object({
+    kind: slugResourceKind.describe("Resource kind the slug was checked for."),
+    normalizedSlug: z.string().describe("Slug after normalization; empty when nothing usable."),
+    available: z.boolean().describe("Whether the normalized slug can be used as-is."),
+    suggestion: z
+        .string()
+        .nullable()
+        .describe("Closest available slug when the requested one is taken; null when available."),
+    hostnameAvailable: z
+        .boolean()
+        .optional()
+        .describe("Whether the normalized slug's managed view.fast hostname can be used as-is."),
+    hostnameSuggestion: z
+        .string()
+        .nullable()
+        .optional()
+        .describe("Closest available public name when the managed hostname is taken."),
+    selectedHostname: z
+        .string()
+        .nullable()
+        .optional()
+        .describe("Managed view.fast hostname selected for the requested slug."),
+    hostnameConflictReason: z
+        .string()
+        .nullable()
+        .optional()
+        .describe("Stable reason code for the selected hostname conflict, when unavailable."),
+    globalHostnameAvailable: z
+        .boolean()
+        .optional()
+        .describe("Whether `{slug}.view.fast` is available."),
+    globalHostname: z.string().nullable().optional().describe("The global managed hostname checked."),
+    globalHostnameSuggestion: z
+        .string()
+        .nullable()
+        .optional()
+        .describe("Closest available global public name when `{slug}.view.fast` is taken."),
+});