@spacefast/common 0.0.24 → 0.0.26

package/dist/contracts/runtime-api.js

@@ -4,6 +4,7 @@ import { functionsRuntimeConfigSchema } from "./functions.js";
 import { grantSchema } from "./grants.js";
 import { manifestFileSchema } from "./internal.js";
 import { runtimePagesSchema } from "./pages.js";
+import { runtimePurgeStatusSchema } from "./runtime-purge.js";
 import { SPACE_CONFIG_CAPS } from "./space-config.js";
 import { zeroEndpointSchema, zeroRuntimeConfigSchema } from "./zero.js";
 const hostCanonicalRedirectSchema = z.object({
@@ -39,11 +40,11 @@ const previousVersionIdSchema = z
     .optional()
     .describe("The pointer target this activation replaces (diff baseline).");
 export const runtimePurgeReceiptSchema = z.object({
-    status: z.enum(["ok", "failed", "pending"]),
+    status: runtimePurgeStatusSchema,
     mode: z.enum(["urls", "domain"]),
     urls: z.number().int().nonnegative().optional(),
 });
-const runtimeMutationPurgeShape = {
+const runtimeMutationPurgeFields = {
     purge: runtimePurgeReceiptSchema.optional(),
 };
 export const runtimeSpacePurgeRequestSchema = z.object({
@@ -71,14 +72,22 @@ export const runtimeVersionFilesResponseSchema = z.object({
     })),
     next_cursor: z.string().min(1).nullable().optional(),
 });
+export const runtimeRetentionModeSchema = z.enum(["all", "list", "none"]);
 export const runtimeVersionCreateRequestSchema = z.object({
     version_id: z.string().min(1).optional(),
     files: z.array(manifestFileSchema),
-    // Retention is expressed as "everything from `reusable_version_id`": naming
-    // the base and NO list is the retain-all signal, which the runtime
-    // materializes from that version's own catalog at finalize (under the space
-    // lock). An explicit list is the narrower form — it retains exactly these
-    // paths — and is what a publish that prunes the base uses.
+    // Retention is stated, never inferred. `all` carries every path of
+    // `reusable_version_id` forward — the runtime materializes that list from the
+    // base version's own catalog at finalize, under the space lock, which is what
+    // keeps the lazy publish path free of a pre-upload round trip. `list` retains
+    // exactly `retained_files`, and an EMPTY list is meaningful: it is a publish
+    // that drops every path the base held. `none` retains nothing.
+    //
+    // `all` and `list` both require `reusable_version_id`. Only `list` may carry
+    // `retained_files`. Inferring `all` from "base named + empty list" used to
+    // silently undo deletes — the runtime has no delete list, so deletion IS
+    // omission from the retained set.
+    retention: runtimeRetentionModeSchema,
     retained_files: z.array(manifestFileSchema).optional(),
     reusable_version_id: z.string().min(1).optional(),
     manifest_hash: z.string().optional(),
@@ -99,13 +108,27 @@ export const runtimeUploadSessionDescriptorSchema = z.object({
     manifest_hash: z.string().optional(),
     files: z.array(manifestFileSchema),
     // Retained files only travel in the authenticated finalize request: they are
-    // unbounded and unused while accepting a PUT. Omitting them beside a
-    // `reusable_version_id` is the retain-all signal (see the create request),
-    // which is also what keeps a lazy session's descriptor inside its JWT budget.
+    // unbounded and unused while accepting a PUT, which is also what keeps a lazy
+    // session's descriptor inside its JWT budget. Retention itself is stated on
+    // the wire — see the create request.
+    retention: runtimeRetentionModeSchema,
     retained_files: z.array(manifestFileSchema).optional(),
     reusable_version_id: z.string().min(1).optional(),
     metadata: z.record(z.string(), z.unknown()).default({}),
 });
+/**
+ * The retention half of a create-version body or session descriptor, spelled
+ * once. `retained_files` is omitted when empty — with an explicit `retention`
+ * that omission is unambiguous: it means retain nothing beyond what `all`
+ * materializes.
+ */
+export function runtimeRetentionFields(input) {
+    return {
+        retention: input.retention,
+        ...(input.retainedFiles.length > 0 ? { retained_files: [...input.retainedFiles] } : {}),
+        ...(input.reusableVersionId ? { reusable_version_id: input.reusableVersionId } : {}),
+    };
+}
 export const RUNTIME_UPLOAD_SESSION_DESCRIPTOR_MAX_BYTES = 4096;
 // Hard wire budget for the complete `Authorization: Bearer <jwt>\r\n` line sent
 // on every PUT. Lazy-session selection measures the signed line and falls back
@@ -530,6 +553,31 @@ export const runtimeCompiledRoutingSchema = z.object({
         .max(1000)
         .default([]),
 });
+// What one finalize RUN cost, stage by stage, straight off the native
+// finalizer's envelope — which is why these keys are camelCase while the rest of
+// this receipt is not: PHP passes the object through rather than restating it.
+// Everything else here is read back from the version's immutable metadata;
+// timings cannot be, because they differ on every run. `skippedFiles` is the
+// incrementality gauge: it stays 0 while every finalize rebuilds everything.
+export const runtimeFinalizeTelemetrySchema = z.object({
+    stagedFiles: z.number().int().nonnegative(),
+    generatedFiles: z.number().int().nonnegative(),
+    decoratedFiles: z.number().int().nonnegative(),
+    skippedFiles: z.number().int().nonnegative(),
+    stagingMs: z.number().int().nonnegative(),
+    templateSubstitutionMs: z.number().int().nonnegative(),
+    htmlPipelineMs: z.number().int().nonnegative(),
+    // The four stages below ship with the finalizer that splits them out; an
+    // engine predating the split reports the coarser stages only.
+    conventionsMs: z.number().int().nonnegative().optional(),
+    zeroCompileMs: z.number().int().nonnegative().optional(),
+    blobInstallMs: z.number().int().nonnegative(),
+    listingsMs: z.number().int().nonnegative().optional(),
+    responseTablesMs: z.number().int().nonnegative(),
+    catalogDeltaMs: z.number().int().nonnegative(),
+    artifactsWriteMs: z.number().int().nonnegative().optional(),
+    totalMs: z.number().int().nonnegative(),
+});
 export const runtimeVersionFinalizeResponseSchema = z.object({
     space_id: z.string(),
     version_id: z.string(),
@@ -556,12 +604,15 @@ export const runtimeVersionFinalizeResponseSchema = z.object({
     // the catalog at finalize. Null when the version serves no image.
     preview_image_path: z.string().min(1).nullable().optional(),
     readiness_target: runtimeReadinessTargetSchema,
+    // Absent whenever the runtime answered without finalizing: a replayed or
+    // idempotent finalize re-runs no stage and reports no timings.
+    telemetry: runtimeFinalizeTelemetrySchema.optional(),
     activation_event_id: z
         .string()
         .min(1)
         .optional()
         .describe("Stable route_updated event id when finalize also activated a route."),
-    ...runtimeMutationPurgeShape,
+    ...runtimeMutationPurgeFields,
 });
 export const runtimeZeroMigrationsApplyResponseSchema = z.object({
     space_id: z.string(),
@@ -602,12 +653,12 @@ export const runtimeRouteUpdateResponseSchema = z.object({
         .min(1)
         .optional()
         .describe("Stable route_updated event id for this exact route command, including retries."),
-    ...runtimeMutationPurgeShape,
+    ...runtimeMutationPurgeFields,
 });
 export const runtimeHostnameIntentUpdateResponseSchema = z.object({
     space_id: z.string(),
     route_count: z.number().int().nonnegative(),
-    ...runtimeMutationPurgeShape,
+    ...runtimeMutationPurgeFields,
 });
 export const runtimeTombstonesUpdateRequestSchema = z.object({
     hostnames: runtimeRouteIntentSchema.shape.production_hostnames,
@@ -620,7 +671,7 @@ export const runtimeTombstonesUpdateRequestSchema = z.object({
 export const runtimeTombstonesUpdateResponseSchema = z.object({
     space_id: z.string(),
     tombstone_count: z.number().int().nonnegative(),
-    ...runtimeMutationPurgeShape,
+    ...runtimeMutationPurgeFields,
 });
 // The control plane computes prunable version ids; the engine stores the list
 // and its housekeeping tick prunes trees after re-checking live route pointers.
@@ -631,23 +682,13 @@ export const runtimeRetentionPolicyUpdateRequestSchema = z.object({
 export const runtimeRetentionPolicyUpdateResponseSchema = z.object({
     space_id: z.string(),
     prunable_count: z.number().int().nonnegative(),
-    ...runtimeMutationPurgeShape,
-});
-export const runtimeSpaceDeleteResponseSchema = z.object({
-    space_id: z.string(),
-    status: z.literal("deleted"),
-    ...runtimeMutationPurgeShape,
+    ...runtimeMutationPurgeFields,
 });
 export const runtimeVersionDeleteResponseSchema = z.object({
     space_id: z.string(),
     version_id: z.string(),
     status: z.literal("deleted"),
-    ...runtimeMutationPurgeShape,
-});
-export const runtimeSpaceRepairResponseSchema = z.object({
-    space_id: z.string(),
-    status: z.literal("repaired"),
-    ...runtimeMutationPurgeShape,
+    ...runtimeMutationPurgeFields,
 });
 // A pin freezes a set of blob SHAs against the collector for as long as it
 // lives. `snapshot` pins everything a set of versions plus space storage

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

@@ -23,8 +23,8 @@ export declare const runtimeAppSchema: z.ZodObject<{
         serverRuntime: z.ZodLiteral<"quickjs-rust">;
         inspect: z.ZodObject<{
             policy: z.ZodEnum<{
-                public: "public";
                 private: "private";
+                public: "public";
             }>;
         }, z.core.$strict>;
         install: z.ZodObject<{
@@ -36,7 +36,7 @@ export declare const runtimeAppSchema: z.ZodObject<{
             binary: z.ZodObject<{
                 path: z.ZodLiteral<"__spacefast/zero/bin/stattic-runtime">;
                 compatibilityTarget: z.ZodObject<{
-                    profile: z.ZodLiteral<"wpcloud-linux-x86_64-gnu-v1">;
+                    profile: z.ZodLiteral<"linux-x86_64-gnu-v1">;
                     os: z.ZodLiteral<"linux">;
                     cpu: z.ZodLiteral<"x86_64">;
                     libc: z.ZodLiteral<"glibc">;

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

@@ -17,7 +17,7 @@ import { z } from "zod";
 export declare const runtimeDbInspectResponseSchema: z.ZodObject<{
     versionId: z.ZodNullable<z.ZodString>;
     artifactId: z.ZodNullable<z.ZodString>;
-    backend: z.ZodNullable<z.ZodLiteral<"wpcloud-mysql">>;
+    backend: z.ZodNullable<z.ZodLiteral<"mysql">>;
     migrationMode: z.ZodNullable<z.ZodEnum<{
         safe: "safe";
         drop: "drop";
@@ -97,7 +97,7 @@ export declare const runtimeDbInspectPublicResponseSchema: z.ZodObject<{
     data: z.ZodObject<{
         versionId: z.ZodNullable<z.ZodString>;
         artifactId: z.ZodNullable<z.ZodString>;
-        backend: z.ZodNullable<z.ZodLiteral<"wpcloud-mysql">>;
+        backend: z.ZodNullable<z.ZodLiteral<"mysql">>;
         migrationMode: z.ZodNullable<z.ZodEnum<{
             safe: "safe";
             drop: "drop";
@@ -392,14 +392,14 @@ export declare const runtimeDbMigrateResponseSchema: z.ZodObject<{
             code: z.ZodString;
             severity: z.ZodEnum<{
                 info: "info";
-                warning: "warning";
                 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";
+                infra: "infra";
                 dns: "dns";
                 runtime: "runtime";
             }>>>;
@@ -412,13 +412,13 @@ export declare const runtimeDbMigrateResponseSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const runtimeDbConsoleSchema: z.ZodObject<{
-    provider: z.ZodLiteral<"wpcloud-phpmyadmin">;
+    provider: z.ZodLiteral<"phpmyadmin">;
     url: z.ZodString;
 }, z.core.$strict>;
 export type RuntimeDbConsole = z.infer<typeof runtimeDbConsoleSchema>;
 export declare const runtimeDbConsoleResponseSchema: z.ZodObject<{
     data: z.ZodObject<{
-        provider: z.ZodLiteral<"wpcloud-phpmyadmin">;
+        provider: z.ZodLiteral<"phpmyadmin">;
         url: z.ZodString;
     }, z.core.$strict>;
 }, z.core.$strip>;

package/dist/contracts/runtime-db.js

@@ -21,7 +21,7 @@ export const runtimeDbInspectResponseSchema = z
     .object({
     versionId: z.string().min(1).nullable(),
     artifactId: z.string().min(1).nullable(),
-    backend: z.literal("wpcloud-mysql").nullable(),
+    backend: z.literal("mysql").nullable(),
     migrationMode: z.enum(["safe", "drop", "rename"]).nullable(),
     schemaHash: executionSha256Schema.nullable(),
     tables: z.array(zeroTableSchema).default([]),
@@ -98,7 +98,7 @@ export const runtimeDbMigrateResultSchema = z
 export const runtimeDbMigrateResponseSchema = mutationEnvelope(runtimeDbMigrateResultSchema);
 export const runtimeDbConsoleSchema = z
     .object({
-    provider: z.literal("wpcloud-phpmyadmin"),
+    provider: z.literal("phpmyadmin"),
     url: z
         .string()
         .url()

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

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const runtimePurgeStatusSchema: z.ZodEnum<{
+    failed: "failed";
+    queued: "queued";
+    pending: "pending";
+    ok: "ok";
+}>;
+export type RuntimePurgeStatus = z.infer<typeof runtimePurgeStatusSchema>;

package/dist/contracts/runtime-purge.js

@@ -0,0 +1,7 @@
+import { z } from "zod";
+// One vocabulary for every runtime mutation that can invalidate edge state.
+// `queued` is a successful durable handoff: production FPM flushes the
+// management response once the purge journal owns the work, before the edge
+// provider call runs. `pending` is narrower — the synchronous worker kick did
+// not reach the purge entrypoint, so maintenance still owes the attempt.
+export const runtimePurgeStatusSchema = z.enum(["queued", "ok", "failed", "pending"]);

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

@@ -90,14 +90,14 @@ export declare const runtimeStorageDeletePublicResponseSchema: z.ZodObject<{
             code: z.ZodString;
             severity: z.ZodEnum<{
                 info: "info";
-                warning: "warning";
                 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";
+                infra: "infra";
                 dns: "dns";
                 runtime: "runtime";
             }>>>;
@@ -119,6 +119,7 @@ export declare const runtimeStorageReadKeyRotateResponseSchema: z.ZodObject<{
     purge: z.ZodObject<{
         status: z.ZodEnum<{
             failed: "failed";
+            queued: "queued";
             pending: "pending";
             ok: "ok";
         }>;

package/dist/contracts/runtime-storage.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { dataEnvelope, mutationEnvelope } from "./common.js";
+import { runtimePurgeStatusSchema } from "./runtime-purge.js";
 /** Objects are addressed by a bare 128-bit random id — there is no key and no visibility. */
 export const runtimeStorageObjectIdSchema = z.string().regex(/^[a-f0-9]{32}$/);
 /** The runtime-scoped, revocable read key that makes a `/__stattic/u/<id>` URL readable. */
@@ -53,7 +54,7 @@ export const runtimeStorageReadKeyRotateResponseSchema = z
     // was nothing to purge.
     purge: z
         .object({
-        status: z.enum(["ok", "failed", "pending"]),
+        status: runtimePurgeStatusSchema,
         mode: z.enum(["urls", "domain", "none"]),
         urls: z.number().int().nonnegative().optional(),
     })

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

@@ -4,10 +4,31 @@ export declare const SF_CONFIG_V1_FILES: readonly ["sf.jsonc", "spacefast.jsonc"
 /** 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.
+ * How a redirect answers. Omitting it means 302. There is no 200 and no 404:
+ * a rule that serves other content under the requested URL is a `rewrites`
+ * entry — with `notFound: true` when it should answer 404.
  */
 export type SfConfigV1RedirectStatus = 301 | 302 | 303 | 307 | 308;
+/**
+ * Query parameters a redirect or rewrite requires, as parameter name to
+ * capture name — `{ id: "id" }` is the `id=:id` token of a `_redirects` line,
+ * spelled the way the compiled rule (and the runtime matcher) carry it.
+ */
+export type SfConfigV1QueryMatch = Record<string, string>;
+/**
+ * One header operation: `{ key, value }` sets, `{ key, remove: true }` is the
+ * `!Name` line of a `_headers` block. The shape is what tells the two apart,
+ * so a remove entry carries no value.
+ */
+export type SfConfigV1HeaderEntry = {
+    key: string;
+    value: string;
+    remove?: never;
+} | {
+    key: string;
+    remove: true;
+    value?: never;
+};
 export type SfConfigV1 = {
     $schema?: typeof SF_CONFIG_V1_SCHEMA_URL;
     version: 1;
@@ -32,29 +53,36 @@ export type SfConfigV1 = {
         source: string;
         destination: string;
         status?: SfConfigV1RedirectStatus;
+        /** Answer even when the request path resolves to a committed file — the `!` of a `_redirects` rule. */
+        force?: boolean;
+        query?: SfConfigV1QueryMatch;
     }[];
     /**
      * 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.
+     * carry no status of their own. `notFound: true` answers 404 instead — the
+     * `/gone /404.html 404` rule, which is a rewrite in every way except the
+     * status; its destination must be a path.
      */
     rewrites?: {
         source: string;
         destination: string;
         /** Let shared caches store the proxy response. Absolute-URL destinations only. */
         cache?: "shared";
+        /** Rewrite even when the request path resolves to a committed file — the `!` of a `200!` / `404!` file rule. */
+        force?: boolean;
+        query?: SfConfigV1QueryMatch;
+        notFound?: boolean;
     }[];
     /**
-     * Response headers to set on matching requests. Headers are a list, not a
-     * map, so repeated names (Set-Cookie) survive.
+     * Response headers to set — or remove — on matching requests. Headers are a
+     * list, not a map, so repeated names (Set-Cookie) survive and operations
+     * keep their order.
      */
     headers?: {
         source: string;
-        headers: {
-            key: string;
-            value: string;
-        }[];
+        headers: SfConfigV1HeaderEntry[];
     }[];
     metadata?: {
         title?: string;
@@ -67,6 +95,15 @@ export type SfConfigV1 = {
     access?: {
         public: string[];
     };
+    /**
+     * Scheduled requests against this space's own paths. Declarations pass
+     * through verbatim — the compiled `__spacefast/crons.json` derives each
+     * entry's key from its path, and the schedule is never normalized here.
+     */
+    crons?: {
+        path: string;
+        schedule: string;
+    }[];
 };
 export type EffectiveConfigV1 = {
     version: 1;
@@ -88,6 +125,7 @@ export type EffectiveConfigV1 = {
     headers?: SfConfigV1["headers"];
     metadata?: SfConfigV1["metadata"];
     substitute?: SfConfigV1["substitute"];
+    crons?: SfConfigV1["crons"];
     grants?: Grant[];
 };
 /**
@@ -96,7 +134,7 @@ export type EffectiveConfigV1 = {
  * 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" | "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";
+    code: "config_alias" | "config_conflict" | "config_cron_duplicate_path" | "config_cron_invalid_path" | "config_cron_invalid_schedule" | "config_cron_too_many" | "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_query_match_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/space-config.d.ts

@@ -4,7 +4,7 @@ export declare const SPACE_CONFIG_ALIAS_FILES: readonly ["spacefast.jsonc", "spa
 export declare const SPACE_CONFIG_ACCEPTED_FILES: readonly ["sf.jsonc", "spacefast.jsonc", "spacefast.json", "sf.json", ".sf/sf.json", ".sf/config.jsonc", ".sf/config.json"];
 /**
  * Accepted config filenames in read precedence order, highest first. Kept in
- * step with the finalizer's `CONFIG_PRECEDENCE` (crates/stattic-runtime-core
+ * step with the finalizer's `CONFIG_ACCEPTED_FILES` (crates/stattic-runtime-core
  * protocol.rs) — the runtime compile is the selection authority, and a local
  * read choosing a different file than the publish serves is a split brain.
  */
@@ -35,6 +35,10 @@ export declare const SPACE_CONFIG_CAPS: {
     readonly themeNameChars: 120;
     /** Max top-level `name` (space display name) length. Matches the stored column. */
     readonly nameChars: 255;
+    /** Max `crons` entries. One provider crontab slot each, so the cap is small and hard. */
+    readonly crons: 8;
+    /** Max `crons[].path` length. */
+    readonly cronPathChars: 512;
 };
 /** Published JSON Schema URL for `sf.jsonc` ($schema autocomplete). */
 export declare const SPACE_CONFIG_SCHEMA_URL: string;
@@ -71,7 +75,6 @@ export declare const wordpressDataSourceSchema: z.ZodObject<{
     kind: z.ZodLiteral<"wordpress">;
     url: z.ZodString;
 }, z.core.$strict>;
-export type WordPressDataSource = z.infer<typeof wordpressDataSourceSchema>;
 export declare const spaceDataSourcesSchema: z.ZodPipe<z.ZodUnknown, z.ZodRecord<z.ZodString, z.ZodObject<{
     kind: z.ZodLiteral<"wordpress">;
     url: z.ZodString;
@@ -166,7 +169,6 @@ export declare const spaceConfigFileAccessSchema: z.ZodUnion<readonly [z.ZodPipe
 }, "public">>, z.ZodObject<{
     public: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
 }, z.core.$strict>]>;
-export type SpaceConfigFileAccess = z.infer<typeof spaceConfigFileAccessSchema>;
 /**
  * Zero: a transactional app with its own database.
  *
@@ -193,6 +195,7 @@ export declare const spaceRuntimeFunctionsSchema: 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>;
 /**
@@ -211,11 +214,60 @@ export declare const spaceRuntimeSchema: z.ZodDiscriminatedUnion<[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">;
 export type SpaceRuntimeZeroConfig = z.infer<typeof spaceRuntimeZeroSchema>;
 export type SpaceRuntimeFunctionsConfig = z.infer<typeof spaceRuntimeFunctionsSchema>;
 export type SpaceRuntimeConfig = z.infer<typeof spaceRuntimeSchema>;
+/**
+ * Scheduled requests: the provider crontab asks this space for these paths on
+ * these schedules.
+ *
+ * File-only for the same reason `runtime` is: what runs on a schedule 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.
+ *
+ * The Rust config compiler is the selection authority for both fields; this
+ * schema exists so an editor and an agent get the same answer before publish.
+ */
+export declare const SPACE_CRON_NAMED_SCHEDULES: readonly ["hourly", "daily", "twicedaily", "weekly"];
+/**
+ * The wp.cloud schedule grammar: a named interval, an `Nh`/`Nd`/`Nw` count, or
+ * a five-field crontab expression. No `@daily` macros and no month/day names —
+ * the provider does not accept them either.
+ */
+export declare function isSpaceCronSchedule(schedule: string): boolean;
+/**
+ * The artifact key for a cron path: lowercase, leading `/` stripped, every run
+ * of non-alphanumerics collapsed to one `-`, trimmed. Two paths that produce
+ * one key are rejected, so a key names exactly one schedule.
+ */
+export declare function spaceCronKey(path: string): string;
+/** Generated runtime file the serving engine reads, written only when a version declares a cron. */
+export declare const SPACE_CRONS_ARTIFACT_PATH = "__spacefast/crons.json";
+export declare const SPACE_CRONS_ARTIFACT_VERSION = 1;
+/** One compiled cron, as the artifact carries it. */
+export type SpaceCronEntry = {
+    /** Slug of `path`; unique within a version. */
+    key: string;
+    path: string;
+    /** Verbatim as declared — never normalized or expanded. */
+    schedule: string;
+};
+export type SpaceCronsArtifact = {
+    version: typeof SPACE_CRONS_ARTIFACT_VERSION;
+    crons: SpaceCronEntry[];
+};
+export declare const spaceCronSchema: z.ZodObject<{
+    path: z.ZodString;
+    schedule: z.ZodString;
+}, z.core.$strip>;
+export declare const spaceCronsSchema: z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    schedule: z.ZodString;
+}, z.core.$strip>>;
+export type SpaceCronConfig = z.infer<typeof spaceCronSchema>;
 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<{
@@ -307,8 +359,13 @@ export declare const spaceConfigFileSchema: 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>>>;
 }, z.core.$strip>;
 export type SpaceConfigFile = z.infer<typeof spaceConfigFileSchema>;
 /**