@spacefast/common 0.0.24 → 0.0.26

package/dist/contracts/features.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 import { FEATURE_RUNTIME_DEFINITIONS, FEATURE_RUNTIME_KEYS, } from "./feature-lifecycle.js";
-// Spec plan vocabulary (internal-docs/platform.md "Plans And Limits").
+// Spec plan vocabulary (the platform spec "Plans And Limits").
 // `enterprise` and `internal` are named plans without self-serve pricing.
+// Codes are wire/storage vocabulary and never change with marketing renames:
+// `personal` sells as "Plus" and `work` as "Pro" (2026-08 rename) — display
+// names live on PlanDefinition.name.
 export const PLAN_CODES = ["free", "personal", "work", "enterprise", "internal"];
 export const planCodeSchema = z.enum(PLAN_CODES).describe("Plan code.");
 export const DEFAULT_PLAN_CODE = "free";
@@ -21,7 +24,7 @@ export const featureOverrideStateSchema = z.enum(FEATURE_OVERRIDE_STATES);
 export const planLimitValueSchema = z
     .union([z.number().int().nonnegative(), z.literal("unlimited")])
     .describe('Plan limit value; "unlimited" when the plan does not limit this axis.');
-// Named plan limit table (internal-docs/platform.md "Plans And Limits",
+// Named plan limit table (the platform spec "Plans And Limits",
 // Free/Personal/Work columns verbatim). Keys mirror `PlanPolicyResponse.limits`
 // so plan policy is a projection of this data, never a re-derivation.
 export const planLimitsSchema = z
@@ -31,7 +34,7 @@ export const planLimitsSchema = z
     subTeams: planLimitValueSchema,
     externalDomainGroups: planLimitValueSchema,
     // Per-space daily bandwidth cap feeding the egress kill-switch sweep
-    // (internal-docs/platform.md "Abuse Posture"; internal plan data — never on
+    // (the platform spec "Abuse Posture"; internal plan data — never on
     // the PlanPolicyResponse wire shape). WORST_CASE_QUOTAS
     // .maxEgressBytesPerSpacePerDay stays the absolute platform ceiling.
     egressBytesPerDay: planLimitValueSchema,
@@ -126,11 +129,13 @@ export const PLAN_DEFINITIONS = {
         name: "Free",
         monthlyPriceUsd: 0,
         yearlyPriceUsd: 0,
-        includedSeats: 3,
+        // Free is single-player: the owner is the only editor. Reviewers and
+        // agent principals are not seats.
+        includedSeats: 1,
         extraSeatPriceUsd: null,
         limits: {
-            storageBytes: 5 * GB,
-            teamMembers: 3,
+            storageBytes: 10 * GB,
+            teamMembers: 1,
             subTeams: 0,
             externalDomainGroups: 3,
             egressBytesPerDay: 100 * GB, // = worst-case ceiling; tunable per plan
@@ -149,15 +154,17 @@ export const PLAN_DEFINITIONS = {
     },
     personal: {
         code: "personal",
-        name: "Personal",
-        monthlyPriceUsd: 5,
-        yearlyPriceUsd: 60,
-        includedSeats: 5,
-        extraSeatPriceUsd: { monthly: 1, yearly: 12 },
+        name: "Plus",
+        monthlyPriceUsd: 4.99,
+        yearlyPriceUsd: 49.99,
+        includedSeats: 3,
+        // Each paid seat also raises usage limits (builds, domains, emails,
+        // versions) via additive grants — the seat price is not access alone.
+        extraSeatPriceUsd: { monthly: 4.99, yearly: 49.99 },
         limits: {
             ...UNLIMITED_LIMITS,
-            storageBytes: 20 * GB,
-            teamMembers: 5,
+            storageBytes: 50 * GB,
+            teamMembers: 3,
             subTeams: 0,
             externalDomainGroups: 10,
             maxFileBytes: 1 * GB,
@@ -174,18 +181,18 @@ export const PLAN_DEFINITIONS = {
     },
     work: {
         code: "work",
-        name: "Work",
-        monthlyPriceUsd: 15,
-        yearlyPriceUsd: 180,
-        includedSeats: 15,
-        extraSeatPriceUsd: { monthly: 1, yearly: 12 },
+        name: "Pro",
+        monthlyPriceUsd: 49.99,
+        yearlyPriceUsd: 499,
+        includedSeats: 10,
+        extraSeatPriceUsd: { monthly: 4.99, yearly: 49.99 },
         limits: {
             ...UNLIMITED_LIMITS,
-            storageBytes: 50 * GB,
+            storageBytes: 200 * GB,
             // The catalog keeps the included quantity numeric for display and seat
             // billing. An active paid Stripe source lifts admission separately so
             // editors beyond this number can be added and reconciled automatically.
-            teamMembers: 15,
+            teamMembers: 10,
             subTeams: 0,
             ...ACCESS_QUOTA_DEFAULTS,
         },

package/dist/contracts/functions.d.ts

@@ -51,7 +51,21 @@ 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.
@@ -89,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.
  *
@@ -100,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<{
@@ -123,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;
@@ -134,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>;
 /**
@@ -155,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>;
@@ -171,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.
  *
@@ -193,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,
@@ -201,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;
@@ -211,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<{
@@ -226,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>>;
@@ -303,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>;
 /**
@@ -336,6 +460,22 @@ export declare const functionsUsageConfigSchema: z.ZodObject<{
     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.
@@ -359,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<{
@@ -374,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>>;
@@ -416,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<{
@@ -431,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>>;
@@ -453,6 +607,7 @@ 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";
@@ -476,6 +631,9 @@ export declare const functionsRuntimeConfigSchema: 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>;
@@ -493,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<{
@@ -508,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>>;
@@ -542,9 +707,11 @@ 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[];