@spacefast/common 0.0.23 → 0.0.26

package/dist/contracts/functions.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { runtimeKindSchema, type ExecutionCapabilities } from "./execution.js";
+import { type ExecutionCapabilities } from "./execution.js";
 /**
  * Spacefast Functions: tenant workers run as Cloudflare Dynamic Workers.
  *
@@ -37,6 +37,13 @@ import { runtimeKindSchema, type ExecutionCapabilities } from "./execution.js";
  * than transactional. That is why capsules are a different product rather
  * than a placement option — see `endpointIsPortable` in `./execution.js`.
  */
+/**
+ * The tag a compiled worker artifact carries — in `functionsSourceFinalizeSchema`
+ * and the runtime config built from it — so the PHP origin can tell what it is
+ * dispatching (`functions-dispatch.php` refuses a config tagged anything else).
+ * It is a property of the artifact the tree produced, not a kind a space or a
+ * version declares: a publish can carry this beside a capsule.
+ */
 export declare const FUNCTIONS_RUNTIME_KIND = "functions";
 export declare const FUNCTIONS_SOURCE_METADATA_KEY = "spacefastFunctions";
 export declare const FUNCTIONS_PLATFORM_ROUTE_PREFIX = "/__spacefast/functions";
@@ -44,7 +51,32 @@ export declare const FUNCTIONS_RUNTIME_ROUTE_PATHS: {
     readonly logs: "/__spacefast/functions/logs";
     /** Where a dispatched worker calls back for brokered capabilities. */
     readonly relay: "/__spacefast/functions/relay";
+    /**
+     * Where the execution host asks the space origin to drop cached responses —
+     * an OpenNext `revalidatePath` must reach the CDN in front of wp.cloud, and
+     * only the origin can speak for its own cache. Authenticated with the
+     * version-scoped purge credential in the `sf-purge-token` request header.
+     */
+    readonly purge: "/__spacefast/functions/purge";
 };
+/**
+ * The header the execution host presents at the origin purge route. Outside the
+ * `sf-fx-` namespace on purpose: that prefix names dispatch instructions the
+ * origin SENDS, and is stripped from anything inbound before tenant code — a
+ * purge call is the host speaking for itself, like a relay call.
+ */
+export declare const FUNCTIONS_PURGE_TOKEN_HEADER = "sf-purge-token";
+/**
+ * Where invocation counts are reported, on the CONTROL PLANE rather than the
+ * space origin.
+ *
+ * The two destinations are separate on purpose. Logs are the tenant's content
+ * and stay on their own origin; usage is a number the platform bills from and
+ * goes straight to us. Sharing one channel would make either destination a
+ * plausible place to look for the other's data, and would put log volume on the
+ * path that has to stay cheap.
+ */
+export declare const FUNCTIONS_USAGE_INTAKE_PATH = "/v1/runtime/functions/usage";
 /** Public, signed read path. Distinct from storage so the token is never a filename. */
 export declare const FUNCTIONS_BUNDLE_ROUTE_PREFIX = "/__spacefast/functions/b";
 export declare const FUNCTIONS_RUNTIME_STORAGE_ROOT = "__spacefast/functions";
@@ -71,7 +103,17 @@ export declare const FUNCTIONS_RUNTIME_STORAGE_ROOT = "__spacefast/functions";
  * was never given.
  */
 export declare const FUNCTIONS_RUNTIME_BUNDLE_ROOT = "__spacefast/functions/bundles";
+/**
+ * Where a version's Next-cache seed document lives — the build-time prerender
+ * and fetch-cache entries that warm the execution host's cache object so the
+ * first visitor gets the page the build rendered instead of a live re-render.
+ * A sibling of `bundles/` with the same properties: publishable through the
+ * ordinary upload path (its own carve-out in publish-policy), never servable
+ * as static content, read back only through the signed artifact route.
+ */
+export declare const FUNCTIONS_RUNTIME_SEED_ROOT = "__spacefast/functions/seeds";
 export declare const FUNCTIONS_BUNDLE_FORMAT = "spacefast.functions.bundle.v1";
+export declare const FUNCTIONS_SEED_FORMAT = "spacefast.functions.seed.v1";
 /**
  * Ceiling on a bundle's decoded size.
  *
@@ -82,10 +124,67 @@ export declare const FUNCTIONS_BUNDLE_FORMAT = "spacefast.functions.bundle.v1";
  * modules are large, rather than at dispatch, where the tenant sees a 502.
  */
 export declare const FUNCTIONS_BUNDLE_MAX_BYTES: number;
+/**
+ * Ceilings on the cache seed document. Per-entry mirrors the cache object's
+ * own row limit (an entry the object would refuse is dead weight in the
+ * document); the total bounds what the host pulls and ingests on a cold
+ * cache. Both are enforced in the CLI, where an overflow can say WHICH pages
+ * were left out — an omitted entry is not an error, it just renders live on
+ * first request like any cache miss.
+ */
+export declare const FUNCTIONS_SEED_ENTRY_MAX_BYTES: number;
+export declare const FUNCTIONS_SEED_MAX_BYTES: number;
+/**
+ * One warm-cache entry: exactly what the runtime's incremental-cache client
+ * would have written for `key` had it rendered the page itself. `valueJson`
+ * is carried as the JSON string it already is on disk (OpenNext's `.cache` /
+ * fetch-cache files) — re-parsing it here would only invite the seed writer
+ * and the cache client to disagree about serialization.
+ */
+export declare const functionsSeedEntrySchema: z.ZodObject<{
+    key: z.ZodString;
+    cacheType: z.ZodEnum<{
+        fetch: "fetch";
+        cache: "cache";
+    }>;
+    valueJson: z.ZodString;
+    lastModified: z.ZodNumber;
+}, z.core.$strict>;
+export type FunctionsSeedEntry = z.infer<typeof functionsSeedEntrySchema>;
+/** The document served at a seed URL; host and CLI validate the same shape. */
+export declare const functionsSeedManifestSchema: z.ZodObject<{
+    format: z.ZodLiteral<"spacefast.functions.seed.v1">;
+    entries: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        cacheType: z.ZodEnum<{
+            fetch: "fetch";
+            cache: "cache";
+        }>;
+        valueJson: z.ZodString;
+        lastModified: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type FunctionsSeedManifest = z.infer<typeof functionsSeedManifestSchema>;
+/**
+ * How many entries the origin's dispatch table accepts.
+ *
+ * Exported because the CLI classifier has to compact its route claims BEFORE
+ * assembling the artifact — discovering the ceiling as a validation error at
+ * finalize would mean a build that classified fine fails at the last step — so
+ * the ceiling has to be a value both sides can read, not a literal each side
+ * spells for itself.
+ */
+export declare const FUNCTIONS_MAX_ROUTES = 256;
 /**
  * A worker's dynamic route table. Anything not matched here is answered from
  * the version's static content by wp.cloud and never reaches Cloudflare, which
  * is both the cheaper path and the one that keeps assets ours.
+ *
+ * A `subtree` entry covers its own path AND everything below it: the engine
+ * expands one into both `path` and `path/:splat`
+ * (`_stattic_runtime_functions_routes_artifact`, runtime/engine/admin/management.php),
+ * which is why `wholeSiteRoutes()` is a single `/` subtree entry and why an
+ * exact entry beside a subtree entry at the same path is dead weight.
  */
 export declare const functionsRouteSchema: z.ZodObject<{
     method: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
@@ -105,8 +204,9 @@ export type FunctionsRoute = z.infer<typeof functionsRouteSchema>;
  * One module in a bundle, in the shape the Worker Loader consumes.
  *
  * `commonjs` exists because bundlers still emit it and rejecting it would fail
- * builds for a format the runtime accepts. Binary module types are deliberately
- * absent: nothing we build today emits them, and adding one later is additive.
+ * builds for a format the runtime accepts. Binary modules cross this JSON wire
+ * format as base64; the Functions host turns them back into ArrayBuffers at the
+ * Worker Loader boundary.
  */
 export declare const functionsBundleModuleSchema: z.ZodUnion<readonly [z.ZodObject<{
     js: z.ZodString;
@@ -116,6 +216,10 @@ export declare const functionsBundleModuleSchema: z.ZodUnion<readonly [z.ZodObje
     text: z.ZodString;
 }, z.core.$strict>, z.ZodObject<{
     json: z.ZodUnknown;
+}, z.core.$strict>, z.ZodObject<{
+    wasm: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    data: z.ZodString;
 }, z.core.$strict>]>;
 export type FunctionsBundleModule = z.infer<typeof functionsBundleModuleSchema>;
 /**
@@ -137,6 +241,10 @@ export declare const functionsBundleManifestSchema: z.ZodObject<{
         text: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         json: z.ZodUnknown;
+    }, z.core.$strict>, z.ZodObject<{
+        wasm: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        data: z.ZodString;
     }, z.core.$strict>]>>;
 }, z.core.$strict>;
 export type FunctionsBundleManifest = z.infer<typeof functionsBundleManifestSchema>;
@@ -153,6 +261,18 @@ export declare const functionsBundleRefSchema: z.ZodObject<{
     size: z.ZodNumber;
 }, z.core.$strict>;
 export type FunctionsBundleRef = z.infer<typeof functionsBundleRefSchema>;
+/**
+ * Where a version's cache seed document sits in its content store — the
+ * bundle ref's sibling, with the seed's own root and ceiling. `entries` is
+ * carried so status surfaces can say what the seed holds without fetching it.
+ */
+export declare const functionsSeedRefSchema: z.ZodObject<{
+    path: z.ZodString;
+    sha256: z.ZodString;
+    size: z.ZodNumber;
+    entries: z.ZodNumber;
+}, z.core.$strict>;
+export type FunctionsSeedRef = z.infer<typeof functionsSeedRefSchema>;
 /**
  * The path a bundle is served from.
  *
@@ -175,6 +295,16 @@ export declare function functionsBundlePath(input: {
     sha256: string;
     token: string;
 }): string;
+/**
+ * The seed document's read path — the bundle route with a different terminal
+ * filename and its own token audience. One signed artifact route on the
+ * origin serves both: the filename says what the digest names, the token's
+ * audience says what the caller was authorised to read.
+ */
+export declare function functionsSeedPath(input: {
+    sha256: string;
+    token: string;
+}): string;
 /**
  * Where the bundle actually sits in the published version — the same path minus
  * the token segment. The token authorises the read; it does not name the file,
@@ -183,6 +313,10 @@ export declare function functionsBundlePath(input: {
 export declare function functionsBundleStoragePath(input: {
     sha256: string;
 }): string;
+/** The seed's storage twin of `functionsBundleStoragePath`. */
+export declare function functionsSeedStoragePath(input: {
+    sha256: string;
+}): string;
 export declare const functionsWorkerArtifactSchema: z.ZodObject<{
     format: z.ZodLiteral<"spacefast.functions.worker.v1">;
     appName: z.ZodString;
@@ -193,6 +327,12 @@ export declare const functionsWorkerArtifactSchema: z.ZodObject<{
         sha256: z.ZodString;
         size: z.ZodNumber;
     }, z.core.$strict>;
+    seed: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        path: z.ZodString;
+        sha256: z.ZodString;
+        size: z.ZodNumber;
+        entries: z.ZodNumber;
+    }, z.core.$strict>>>;
     compatibilityDate: z.ZodString;
     compatibilityFlags: z.ZodDefault<z.ZodArray<z.ZodString>>;
     routes: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -208,6 +348,7 @@ export declare const functionsWorkerArtifactSchema: z.ZodObject<{
         path: z.ZodString;
         subtree: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strict>>>;
+    bypassCookies: z.ZodDefault<z.ZodArray<z.ZodString>>;
     capabilities: z.ZodDefault<z.ZodObject<{
         db: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
         fetch: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
@@ -215,7 +356,13 @@ export declare const functionsWorkerArtifactSchema: z.ZodObject<{
         env: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
         realtime: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
         logging: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        gravatar: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        spam: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        email: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
     }, z.core.$strip>>;
+    platform: z.ZodDefault<z.ZodObject<{
+        nextCache: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export type FunctionsWorkerArtifact = z.infer<typeof functionsWorkerArtifactSchema>;
 /**
@@ -227,19 +374,25 @@ export type FunctionsWorkerArtifact = z.infer<typeof functionsWorkerArtifactSche
  * *grants*, resolved by the control plane at finalize so the origin forwards a
  * decision rather than making one. Anything absent fails closed at the relay.
  */
-export declare const FUNCTIONS_DISPATCH_CAPABILITIES: readonly ["db.read", "db.write", "fetch", "log"];
+export declare const FUNCTIONS_DISPATCH_CAPABILITIES: readonly ["storage.read", "storage.write", "db.read", "db.write", "fetch", "log", "next.cache", "gravatar.profile", "spam.check", "email.send"];
 export declare const functionsDispatchCapabilitySchema: z.ZodEnum<{
     fetch: "fetch";
+    "storage.read": "storage.read";
+    "storage.write": "storage.write";
     "db.read": "db.read";
     "db.write": "db.write";
     log: "log";
+    "next.cache": "next.cache";
+    "gravatar.profile": "gravatar.profile";
+    "spam.check": "spam.check";
+    "email.send": "email.send";
 }>;
 export type FunctionsDispatchCapability = z.infer<typeof functionsDispatchCapabilitySchema>;
 /**
  * Resolves a build's declared capabilities into the grant a dispatch carries.
  *
- * Three of the six declared capabilities have no dispatch counterpart, and each
- * for its own reason:
+ * Three declared capabilities have no dispatch counterpart, each for its own
+ * reason:
  *
  * - `env` is not a runtime call at all. Values are resolved at finalize and
  *   travel in the config, so a worker reading `env` reaches nothing.
@@ -251,9 +404,16 @@ export type FunctionsDispatchCapability = z.infer<typeof functionsDispatchCapabi
  * touches the database, not how. Narrowing it would take per-statement analysis
  * we do not do, and guessing "read-only" from a declaration would be a grant
  * the author never asked for and cannot see.
+ *
+ * The three platform-service grants are named for the operation an author
+ * reaches for, and each covers its service's whole operation set for the same
+ * reason `db` widens: a declaration says a handler uses spam checking, not that
+ * it never files a correction.
  */
-export declare function functionsDispatchCapabilities(capabilities: ExecutionCapabilities): FunctionsDispatchCapability[];
-/** Everything except `log` needs the relay to mean anything. */
+export declare function functionsDispatchCapabilities(capabilities: ExecutionCapabilities, platform?: {
+    nextCache?: boolean;
+}): FunctionsDispatchCapability[];
+/** Logs and the host-local Next cache do not transit the origin relay. */
 export declare function functionsGrantNeedsRelay(granted: readonly FunctionsDispatchCapability[]): boolean;
 /**
  * What the space origin needs in order to dispatch to the host on its own. The
@@ -266,6 +426,7 @@ export declare function functionsGrantNeedsRelay(granted: readonly FunctionsDisp
 export declare const functionsHostConfigSchema: z.ZodObject<{
     hostname: z.ZodString;
     bundleUrl: z.ZodString;
+    seedUrl: z.ZodDefault<z.ZodNullable<z.ZodString>>;
 }, z.core.$strict>;
 export type FunctionsHostConfig = z.infer<typeof functionsHostConfigSchema>;
 /**
@@ -286,6 +447,35 @@ export declare const functionsRelayConfigSchema: z.ZodObject<{
     maxConcurrentCalls: z.ZodNumber;
 }, z.core.$strict>;
 export type FunctionsRelayConfig = z.infer<typeof functionsRelayConfigSchema>;
+/**
+ * Where the execution host reports how much this version ran.
+ *
+ * Absent means uncounted, not refused: a space whose configuration predates
+ * usage reporting must keep serving, and an execution tier that cannot reach
+ * the control plane must never fail a request over it. Counting is reporting
+ * only — nothing here throttles, and no limit is enforced anywhere from it.
+ */
+export declare const functionsUsageConfigSchema: z.ZodObject<{
+    url: z.ZodString;
+    token: z.ZodString;
+}, z.core.$strict>;
+export type FunctionsUsageConfig = z.infer<typeof functionsUsageConfigSchema>;
+/**
+ * The credential the execution host presents at the origin's purge route.
+ *
+ * Only the token lives here: the purge route is on whichever hostname the
+ * visitor actually hit, so the origin composes the URL from the request host at
+ * dispatch time — exactly as it does for log intake — instead of freezing one
+ * hostname at finalize. A third credential rather than a reuse of the relay's,
+ * for the relay's own reason: purging cached responses is a distinct authority,
+ * and a worker whose relay is unusable must still be able to invalidate what it
+ * rendered. Version-scoped and folded into the host's isolate identity like its
+ * siblings, so a republish revokes it.
+ */
+export declare const functionsPurgeConfigSchema: z.ZodObject<{
+    token: z.ZodString;
+}, z.core.$strict>;
+export type FunctionsPurgeConfig = z.infer<typeof functionsPurgeConfigSchema>;
 /**
  * What a build declares about its worker — everything the CLI can know from the
  * author's project alone.
@@ -309,6 +499,12 @@ export declare const functionsSourceFinalizeSchema: z.ZodObject<{
             sha256: z.ZodString;
             size: z.ZodNumber;
         }, z.core.$strict>;
+        seed: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            path: z.ZodString;
+            sha256: z.ZodString;
+            size: z.ZodNumber;
+            entries: z.ZodNumber;
+        }, z.core.$strict>>>;
         compatibilityDate: z.ZodString;
         compatibilityFlags: z.ZodDefault<z.ZodArray<z.ZodString>>;
         routes: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -324,6 +520,7 @@ export declare const functionsSourceFinalizeSchema: z.ZodObject<{
             path: z.ZodString;
             subtree: z.ZodDefault<z.ZodBoolean>;
         }, z.core.$strict>>>;
+        bypassCookies: z.ZodDefault<z.ZodArray<z.ZodString>>;
         capabilities: z.ZodDefault<z.ZodObject<{
             db: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
             fetch: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
@@ -331,7 +528,13 @@ export declare const functionsSourceFinalizeSchema: z.ZodObject<{
             env: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
             realtime: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
             logging: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            gravatar: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            spam: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            email: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
         }, z.core.$strip>>;
+        platform: z.ZodDefault<z.ZodObject<{
+            nextCache: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strict>>;
     }, z.core.$strict>;
     variables: z.ZodDefault<z.ZodObject<{
         source: z.ZodLiteral<"spacefast-variables">;
@@ -343,9 +546,10 @@ export type FunctionsSourceFinalize = z.infer<typeof functionsSourceFinalizeSche
  * The document the control plane sends to the runtime, which the engine stores
  * beside the version's files and the origin reads on every dispatch.
  *
- * It is the build's declaration plus the four things only the platform can
- * supply: where to dispatch, what the worker is allowed to do, the credential
- * that lets it do those things, and the resolved values of its variables.
+ * It is the build's declaration plus the things only the platform can supply:
+ * where to dispatch, what the worker is allowed to do, the credentials that let
+ * it do those things and report what it did, and the resolved values of its
+ * variables.
  */
 export declare const functionsRuntimeConfigSchema: z.ZodObject<{
     runtimeKind: z.ZodLiteral<"functions">;
@@ -359,6 +563,12 @@ export declare const functionsRuntimeConfigSchema: z.ZodObject<{
             sha256: z.ZodString;
             size: z.ZodNumber;
         }, z.core.$strict>;
+        seed: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            path: z.ZodString;
+            sha256: z.ZodString;
+            size: z.ZodNumber;
+            entries: z.ZodNumber;
+        }, z.core.$strict>>>;
         compatibilityDate: z.ZodString;
         compatibilityFlags: z.ZodDefault<z.ZodArray<z.ZodString>>;
         routes: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -374,6 +584,7 @@ export declare const functionsRuntimeConfigSchema: z.ZodObject<{
             path: z.ZodString;
             subtree: z.ZodDefault<z.ZodBoolean>;
         }, z.core.$strict>>>;
+        bypassCookies: z.ZodDefault<z.ZodArray<z.ZodString>>;
         capabilities: z.ZodDefault<z.ZodObject<{
             db: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
             fetch: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
@@ -381,7 +592,13 @@ export declare const functionsRuntimeConfigSchema: z.ZodObject<{
             env: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
             realtime: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
             logging: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            gravatar: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            spam: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            email: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
         }, z.core.$strip>>;
+        platform: z.ZodDefault<z.ZodObject<{
+            nextCache: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strict>>;
     }, z.core.$strict>;
     variables: z.ZodDefault<z.ZodObject<{
         source: z.ZodLiteral<"spacefast-variables">;
@@ -390,12 +607,19 @@ export declare const functionsRuntimeConfigSchema: z.ZodObject<{
     host: z.ZodObject<{
         hostname: z.ZodString;
         bundleUrl: z.ZodString;
+        seedUrl: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     }, z.core.$strict>;
     grantedCapabilities: z.ZodDefault<z.ZodArray<z.ZodEnum<{
         fetch: "fetch";
+        "storage.read": "storage.read";
+        "storage.write": "storage.write";
         "db.read": "db.read";
         "db.write": "db.write";
         log: "log";
+        "next.cache": "next.cache";
+        "gravatar.profile": "gravatar.profile";
+        "spam.check": "spam.check";
+        "email.send": "email.send";
     }>>>;
     relay: z.ZodDefault<z.ZodNullable<z.ZodObject<{
         url: z.ZodString;
@@ -403,6 +627,13 @@ export declare const functionsRuntimeConfigSchema: z.ZodObject<{
         maxBatchStatements: z.ZodNumber;
         maxConcurrentCalls: z.ZodNumber;
     }, z.core.$strict>>>;
+    usage: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        url: z.ZodString;
+        token: z.ZodString;
+    }, z.core.$strict>>>;
+    purge: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        token: z.ZodString;
+    }, z.core.$strict>>>;
     variableValues: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, z.core.$strict>;
 export type FunctionsRuntimeConfig = z.infer<typeof functionsRuntimeConfigSchema>;
@@ -420,6 +651,12 @@ export declare const functionsDeployMetadataSchema: z.ZodObject<{
                 sha256: z.ZodString;
                 size: z.ZodNumber;
             }, z.core.$strict>;
+            seed: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                path: z.ZodString;
+                sha256: z.ZodString;
+                size: z.ZodNumber;
+                entries: z.ZodNumber;
+            }, z.core.$strict>>>;
             compatibilityDate: z.ZodString;
             compatibilityFlags: z.ZodDefault<z.ZodArray<z.ZodString>>;
             routes: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -435,6 +672,7 @@ export declare const functionsDeployMetadataSchema: z.ZodObject<{
                 path: z.ZodString;
                 subtree: z.ZodDefault<z.ZodBoolean>;
             }, z.core.$strict>>>;
+            bypassCookies: z.ZodDefault<z.ZodArray<z.ZodString>>;
             capabilities: z.ZodDefault<z.ZodObject<{
                 db: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                 fetch: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
@@ -442,7 +680,13 @@ export declare const functionsDeployMetadataSchema: z.ZodObject<{
                 env: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                 realtime: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                 logging: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+                gravatar: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+                spam: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+                email: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
             }, z.core.$strip>>;
+            platform: z.ZodDefault<z.ZodObject<{
+                nextCache: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strict>>;
         }, z.core.$strict>;
         variables: z.ZodDefault<z.ZodObject<{
             source: z.ZodLiteral<"spacefast-variables">;
@@ -463,10 +707,13 @@ export declare function createFunctionsSourceFinalize(input: {
     entry: string;
     mainModule: string;
     bundle: z.input<typeof functionsBundleRefSchema>;
+    seed?: z.input<typeof functionsSeedRefSchema> | null;
     compatibilityDate: string;
     compatibilityFlags?: string[];
     routes?: z.input<typeof functionsRouteSchema>[];
+    bypassCookies?: string[];
     capabilities?: ExecutionCapabilities;
+    nextCache?: boolean;
     variableNames?: string[];
 }): FunctionsSourceFinalize;
 /**
@@ -485,10 +732,12 @@ export declare const functionsExecutionStateSchema: z.ZodEnum<{
 }>;
 export type FunctionsExecutionState = z.infer<typeof functionsExecutionStateSchema>;
 /**
- * What a live worker is, as the `app` member of a space's runtime status.
+ * What a live worker is, as the `worker` member of a space's runtime status.
+ *
+ * It carries no kind tag. The member it rides in already says which product
+ * answered, and the same tree can carry a capsule beside it — a discriminant
+ * here could only repeat the field name or contradict its sibling.
  *
- * Shaped like `zeroAppSchema` and discriminated by the same `runtimeKind`, so a
- * reader switches on one field rather than probing for which product answered.
  * No `versionId`: the status response it rides in already names the live
  * version.
  *
@@ -498,7 +747,6 @@ export type FunctionsExecutionState = z.infer<typeof functionsExecutionStateSche
  * branches on, and stating it twice invites the two to disagree.
  */
 export declare const functionsAppSchema: z.ZodObject<{
-    runtimeKind: z.ZodLiteral<"functions">;
     artifactId: z.ZodString;
     appName: z.ZodString;
     entry: z.ZodString;
@@ -524,6 +772,9 @@ export declare const functionsAppSchema: z.ZodObject<{
         env: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
         realtime: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
         logging: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        gravatar: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        spam: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        email: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
     }, z.core.$strip>>;
     executionState: z.ZodEnum<{
         ready: "ready";
@@ -538,60 +789,3 @@ export declare const functionsAppSchema: z.ZodObject<{
     }, z.core.$strict>;
 }, z.core.$strict>;
 export type FunctionsApp = z.infer<typeof functionsAppSchema>;
-/**
- * The wire shape of the origin's log-read route, not a public API contract.
- *
- * Handler logs reach callers through `GET /v1/spaces/:spaceId/logs/runtime`,
- * which serves the platform's own `runtimeLogListResponseSchema` for both
- * execution tiers. These aliases describe the hop underneath it: a worker tails
- * its output to the origin that dispatched it, and the control plane reads it
- * back from there. Keeping them named after this product is the point — the
- * origin is the only place a wp.cloud-hosted space keeps anything, and Zero's
- * records never travel this path at all.
- */
-export declare const functionsLogEntrySchema: z.ZodObject<{
-    id: z.ZodString;
-    timestamp: z.ZodString;
-    level: z.ZodEnum<{
-        info: "info";
-        error: "error";
-        debug: "debug";
-        warn: "warn";
-    }>;
-    requestId: z.ZodNullable<z.ZodString>;
-    versionId: z.ZodNullable<z.ZodString>;
-    handlerName: z.ZodNullable<z.ZodString>;
-    message: z.ZodString;
-    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strict>;
-export type FunctionsLogEntry = z.infer<typeof functionsLogEntrySchema>;
-export declare const functionsLogListQuerySchema: z.ZodObject<{
-    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-    cursor: z.ZodOptional<z.ZodString>;
-    requestId: z.ZodOptional<z.ZodString>;
-    handlerName: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export type FunctionsLogListQuery = z.infer<typeof functionsLogListQuerySchema>;
-export declare const functionsLogListResponseSchema: z.ZodObject<{
-    data: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        timestamp: z.ZodString;
-        level: z.ZodEnum<{
-            info: "info";
-            error: "error";
-            debug: "debug";
-            warn: "warn";
-        }>;
-        requestId: z.ZodNullable<z.ZodString>;
-        versionId: z.ZodNullable<z.ZodString>;
-        handlerName: z.ZodNullable<z.ZodString>;
-        message: z.ZodString;
-        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strict>>;
-    pagination: z.ZodObject<{
-        nextCursor: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export type FunctionsLogListResponse = z.infer<typeof functionsLogListResponseSchema>;
-/** Narrows a space's live runtime kind to this product. */
-export declare function isFunctionsRuntime(kind: z.infer<typeof runtimeKindSchema> | null): boolean;