@ornncompute/cli 1.0.35 → 1.0.62

package/vendor/capabilities/capabilities/native-listing.js

@@ -0,0 +1,63 @@
+import { z } from "zod";
+import { flag } from "./market-shared.js";
+export const nativeTermFields = {
+    type: z.enum(["reserved", "spot", "on-demand"]).nullable().optional(),
+    minDurationHours: z.coerce.number().nonnegative(),
+    maxDurationHours: z.coerce.number().nonnegative(),
+    pricePerGpuHourMicroUsd: z.coerce.number().int().positive(),
+    downPaymentCents: z.coerce.number().int().nonnegative().nullable().optional(),
+    renewable: flag,
+};
+export const nativeTermInput = z.object(nativeTermFields).strict();
+export const nativeTermsInput = z.preprocess((value) => {
+    if (typeof value !== "string")
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}, z.array(nativeTermInput));
+export const listingWriteControls = {
+    confirm: z.boolean().optional(),
+    idempotencyKey: z.string().min(1).max(200),
+};
+export const nativeListingCreateInput = z
+    .object({
+    organizationId: z.string().uuid().nullable().optional(),
+    kind: z.enum(["primary", "secondary"]).default("primary"),
+    gpuSlug: z.string().min(1),
+    gpusPerNode: z.coerce.number().int().positive(),
+    capacityNodeCount: z.coerce.number().int().positive(),
+    facilityId: z.string().uuid(),
+    provisioningType: z.enum(["bare-metal", "virtual-machine"]),
+    state: z.enum(["draft", "available"]),
+    availableAt: z.iso.datetime({ offset: true }).nullable().optional(),
+    availableUntil: z.iso.datetime({ offset: true }).nullable().optional(),
+    daysToRfs: z.coerce.number().int().nonnegative().optional(),
+    cpu: z.string().optional(),
+    ram: z.string().optional(),
+    storage: z.string().optional(),
+    fabricType: z.string().optional(),
+    internet: z.string().optional(),
+    terms: nativeTermsInput,
+    ...listingWriteControls,
+})
+    .strict();
+export const nativeListingUpdateFields = {
+    state: z.enum(["draft", "available", "delisted"]).optional(),
+    nodeCount: z.coerce.number().int().positive().optional(),
+    gpuSlug: z.string().min(1).optional(),
+    gpusPerNode: z.coerce.number().int().positive().optional(),
+    facilityId: z.string().uuid().optional(),
+    provisioningType: z.enum(["bare-metal", "virtual-machine"]).optional(),
+    availableAt: z.iso.datetime({ offset: true }).optional(),
+    availableUntil: z.iso.datetime({ offset: true }).nullable().optional(),
+    daysToRfs: z.coerce.number().int().nonnegative().optional(),
+    cpu: z.string().optional(),
+    ram: z.string().optional(),
+    storage: z.string().optional(),
+    fabricType: z.string().optional(),
+    internet: z.string().optional(),
+};

package/vendor/capabilities/capabilities/organization-invites.js

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import { defineCapability } from "../capability.js";
+export const organizationInviteInput = z.object({
+    organization_id: z.uuid(),
+    email: z.string().trim().toLowerCase().pipe(z.email()),
+});
+export const organizationInviteCapability = defineCapability({
+    id: "organization.invite",
+    domain: "users",
+    roles: ["admin"],
+    description: "Email an invitation to an existing organization. Resolve its UUID with organization_list first; ask the operator to choose if matches are ambiguous. The recipient may already belong to another organization. Send directly when the admin requests the invitation.",
+    mutation: "immediate",
+    http: { method: "POST", path: "/v1/staff/invites" },
+    cli: {
+        command: ["admin", "organizations", "invite"],
+        vnext: {
+            audience: "admin",
+            category: "resource",
+            command: ["admin", "organizations", "invite"],
+            outcome: "Email an invitation to an existing organization.",
+            human: "ornn admin organizations invite --organization UUID --email EMAIL",
+            automation: "ornn admin organizations invite --organization UUID --email EMAIL --format json",
+            acceptedReferences: ["organization UUID from admin organizations list"],
+            related: ["admin organizations list"],
+        },
+    },
+    slack: {
+        parameters: {
+            type: "object",
+            properties: {
+                organization_id: {
+                    type: "string",
+                    format: "uuid",
+                    description: "Exact organization UUID from organization_list.",
+                },
+                email: {
+                    type: "string",
+                    format: "email",
+                    description: "Address to receive the invitation.",
+                },
+            },
+            required: ["organization_id", "email"],
+        },
+    },
+    input: organizationInviteInput,
+    execute: async (ctx, input) => {
+        const parsed = organizationInviteInput.parse(input);
+        return ctx.fetch("/v1/staff/invites", {
+            method: "POST",
+            body: { ...parsed, send_email: true },
+        });
+    },
+});

package/vendor/capabilities/capabilities/reservation-list.js

@@ -0,0 +1,68 @@
+import { z } from "zod";
+import { defineCapability } from "../capability.js";
+import { queryString } from "./staff-shared.js";
+export const reservationListInput = z.object({
+    customerId: z.string().uuid().optional(),
+    listingId: z.string().uuid().optional(),
+    listingTermId: z.string().uuid().optional(),
+    status: z.enum(["confirmed", "active", "completed", "cancelled"]).optional(),
+    cursor: z.string().optional(),
+    limit: z.number().int().min(1).max(100).optional(),
+});
+// Staff on every surface: Slack and the CLI resolve a customer's reservations
+// with this, then nodes.list reservation_id for that reservation's machines.
+export const reservationListCapability = defineCapability({
+    id: "reservation.list",
+    domain: "reservations",
+    roles: ["admin"],
+    description: "Internal staff only: list Commerce reservations across organizations, optionally filtered by customer organization (customerId), listing, listing term, and derived status. Resolve a customer's organization with users.list or organization.list first; pass each reservationId to nodes.list reservation_id for its machines. Page with nextCursor as cursor.",
+    mutation: "read",
+    http: { method: "GET", path: "/commerce/reservations" },
+    cli: {
+        command: ["admin", "reservations", "list"],
+        vnext: {
+            audience: "admin",
+            category: "resource",
+            command: ["admin", "reservations", "list"],
+            outcome: "List reservations across organizations.",
+            human: "ornn admin reservations list [--customer UUID] [--listing UUID] [--listing-term UUID] [--status confirmed|active|completed|cancelled] [--limit 50] [--cursor CURSOR]",
+            automation: "ornn admin reservations list --customer UUID --limit 50 [--cursor CURSOR] --format json",
+            acceptedReferences: [],
+        },
+    },
+    slack: {
+        parameters: {
+            type: "object",
+            properties: {
+                customerId: {
+                    type: "string",
+                    description: "Optional customer organization UUID from users_list or organization_list.",
+                },
+                listingId: { type: "string", description: "Optional listing UUID." },
+                listingTermId: { type: "string", description: "Optional listing term UUID." },
+                status: {
+                    type: "string",
+                    enum: ["confirmed", "active", "completed", "cancelled"],
+                    description: "Optional derived reservation status.",
+                },
+                cursor: {
+                    type: "string",
+                    description: "Optional. Pass the previous response's nextCursor to fetch the next page.",
+                },
+                limit: { type: "integer", description: "Optional page size (Slack returns at most 10)." },
+            },
+        },
+    },
+    input: reservationListInput,
+    execute: async (ctx, input) => {
+        const parsed = reservationListInput.parse(input ?? {});
+        return ctx.fetch(`/commerce/reservations${queryString({
+            customerId: parsed.customerId,
+            listingId: parsed.listingId,
+            status: parsed.status,
+            listingTermId: parsed.listingTermId,
+            cursor: parsed.cursor,
+            limit: parsed.limit,
+        })}`, { method: "GET" });
+    },
+});

package/vendor/capabilities/capabilities/staff-shared.js

@@ -0,0 +1,64 @@
+/** Helpers shared by staff capabilities. */
+/**
+ * Build a request body from the fields that were actually supplied.
+ *
+ * Staff writes are almost all "PATCH the fields the caller named": `undefined`
+ * means leave alone, and `null` is a real value that clears the field. So the
+ * check is `!== undefined`, never truthiness.
+ */
+export function mapBody(input, mapping) {
+    const body = {};
+    for (const [field, wire] of Object.entries(mapping)) {
+        if (input[field] !== undefined)
+            body[wire] = input[field];
+    }
+    return body;
+}
+/** Path segment escape. */
+export function seg(value) {
+    return encodeURIComponent(value);
+}
+/**
+ * A transport failure's HTTP status, when it carries one.
+ *
+ * Capabilities cannot import a surface's error class (`apps/mcp`'s
+ * `WebApiError`, say), so read the status structurally.
+ */
+export function statusOf(error) {
+    if (error && typeof error === "object" && "status" in error) {
+        const status = error.status;
+        if (typeof status === "number")
+            return status;
+    }
+    return undefined;
+}
+/**
+ * Read a resource's current optimistic-concurrency version.
+ *
+ * Commerce rejects a PATCH or lifecycle action whose `version` is absent or
+ * non-positive ("missing version" / "version must be positive"), but no staff
+ * caller has that number to hand. Read it back when it was not supplied, and
+ * only once confirmed so a preview stays a pure dry run.
+ */
+export async function resolveVersion(ctx, path, provided) {
+    if (provided && provided > 0)
+        return provided;
+    if (!ctx.confirmed)
+        return 1;
+    try {
+        const current = (await ctx.fetch(path, { method: "GET" }));
+        if (typeof current?.version === "number" && current.version > 0)
+            return current.version;
+    }
+    catch {
+        // Fall through: send 1 and let commerce report the conflict, which names
+        // the expected version, rather than failing on a lookup the caller can't see.
+    }
+    return 1;
+}
+export function queryString(params) {
+    const parts = Object.entries(params)
+        .filter((entry) => entry[1] !== undefined && entry[1] !== "")
+        .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+    return parts.length > 0 ? `?${parts.join("&")}` : "";
+}

package/vendor/capabilities/capabilities/users.js

@@ -1,49 +1,159 @@
 import { z } from "zod";
 import { defineCapability } from "../capability.js";
-function queryPath(path, params) {
-    const parts = [];
-    for (const [key, value] of Object.entries(params)) {
-        if (value?.trim())
-            parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(value.trim())}`);
+const directoryLimit = z.number().int().min(1).max(100).default(25);
+const directoryOffset = z.number().int().nonnegative().optional();
+export const organizationListInput = z.object({
+    q: z.string().trim().optional().describe("Company name, contact/member name, or email."),
+    role: z.enum(["consumer", "supplier"]).optional(),
+    approved: z.boolean().optional(),
+    ids: z.array(z.uuid()).min(1).max(100).optional(),
+    limit: directoryLimit,
+    offset: directoryOffset,
+});
+export const usersListInput = z.object({
+    q: z.string().trim().optional().describe("Person name, email, or company name."),
+    organization_id: z.uuid().optional(),
+    limit: directoryLimit,
+    offset: directoryOffset,
+});
+function directoryPath(input) {
+    const params = [
+        `limit=${input.limit}`,
+        `offset=${input.offset}`,
+        "sort=name",
+        "direction=asc",
+    ];
+    if (input.q)
+        params.push(`q=${encodeURIComponent(input.q)}`);
+    if (input.role)
+        params.push(`role=${encodeURIComponent(input.role)}`);
+    if (input.approved !== undefined) {
+        params.push(`approved=${input.approved}`);
     }
-    return parts.length ? `${path}?${parts.join("&")}` : path;
+    if (input.ids)
+        params.push(`ids=${encodeURIComponent(input.ids.join(","))}`);
+    return `/v1/organizations?${params.join("&")}`;
+}
+function directoryMembers(organization) {
+    return organization.members ?? [];
+}
+function organizationMatchesQuery(organization, query) {
+    return (organization.name.toLowerCase().includes(query) ||
+        organization.id.toLowerCase() === query ||
+        [
+            organization.company_profile?.company_name,
+            organization.company_profile?.contact_name,
+            organization.company_profile?.contact_email,
+            organization.company_profile?.work_email,
+        ].some((value) => value?.toLowerCase().includes(query)));
 }
-const usersQueryInput = z.object({
-    name: z.string().optional(),
-    email: z.string().optional(),
-    organization: z.string().optional(),
-    q: z.string().optional(),
-    max: z.number().int().positive().max(1000).optional(),
-    limit: z.number().int().positive().max(1000).optional(),
+export const organizationListCapability = defineCapability({
+    id: "organization.list",
+    domain: "users",
+    roles: ["admin"],
+    description: "List organizations from the Authorization directory. Search by company name, contact/member name, or email; filter by role, approval, or UUIDs. Use the organization id as organizationId when recording downtime, and ask the user to choose if matches are ambiguous.",
+    mutation: "read",
+    http: { method: "GET", path: "/v1/organizations" },
+    slack: {
+        parameters: {
+            type: "object",
+            properties: {
+                q: {
+                    type: "string",
+                    description: "Company name, contact/member name, or email.",
+                },
+                role: { type: "string", enum: ["consumer", "supplier"] },
+                approved: { type: "boolean" },
+                ids: {
+                    type: "array",
+                    items: { type: "string", format: "uuid" },
+                    minItems: 1,
+                    maxItems: 100,
+                },
+                limit: { type: "integer", minimum: 1, maximum: 100, default: 25 },
+                offset: { type: "integer", minimum: 0 },
+            },
+        },
+    },
+    input: organizationListInput,
+    execute: async (ctx, input) => {
+        const parsed = organizationListInput.parse(input);
+        const limit = parsed.limit;
+        const offset = parsed.offset ?? 0;
+        const rows = (await ctx.fetch(directoryPath({ ...parsed, limit, offset }), { method: "GET" }));
+        return {
+            organizations: rows.map((organization) => ({
+                id: organization.id,
+                name: organization.name,
+                role: organization.role,
+                approved: organization.approved,
+                members: directoryMembers(organization).map((member) => ({
+                    user_id: member.user_id,
+                    email: member.email,
+                    name: member.name ?? null,
+                })),
+            })),
+            ...(rows.length === limit ? { next_offset: offset + rows.length } : {}),
+        };
+    },
 });
-export const usersQueryCapability = defineCapability({
-    id: "users.query",
+export const usersListCapability = defineCapability({
+    id: "users.list",
     domain: "users",
     roles: ["admin"],
-    description: "Admin-only directory search. Filter by name, email, or organization. Optional max (default 100, cap 1000). Returns matching users and organizations.",
+    description: "List users who belong to an organization, from the Authorization directory. Search by person name, email, or company name; use organization_id to restrict results to one organization.",
     mutation: "read",
-    http: { method: "GET", path: "/internal/users" },
+    http: { method: "GET", path: "/v1/organizations" },
     slack: {
         parameters: {
             type: "object",
             properties: {
-                name: { type: "string" },
-                email: { type: "string" },
-                organization: { type: "string" },
-                max: { type: "integer", description: "Maximum rows to return (1-1000)." },
+                q: { type: "string", description: "Person name, email, or company name." },
+                organization_id: { type: "string", format: "uuid" },
+                limit: {
+                    type: "integer",
+                    minimum: 1,
+                    maximum: 100,
+                    default: 25,
+                    description: "Maximum number of organizations to search.",
+                },
+                offset: { type: "integer", minimum: 0 },
             },
         },
     },
-    input: usersQueryInput,
+    input: usersListInput,
     execute: async (ctx, input) => {
-        const parsed = usersQueryInput.parse(input);
-        const q = [parsed.q, parsed.name, parsed.email, parsed.organization].find((value) => value?.trim());
-        return ctx.fetch(queryPath("/internal/users", {
-            q,
-            email: parsed.email,
-            organization: parsed.organization,
-            limit: String(parsed.max ?? parsed.limit ?? 100),
-        }), { method: "GET" });
+        const parsed = usersListInput.parse(input);
+        const limit = parsed.limit;
+        const offset = parsed.offset ?? 0;
+        const rows = (await ctx.fetch(directoryPath({
+            limit,
+            offset,
+            q: parsed.q,
+            ids: parsed.organization_id ? [parsed.organization_id] : undefined,
+        }), { method: "GET" }));
+        const q = parsed.q?.toLowerCase();
+        const users = rows.flatMap((organization) => {
+            const members = directoryMembers(organization);
+            const matchesOrganization = q ? organizationMatchesQuery(organization, q) : false;
+            return members
+                .filter((member) => !q ||
+                matchesOrganization ||
+                (member.name ?? "").toLowerCase().includes(q) || member.email.toLowerCase().includes(q))
+                .map((member) => ({
+                user_id: member.user_id,
+                email: member.email,
+                name: member.name ?? null,
+                organization_id: organization.id,
+                organization_name: organization.name,
+                organization_role: organization.role,
+                approved: organization.approved,
+            }));
+        });
+        return {
+            users,
+            ...(rows.length === limit ? { next_offset: offset + rows.length } : {}),
+        };
     },
 });
-export const userCapabilities = [usersQueryCapability];
+export const userCapabilities = [organizationListCapability, usersListCapability];

package/vendor/capabilities/cli-catalog.js

@@ -6,6 +6,7 @@ import { adminEnrollmentCapabilities, bindAdminEnrollmentCapabilities, } from ".
 import { adminNodeDiagnosticCapabilities } from "./capabilities/admin-node-diagnostics.js";
 import { adminNodeLifecycleCapabilities } from "./capabilities/admin-nodes-lifecycle.js";
 import { computeCapabilities } from "./capabilities/compute.js";
+import { creditGrantCapability } from "./capabilities/credits.js";
 import { cliShellCapabilities } from "./capabilities/cli.js";
 import { clusterCliCapabilities, kubernetesCapabilities, slurmCapabilities, } from "./capabilities/clusters.js";
 import { externalBucketCapabilities } from "./capabilities/external-buckets.js";
@@ -16,7 +17,9 @@ import { mountCapabilities } from "./capabilities/mounts.js";
 import { identityCapabilities } from "./capabilities/identity.js";
 import { listingCapabilities } from "./capabilities/listings.js";
 import { observabilityCapabilities } from "./capabilities/observability.js";
+import { organizationInviteCapability } from "./capabilities/organization-invites.js";
 import { networkCapabilities } from "./capabilities/networks.js";
+import { reservationListCapability } from "./capabilities/reservation-list.js";
 import { volumeCapabilities } from "./capabilities/volumes.js";
 import { userCapabilities } from "./capabilities/users.js";
 function canonicalCliCatalog(capabilities) {
@@ -41,7 +44,7 @@ export const catalog = [
         ...bindAdminEnrollmentCapabilities(bindAdminCapabilities([
             ...cliShellCapabilities,
             ...identityCapabilities,
-            ...listingCapabilities,
+            ...listingCapabilities.filter((capability) => capability.id !== "listings.create"),
             ...commerceMarketCapabilities,
             ...marketCapabilities,
             ...computeCapabilities,
@@ -60,8 +63,11 @@ export const catalog = [
             ...adminNodeLifecycleCapabilities,
         ])),
         ...adminCapabilities.filter((capability) => capability.id === "nodes.health"),
-        ...adminCapacityReservationCapabilities.filter((capability) => capability.id !== "listings.create"),
+        ...adminCapacityReservationCapabilities,
+        reservationListCapability,
         ...adminNodeDiagnosticCapabilities,
         ...adminEnrollmentCapabilities,
+        organizationInviteCapability,
+        creditGrantCapability,
     ]),
 ];

package/vendor/capabilities/cli-migrations.js

@@ -9,21 +9,25 @@ export const LEGACY_CLI_MIGRATIONS = [
     { legacy: ["catalog", "search"], replacement: "ornn capacity-offers list" },
     { legacy: ["gpu-types"], replacement: "ornn capacity-offers list" },
     { legacy: ["availability", "list"], replacement: "ornn capacity-offers list" },
-    { legacy: ["availability", "forecast"], replacement: "ornn schedules list" },
+    { legacy: ["availability", "forecast"], replacement: "ornn capacity-offers availability" },
     { legacy: ["availability", "show"], replacement: "ornn capacity-offers show" },
     { legacy: ["listing", "list"], replacement: "ornn capacity-offers list" },
-    { legacy: ["listing", "forecast"], replacement: "ornn schedules list" },
+    { legacy: ["listing", "forecast"], replacement: "ornn capacity-offers availability" },
     { legacy: ["listing", "show"], replacement: "ornn capacity-offers show" },
     { legacy: ["listings", "list"], replacement: "ornn capacity-offers list" },
-    { legacy: ["listings", "forecast"], replacement: "ornn schedules list" },
+    { legacy: ["listings", "forecast"], replacement: "ornn capacity-offers availability" },
     { legacy: ["listings", "show"], replacement: "ornn capacity-offers show" },
     { legacy: ["listings", "create"], replacement: "ornn admin capacity-offers create" },
     { legacy: ["buy"], replacement: "ornn offers post" },
-    { legacy: ["bid", "create"], replacement: "ornn spot bid" },
-    { legacy: ["bid", "list"], replacement: "ornn spot orders" },
-    { legacy: ["bid", "show"], replacement: "ornn spot orders" },
-    { legacy: ["bid", "update"], replacement: "ornn spot bid" },
-    { legacy: ["bid", "withdraw"], replacement: "ornn spot cancel" },
+    { legacy: ["schedules", "list"], replacement: "ornn capacity-offers list --kind secondary" },
+    { legacy: ["schedules", "show"], replacement: "ornn capacity-offers availability" },
+    { legacy: ["schedules", "buy"], replacement: "ornn reservations buy" },
+    { legacy: ["schedules"], replacement: "ornn capacity-offers list" },
+    { legacy: ["bid", "create"], replacement: "ornn market bid" },
+    { legacy: ["bid", "list"], replacement: "ornn market orders" },
+    { legacy: ["bid", "show"], replacement: "ornn market orders" },
+    { legacy: ["bid", "update"], replacement: "ornn market bid" },
+    { legacy: ["bid", "withdraw"], replacement: "ornn market cancel" },
     {
         legacy: ["exchange", "create"],
         replacement: "ornn capacity-offers list (use the Ornn web app for commercial workflows)",
@@ -231,7 +235,6 @@ export const LEGACY_CLI_MIGRATIONS = [
     { legacy: ["tokens", "list"], replacement: "ornn admin enrollment-tokens list" },
     { legacy: ["tokens", "create"], replacement: "ornn admin enrollment-tokens create" },
     { legacy: ["tokens", "revoke"], replacement: "ornn admin enrollment-tokens revoke" },
-    { legacy: ["users", "query"], replacement: "ornn admin users search" },
     { legacy: ["node", "enroll"], replacement: "ornn admin nodes enroll" },
     { legacy: ["node", "list"], replacement: "ornn admin nodes list" },
     { legacy: ["node", "health"], replacement: "ornn admin nodes health" },
@@ -247,7 +250,7 @@ export const LEGACY_CLI_MIGRATIONS = [
     { legacy: ["operators"], replacement: "ornn admin suppliers list" },
     { legacy: ["facilities"], replacement: "ornn admin facilities list" },
     { legacy: ["tokens"], replacement: "ornn admin enrollment-tokens list" },
-    { legacy: ["users"], replacement: "ornn admin users search" },
+    { legacy: ["users"], replacement: "ornn admin users list" },
     { legacy: ["node"], replacement: "ornn admin nodes list" },
     { legacy: ["cache", "purge"], replacement: "ornn resources" },
     { legacy: ["api"], replacement: "ornn resources" },

package/vendor/capabilities/software-catalog.js

@@ -1,6 +1,8 @@
 /** Live orchestrator software dictionary: `GET /v1/orchestrator/catalog/software`. */
 export const SOFTWARE_CATALOG_PATH = "/v1/orchestrator/catalog/software";
-export const SOFTWARE_KINDS = ["python", "package", "cuda", "nvidia_smi", "dcgmi"];
+export const SOFTWARE_KINDS = ["python", "package", "cuda", "nvidia_driver", "dcgmi"];
+/** Kinds a disk build installs per OS release; Python packages install anywhere. */
+const RELEASE_KINDS = ["python", "cuda", "nvidia_driver", "dcgmi"];
 function stringMap(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         return {};
@@ -13,22 +15,66 @@ function stringMap(value) {
     }
     return out;
 }
+function stringList(value) {
+    return Array.isArray(value)
+        ? value.filter((entry) => typeof entry === "string")
+        : [];
+}
+function releaseSupport(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return {};
+    }
+    const out = {};
+    for (const [release, kinds] of Object.entries(value)) {
+        if (!kinds || typeof kinds !== "object")
+            continue;
+        const row = kinds;
+        out[release] = Object.fromEntries(RELEASE_KINDS.map((kind) => [kind, stringList(row[kind])]));
+    }
+    return out;
+}
 export function parseSoftwareCatalog(payload) {
     const row = payload && typeof payload === "object" ? payload : {};
-    const python = Array.isArray(row.python)
-        ? row.python.filter((value) => typeof value === "string")
-        : [];
     return {
-        python,
+        python: stringList(row.python),
         packages: stringMap(row.packages),
         cuda: stringMap(row.cuda),
-        nvidia_smi: stringMap(row.nvidia_smi),
+        nvidia_driver: stringMap(row.nvidia_driver),
         dcgmi: stringMap(row.dcgmi),
+        os_releases: releaseSupport(row.os_releases),
     };
 }
 export async function loadSoftwareCatalog(fetchImpl) {
     return parseSoftwareCatalog(await fetchImpl(SOFTWARE_CATALOG_PATH, { method: "GET" }));
 }
+/**
+ * The catalog a disk built on an image of `osRelease` can install: Python,
+ * CUDA, driver, and DCGM choices narrowed to that release (none when it is
+ * unset or unknown); packages unchanged.
+ */
+export function softwareCatalogForOsRelease(catalog, osRelease) {
+    const supported = catalog.os_releases[osRelease ?? ""] ?? {};
+    const allows = (kind, slug) => supported[kind]?.includes(slug) ?? false;
+    const narrow = (kind) => Object.fromEntries(Object.entries(catalog[kind]).filter(([, slug]) => allows(kind, slug)));
+    return {
+        ...catalog,
+        python: catalog.python.filter((version) => allows("python", version)),
+        cuda: narrow("cuda"),
+        nvidia_driver: narrow("nvidia_driver"),
+        dcgmi: narrow("dcgmi"),
+    };
+}
+/** `stack` with every version `catalog` does not offer cleared. */
+export function keepOfferedChoices(stack, catalog) {
+    const offered = (map, slug) => slug && Object.values(map).includes(slug) ? slug : "";
+    return {
+        ...stack,
+        python_version: catalog.python.includes(stack.python_version) ? stack.python_version : "",
+        cuda_version: offered(catalog.cuda, stack.cuda_version),
+        nvidia_driver_version: offered(catalog.nvidia_driver, stack.nvidia_driver_version),
+        dcgmi_version: offered(catalog.dcgmi, stack.dcgmi_version),
+    };
+}
 export function displayForSoftwareSlug(catalog, kind, slug) {
     const map = catalog[kind];
     const hit = Object.entries(map).find(([, value]) => value === slug);