ankka-console 0.10.0

package/dist/client/schemas.d.ts

@@ -0,0 +1,365 @@
+/**
+ * The control plane's wire types, mirrored from `controlplane-api`'s `descriptors.scala`.
+ *
+ * Mapping rules, the same everywhere: a Scala `Option` is an optional field (absent or `null`), an
+ * `Instant` is an ISO-8601 string, a `LocalDate` is `YYYY-MM-DD`, an enum is its word, and a key this
+ * side does not know is dropped on decode, so a newer control plane answers an older console.
+ * `console/package/fixtures/control-plane/` holds what the platform's own codecs write for each type,
+ * and the package's tests decode every one of them.
+ */
+import { z } from "zod";
+/** `Role`'s codec writes the lowercase word. */
+export declare const roleSchema: z.ZodEnum<{
+    member: "member";
+    owner: "owner";
+}>;
+export type Role = z.infer<typeof roleSchema>;
+/**
+ * The words `ServiceLifecycle`'s codec writes today. The schema accepts any string, so a word a newer
+ * control plane adds is shown as it is rather than failing the page.
+ */
+export declare const serviceLifecycles: readonly ["NotDeployed", "UpdateInProgress", "Ready", "PartiallyReady", "Unavailable", "Paused", "Failed", "Suspended"];
+export type KnownServiceLifecycle = (typeof serviceLifecycles)[number];
+export declare const serviceLifecycleSchema: z.ZodString;
+export type ServiceLifecycle = KnownServiceLifecycle | (string & {});
+export declare const authDiscoverySchema: z.ZodObject<{
+    issuer: z.ZodString;
+    clientId: z.ZodString;
+    audience: z.ZodString;
+}, z.core.$strip>;
+export type AuthDiscovery = z.infer<typeof authDiscoverySchema>;
+export declare const organizationMembershipSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    role: z.ZodEnum<{
+        member: "member";
+        owner: "owner";
+    }>;
+}, z.core.$strip>;
+export type OrganizationMembership = z.infer<typeof organizationMembershipSchema>;
+export declare const whoamiSchema: z.ZodObject<{
+    subject: z.ZodString;
+    name: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+    email: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+    emailVerified: z.ZodDefault<z.ZodBoolean>;
+    platformAdmin: z.ZodDefault<z.ZodBoolean>;
+    organizations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        role: z.ZodEnum<{
+            member: "member";
+            owner: "owner";
+        }>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type Whoami = z.infer<typeof whoamiSchema>;
+export declare const quotaSchema: z.ZodObject<{
+    projects: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodNumber>>, z.ZodTransform<number | undefined, number | null | undefined>>;
+    services: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodNumber>>, z.ZodTransform<number | undefined, number | null | undefined>>;
+    instances: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodNumber>>, z.ZodTransform<number | undefined, number | null | undefined>>;
+}, z.core.$strip>;
+export type Quota = z.input<typeof quotaSchema>;
+export declare const usageSchema: z.ZodObject<{
+    projects: z.ZodNumber;
+    services: z.ZodNumber;
+    instances: z.ZodNumber;
+}, z.core.$strip>;
+export type Usage = z.infer<typeof usageSchema>;
+export declare const organizationDetailSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    disabled: z.ZodDefault<z.ZodBoolean>;
+    quota: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        projects: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodNumber>>, z.ZodTransform<number | undefined, number | null | undefined>>;
+        services: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodNumber>>, z.ZodTransform<number | undefined, number | null | undefined>>;
+        instances: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodNumber>>, z.ZodTransform<number | undefined, number | null | undefined>>;
+    }, z.core.$strip>>>, z.ZodTransform<{
+        projects: number | undefined;
+        services: number | undefined;
+        instances: number | undefined;
+    } | undefined, {
+        projects: number | undefined;
+        services: number | undefined;
+        instances: number | undefined;
+    } | null | undefined>>;
+    usage: z.ZodDefault<z.ZodObject<{
+        projects: z.ZodNumber;
+        services: z.ZodNumber;
+        instances: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type OrganizationDetail = z.infer<typeof organizationDetailSchema>;
+export declare const organizationSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    projects: z.ZodNumber;
+    disabled: z.ZodDefault<z.ZodBoolean>;
+    role: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        member: "member";
+        owner: "owner";
+    }>>>, z.ZodTransform<NonNullable<"member" | "owner"> | undefined, "member" | "owner" | null | undefined>>;
+    quota: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        projects: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodNumber>>, z.ZodTransform<number | undefined, number | null | undefined>>;
+        services: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodNumber>>, z.ZodTransform<number | undefined, number | null | undefined>>;
+        instances: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodNumber>>, z.ZodTransform<number | undefined, number | null | undefined>>;
+    }, z.core.$strip>>>, z.ZodTransform<{
+        projects: number | undefined;
+        services: number | undefined;
+        instances: number | undefined;
+    } | undefined, {
+        projects: number | undefined;
+        services: number | undefined;
+        instances: number | undefined;
+    } | null | undefined>>;
+    usage: z.ZodDefault<z.ZodObject<{
+        projects: z.ZodNumber;
+        services: z.ZodNumber;
+        instances: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type OrganizationSummary = z.infer<typeof organizationSummarySchema>;
+export declare const registrySummarySchema: z.ZodObject<{
+    server: z.ZodString;
+    username: z.ZodString;
+    setAt: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+    setBy: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+}, z.core.$strip>;
+export type RegistrySummary = z.infer<typeof registrySummarySchema>;
+export declare const projectDetailSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    organizationId: z.ZodString;
+    registry: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        server: z.ZodString;
+        username: z.ZodString;
+        setAt: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+        setBy: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+    }, z.core.$strip>>>, z.ZodTransform<{
+        server: string;
+        username: string;
+        setAt: string | undefined;
+        setBy: string | undefined;
+    } | undefined, {
+        server: string;
+        username: string;
+        setAt: string | undefined;
+        setBy: string | undefined;
+    } | null | undefined>>;
+}, z.core.$strip>;
+export type ProjectDetail = z.infer<typeof projectDetailSchema>;
+export declare const projectSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    organizationId: z.ZodString;
+    services: z.ZodNumber;
+    registry: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        server: z.ZodString;
+        username: z.ZodString;
+        setAt: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+        setBy: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+    }, z.core.$strip>>>, z.ZodTransform<{
+        server: string;
+        username: string;
+        setAt: string | undefined;
+        setBy: string | undefined;
+    } | undefined, {
+        server: string;
+        username: string;
+        setAt: string | undefined;
+        setBy: string | undefined;
+    } | null | undefined>>;
+}, z.core.$strip>;
+export type ProjectSummary = z.infer<typeof projectSummarySchema>;
+export declare const serviceStatusSchema: z.ZodObject<{
+    name: z.ZodString;
+    projectId: z.ZodString;
+    lifecycle: z.ZodString;
+    generation: z.ZodNumber;
+    image: z.ZodString;
+    readyInstances: z.ZodNumber;
+    desiredInstances: z.ZodNumber;
+    detail: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+    confirmed: z.ZodDefault<z.ZodBoolean>;
+    database: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+    hostname: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+    exposed: z.ZodDefault<z.ZodBoolean>;
+    suspended: z.ZodDefault<z.ZodBoolean>;
+    paused: z.ZodDefault<z.ZodBoolean>;
+    hosting: z.ZodDefault<z.ZodString>;
+    protocol: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+}, z.core.$strip>;
+export type ServiceStatus = z.infer<typeof serviceStatusSchema>;
+export declare const historyActorSchema: z.ZodObject<{
+    subject: z.ZodString;
+    display: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+    administrative: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type HistoryActor = z.infer<typeof historyActorSchema>;
+export declare const historyEntrySchema: z.ZodObject<{
+    kind: z.ZodString;
+    generation: z.ZodNumber;
+    actor: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        subject: z.ZodString;
+        display: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+        administrative: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>>, z.ZodTransform<{
+        subject: string;
+        display: string | undefined;
+        administrative: boolean;
+    } | undefined, {
+        subject: string;
+        display: string | undefined;
+        administrative: boolean;
+    } | null | undefined>>;
+    at: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+}, z.core.$strip>;
+export type HistoryEntry = z.infer<typeof historyEntrySchema>;
+export declare const instanceLogsSchema: z.ZodObject<{
+    instance: z.ZodString;
+    output: z.ZodString;
+    error: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+}, z.core.$strip>;
+export type InstanceLogs = z.infer<typeof instanceLogsSchema>;
+export declare const logsResponseSchema: z.ZodObject<{
+    instances: z.ZodArray<z.ZodObject<{
+        instance: z.ZodString;
+        output: z.ZodString;
+        error: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type LogsResponse = z.infer<typeof logsResponseSchema>;
+export declare const memberSummarySchema: z.ZodObject<{
+    subject: z.ZodString;
+    role: z.ZodEnum<{
+        member: "member";
+        owner: "owner";
+    }>;
+    email: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+    display: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+    since: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+    addedBy: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+}, z.core.$strip>;
+export type MemberSummary = z.infer<typeof memberSummarySchema>;
+export declare const invitationSummarySchema: z.ZodObject<{
+    email: z.ZodString;
+    role: z.ZodEnum<{
+        member: "member";
+        owner: "owner";
+    }>;
+    invitedAt: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+    invitedBy: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+}, z.core.$strip>;
+export type InvitationSummary = z.infer<typeof invitationSummarySchema>;
+export declare const membersResponseSchema: z.ZodObject<{
+    members: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        subject: z.ZodString;
+        role: z.ZodEnum<{
+            member: "member";
+            owner: "owner";
+        }>;
+        email: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+        display: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+        since: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+        addedBy: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+    }, z.core.$strip>>>;
+    invitations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        email: z.ZodString;
+        role: z.ZodEnum<{
+            member: "member";
+            owner: "owner";
+        }>;
+        invitedAt: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+        invitedBy: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type MembersResponse = z.infer<typeof membersResponseSchema>;
+export declare const deployTokenSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    subject: z.ZodString;
+    createdBy: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+    createdAt: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+    expiresAt: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+    lastUsed: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+}, z.core.$strip>;
+export type DeployTokenSummary = z.infer<typeof deployTokenSummarySchema>;
+export declare const deployTokenCreatedSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    secret: z.ZodString;
+    subject: z.ZodString;
+    expiresAt: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+}, z.core.$strip>;
+export type DeployTokenCreated = z.infer<typeof deployTokenCreatedSchema>;
+export declare const errorBodySchema: z.ZodObject<{
+    status: z.ZodNumber;
+    error: z.ZodString;
+}, z.core.$strip>;
+export type ErrorBody = z.infer<typeof errorBodySchema>;
+export declare const ownerSchema: z.ZodObject<{
+    subject: z.ZodString;
+    email: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+    display: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+}, z.core.$strip>;
+export type Owner = z.input<typeof ownerSchema>;
+export declare const createOrganizationSchema: z.ZodObject<{
+    name: z.ZodString;
+    owner: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        subject: z.ZodString;
+        email: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+        display: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+    }, z.core.$strip>>>, z.ZodTransform<{
+        subject: string;
+        email: string | undefined;
+        display: string | undefined;
+    } | undefined, {
+        subject: string;
+        email: string | undefined;
+        display: string | undefined;
+    } | null | undefined>>;
+}, z.core.$strip>;
+export type CreateOrganization = z.input<typeof createOrganizationSchema>;
+export declare const createProjectSchema: z.ZodObject<{
+    name: z.ZodString;
+    organizationId: z.ZodString;
+}, z.core.$strip>;
+export type CreateProject = z.input<typeof createProjectSchema>;
+export declare const renameSchema: z.ZodObject<{
+    name: z.ZodString;
+}, z.core.$strip>;
+export type Rename = z.input<typeof renameSchema>;
+export declare const inviteSchema: z.ZodObject<{
+    email: z.ZodString;
+    role: z.ZodDefault<z.ZodEnum<{
+        member: "member";
+        owner: "owner";
+    }>>;
+}, z.core.$strip>;
+export type Invite = z.input<typeof inviteSchema>;
+export declare const roleChangeSchema: z.ZodObject<{
+    role: z.ZodEnum<{
+        member: "member";
+        owner: "owner";
+    }>;
+}, z.core.$strip>;
+export type RoleChange = z.input<typeof roleChangeSchema>;
+export declare const repairSchema: z.ZodObject<{
+    role: z.ZodDefault<z.ZodEnum<{
+        member: "member";
+        owner: "owner";
+    }>>;
+}, z.core.$strip>;
+export type Repair = z.input<typeof repairSchema>;
+export declare const createDeployTokenSchema: z.ZodObject<{
+    label: z.ZodString;
+    expiresIn: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodNumber>>, z.ZodTransform<number | undefined, number | null | undefined>>;
+}, z.core.$strip>;
+export type CreateDeployToken = z.input<typeof createDeployTokenSchema>;
+export declare const setRegistrySchema: z.ZodObject<{
+    server: z.ZodString;
+    username: z.ZodString;
+    password: z.ZodString;
+}, z.core.$strip>;
+export type SetRegistry = z.input<typeof setRegistrySchema>;
+/** Every schema by the Scala type's name, as the fixture files name them. */
+export declare const schemasByType: Record<string, z.ZodType>;

package/dist/client/schemas.js

@@ -0,0 +1,221 @@
+/**
+ * The control plane's wire types, mirrored from `controlplane-api`'s `descriptors.scala`.
+ *
+ * Mapping rules, the same everywhere: a Scala `Option` is an optional field (absent or `null`), an
+ * `Instant` is an ISO-8601 string, a `LocalDate` is `YYYY-MM-DD`, an enum is its word, and a key this
+ * side does not know is dropped on decode, so a newer control plane answers an older console.
+ * `console/package/fixtures/control-plane/` holds what the platform's own codecs write for each type,
+ * and the package's tests decode every one of them.
+ */
+import { z } from "zod";
+const optional = (schema) => schema.nullish().transform((v) => v ?? undefined);
+/** `Role`'s codec writes the lowercase word. */
+export const roleSchema = z.enum(["owner", "member"]);
+/**
+ * The words `ServiceLifecycle`'s codec writes today. The schema accepts any string, so a word a newer
+ * control plane adds is shown as it is rather than failing the page.
+ */
+export const serviceLifecycles = [
+    "NotDeployed",
+    "UpdateInProgress",
+    "Ready",
+    "PartiallyReady",
+    "Unavailable",
+    "Paused",
+    "Failed",
+    "Suspended",
+];
+export const serviceLifecycleSchema = z.string();
+export const authDiscoverySchema = z.object({
+    issuer: z.string(),
+    clientId: z.string(),
+    audience: z.string(),
+});
+export const organizationMembershipSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    role: roleSchema,
+});
+export const whoamiSchema = z.object({
+    subject: z.string(),
+    name: optional(z.string()),
+    email: optional(z.string()),
+    emailVerified: z.boolean().default(false),
+    platformAdmin: z.boolean().default(false),
+    organizations: z.array(organizationMembershipSchema).default([]),
+});
+export const quotaSchema = z.object({
+    projects: optional(z.number().int()),
+    services: optional(z.number().int()),
+    instances: optional(z.number().int()),
+});
+export const usageSchema = z.object({
+    projects: z.number().int(),
+    services: z.number().int(),
+    instances: z.number().int(),
+});
+const zeroUsage = { projects: 0, services: 0, instances: 0 };
+export const organizationDetailSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    disabled: z.boolean().default(false),
+    quota: optional(quotaSchema),
+    usage: usageSchema.default(zeroUsage),
+});
+export const organizationSummarySchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    projects: z.number().int(),
+    disabled: z.boolean().default(false),
+    role: optional(roleSchema),
+    quota: optional(quotaSchema),
+    usage: usageSchema.default(zeroUsage),
+});
+export const registrySummarySchema = z.object({
+    server: z.string(),
+    username: z.string(),
+    setAt: optional(z.string()),
+    setBy: optional(z.string()),
+});
+export const projectDetailSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    organizationId: z.string(),
+    registry: optional(registrySummarySchema),
+});
+export const projectSummarySchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    organizationId: z.string(),
+    services: z.number().int(),
+    registry: optional(registrySummarySchema),
+});
+export const serviceStatusSchema = z.object({
+    name: z.string(),
+    projectId: z.string(),
+    lifecycle: serviceLifecycleSchema,
+    generation: z.number().int(),
+    image: z.string(),
+    readyInstances: z.number().int(),
+    desiredInstances: z.number().int(),
+    detail: optional(z.string()),
+    confirmed: z.boolean().default(true),
+    database: optional(z.string()),
+    hostname: optional(z.string()),
+    exposed: z.boolean().default(false),
+    suspended: z.boolean().default(false),
+    paused: z.boolean().default(false),
+    hosting: z.string().default("embedded"),
+    protocol: optional(z.string()),
+});
+export const historyActorSchema = z.object({
+    subject: z.string(),
+    display: optional(z.string()),
+    administrative: z.boolean().default(false),
+});
+export const historyEntrySchema = z.object({
+    kind: z.string(),
+    generation: z.number().int(),
+    actor: optional(historyActorSchema),
+    at: optional(z.string()),
+});
+export const instanceLogsSchema = z.object({
+    instance: z.string(),
+    output: z.string(),
+    error: optional(z.string()),
+});
+export const logsResponseSchema = z.object({
+    instances: z.array(instanceLogsSchema),
+});
+export const memberSummarySchema = z.object({
+    subject: z.string(),
+    role: roleSchema,
+    email: optional(z.string()),
+    display: optional(z.string()),
+    since: optional(z.string()),
+    addedBy: optional(z.string()),
+});
+export const invitationSummarySchema = z.object({
+    email: z.string(),
+    role: roleSchema,
+    invitedAt: optional(z.string()),
+    invitedBy: optional(z.string()),
+});
+export const membersResponseSchema = z.object({
+    members: z.array(memberSummarySchema).default([]),
+    invitations: z.array(invitationSummarySchema).default([]),
+});
+export const deployTokenSummarySchema = z.object({
+    id: z.string(),
+    label: z.string(),
+    subject: z.string(),
+    createdBy: optional(z.string()),
+    createdAt: optional(z.string()),
+    expiresAt: optional(z.string()),
+    lastUsed: optional(z.string()),
+});
+export const deployTokenCreatedSchema = z.object({
+    id: z.string(),
+    label: z.string(),
+    secret: z.string(),
+    subject: z.string(),
+    expiresAt: optional(z.string()),
+});
+export const errorBodySchema = z.object({
+    status: z.number().int(),
+    error: z.string(),
+});
+// ── Request bodies ──────────────────────────────────────────────────────────
+export const ownerSchema = z.object({
+    subject: z.string(),
+    email: optional(z.string()),
+    display: optional(z.string()),
+});
+export const createOrganizationSchema = z.object({ name: z.string(), owner: optional(ownerSchema) });
+export const createProjectSchema = z.object({ name: z.string(), organizationId: z.string() });
+export const renameSchema = z.object({ name: z.string() });
+export const inviteSchema = z.object({ email: z.string(), role: roleSchema.default("member") });
+export const roleChangeSchema = z.object({ role: roleSchema });
+export const repairSchema = z.object({ role: roleSchema.default("owner") });
+export const createDeployTokenSchema = z.object({
+    label: z.string(),
+    expiresIn: optional(z.number().int()),
+});
+export const setRegistrySchema = z.object({
+    server: z.string(),
+    username: z.string(),
+    password: z.string(),
+});
+/** Every schema by the Scala type's name, as the fixture files name them. */
+export const schemasByType = {
+    AuthDiscovery: authDiscoverySchema,
+    OrganizationMembership: organizationMembershipSchema,
+    Whoami: whoamiSchema,
+    Quota: quotaSchema,
+    Usage: usageSchema,
+    OrganizationDetail: organizationDetailSchema,
+    OrganizationSummary: organizationSummarySchema,
+    RegistrySummary: registrySummarySchema,
+    ProjectDetail: projectDetailSchema,
+    ProjectSummary: projectSummarySchema,
+    ServiceStatus: serviceStatusSchema,
+    HistoryActor: historyActorSchema,
+    HistoryEntry: historyEntrySchema,
+    InstanceLogs: instanceLogsSchema,
+    LogsResponse: logsResponseSchema,
+    MemberSummary: memberSummarySchema,
+    InvitationSummary: invitationSummarySchema,
+    MembersResponse: membersResponseSchema,
+    DeployTokenSummary: deployTokenSummarySchema,
+    DeployTokenCreated: deployTokenCreatedSchema,
+    ErrorBody: errorBodySchema,
+    Owner: ownerSchema,
+    CreateOrganization: createOrganizationSchema,
+    CreateProject: createProjectSchema,
+    Rename: renameSchema,
+    Invite: inviteSchema,
+    RoleChange: roleChangeSchema,
+    Repair: repairSchema,
+    CreateDeployToken: createDeployTokenSchema,
+    SetRegistry: setRegistrySchema,
+};

package/dist/context.d.ts

@@ -0,0 +1,83 @@
+/**
+ * What every package route receives about the request it is serving: a control plane client that
+ * acts as the signed-in person, where the package is mounted, and how to send someone to sign in.
+ */
+import { data, type RouterContextProvider } from "react-router";
+import { ControlPlaneClient } from "./client/control-plane.ts";
+import type { ConsoleRuntime } from "./runtime.ts";
+import type { ConsoleExtensions, Operation } from "./extensions/types.ts";
+export interface Principal {
+    subject: string;
+    name?: string;
+    email?: string;
+    platformAdmin: boolean;
+}
+export interface ConsoleContext {
+    runtime: ConsoleRuntime;
+    request: Request;
+    client: ControlPlaneClient;
+    /** Where a changed session is written; the middleware appends it to whatever response is sent. */
+    headers: Headers;
+    mount: string;
+    extensions: ConsoleExtensions;
+    /** A path under the mount: `href("organizations/acme")`. */
+    href(path?: string): string;
+    signInUrl(returnTo?: string): string;
+    accessToken(): Promise<string | null>;
+    principal(): Promise<Principal | null>;
+    /** The principal if this request has already obtained a token; never causes a call of its own. */
+    knownPrincipal(): Principal | null;
+}
+export declare const consoleContext: import("react-router").RouterContext<ConsoleContext>;
+/** The context the console's middleware put on this request; a clear error if the host did not install it. */
+export declare function useConsoleContext(context: Readonly<RouterContextProvider>): ConsoleContext;
+export declare function principalOf(token: string | null): Principal | null;
+/** Only a path within the console is ever returned to after sign-in; anything else lands on the front page. */
+export declare function safeReturnTo(runtime: ConsoleRuntime, value: string | null | undefined): string;
+export declare function createConsoleContext(runtime: ConsoleRuntime, request: Request): ConsoleContext;
+/** A failure a page shows rather than crashes on, as its error boundary receives it. */
+export type ConsoleFailure = {
+    kind: "lost";
+    reason: string;
+} | {
+    kind: "refused";
+    status: number;
+    reason: string;
+} | {
+    kind: "unavailable";
+    what: "identity provider" | "control plane";
+    reason: string;
+};
+/**
+ * Runs a loader's or action's work, turning what the person should see into responses: sign in
+ * again, access lost, a refusal, something unavailable. Anything else is a bug and propagates.
+ */
+export declare function guard<T>(ctx: ConsoleContext, work: () => Promise<T>): Promise<T>;
+export declare function failureResponse(ctx: ConsoleContext, e: unknown): unknown;
+/** What an action answers when the control plane refused it: shown beside the form, values kept. */
+export interface ActionRefusal {
+    intent: string;
+    status: number;
+    reason: string;
+    problems: string[];
+    values: Record<string, string>;
+}
+/**
+ * Runs an action's work. A refusal the person can act on — a `400`, `403` or `409` — comes back as
+ * data for the page, with the form's values, so the form is shown again with the reason beside it.
+ * Everything else is what `guard` makes of it.
+ */
+export declare function act<T>(ctx: ConsoleContext, intent: string, form: FormData, work: () => Promise<T>): Promise<T | ReturnType<typeof data<ActionRefusal>>>;
+export declare const text: (form: FormData, name: string) => string;
+/** What every package page's loader data carries for the pages and the host's layout. */
+export interface ConsolePageData {
+    mount: string;
+    principal: Principal | null;
+    hidden: Operation[];
+}
+/**
+ * The page data every package page returns. It is also what makes a page require a session: nobody
+ * signed in is `SignInRequired`, which `guard` turns into the trip to sign in, even for a page whose
+ * loader asks the control plane nothing.
+ */
+export declare function pageData(ctx: ConsoleContext): Promise<ConsolePageData>;