@spacefast/common 0.0.13 → 0.0.17

package/dist/contracts/sf-config-v1.d.ts

@@ -3,6 +3,11 @@ export declare const SF_CONFIG_V1_CANONICAL_FILE = "sf.jsonc";
 export declare const SF_CONFIG_V1_FILES: readonly ["sf.jsonc", "spacefast.jsonc", "spacefast.json", "sf.json", ".sf/sf.json", ".sf/config.jsonc", ".sf/config.json"];
 /** Published JSON Schema URL for the strict `sf.jsonc` v1 contract. */
 export declare const SF_CONFIG_V1_SCHEMA_URL: `${string}/schemas/sf.v1.json`;
+/**
+ * How a redirect answers. Omitting it means 302. There is no 200: a rule that
+ * serves other content under the requested URL is a `rewrites` entry.
+ */
+export type SfConfigV1RedirectStatus = 301 | 302 | 303 | 307 | 308;
 export type SfConfigV1 = {
     $schema?: typeof SF_CONFIG_V1_SCHEMA_URL;
     version: 1;
@@ -19,6 +24,38 @@ export type SfConfigV1 = {
         cleanUrls?: boolean;
         directoryListing?: boolean;
     };
+    /**
+     * Browser redirect rules, in the same matcher grammar as `_redirects`. The
+     * files match first; config rules add behavior where the files are silent.
+     */
+    redirects?: {
+        source: string;
+        destination: string;
+        status?: SfConfigV1RedirectStatus;
+    }[];
+    /**
+     * Rewrite and proxy rules: the URL stays, the content comes from the
+     * destination. A path destination rewrites, an absolute URL proxies — the
+     * same 200 rules `_redirects` writes as `/from /to 200`, which is why they
+     * carry no status of their own.
+     */
+    rewrites?: {
+        source: string;
+        destination: string;
+        /** Let shared caches store the proxy response. Absolute-URL destinations only. */
+        cache?: "shared";
+    }[];
+    /**
+     * Response headers to set on matching requests. Headers are a list, not a
+     * map, so repeated names (Set-Cookie) survive.
+     */
+    headers?: {
+        source: string;
+        headers: {
+            key: string;
+            value: string;
+        }[];
+    }[];
     metadata?: {
         title?: string;
         description?: string;
@@ -43,12 +80,23 @@ export type EffectiveConfigV1 = {
         cleanUrls: boolean;
         directoryListing: boolean;
     };
+    /** Every rule states its status; an omitted one resolves to 302. */
+    redirects?: (NonNullable<SfConfigV1["redirects"]>[number] & {
+        status: SfConfigV1RedirectStatus;
+    })[];
+    rewrites?: SfConfigV1["rewrites"];
+    headers?: SfConfigV1["headers"];
     metadata?: SfConfigV1["metadata"];
     substitute?: SfConfigV1["substitute"];
     grants?: Grant[];
 };
+/**
+ * Config-shape problems use the `config_*` codes; a bad routing rule reports
+ * the same code the `_redirects` / `_headers` compiler would give it, because
+ * it is the same grammar and the same compiler.
+ */
 export type SfConfigV1Issue = {
-    code: "config_alias" | "config_conflict" | "config_identity_moved" | "config_invalid" | "config_key_removed" | "config_unknown_key" | "serve_index_required" | "template_syntax_retired";
+    code: "config_alias" | "config_conflict" | "config_identity_moved" | "config_invalid" | "config_key_removed" | "config_unknown_key" | "header_basic_auth_unsupported" | "header_cache_control_platform_managed" | "header_cdn_cache_unsupported" | "header_name_invalid" | "header_name_unsupported" | "header_path_invalid" | "header_pattern_invalid" | "header_port_unsupported" | "header_value_invalid" | "redirect_cache_directive_invalid" | "redirect_cache_not_proxy" | "redirect_destination_invalid" | "redirect_destination_missing" | "redirect_host_invalid" | "redirect_loop_invalid" | "redirect_pattern_invalid" | "redirect_rewrite_destination_invalid" | "redirect_source_invalid" | "redirect_status_unsupported" | "redirect_status_use_rewrites" | "serve_index_required" | "template_syntax_retired";
     severity: "error" | "warning";
     path: string;
     line: number;

package/dist/contracts/sf-config-v1.js

@@ -1,6 +1,6 @@
-import { BRAND } from "../brand.js";
+import { serviceOrigin } from "../config/domains.js";
 import { SPACE_CONFIG_ACCEPTED_FILES, SPACE_CONFIG_CANONICAL_FILE } from "./space-config.js";
 export const SF_CONFIG_V1_CANONICAL_FILE = SPACE_CONFIG_CANONICAL_FILE;
 export const SF_CONFIG_V1_FILES = SPACE_CONFIG_ACCEPTED_FILES;
 /** Published JSON Schema URL for the strict `sf.jsonc` v1 contract. */
-export const SF_CONFIG_V1_SCHEMA_URL = `${BRAND.websiteOrigin}/schemas/sf.v1.json`;
+export const SF_CONFIG_V1_SCHEMA_URL = `${serviceOrigin("www", "prod")}/schemas/sf.v1.json`;

package/dist/contracts/sites.d.ts

@@ -104,6 +104,7 @@ export declare const operatorSiteProvisioningSchema: z.ZodOptional<z.ZodObject<{
 }, z.core.$strip>>;
 export declare const tenantSiteProvisioningSchema: z.ZodOptional<z.ZodObject<{}, z.core.$strict>>;
 export declare const siteCreateSchema: z.ZodObject<{
+    teamId: z.ZodOptional<z.ZodString>;
     kind: z.ZodDefault<z.ZodEnum<{
         static_runtime: "static_runtime";
     }>>;

package/dist/contracts/sites.js

@@ -11,7 +11,7 @@ export const SiteCapacitySchema = z
         .int()
         .nonnegative()
         .optional()
-        .describe("Maximum spaces this site may host."),
+        .describe("Maximum number of spaces this site can host."),
     usedSpaces: z
         .number()
         .int()
@@ -56,8 +56,8 @@ export const SitePressureSchema = z
 // 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_...`)."),
+    id: z.string().describe("The site id (`site_...`)."),
+    tenantId: z.string().describe("The 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."),
@@ -67,7 +67,7 @@ export const SiteSchema = z.object({
         .string()
         .nullable()
         .describe("Hostname the control plane manages the site runtime through."),
-    runtimeInstanceId: z.string().nullable().describe("Runtime instance identity for this site."),
+    runtimeInstanceId: z.string().nullable().describe("Runtime instance id 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(),
@@ -84,7 +84,7 @@ export const operatorSiteProvisioningSchema = z
         .trim()
         .min(1)
         .optional()
-        .describe("Import an existing WP.Cloud site by its atomic_site_id (operator flows)."),
+        .describe("Import an existing WP.Cloud site by its `atomic_site_id` (operator flows)."),
 })
     .optional();
 // An explicit empty object requests fresh provider provisioning while keeping
@@ -92,9 +92,15 @@ export const operatorSiteProvisioningSchema = z
 export const tenantSiteProvisioningSchema = z.object({}).strict().optional();
 export const siteCreateSchema = z
     .object({
+    teamId: z
+        .string()
+        .trim()
+        .min(1)
+        .optional()
+        .describe("Team id or slug that will own the site. If omitted, the server infers it from the principal."),
     kind: siteKind.default("static_runtime"),
     isolation: siteIsolation.default("site"),
-    region: z.string().trim().min(1).optional().describe('Placement region; defaults to `"auto"`.'),
+    region: z.string().trim().min(1).optional().describe('Placement region. Defaults to `"auto"`.'),
     provisioning: tenantSiteProvisioningSchema,
 })
     .strict();
@@ -113,14 +119,16 @@ export const SuperadminSiteSchema = SiteSchema.extend({
         .string()
         .nullable()
         .describe("WP.Cloud client identity (`pvc_...`) the site is provisioned under."),
-    providerRef: z.string().nullable().describe("WP.Cloud atomic_site_id."),
+    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.omit({ provisioning: true }).extend({
+export const superadminSiteCreateSchema = siteCreateSchema
+    .omit({ provisioning: true, teamId: true })
+    .extend({
     tenantId: z.string().trim().min(1),
     provisioning: operatorSiteProvisioningSchema,
 });
@@ -133,12 +141,12 @@ export const siteRebalanceRequestSchema = 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("Limit the rebalance to these space ids. If omitted, the server rebalances every live space on the site."),
 })
     .describe("Operator-only rebalance trigger: move spaces off this site. This is the ONLY path that relocates an existing Space, and it is not free — see the reverification warning on the result.");
 export const SiteRebalanceResultSchema = z
     .object({
-    siteId: z.string().describe("The site spaces are being moved off."),
+    siteId: z.string().describe("The site id that spaces are being moved off."),
     moves: z
         .array(z.object({
         spaceId: z.string().describe("Space queued to move."),
@@ -147,7 +155,7 @@ export const SiteRebalanceResultSchema = z
         .describe("One queued move operation per affected space."),
     warning: z
         .string()
-        .describe("Consequence of relocating these Spaces: each hostname is handed to another provider site, which re-runs the provider's domain-exclusivity check and is rejected unless the domain's ownership TXT record is still live in DNS."),
+        .describe("Consequence of relocating these spaces. Each hostname moves to another provider site. The provider re-runs its domain-exclusivity check and rejects the move unless the ownership TXT record is still live in DNS."),
     domainsRequiringReverification: z
         .array(z.object({
         spaceId: z.string().describe("Space the hostname serves."),
@@ -155,6 +163,6 @@ export const SiteRebalanceResultSchema = z
             .string()
             .describe("Custom hostname whose provider ownership check re-runs during the move."),
     }))
-        .describe("Live custom hostnames on the moved Spaces. Empty means nothing customer-visible is at risk."),
+        .describe("Live custom hostnames on the moved spaces. Empty means no customer-visible hostname is at risk."),
 })
     .describe("Queued rebalance moves; track each operation for completion.");

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

@@ -25,6 +25,8 @@ export declare const SPACE_CONFIG_CAPS: {
     readonly themeLogoChars: 2000;
     /** Max `theme.name` display-name length. */
     readonly themeNameChars: 120;
+    /** Max top-level `name` (space display name) length. Matches the stored column. */
+    readonly nameChars: 255;
 };
 /** Published JSON Schema URL for `sf.jsonc` ($schema autocomplete). */
 export declare const SPACE_CONFIG_SCHEMA_URL: string;
@@ -70,7 +72,7 @@ export declare const wordpressDataSourceSchema: z.ZodObject<{
     url: z.ZodString;
 }, z.core.$strict>;
 export type WordPressDataSource = z.infer<typeof wordpressDataSourceSchema>;
-export declare const spaceDataSourcesSchema: z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodObject<{
+export declare const spaceDataSourcesSchema: z.ZodPipe<z.ZodUnknown, z.ZodRecord<z.ZodString, z.ZodObject<{
     kind: z.ZodLiteral<"wordpress">;
     url: z.ZodString;
 }, z.core.$strict>>>;
@@ -152,7 +154,7 @@ export declare const spaceConfigSchema: z.ZodObject<{
         bodyEnd: z.ZodOptional<z.ZodArray<z.ZodString>>;
         noscript: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
-    dataSources: z.ZodOptional<z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodObject<{
+    dataSources: z.ZodOptional<z.ZodPipe<z.ZodUnknown, z.ZodRecord<z.ZodString, z.ZodObject<{
         kind: z.ZodLiteral<"wordpress">;
         url: z.ZodString;
     }, z.core.$strict>>>>;
@@ -162,28 +164,61 @@ export type SpaceConfig = z.infer<typeof spaceConfigSchema>;
 export declare function compareDataSourceNames(left: string, right: string): number;
 export declare function resolveDefaultDataSourceName(config: Pick<SpaceConfig, "dataSources" | "defaultDataSource"> | null | undefined): string | null;
 export declare function spaceSuperpowersEnabled(config: SpaceConfig | null | undefined): boolean;
-export declare const spacePublishOptionsSchema: z.ZodObject<{
-    fingerprint: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export type SpacePublishOptions = z.infer<typeof spacePublishOptionsSchema>;
-export declare const spaceConfigFileAccessSchema: z.ZodObject<{
+export declare const spaceConfigFileAccessSchema: 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>;
+}, z.core.$strict>]>;
 export type SpaceConfigFileAccess = z.infer<typeof spaceConfigFileAccessSchema>;
 /**
- * Overrides for the worker `sf publish` compiles.
+ * Zero: a transactional app with its own database.
+ *
+ * Both entries are required because Zero is never inferred. A runtime that owns
+ * a database must not spring into existence from a directory shape, so the only
+ * way to get one is to say so — and once said, a server or client that cannot
+ * be resolved fails the publish rather than degrading to static files.
+ */
+export declare const spaceRuntimeZeroSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"zero">;
+    server: z.ZodString;
+    client: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Functions: the worker `sf publish` compiles.
  *
- * Every field is optional because the normal case is detection: a project with
- * `handler.ts` or an OpenNext build needs no configuration at all. These exist
- * for the layouts detection cannot guess — a worker somewhere unusual, or a
- * compatibility date the author wants pinned rather than defaulted.
+ * Every field beyond `kind` is optional because the normal case is detection: a
+ * project with `handler.ts` or an OpenNext build needs no configuration at all.
+ * These exist for the layouts detection cannot guess — a worker somewhere
+ * unusual, or a compatibility date the author wants pinned rather than
+ * defaulted.
  */
-export declare const spaceFunctionsOptionsSchema: z.ZodObject<{
+export declare const spaceRuntimeFunctionsSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"functions">;
     entry: z.ZodOptional<z.ZodString>;
     database: z.ZodDefault<z.ZodBoolean>;
     compatibilityDate: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-export type SpaceFunctionsOptions = z.infer<typeof spaceFunctionsOptionsSchema>;
+/**
+ * The one runtime declaration, discriminated on `kind`.
+ *
+ * One block, one kind — a version cannot express two runtimes at once, so the
+ * ambiguity never has to be resolved downstream. File-only on purpose: a
+ * runtime is a fact about the content of a version, so it rolls forward and
+ * back with the version instead of being set through the API config overlay.
+ */
+export declare const spaceRuntimeSchema: 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>;
+    compatibilityDate: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "kind">;
+export type SpaceRuntimeZeroConfig = z.infer<typeof spaceRuntimeZeroSchema>;
+export type SpaceRuntimeFunctionsConfig = z.infer<typeof spaceRuntimeFunctionsSchema>;
+export type SpaceRuntimeConfig = z.infer<typeof spaceRuntimeSchema>;
 export declare const spaceConfigFileSchema: z.ZodObject<{
     index: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<false>]>>;
     fallback: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
@@ -264,17 +299,22 @@ export declare const spaceConfigFileSchema: z.ZodObject<{
     }, z.core.$strip>>;
     $schema: z.ZodOptional<z.ZodString>;
     space: z.ZodOptional<z.ZodString>;
-    publish: z.ZodOptional<z.ZodObject<{
-        fingerprint: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    access: z.ZodOptional<z.ZodObject<{
+    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>>;
-    functions: z.ZodOptional<z.ZodObject<{
+    }, 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>;
         compatibilityDate: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
+    }, z.core.$strip>], "kind">>;
 }, z.core.$strip>;
 export type SpaceConfigFile = z.infer<typeof spaceConfigFileSchema>;
 /**

package/dist/contracts/space-config.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { BRAND } from "../brand.js";
+import { serviceOrigin } from "../config/domains.js";
 import { normalizedSiteClass } from "./enums.js";
 import { GRANT_RESOURCE_PATTERN_LIMIT, normalizeGrantResourcePattern } from "./grants.js";
 export const SPACE_CONFIG_CANONICAL_FILE = "sf.jsonc";
@@ -43,9 +43,11 @@ export const SPACE_CONFIG_CAPS = {
     themeLogoChars: 2000,
     /** Max `theme.name` display-name length. */
     themeNameChars: 120,
+    /** Max top-level `name` (space display name) length. Matches the stored column. */
+    nameChars: 255,
 };
 /** Published JSON Schema URL for `sf.jsonc` ($schema autocomplete). */
-export const SPACE_CONFIG_SCHEMA_URL = `${BRAND.websiteOrigin}/schemas/sf.json`;
+export const SPACE_CONFIG_SCHEMA_URL = `${serviceOrigin("www", "prod")}/schemas/sf.json`;
 // Pages theme tokens: visual values consumed by publish-rendered site pages.
 // Presentation only — never layout, behavior, or protocol.
 // Color grammar accepts hex/rgb(a)/hsl(a)/
@@ -317,17 +319,16 @@ export const wordpressDataSourceSchema = z
 })
     .strict()
     .describe("A public WordPress site exposed to repository builds as a content source.");
-function rejectReservedDataSourceRecordKeys(value) {
-    if (typeof value === "object" &&
+function hasNoReservedDataSourceRecordKeys(value) {
+    return !(typeof value === "object" &&
         value !== null &&
         !Array.isArray(value) &&
-        Object.keys(value).some((name) => RESERVED_DATA_SOURCE_NAMES.has(name))) {
-        return null;
-    }
-    return value;
+        Object.keys(value).some((name) => RESERVED_DATA_SOURCE_NAMES.has(name)));
 }
 export const spaceDataSourcesSchema = z
-    .preprocess(rejectReservedDataSourceRecordKeys, z
+    .unknown()
+    .refine(hasNoReservedDataSourceRecordKeys, { message: "dataSources contains a reserved name." })
+    .pipe(z
     .record(dataSourceNameSchema, wordpressDataSourceSchema)
     .refine((sources) => Object.keys(sources).length <= SPACE_CONFIG_CAPS.dataSources, {
     message: `dataSources supports up to ${SPACE_CONFIG_CAPS.dataSources} entries.`,
@@ -365,11 +366,11 @@ const spaceConfigBaseSchema = z.object({
         }),
     ])
         .optional()
-        .describe('Fallback document; "/index.html" means SPA. Default: nearest 404.html.'),
+        .describe('Fallback document. "/index.html" means SPA. Defaults to the nearest 404.html.'),
     cleanUrls: z
         .boolean()
         .optional()
-        .describe("Serve flat `<name>.html` files at their extensionless URL (/about serves about.html). Default: on, unless a 200-status SPA fallback is configured."),
+        .describe("Serve flat `<name>.html` files at their extensionless URL (`/about` serves `about.html`). Defaults to on, unless a 200-status SPA fallback is configured."),
     listing: z.boolean().optional().describe("Enable automatic directory listings."),
     meta: z
         .object({
@@ -470,7 +471,7 @@ export const spaceConfigSchema = spaceConfigBaseSchema
         .describe(`Named public WordPress sources exposed to repository builds; at most ${SPACE_CONFIG_CAPS.dataSources} entries.`),
     defaultDataSource: dataSourceNameSchema
         .optional()
-        .describe("Name of the configured source exposed through WORDPRESS_URL. Must match a dataSources entry; when omitted, the first source in bytewise name order is used."),
+        .describe("Name of the configured source exposed through `WORDPRESS_URL`. It must match a `dataSources` entry. When omitted, the first source in bytewise name order is used."),
 })
     .superRefine(refineDefaultDataSource);
 export function compareDataSourceNames(left, right) {
@@ -491,22 +492,9 @@ export function spaceSuperpowersEnabled(config) {
 // The `sf.jsonc` FILE shape (internal-docs/platform.md "Space
 // Configuration Files"): SpaceConfig plus the editor `$schema` pointer and the
 // optional `space` link (slug or `spc_` id) resolved by CLI/publish flows.
-// Routing never lives here — redirects/rewrites/proxies/headers stay
-// exclusively in `_redirects`/`_headers` (one way per concern).
-// Client-side publish options (caching plan §6): consumed by the CLI/agent
-// publish tooling before upload, never by the runtime — like `$schema` and
-// `space`, this key lives only in the FILE shape and never reaches the space
-// `config` overlay.
-export const spacePublishOptionsSchema = z
-    .object({
-    fingerprint: z
-        .boolean()
-        .optional()
-        .describe("Publish-time asset fingerprinting: adds content-hashed immutable aliases " +
-        "(name.<sha256-8>.ext) for stable assets and rewrites exact HTML/CSS references. " +
-        "Originals keep serving unchanged. Default off."),
-})
-    .describe("Client publish-time options consumed by the Spacefast CLI, not the runtime.");
+// Routing rules (`redirects`/`rewrites`/`headers`) are sf.jsonc keys too, but they belong
+// to the routing compiler, not to this shape: it resolves serving, they compile
+// into the canonical rules and merge behind `_redirects`/`_headers`.
 const spaceConfigPublicPatternSchema = z
     .string()
     .min(1)
@@ -525,7 +513,7 @@ const spaceConfigPublicPatternSchema = z
         return z.NEVER;
     }
 });
-export const spaceConfigFileAccessSchema = z
+const spaceConfigFileAccessObjectSchema = z
     .object({
     public: z
         .array(spaceConfigPublicPatternSchema)
@@ -555,39 +543,79 @@ export const spaceConfigFileAccessSchema = z
             message: "access.public requires at least one inclusion pattern.",
         });
     }
+});
+export const spaceConfigFileAccessSchema = z
+    .union([
+    z
+        .literal("public")
+        .describe('Shorthand for { "public": ["/**"] }: the whole live space is public.')
+        .transform(() => ({ public: ["/**"] })),
+    spaceConfigFileAccessObjectSchema,
+])
+    .describe("File-only public access declaration. It is inactive until the space is claimed.");
+/**
+ * Zero: a transactional app with its own database.
+ *
+ * Both entries are required because Zero is never inferred. A runtime that owns
+ * a database must not spring into existence from a directory shape, so the only
+ * way to get one is to say so — and once said, a server or client that cannot
+ * be resolved fails the publish rather than degrading to static files.
+ */
+export const spaceRuntimeZeroSchema = z
+    .object({
+    kind: z.literal("zero"),
+    server: z
+        .string()
+        .trim()
+        .min(1)
+        .describe("Path to the server entry module, relative to the published directory."),
+    client: z
+        .string()
+        .trim()
+        .min(1)
+        .describe("Path to the client entry module, relative to the published directory."),
 })
-    .describe("File-only public access declaration. It is inactive until the Space is claimed.");
+    .describe("Zero: a transactional app with its own database, compiled at publish time.");
 /**
- * Overrides for the worker `sf publish` compiles.
+ * Functions: the worker `sf publish` compiles.
  *
- * Every field is optional because the normal case is detection: a project with
- * `handler.ts` or an OpenNext build needs no configuration at all. These exist
- * for the layouts detection cannot guess — a worker somewhere unusual, or a
- * compatibility date the author wants pinned rather than defaulted.
+ * Every field beyond `kind` is optional because the normal case is detection: a
+ * project with `handler.ts` or an OpenNext build needs no configuration at all.
+ * These exist for the layouts detection cannot guess — a worker somewhere
+ * unusual, or a compatibility date the author wants pinned rather than
+ * defaulted.
  */
-export const spaceFunctionsOptionsSchema = z
+export const spaceRuntimeFunctionsSchema = z
     .object({
+    kind: z.literal("functions"),
     entry: z
         .string()
         .optional()
         .describe("Path to the worker entry module, relative to the published directory. " +
-        "Detected automatically when absent; naming one that does not exist is an error " +
-        "rather than a silent static publish."),
+        "When absent, the server detects it automatically. Naming an entry that does not exist is an error, not a silent static publish."),
     database: z
         .boolean()
         .default(false)
         .describe("Give the worker `env.DB`, a D1-shaped binding to this space's database. " +
-        "Declared rather than detected: a capability an author did not ask for is " +
-        "authority they cannot see, and reading it out of minified build output " +
-        "would be a guess. Off by default, so a worker reaches nothing until it says so."),
+        "This capability is declared, not detected. A capability an author did not request is authority they cannot see. Reading it from minified build output is a guess. Defaults to off, so a worker reaches nothing until it says so."),
     compatibilityDate: z
         .string()
         .regex(/^\d{4}-\d{2}-\d{2}$/)
         .optional()
-        .describe("Runtime compatibility date this worker was written against. Pinning it makes " +
-        "rollback honest: promoting an old version restores the semantics it was built with."),
+        .describe("Runtime compatibility date this worker was written against. Pinning it makes rollback honest. Promoting an old version restores the semantics it was built with."),
 })
-    .describe("Overrides for the worker compiled at publish time.");
+    .describe("Functions: a worker compiled at publish time.");
+/**
+ * The one runtime declaration, discriminated on `kind`.
+ *
+ * One block, one kind — a version cannot express two runtimes at once, so the
+ * ambiguity never has to be resolved downstream. File-only on purpose: a
+ * runtime is a fact about the content of a version, so it rolls forward and
+ * back with the version instead of being set through the API config overlay.
+ */
+export const spaceRuntimeSchema = z
+    .discriminatedUnion("kind", [spaceRuntimeZeroSchema, spaceRuntimeFunctionsSchema])
+    .describe("Runtime this version's code runs on. Omit it for a static space. Functions is also detected from the published directory when it is not stated.");
 export const spaceConfigFileSchema = spaceConfigBaseSchema.extend({
     $schema: z
         .string()
@@ -598,9 +626,17 @@ export const spaceConfigFileSchema = spaceConfigBaseSchema.extend({
         .min(1)
         .optional()
         .describe("Optional space link: a space slug or spc_ id this project publishes to."),
-    publish: spacePublishOptionsSchema.optional(),
+    // File-owned naming: the live version's config decides the display name, so
+    // it rolls forward and back with the version like every other content fact.
+    name: z
+        .string()
+        .trim()
+        .min(1)
+        .max(SPACE_CONFIG_CAPS.nameChars)
+        .optional()
+        .describe("Display name for this space. While set, the API refuses to rename the space."),
     access: spaceConfigFileAccessSchema.optional(),
-    functions: spaceFunctionsOptionsSchema.optional(),
+    runtime: spaceRuntimeSchema.optional(),
 });
 /**
  * The published JSON Schema artifact for `sf.jsonc`, generated from the
@@ -608,12 +644,102 @@ export const spaceConfigFileSchema = spaceConfigBaseSchema.extend({
  * autocomplete and validation.
  */
 export function spaceConfigJsonSchema() {
-    return stripHiddenSpaceConfigKeys({
+    const schema = stripHiddenSpaceConfigKeys({
         ...z.toJSONSchema(spaceConfigFileSchema, { target: "draft-7", io: "input" }),
         $id: SPACE_CONFIG_SCHEMA_URL,
         title: "Spacefast space configuration (sf.jsonc)",
     });
+    // `redirects`, `rewrites` and `headers` are real sf.jsonc keys, owned by the routing
+    // compiler rather than by the serving shape above — which is why they are
+    // described here instead of in the zod schema that resolves serving. An editor
+    // reading this file still has to know they exist, or the documented routing
+    // examples read as unknown keys.
+    return {
+        ...schema,
+        properties: {
+            ...schema.properties,
+            ...SPACE_CONFIG_ROUTING_SCHEMA_PROPERTIES,
+        },
+    };
 }
+const SPACE_CONFIG_ROUTING_SCHEMA_PROPERTIES = {
+    redirects: {
+        type: "array",
+        description: "Browser redirect rules. Same matcher grammar as _redirects, and _redirects rules match first.",
+        items: {
+            type: "object",
+            properties: {
+                source: {
+                    type: "string",
+                    minLength: 1,
+                    description: "Request path to match. * is a splat, :name captures a segment.",
+                },
+                destination: {
+                    type: "string",
+                    minLength: 1,
+                    description: "Path or absolute URL. :splat and :name from the source are substituted.",
+                },
+                status: {
+                    enum: [301, 302, 303, 307, 308],
+                    default: 302,
+                    description: "Redirect status. To serve other content under this URL, use rewrites.",
+                },
+            },
+            required: ["source", "destination"],
+            additionalProperties: false,
+        },
+    },
+    rewrites: {
+        type: "array",
+        description: "Rewrite and proxy rules: the URL stays, the content comes from the destination. _redirects rules match first, then redirects.",
+        items: {
+            type: "object",
+            properties: {
+                source: {
+                    type: "string",
+                    minLength: 1,
+                    description: "Request path to match. * is a splat, :name captures a segment.",
+                },
+                destination: {
+                    type: "string",
+                    minLength: 1,
+                    description: "Path to serve under this URL, or an absolute URL to proxy. :splat and :name from the source are substituted.",
+                },
+                cache: {
+                    const: "shared",
+                    description: "Let shared caches store the proxy response. Absolute-URL destinations only.",
+                },
+            },
+            required: ["source", "destination"],
+            additionalProperties: false,
+        },
+    },
+    headers: {
+        type: "array",
+        description: "Response headers to set on matching requests. A _headers rule wins on the same header name.",
+        items: {
+            type: "object",
+            properties: {
+                source: { type: "string", minLength: 1, description: "Request path to match." },
+                headers: {
+                    type: "array",
+                    minItems: 1,
+                    items: {
+                        type: "object",
+                        properties: {
+                            key: { type: "string", minLength: 1 },
+                            value: { type: "string" },
+                        },
+                        required: ["key", "value"],
+                        additionalProperties: false,
+                    },
+                },
+            },
+            required: ["source", "headers"],
+            additionalProperties: false,
+        },
+    },
+};
 /*
  * Hidden-feature discipline (internal-docs/build-pipeline-plan.md): the
  * `experimental_gutenberg` flag and its `inject` companion are ACCEPTED by the