@spacefast/common 0.0.23 → 0.0.24

package/dist/contracts/superadmin-spaces.js

@@ -1,8 +1,10 @@
 import { z } from "zod";
 import { accessScopePathSchema } from "./access.js";
+import { makeOffsetListSchema } from "./common.js";
+import { spaceStatus } from "./enums.js";
 import { SpaceSchema } from "./resources.js";
+import { superadminPaginationSchema } from "./superadmin.js";
 import { ZERO_RUNTIME_KIND } from "./zero.js";
-const zeroLogLevelSchema = z.enum(["debug", "info", "warn", "error"]);
 export const SuperadminSpaceHostnameSchema = z.object({
     hostname: z.string(),
     url: z.string(),
@@ -39,12 +41,13 @@ export const SuperadminSpaceVersionZeroSchema = z
     runnerCompatibilityTarget: z.string().nullable(),
     runnerSha256: z.string().nullable(),
     blockIncompatibleRollback: z.boolean(),
+    // No log counts. A capsule's output is the space's runtime log like any
+    // other tier's, and that lives in one place only — the provider's PHP error
+    // log, windowed and paged. Summarising it per version would mean scanning
+    // that window on every superadmin page load; read it on the log surface
+    // instead.
     operations: z
         .object({
-        centralLogCount: z.number().int().nonnegative(),
-        centralErrorLogCount: z.number().int().nonnegative(),
-        latestLogAt: z.string().datetime().nullable(),
-        latestLogLevel: zeroLogLevelSchema.nullable(),
         replayEventCount: z.number().int().nonnegative(),
         latestReplayEventAt: z.string().datetime().nullable(),
         latestReplayEventId: z.string().nullable(),
@@ -102,27 +105,97 @@ export const SuperadminSpaceViewLinkSchema = z
     url: z.string().url(),
 })
     .strict();
-export const SuperadminAnonymousSpaceSchema = z.object({
-    id: z.string(),
-    tenantId: z.string(),
-    slug: z.string(),
-    title: z.string(),
-    status: z.string(),
-    liveUrl: z.string().nullable(),
-    defaultHostname: z.string().nullable(),
-    claimExpiresAt: z.string().datetime().nullable(),
-    createdAt: z.string().datetime().nullable(),
-    updatedAt: z.string().datetime().nullable(),
-    latestVersionId: z.string().nullable(),
-    latestVersionStatus: z.string().nullable(),
-    disabledReason: z.string().nullable(),
+// The cross-tenant Space list. Same Space resource the customer API returns —
+// operators need the identical shape, not a parallel projection — narrowed by
+// the operator-only facets (tenant, team, ownership, lifecycle, serving).
+export const SuperadminSpaceListSchema = makeOffsetListSchema("spaces", SpaceSchema, superadminPaginationSchema);
+export const superadminSpaceListQuerySchema = z.object({
+    limit: z.coerce.number().int().min(1).max(100).default(25),
+    offset: z.coerce.number().int().min(0).default(0),
+    // Unscoped search is restricted to slug prefixes and exact ids so the query
+    // stays index-backed; substring search requires a scoping filter.
+    search: z.string().trim().optional(),
+    tenantId: z.string().trim().optional(),
+    teamId: z.string().trim().optional(),
+    // Customer-360: every space owned by any team this user is a member of.
+    memberUserId: z.string().trim().optional(),
+    ownership: z.enum(["team", "external", "anonymous"]).optional(),
+    status: spaceStatus.optional(),
+    // Serving axis, independent of lifecycle status: true selects spaces whose
+    // serving is currently disabled (takedown, suspension), false the rest.
+    disabled: z.stringbool().optional(),
 });
-export const SuperadminAnonymousSpaceListSchema = z.object({
-    spaces: z.array(SuperadminAnonymousSpaceSchema),
+// Per-space scan visibility. The evidence is content-addressed — one verdict
+// per (digest, engine, signature DB version), shared by every version that
+// published the same bytes — so this projects it back onto the version's
+// manifest, which is the coordinate an operator actually has.
+export const superadminSpaceScanResultsQuerySchema = z.object({
+    // Narrow to one version; otherwise the newest `versionLimit` are returned.
+    versionId: z.string().trim().min(1).optional(),
+    versionLimit: z.coerce.number().int().min(1).max(20).default(5),
 });
-export const superadminAnonymousSpaceAssignSchema = z.object({
+export const SuperadminSpaceScanVerdictSchema = z
+    .object({
+    engine: z.string(),
+    signatureDbVersion: z.string(),
+    // The evidence row exactly as the engine wrote it. The hash allowlist never
+    // rewrites this — suppression is prospective, not a retraction.
+    verdict: z.enum(["clean", "flagged", "skipped"]),
+    // What enforcement acts on: an allowlisted media-hash flag reads clean.
+    effectiveVerdict: z.enum(["clean", "flagged", "skipped"]),
+    whitelisted: z.boolean(),
+    category: z.string().nullable(),
+    severity: z.number().int().nullable(),
+    signature: z.string().nullable(),
+    firstSeenAt: z.string().datetime().nullable(),
+})
+    .strict();
+export const SuperadminSpaceScanFileSchema = z
+    .object({
+    path: z.string(),
+    size: z.number().int().nonnegative(),
+    // Historical manifest rows and sourceUrl entries can lack a digest; those
+    // files are uncorrelatable and count as unscanned.
+    sha256: z.string().nullable(),
+    verdicts: z.array(SuperadminSpaceScanVerdictSchema),
+})
+    .strict();
+export const SuperadminSpaceScanVersionSchema = z
+    .object({
+    versionId: z.string(),
+    number: z.number().int().nullable(),
+    status: z.string(),
+    readyAt: z.string().datetime().nullable(),
+    files: z.array(SuperadminSpaceScanFileSchema),
+    // One bucket per manifest file, by the worst effective verdict it carries:
+    // flagged beats skipped beats clean, and a file with no evidence row at all
+    // is unscanned. The four always sum to the manifest file count.
+    summary: z
+        .object({
+        flagged: z.number().int().nonnegative(),
+        skipped: z.number().int().nonnegative(),
+        clean: z.number().int().nonnegative(),
+        unscanned: z.number().int().nonnegative(),
+    })
+        .strict(),
+})
+    .strict();
+export const SuperadminSpaceScanResultsSchema = z
+    .object({
+    // The aggregated space-level verdict the enforcement pipeline settled on.
+    spaceScanVerdict: z.string().nullable(),
+    versions: z.array(SuperadminSpaceScanVersionSchema),
+})
+    .strict();
+// Operator re-home: one assign for every space, claimed or not. The reason is
+// the operator's own note on why ownership moved — it lands in the space's
+// activity feed, so the customer can read it.
+export const superadminSpaceAssignSchema = z
+    .object({
     teamId: z.string().min(1),
-});
-export const SuperadminAnonymousSpaceAssignResponseSchema = z.object({
+    reason: z.string().trim().min(1).max(500).optional(),
+})
+    .strict();
+export const SuperadminSpaceAssignResponseSchema = z.object({
     space: SpaceSchema,
 });

package/dist/contracts/superadmin-teams.d.ts

@@ -14,12 +14,21 @@ export declare const SuperadminTeamSchema: z.ZodObject<{
     updatedAt: z.ZodString;
 }, z.core.$strip>;
 export declare const SuperadminTeamMemberSchema: z.ZodObject<{
-    membershipId: z.ZodString;
-    role: z.ZodString;
-    joinedAt: z.ZodString;
+    id: z.ZodString;
+    teamId: z.ZodString;
     userId: z.ZodString;
-    userName: z.ZodString;
-    userEmail: z.ZodString;
+    role: z.ZodEnum<{
+        owner: "owner";
+        admin: "admin";
+        member: "member";
+    }>;
+    createdAt: z.ZodString;
+    user: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        email: z.ZodString;
+        image: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
     userBanned: z.ZodBoolean;
 }, z.core.$strip>;
 export declare const SuperadminTeamDetailSchema: z.ZodObject<{
@@ -36,12 +45,21 @@ export declare const SuperadminTeamDetailSchema: z.ZodObject<{
     createdAt: z.ZodString;
     updatedAt: z.ZodString;
     members: z.ZodArray<z.ZodObject<{
-        membershipId: z.ZodString;
-        role: z.ZodString;
-        joinedAt: z.ZodString;
+        id: z.ZodString;
+        teamId: z.ZodString;
         userId: z.ZodString;
-        userName: z.ZodString;
-        userEmail: z.ZodString;
+        role: z.ZodEnum<{
+            owner: "owner";
+            admin: "admin";
+            member: "member";
+        }>;
+        createdAt: z.ZodString;
+        user: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            email: z.ZodString;
+            image: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
         userBanned: z.ZodBoolean;
     }, z.core.$strip>>;
 }, z.core.$strip>;

package/dist/contracts/superadmin-teams.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { makeOffsetListSchema } from "./common.js";
 import { superadminPaginationSchema } from "./superadmin.js";
+import { TeamMemberSchema } from "./teams.js";
 export const SuperadminTeamSchema = z.object({
     id: z.string(),
     tenantId: z.string(),
@@ -15,14 +16,10 @@ export const SuperadminTeamSchema = z.object({
     createdAt: z.string().datetime(),
     updatedAt: z.string().datetime(),
 });
-export const SuperadminTeamMemberSchema = z.object({
-    membershipId: z.string(),
-    role: z.string(),
-    joinedAt: z.string().datetime(),
-    userId: z.string(),
-    userName: z.string(),
-    userEmail: z.string().email(),
-    userBanned: z.boolean(),
+// Superadmin reads the same membership shape every other surface does, plus
+// the one operator-only fact the product API never exposes.
+export const SuperadminTeamMemberSchema = TeamMemberSchema.extend({
+    userBanned: z.boolean().describe("Whether the member's user account is banned."),
 });
 export const SuperadminTeamDetailSchema = SuperadminTeamSchema.extend({
     members: z.array(SuperadminTeamMemberSchema),

package/dist/contracts/superadmin.d.ts

@@ -314,8 +314,6 @@ export declare const SuperadminBillingTransactionSchema: z.ZodObject<{
     teamName: z.ZodNullable<z.ZodString>;
     provider: z.ZodEnum<{
         stripe: "stripe";
-        app_store: "app_store";
-        google_play: "google_play";
     }>;
     kind: z.ZodEnum<{
         purchase: "purchase";
@@ -356,8 +354,6 @@ export declare const SuperadminTeamBillingOverviewSchema: z.ZodObject<{
         provider: z.ZodEnum<{
             grant: "grant";
             stripe: "stripe";
-            app_store: "app_store";
-            google_play: "google_play";
         }>;
         planCode: z.ZodString;
         active: z.ZodBoolean;
@@ -369,26 +365,12 @@ export declare const SuperadminTeamBillingOverviewSchema: z.ZodObject<{
 export declare const SuperadminWpCloudSiteSchema: z.ZodObject<{
     providerSiteId: z.ZodString;
     placementId: z.ZodNullable<z.ZodString>;
-    placementKind: z.ZodNullable<z.ZodEnum<{
-        shared: "shared";
-        dedicated: "dedicated";
-        shared_org: "shared_org";
-        anonymous_pool: "anonymous_pool";
-        dedicated_space: "dedicated_space";
-    }>>;
     placementState: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     placementStatus: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     placementPrimaryHostname: z.ZodNullable<z.ZodString>;
     placementDatacenterId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     placementRegion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     placementGeoAffinity: z.ZodNullable<z.ZodString>;
-    anonymousPoolId: z.ZodNullable<z.ZodString>;
-    anonymousPoolState: z.ZodNullable<z.ZodEnum<{
-        active: "active";
-        disabled: "disabled";
-        draining: "draining";
-    }>>;
-    anonymousPoolAssignedSpaceCount: z.ZodNullable<z.ZodNumber>;
     assignedSpaceCount: z.ZodNumber;
     assignedSpaces: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
@@ -437,26 +419,12 @@ export declare const SuperadminWpCloudSiteListSchema: z.ZodObject<{
     sites: z.ZodArray<z.ZodObject<{
         providerSiteId: z.ZodString;
         placementId: z.ZodNullable<z.ZodString>;
-        placementKind: z.ZodNullable<z.ZodEnum<{
-            shared: "shared";
-            dedicated: "dedicated";
-            shared_org: "shared_org";
-            anonymous_pool: "anonymous_pool";
-            dedicated_space: "dedicated_space";
-        }>>;
         placementState: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         placementStatus: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         placementPrimaryHostname: z.ZodNullable<z.ZodString>;
         placementDatacenterId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         placementRegion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         placementGeoAffinity: z.ZodNullable<z.ZodString>;
-        anonymousPoolId: z.ZodNullable<z.ZodString>;
-        anonymousPoolState: z.ZodNullable<z.ZodEnum<{
-            active: "active";
-            disabled: "disabled";
-            draining: "draining";
-        }>>;
-        anonymousPoolAssignedSpaceCount: z.ZodNullable<z.ZodNumber>;
         assignedSpaceCount: z.ZodNumber;
         assignedSpaces: z.ZodArray<z.ZodObject<{
             id: z.ZodString;

package/dist/contracts/superadmin.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { makeOffsetListSchema } from "./common.js";
-import { buildStatus, siteClass } from "./enums.js";
+import { buildStatus } from "./enums.js";
 // Operator-only offset pagination. The platform API uses opaque cursors exclusively
 // (contracts/common.ts); the superadmin surface is the one sanctioned exception.
 export const superadminPaginationSchema = z.object({
@@ -183,7 +183,7 @@ export const SuperadminBillingTransactionSchema = z.object({
     teamId: z.string().nullable(),
     teamSlug: z.string().nullable(),
     teamName: z.string().nullable(),
-    provider: z.enum(["stripe", "app_store", "google_play"]),
+    provider: z.enum(["stripe"]),
     kind: z.enum(["purchase", "renewal", "refund", "adjustment"]),
     scope: z.enum(["plan", "seats", "domain", "other"]),
     planCode: z.string().nullable(),
@@ -210,7 +210,7 @@ export const SuperadminTeamBillingOverviewSchema = z.object({
     }),
     planCode: z.string(),
     sources: z.array(z.object({
-        provider: z.enum(["stripe", "app_store", "google_play", "grant"]),
+        provider: z.enum(["stripe", "grant"]),
         planCode: z.string(),
         active: z.boolean(),
         detail: z.string(),
@@ -221,20 +221,12 @@ export const SuperadminTeamBillingOverviewSchema = z.object({
 export const SuperadminWpCloudSiteSchema = z.object({
     providerSiteId: z.string(),
     placementId: z.string().nullable(),
-    // Reuses `siteClass` (enums.ts) rather than a private legacy-only literal
-    // union — this echoes the site's raw placementMode column, which Deploy T
-    // still tolerates in both legacy (anonymous_pool/shared_org/dedicated_space)
-    // and normalized (shared/dedicated) form.
-    placementKind: siteClass.nullable(),
     placementState: z.string().nullable().optional(),
     placementStatus: z.string().nullable().optional(),
     placementPrimaryHostname: z.string().nullable(),
     placementDatacenterId: z.string().nullable().optional(),
     placementRegion: z.string().nullable().optional(),
     placementGeoAffinity: z.string().nullable(),
-    anonymousPoolId: z.string().nullable(),
-    anonymousPoolState: z.enum(["active", "draining", "disabled"]).nullable(),
-    anonymousPoolAssignedSpaceCount: z.number().int().nonnegative().nullable(),
     assignedSpaceCount: z.number().int().nonnegative(),
     assignedSpaces: z.array(z.object({
         id: z.string(),

package/dist/contracts/tags.d.ts

@@ -81,8 +81,8 @@ export declare const tagConsentPolicySchema: z.ZodObject<{
         code: z.ZodString;
         severity: z.ZodEnum<{
             info: "info";
-            error: "error";
             warning: "warning";
+            error: "error";
         }>;
         message: z.ZodString;
         path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -142,8 +142,8 @@ export declare const tagValidationResultSchema: z.ZodObject<{
         code: z.ZodString;
         severity: z.ZodEnum<{
             info: "info";
-            error: "error";
             warning: "warning";
+            error: "error";
         }>;
         message: z.ZodString;
         path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -191,8 +191,8 @@ export declare const tagVersionSchema: z.ZodObject<{
             code: z.ZodString;
             severity: z.ZodEnum<{
                 info: "info";
-                error: "error";
                 warning: "warning";
+                error: "error";
             }>;
             message: z.ZodString;
             path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -261,8 +261,8 @@ export declare const tagVersionListResponseSchema: z.ZodObject<{
                 code: z.ZodString;
                 severity: z.ZodEnum<{
                     info: "info";
-                    error: "error";
                     warning: "warning";
+                    error: "error";
                 }>;
                 message: z.ZodString;
                 path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -324,8 +324,8 @@ export declare const tagVersionResponseSchema: z.ZodObject<{
                 code: z.ZodString;
                 severity: z.ZodEnum<{
                     info: "info";
-                    error: "error";
                     warning: "warning";
+                    error: "error";
                 }>;
                 message: z.ZodString;
                 path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -419,8 +419,8 @@ export declare const tagValidateResponseSchema: z.ZodObject<{
             code: z.ZodString;
             severity: z.ZodEnum<{
                 info: "info";
-                error: "error";
                 warning: "warning";
+                error: "error";
             }>;
             message: z.ZodString;
             path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -640,8 +640,8 @@ export declare const tagApplyResponseSchema: z.ZodObject<{
                     code: z.ZodString;
                     severity: z.ZodEnum<{
                         info: "info";
-                        error: "error";
                         warning: "warning";
+                        error: "error";
                     }>;
                     message: z.ZodString;
                     path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -673,8 +673,8 @@ export declare const tagApplyResponseSchema: z.ZodObject<{
                 code: z.ZodString;
                 severity: z.ZodEnum<{
                     info: "info";
-                    error: "error";
                     warning: "warning";
+                    error: "error";
                 }>;
                 message: z.ZodString;
                 path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -1022,8 +1022,8 @@ export declare const tagConsentPolicyResponseSchema: z.ZodObject<{
                 code: z.ZodString;
                 severity: z.ZodEnum<{
                     info: "info";
-                    error: "error";
                     warning: "warning";
+                    error: "error";
                 }>;
                 message: z.ZodString;
                 path: z.ZodOptional<z.ZodNullable<z.ZodString>>;

package/dist/contracts/teams.d.ts

@@ -5,6 +5,12 @@ export declare const teamMemberRole: z.ZodEnum<{
     admin: "admin";
     member: "member";
 }>;
+/**
+ * Better Auth stores the member role as free text, so every surface that reads
+ * it back has to land on the same canonical value. Unknown roles carry no
+ * privilege, so they read as the least-privileged one.
+ */
+export declare function normalizeTeamMemberRole(role: string | null | undefined): "owner" | "admin" | "member";
 export declare const teamInvitationCreateSchema: z.ZodObject<{
     email: z.ZodString;
     role: z.ZodDefault<z.ZodEnum<{
@@ -29,6 +35,37 @@ export declare const teamSpaceListQuerySchema: z.ZodObject<{
     limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
     cursor: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
+export declare const TeamMemberUserSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    email: z.ZodString;
+    image: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const TeamMemberSchema: z.ZodObject<{
+    id: z.ZodString;
+    teamId: z.ZodString;
+    userId: z.ZodString;
+    role: z.ZodEnum<{
+        owner: "owner";
+        admin: "admin";
+        member: "member";
+    }>;
+    createdAt: z.ZodString;
+    user: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        email: z.ZodString;
+        image: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const teamMemberRoleUpdateSchema: z.ZodObject<{
+    role: z.ZodEnum<{
+        owner: "owner";
+        admin: "admin";
+        member: "member";
+    }>;
+}, z.core.$strip>;
+export type TeamMember = z.infer<typeof TeamMemberSchema>;
 export declare const TeamInvitationSchema: z.ZodObject<{
     id: z.ZodString;
     teamId: z.ZodString;
@@ -42,6 +79,7 @@ export declare const TeamInvitationSchema: z.ZodObject<{
     expiresAt: z.ZodString;
     createdAt: z.ZodString;
 }, z.core.$strip>;
+export type TeamInvitation = z.infer<typeof TeamInvitationSchema>;
 export declare const teamPlanCode: z.ZodEnum<{
     free: "free";
     internal: "internal";

package/dist/contracts/teams.js

@@ -3,6 +3,15 @@ import { CursorPaginationSchema, cursorListQuerySchema } from "./common.js";
 import { planCodeSchema, planLimitValueSchema } from "./features.js";
 export const TEAM_ROLE_VALUES = ["owner", "admin", "member"];
 export const teamMemberRole = z.enum(TEAM_ROLE_VALUES);
+/**
+ * Better Auth stores the member role as free text, so every surface that reads
+ * it back has to land on the same canonical value. Unknown roles carry no
+ * privilege, so they read as the least-privileged one.
+ */
+export function normalizeTeamMemberRole(role) {
+    const parsed = teamMemberRole.safeParse(role ?? "member");
+    return parsed.success ? parsed.data : "member";
+}
 export const teamInvitationCreateSchema = z.object({
     email: z.string().trim().email().toLowerCase(),
     role: teamMemberRole.default("member"),
@@ -11,19 +20,26 @@ export const teamMemberListQuerySchema = cursorListQuerySchema;
 export const teamInvitationListQuerySchema = cursorListQuerySchema;
 export const teamListQuerySchema = cursorListQuerySchema;
 export const teamSpaceListQuerySchema = cursorListQuerySchema;
-const TeamMemberUserSchema = z.object({
-    id: z.string(),
-    name: z.string(),
-    email: z.string().email(),
-    image: z.string().nullable(),
-});
-const TeamMemberSchema = z.object({
-    id: z.string(),
-    teamId: z.string(),
-    userId: z.string(),
-    role: teamMemberRole,
-    createdAt: z.string().datetime(),
-    user: TeamMemberUserSchema.nullable(),
+export const TeamMemberUserSchema = z.object({
+    id: z.string().describe("The member's user id."),
+    name: z.string().describe("The member's display name."),
+    email: z.string().email().describe("The member's email address."),
+    image: z.string().nullable().describe("Avatar URL, or null when the user has none."),
+});
+// The one membership shape: every surface that shows or edits a team member
+// (dashboard, superadmin, CLI, MCP) types from this. Better Auth's
+// organization plugin owns the underlying rows, but its plugin-inferred types
+// never cross an app boundary.
+export const TeamMemberSchema = z.object({
+    id: z.string().describe("The membership id, stable for the life of the membership."),
+    teamId: z.string().describe("The team this membership belongs to."),
+    userId: z.string().describe("The member's user id."),
+    role: teamMemberRole.describe("The member's role on the team."),
+    createdAt: z.string().datetime().describe("Instant the member joined the team."),
+    user: TeamMemberUserSchema.nullable().describe("The member's user record; null when the user row is unavailable."),
+});
+export const teamMemberRoleUpdateSchema = z.object({
+    role: teamMemberRole.describe("The role to grant this member."),
 });
 export const TeamInvitationSchema = z.object({
     id: z.string(),
@@ -135,7 +151,9 @@ export const teamUsageResponseSchema = z.object({
         spaces: z.number().int().describe("Live spaces in the team."),
         domains: z.number().int().describe("External domain groups counted against the plan."),
         members: z.number().int().describe("Team members."),
-        storageBytes: z.number().describe("Stored bytes across the team's spaces."),
+        storageBytes: z
+            .number()
+            .describe("Disk actually occupied across the team's spaces, as measured by the serving infrastructure. Nothing is deduplicated: a file present in two spaces sits on two disks and counts twice."),
         storageQuotaBytes: z
             .union([z.number(), z.literal("unlimited")])
             .describe('Plan storage quota; "unlimited" when unbounded.'),
@@ -143,7 +161,7 @@ export const teamUsageResponseSchema = z.object({
         storageCalculatedAt: z
             .string()
             .nullable()
-            .describe("Instant when storage was last accounted."),
+            .describe("How far back the weakest measurement behind this total reaches. Null when the team's storage has not been measured yet. This is a lagging meter — expect it to trail the present by about an hour."),
         buildsDeploysThisMonth: z
             .number()
             .int()
@@ -162,7 +180,7 @@ export const teamUsageResponseSchema = z.object({
         title: z.string().describe("Space display title."),
         storageBytes: z
             .number()
-            .describe("Deduplicated bytes this space's ready versions hold. Spaces sharing files each count them, so the sum can exceed the team total."),
+            .describe("Disk this space occupies, as measured by the infrastructure serving it. Zero for a space that has not been measured yet."),
     }))
         .describe("Per-space storage breakdown for spaces the caller can read."),
 });

package/dist/contracts/transfers.d.ts

@@ -45,59 +45,10 @@ export declare const spaceTransferSchema: z.ZodObject<{
     }, z.core.$strip>;
     status: z.ZodEnum<{
         pending_confirmation: "pending_confirmation";
-        confirming_domains: "confirming_domains";
         completed: "completed";
         canceled: "canceled";
         expired: "expired";
     }>;
-    requiredActions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        type: z.ZodLiteral<"dns">;
-        instructions: z.ZodArray<z.ZodObject<{
-            type: z.ZodEnum<{
-                A: "A";
-                AAAA: "AAAA";
-                CNAME: "CNAME";
-                TXT: "TXT";
-                ALIAS: "ALIAS";
-            }>;
-            name: z.ZodString;
-            value: z.ZodString;
-            ttl: z.ZodOptional<z.ZodNumber>;
-            purpose: z.ZodEnum<{
-                verification: "verification";
-                routing: "routing";
-                ssl: "ssl";
-            }>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"confirm_move">;
-        conflictId: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"verify_domain">;
-        domainId: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"renew">;
-        domainId: z.ZodString;
-    }, z.core.$strip>], "type">>;
-    diagnostics: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        code: z.ZodString;
-        severity: z.ZodEnum<{
-            info: "info";
-            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";
-            dns: "dns";
-            runtime: "runtime";
-        }>>>;
-        details: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-        fix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        retryable: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
-    }, z.core.$strip>>>;
     expiresAt: z.ZodString;
     createdAt: z.ZodString;
     updatedAt: z.ZodString;

package/dist/contracts/transfers.js

@@ -1,5 +1,4 @@
 import { z } from "zod";
-import { baseDiagnosticSchema, requiredActionsSchema } from "./common.js";
 import { spaceTransferStatus } from "./enums.js";
 // Tenant-local external principal id grammar (internal-docs/platform.md
 // "Principal"): 1-256 chars, no whitespace, no `/` or `\`, no
@@ -34,11 +33,8 @@ export const spaceTransferSchema = z.object({
     id: z.string().describe("SpaceTransfer id (`trf_`)."),
     spaceId: z.string().describe("Space being transferred."),
     from: transferPrincipalSchema.describe("Current owner. Keeps full control, serving, and billing attribution until `completed`."),
-    to: transferPrincipalSchema.describe("Receiving principal. Confirm is a to-side action."),
-    status: spaceTransferStatus.describe("Transfer state. `confirming_domains` waits on re-confirmation of bound domains; a failed move reverts to `pending_confirmation` with a diagnostic (there is no failed state)."),
-    // Domain confirmations the receiving principal must complete before the move.
-    requiredActions: requiredActionsSchema,
-    diagnostics: z.array(baseDiagnosticSchema).default([]),
+    to: transferPrincipalSchema.describe("Receiving principal. Accept is a to-side action."),
+    status: spaceTransferStatus.describe("Transfer state. Accepting moves ownership in one transaction, so a transfer is either still `pending_confirmation` or already terminal."),
     expiresAt: z
         .string()
         .datetime()