ankka-console 0.10.0 → 0.11.0

package/dist/client/schemas.js

@@ -90,6 +90,11 @@ export const projectSummarySchema = z.object({
     services: z.number().int(),
     registry: optional(registrySummarySchema),
 });
+export const mountStatusSchema = z.object({
+    path: z.string(),
+    service: z.string(),
+    state: z.string().default(""),
+});
 export const serviceStatusSchema = z.object({
     name: z.string(),
     projectId: z.string(),
@@ -107,6 +112,19 @@ export const serviceStatusSchema = z.object({
     paused: z.boolean().default(false),
     hosting: z.string().default("embedded"),
     protocol: optional(z.string()),
+    mounts: z.array(mountStatusSchema).default([]),
+    callers: z.array(z.string()).default([]),
+    processPort: optional(z.number().int()),
+    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())),
+    /** 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))),
+    objectStorage: optional(z.string()),
+    bucket: optional(z.string()),
+    bucketAddress: optional(z.string()),
 });
 export const historyActorSchema = z.object({
     subject: z.string(),
@@ -118,7 +136,14 @@ export const historyEntrySchema = z.object({
     generation: z.number().int(),
     actor: optional(historyActorSchema),
     at: optional(z.string()),
+    /** 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 rollback: the generation whose descriptor was applied again. */
+    rolledBackTo: optional(z.number().int()),
 });
+export const rollbackRequestSchema = z.object({ generation: optional(z.number().int()) });
+export const rolledBackSchema = z.object({ rolledBackTo: z.number().int(), status: serviceStatusSchema });
 export const instanceLogsSchema = z.object({
     instance: z.string(),
     output: z.string(),
@@ -127,6 +152,65 @@ export const instanceLogsSchema = z.object({
 export const logsResponseSchema = z.object({
     instances: z.array(instanceLogsSchema),
 });
+// ── Topology ──────────────────────────────────────────────────────────────
+export const topologyHandlerSchema = z.object({
+    name: z.string(),
+    type: z.string(),
+    streaming: optional(z.boolean()),
+});
+export const topologyNodeSchema = z.object({
+    id: z.string(),
+    kind: z.string(),
+    layer: z.number().int(),
+    platform: z.boolean(),
+    handlers: z.array(topologyHandlerSchema),
+});
+export const declaredEdgeSchema = z.object({ from: z.string(), to: z.string(), kind: z.string() });
+export const callPairSchema = z.object({
+    caller: z.string(),
+    callee: z.string(),
+    handled: z.object({ ok: z.number(), refused: z.number(), failed: z.number() }),
+    unanswered: z.object({ timedOut: z.number(), undelivered: z.number() }),
+    durationMillis: z.object({ p50: z.number(), p99: z.number(), max: z.number(), bucketed: z.boolean().default(true) }),
+    streaming: z.boolean().default(false),
+    histogram: z.array(z.number()).default([]),
+});
+export const callEdgeSchema = z.object({ from: z.string(), to: z.string(), pairs: z.array(callPairSchema) });
+export const topologyWindowSchema = z.object({
+    seconds: z.number(),
+    since: z.string(),
+    calls: z.number(),
+    unanswered: z.number().default(0),
+});
+export const instanceTopologyDocumentSchema = z.object({
+    service: z.object({ name: z.string(), runtime: z.string(), instance: z.string(), startedAt: z.string() }),
+    window: topologyWindowSchema,
+    nodes: z.array(topologyNodeSchema),
+    declared: z.array(declaredEdgeSchema),
+    calls: z.array(callEdgeSchema),
+});
+export const instanceStatusSchema = z.enum(["ok", "unreachable", "unsupported", "failed"]);
+export const instanceTopologySchema = z.object({
+    pod: z.string(),
+    status: instanceStatusSchema,
+    problem: optional(z.string()),
+    runtime: optional(z.string()),
+    readAt: optional(z.string()),
+});
+export const topologyDifferenceSchema = z.object({ node: z.string(), presentOn: z.array(z.string()) });
+/** `GET /services/{projectId}/{name}/topology`: every instance's topology, merged. */
+export const serviceTopologySchema = z.object({
+    service: z.string(),
+    running: z.number().int(),
+    contributing: z.number().int(),
+    partial: z.boolean(),
+    instances: z.array(instanceTopologySchema),
+    window: topologyWindowSchema,
+    nodes: z.array(topologyNodeSchema),
+    declared: z.array(declaredEdgeSchema),
+    calls: z.array(callEdgeSchema),
+    differences: z.array(topologyDifferenceSchema),
+});
 export const memberSummarySchema = z.object({
     subject: z.string(),
     role: roleSchema,
@@ -186,6 +270,83 @@ export const setRegistrySchema = z.object({
     username: z.string(),
     password: z.string(),
 });
+/** `PUT /projects/{id}/secrets/{name}`: entries merged into a project secret. */
+export const setProjectSecretSchema = z.object({
+    entries: z.record(z.string(), z.string()),
+});
+/** A contract as declared on a topic: its name and the fingerprint of its schema document. */
+export const contractSchema = z.object({
+    name: z.string(),
+    fingerprint: z.string(),
+});
+/** One side of a declared topic as a running service states it, against the declared contract. */
+export const topicCheckSchema = z.object({
+    topic: optional(z.string()),
+    service: z.string(),
+    component: z.string(),
+    direction: z.string(),
+    stated: optional(z.string()),
+    state: z.string(),
+});
+/**
+ * `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.
+ */
+export const topicDeclarationRequestSchema = z.object({
+    partitions: z.number().int(),
+    compacted: z.boolean().default(false),
+    contract: optional(z.object({ name: z.string(), schema: z.unknown() })),
+});
+/** A topic a project declares, and how far the platform has got with it. */
+export const projectTopicSchema = z.object({
+    name: z.string(),
+    partitions: z.number().int(),
+    phase: optional(z.string()),
+    detail: optional(z.string()),
+    compacted: z.boolean().default(false),
+    contract: optional(contractSchema),
+    checks: z.array(topicCheckSchema).default([]),
+});
+/**
+ * A topic source as a service's instances report it: what reads which topic under which group, the
+ * declared broker and contract it states, `lag` (messages past the last one handled, as of the last
+ * poll) and `failing` (the reason of the change being delivered again, until one succeeds).
+ */
+export const topicSourceReportSchema = z.object({
+    kind: z.string(),
+    component: z.string(),
+    topic: z.string(),
+    group: z.string(),
+    start: z.string(),
+    version: z.number().int(),
+    recordedVersion: optional(z.number().int()),
+    behind: z.boolean().default(false),
+    broker: optional(z.string()),
+    contract: optional(z.string()),
+    lag: optional(z.number().int()),
+    failing: optional(z.string()),
+});
+/** `PUT /projects/{id}/brokers/{name}`: a broker declared beside the installation's, and how it is reached. */
+export const brokerDeclarationRequestSchema = z.object({
+    bootstrap: z.string(),
+    shape: z.string(),
+    secret: z.string(),
+});
+/** A broker a project declares, as listed: where it is, the shape of its credential, and the project secret holding it. */
+export const projectBrokerSchema = z.object({
+    name: z.string(),
+    bootstrap: z.string(),
+    shape: z.string(),
+    secret: z.string(),
+    declaredAt: optional(z.string()),
+});
+/** A project secret as the control plane lists it: entries' names, never a value. */
+export const projectSecretSummarySchema = z.object({
+    name: z.string(),
+    entries: z.array(z.string()),
+    setAt: optional(z.string()),
+    setBy: optional(z.string()),
+});
 /** Every schema by the Scala type's name, as the fixture files name them. */
 export const schemasByType = {
     AuthDiscovery: authDiscoverySchema,
@@ -198,11 +359,17 @@ export const schemasByType = {
     RegistrySummary: registrySummarySchema,
     ProjectDetail: projectDetailSchema,
     ProjectSummary: projectSummarySchema,
+    MountStatus: mountStatusSchema,
     ServiceStatus: serviceStatusSchema,
     HistoryActor: historyActorSchema,
     HistoryEntry: historyEntrySchema,
+    RollbackRequest: rollbackRequestSchema,
+    RolledBack: rolledBackSchema,
     InstanceLogs: instanceLogsSchema,
     LogsResponse: logsResponseSchema,
+    InstanceTopologyDocument: instanceTopologyDocumentSchema,
+    InstanceTopology: instanceTopologySchema,
+    ServiceTopology: serviceTopologySchema,
     MemberSummary: memberSummarySchema,
     InvitationSummary: invitationSummarySchema,
     MembersResponse: membersResponseSchema,
@@ -218,4 +385,11 @@ export const schemasByType = {
     Repair: repairSchema,
     CreateDeployToken: createDeployTokenSchema,
     SetRegistry: setRegistrySchema,
+    SetProjectSecret: setProjectSecretSchema,
+    ProjectSecretSummary: projectSecretSummarySchema,
+    TopicDeclarationRequest: topicDeclarationRequestSchema,
+    ProjectTopic: projectTopicSchema,
+    Contract: contractSchema,
+    BrokerDeclarationRequest: brokerDeclarationRequestSchema,
+    ProjectBroker: projectBrokerSchema,
 };

package/dist/context.d.ts

@@ -69,15 +69,113 @@ 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 type Area = (typeof areas)[number];
+export interface Crumb {
+    label: string;
+    to?: string;
+}
+/** One entry of the shell's listing: a project's service, or an organization's project. */
+export type ListingItem = {
+    kind: "service";
+    key: string;
+    name: string;
+    to: string;
+    lifecycle: string;
+    confirmed: boolean;
+    ready: number;
+    desired: number;
+} | {
+    kind: "project";
+    key: string;
+    name: string;
+    to: string;
+    services: number;
+};
+/**
+ * What the shell around a page shows: the area the rail marks, where the bar says the member is,
+ * the page's primary operation, the organization and project the rail's areas open, and the listing
+ * beside the page. A page with no listing (the front page) leaves it out.
+ */
+export interface ShellData {
+    area?: Area;
+    crumbs: Crumb[];
+    primary?: {
+        label: string;
+        to: string;
+        operation?: Operation;
+    };
+    /** `manages`: the member may manage its members and deploy tokens (an owner, or an administrator). */
+    organization?: {
+        id: string;
+        name: string;
+        manages: boolean;
+    };
+    project?: {
+        id: string;
+        name: string;
+    };
+    listing?: {
+        title: string;
+        label: string;
+        items: ListingItem[];
+        current?: 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[];
+    shell?: ShellData;
 }
+/** The listing of a project's services, in name order, marking the one being read. */
+export declare function servicesListing(project: {
+    id: string;
+    name: string;
+}, services: {
+    name: string;
+    lifecycle: string;
+    confirmed: boolean;
+    readyInstances: number;
+    desiredInstances: number;
+}[], current?: string): NonNullable<ShellData["listing"]>;
+/** The listing of an organization's projects, in name order, marking the one being read. */
+export declare function projectsListing(organization: {
+    id: string;
+    name: string;
+}, projects: {
+    id: string;
+    name: string;
+    organizationId: string;
+    services: number;
+}[], current?: string): NonNullable<ShellData["listing"]>;
 /**
  * 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>;
+/** A page's data with the shell around it; loaders call it once everything the shell names is read. */
+export declare function withShell(page: ConsolePageData, shell: ShellData): ConsolePageData;
+type OrganizationLike = {
+    id: string;
+    name: string;
+    role?: "owner" | "member" | null;
+};
+/** The shell of a page that belongs to an organization: its projects beside the page. */
+export declare function organizationShell(page: ConsolePageData, o: OrganizationLike, projects: {
+    id: string;
+    name: string;
+    organizationId: string;
+    services: number;
+}[], area: Area, tail: Crumb[], primary?: ShellData["primary"]): ConsolePageData;
+/** The shell of a page that belongs to a project: its services beside the page. */
+export declare function projectShell(page: ConsolePageData, o: OrganizationLike, p: {
+    id: string;
+    name: string;
+}, services: Parameters<typeof servicesListing>[1], tail: Crumb[], primary?: ShellData["primary"], current?: string): ConsolePageData;
+/** A service's pages put applying a new descriptor first. */
+export declare function applyPrimary(projectId: string, name: string): NonNullable<ShellData["primary"]>;
+export {};

package/dist/context.js

@@ -143,6 +143,40 @@ export const text = (form, name) => {
     const v = form.get(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"];
+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) {
+    const base = `projects/${encodeURIComponent(project.id)}/services/`;
+    return {
+        title: project.name,
+        label: `Services in ${project.name}`,
+        current,
+        items: [...services].sort(byName).map((s) => ({
+            kind: "service",
+            key: s.name,
+            name: s.name,
+            to: base + encodeURIComponent(s.name),
+            lifecycle: s.lifecycle,
+            confirmed: s.confirmed,
+            ready: s.readyInstances,
+            desired: s.desiredInstances,
+        })),
+    };
+}
+/** The listing of an organization's projects, in name order, marking the one being read. */
+export function projectsListing(organization, projects, current) {
+    return {
+        title: organization.name,
+        label: `Projects in ${organization.name}`,
+        current,
+        items: projects
+            .filter((p) => p.organizationId === organization.id)
+            .sort(byName)
+            .map((p) => ({ kind: "project", key: p.id, name: p.name, to: `projects/${encodeURIComponent(p.id)}`, services: p.services })),
+    };
+}
 /**
  * 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
@@ -154,3 +188,42 @@ export async function pageData(ctx) {
         throw new SignInRequired();
     return { mount: ctx.mount, principal, hidden: ctx.extensions.hidden ?? [] };
 }
+/** A page's data with the shell around it; loaders call it once everything the shell names is read. */
+export function withShell(page, shell) {
+    return { ...page, shell };
+}
+/** The shell of a page that belongs to an organization: its projects beside the page. */
+export function organizationShell(page, o, projects, area, tail, primary) {
+    const orgPath = `organizations/${encodeURIComponent(o.id)}`;
+    return withShell(page, {
+        area,
+        crumbs: [{ label: "Organizations", to: "" }, { label: o.name, to: orgPath }, ...tail],
+        primary,
+        organization: { id: o.id, name: o.name, manages: o.role === "owner" || (page.principal?.platformAdmin ?? false) },
+        listing: projectsListing(o, projects),
+    });
+}
+/** The shell of a page that belongs to a project: its services beside the page. */
+export function projectShell(page, o, p, services, tail, primary, current) {
+    return withShell(page, {
+        area: current === undefined ? "projects" : "services",
+        crumbs: [
+            { label: "Organizations", to: "" },
+            { label: o.name, to: `organizations/${encodeURIComponent(o.id)}` },
+            { label: p.name, to: `projects/${encodeURIComponent(p.id)}` },
+            ...tail,
+        ],
+        primary,
+        organization: { id: o.id, name: o.name, manages: o.role === "owner" || (page.principal?.platformAdmin ?? false) },
+        project: { id: p.id, name: p.name },
+        listing: servicesListing(p, services, current),
+    });
+}
+/** A service's pages put applying a new descriptor first. */
+export function applyPrimary(projectId, name) {
+    return {
+        label: "Apply a new descriptor",
+        to: `projects/${encodeURIComponent(projectId)}/services/apply?name=${encodeURIComponent(name)}`,
+        operation: "service.apply",
+    };
+}

package/dist/extensions/render.d.ts

@@ -14,6 +14,8 @@ export declare function Panels<K extends PanelKind>({ kind, entity, loaded }: {
     entity: PanelEntities[K];
     loaded?: LoadedPanels;
 }): import("react").JSX.Element | null;
+/** Whether the host added anything beside an operation, so a page knows to make room for it. */
+export declare function useHostActions(operation: Operation): boolean;
 export declare function HostActions({ operation, entity }: {
     operation: Operation;
     entity?: unknown;

package/dist/extensions/render.js

@@ -42,6 +42,11 @@ export function Panels({ kind, entity, loaded }) {
             return (_jsxs("section", { className: "ac-panel", "aria-labelledby": `panel-${p.id}`, "data-panel": p.id, children: [_jsx("h2", { id: `panel-${p.id}`, children: p.title }), result && !result.ok ? (_jsxs("p", { className: "ac-panel-failed", children: [p.title, " could not be loaded: ", result.error] })) : (_jsx(PanelBoundary, { title: p.title, children: _jsx(p.Component, { entity: entity, data: result?.ok ? result.data : undefined }) }))] }, p.id));
         }) }));
 }
+/** Whether the host added anything beside an operation, so a page knows to make room for it. */
+export function useHostActions(operation) {
+    const { extensions } = useConsole();
+    return (extensions.actions?.[operation]?.length ?? 0) > 0;
+}
 export function HostActions({ operation, entity }) {
     const { extensions } = useConsole();
     const actions = extensions.actions?.[operation] ?? [];

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", "service.apply", "service.pause", "service.resume", "service.restart", "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", "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 type Operation = (typeof operations)[number];
 export interface PanelEntities {
     organization: OrganizationSummary;

package/dist/extensions/types.js

@@ -19,10 +19,17 @@ export const operations = [
     "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",

package/dist/index.d.ts

@@ -1,5 +1,12 @@
-export { ConsoleProvider, useConsole, ConsoleLink, ConsoleForm } from "./ui/console.tsx";
+export { ConsoleProvider, useConsole, ConsoleLink, ConsoleForm, Breadcrumbs, Field, Submit, OperationForm } from "./ui/console.tsx";
 export type { UseConsole } from "./ui/console.tsx";
-export type { Principal } from "./context.ts";
+export { Shell, Backdrop, Bar, Rail, Listing, Inspector, Page, SectionTitle, SegmentedLinks, ServiceSections } from "./ui/shell.tsx";
+export type { SegmentLink, ServiceSection } from "./ui/shell.tsx";
+export { Shape } from "./ui/shape.tsx";
+export { Lifecycle } from "./ui/status.tsx";
+export { button } from "./ui/primitives/button.ts";
+export { Switch } from "./ui/primitives/switch.tsx";
+export { Select } from "./ui/primitives/select.tsx";
+export type { Area, Crumb, ListingItem, Principal, ShellData } from "./context.ts";
 export { operations } from "./extensions/types.ts";
 export type { Action, ConsoleExtensions, Operation, Panel, PanelKind, PanelLoadContext } from "./extensions/types.ts";

package/dist/index.js

@@ -1,5 +1,11 @@
 // The browser-safe entry point: what a host's layout and its own components use. Everything that
 // runs only on the server — the routes table, the middleware, sessions, the server itself — is
 // `ankka-console/server`, so a host's browser bundle never resolves a Node module.
-export { ConsoleProvider, useConsole, ConsoleLink, ConsoleForm } from "./ui/console.js";
+export { ConsoleProvider, useConsole, ConsoleLink, ConsoleForm, Breadcrumbs, Field, Submit, OperationForm } from "./ui/console.js";
+export { Shell, Backdrop, Bar, Rail, Listing, Inspector, Page, SectionTitle, SegmentedLinks, ServiceSections } from "./ui/shell.js";
+export { Shape } from "./ui/shape.js";
+export { Lifecycle } from "./ui/status.js";
+export { button } from "./ui/primitives/button.js";
+export { Switch } from "./ui/primitives/switch.js";
+export { Select } from "./ui/primitives/select.js";
 export { operations } from "./extensions/types.js";

package/dist/routes/auth.sign-out.js

@@ -5,14 +5,19 @@ import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-run
  * than passing silently through single sign-on. Only a POST signs anyone out.
  */
 import { redirect, useLoaderData } from "react-router";
-import { pageData, useConsoleContext } from "../context.js";
+import { pageData, useConsoleContext, withShell } from "../context.js";
 import { ConsoleErrorBoundary } from "../ui/errors.js";
 import { ConsoleForm, ConsoleLink, Submit } from "../ui/console.js";
+import { Page } from "../ui/shell.js";
+import { button } from "../ui/primitives/button.js";
 export const meta = () => [{ title: "Sign out · ankka" }];
 export async function loader({ request, context }) {
     const ctx = useConsoleContext(context);
     const signedIn = (await ctx.runtime.store.read(request)) !== null;
-    return { console: await pageData(ctx).catch(() => ({ mount: ctx.mount, principal: null, hidden: [] })), signedIn };
+    const page = await pageData(ctx)
+        .then((p) => withShell(p, { area: "organizations", crumbs: [{ label: "Organizations", to: "" }, { label: "Sign out" }] }))
+        .catch(() => ({ mount: ctx.mount, principal: null, hidden: [] }));
+    return { console: page, signedIn };
 }
 export async function action({ request, context }) {
     const ctx = useConsoleContext(context);
@@ -32,6 +37,6 @@ export async function action({ request, context }) {
 }
 export default function SignOut() {
     const { signedIn } = useLoaderData();
-    return (_jsx("section", { className: "ac-page", children: signedIn ? (_jsxs(_Fragment, { children: [_jsx("h1", { children: "Sign out" }), _jsx(ConsoleForm, { to: "auth/sign-out", children: _jsx(Submit, { children: "Sign out" }) })] })) : (_jsxs(_Fragment, { children: [_jsx("h1", { children: "You are signed out" }), _jsx("p", { children: "Your session in this console and in the identity provider has ended." }), _jsx("p", { children: _jsx(ConsoleLink, { to: "auth/sign-in", className: "ac-button", children: "Sign in" }) })] })) }));
+    return (_jsx(Page, { children: signedIn ? (_jsxs(_Fragment, { children: [_jsx("h1", { children: "Sign out" }), _jsxs(ConsoleForm, { to: "auth/sign-out", className: "ac-card", children: [_jsx("p", { children: "Sign out of this console and of the identity provider." }), _jsx("div", { children: _jsx(Submit, { primary: true, children: "Sign out" }) })] })] })) : (_jsxs(_Fragment, { children: [_jsx("h1", { children: "You are signed out" }), _jsx("p", { children: "Your session in this console and in the identity provider has ended." }), _jsx("p", { children: _jsx(ConsoleLink, { to: "auth/sign-in", className: button({ variant: "primary" }), children: "Sign in" }) })] })) }));
 }
 export const ErrorBoundary = ConsoleErrorBoundary;

package/dist/routes/front.js

@@ -4,22 +4,28 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * yours with your role in each, or every one of them for a platform administrator.
  */
 import { useLoaderData } from "react-router";
-import { guard, pageData, useConsoleContext } from "../context.js";
+import { guard, pageData, useConsoleContext, withShell } from "../context.js";
 import { ConsoleErrorBoundary } from "../ui/errors.js";
-import { ConsoleLink, useConsole } from "../ui/console.js";
-import { HostActions } from "../extensions/render.js";
+import { ConsoleLink } from "../ui/console.js";
+import { Page } from "../ui/shell.js";
+import { HostActions, useHostActions } from "../extensions/render.js";
 export const meta = () => [{ title: "Organizations · ankka" }];
 export async function loader({ context }) {
     const ctx = useConsoleContext(context);
     return guard(ctx, async () => {
         const [whoami, organizations] = await Promise.all([ctx.client.whoami(), ctx.client.listOrganizations()]);
-        return { console: await pageData(ctx), whoami, organizations };
+        const shell = {
+            area: "organizations",
+            crumbs: [{ label: "Organizations" }],
+            primary: { label: "Create an organization", to: "organizations/new", operation: "organization.create" },
+        };
+        return { console: withShell(await pageData(ctx), shell), whoami, organizations };
     });
 }
 const roleWords = { owner: "Owner", member: "Member" };
 export default function Front() {
     const { whoami, organizations } = useLoaderData();
-    const { shows } = useConsole();
-    return (_jsxs("section", { className: "ac-page", children: [_jsx("h1", { children: "Organizations" }), _jsxs("p", { className: "ac-lede", children: ["Signed in as ", _jsx("strong", { children: whoami.name ?? whoami.email ?? whoami.subject }), whoami.email && whoami.name ? ` (${whoami.email})` : null, whoami.platformAdmin ? ", a platform administrator: you see every organization in this installation." : "."] }), organizations.length === 0 ? (_jsxs("p", { className: "ac-empty", children: ["You are not a member of any organization yet. Create one, or ask an owner to invite ", whoami.email ?? "you", "."] })) : (_jsx("div", { className: "ac-table-wrap", children: _jsxs("table", { className: "ac-table", children: [_jsx("caption", { className: "ac-visually-hidden", children: "Organizations you can see" }), _jsx("thead", { children: _jsxs("tr", { children: [_jsx("th", { scope: "col", children: "Name" }), _jsx("th", { scope: "col", children: "Id" }), _jsx("th", { scope: "col", children: "Your role" }), _jsx("th", { scope: "col", className: "ac-num", children: "Projects" }), _jsx("th", { scope: "col", children: "State" })] }) }), _jsx("tbody", { children: organizations.map((o) => (_jsxs("tr", { children: [_jsx("td", { children: _jsx(ConsoleLink, { to: `organizations/${encodeURIComponent(o.id)}`, children: o.name }) }), _jsx("td", { children: o.id }), _jsx("td", { children: o.role ? roleWords[o.role] : "Administrator (not a member)" }), _jsx("td", { className: "ac-num", children: o.projects }), _jsx("td", { children: o.disabled ? "Disabled" : "Active" })] }, o.id))) })] }) })), _jsxs("div", { className: "ac-actions", children: [shows("organization.create") ? (_jsx(ConsoleLink, { to: "organizations/new", className: "ac-button", children: "Create an organization" })) : null, _jsx(HostActions, { operation: "organization.create" })] })] }));
+    const hostActions = useHostActions("organization.create");
+    return (_jsxs(Page, { inspector: hostActions ? (_jsx("div", { className: "ac-ops", children: _jsx(HostActions, { operation: "organization.create" }) })) : null, children: [_jsx("h1", { children: "Organizations" }), _jsxs("p", { className: "ac-lede", children: ["Signed in as ", _jsx("strong", { children: whoami.name ?? whoami.email ?? whoami.subject }), whoami.email && whoami.name ? ` (${whoami.email})` : null, whoami.platformAdmin ? ", a platform administrator: you see every organization in this installation." : "."] }), organizations.length === 0 ? (_jsxs("p", { className: "ac-empty", children: ["You are not a member of any organization yet. Create one, or ask an owner to invite ", whoami.email ?? "you", "."] })) : (_jsx("div", { className: "ac-card ac-table-wrap", children: _jsxs("table", { className: "ac-table", children: [_jsx("caption", { className: "ac-visually-hidden", children: "Organizations you can see" }), _jsx("thead", { children: _jsxs("tr", { children: [_jsx("th", { scope: "col", children: "Name" }), _jsx("th", { scope: "col", children: "Id" }), _jsx("th", { scope: "col", children: "Your role" }), _jsx("th", { scope: "col", className: "ac-num", children: "Projects" }), _jsx("th", { scope: "col", children: "State" })] }) }), _jsx("tbody", { children: organizations.map((o) => (_jsxs("tr", { children: [_jsx("td", { children: _jsx(ConsoleLink, { to: `organizations/${encodeURIComponent(o.id)}`, children: o.name }) }), _jsx("td", { children: o.id }), _jsx("td", { children: o.role ? roleWords[o.role] : "Administrator (not a member)" }), _jsx("td", { className: "ac-num", children: o.projects }), _jsx("td", { children: o.disabled ? "Disabled" : "Active" })] }, o.id))) })] }) }))] }));
 }
 export const ErrorBoundary = ConsoleErrorBoundary;

package/dist/routes/logs.d.ts

@@ -20,6 +20,40 @@ export declare function loader({ request, params, context }: LoaderFunctionArgs)
         paused: boolean;
         hosting: string;
         protocol: string | undefined;
+        mounts: {
+            path: string;
+            service: string;
+            state: string;
+        }[];
+        callers: string[];
+        processPort: number | undefined;
+        broker: string | undefined;
+        undeclaredTopics: string[] | undefined;
+        topicChecks: {
+            topic: string | undefined;
+            service: string;
+            component: string;
+            direction: string;
+            stated: string | undefined;
+            state: string;
+        }[] | undefined;
+        topicSources: {
+            kind: string;
+            component: string;
+            topic: string;
+            group: string;
+            start: string;
+            version: number;
+            recordedVersion: number | undefined;
+            behind: boolean;
+            broker: string | undefined;
+            contract: string | undefined;
+            lag: number | undefined;
+            failing: string | undefined;
+        }[] | undefined;
+        objectStorage: string | undefined;
+        bucket: string | undefined;
+        bucketAddress: string | undefined;
     };
     project: {
         id: string;
@@ -58,6 +92,7 @@ export declare function loader({ request, params, context }: LoaderFunctionArgs)
     query: {
         instance: string | undefined;
         previous: boolean;
+        platform: boolean;
         tail: number;
         since: number | undefined;
     };