docs: OpenCPU, OpenMemory, OpenGPU and OpenBandwidth, the resources of a server purchase

Four resource specifications under OpenServer, one per thing that is
negotiable when a server is bought. Each is the block of an OpenServer
offer (compute, memory, gpu, network) written down on its own, with the
units OpenServer 0.1 already uses (vcpu, cores, ram_mb, vram_mb,
bandwidth_mbps, transfer_gb, ipv4, ipv6) and one new shape shared by all
four: `range`, the field a buyer can dial at checkout, its bounds, the
step and what a step costs on top of the base price.

- OpenCPU: threads against cores, the processor by its vendor name,
  dedicated, shared or burstable allocation.
- OpenMemory: mebibytes, DDR generation, ECC as three states, reserved,
  balloonable or shared; wins over compute.ram_mb when both are present.
- OpenGPU: the card by its vendor name, count and VRAM per device,
  interconnect, passthrough, MIG, vGPU or shared access.
- OpenBandwidth: port, four meters (transfer, unmetered, percentile,
  flat), overage, IPv4 and IPv6 addresses as a priced resource.

A provider that sells only one resource lists it as an OpenServer offer
and may serve the same document at /.well-known/<slug>.json. Landing
pages share one component (resource-spec-page.tsx). Registered in
DOC_SLUGS, NAV, STATIC_ROUTES and llms.txt. OpenServer, OpenFile and
OpenDisk arrive in sibling PRs.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_014cmNRtR2vL1p89dbVQ7FZJ

apps/logicsrc-web/src/app/llms.txt/route.ts

@@ -23,6 +23,10 @@ export function GET(): Response {
 - [OpenProfile.md](${SITE_URL}/openprofile): One Markdown file that says who you are and where you are, for people and agents alike: identity block, accounts, topics, reshare terms and operator, discovered at /.well-known/openprofile.md or through rel="openprofile".
 - [OpenMCP](${SITE_URL}/openmcp): An open catalog of MCP relays: a relay serves /.well-known/openmcp.json, a catalog probes it and lists only what it found, and clients reach every relay through the catalog's REST, its own MCP endpoint, or signed webhooks.
 - [OpenAccess](${SITE_URL}/openaccess): OAuth 2.1 with a grant you can carry: one hub account per person or agent, apps keep their own users and link them once, grants delegate narrower to agents, and a subscription bought in one app is honoured by every app that honours the product. Reference hub at openaccess.logicsrc.com.
+- [OpenCPU](${SITE_URL}/opencpu): The compute block of an OpenServer offer: threads against cores, the processor by its vendor name, dedicated, shared or burstable allocation, and a range that says what a buyer can add at checkout and for how much.
+- [OpenMemory](${SITE_URL}/openmemory): The memory block of an OpenServer offer: RAM in mebibytes, DDR generation, ECC as three states, reserved or balloonable allocation, and a range priced per step.
+- [OpenGPU](${SITE_URL}/opengpu): The gpu block of an OpenServer offer: the card by its vendor name, count and VRAM per device, interconnect, passthrough, MIG, vGPU or shared access, and a range over count.
+- [OpenBandwidth](${SITE_URL}/openbandwidth): The network block of an OpenServer offer: port speed, transfer, unmetered, 95th percentile or flat metering, overage, IPv4 and IPv6 addresses as a priced resource, DDoS scrubbing, and a range.
 - [AgentSwarm](${SITE_URL}/agent-swarm): Provider-neutral agent orchestration, model routing, and cost controls.
 - [AgentByte](${SITE_URL}/agentbyte): Agent screening sessions, policy events, and APIs.
 - [Credential Sharing](${SITE_URL}/credential-sharing): End-to-end-encrypted team vaults, plus source/target credential diffs, approval, sync, rollback, and audit.

apps/logicsrc-web/src/app/openbandwidth/page.tsx

@@ -0,0 +1,63 @@
+import type { ReactNode } from "react";
+import type { Metadata } from "next";
+import { ResourceSpecPage, type ResourceSpec } from "@/components/resource-spec-page";
+
+export const metadata: Metadata = {
+  title: "OpenBandwidth · LogicSRC",
+  description:
+    "OpenBandwidth is the network block of an OpenServer offer: port speed, how traffic is metered (transfer, unmetered, 95th percentile, flat), what overage costs, IPv4 and IPv6 addresses as a priced resource, DDoS scrubbing, and a range that says what a buyer can add at checkout and for how much.",
+  alternates: { canonical: "/openbandwidth" }
+};
+
+const SPEC: ResourceSpec = {
+  name: "OpenBandwidth",
+  slug: "openbandwidth",
+  block: "network",
+  tagline:
+    "The network line of a server purchase, with the words fixed: the port, the meter, the overage, the addresses, and what more of any of them costs.",
+  problem:
+    "Unmetered 1 Gbps, 1 Gbps with 20 TB, and 1 Gbps at the 95th percentile with 100 Mbps committed are three products that every comparison site shows as 1 Gbps. The surprise on the invoice is always the network line: overage at a cent a gigabyte here and nine there, ingress free or billed, a second IPv4 address at two a month or unavailable at any price. IPv4 is now a market of its own, leased by the /24, and no catalog format has a place for it.",
+  sample: `{
+  "network": {
+    "bandwidth_mbps": 1000,
+    "metering": "transfer",
+    "transfer_gb": 20000,
+    "counts": "egress",
+    "overage": { "amount": 0.01, "currency": "USD", "per_gb": 1 },
+    "ipv4": 1,
+    "ipv4_price": { "amount": 2, "currency": "USD", "interval": "month", "per": 1 },
+    "ipv4_max": 8,
+    "ipv6": "/64",
+    "ddos": "always-on",
+    "range": {
+      "key": "bandwidth_mbps", "min": 1000, "max": 10000, "step": 1000,
+      "price": { "amount": 15, "currency": "USD", "interval": "month", "per": 1000 }
+    }
+  }
+}`,
+  smallest: `{ "network": { "bandwidth_mbps": 1000 } }`,
+  fields: [
+    ["bandwidth_mbps", "integer, required", "The port speed sold. A shaped link states the shaped rate."],
+    ["metering", "transfer, unmetered, percentile, flat", "Gigabytes against transfer_gb, no cap, 95th percentile with commit_mbps, or a fixed price for the port."],
+    ["transfer_gb, counts", "integer per interval; egress, ingress, both, max", "Included traffic and which direction counts. A reader never assumes egress."],
+    ["overage, over_cap", "amount, currency, per_gb or per_mbps; bill, throttle, suspend", "What traffic past the cap costs, or what happens instead."],
+    ["ipv4, ipv4_price, ipv4_max, ipv6", "integer; price per address; integer; boolean or prefix", "Addresses as a resource: included, the price of more, the ceiling, and the IPv6 assignment."],
+    ["ddos, private_network, uplinks", "always-on, on-demand, none; boolean; integer", "That mitigation exists, a private LAN, physical links on a dedicated box."],
+    ["range", "key bandwidth_mbps, transfer_gb or ipv4; min, max, step, price", "What the buyer can dial and what a step costs."]
+  ],
+  directory: [
+    ["Meter beside the port", "1 Gbps unmetered and 1 Gbps with 20 TB are two rows with two words."],
+    ["Price a month of traffic", "Base plus overage at a stated volume, with the volume shown."],
+    ["Addresses as a resource", "Included count, price of more, ceiling. Zero with no price is unstated, not free."],
+    ["Never assume direction", "A cap with no counts is a cap with the direction unstated."]
+  ],
+  absent: [
+    ["No speed test", "bandwidth_mbps is the port sold. Achieved throughput is a measurement."],
+    ["No carriers or peering", "Upstreams and exchanges are the provider's network page. An ASN goes under the provider's own key."],
+    ["No SLA", "Uptime percentages and credits are the provider's terms, linked from the offer's url."]
+  ]
+};
+
+export default function OpenBandwidthPage(): ReactNode {
+  return <ResourceSpecPage spec={SPEC} />;
+}

apps/logicsrc-web/src/app/opencpu/page.tsx

@@ -0,0 +1,61 @@
+import type { ReactNode } from "react";
+import type { Metadata } from "next";
+import { ResourceSpecPage, type ResourceSpec } from "@/components/resource-spec-page";
+
+export const metadata: Metadata = {
+  title: "OpenCPU · LogicSRC",
+  description:
+    "OpenCPU is the compute block of an OpenServer offer: threads against cores, the processor by its vendor name, dedicated, shared or burstable allocation, and a range that says how many more a buyer can add at checkout and for how much.",
+  alternates: { canonical: "/opencpu" }
+};
+
+const SPEC: ResourceSpec = {
+  name: "OpenCPU",
+  slug: "opencpu",
+  block: "compute",
+  tagline:
+    "The processor line of a server purchase, with the words fixed: threads or cores, whose they are, and what one more costs.",
+  problem:
+    "Four vCPU on one pricing page is four hyperthreads of a shared socket, throttled at a fifth of sustained load. On the next it is four dedicated cores with the boost clock quoted. A comparison site sorts both on the number four, and the buyer who wanted the second pays for the first. A configurator that offers three processors at three prices keeps that choice in a form where no reader can see it.",
+  sample: `{
+  "compute": {
+    "vcpu": 4,
+    "cores": 2,
+    "threads_per_core": 2,
+    "arch": "x86_64",
+    "model": "AMD EPYC 9354",
+    "vendor": "AMD",
+    "base_ghz": 3.25,
+    "boost_ghz": 3.75,
+    "allocation": "dedicated",
+    "range": {
+      "key": "vcpu", "min": 2, "max": 32, "step": 2,
+      "price": { "amount": 4, "currency": "USD", "interval": "month", "per": 1 }
+    }
+  }
+}`,
+  smallest: `{ "compute": { "vcpu": 4 } }`,
+  fields: [
+    ["vcpu / cores", "integer, one required", "Threads sold to the guest, or physical cores. threads_per_core relates them; a reader never derives one from the other without it."],
+    ["arch", "x86_64, arm64, riscv64, or the provider's word", "Absent means unstated, not x86."],
+    ["model, vendor", "the vendor's own name", "AMD EPYC 9354, Ampere Altra Max. Kept verbatim so a buyer can look it up."],
+    ["base_ghz, boost_ghz, sockets", "decimal GHz, integer", "The vendor's figures, not a measurement."],
+    ["allocation", "dedicated, shared, burstable", "Reserved for the buyer, oversubscribed, or shared with a credit balance (credits_per_hour, baseline_pct)."],
+    ["range", "key, min, max, step, price", "What the buyer can dial at checkout and what each step costs on top of the base price."]
+  ],
+  directory: [
+    ["Two columns", "vcpu and cores are sorted separately; a row with neither is listed and marked unstated."],
+    ["Allocation beside the count", "Four dedicated threads and four shared ones are different products at the same number."],
+    ["Price the range", "Base price plus the per-step price, so 8 vCPU reads as base plus four steps."],
+    ["Keep the model string", "Normalise for search, display the vendor's spelling."]
+  ],
+  absent: [
+    ["No benchmarks", "Clock figures are the vendor's. A measured score is another document's business."],
+    ["No instruction-set flags", "AVX-512, SVE and the rest: look up model. A provider that wants them states them under its own key."],
+    ["No scheduling guarantees", "Pinning, NUMA and latency are the provider's terms, linked from the offer's url."]
+  ]
+};
+
+export default function OpenCpuPage(): ReactNode {
+  return <ResourceSpecPage spec={SPEC} />;
+}

apps/logicsrc-web/src/app/opengpu/page.tsx

@@ -0,0 +1,61 @@
+import type { ReactNode } from "react";
+import type { Metadata } from "next";
+import { ResourceSpecPage, type ResourceSpec } from "@/components/resource-spec-page";
+
+export const metadata: Metadata = {
+  title: "OpenGPU · LogicSRC",
+  description:
+    "OpenGPU is the gpu block of an OpenServer offer: the card by its vendor name, count and VRAM per device, the interconnect between them, passthrough, MIG, vGPU or shared access, and a range that says how many more a buyer can add at checkout and for how much.",
+  alternates: { canonical: "/opengpu" }
+};
+
+const SPEC: ResourceSpec = {
+  name: "OpenGPU",
+  slug: "opengpu",
+  block: "gpu",
+  tagline:
+    "The accelerator line of a server purchase, with the words fixed: which card, how many, how much memory, how they are joined, whole or a slice, and what one more costs.",
+  problem:
+    "The same card is sold whole, as a MIG slice, as a time-shared vGPU and as a peer's idle desktop, at prices an order of magnitude apart, and a listing that says one A100 has said almost nothing: 40 or 80 GB, PCIe or SXM, NVLinked or not. The peer markets move by the minute and publish their own schemas. A buyer's agent asked for two 80 GB cards with NVLink under 4 an hour reads six catalogs six ways.",
+  sample: `{
+  "gpu": {
+    "model": "NVIDIA H100 SXM",
+    "vendor": "NVIDIA",
+    "count": 8,
+    "vram_mb": 81920,
+    "arch": "Hopper",
+    "interconnect": "nvlink",
+    "access": "passthrough",
+    "driver": "550",
+    "runtime": "CUDA 12.4",
+    "range": {
+      "key": "count", "min": 1, "max": 8, "step": 1,
+      "price": { "amount": 2.49, "currency": "USD", "interval": "hour", "per": 1 }
+    }
+  }
+}`,
+  smallest: `{ "gpu": { "model": "NVIDIA RTX 4090" } }`,
+  fields: [
+    ["model, vendor, arch", "the vendor's own name, required", "Including the form factor when the vendor distinguishes one: H100 SXM and H100 PCIe are two models."],
+    ["count, vram_mb", "integer; mebibytes per device", "80 GB is 81920. A reader multiplies for the total and never assumes the provider did."],
+    ["interconnect", "nvlink, nvswitch, infinity-fabric, pcie, none", "How the devices in one offer are joined. A single card states nothing."],
+    ["access", "passthrough, mig, vgpu, shared", "The whole device, a hardware partition (profile or fraction), a virtualised share, or time-sliced with neighbours."],
+    ["driver, runtime", "version strings", "What the provider installs by default; absent means the buyer installs their own."],
+    ["range", "key count, min, max, step, price", "One offer per model; the range is over how many."]
+  ],
+  directory: [
+    ["Keep the model, match beside it", "NVIDIA H100 SXM and H100-SXM5-80GB are one card for search and two spellings on the page."],
+    ["Access beside VRAM", "A MIG slice and a whole card share a model and differ in everything else."],
+    ["Per-device price", "Computed from price and count so a row of eight and a row of one sort together, and labelled as computed."],
+    ["Stock with its timestamp", "GPU stock goes stale first; every row says when it was read."]
+  ],
+  absent: [
+    ["No TFLOPS", "Vendor throughput depends on precision, sparsity and clock, and no two vendors quote it alike."],
+    ["No reservation calendar", "Whether a card is free next Tuesday is the provider's scheduler. stock says now."],
+    ["No spot flag", "A card at a spot price is a second offer; price.commitment and the url carry the terms."]
+  ]
+};
+
+export default function OpenGpuPage(): ReactNode {
+  return <ResourceSpecPage spec={SPEC} />;
+}

apps/logicsrc-web/src/app/openmemory/page.tsx

@@ -0,0 +1,59 @@
+import type { ReactNode } from "react";
+import type { Metadata } from "next";
+import { ResourceSpecPage, type ResourceSpec } from "@/components/resource-spec-page";
+
+export const metadata: Metadata = {
+  title: "OpenMemory · LogicSRC",
+  description:
+    "OpenMemory is the memory block of an OpenServer offer: RAM in mebibytes, DDR generation and speed, ECC as three states, reserved or balloonable allocation, and a range that says how much more a buyer can add at checkout and for how much.",
+  alternates: { canonical: "/openmemory" }
+};
+
+const SPEC: ResourceSpec = {
+  name: "OpenMemory",
+  slug: "openmemory",
+  block: "memory",
+  tagline:
+    "The memory line of a server purchase, with the words fixed: how much, what kind, whether it is corrected, whether it is yours, and what a step more costs.",
+  problem:
+    "Memory is the resource most often bought in increments and least often described. A configurator offers 64, 128 or 256 GB at three prices and a scraper records the default. Eight gigabytes on a VPS may be reserved or may be reclaimed by the host under pressure. Whether the DIMMs are error-corrected decides whether a database belongs on the machine, and almost no listing says.",
+  sample: `{
+  "memory": {
+    "ram_mb": 65536,
+    "type": "DDR5",
+    "ecc": true,
+    "speed_mts": 4800,
+    "channels": 8,
+    "allocation": "reserved",
+    "hugepages": true,
+    "range": {
+      "key": "ram_mb", "min": 32768, "max": 1048576, "step": 32768,
+      "price": { "amount": 12, "currency": "USD", "interval": "month", "per": 32768 }
+    }
+  }
+}`,
+  smallest: `{ "memory": { "ram_mb": 8192 } }`,
+  fields: [
+    ["ram_mb", "integer mebibytes, required", "What the guest sees. 8 GiB is 8192, the same unit OpenServer uses. Wins over compute.ram_mb when both are present."],
+    ["type, speed_mts, channels", "DDR4, DDR5, LPDDR5, HBM3; MT/s; integer", "The vendor's rating, stated not measured."],
+    ["ecc", "true, false, absent", "Three states. A directory never shows absent as false."],
+    ["allocation", "reserved, balloonable, shared", "Backed and never reclaimed, reclaimable under host pressure, or oversubscribed."],
+    ["swap_mb, hugepages", "integer, boolean", "Swap the provider configures by default; whether huge pages are allowed."],
+    ["range", "key, min, max, step, price", "Memory sold in steps: the example is 32 GiB steps at 12 USD a month each."]
+  ],
+  directory: [
+    ["Mebibytes as the provider's unit", "Store ram_mb; display GiB or GB as the provider's page does, and say which."],
+    ["ECC as three states", "Yes, no and unstated are three filters."],
+    ["Price the range", "A configurator's three sizes are one offer with a range, shown as base plus step."],
+    ["memory before compute.ram_mb", "Read the block first and never sum the two."]
+  ],
+  absent: [
+    ["No bandwidth or latency", "speed_mts is the DIMM rating. Measured memory bandwidth is a benchmark."],
+    ["No persistent-memory tier", "Persistent and CXL-attached memory sit under the provider's own key until there is a second provider to agree with."],
+    ["No per-process limits", "cgroup limits on a container platform are the platform's terms, linked from the offer's url."]
+  ]
+};
+
+export default function OpenMemoryPage(): ReactNode {
+  return <ResourceSpecPage spec={SPEC} />;
+}

apps/logicsrc-web/src/app/sitemap.ts

@@ -25,6 +25,10 @@ const STATIC_ROUTES: Array<{
   { path: "/openprofile", changeFrequency: "weekly", priority: 0.9 },
   { path: "/openmcp", changeFrequency: "weekly", priority: 0.9 },
   { path: "/openaccess", changeFrequency: "weekly", priority: 0.9 },
+  { path: "/opencpu", changeFrequency: "weekly", priority: 0.9 },
+  { path: "/openmemory", changeFrequency: "weekly", priority: 0.9 },
+  { path: "/opengpu", changeFrequency: "weekly", priority: 0.9 },
+  { path: "/openbandwidth", changeFrequency: "weekly", priority: 0.9 },
   { path: "/openontology/explore", changeFrequency: "daily", priority: 0.7 },
   { path: "/openspec", changeFrequency: "weekly", priority: 0.8 },
   { path: "/agent-swarm", changeFrequency: "weekly", priority: 0.8 },

apps/logicsrc-web/src/components/resource-spec-page.tsx

@@ -0,0 +1,167 @@
+import Link from "next/link";
+import type { ReactNode } from "react";
+import { SiteShell } from "@/components/site-shell";
+import { mono, pre, table, td, th } from "../app/openontology/ui";
+
+/**
+ * One landing page shape for the five OpenServer resource specifications
+ * (OpenCPU, OpenMemory, OpenDisk, OpenGPU, OpenBandwidth). Each page is
+ * the same five bands with different words, so the words live in the page
+ * and the bands live here.
+ */
+
+export type ResourceSpec = {
+  /** Display name, e.g. "OpenCPU". */
+  name: string;
+  /** URL slug under /docs and /, e.g. "opencpu". */
+  slug: string;
+  /** The block key on an OpenServer offer, e.g. "compute". */
+  block: string;
+  /** One line under the title. */
+  tagline: string;
+  /** Two or three sentences on why the resource needs its own words. */
+  problem: ReactNode;
+  /** The example block, pretty-printed JSON. */
+  sample: string;
+  /** The smallest valid block, one line of JSON. */
+  smallest: string;
+  /** Field name, values, meaning. */
+  fields: Array<[string, string, string]>;
+  /** What a directory does with the block. */
+  directory: Array<[string, string]>;
+  /** What is deliberately absent, and why. */
+  absent: Array<[string, string]>;
+};
+
+const SIBLINGS: Array<[string, string]> = [
+  ["OpenCPU", "opencpu"],
+  ["OpenMemory", "openmemory"],
+  ["OpenDisk", "opendisk"],
+  ["OpenGPU", "opengpu"],
+  ["OpenBandwidth", "openbandwidth"]
+];
+
+export function ResourceSpecPage({ spec }: { spec: ResourceSpec }): ReactNode {
+  const wellKnown = `/.well-known/${spec.slug}.json`;
+  return (
+    <SiteShell active={spec.name}>
+      <div className="band">
+        <div className="section-head">
+          <p className="eyebrow">LogicSRC standards surface · OpenServer resource</p>
+          <h2>{spec.name}</h2>
+          <p>{spec.tagline}</p>
+        </div>
+        <p style={{ color: "#41505d" }}>{spec.problem}</p>
+        <p style={{ color: "#5b6b7a" }}>
+          Status: 0.1. The <code style={mono}>{spec.block}</code> block of an{" "}
+          <Link href="/docs/openserver">OpenServer</Link> offer, written down on its own. A provider
+          that sells only this resource lists it as an offer and may serve the same document at{" "}
+          <code style={mono}>{wellKnown}</code>. Every rule degrades: the smallest valid block is{" "}
+          <code style={mono}>{spec.smallest}</code>.
+        </p>
+      </div>
+
+      <div className="band">
+        <div className="section-head">
+          <h2>The {spec.block} block</h2>
+          <p>
+            Every key is the provider&apos;s claim, in fixed units. <code style={mono}>range</code>{" "}
+            is the part a buyer can dial at checkout: the field, its bounds, the step and what a
+            step costs.
+          </p>
+        </div>
+        <pre style={pre}>{spec.sample}</pre>
+      </div>
+
+      <div className="band">
+        <div className="section-head">
+          <h2>Fields</h2>
+          <p>Absent means unstated, never a default. A reader says so beside the number.</p>
+        </div>
+        <table style={table}>
+          <thead>
+            <tr>
+              <th style={th}>Key</th>
+              <th style={th}>Values</th>
+              <th style={th}>Meaning</th>
+            </tr>
+          </thead>
+          <tbody>
+            {spec.fields.map(([key, values, meaning]) => (
+              <tr key={key}>
+                <td style={td}>
+                  <code style={mono}>{key}</code>
+                </td>
+                <td style={td}>{values}</td>
+                <td style={td}>{meaning}</td>
+              </tr>
+            ))}
+          </tbody>
+        </table>
+      </div>
+
+      <div className="band">
+        <div className="section-head">
+          <h2>What a directory does with it</h2>
+        </div>
+        <table style={table}>
+          <tbody>
+            {spec.directory.map(([what, how]) => (
+              <tr key={what}>
+                <td style={td}>
+                  <strong>{what}</strong>
+                </td>
+                <td style={td}>{how}</td>
+              </tr>
+            ))}
+          </tbody>
+        </table>
+      </div>
+
+      <div className="band">
+        <div className="section-head">
+          <h2>What is deliberately absent</h2>
+        </div>
+        <table style={table}>
+          <tbody>
+            {spec.absent.map(([what, why]) => (
+              <tr key={what}>
+                <td style={td}>
+                  <strong>{what}</strong>
+                </td>
+                <td style={td}>{why}</td>
+              </tr>
+            ))}
+          </tbody>
+        </table>
+      </div>
+
+      <div className="band">
+        <div className="section-head">
+          <h2>Where everything lives</h2>
+        </div>
+        <ul style={{ color: "#41505d", lineHeight: 1.9, paddingLeft: "1.1rem" }}>
+          <li>
+            <Link href={`/docs/${spec.slug}`}>Specification</Link>: the block, every rule and how
+            it degrades, the resource as its own offer, what a directory owes a provider
+          </li>
+          <li>
+            <Link href="/docs/openserver">OpenServer</Link>: the descriptor at{" "}
+            <code style={mono}>/.well-known/openserver.json</code> that this block sits in, and the
+            directory that reads it
+          </li>
+          <li>
+            The five resources of a purchase:{" "}
+            {SIBLINGS.map(([name, slug], i) => (
+              <span key={slug}>
+                {i > 0 ? ", " : ""}
+                {slug === spec.slug ? <strong>{name}</strong> : <Link href={`/${slug}`}>{name}</Link>}
+              </span>
+            ))}
+            , each with the same <code style={mono}>range</code> shape
+          </li>
+        </ul>
+      </div>
+    </SiteShell>
+  );
+}

apps/logicsrc-web/src/components/site-shell.tsx

@@ -17,6 +17,10 @@ const NAV: Array<{ href: string; label: string; external?: boolean }> = [
   { href: "/openprofile", label: "OpenProfile" },
   { href: "/openmcp", label: "OpenMCP" },
   { href: "/openaccess", label: "OpenAccess" },
+  { href: "/opencpu", label: "OpenCPU" },
+  { href: "/openmemory", label: "OpenMemory" },
+  { href: "/opengpu", label: "OpenGPU" },
+  { href: "/openbandwidth", label: "OpenBandwidth" },
   { href: "/#cli", label: "CLI" },
   { href: "/docs", label: "Docs" },
   { href: "/blog", label: "Blog" },

apps/logicsrc-web/src/lib/docs.ts

@@ -21,6 +21,10 @@ export const DOC_SLUGS = [
   "openmcp",
   "openaccess",
   "openstream",
+  "opencpu",
+  "openmemory",
+  "opengpu",
+  "openbandwidth",
   "openspec-comparison",
   "data-model",
   "cli",