ankka-console 0.11.0 → 0.12.0

package/dist/client/schemas.js

@@ -44,6 +44,30 @@ export const whoamiSchema = z.object({
     platformAdmin: z.boolean().default(false),
     organizations: z.array(organizationMembershipSchema).default([]),
 });
+/** The installation's cloud: its provider, account and location, and its key for an owner alone. */
+export const cloudInstallationSchema = z.object({
+    provider: z.string(),
+    account: z.string(),
+    location: z.string(),
+    kmsKey: optional(z.string()),
+});
+/** Where the installation keeps its secrets, and how long the record of reads is kept (feature 038). */
+export const installationSecretsSchema = z.object({
+    backend: z.string(),
+    recordRetention: z.string(),
+    auditLog: z.string().default("unknown"),
+});
+/**
+ * `GET /installation`: the platform's version, and its cloud when it names a provider; and its
+ * backups (feature 041); and where it keeps its secrets (feature 038).
+ */
+export const installationSchema = z.object({
+    platformVersion: z.string(),
+    cloud: optional(cloudInstallationSchema),
+    // Lazily: its schema is with the other backup schemas, below.
+    backups: optional(z.lazy(() => installationStatusSchema)),
+    secrets: optional(installationSecretsSchema),
+});
 export const quotaSchema = z.object({
     projects: optional(z.number().int()),
     services: optional(z.number().int()),
@@ -95,6 +119,35 @@ export const mountStatusSchema = z.object({
     service: z.string(),
     state: z.string().default(""),
 });
+/** One name in a move of a service's secrets to Secret Manager, and how the two compare. */
+export const secretMoveNameSchema = z.object({ name: z.string(), state: z.string() });
+/** What a move of a service's secrets did when its instance started; names and states, never a value. */
+export const secretMoveReportSchema = z.object({
+    phase: z.string(),
+    outcome: z.string(),
+    names: z.array(secretMoveNameSchema).default([]),
+    detail: optional(z.string()),
+});
+/** Where a service's instance keeps its secrets, and what a move of them did. */
+export const secretStoreReportSchema = z.object({
+    backend: z.string(),
+    keyRead: z.boolean(),
+    move: optional(secretMoveReportSchema),
+});
+/** A DNS record a member creates at their provider; the platform writes none. */
+export const dnsRecordSchema = z.object({
+    name: z.string(),
+    kind: z.string(),
+    value: z.string(),
+});
+/** One custom hostname of a service: where it stands, and the record that points it at the installation. */
+export const customHostnameSchema = z.object({
+    hostname: z.string(),
+    state: z.string().default("pending"),
+    reason: optional(z.string()),
+    record: optional(dnsRecordSchema),
+    note: optional(z.string()),
+});
 export const serviceStatusSchema = z.object({
     name: z.string(),
     projectId: z.string(),
@@ -118,13 +171,45 @@ export const serviceStatusSchema = z.object({
     broker: optional(z.string()),
     /** Topics the service's components use that its project does not declare; absent when not read. */
     undeclaredTopics: optional(z.array(z.string())),
+    /** Where the service keeps its secrets, and what a move of them did, from its instances; absent when not read. */
+    secretStore: optional(secretStoreReportSchema),
     /** Each side the service takes on a declared topic with a contract, checked against it; absent when not read. */
     topicChecks: optional(z.array(z.lazy(() => topicCheckSchema))),
     /** Each topic source of the service with how far behind it is, from its instances; absent when not read. */
     topicSources: optional(z.array(z.lazy(() => topicSourceReportSchema))),
+    /** What a member should know and need not act on, worked out from the project's declarations now. */
+    warnings: optional(z.array(z.lazy(() => serviceWarningSchema))),
     objectStorage: optional(z.string()),
     bucket: optional(z.string()),
     bucketAddress: optional(z.string()),
+    /** Which store the bucket is in, `garage` or `gcs`, as the operator reported it. */
+    objectStore: optional(z.string()),
+    /** The bucket's location, in Google Cloud Storage. */
+    bucketLocation: optional(z.string()),
+    /** How many days the bucket keeps a deleted object, in Google Cloud Storage. */
+    softDeleteDays: optional(z.number().int()),
+    /** Where a move of the bucket from Garage is, as a phrase; its detail is in `detail`. */
+    storageMove: optional(z.string()),
+    /** The project database cluster the service is on, when a member switched it to a restore. */
+    databaseCluster: optional(z.string()),
+    /** `mounted` when the service's instances read their project's grants (feature 040). */
+    grants: optional(z.string()),
+    /** Each other project's topic the service uses, and whether that project grants it; absent when not read. */
+    crossProjectTopics: optional(z.array(z.lazy(() => crossProjectTopicSchema))),
+    /** Names under domains the project's owner brings, served beside the derived hostname. */
+    customHostnames: z.array(customHostnameSchema).default([]),
+    /** The TXT record that proves the project controls a name it brings; on a read of one service. */
+    proofRecord: optional(dnsRecordSchema),
+});
+/** `POST /services/{project}/{name}/storage/move`: how long the service's writes may be paused. */
+export const storageMoveRequestSchema = z.object({ writePauseBound: optional(z.string()) });
+/** `PUT /projects/{id}/location`. */
+export const setProjectLocationSchema = z.object({ location: z.string() });
+export const crossProjectTopicSchema = z.object({
+    project: z.string(),
+    topic: z.string(),
+    right: z.string(),
+    status: z.string(),
 });
 export const historyActorSchema = z.object({
     subject: z.string(),
@@ -139,8 +224,12 @@ export const historyEntrySchema = z.object({
     /** On an entry that recorded a descriptor: its image, and a digest two such entries share exactly when the descriptors are the same. */
     image: optional(z.string()),
     digest: optional(z.string()),
+    /** On a custom hostname's entry: the name it added or removed. */
+    hostname: optional(z.string()),
     /** On a rollback: the generation whose descriptor was applied again. */
     rolledBackTo: optional(z.number().int()),
+    /** What else the entry says: for a switch, which cluster the service left and which it is on. */
+    detail: optional(z.string()),
 });
 export const rollbackRequestSchema = z.object({ generation: optional(z.number().int()) });
 export const rolledBackSchema = z.object({ rolledBackTo: z.number().int(), status: serviceStatusSchema });
@@ -290,12 +379,37 @@ export const topicCheckSchema = z.object({
 });
 /**
  * `PUT /projects/{id}/topics/{name}`: the partitions a declared topic has, whether the broker keeps
- * only the last message under each key, and the contract it carries with its schema document.
+ * only the last message under each key, and the contract it carries with its schema document; and
+ * how long it keeps, how it is cleaned and how many copies it has, each in the words a member types.
+ * A new topic needs its partitions and takes every setting left out from the installation; a topic
+ * already declared keeps what is left out. `removes` restates what a change that removes messages
+ * removes, in the control plane's own words.
  */
 export const topicDeclarationRequestSchema = z.object({
-    partitions: z.number().int(),
+    partitions: optional(z.number().int()),
     compacted: z.boolean().default(false),
     contract: optional(z.object({ name: z.string(), schema: z.unknown() })),
+    retention: optional(z.string()),
+    retentionSize: optional(z.string()),
+    cleanup: optional(z.string()),
+    tombstoneWindow: optional(z.string()),
+    minCompactionLag: optional(z.string()),
+    maxCompactionLag: optional(z.string()),
+    copies: optional(z.number().int()),
+    minInSync: optional(z.number().int()),
+    removes: optional(z.string()),
+});
+/** A declared topic's every setting in words, and the ones the installation supplied. */
+export const topicSettingsViewSchema = z.object({
+    retention: z.string(),
+    retentionSize: z.string(),
+    cleanup: z.string(),
+    tombstoneWindow: z.string(),
+    minCompactionLag: z.string(),
+    maxCompactionLag: z.string(),
+    copies: optional(z.number().int()),
+    minInSync: optional(z.number().int()),
+    defaulted: z.array(z.string()).default([]),
 });
 /** A topic a project declares, and how far the platform has got with it. */
 export const projectTopicSchema = z.object({
@@ -306,6 +420,37 @@ export const projectTopicSchema = z.object({
     compacted: z.boolean().default(false),
     contract: optional(contractSchema),
     checks: z.array(topicCheckSchema).default([]),
+    settings: optional(topicSettingsViewSchema),
+    /** How many copies the broker holds, as the operator last saw. */
+    copiesHeld: optional(z.number().int()),
+    /** How many broker nodes the installation's broker has. */
+    brokerNodes: optional(z.number().int()),
+});
+/** One setting a declaration changed, from what to what. */
+export const settingChangeSchema = z.object({
+    setting: z.string(),
+    from: z.string(),
+    to: z.string(),
+});
+/** Where a partition begins on the broker, and when that message was published. */
+export const partitionGapReportSchema = z.object({
+    partition: z.number().int(),
+    beginning: z.number().int(),
+    earliestRetained: optional(z.string()),
+});
+/** What a topic source's topic no longer holds, per partition, and whether earlier messages are gone. */
+export const retentionGapReportSchema = z.object({
+    partitions: z.array(partitionGapReportSchema),
+    compacted: z.boolean().default(false),
+    gone: z.boolean().default(false),
+    readAt: optional(z.string()),
+});
+/** Something about a service a member should know: a view over a topic that keeps too little. */
+export const serviceWarningSchema = z.object({
+    kind: z.string(),
+    component: z.string(),
+    topic: z.string(),
+    message: z.string(),
 });
 /**
  * A topic source as a service's instances report it: what reads which topic under which group, the
@@ -325,6 +470,8 @@ export const topicSourceReportSchema = z.object({
     contract: optional(z.string()),
     lag: optional(z.number().int()),
     failing: optional(z.string()),
+    /** What the broker still holds of the topic, per partition. */
+    gap: optional(retentionGapReportSchema),
 });
 /** `PUT /projects/{id}/brokers/{name}`: a broker declared beside the installation's, and how it is reached. */
 export const brokerDeclarationRequestSchema = z.object({
@@ -347,11 +494,262 @@ export const projectSecretSummarySchema = z.object({
     setAt: optional(z.string()),
     setBy: optional(z.string()),
 });
+/** The record of one read, keep or removal of a service secret: never its value. */
+export const readRecordSchema = z.object({
+    at: z.string(),
+    project: z.string(),
+    service: z.string(),
+    hosting: z.string(),
+    name: z.string(),
+    operation: z.string(),
+    outcome: z.string(),
+    backend: z.string(),
+    traceId: optional(z.string()),
+    spanId: optional(z.string()),
+    component: optional(z.string()),
+    componentKind: optional(z.string()),
+    latestSkipped: z.boolean().default(false),
+});
+/** The record of a project's secret reads, newest first, as an owner reads it. */
+export const secretReadsPageSchema = z.object({ records: z.array(readRecordSchema).default([]) });
+// ── Backups and recovery (feature 041) ──────────────────────────────────────
+/** One line of history's backups: `phase` is `backing up`, `failing` or `not backed up`. */
+export const backupLineSchema = z.object({
+    line: z.string(),
+    cluster: z.string(),
+    phase: z.string(),
+    lastBaseBackup: optional(z.string()),
+    firstRestorable: optional(z.string()),
+    lastRestorable: optional(z.string()),
+    archiveLagSeconds: optional(z.number()),
+    failing: optional(z.string()),
+    copiedAt: optional(z.string()),
+});
+export const projectDatabaseSchema = z.object({
+    cluster: z.string(),
+    instances: z.number().int(),
+    readyInstances: z.number().int(),
+    primary: optional(z.string()),
+    synchronous: z.boolean().default(false),
+    writesWaitingOn: optional(z.string()),
+});
+/** One of the project's database clusters: `live`, a `restore`, or `left` once every service has left it. */
+export const projectClusterSchema = z.object({
+    name: z.string(),
+    line: z.string(),
+    phase: z.string(),
+    services: z.array(z.string()).default([]),
+    since: optional(z.string()),
+    leftAt: optional(z.string()),
+});
+/** What one service's database holds in a restore or a rehearsal; secrets by name only. */
+export const serviceVerificationSchema = z.object({
+    name: z.string(),
+    present: z.boolean(),
+    journalRows: z.number().int().default(0),
+    stateRows: z.number().int().default(0),
+    offsetRows: z.number().int().default(0),
+    timerRows: z.number().int().default(0),
+    highestSequence: z.number().int().default(0),
+    changedSecrets: z.array(z.string()).default([]),
+});
+/** A topic past a restore's moment: messages newer than it, and how many of them a group has read. */
+export const topicDivergenceSchema = z.object({
+    topic: z.string(),
+    group: optional(z.string()),
+    after: z.number().int().default(0),
+    read: optional(z.number().int()),
+    services: z.array(z.string()).default([]),
+});
+/** A restore: `Restoring`, `Verified`, `Failed` or `InUse`, with what each service's database holds. */
+export const restoreViewSchema = z.object({
+    name: z.string(),
+    line: z.string(),
+    moment: z.string(),
+    phase: z.string(),
+    requestedBy: optional(z.string()),
+    requestedAt: optional(z.string()),
+    reachedAt: optional(z.string()),
+    services: z.array(serviceVerificationSchema).default([]),
+    detail: optional(z.string()),
+    broker: z.array(topicDivergenceSchema).default([]),
+    notAsked: z.array(z.string()).default([]),
+    note: optional(z.string()),
+});
+/** A rehearsal: `Running`, `Completed`, `Failed` or `NotRemoved`, and how long it took. */
+export const rehearsalViewSchema = z.object({
+    name: z.string(),
+    line: z.string(),
+    moment: z.string(),
+    outcome: z.string(),
+    requestedBy: optional(z.string()),
+    requestedAt: optional(z.string()),
+    elapsedSeconds: optional(z.number().int()),
+    detail: optional(z.string()),
+    services: z.array(serviceVerificationSchema).default([]),
+});
+export const projectStatusSchema = z.object({
+    id: z.string(),
+    backedUp: z.boolean(),
+    target: z.string(),
+    lines: z.array(backupLineSchema).default([]),
+    database: optional(projectDatabaseSchema),
+    detail: optional(z.string()),
+    clusters: z.array(projectClusterSchema).default([]),
+    restores: z.array(restoreViewSchema).default([]),
+    rehearsal: optional(rehearsalViewSchema),
+});
+export const secondaryStoreSchema = z.object({
+    lastCompleted: optional(z.string()),
+    lastFailed: optional(z.string()),
+    failure: optional(z.string()),
+    buckets: optional(z.number().int()),
+    deletedObjects: optional(z.number().int()),
+});
+export const installationStatusSchema = z.object({
+    backupTarget: z.string(),
+    retentionDays: z.number().int(),
+    copyRequired: z.boolean(),
+    sharesFailureDomain: z.boolean(),
+    encryption: z.string(),
+    controlPlane: optional(backupLineSchema),
+    notBackedUp: optional(z.string()),
+    secondaryStore: optional(secondaryStoreSchema),
+});
+export const serviceDifferenceSchema = z.object({
+    project: z.string(),
+    service: z.string(),
+    recordedGeneration: optional(z.number().int()),
+    clusterGeneration: optional(z.number().int()),
+    recordedImage: optional(z.string()),
+    clusterImage: optional(z.string()),
+});
+/** Whether the control plane is held after its own database was restored, and what differs. */
+export const restoreHoldStatusSchema = z.object({
+    held: z.boolean(),
+    restoredAt: optional(z.string()),
+    targetTime: optional(z.string()),
+    releasedAt: optional(z.string()),
+    releasedBy: optional(z.string()),
+    services: z.array(serviceDifferenceSchema).default([]),
+    topics: z.array(z.string()).default([]),
+    unknownProjects: z.array(z.string()).default([]),
+    reconciled: z.array(z.string()).default([]),
+});
+/** `POST /projects/{id}/restores`: the moment, and the line when services are on more than one. */
+export const restoreRequestSchema = z.object({ moment: z.string(), line: optional(z.string()) });
+/** `POST /services/{p}/{n}/switch`: the cluster to move the service to. */
+export const switchRequestSchema = z.object({ cluster: z.string() });
+/** `POST /projects/{id}/rehearsals`: both may be left out, for the latest restorable moment. */
+export const rehearsalRequestSchema = z.object({ moment: optional(z.string()), line: optional(z.string()) });
+export const credentialReissuedSchema = z.object({ project: z.string(), generation: z.number().int() });
+/** What a project asks of its database, whole. */
+export const databaseSettingSchema = z.object({
+    replicas: z.number().int().default(0),
+    synchronous: z.boolean().default(false),
+    retentionDays: optional(z.number().int()),
+    rehearse: optional(z.string()),
+});
+/**
+ * Who did what to a project: to its database, or to the topic `topic` names, with each setting it
+ * changed (feature 043).
+ */
+export const projectHistoryViewSchema = z.object({
+    kind: z.string(),
+    by: optional(z.string()),
+    at: optional(z.string()),
+    detail: optional(z.string()),
+    topic: optional(z.string()),
+    changes: z.array(settingChangeSchema).default([]),
+});
+// ── Grants and machines (feature 040) ───────────────────────────────────────
+/** What a grant opens: one route, one gRPC method, one topic with one right, or the erasure. */
+export const grantTargetSchema = z.object({
+    kind: z.string(),
+    service: optional(z.string()),
+    method: optional(z.string()),
+    path: optional(z.string()),
+    topic: optional(z.string()),
+    right: optional(z.string()),
+    decrypt: z.boolean().default(false),
+});
+/** Who did something to a grant, and when. */
+export const grantActSchema = z.object({
+    by: optional(z.string()),
+    at: optional(z.string()),
+});
+export const grantRequestSchema = z.object({
+    grantee: z.string(),
+    target: grantTargetSchema,
+});
+/** A grant as its project lists it; `effect` is `in effect`, or why not. */
+export const grantDetailSchema = z.object({
+    id: z.string(),
+    grantee: z.string(),
+    target: grantTargetSchema,
+    state: z.string(),
+    effect: z.string(),
+    granted: grantActSchema,
+    answered: optional(grantActSchema),
+    ended: optional(grantActSchema),
+});
+export const grantChangeRecordSchema = z.object({
+    change: z.string(),
+    by: optional(z.string()),
+    at: optional(z.string()),
+});
+export const topicSettingsSchema = z.object({
+    partitions: z.number().int(),
+    compacted: z.boolean().default(false),
+    retention: optional(z.string()),
+    copies: optional(z.number().int()),
+});
+/** A grant as its grantee's side records it. */
+export const receivedGrantDetailSchema = z.object({
+    id: z.string(),
+    grantingProject: z.string(),
+    grantingOrganization: z.string(),
+    grantee: z.string(),
+    target: grantTargetSchema,
+    state: z.string(),
+    changes: z.array(grantChangeRecordSchema).default([]),
+    topic: optional(topicSettingsSchema),
+});
+export const machineRegistrationSchema = z.object({ name: z.string() });
+/** A machine just registered: its secret, shown this once. */
+export const machineRegisteredSchema = z.object({
+    name: z.string(),
+    clientId: z.string(),
+    clientSecret: z.string(),
+    tokenUrl: z.string(),
+    brokerBootstrap: optional(z.string()),
+});
+export const byteRatesRequestSchema = z.object({
+    produceBytesPerSecond: z.number().int(),
+    consumeBytesPerSecond: z.number().int(),
+    requestPercentage: z.number().int(),
+});
+export const machineSummarySchema = z.object({
+    name: z.string(),
+    clientId: z.string(),
+    registeredBy: optional(z.string()),
+    registeredAt: optional(z.string()),
+    byteRates: optional(byteRatesRequestSchema),
+});
+export const tokenResponseSchema = z.object({
+    access_token: z.string(),
+    token_type: z.string(),
+    expires_in: z.number().int(),
+});
+export const jsonWebKeySetSchema = z.object({
+    keys: z.array(z.object({ kty: z.string(), use: z.string(), alg: z.string(), kid: z.string(), n: z.string(), e: 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,
+    Installation: installationSchema,
     Quota: quotaSchema,
     Usage: usageSchema,
     OrganizationDetail: organizationDetailSchema,
@@ -364,6 +762,8 @@ export const schemasByType = {
     HistoryActor: historyActorSchema,
     HistoryEntry: historyEntrySchema,
     RollbackRequest: rollbackRequestSchema,
+    StorageMoveRequest: storageMoveRequestSchema,
+    SetProjectLocation: setProjectLocationSchema,
     RolledBack: rolledBackSchema,
     InstanceLogs: instanceLogsSchema,
     LogsResponse: logsResponseSchema,
@@ -392,4 +792,25 @@ export const schemasByType = {
     Contract: contractSchema,
     BrokerDeclarationRequest: brokerDeclarationRequestSchema,
     ProjectBroker: projectBrokerSchema,
+    SecretReadsPage: secretReadsPageSchema,
+    ProjectStatus: projectStatusSchema,
+    InstallationStatus: installationStatusSchema,
+    RestoreRequest: restoreRequestSchema,
+    RestoreView: restoreViewSchema,
+    SwitchRequest: switchRequestSchema,
+    ProjectHistoryView: projectHistoryViewSchema,
+    DatabaseSetting: databaseSettingSchema,
+    RehearsalRequest: rehearsalRequestSchema,
+    RehearsalView: rehearsalViewSchema,
+    RestoreHoldStatus: restoreHoldStatusSchema,
+    CredentialReissued: credentialReissuedSchema,
+    GrantRequest: grantRequestSchema,
+    GrantDetail: grantDetailSchema,
+    ReceivedGrantDetail: receivedGrantDetailSchema,
+    MachineRegistration: machineRegistrationSchema,
+    MachineRegistered: machineRegisteredSchema,
+    MachineSummary: machineSummarySchema,
+    ByteRatesRequest: byteRatesRequestSchema,
+    TokenResponse: tokenResponseSchema,
+    JsonWebKeySet: jsonWebKeySetSchema,
 };

package/dist/context.d.ts

@@ -70,7 +70,7 @@ export interface ActionRefusal {
 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;
 /** The rail's areas, in the order it shows them. */
-export declare const areas: readonly ["organizations", "projects", "services", "members", "tokens"];
+export declare const areas: readonly ["organizations", "projects", "services", "members", "tokens", "machines"];
 export type Area = (typeof areas)[number];
 export interface Crumb {
     label: string;

package/dist/context.js

@@ -144,7 +144,7 @@ export const text = (form, name) => {
     return typeof v === "string" ? v.trim() : "";
 };
 /** The rail's areas, in the order it shows them. */
-export const areas = ["organizations", "projects", "services", "members", "tokens"];
+export const areas = ["organizations", "projects", "services", "members", "tokens", "machines"];
 const byName = (a, b) => a.name.localeCompare(b.name);
 /** The listing of a project's services, in name order, marking the one being read. */
 export function servicesListing(project, services, current) {

package/dist/extensions/types.d.ts

@@ -1,7 +1,7 @@
 import type { ComponentType } from "react";
 import type { OrganizationSummary, ProjectDetail, ServiceStatus } from "../client/schemas.ts";
 /** Every operation the console offers, by the name a host uses to add beside it or hide it. */
-export declare const operations: readonly ["organization.create", "organization.rename", "organization.delete", "organization.disable", "organization.enable", "organization.quota.set", "organization.quota.clear", "member.invite", "member.role", "member.remove", "invitation.withdraw", "member.repair", "token.create", "token.revoke", "project.create", "project.rename", "project.delete", "registry.set", "registry.clear", "project-secret.set", "project-secret.unset", "project-topic.set", "project-topic.unset", "project-broker.set", "project-broker.unset", "service.apply", "service.pause", "service.resume", "service.restart", "service.rollback", "service.expose", "service.unexpose", "service.delete", "service.logs"];
+export declare const operations: readonly ["organization.create", "organization.rename", "organization.delete", "organization.disable", "organization.enable", "organization.quota.set", "organization.quota.clear", "member.invite", "member.role", "member.remove", "invitation.withdraw", "member.repair", "token.create", "token.revoke", "machine.register", "machine.delete", "machine.byte-rates", "project.create", "project.rename", "project.delete", "registry.set", "registry.clear", "project-secret.set", "project-secret.unset", "project-topic.set", "project-topic.unset", "project-broker.set", "project-broker.unset", "project.restore", "project.rehearse", "project.database", "project.backup-credential", "installation.release", "service.switch", "grant.make", "grant.end", "grant.answer", "grant.relinquish", "service.apply", "service.pause", "service.resume", "service.restart", "service.rollback", "service.expose", "service.unexpose", "service-hostname.add", "service-hostname.remove", "service.delete", "service.logs", "service.storage-credential", "service.storage-move", "service.storage-settings", "project-location.set", "project-location.clear"];
 export type Operation = (typeof operations)[number];
 export interface PanelEntities {
     organization: OrganizationSummary;

package/dist/extensions/types.js

@@ -14,6 +14,9 @@ export const operations = [
     "member.repair",
     "token.create",
     "token.revoke",
+    "machine.register",
+    "machine.delete",
+    "machine.byte-rates",
     "project.create",
     "project.rename",
     "project.delete",
@@ -25,6 +28,18 @@ export const operations = [
     "project-topic.unset",
     "project-broker.set",
     "project-broker.unset",
+    "project.restore",
+    "project.rehearse",
+    "project.database",
+    "project.backup-credential",
+    "installation.release",
+    "service.switch",
+    "grant.make",
+    "grant.end",
+    // An owner of the grantee's side accepting or declining a pending grant, and giving one up: the
+    // organization page's "Offered grants" card.
+    "grant.answer",
+    "grant.relinquish",
     "service.apply",
     "service.pause",
     "service.resume",
@@ -32,6 +47,13 @@ export const operations = [
     "service.rollback",
     "service.expose",
     "service.unexpose",
+    "service-hostname.add",
+    "service-hostname.remove",
     "service.delete",
     "service.logs",
+    "service.storage-credential",
+    "service.storage-move",
+    "service.storage-settings",
+    "project-location.set",
+    "project-location.clear",
 ];

package/dist/routes/front.d.ts

@@ -1,8 +1,9 @@
 /**
  * The front page: who you are, as the control plane sees you, and the organizations you can see —
- * yours with your role in each, or every one of them for a platform administrator.
+ * yours with your role in each, or every one of them for a platform administrator — and what the
+ * installation is: its version, and its cloud when it names one (feature 044).
  */
-import { type LoaderFunctionArgs, type MetaFunction } from "react-router";
+import { type ActionFunctionArgs, type LoaderFunctionArgs, type MetaFunction } from "react-router";
 import { ConsoleErrorBoundary } from "../ui/errors.tsx";
 export declare const meta: MetaFunction;
 export declare function loader({ context }: LoaderFunctionArgs): Promise<{
@@ -36,6 +37,65 @@ export declare function loader({ context }: LoaderFunctionArgs): Promise<{
             instances: number;
         };
     }[];
+    installation: {
+        platformVersion: string;
+        cloud: {
+            provider: string;
+            account: string;
+            location: string;
+            kmsKey: string | undefined;
+        } | undefined;
+        backups: {
+            backupTarget: string;
+            retentionDays: number;
+            copyRequired: boolean;
+            sharesFailureDomain: boolean;
+            encryption: string;
+            controlPlane: {
+                line: string;
+                cluster: string;
+                phase: string;
+                lastBaseBackup: string | undefined;
+                firstRestorable: string | undefined;
+                lastRestorable: string | undefined;
+                archiveLagSeconds: number | undefined;
+                failing: string | undefined;
+                copiedAt: string | undefined;
+            } | undefined;
+            notBackedUp: string | undefined;
+            secondaryStore: {
+                lastCompleted: string | undefined;
+                lastFailed: string | undefined;
+                failure: string | undefined;
+                buckets: number | undefined;
+                deletedObjects: number | undefined;
+            } | undefined;
+        } | undefined;
+        secrets: {
+            backend: string;
+            recordRetention: string;
+            auditLog: string;
+        } | undefined;
+    };
+    hold: {
+        held: boolean;
+        restoredAt: string | undefined;
+        targetTime: string | undefined;
+        releasedAt: string | undefined;
+        releasedBy: string | undefined;
+        services: {
+            project: string;
+            service: string;
+            recordedGeneration: number | undefined;
+            clusterGeneration: number | undefined;
+            recordedImage: string | undefined;
+            clusterImage: string | undefined;
+        }[];
+        topics: string[];
+        unknownProjects: string[];
+        reconciled: string[];
+    } | undefined;
 }>;
+export declare function action({ request, context }: ActionFunctionArgs): Promise<import("react-router").UNSAFE_DataWithResponseInit<import("../context.ts").ActionRefusal> | Response>;
 export default function Front(): import("react").JSX.Element;
 export declare const ErrorBoundary: typeof ConsoleErrorBoundary;