@spacefast/common 0.2.1 → 0.4.1

package/dist/contracts/source-workspaces.js

@@ -0,0 +1,276 @@
+import { z } from "zod";
+import { CursorPaginationSchema, cursorListQuerySchema } from "./common.js";
+export const sourceCommitShaSchema = z.string().regex(/^[a-f0-9]{40}$/i);
+export const sourceWorkspacePathSchema = z
+    .string()
+    .min(1)
+    .max(4096)
+    .refine((path) => !/[\\\p{Cc}]/u.test(path) &&
+    !path
+        .split("/")
+        .some((part) => !part || part === "." || part === ".." || part.toLowerCase() === ".git"), { message: "Use a repository-relative file path. Do not use dot segments or a leading slash." });
+export const sourceWorkspaceAuthorSchema = z.object({
+    name: z.string().trim().min(1),
+    email: z.string().email(),
+});
+function validateSourceContents(input, context) {
+    if (input.contents === undefined)
+        return;
+    const encoding = input.encoding ?? "utf8";
+    const contents = input.contents;
+    if (encoding === "base64" &&
+        !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(contents)) {
+        context.addIssue({
+            code: "custom",
+            path: ["contents"],
+            message: "Use complete valid base64 contents. Include required padding.",
+        });
+    }
+    if (encoding === "hex" && (contents.length % 2 !== 0 || !/^[a-f0-9]*$/i.test(contents))) {
+        context.addIssue({
+            code: "custom",
+            path: ["contents"],
+            message: "Use hexadecimal byte pairs. Do not omit a digit.",
+        });
+    }
+    if (encoding === "utf8" && new TextEncoder().encode(contents).byteLength > 1024 * 1024) {
+        context.addIssue({
+            code: "custom",
+            path: ["contents"],
+            message: "Complete file contents must be at most 1 MiB.",
+        });
+    }
+}
+export const sourceWorkspaceFileOperationSchema = z.discriminatedUnion("action", [
+    z
+        .object({
+        action: z.literal("upsert"),
+        path: sourceWorkspacePathSchema,
+        contents: z
+            .string()
+            .max(1024 * 1024)
+            .describe("Complete file contents. Omitted files do not change."),
+        encoding: z.enum(["utf8", "base64", "hex"]).optional(),
+        mode: z.enum(["100644", "100755", "120000", "160000"]).optional(),
+    })
+        .superRefine(validateSourceContents),
+    z.object({ action: z.literal("delete"), path: sourceWorkspacePathSchema }),
+]);
+const operationId = z
+    .string()
+    .trim()
+    .min(1)
+    .max(128)
+    .describe("Unique ID for this operation. Reuse this ID and the same input after an uncertain response.");
+export const sourceWorkspaceMutationSchema = z.object({
+    expectedRevision: z
+        .number()
+        .int()
+        .nonnegative()
+        .describe("Revision from the last workspace response. Read the workspace again after a revision conflict."),
+    operationId,
+});
+export const sourceWorkspaceCreateSchema = z.object({
+    operationId,
+    name: z.string().trim().min(1).max(160).optional(),
+    targetBranch: z
+        .string()
+        .trim()
+        .min(1)
+        .max(255)
+        .optional()
+        .describe("Existing project branch. Defaults to the production branch."),
+    originalUploadVersionId: z
+        .string()
+        .min(1)
+        .max(64)
+        .optional()
+        .describe("Pinned eligible direct upload to import if this Space has no saved source. Omit to import the current eligible direct upload automatically. Never send a build output version."),
+    author: sourceWorkspaceAuthorSchema
+        .optional()
+        .describe("Omit to use the registered name and email. If they are incomplete, send the author once when you create the workspace. This affects attribution only."),
+});
+export const sourceWorkspaceEditSchema = sourceWorkspaceMutationSchema.extend({
+    operations: z
+        .array(sourceWorkspaceFileOperationSchema)
+        .min(1)
+        .max(100)
+        .refine((operations) => new Set(operations.map((operation) => operation.path)).size === operations.length, { message: "Use each file path once per operation." }),
+});
+export const sourceWorkspaceSelectionSchema = sourceWorkspaceMutationSchema
+    .extend({
+    paths: z.array(sourceWorkspacePathSchema).min(1).max(1000).optional(),
+    hunkIds: z
+        .array(z.string().min(1))
+        .min(1)
+        .max(1000)
+        .optional()
+        .describe("Exact hunk IDs from the current diff. Do not construct or reuse stale IDs."),
+    all: z.literal(true).optional(),
+})
+    .refine((input) => [input.paths, input.hunkIds, input.all].filter((value) => value !== undefined).length === 1, { message: "Send paths, hunkIds, or all. Send only one selection." });
+export const sourceWorkspaceCommitSchema = sourceWorkspaceMutationSchema.extend({
+    message: z.string().trim().min(1).max(4096),
+    author: sourceWorkspaceAuthorSchema
+        .optional()
+        .describe("Omit to reuse the author stored when the workspace was created."),
+});
+export const sourceWorkspaceRestoreSchema = sourceWorkspaceMutationSchema.extend({
+    paths: z.array(sourceWorkspacePathSchema).min(1).max(1000),
+    sourceCommitSha: sourceCommitShaSchema
+        .optional()
+        .describe("Saved source commit to copy from. Omit to copy from the staged snapshot. Staging does not change."),
+});
+export const sourceWorkspaceUndoSchema = sourceWorkspaceMutationSchema.extend({
+    sourceCommitSha: sourceCommitShaSchema.describe("Non-merge source commit to undo in working files. This does not commit or deploy."),
+});
+export const sourceWorkspaceCloseSchema = sourceWorkspaceMutationSchema.extend({
+    discardPending: z
+        .boolean()
+        .default(false)
+        .describe("Set true only when the user requests discarding pending changes."),
+});
+export const sourceWorkspaceResolutionSchema = z.union([
+    z
+        .object({
+        path: sourceWorkspacePathSchema,
+        contents: z
+            .string()
+            .max(1024 * 1024)
+            .describe("Complete file contents for this resolution."),
+        encoding: z
+            .enum(["utf8", "base64", "hex"])
+            .optional()
+            .describe("Encoding of contents. Omit it for UTF-8."),
+        mode: z
+            .enum(["100644", "100755", "120000", "160000"])
+            .optional()
+            .describe("File mode for contents. Omit it to keep the current mode."),
+    })
+        .strict()
+        .superRefine(validateSourceContents),
+    z
+        .object({
+        path: sourceWorkspacePathSchema,
+        delete: z
+            .literal(true)
+            .describe("Delete this path. Do not send contents, encoding, or mode."),
+    })
+        .strict(),
+    z
+        .object({
+        path: sourceWorkspacePathSchema,
+        side: z
+            .enum(["base", "ours", "theirs"])
+            .describe("Copy this exact pinned side. Do not send contents, encoding, or mode."),
+    })
+        .strict(),
+]);
+export const sourceWorkspaceResolveSchema = sourceWorkspaceMutationSchema.extend({
+    resolutions: z.array(sourceWorkspaceResolutionSchema).min(1).max(1000),
+});
+export const sourceWorkspaceDiffQuerySchema = z.object({
+    view: z.enum(["working", "staged", "unstaged"]).default("working"),
+    path: sourceWorkspacePathSchema.optional(),
+});
+export const sourceWorkspaceListQuerySchema = cursorListQuerySchema.extend({
+    status: z
+        .enum(["open", "closed"])
+        .default("open")
+        .describe("Open includes initializing, active, and conflicted workspaces. Use closed for history."),
+});
+export const SourceWorkspaceSchema = z.object({
+    id: z.string(),
+    spaceId: z.string(),
+    repositoryId: z.string(),
+    targetBranch: z.string(),
+    name: z.string(),
+    revision: z.number().int().nonnegative(),
+    state: z.enum(["initializing", "active", "conflicted", "closed"]),
+    baseCommitSha: sourceCommitShaSchema.nullable(),
+    indexCommitSha: sourceCommitShaSchema.nullable(),
+    workingCommitSha: sourceCommitShaSchema.nullable(),
+    headCommitSha: sourceCommitShaSchema.nullable(),
+    originalUploadVersionId: z.string().nullable(),
+    hasStagedChanges: z.boolean(),
+    hasUnstagedChanges: z.boolean(),
+    hasPendingChanges: z.boolean(),
+    needsSync: z.boolean(),
+    pendingOperationId: z.string().nullable(),
+    autoDeploy: z.boolean(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+});
+export const sourceWorkspaceHunkSchema = z.object({
+    id: z.string(),
+    oldStart: z.number().int(),
+    oldLines: z.number().int().nonnegative(),
+    newStart: z.number().int(),
+    newLines: z.number().int().nonnegative(),
+    patch: z.string(),
+});
+export const sourceWorkspaceDiffFileSchema = z.object({
+    path: z.string(),
+    oldPath: z.string().nullable(),
+    state: z.string(),
+    additions: z.number().int(),
+    deletions: z.number().int(),
+    changes: z.number().int(),
+    patch: z.string(),
+    patchTruncated: z.boolean(),
+    wholeFileOnly: z.boolean(),
+    hunks: z.array(sourceWorkspaceHunkSchema),
+});
+export const sourceWorkspaceDiffSchema = z.object({
+    workspace: SourceWorkspaceSchema,
+    view: z.enum(["working", "staged", "unstaged"]),
+    baseCommitSha: sourceCommitShaSchema,
+    targetCommitSha: sourceCommitShaSchema,
+    stats: z.object({
+        files: z.number().int(),
+        additions: z.number().int(),
+        deletions: z.number().int(),
+        changes: z.number().int(),
+    }),
+    files: z.array(sourceWorkspaceDiffFileSchema),
+    filteredFiles: z.array(z.object({ path: z.string(), oldPath: z.string().nullable(), state: z.string() })),
+});
+export const sourceWorkspaceConflictSideSchema = z.object({
+    sourceCommitSha: sourceCommitShaSchema,
+    content: z.string().nullable(),
+    exists: z.boolean(),
+    binary: z.boolean(),
+    truncated: z.boolean(),
+    mode: z.string().nullable(),
+});
+export const sourceWorkspaceConflictsSchema = z.object({
+    phase: z.enum(["staged", "working", "undo"]),
+    labels: z.object({ ours: z.string(), theirs: z.string() }),
+    files: z.array(z.object({
+        path: z.string(),
+        result: z.string(),
+        base: sourceWorkspaceConflictSideSchema,
+        ours: sourceWorkspaceConflictSideSchema,
+        theirs: sourceWorkspaceConflictSideSchema,
+    })),
+});
+export const sourceWorkspaceReceiptSchema = z.object({
+    workspace: SourceWorkspaceSchema,
+    commit: z
+        .object({
+        sourceCommitSha: sourceCommitShaSchema,
+        parentSourceCommitSha: sourceCommitShaSchema,
+        message: z.string(),
+        autoDeploy: z.boolean(),
+    })
+        .optional(),
+    conflicts: sourceWorkspaceConflictsSchema.optional(),
+});
+export const sourceWorkspaceListSchema = z.object({
+    workspaces: z.array(SourceWorkspaceSchema),
+    pagination: CursorPaginationSchema,
+});
+export const sourceWorkspaceConflictResponseSchema = z.object({
+    workspace: SourceWorkspaceSchema,
+    conflicts: sourceWorkspaceConflictsSchema.nullable(),
+});

package/dist/contracts/space-config-spacefast.d.ts

@@ -0,0 +1,394 @@
+import { z } from "zod";
+/**
+ * The system manifest as Spacefast parses it: the format's manifest plus the
+ * per-tenant plan catalog. Metering is host material, so `plans` lives here
+ * rather than in the format.
+ */
+export declare const spacefastSpaceSystemManifestSchema: z.ZodObject<{
+    presentation: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        logo: z.ZodOptional<z.ZodString>;
+        supportUrl: z.ZodOptional<z.ZodString>;
+        claimOrigin: z.ZodOptional<z.ZodString>;
+        accessHandoffOrigin: z.ZodOptional<z.ZodString>;
+        problemDocsBaseUrl: z.ZodOptional<z.ZodString>;
+        contacts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strict>>;
+    hostnames: z.ZodOptional<z.ZodObject<{
+        apex: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    api: z.ZodOptional<z.ZodObject<{
+        origin: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        allowedOrigins: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+    }, z.core.$strict>>;
+    tokenIssuers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        issuer: z.ZodString;
+        keys: z.ZodArray<z.ZodObject<{
+            kid: z.ZodString;
+            publicKey: z.ZodString;
+        }, z.core.$strict>>;
+        proofs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>>;
+    subscriptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        events: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>>;
+    plans: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        features: z.ZodArray<z.ZodEnum<{
+            connectors: "connectors";
+            zero: "zero";
+            tags: "tags";
+            functions: "functions";
+            "plans.paid.available": "plans.paid.available";
+            "anonymous.publishing": "anonymous.publishing";
+            "beta.enrollment_gate": "beta.enrollment_gate";
+            "domains.search": "domains.search";
+            "domains.registration": "domains.registration";
+            "domains.dns_management": "domains.dns_management";
+            "domains.wpcom_dns": "domains.wpcom_dns";
+            "domains.domain_connect": "domains.domain_connect";
+            "domains.proxy_bindings": "domains.proxy_bindings";
+            "collab.notices": "collab.notices";
+            "collab.comments": "collab.comments";
+            "content.managed": "content.managed";
+            "collab.drawing": "collab.drawing";
+            "sites.jetpack": "sites.jetpack";
+            "spaces.slug_rename": "spaces.slug_rename";
+            "content.users": "content.users";
+            "pages.templates": "pages.templates";
+            "branding.hide": "branding.hide";
+        }>>;
+        quotas: z.ZodObject<{
+            spaces: z.ZodOptional<z.ZodNumber>;
+            storageBytes: z.ZodOptional<z.ZodNumber>;
+            buildMinutesPerMonth: z.ZodOptional<z.ZodNumber>;
+            customDomains: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        quotaPolicy: z.ZodOptional<z.ZodEnum<{
+            block: "block";
+            warn: "warn";
+        }>>;
+    }, z.core.$strict>>>;
+    defaultPlan: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type SpacefastSpaceSystemManifest = z.infer<typeof spacefastSpaceSystemManifestSchema>;
+/**
+ * The `sf.jsonc` FILE shape as Spacefast parses it. Every intake seam that may
+ * receive a partner's system manifest — finalize, the CLI's project config —
+ * parses through this; the format's own schema rejects `system.plans` outright,
+ * so a seam that forgets fails loudly instead of dropping the catalog.
+ */
+export declare const spacefastSpaceConfigFileSchema: z.ZodObject<{
+    index: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<false>]>>;
+    fallback: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        path: z.ZodString;
+        status: z.ZodNumber;
+    }, z.core.$strip>]>>;
+    cleanUrls: z.ZodOptional<z.ZodBoolean>;
+    listing: z.ZodOptional<z.ZodBoolean>;
+    meta: z.ZodOptional<z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        image: z.ZodOptional<z.ZodString>;
+        favicon: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    superpowers: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        disable_all_injection: z.ZodOptional<z.ZodBoolean>;
+        googleAnalytics: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            measurementId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        googleTagManager: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            containerId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        javascriptTags: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            code: z.ZodString;
+        }, z.core.$strip>>>;
+        tags: z.ZodOptional<z.ZodObject<{
+            inheritance: z.ZodOptional<z.ZodObject<{
+                inherited: z.ZodOptional<z.ZodBoolean>;
+                overrides: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    tagId: z.ZodString;
+                    disabled: z.ZodDefault<z.ZodBoolean>;
+                    reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
+            requireReview: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    templates: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    theme: z.ZodOptional<z.ZodObject<{
+        accent: z.ZodOptional<z.ZodString>;
+        background: z.ZodOptional<z.ZodString>;
+        logo: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        font: z.ZodOptional<z.ZodString>;
+        hideSpacefastBranding: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    build: z.ZodOptional<z.ZodObject<{
+        rootDirectory: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        installDirectory: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        installCommand: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        buildCommand: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        outputDirectory: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        ignoredBuildCommand: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        frameworkPreset: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        platformPreset: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        allowUnsupportedPlatformFeatures: z.ZodOptional<z.ZodBoolean>;
+        timeoutSeconds: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    placement: z.ZodOptional<z.ZodObject<{
+        burstable: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    markdownNegotiation: z.ZodOptional<z.ZodBoolean>;
+    inject: z.ZodOptional<z.ZodObject<{
+        head: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        bodyStart: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        bodyEnd: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        noscript: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    $schema: z.ZodOptional<z.ZodString>;
+    space: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    access: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodLiteral<"public">, z.ZodTransform<{
+        public: string[];
+    }, "public">>, z.ZodObject<{
+        public: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+    }, z.core.$strict>]>>;
+    runtime: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"zero">;
+        server: z.ZodString;
+        client: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"functions">;
+        entry: z.ZodOptional<z.ZodString>;
+        database: z.ZodDefault<z.ZodBoolean>;
+        fetch: z.ZodOptional<z.ZodBoolean>;
+        compatibilityDate: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "kind">>;
+    crons: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        schedule: z.ZodString;
+    }, z.core.$strip>>>;
+    system: z.ZodOptional<z.ZodObject<{
+        presentation: z.ZodOptional<z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            logo: z.ZodOptional<z.ZodString>;
+            supportUrl: z.ZodOptional<z.ZodString>;
+            claimOrigin: z.ZodOptional<z.ZodString>;
+            accessHandoffOrigin: z.ZodOptional<z.ZodString>;
+            problemDocsBaseUrl: z.ZodOptional<z.ZodString>;
+            contacts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strict>>;
+        hostnames: z.ZodOptional<z.ZodObject<{
+            apex: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        api: z.ZodOptional<z.ZodObject<{
+            origin: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+            allowedOrigins: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+        }, z.core.$strict>>;
+        tokenIssuers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            issuer: z.ZodString;
+            keys: z.ZodArray<z.ZodObject<{
+                kid: z.ZodString;
+                publicKey: z.ZodString;
+            }, z.core.$strict>>;
+            proofs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>>;
+        subscriptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            url: z.ZodString;
+            events: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>>;
+        plans: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            features: z.ZodArray<z.ZodEnum<{
+                connectors: "connectors";
+                zero: "zero";
+                tags: "tags";
+                functions: "functions";
+                "plans.paid.available": "plans.paid.available";
+                "anonymous.publishing": "anonymous.publishing";
+                "beta.enrollment_gate": "beta.enrollment_gate";
+                "domains.search": "domains.search";
+                "domains.registration": "domains.registration";
+                "domains.dns_management": "domains.dns_management";
+                "domains.wpcom_dns": "domains.wpcom_dns";
+                "domains.domain_connect": "domains.domain_connect";
+                "domains.proxy_bindings": "domains.proxy_bindings";
+                "collab.notices": "collab.notices";
+                "collab.comments": "collab.comments";
+                "content.managed": "content.managed";
+                "collab.drawing": "collab.drawing";
+                "sites.jetpack": "sites.jetpack";
+                "spaces.slug_rename": "spaces.slug_rename";
+                "content.users": "content.users";
+                "pages.templates": "pages.templates";
+                "branding.hide": "branding.hide";
+            }>>;
+            quotas: z.ZodObject<{
+                spaces: z.ZodOptional<z.ZodNumber>;
+                storageBytes: z.ZodOptional<z.ZodNumber>;
+                buildMinutesPerMonth: z.ZodOptional<z.ZodNumber>;
+                customDomains: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>;
+            quotaPolicy: z.ZodOptional<z.ZodEnum<{
+                block: "block";
+                warn: "warn";
+            }>>;
+        }, z.core.$strict>>>;
+        defaultPlan: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strip>;
+export type SpacefastSpaceConfigFile = z.infer<typeof spacefastSpaceConfigFileSchema>;
+/**
+ * The published JSON Schema artifact for `sf.jsonc`, generated from the zod file
+ * schema. Served at SPACE_CONFIG_SCHEMA_URL so editors and agents get
+ * autocomplete and validation — including the host keys, since the document an
+ * editor resolves describes what this host accepts.
+ */
+export declare function spaceConfigJsonSchema(): {
+    properties: {
+        redirects: {
+            readonly type: "array";
+            readonly description: "Browser redirect rules. Same matcher grammar as _redirects, and _redirects rules match first.";
+            readonly items: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly source: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "Request path to match. * is a splat, :name captures a segment.";
+                    };
+                    readonly destination: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "Path or absolute URL. :splat and :name from the source are substituted.";
+                    };
+                    readonly status: {
+                        readonly enum: readonly [301, 302, 303, 307, 308];
+                        readonly default: 302;
+                        readonly description: "Redirect status. To serve other content under this URL, use rewrites.";
+                    };
+                    readonly force: {
+                        readonly type: "boolean";
+                        readonly default: false;
+                        readonly description: "Answer even when the request path resolves to a committed file, the ! of a _redirects rule.";
+                    };
+                    readonly query: {
+                        readonly type: "object";
+                        readonly description: "Query parameters the request must carry, as parameter name to capture name: { \"id\": \"id\" } is the name=:capture token id=:id.";
+                        readonly propertyNames: {
+                            readonly pattern: "^[A-Za-z_][A-Za-z0-9_-]*$";
+                        };
+                        readonly additionalProperties: {
+                            readonly type: "string";
+                            readonly pattern: "^[A-Za-z][A-Za-z0-9_]*$";
+                        };
+                    };
+                };
+                readonly required: readonly ["source", "destination"];
+                readonly additionalProperties: false;
+            };
+        };
+        rewrites: {
+            readonly type: "array";
+            readonly description: "Rewrite and proxy rules: the URL stays, the content comes from the destination. _redirects rules match first, then redirects.";
+            readonly items: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly source: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "Request path to match. * is a splat, :name captures a segment.";
+                    };
+                    readonly destination: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "Path to serve under this URL, or an absolute URL to proxy. :splat and :name from the source are substituted.";
+                    };
+                    readonly cache: {
+                        readonly const: "shared";
+                        readonly description: "Let shared caches store the proxy response. Absolute-URL destinations only.";
+                    };
+                    readonly force: {
+                        readonly type: "boolean";
+                        readonly default: false;
+                        readonly description: "Answer even when the request path resolves to a committed file, the ! of a _redirects rule.";
+                    };
+                    readonly query: {
+                        readonly type: "object";
+                        readonly description: "Query parameters the request must carry, as parameter name to capture name: { \"id\": \"id\" } is the name=:capture token id=:id.";
+                        readonly propertyNames: {
+                            readonly pattern: "^[A-Za-z_][A-Za-z0-9_-]*$";
+                        };
+                        readonly additionalProperties: {
+                            readonly type: "string";
+                            readonly pattern: "^[A-Za-z][A-Za-z0-9_]*$";
+                        };
+                    };
+                    readonly notFound: {
+                        readonly type: "boolean";
+                        readonly default: false;
+                        readonly description: "Serve the destination with status 404, the 404 of a _redirects rule. The destination must be a path.";
+                    };
+                };
+                readonly required: readonly ["source", "destination"];
+                readonly additionalProperties: false;
+            };
+        };
+        headers: {
+            readonly type: "array";
+            readonly description: "Response headers to set or remove on matching requests. A _headers rule wins on the same header name.";
+            readonly items: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly source: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "Request path to match.";
+                    };
+                    readonly headers: {
+                        readonly type: "array";
+                        readonly minItems: 1;
+                        readonly items: {
+                            readonly oneOf: readonly [{
+                                readonly type: "object";
+                                readonly properties: {
+                                    readonly key: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                    readonly value: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly required: readonly ["key", "value"];
+                                readonly additionalProperties: false;
+                            }, {
+                                readonly type: "object";
+                                readonly properties: {
+                                    readonly key: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                    readonly remove: {
+                                        readonly const: true;
+                                        readonly description: "Remove this header instead of setting it, the !Name line of a _headers block.";
+                                    };
+                                };
+                                readonly required: readonly ["key", "remove"];
+                                readonly additionalProperties: false;
+                            }];
+                        };
+                    };
+                };
+                readonly required: readonly ["source", "headers"];
+                readonly additionalProperties: false;
+            };
+        };
+    };
+};