@spacefast/common 0.0.24 → 0.0.26

package/dist/contracts/functions.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { appRoutePathSchema, executionCapabilitiesSchema, executionSha256Schema, httpMethodSchema, } from "./execution.js";
+import { appRoutePathSchema, executionBase64Schema, executionCapabilitiesSchema, executionSha256Schema, httpMethodSchema, } from "./execution.js";
 /**
  * Spacefast Functions: tenant workers run as Cloudflare Dynamic Workers.
  *
@@ -51,7 +51,21 @@ export const FUNCTIONS_RUNTIME_ROUTE_PATHS = {
     logs: `${FUNCTIONS_PLATFORM_ROUTE_PREFIX}/logs`,
     /** Where a dispatched worker calls back for brokered capabilities. */
     relay: `${FUNCTIONS_PLATFORM_ROUTE_PREFIX}/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.
+     */
+    purge: `${FUNCTIONS_PLATFORM_ROUTE_PREFIX}/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 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 const FUNCTIONS_RUNTIME_STORAGE_ROOT = "__spacefast/functions";
  * was never given.
  */
 export const FUNCTIONS_RUNTIME_BUNDLE_ROOT = `${FUNCTIONS_RUNTIME_STORAGE_ROOT}/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 const FUNCTIONS_RUNTIME_SEED_ROOT = `${FUNCTIONS_RUNTIME_STORAGE_ROOT}/seeds`;
 export const FUNCTIONS_BUNDLE_FORMAT = "spacefast.functions.bundle.v1";
+export const FUNCTIONS_SEED_FORMAT = "spacefast.functions.seed.v1";
 /**
  * Ceiling on a bundle's decoded size.
  *
@@ -100,13 +124,66 @@ export const FUNCTIONS_BUNDLE_FORMAT = "spacefast.functions.bundle.v1";
  * modules are large, rather than at dispatch, where the tenant sees a 502.
  */
 export const FUNCTIONS_BUNDLE_MAX_BYTES = 8 * 1024 * 1024;
+/**
+ * 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 const FUNCTIONS_SEED_ENTRY_MAX_BYTES = 2 * 1024 * 1024 - 8192;
+// The Durable Object buffers the JSON once, then decoding/parsing temporarily
+// holds the text and object graph beside it. Keep the document far below
+// Cloudflare's 128 MiB SHARED-isolate ceiling; several objects can occupy that
+// isolate, and the host enforces this bound again while streaming the response.
+export const FUNCTIONS_SEED_MAX_BYTES = 8 * 1024 * 1024;
+/**
+ * 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 const functionsSeedEntrySchema = z
+    .object({
+    key: z.string().min(1).max(2048),
+    cacheType: z.enum(["cache", "fetch"]),
+    valueJson: z.string().min(1),
+    /** Epoch milliseconds the entry was built, so staleness math holds. */
+    lastModified: z.number().int().nonnegative(),
+})
+    .strict();
+/** The document served at a seed URL; host and CLI validate the same shape. */
+export const functionsSeedManifestSchema = z
+    .object({
+    format: z.literal(FUNCTIONS_SEED_FORMAT),
+    entries: z.array(functionsSeedEntrySchema),
+})
+    .strict();
 const functionsRoutePathSchema = appRoutePathSchema({
     subject: "Function routes",
 });
+/**
+ * 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 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 const functionsRouteSchema = z
     .object({
@@ -120,14 +197,17 @@ export const functionsRouteSchema = z
  * 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 const functionsBundleModuleSchema = z.union([
     z.object({ js: z.string() }).strict(),
     z.object({ cjs: z.string() }).strict(),
     z.object({ text: z.string() }).strict(),
     z.object({ json: z.unknown() }).strict(),
+    z.object({ wasm: executionBase64Schema }).strict(),
+    z.object({ data: executionBase64Schema }).strict(),
 ]);
 /**
  * The document served at a bundle URL and parsed by the host.
@@ -168,6 +248,25 @@ export const functionsBundleRefSchema = z
     size: z.number().int().nonnegative().max(FUNCTIONS_BUNDLE_MAX_BYTES),
 })
     .strict();
+/**
+ * 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 const functionsSeedRefSchema = z
+    .object({
+    path: z
+        .string()
+        .min(1)
+        .startsWith(`${FUNCTIONS_RUNTIME_SEED_ROOT}/`)
+        .refine((path) => !path.split("/").includes(".."), {
+        message: "Function seed paths cannot traverse outside the seed root.",
+    }),
+    sha256: executionSha256Schema,
+    size: z.number().int().nonnegative().max(FUNCTIONS_SEED_MAX_BYTES),
+    entries: z.number().int().nonnegative(),
+})
+    .strict();
 /**
  * The path a bundle is served from.
  *
@@ -189,6 +288,15 @@ export const functionsBundleRefSchema = z
 export function functionsBundlePath(input) {
     return `${FUNCTIONS_BUNDLE_ROUTE_PREFIX}/${bundleDigest(input.sha256)}/${input.token}/bundle.json`;
 }
+/**
+ * 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 function functionsSeedPath(input) {
+    return `${FUNCTIONS_BUNDLE_ROUTE_PREFIX}/${bundleDigest(input.sha256)}/${input.token}/seed.json`;
+}
 /**
  * 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,
@@ -197,6 +305,10 @@ export function functionsBundlePath(input) {
 export function functionsBundleStoragePath(input) {
     return `${FUNCTIONS_RUNTIME_BUNDLE_ROOT}/${bundleDigest(input.sha256)}/bundle.json`;
 }
+/** The seed's storage twin of `functionsBundleStoragePath`. */
+export function functionsSeedStoragePath(input) {
+    return `${FUNCTIONS_RUNTIME_SEED_ROOT}/${bundleDigest(input.sha256)}/seed.json`;
+}
 /**
  * The digest is carried in contracts as `sha256:<hex>` but appears in paths as
  * bare hex: a colon is legal in a path segment yet needlessly invites
@@ -229,9 +341,26 @@ export const functionsWorkerArtifactSchema = z
      */
     mainModule: z.string().min(1).max(1024),
     bundle: functionsBundleRefSchema,
+    /**
+     * The build-time cache seed, or null when the build produced nothing
+     * worth warming (no prerenders left with the worker, no fetch cache).
+     * A ref, not content: the document rides the version's own file tree
+     * like the bundle, and the host pulls it through a signed URL minted at
+     * finalize.
+     */
+    seed: functionsSeedRefSchema.nullable().default(null),
     compatibilityDate: functionsCompatibilityDateSchema,
     compatibilityFlags: z.array(z.string().min(1).max(128)).max(32).default([]),
-    routes: z.array(functionsRouteSchema).max(256).default([]),
+    routes: z.array(functionsRouteSchema).max(FUNCTIONS_MAX_ROUTES).default([]),
+    /**
+     * Cookie names whose presence must skip the origin's static fast path on
+     * claimed routes — the framework's draft/preview session markers. Data
+     * from the classifier, not names the engine knows: the origin checks the
+     * Cookie header against this list and dispatches instead of serving the
+     * extracted file, which is what lets a fully-static page still honor a
+     * draft session without a build-wide draft-usage proof.
+     */
+    bypassCookies: z.array(z.string().min(1).max(128)).max(8).default([]),
     /**
      * Aggregate of what the worker's handlers reach, used to decide which
      * brokered capabilities the relay will honour for this version. A worker
@@ -356,6 +485,13 @@ export const functionsHostConfigSchema = z
      * single artifact.
      */
     bundleUrl: z.string().url(),
+    /**
+     * Where the host pulls the version's cache seed, minted beside the bundle
+     * URL for the same reasons — null exactly when the artifact carries no
+     * seed. The host folds it into the cache object's cold-start path, never
+     * into request serving: an unreachable seed is a cold cache, not an error.
+     */
+    seedUrl: z.string().url().nullable().default(null),
 })
     .strict();
 /**
@@ -402,6 +538,23 @@ export const functionsUsageConfigSchema = z
     token: z.string().min(1),
 })
     .strict();
+/**
+ * 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 const functionsPurgeConfigSchema = z
+    .object({
+    token: z.string().min(1),
+})
+    .strict();
 /**
  * What a build declares about its worker — everything the CLI can know from the
  * author's project alone.
@@ -441,6 +594,7 @@ export const functionsRuntimeConfigSchema = functionsSourceFinalizeSchema
     grantedCapabilities: z.array(functionsDispatchCapabilitySchema).max(10).default([]),
     relay: functionsRelayConfigSchema.nullable().default(null),
     usage: functionsUsageConfigSchema.nullable().default(null),
+    purge: functionsPurgeConfigSchema.nullable().default(null),
     /**
      * Resolved at finalize, so a worker reading configuration never calls back
      * to us for it — and so rotating a variable is a republish with an audit
@@ -475,9 +629,11 @@ export function createFunctionsSourceFinalize(input) {
             entry: input.entry,
             mainModule: input.mainModule,
             bundle: input.bundle,
+            seed: input.seed ?? null,
             compatibilityDate: input.compatibilityDate,
             compatibilityFlags: input.compatibilityFlags ?? [],
             routes: input.routes ?? [],
+            bypassCookies: input.bypassCookies ?? [],
             capabilities: input.capabilities ?? {},
             platform: { nextCache: input.nextCache ?? false },
         },

package/dist/contracts/git.d.ts

@@ -96,16 +96,16 @@ export declare const gitConnectionCreateSchema: z.ZodPipe<z.ZodObject<{
     autoDeployProduction: z.ZodDefault<z.ZodBoolean>;
     autoDeployPreviews: z.ZodDefault<z.ZodBoolean>;
     buildSettings: z.ZodOptional<z.ZodObject<{
-        rootDirectory: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodString>>>;
-        installDirectory: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodString>>>;
-        installCommand: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodString>>>;
-        buildCommand: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodString>>>;
-        outputDirectory: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodString>>>;
-        ignoredBuildCommand: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodString>>>;
-        frameworkPreset: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodString>>>;
-        platformPreset: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodString>>>;
-        allowUnsupportedPlatformFeatures: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-        timeoutSeconds: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        rootDirectory: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        installDirectory: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        installCommand: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        buildCommand: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        outputDirectory: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        ignoredBuildCommand: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        frameworkPreset: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        platformPreset: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        allowUnsupportedPlatformFeatures: z.ZodOptional<z.ZodBoolean>;
+        timeoutSeconds: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodTransform<{
     productionBranch: string;
@@ -163,16 +163,16 @@ export declare const gitConnectionPatchSchema: z.ZodObject<{
     autoDeployProduction: z.ZodOptional<z.ZodBoolean>;
     autoDeployPreviews: z.ZodOptional<z.ZodBoolean>;
     buildSettings: z.ZodOptional<z.ZodObject<{
-        rootDirectory: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodString>>>;
-        installDirectory: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodString>>>;
-        installCommand: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodString>>>;
-        buildCommand: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodString>>>;
-        outputDirectory: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodString>>>;
-        ignoredBuildCommand: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodString>>>;
-        frameworkPreset: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodString>>>;
-        platformPreset: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodString>>>;
-        allowUnsupportedPlatformFeatures: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-        timeoutSeconds: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        rootDirectory: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        installDirectory: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        installCommand: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        buildCommand: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        outputDirectory: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        ignoredBuildCommand: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        frameworkPreset: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        platformPreset: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        allowUnsupportedPlatformFeatures: z.ZodOptional<z.ZodBoolean>;
+        timeoutSeconds: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const gitConnectionAnalyzeSchema: z.ZodObject<{
@@ -249,7 +249,13 @@ export declare const githubInstallationSchema: z.ZodObject<{
     htmlUrl: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;
 export declare const githubInstallationsResponseSchema: z.ZodObject<{
-    appConfigured: z.ZodBoolean;
+    readiness: z.ZodObject<{
+        canAuthorize: z.ZodBoolean;
+        canInstall: z.ZodBoolean;
+        webhookReady: z.ZodBoolean;
+        codeStorageReady: z.ZodBoolean;
+        ready: z.ZodBoolean;
+    }, z.core.$strip>;
     installUrl: z.ZodNullable<z.ZodString>;
     installations: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
@@ -258,18 +264,6 @@ export declare const githubInstallationsResponseSchema: z.ZodObject<{
         htmlUrl: z.ZodNullable<z.ZodString>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-export declare const githubInstallationClaimSchema: z.ZodObject<{
-    installationId: z.ZodString;
-    state: z.ZodString;
-}, z.core.$strip>;
-export declare const githubInstallationClaimResponseSchema: z.ZodObject<{
-    installation: z.ZodObject<{
-        id: z.ZodString;
-        accountLogin: z.ZodString;
-        accountType: z.ZodNullable<z.ZodString>;
-        htmlUrl: z.ZodNullable<z.ZodString>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
 export declare const githubRepositorySchema: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;

package/dist/contracts/git.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { BuildSettingsSchema } from "./builds.js";
+import { BuildSettingsOverrideSchema, BuildSettingsSchema } from "./builds.js";
 import { gitProvider } from "./enums.js";
 const nullableString = z.string().trim().min(1).nullable();
 export const buildTargetValues = ["production", "preview"];
@@ -55,7 +55,7 @@ export const gitConnectionCreateSchema = z
     credential: z.string().trim().min(1).nullable().optional(),
     autoDeployProduction: z.boolean().default(true),
     autoDeployPreviews: z.boolean().default(true),
-    buildSettings: gitBuildSettingsSchema.partial().optional(),
+    buildSettings: BuildSettingsOverrideSchema.optional(),
 })
     .transform((value) => ({
     ...value,
@@ -67,7 +67,7 @@ export const gitConnectionPatchSchema = z.object({
     credential: z.string().trim().min(1).nullable().optional(),
     autoDeployProduction: z.boolean().optional(),
     autoDeployPreviews: z.boolean().optional(),
-    buildSettings: gitBuildSettingsSchema.partial().optional(),
+    buildSettings: BuildSettingsOverrideSchema.optional(),
 });
 export const gitConnectionAnalyzeSchema = z.object({
     ref: z.string().trim().min(1).optional(),
@@ -95,17 +95,16 @@ export const githubInstallationSchema = z.object({
     htmlUrl: z.string().url().nullable(),
 });
 export const githubInstallationsResponseSchema = z.object({
-    appConfigured: z.boolean(),
+    readiness: z.object({
+        canAuthorize: z.boolean(),
+        canInstall: z.boolean(),
+        webhookReady: z.boolean(),
+        codeStorageReady: z.boolean(),
+        ready: z.boolean(),
+    }),
     installUrl: z.string().url().nullable(),
     installations: z.array(githubInstallationSchema),
 });
-export const githubInstallationClaimSchema = z.object({
-    installationId: z.string().trim().min(1),
-    state: z.string().trim().min(1),
-});
-export const githubInstallationClaimResponseSchema = z.object({
-    installation: githubInstallationSchema,
-});
 export const githubRepositorySchema = z.object({
     id: z.string(),
     name: z.string(),

package/dist/contracts/grants.d.ts

@@ -12,8 +12,8 @@ export declare const GRANT_AUDIENCE_KINDS: readonly ["public", "team", "person",
 export declare const grantAudienceKindSchema: z.ZodEnum<{
     link: "link";
     team: "team";
-    external: "external";
     public: "public";
+    external: "external";
     person: "person";
     password: "password";
     machine: "machine";
@@ -424,8 +424,8 @@ export declare const grantCheckQuerySchema: z.ZodObject<{
     audience: z.ZodDefault<z.ZodEnum<{
         link: "link";
         team: "team";
-        external: "external";
         public: "public";
+        external: "external";
         person: "person";
         password: "password";
         machine: "machine";

package/dist/contracts/ids.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-// Id prefix registry (internal-docs/platform.md "Id prefix registry", L1106-1127).
+// Id prefix registry (the platform spec "Id prefix registry").
 // Every PUBLIC resource registers a prefix here before it ships; ids are globally
 // unique and handle ids (operations, exports, imports, transfers, builds) are
 // fetchable at a top-level collection with no extra context. Control-plane-internal
@@ -49,7 +49,7 @@ export function registeredIdSchema(prefix) {
 }
 // The main Stattic tenant every self-serve team/user/resource lives under. A
 // well-known CONSTANT, never configuration: grammatically a normal tenant id with
-// zero special cases in contracts, policy URIs, or parsers (spec L1100-1105).
+// zero special cases in contracts, policy URIs, or parsers (per the platform spec).
 export const MAIN_TENANT_ID = "ten_main";
 /** Mint a globally unique id for a registered public resource prefix. */
 export function createId(prefix) {

package/dist/contracts/internal.d.ts

@@ -1,9 +1,4 @@
 import { z } from "zod";
-export declare const conventionFilesSchema: z.ZodObject<{
-    redirects: z.ZodOptional<z.ZodString>;
-    headers: z.ZodOptional<z.ZodString>;
-    routes: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
 export declare const manifestFileSchema: z.ZodObject<{
     path: z.ZodString;
     size: z.ZodNumber;
@@ -11,19 +6,13 @@ export declare const manifestFileSchema: z.ZodObject<{
     contentType: z.ZodOptional<z.ZodString>;
     sourceUrl: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-export declare const uploadManifestFileSchema: z.ZodUnion<readonly [z.ZodObject<{
-    path: z.ZodString;
-    size: z.ZodNumber;
-    contentType: z.ZodOptional<z.ZodString>;
-    sourceUrl: z.ZodOptional<z.ZodString>;
-    sha256: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
+export declare const uploadManifestFileSchema: z.ZodObject<{
     path: z.ZodString;
     size: z.ZodNumber;
     sha256: z.ZodOptional<z.ZodString>;
     contentType: z.ZodOptional<z.ZodString>;
-    sourceUrl: z.ZodString;
-}, z.core.$strip>]>;
+    sourceUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 export declare const pendingUploadSchema: z.ZodObject<{
     path: z.ZodString;
     size: z.ZodNumber;
@@ -97,14 +86,14 @@ export declare const uploadInstructionsSchema: 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";
             }>>>;

package/dist/contracts/internal.js

@@ -1,10 +1,5 @@
 import { z } from "zod";
 import { baseDiagnosticSchema } from "./common.js";
-export const conventionFilesSchema = z.object({
-    redirects: z.string().optional(),
-    headers: z.string().optional(),
-    routes: z.string().optional(),
-});
 const manifestSha256Schema = z
     .string()
     .regex(/^[0-9a-f]{64}$/, "sha256 must be 64 lowercase hex characters without a prefix.")
@@ -20,18 +15,13 @@ export const manifestFileSchema = z.object({
     size: z.number().int().nonnegative().describe("File size in bytes."),
     sha256: manifestSha256Schema
         .optional()
-        .describe("SHA-256 content digest: exactly 64 lowercase hex characters, no `sha256:` prefix (Version.manifestHash is the only prefixed form). Required when the caller uploads local bytes; may be absent on historical records and sourceUrl entries."),
+        .describe("Optional SHA-256 content digest: exactly 64 lowercase hex characters, no `sha256:` prefix (Version.manifestHash is the only prefixed form). Omit it to let the runtime hash uploaded bytes; include it to upload by content address, with the digest verified as the bytes land."),
     contentType: z.string().optional().describe("Optional content type for serving metadata."),
     sourceUrl: manifestSourceUrlSchema
         .optional()
         .describe("Optional HTTPS URL the runtime can fetch directly for this file instead of receiving bytes from the client."),
 });
-export const uploadManifestFileSchema = z
-    .union([
-    manifestFileSchema.extend({ sha256: manifestSha256Schema }),
-    manifestFileSchema.extend({ sourceUrl: manifestSourceUrlSchema }),
-])
-    .describe("A declared upload file. Local bytes require sha256. A sourceUrl entry may omit sha256 because the runtime computes it while fetching.");
+export const uploadManifestFileSchema = manifestFileSchema.describe("A declared upload file. sha256 is optional: omit it for runtime-hashed path uploads or sourceUrl fetches; include it for content-addressed uploads.");
 export const pendingUploadSchema = manifestFileSchema.pick({
     path: true,
     size: true,

package/dist/contracts/mcp.d.ts

@@ -155,6 +155,16 @@ export declare const hostedMcpDashboardResponseSchema: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>;
 }, z.core.$strip>;
+export declare const hostedMcpProxyTokenSchema: z.ZodObject<{
+    accessToken: z.ZodString;
+    expiresAt: z.ZodString;
+}, z.core.$strip>;
+export declare const hostedMcpProxyTokenResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        accessToken: z.ZodString;
+        expiresAt: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
 export declare const hostedMcpCloseSessionResponseSchema: z.ZodObject<{
     data: z.ZodObject<{
         sessionId: z.ZodString;
@@ -243,5 +253,6 @@ export declare const hostedMcpApprovalResponseSchema: z.ZodObject<{
 export type HostedMcpSession = z.infer<typeof hostedMcpSessionSchema>;
 export type HostedMcpSessionEvent = z.infer<typeof hostedMcpSessionEventSchema>;
 export type HostedMcpDashboard = z.infer<typeof hostedMcpDashboardSchema>;
+export type HostedMcpProxyToken = z.infer<typeof hostedMcpProxyTokenSchema>;
 export type HostedMcpPausedExecution = z.infer<typeof hostedMcpPausedExecutionSchema>;
 export type HostedMcpApprovalAction = z.infer<typeof hostedMcpApprovalActionSchema>;

package/dist/contracts/mcp.js

@@ -50,6 +50,11 @@ export const hostedMcpDashboardSchema = z.object({
     events: z.array(hostedMcpSessionEventSchema),
 });
 export const hostedMcpDashboardResponseSchema = dataEnvelope(hostedMcpDashboardSchema);
+export const hostedMcpProxyTokenSchema = z.object({
+    accessToken: z.string().min(1),
+    expiresAt: z.string().datetime(),
+});
+export const hostedMcpProxyTokenResponseSchema = dataEnvelope(hostedMcpProxyTokenSchema);
 export const hostedMcpCloseSessionResponseSchema = dataEnvelope(hostedMcpSessionSchema);
 export const hostedMcpSessionEventsResponseSchema = dataEnvelope(z.object({
     session: hostedMcpSessionSchema,

package/dist/contracts/me.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { betaEligibleTeamSourceSchema } from "./beta.js";
 import { planCodeSchema } from "./features.js";
-// `GET /v1/me` (internal-docs/platform.md route catalog): the authenticated
+// `GET /v1/me` (the platform spec route catalog): the authenticated
 // subject, its tenant grants, principal/team memberships, and a plan summary.
 // Works for every credential kind — sessions resolve their user and team
 // memberships; machine credentials resolve the teams and tenants their policy

package/dist/contracts/operations.d.ts

@@ -36,14 +36,14 @@ export declare const UserOperationSchema: 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";
         }>>>;
@@ -110,14 +110,14 @@ export declare const operationListResponseSchema: 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";
             }>>>;

package/dist/contracts/operations.js

@@ -32,13 +32,13 @@ export const operationListQuerySchema = cursorListQuerySchema.extend({
         .string()
         .min(1)
         .optional()
-        .describe("Filter to operations touching one resource type, e.g. `space`."),
+        .describe("Filter to operations touching one resource type, for example `space`."),
     resourceId: z.string().min(1).optional().describe("Filter to operations touching one resource."),
     spaceId: z
         .string()
         .min(1)
         .optional()
-        .describe("Filter to operations pertaining to one Space — its own operations plus those of its versions and builds. The Space must be readable by the caller."),
+        .describe("Filter to operations for one Space — its own operations plus those of its versions and builds. The Space must be readable by the caller."),
 });
 export const operationListResponseSchema = z.object({
     data: z.array(UserOperationSchema),