@spacefast/common 0.2.2 → 0.4.1

package/dist/contracts/runtime-components.js

@@ -1,199 +1,315 @@
+// src/contracts/runtime-components.ts
 import { z } from "zod";
-import { contentProgramSha256Schema } from "./content-program.js";
-import { registeredIdSchema } from "./ids.js";
-export const runtimeCapabilityIdSchema = z
-    .string()
-    .min(1)
-    .max(160)
-    .regex(/^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/)
-    .brand();
-export const runtimeComponentIdSchema = z
-    .string()
-    .min(1)
-    .max(160)
-    .regex(/^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/)
-    .brand();
-export const RUNTIME_COMPONENT_V1_REQUIRED_IDS = [
-    "wordpress-core",
-    "runtime-engine",
-    "immutable-loader",
-    "content-kernel",
-    "managed-theme",
-    "secure-custom-fields",
-    "redirection",
-    "block-transformer",
-    "quickjs-abi",
+import {
+  compiledContentModelV1Schema,
+  contentExecutableSetV1Schema,
+  contentModelReleaseV1Schema,
+  contentModelSha256Schema,
+  contentRouteContributionSetV1Schema,
+  contentSdkDescriptorSetV1Schema
+} from "./content-model.js";
+import { prefixedIdSchema } from "./ids-core.js";
+
+// src/contracts/wordpress-php-toolkit.json
+var wordpress_php_toolkit_default = {
+  version: "0.9.0",
+  archiveUrl: "https://github.com/WordPress/php-toolkit/releases/download/v0.9.0/data-liberation.zip",
+  archiveBytes: 883739,
+  archiveSha256: "sha256:ba6e691936699ae7f5ceaa0129ef7e7a10f1db77c559a32f824e8307747b7b54",
+  archivePath: "data-liberation/php-toolkit.phar",
+  embeddedPath: "engine/vendor/php-toolkit.phar",
+  sha256: "sha256:bd452b61fd6ee9f4838ff416a3d225e6c82a742ffaf325a57ad327828eda446a"
+};
+
+// src/contracts/runtime-components.ts
+var runtimeCapabilityIdSchema = z.string().min(1).max(160).regex(/^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/).brand();
+var runtimeComponentIdSchema = z.string().min(1).max(160).regex(/^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/).brand();
+var RUNTIME_ACCESS_BROWSER_STATE_CAPABILITY = runtimeCapabilityIdSchema.parse(
+  "runtime.access.browser-state.v1"
+);
+var SPACEFAST_WORDPRESS_COMPONENT_RELEASE = {
+  wordpress: {
+    version: "7.1",
+    archiveUrl: "https://wordpress.org/wordpress-7.1.zip",
+    archiveBytes: 37216004,
+    archiveSha256: "sha256:d1ae02b5ae18428031ffc3943659fa87ab361d827f4aa804adf9276e4dc75df6"
+  },
+  secureCustomFields: {
+    version: "6.9.5",
+    software: "plugin://https://downloads.wordpress.org/plugin/secure-custom-fields.6.9.5.zip",
+    archiveUrl: "https://downloads.wordpress.org/plugin/secure-custom-fields.6.9.5.zip",
+    archiveBytes: 5532990,
+    archiveSha256: "sha256:2f3c6be871e23192bbcaf0f0870a8103678b078d168983cb39d95e0b0d25dbf3"
+  },
+  redirection: {
+    version: "5.10.0",
+    software: "plugin://https://downloads.wordpress.org/plugin/redirection.5.10.0.zip",
+    archiveUrl: "https://downloads.wordpress.org/plugin/redirection.5.10.0.zip",
+    archiveBytes: 494067,
+    archiveSha256: "sha256:966ac6267cd6a99f2d79ec05db1dee2e0aa0cddb6060b1c32cde2ffde739e333"
+  },
+  blockTransformer: {
+    version: "0.6.2",
+    software: "plugin://https://codeload.github.com/Automattic/blocks-engine-php-transformer/zip/refs/tags/v0.6.2",
+    archiveUrl: "https://codeload.github.com/Automattic/blocks-engine-php-transformer/zip/refs/tags/v0.6.2",
+    archiveBytes: 786827,
+    archiveSha256: "sha256:16492638259e8f0c1676332e52df27dd005552cca4a3f50055274363030a5a49"
+  },
+  phpToolkit: wordpress_php_toolkit_default,
+  // Jetpack is the one component the platform locks but does not always
+  // install: it is a per-team feature, and wp.cloud ships its own managed build
+  // rather than an archive we pin. The lock therefore names the software lane,
+  // not a version — licenses attach to whatever Jetpack the platform ships.
+  jetpack: {
+    version: "latest",
+    software: "plugins/jetpack/latest"
+  },
+  quickjsAbi: "rquickjs-0.12",
+  managedTheme: "spacefast-managed"
+};
+var RUNTIME_COMPONENT_V1_REQUIRED_IDS = [
+  "wordpress-core",
+  "runtime-engine",
+  "immutable-loader",
+  "content-kernel",
+  "managed-theme",
+  "secure-custom-fields",
+  "redirection",
+  "block-transformer",
+  "php-toolkit",
+  "jetpack",
+  "quickjs-abi"
 ];
-export const RUNTIME_COMPONENT_KINDS = [
-    "wordpress-core",
-    "runtime-engine",
-    "mu-plugin",
-    "plugin",
-    "theme",
-    "block-transformer",
-    "quickjs-abi",
+var JETPACK_RUNTIME_COMPONENT_ID = runtimeComponentIdSchema.parse("jetpack");
+var RUNTIME_COMPONENT_KINDS = [
+  "wordpress-core",
+  "runtime-engine",
+  "mu-plugin",
+  "plugin",
+  "theme",
+  "block-transformer",
+  "quickjs-abi",
+  "runtime-library"
 ];
-export const runtimeComponentKindSchema = z.enum(RUNTIME_COMPONENT_KINDS);
-const runtimeComponentV1RequiredKinds = {
-    "wordpress-core": "wordpress-core",
-    "runtime-engine": "runtime-engine",
-    "immutable-loader": "mu-plugin",
-    "content-kernel": "mu-plugin",
-    "managed-theme": "theme",
-    "secure-custom-fields": "plugin",
-    redirection: "plugin",
-    "block-transformer": "block-transformer",
-    "quickjs-abi": "quickjs-abi",
+var runtimeComponentKindSchema = z.enum(RUNTIME_COMPONENT_KINDS);
+var runtimeComponentV1RequiredKinds = {
+  "wordpress-core": "wordpress-core",
+  "runtime-engine": "runtime-engine",
+  "immutable-loader": "mu-plugin",
+  "content-kernel": "mu-plugin",
+  "managed-theme": "theme",
+  "secure-custom-fields": "plugin",
+  redirection: "plugin",
+  "block-transformer": "block-transformer",
+  "php-toolkit": "runtime-library",
+  jetpack: "plugin",
+  "quickjs-abi": "quickjs-abi"
 };
-const runtimeComponentSourceSchema = z.discriminatedUnion("kind", [
-    z
-        .object({
-        kind: z.literal("archive"),
-        url: z.string().url(),
-        bytes: z.number().int().positive(),
+var runtimeComponentSourceSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("archive"),
+    url: z.string().url(),
+    bytes: z.number().int().positive()
+  }).strict(),
+  z.object({
+    kind: z.literal("embedded"),
+    path: z.string().min(1).max(512).refine((path) => !path.startsWith("/") && !path.split("/").includes(".."), {
+      message: "embedded component paths must be relative and cannot traverse"
     })
-        .strict(),
-    z
-        .object({
-        kind: z.literal("embedded"),
-        path: z
-            .string()
-            .min(1)
-            .max(512)
-            .refine((path) => !path.startsWith("/") && !path.split("/").includes(".."), {
-            message: "embedded component paths must be relative and cannot traverse",
-        }),
-    })
-        .strict(),
+  }).strict(),
+  // The provider owns the bytes: wp.cloud installs and updates this component
+  // from its own managed build, so the lock pins the software lane it may come
+  // from and readiness is proven by observation instead of a byte digest.
+  z.object({
+    kind: z.literal("provider-managed"),
+    software: z.string().min(1).max(255)
+  }).strict()
 ]);
-export const runtimeComponentV1Schema = z
-    .object({
-    id: runtimeComponentIdSchema,
-    kind: runtimeComponentKindSchema,
-    version: z.string().min(1).max(160),
-    sha256: contentProgramSha256Schema,
-    source: runtimeComponentSourceSchema,
-    provides: z.array(runtimeCapabilityIdSchema).max(100),
-    activation: z.enum(["always", "on-demand"]),
-})
-    .strict()
-    .refine((component) => new Set(component.provides).size === component.provides.length, {
-    path: ["provides"],
-    message: "provided capabilities must be unique",
-});
-export const runtimeComponentInventoryV1Schema = z
-    .object({
-    format: z.literal("spacefast.wordpress-components"),
-    version: z.literal(1),
-    platformRelease: z.string().min(1).max(160),
-    digest: contentProgramSha256Schema,
-    components: z.array(runtimeComponentV1Schema).min(1).max(100),
-})
-    .strict()
-    .superRefine((inventory, context) => {
-    const ids = inventory.components.map((component) => component.id);
-    if (new Set(ids).size !== ids.length) {
-        context.addIssue({
-            code: "custom",
-            path: ["components"],
-            message: "component ids must be unique",
-        });
-    }
-    for (const required of RUNTIME_COMPONENT_V1_REQUIRED_IDS) {
-        const matching = inventory.components.filter((component) => component.id === required);
-        if (matching.length !== 1) {
-            context.addIssue({
-                code: "custom",
-                path: ["components"],
-                message: `component inventory requires exactly one ${required} component`,
-            });
-        }
-        else if (matching[0]?.kind !== runtimeComponentV1RequiredKinds[required]) {
-            context.addIssue({
-                code: "custom",
-                path: ["components"],
-                message: `${required} must use component kind ${runtimeComponentV1RequiredKinds[required]}`,
-            });
-        }
+var runtimeComponentV1Schema = z.object({
+  id: runtimeComponentIdSchema,
+  kind: runtimeComponentKindSchema,
+  version: z.string().min(1).max(160),
+  sha256: contentModelSha256Schema,
+  source: runtimeComponentSourceSchema,
+  installedArtifact: z.object({
+    path: z.string().min(1).max(512).refine((path) => !path.startsWith("/") && !path.split("/").includes(".."), {
+      message: "installed component paths must be relative and cannot traverse"
+    }),
+    sha256: contentModelSha256Schema
+  }).strict().optional(),
+  provides: z.array(runtimeCapabilityIdSchema).max(100),
+  activation: z.enum(["always", "installed", "on-demand"])
+}).strict().refine((component) => new Set(component.provides).size === component.provides.length, {
+  path: ["provides"],
+  message: "provided capabilities must be unique"
+}).refine(
+  (component) => component.activation === "installed" === (component.installedArtifact !== void 0),
+  {
+    path: ["installedArtifact"],
+    message: "installed activation requires exactly one installed artifact receipt"
+  }
+).refine(
+  (component) => component.activation !== "installed" || component.source.kind === "archive",
+  {
+    path: ["source"],
+    message: "installed components must come from a pinned archive"
+  }
+);
+var runtimeComponentInventoryV1Schema = z.object({
+  format: z.literal("spacefast.wordpress-components"),
+  version: z.literal(1),
+  platformRelease: z.string().min(1).max(160),
+  digest: contentModelSha256Schema,
+  components: z.array(runtimeComponentV1Schema).min(1).max(100)
+}).strict().superRefine((inventory, context) => {
+  const ids = inventory.components.map((component) => component.id);
+  if (new Set(ids).size !== ids.length) {
+    context.addIssue({
+      code: "custom",
+      path: ["components"],
+      message: "component ids must be unique"
+    });
+  }
+  for (const required of RUNTIME_COMPONENT_V1_REQUIRED_IDS) {
+    const matching = inventory.components.filter((component) => component.id === required);
+    if (matching.length !== 1) {
+      context.addIssue({
+        code: "custom",
+        path: ["components"],
+        message: `component inventory requires exactly one ${required} component`
+      });
+    } else if (matching[0]?.kind !== runtimeComponentV1RequiredKinds[required]) {
+      context.addIssue({
+        code: "custom",
+        path: ["components"],
+        message: `${required} must use component kind ${runtimeComponentV1RequiredKinds[required]}`
+      });
     }
+  }
 });
-export const programRequirementsV1Schema = z
-    .object({
-    format: z.literal("spacefast.program-requirements"),
-    version: z.literal(1),
-    inputDigest: contentProgramSha256Schema,
-    wordpressAbi: z.literal(1),
-    capabilities: z.array(runtimeCapabilityIdSchema).max(100),
-})
-    .strict()
-    .refine((requirements) => new Set(requirements.capabilities).size === requirements.capabilities.length, {
+var contentModelRequirementsV1Schema = z.object({
+  format: z.literal("spacefast.content-model-requirements"),
+  version: z.literal(1),
+  inputDigest: contentModelSha256Schema,
+  wordpressAbi: z.literal(1),
+  capabilities: z.array(runtimeCapabilityIdSchema).max(100)
+}).strict().refine(
+  (requirements) => new Set(requirements.capabilities).size === requirements.capabilities.length,
+  {
     path: ["capabilities"],
-    message: "program capabilities must be unique",
-});
-export const runtimeComponentPlacementTargetV1Schema = z
-    .object({
-    spaceId: registeredIdSchema("spc"),
-    runtimeInstanceId: z.string().min(1).max(255),
-    siteId: z.string().min(1).max(255),
-})
-    .strict();
-const runtimeComponentPlacementReceiptFields = {
-    format: z.literal("spacefast.component-placement"),
-    version: z.literal(1),
-    operationId: z.string().min(1).max(160),
-    target: runtimeComponentPlacementTargetV1Schema,
-    platformRelease: z.string().min(1).max(160),
-    expectedInventoryDigest: contentProgramSha256Schema,
+    message: "content model capabilities must be unique"
+  }
+);
+var compiledContentModelArtifactsV1Schema = z.object({
+  compiled: compiledContentModelV1Schema,
+  model: contentModelReleaseV1Schema,
+  executables: contentExecutableSetV1Schema,
+  sdk: contentSdkDescriptorSetV1Schema,
+  routes: contentRouteContributionSetV1Schema,
+  requirements: contentModelRequirementsV1Schema
+}).strict();
+var runtimeComponentPlacementTargetV1Schema = z.object({
+  spaceId: prefixedIdSchema("spc", "Space"),
+  runtimeInstanceId: z.string().min(1).max(255),
+  siteId: z.string().min(1).max(255)
+}).strict();
+var runtimeComponentPoolPlacementTargetV1Schema = z.object({
+  sitePoolId: prefixedIdSchema("site", "Site"),
+  runtimeInstanceId: z.string().min(1).max(255),
+  siteId: z.string().min(1).max(255)
+}).strict();
+var runtimeComponentReceiptTargetV1Schema = z.union([
+  runtimeComponentPlacementTargetV1Schema,
+  runtimeComponentPoolPlacementTargetV1Schema
+]);
+var runtimeComponentPlacementReceiptFields = {
+  format: z.literal("spacefast.component-placement"),
+  version: z.literal(1),
+  operationId: z.string().min(1).max(160),
+  target: runtimeComponentReceiptTargetV1Schema,
+  platformRelease: z.string().min(1).max(160),
+  expectedInventoryDigest: contentModelSha256Schema
 };
-const readyPlacementSubstrateV1Schema = z
-    .object({
-    wordpress: z
-        .object({
-        boot: z.literal("ready"),
-        database: z.literal("ready"),
-        tables: z.literal("ready"),
-    })
-        .strict(),
-    routing: z
-        .object({
-        state: z.literal("ready"),
-        snapshotRevision: contentProgramSha256Schema,
-        inventoryDigest: contentProgramSha256Schema,
-    })
-        .strict(),
-    mail: z.object({ state: z.literal("ready") }).strict(),
-    journal: z.object({ state: z.literal("ready") }).strict(),
-})
-    .strict();
-export const runtimeComponentPlacementReceiptV1Schema = z
-    .discriminatedUnion("status", [
-    z
-        .object({
-        ...runtimeComponentPlacementReceiptFields,
-        status: z.literal("ready"),
-        observedInventoryDigest: contentProgramSha256Schema,
-        substrate: readyPlacementSubstrateV1Schema,
-    })
-        .strict(),
-    z
-        .object({
-        ...runtimeComponentPlacementReceiptFields,
-        status: z.literal("blocked"),
-        problems: z
-            .array(z
-            .object({
-            componentId: runtimeComponentIdSchema.optional(),
-            code: z.string().min(1).max(160),
-            detail: z.string().min(1).max(2_000),
-        })
-            .strict())
-            .min(1)
-            .max(100),
-    })
-        .strict(),
-])
-    .refine((receipt) => receipt.status !== "ready" ||
-    receipt.observedInventoryDigest === receipt.expectedInventoryDigest, {
+var readyPlacementSubstrateV1Schema = z.object({
+  wordpress: z.object({
+    boot: z.literal("ready"),
+    database: z.literal("ready"),
+    tables: z.literal("ready")
+  }).strict(),
+  routing: z.object({
+    state: z.literal("ready"),
+    snapshotRevision: contentModelSha256Schema,
+    inventoryDigest: contentModelSha256Schema
+  }).strict(),
+  mail: z.object({ state: z.literal("ready") }).strict(),
+  journal: z.object({ state: z.literal("ready") }).strict(),
+  // Which `on-demand` components the box actually runs. Always components are
+  // covered by the inventory digest; these are not installed everywhere, so
+  // the receipt reports what is there and the control plane decides whether
+  // that matches what it has converged.
+  onDemandActive: z.array(runtimeComponentIdSchema).max(20)
+}).strict();
+var runtimeComponentPlacementReceiptV1Schema = z.discriminatedUnion("status", [
+  z.object({
+    ...runtimeComponentPlacementReceiptFields,
+    status: z.literal("ready"),
+    observedInventoryDigest: contentModelSha256Schema,
+    substrate: readyPlacementSubstrateV1Schema
+  }).strict(),
+  z.object({
+    ...runtimeComponentPlacementReceiptFields,
+    status: z.literal("blocked"),
+    // A pre-receipt Space has no control-plane routing baseline yet. New
+    // engines return the routing they observed so that one guarded retry
+    // can bind the first receipt without pretending the route set is
+    // empty. Optional keeps the control plane compatible with engines
+    // published before this adoption field existed.
+    observedRouting: z.object({
+      snapshotRevision: contentModelSha256Schema,
+      inventoryDigest: contentModelSha256Schema
+    }).strict().optional(),
+    problems: z.array(
+      z.object({
+        componentId: runtimeComponentIdSchema.optional(),
+        code: z.string().min(1).max(160),
+        detail: z.string().min(1).max(2e3)
+      }).strict()
+    ).min(1).max(100)
+  }).strict()
+]).refine(
+  (receipt) => receipt.status !== "ready" || receipt.observedInventoryDigest === receipt.expectedInventoryDigest,
+  {
     path: ["observedInventoryDigest"],
-    message: "a ready receipt must observe the expected inventory digest",
-});
+    message: "a ready receipt must observe the expected inventory digest"
+  }
+);
+var runtimeComponentStageRequestV1Schema = z.object({
+  format: z.literal("spacefast.component-stage"),
+  version: z.literal(1),
+  operationId: z.string().min(1).max(160),
+  target: runtimeComponentPlacementReceiptFields.target,
+  expectedInventoryDigest: contentModelSha256Schema,
+  routing: z.object({
+    snapshotRevision: contentModelSha256Schema,
+    inventoryDigest: contentModelSha256Schema
+  }).strict()
+}).strict();
+export {
+  JETPACK_RUNTIME_COMPONENT_ID,
+  RUNTIME_ACCESS_BROWSER_STATE_CAPABILITY,
+  RUNTIME_COMPONENT_KINDS,
+  RUNTIME_COMPONENT_V1_REQUIRED_IDS,
+  SPACEFAST_WORDPRESS_COMPONENT_RELEASE,
+  compiledContentModelArtifactsV1Schema,
+  contentModelRequirementsV1Schema,
+  runtimeCapabilityIdSchema,
+  runtimeComponentIdSchema,
+  runtimeComponentInventoryV1Schema,
+  runtimeComponentKindSchema,
+  runtimeComponentPlacementReceiptV1Schema,
+  runtimeComponentPlacementTargetV1Schema,
+  runtimeComponentPoolPlacementTargetV1Schema,
+  runtimeComponentReceiptTargetV1Schema,
+  runtimeComponentStageRequestV1Schema,
+  runtimeComponentV1Schema
+};

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

@@ -1,3 +1,18 @@
+import { type ConnectorCallState, type ConnectorRun, type ConnectorJsonValue } from "./connectors.js";
+export type ConnectorToolProxy = {
+    (args?: Record<string, ConnectorJsonValue>): Promise<ConnectorJsonValue | null>;
+    [tool: string]: ConnectorToolProxy;
+};
+export type Connectors = Record<string, ConnectorToolProxy> & {
+    call(role: string, tool: string, args: Record<string, ConnectorJsonValue>, handler?: {
+        name: string;
+        mode: "read" | "write";
+        callIndex?: number;
+    }): Promise<{
+        state: ConnectorCallState;
+        run?: ConnectorRun;
+    }>;
+};
 /**
  * Platform services that tenant code reaches through the runtime rather than
  * through a credential of its own: Gravatar, spam checking, and mail.

package/dist/contracts/runtime-services.js

@@ -1,3 +1,4 @@
+import { CONNECTOR_CALL_STATE_COPY, } from "./connectors.js";
 /**
  * Platform services that tenant code reaches through the runtime rather than
  * through a credential of its own: Gravatar, spam checking, and mail.
@@ -77,6 +78,28 @@ export const SPAM_CONTENT_TYPES = [
  * one tier and a string on the other.
  */
 export const RUNTIME_SERVICE_CLIENT_SOURCE = String.raw `
+class ConnectorCallError extends Error {
+  constructor(state) { super(state.message); this.name = "ConnectorCallError"; this.state = state; }
+}
+
+const CONNECTOR_STATE_COPY = ${JSON.stringify(CONNECTOR_CALL_STATE_COPY)};
+
+function makeConnectorProxy(call, handler) {
+  let callIndex = 0;
+  const tool = (role, path) => new Proxy(async (args = {}) => {
+    let answer;
+    try { answer = await call(role, path.join("."), args, { ...handler, callIndex: callIndex++ }); }
+    catch (error) {
+      const code = ["connector_write_in_read_handler", "connector_forbidden", "service_capability_denied"].includes(error?.code) ? "forbidden" : "unavailable";
+      throw new ConnectorCallError({ code, role, message: CONNECTOR_STATE_COPY[code] });
+    }
+    if (answer.state.code !== "ok") throw new ConnectorCallError({ ...answer.state, role });
+    return answer.run?.result ?? null;
+  }, { get: (_, name) => name === "then" ? undefined : typeof name === "string" ? tool(role, [...path, name]) : undefined });
+  return new Proxy({ call }, { get: (target, role) => role === "call" ? target.call : typeof role === "string" && role !== "then" ? tool(role, []) : undefined });
+}
+
+
 const SERVICE_DEFAULTS = ${JSON.stringify(GRAVATAR_DEFAULTS)};
 const SERVICE_RATINGS = ${JSON.stringify(GRAVATAR_RATINGS)};
 const SPAM_TYPES = ${JSON.stringify(SPAM_CONTENT_TYPES)};
@@ -409,6 +432,8 @@ function makeEmail(call) {
 
 function makeRuntimeServices(call, requestContext) {
   return {
+    connectors: makeConnectorProxy((role, tool, args, handler) =>
+      call("connectors", "call", { role, tool, args, handler })),
     gravatar: makeGravatar(call),
     spam: makeSpam(call, requestContext),
     email: makeEmail(call),

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

@@ -18,10 +18,19 @@ export declare const runtimeStorageListQuerySchema: z.ZodObject<{
     cursor: z.ZodOptional<z.ZodString>;
     limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
 }, z.core.$strict>;
+/**
+ * The uploader's own name for an object: presentation only, never a path.
+ *
+ * The id is the identity — this is what a person reads in a list and what a
+ * download is saved as. Separators are refused rather than stripped so the
+ * value the caller sent is the value that comes back.
+ */
+export declare const runtimeStorageFilenameSchema: z.ZodString;
 export declare const runtimeStorageObjectSchema: z.ZodObject<{
     id: z.ZodString;
     contentType: z.ZodString;
     createdAt: z.ZodString;
+    filename: z.ZodOptional<z.ZodString>;
     size: z.ZodNumber;
     uploaderId: z.ZodString;
     sha256: z.ZodString;
@@ -33,6 +42,7 @@ export declare const runtimeStorageListResponseSchema: z.ZodObject<{
         id: z.ZodString;
         contentType: z.ZodString;
         createdAt: z.ZodString;
+        filename: z.ZodOptional<z.ZodString>;
         size: z.ZodNumber;
         uploaderId: z.ZodString;
         sha256: z.ZodString;
@@ -42,11 +52,33 @@ export declare const runtimeStorageListResponseSchema: z.ZodObject<{
     hasMore: z.ZodBoolean;
 }, z.core.$strict>;
 export type RuntimeStorageListResponse = z.infer<typeof runtimeStorageListResponseSchema>;
+/**
+ * The upload's metadata rides the URL because the body is the file.
+ *
+ * `contentType` comes from the request's own `Content-Type`, which is where a
+ * raw-body upload already states it; only the name has nowhere else to go.
+ */
+export declare const runtimeStorageUploadQuerySchema: z.ZodObject<{
+    filename: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const runtimeStorageUploadPublicResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        id: z.ZodString;
+        contentType: z.ZodString;
+        createdAt: z.ZodString;
+        filename: z.ZodOptional<z.ZodString>;
+        size: z.ZodNumber;
+        uploaderId: z.ZodString;
+        sha256: z.ZodString;
+        url: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strip>;
 export declare const runtimeStorageListPublicResponseSchema: z.ZodObject<{
     data: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         contentType: z.ZodString;
         createdAt: z.ZodString;
+        filename: z.ZodOptional<z.ZodString>;
         size: z.ZodNumber;
         uploaderId: z.ZodString;
         sha256: z.ZodString;