@spacefast/common 0.2.2 → 0.4.1

package/dist/contracts/wordpress-php-toolkit.json

@@ -0,0 +1,9 @@
+{
+    "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"
+}

package/dist/contracts/work-mode.d.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+export declare const spaceWorkModeSchema: z.ZodEnum<{
+    code: "code";
+    vibe: "vibe";
+}>;
+export declare const spaceWorkModePreferenceSchema: z.ZodObject<{
+    space: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+    }, z.core.$strip>;
+    mode: z.ZodNullable<z.ZodEnum<{
+        code: "code";
+        vibe: "vibe";
+    }>>;
+    revision: z.ZodNumber;
+}, z.core.$strip>;
+export declare const spaceWorkModeUpdateSchema: z.ZodObject<{
+    mode: z.ZodEnum<{
+        code: "code";
+        vibe: "vibe";
+    }>;
+    expectedRevision: z.ZodNumber;
+}, z.core.$strip>;
+export type SpaceWorkModePreference = z.infer<typeof spaceWorkModePreferenceSchema>;

package/dist/contracts/work-mode.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+export const spaceWorkModeSchema = z
+    .enum(["vibe", "code"])
+    .describe("The mode selected by the user. Vibe it hides routine code review.");
+export const spaceWorkModePreferenceSchema = z.object({
+    space: z.object({ id: z.string(), title: z.string() }),
+    mode: spaceWorkModeSchema.nullable(),
+    revision: z.number().int().nonnegative(),
+});
+export const spaceWorkModeUpdateSchema = z.object({
+    mode: spaceWorkModeSchema,
+    expectedRevision: z
+        .number()
+        .int()
+        .nonnegative()
+        .describe("Revision from the current mode card. Use zero when no choice is saved."),
+});

package/dist/contracts/wp-cli.d.ts

@@ -0,0 +1,66 @@
+import { z } from "zod";
+/**
+ * Running `wp` against a Space's own WordPress.
+ *
+ * This is the escape hatch the bespoke surfaces (`sf zero`, `sf db`, `sf
+ * content`) are carved out of: everything WP-CLI can do that Spacefast has not
+ * given a noun to. It exists so a Space is never a dead end.
+ *
+ * The relay is deliberately server-side. wp.cloud's API is reachable only from
+ * allowlisted control-plane egress, so the provider credential cannot be handed
+ * to a caller — the control plane submits the command on the caller's behalf and
+ * the credential never leaves the server.
+ */
+/** The one WP-CLI context knob wp.cloud exposes. */
+export declare const wpCliModeSchema: z.ZodEnum<{
+    limited: "limited";
+    full: "full";
+}>;
+export type WpCliMode = z.infer<typeof wpCliModeSchema>;
+/**
+ * wp.cloud caps a task's WP-CLI run at 5 minutes; there is no point waiting
+ * past that, and a caller that waits longer is waiting on nothing.
+ */
+export declare const WP_CLI_MAX_RUN_SECONDS = 300;
+/** Bounds on the argument vector, so one call cannot post an unbounded form body. */
+export declare const WP_CLI_MAX_ARGS = 64;
+export declare const WP_CLI_MAX_ARG_LENGTH = 4096;
+export declare const wpCliRunRequestSchema: z.ZodObject<{
+    args: z.ZodArray<z.ZodString>;
+    mode: z.ZodDefault<z.ZodEnum<{
+        limited: "limited";
+        full: "full";
+    }>>;
+}, z.core.$strict>;
+export type WpCliRunRequest = z.infer<typeof wpCliRunRequestSchema>;
+export declare const wpCliRunResultSchema: z.ZodObject<{
+    taskId: z.ZodNumber;
+    status: z.ZodEnum<{
+        failed: "failed";
+        succeeded: "succeeded";
+    }>;
+    args: z.ZodArray<z.ZodString>;
+    mode: z.ZodEnum<{
+        limited: "limited";
+        full: "full";
+    }>;
+    tookMs: z.ZodNullable<z.ZodNumber>;
+    output: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type WpCliRunResult = z.infer<typeof wpCliRunResultSchema>;
+export declare const wpCliRunResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        taskId: z.ZodNumber;
+        status: z.ZodEnum<{
+            failed: "failed";
+            succeeded: "succeeded";
+        }>;
+        args: z.ZodArray<z.ZodString>;
+        mode: z.ZodEnum<{
+            limited: "limited";
+            full: "full";
+        }>;
+        tookMs: z.ZodNullable<z.ZodNumber>;
+        output: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strip>;

package/dist/contracts/wp-cli.js

@@ -0,0 +1,68 @@
+import { z } from "zod";
+import { dataEnvelope } from "./common.js";
+/**
+ * Running `wp` against a Space's own WordPress.
+ *
+ * This is the escape hatch the bespoke surfaces (`sf zero`, `sf db`, `sf
+ * content`) are carved out of: everything WP-CLI can do that Spacefast has not
+ * given a noun to. It exists so a Space is never a dead end.
+ *
+ * The relay is deliberately server-side. wp.cloud's API is reachable only from
+ * allowlisted control-plane egress, so the provider credential cannot be handed
+ * to a caller — the control plane submits the command on the caller's behalf and
+ * the credential never leaves the server.
+ */
+/** The one WP-CLI context knob wp.cloud exposes. */
+export const wpCliModeSchema = z.enum(["full", "limited"]);
+/**
+ * wp.cloud caps a task's WP-CLI run at 5 minutes; there is no point waiting
+ * past that, and a caller that waits longer is waiting on nothing.
+ */
+export const WP_CLI_MAX_RUN_SECONDS = 300;
+/** Bounds on the argument vector, so one call cannot post an unbounded form body. */
+export const WP_CLI_MAX_ARGS = 64;
+export const WP_CLI_MAX_ARG_LENGTH = 4096;
+export const wpCliRunRequestSchema = z
+    .object({
+    /**
+     * The `wp` argument vector, already split — `["option", "get", "blogname"]`,
+     * never `"option get blogname"`. A vector rather than a string because the
+     * provider takes a vector: there is no shell in the path, so nothing
+     * re-splits, re-globs, or re-quotes what the caller sent.
+     */
+    args: z.array(z.string().min(1).max(WP_CLI_MAX_ARG_LENGTH)).min(1).max(WP_CLI_MAX_ARGS),
+    /**
+     * `full` loads the site's own themes and plugins, which is what most
+     * commands need and what a caller means by "run this on my site". `limited`
+     * skips them, so a core command still answers on a site whose own code is
+     * broken — the setting you reach for when `full` fails to bootstrap.
+     */
+    mode: wpCliModeSchema.default("full"),
+})
+    .strict();
+export const wpCliRunResultSchema = z
+    .object({
+    /** wp.cloud's task id, for correlating with provider-side support requests. */
+    taskId: z.number().int(),
+    /** Whether WP-CLI exited zero. wp.cloud reports the class, not the code. */
+    status: z.enum(["succeeded", "failed"]),
+    /** The vector that ran, echoed so a stored receipt is self-describing. */
+    args: z.array(z.string()),
+    mode: wpCliModeSchema,
+    /** Provider-measured run time, or null when wp.cloud did not report one. */
+    tookMs: z.number().int().nullable(),
+    /**
+     * WP-CLI's own output, when the provider returns any.
+     *
+     * wp.cloud's task API documents no stdout/stderr channel: a completed task
+     * reports how many sites exited zero and how long it took, and nothing
+     * about what the command printed. This field is therefore `null` on every
+     * response the documented API can produce, and is present so that the day
+     * the provider does carry output, callers already have the field rather
+     * than a breaking change. It is never a silent empty string standing in for
+     * output we did not get — `null` means "the provider returned none".
+     */
+    output: z.string().nullable(),
+})
+    .strict();
+export const wpCliRunResponseSchema = dataEnvelope(wpCliRunResultSchema);

package/dist/contracts/zero-catalog.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The merge that turns two Ability origins into one catalog.
+ *
+ * A Space publishes Abilities from two places and they arrive in different
+ * shapes: the runtime engine registers the platform sets in PHP (mirrored into
+ * `ZERO_PLATFORM_ABILITIES`), and a published capsule's content model carries
+ * its own compiled at publish. The control plane serves the merge over
+ * `GET /v1/spaces/:id/zero/abilities`, and `sf zero types` generates types from
+ * it. Both want the same rows in the same order, so the merge lives here rather
+ * than once in each — two merges would eventually disagree about which
+ * capability vocabulary a row is in, which is exactly the thing that must not
+ * drift.
+ */
+import type { ContentModelReleaseV1 } from "./content-model.js";
+import type { SpaceZeroAbility } from "./zero-spacefast.js";
+/** The platform sets, which a Space publishes because it runs the engine. */
+export declare function zeroPlatformAbilityRows(): SpaceZeroAbility[];
+/**
+ * Every Ability a Space with this content model publishes.
+ *
+ * Platform sets lead and are unconditional; the content set follows and is null
+ * when no capsule declared one. Content schemas are resolved against the
+ * release's own schema table so every row describes itself the same way — a row
+ * that pointed into a document the reader does not hold would describe nothing.
+ * A pointer with nothing behind it is a malformed release rather than an
+ * Ability without a schema, but a catalog is a read: it says what it can see
+ * instead of refusing the whole list over one bad row.
+ */
+export declare function zeroAbilityCatalog(contentModel: ContentModelReleaseV1 | null): SpaceZeroAbility[];

package/dist/contracts/zero-catalog.js

@@ -0,0 +1,55 @@
+/**
+ * The merge that turns two Ability origins into one catalog.
+ *
+ * A Space publishes Abilities from two places and they arrive in different
+ * shapes: the runtime engine registers the platform sets in PHP (mirrored into
+ * `ZERO_PLATFORM_ABILITIES`), and a published capsule's content model carries
+ * its own compiled at publish. The control plane serves the merge over
+ * `GET /v1/spaces/:id/zero/abilities`, and `sf zero types` generates types from
+ * it. Both want the same rows in the same order, so the merge lives here rather
+ * than once in each — two merges would eventually disagree about which
+ * capability vocabulary a row is in, which is exactly the thing that must not
+ * drift.
+ */
+import { contentAbilityWordPressName } from "./content-model.js";
+import { ZERO_PLATFORM_ABILITIES } from "./zero-platform-abilities.generated.js";
+/** The platform sets, which a Space publishes because it runs the engine. */
+export function zeroPlatformAbilityRows() {
+    return ZERO_PLATFORM_ABILITIES.map((ability) => ({
+        name: ability.name,
+        id: ability.id,
+        category: ability.category,
+        mode: ability.mode,
+        requires: { kind: "wordpress", capability: ability.capability },
+        inputSchema: ability.inputSchema,
+        outputSchema: ability.outputSchema,
+    }));
+}
+/**
+ * Every Ability a Space with this content model publishes.
+ *
+ * Platform sets lead and are unconditional; the content set follows and is null
+ * when no capsule declared one. Content schemas are resolved against the
+ * release's own schema table so every row describes itself the same way — a row
+ * that pointed into a document the reader does not hold would describe nothing.
+ * A pointer with nothing behind it is a malformed release rather than an
+ * Ability without a schema, but a catalog is a read: it says what it can see
+ * instead of refusing the whole list over one bad row.
+ */
+export function zeroAbilityCatalog(contentModel) {
+    const platform = zeroPlatformAbilityRows();
+    if (contentModel === null) {
+        return platform;
+    }
+    const schemas = new Map(contentModel.schemas.map((schema) => [schema.id, schema.schema]));
+    const content = contentModel.abilities.map((ability) => ({
+        name: contentAbilityWordPressName(ability.id),
+        id: ability.id,
+        category: "zero-content",
+        mode: ability.mode,
+        requires: { kind: "grant", capabilities: [...ability.permits] },
+        inputSchema: schemas.get(ability.input.id) ?? null,
+        outputSchema: schemas.get(ability.output.id) ?? null,
+    }));
+    return [...platform, ...content];
+}

package/dist/contracts/zero-platform-abilities.generated.d.ts

@@ -0,0 +1,31 @@
+import type { ContentModelJsonValue } from "./content-model.js";
+/**
+ * One Ability the runtime engine registers for every Space, independent of any
+ * content model.
+ *
+ * These are the platform sets: a Space publishes them because it runs the
+ * engine, not because it published a capsule that declared them. A rollback
+ * does not move them; a new engine release does.
+ */
+export type ZeroPlatformAbility = Readonly<{
+    /** The name WordPress publishes the Ability under. */
+    name: string;
+    /** The Ability's product id, before the Abilities API's flattening. */
+    id: string;
+    category: string;
+    mode: "read" | "write";
+    /** The WordPress capability the Ability's permission callback asks for. */
+    capability: string;
+    label: string;
+    description: string;
+    annotations: Readonly<{
+        readonly: boolean;
+        destructive: boolean;
+        idempotent: boolean;
+    }>;
+    inputSchema: ContentModelJsonValue;
+    outputSchema: ContentModelJsonValue;
+}>;
+export declare const ZERO_PLATFORM_ABILITIES: readonly ZeroPlatformAbility[];
+/** The categories the platform sets register under. */
+export declare const ZERO_PLATFORM_ABILITY_CATEGORIES: readonly string[];

package/dist/contracts/zero-platform-abilities.generated.js

@@ -0,0 +1,373 @@
+// GENERATED FILE — DO NOT EDIT.
+//
+// Source of truth: runtime/engine/wordpress/content-users.php and
+// runtime/engine/wordpress/content-storage.php, read through
+// scripts/emit-zero-abilities.php — which loads those files and calls the same
+// builders `*_register_abilities()` iterates, so every schema here is the object
+// the runtime registers rather than a copy of it. Each `capability` is observed
+// by running that Ability's own permission_callback.
+//
+// Regenerate: bun scripts/codegen-zero-abilities.ts --write
+export const ZERO_PLATFORM_ABILITIES = [
+    {
+        name: "zero/storage-delete",
+        category: "zero-storage",
+        mode: "write",
+        capability: "delete_post",
+        label: "Delete a Space file",
+        description: "Trashes one file in this Space. The file leaves every listing and stays recoverable; nothing here removes it permanently.",
+        annotations: { readonly: false, destructive: true, idempotent: true },
+        inputSchema: {
+            type: "object",
+            properties: { id: { type: "integer", minimum: 1 } },
+            required: ["id"],
+            additionalProperties: false,
+        },
+        outputSchema: {
+            type: "object",
+            properties: { id: { type: "integer" }, trashed: { type: "boolean" } },
+            required: ["id", "trashed"],
+            additionalProperties: false,
+        },
+        id: "storage.delete",
+    },
+    {
+        name: "zero/storage-get",
+        category: "zero-storage",
+        mode: "read",
+        capability: "upload_files",
+        label: "Get a Space file",
+        description: "Reads one file stored in this Space.",
+        annotations: { readonly: true, destructive: false, idempotent: true },
+        inputSchema: {
+            type: "object",
+            properties: { id: { type: "integer", minimum: 1 } },
+            required: ["id"],
+            additionalProperties: false,
+        },
+        outputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "integer" },
+                title: { type: "string" },
+                filename: { type: "string" },
+                url: { type: "string" },
+                mimeType: { type: "string" },
+                alt: { type: "string" },
+                folder: { type: "string" },
+                width: { type: ["integer", "null"] },
+                height: { type: ["integer", "null"] },
+                filesize: { type: ["integer", "null"] },
+                uploadedAt: { type: "string" },
+            },
+            required: ["id", "title", "filename", "url", "mimeType", "alt", "folder", "uploadedAt"],
+            additionalProperties: false,
+        },
+        id: "storage.get",
+    },
+    {
+        name: "zero/storage-list",
+        category: "zero-storage",
+        mode: "read",
+        capability: "upload_files",
+        label: "List Space files",
+        description: "Lists the files stored in this Space, optionally within one folder.",
+        annotations: { readonly: true, destructive: false, idempotent: true },
+        inputSchema: {
+            default: [],
+            type: "object",
+            properties: {
+                page: { type: "integer", minimum: 1 },
+                perPage: { type: "integer", minimum: 1, maximum: 100 },
+                folder: {
+                    type: "string",
+                    description: "A slash-separated folder path, or empty for the Space root.",
+                },
+                recursive: { type: "boolean" },
+                search: { type: "string" },
+                mimeType: { type: "string" },
+            },
+            required: [],
+            additionalProperties: false,
+        },
+        outputSchema: {
+            type: "object",
+            properties: {
+                page: { type: "integer" },
+                perPage: { type: "integer" },
+                files: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            id: { type: "integer" },
+                            title: { type: "string" },
+                            filename: { type: "string" },
+                            url: { type: "string" },
+                            mimeType: { type: "string" },
+                            alt: { type: "string" },
+                            folder: { type: "string" },
+                            width: { type: ["integer", "null"] },
+                            height: { type: ["integer", "null"] },
+                            filesize: { type: ["integer", "null"] },
+                            uploadedAt: { type: "string" },
+                        },
+                        required: ["id", "title", "filename", "url", "mimeType", "alt", "folder", "uploadedAt"],
+                        additionalProperties: false,
+                    },
+                },
+            },
+            required: ["page", "perPage", "files"],
+            additionalProperties: false,
+        },
+        id: "storage.list",
+    },
+    {
+        name: "zero/storage-move",
+        category: "zero-storage",
+        mode: "write",
+        capability: "edit_post",
+        label: "Move a Space file",
+        description: "Moves one file into a folder, creating the folder path if needed.",
+        annotations: { readonly: false, destructive: true, idempotent: true },
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "integer", minimum: 1 },
+                folder: {
+                    type: "string",
+                    description: "A slash-separated folder path, or empty for the Space root.",
+                },
+            },
+            required: ["id", "folder"],
+            additionalProperties: false,
+        },
+        outputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "integer" },
+                title: { type: "string" },
+                filename: { type: "string" },
+                url: { type: "string" },
+                mimeType: { type: "string" },
+                alt: { type: "string" },
+                folder: { type: "string" },
+                width: { type: ["integer", "null"] },
+                height: { type: ["integer", "null"] },
+                filesize: { type: ["integer", "null"] },
+                uploadedAt: { type: "string" },
+            },
+            required: ["id", "title", "filename", "url", "mimeType", "alt", "folder", "uploadedAt"],
+            additionalProperties: false,
+        },
+        id: "storage.move",
+    },
+    {
+        name: "zero/storage-upload",
+        category: "zero-storage",
+        mode: "write",
+        capability: "upload_files",
+        label: "Upload a Space file",
+        description: "Stores a file in this Space from base64 content, optionally in a folder. WordPress decides which file types are accepted.",
+        annotations: { readonly: false, destructive: false, idempotent: false },
+        inputSchema: {
+            type: "object",
+            properties: {
+                filename: { type: "string", minLength: 1, maxLength: 255 },
+                contentBase64: { type: "string", minLength: 1 },
+                title: { type: "string", maxLength: 250 },
+                alt: { type: "string", maxLength: 1000 },
+                folder: {
+                    type: "string",
+                    description: "A slash-separated folder path, or empty for the Space root.",
+                },
+            },
+            required: ["filename", "contentBase64"],
+            additionalProperties: false,
+        },
+        outputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "integer" },
+                title: { type: "string" },
+                filename: { type: "string" },
+                url: { type: "string" },
+                mimeType: { type: "string" },
+                alt: { type: "string" },
+                folder: { type: "string" },
+                width: { type: ["integer", "null"] },
+                height: { type: ["integer", "null"] },
+                filesize: { type: ["integer", "null"] },
+                uploadedAt: { type: "string" },
+            },
+            required: ["id", "title", "filename", "url", "mimeType", "alt", "folder", "uploadedAt"],
+            additionalProperties: false,
+        },
+        id: "storage.upload",
+    },
+    {
+        name: "zero/wp-users-create",
+        category: "zero-wp-users",
+        mode: "write",
+        capability: "create_users",
+        label: "Create a Space user",
+        description: "Establishes the WordPress user for an (issuer, subject) authority and joins it to this Space. Roles are not set here: a caller's WordPress role is projected from their Grants. Only this Space is touched: if the authority already has a user that belongs solely to other Spaces on the site, the call is refused rather than reaching across to it.",
+        annotations: { readonly: false, destructive: false, idempotent: true },
+        inputSchema: {
+            type: "object",
+            properties: {
+                issuer: { type: "string", minLength: 1, maxLength: 512 },
+                subject: { type: "string", minLength: 1, maxLength: 512 },
+                displayName: { type: "string", maxLength: 250 },
+            },
+            required: ["issuer", "subject"],
+            additionalProperties: false,
+        },
+        outputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "integer" },
+                login: { type: "string" },
+                displayName: { type: "string" },
+                principal: {
+                    type: ["object", "null"],
+                    properties: {
+                        kind: { type: "string" },
+                        issuer: { type: "string" },
+                        subject: { type: "string" },
+                    },
+                },
+            },
+            required: ["id", "login", "displayName", "principal"],
+            additionalProperties: false,
+        },
+        id: "wp.users.create",
+    },
+    {
+        name: "zero/wp-users-get",
+        category: "zero-wp-users",
+        mode: "read",
+        capability: "list_users",
+        label: "Get a Space user",
+        description: "Reads one WordPress user belonging to this Space.",
+        annotations: { readonly: true, destructive: false, idempotent: true },
+        inputSchema: {
+            type: "object",
+            properties: { id: { type: "integer", minimum: 1 } },
+            required: ["id"],
+            additionalProperties: false,
+        },
+        outputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "integer" },
+                login: { type: "string" },
+                displayName: { type: "string" },
+                principal: {
+                    type: ["object", "null"],
+                    properties: {
+                        kind: { type: "string" },
+                        issuer: { type: "string" },
+                        subject: { type: "string" },
+                    },
+                },
+            },
+            required: ["id", "login", "displayName", "principal"],
+            additionalProperties: false,
+        },
+        id: "wp.users.get",
+    },
+    {
+        name: "zero/wp-users-list",
+        category: "zero-wp-users",
+        mode: "read",
+        capability: "list_users",
+        label: "List Space users",
+        description: "Lists the WordPress users belonging to this Space.",
+        annotations: { readonly: true, destructive: false, idempotent: true },
+        inputSchema: {
+            default: [],
+            type: "object",
+            properties: {
+                page: { type: "integer", minimum: 1 },
+                perPage: { type: "integer", minimum: 1, maximum: 100 },
+                search: { type: "string" },
+            },
+            required: [],
+            additionalProperties: false,
+        },
+        outputSchema: {
+            type: "object",
+            properties: {
+                page: { type: "integer" },
+                perPage: { type: "integer" },
+                users: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            id: { type: "integer" },
+                            login: { type: "string" },
+                            displayName: { type: "string" },
+                            principal: {
+                                type: ["object", "null"],
+                                properties: {
+                                    kind: { type: "string" },
+                                    issuer: { type: "string" },
+                                    subject: { type: "string" },
+                                },
+                            },
+                        },
+                        required: ["id", "login", "displayName", "principal"],
+                        additionalProperties: false,
+                    },
+                },
+            },
+            required: ["page", "perPage", "users"],
+            additionalProperties: false,
+        },
+        id: "wp.users.list",
+    },
+    {
+        name: "zero/wp-users-update",
+        category: "zero-wp-users",
+        mode: "write",
+        capability: "edit_user",
+        label: "Update a Space user",
+        description: "Updates one WordPress user's profile in this Space.",
+        annotations: { readonly: false, destructive: true, idempotent: true },
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "integer", minimum: 1 },
+                displayName: { type: "string", minLength: 1, maxLength: 250 },
+            },
+            required: ["id", "displayName"],
+            additionalProperties: false,
+        },
+        outputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "integer" },
+                login: { type: "string" },
+                displayName: { type: "string" },
+                principal: {
+                    type: ["object", "null"],
+                    properties: {
+                        kind: { type: "string" },
+                        issuer: { type: "string" },
+                        subject: { type: "string" },
+                    },
+                },
+            },
+            required: ["id", "login", "displayName", "principal"],
+            additionalProperties: false,
+        },
+        id: "wp.users.update",
+    },
+];
+/** The categories the platform sets register under. */
+export const ZERO_PLATFORM_ABILITY_CATEGORIES = [
+    "zero-storage",
+    "zero-wp-users",
+];