ankka-console 0.10.0 → 0.11.0

package/dist/testing/fake-control-plane.d.ts

@@ -66,13 +66,63 @@ interface Registry {
     setAt: string;
     setBy?: string;
 }
+interface ProjectSecret {
+    /** Values held as the cluster holds them; the control plane never answers with one. */
+    entries: Map<string, string>;
+    setAt: string;
+    setBy?: string;
+}
 interface Project {
     id: string;
     name: string;
     organizationId: string;
     registry?: Registry;
+    secrets?: Map<string, ProjectSecret>;
+    /** Declared topics, by name: their partitions, compaction, contract and what the broker reported of each. */
+    topics?: Map<string, TopicRecord>;
+    /** Declared brokers beside the installation's, by name. */
+    brokers?: Map<string, BrokerRecord>;
     hidden: boolean;
 }
+interface BrokerRecord {
+    bootstrap: string;
+    shape: string;
+    secret: string;
+    declaredAt: string;
+}
+/** A topic source as an instance reports it, with how far behind it is. */
+interface TopicSourceRecord {
+    kind: string;
+    component: string;
+    topic: string;
+    group: string;
+    start?: string;
+    version?: number;
+    broker?: string;
+    contract?: string;
+    lag?: number;
+    failing?: string;
+}
+interface TopicRecord {
+    partitions: number;
+    phase?: string;
+    detail?: string;
+    compacted?: boolean;
+    contract?: {
+        name: string;
+        fingerprint: string;
+        schema: unknown;
+    };
+}
+/** One side a running service takes on a declared topic with a contract, against it; `topic` is the fake's own, for the project's listing. */
+interface TopicCheckRecord {
+    topic?: string;
+    service: string;
+    component: string;
+    direction: string;
+    stated?: string;
+    state: string;
+}
 interface Service {
     name: string;
     projectId: string;
@@ -84,6 +134,8 @@ interface Service {
     detail?: string;
     exposed: boolean;
     paused: boolean;
+    /** What the cluster reports of its database; `null` until it has reported one. */
+    database: string | null;
     history: {
         kind: string;
         generation: number;
@@ -93,9 +145,65 @@ interface Service {
             administrative: boolean;
         };
         at: string;
+        image?: string;
+        digest?: string;
+        rolledBackTo?: number;
+    }[];
+    /** The descriptor in force, and the applied ones a rollback can return to, newest first, at most fifty. */
+    descriptor?: unknown;
+    kept: {
+        generation: number;
+        descriptor: unknown;
     }[];
     logs: Map<string, string[]>;
     previousLogs: Map<string, string[]>;
+    /** The platform's container's output: the sidecar beside a process, the proxy beside a web-hosted one. */
+    platformLogs: Map<string, string[]>;
+    hosting?: string;
+    mounts?: {
+        path: string;
+        service: string;
+        state: string;
+    }[];
+    callers?: string[];
+    processPort?: number;
+    /** What the operator reported of the service's credential on the installation's broker. */
+    broker?: string;
+    /** Topics the service's components use that its project does not declare, as last read. */
+    undeclaredTopics?: string[];
+    /** The sides it takes on declared topics with a contract, as last read. */
+    topicChecks?: TopicCheckRecord[];
+    /** Its topic sources with how far behind each is, as last read. */
+    topicSources?: TopicSourceRecord[];
+    /** The descriptor asked for a bucket (feature 034). */
+    provisionObjectStorage?: boolean;
+    /** The descriptor gave an ANKKA_S3_ variable: an object store of its own. */
+    ownObjectStore?: boolean;
+    /** The descriptor asked that the bucket be reachable from the internet. */
+    exposeObjectStorage?: boolean;
+    /** What the instances report when asked for the topology; generated from the service when unset. */
+    topology?: FakeTopology;
+}
+/** A service's instances, what each answered, and the merged document, as a suite scripts it. */
+export interface FakeTopology {
+    instances: {
+        pod: string;
+        status: "ok" | "unreachable" | "unsupported" | "failed";
+        problem?: string;
+    }[];
+    nodes: unknown[];
+    declared: unknown[];
+    calls: unknown[];
+    differences?: {
+        node: string;
+        presentOn: string[];
+    }[];
+    window?: {
+        seconds: number;
+        since: string;
+        calls: number;
+        unanswered?: number;
+    };
 }
 interface Token {
     id: string;
@@ -120,6 +228,8 @@ export interface FakeControlPlane {
     /** Advance every service in a transitional state by one step. */
     tick(): void;
     appendLog(projectId: string, name: string, line: string, instance?: string): void;
+    /** What a service's instances report when its topology is read, from now on. */
+    scriptTopology(projectId: string, name: string, topology: FakeTopology): void;
     /** Who may create organizations from now on, and where the refusal sends people. */
     policy(creation: "open" | "platform-admin", signupUrl?: string): void;
     /** From now on, created organizations and projects are missing from listings until `settle()`. */
@@ -155,6 +265,51 @@ export interface FakeSeed {
         image?: string;
         lifecycle?: string;
         instances?: number;
+        hosting?: string;
+        mounts?: {
+            path: string;
+            service: string;
+            state: string;
+        }[];
+        callers?: string[];
+        processPort?: number;
+        exposed?: boolean;
+        /** What the cluster reports of its database; `null` until it has reported one. */
+        database?: string | null;
+        broker?: string;
+        undeclaredTopics?: string[];
+        topicChecks?: TopicCheckRecord[];
+        topicSources?: TopicSourceRecord[];
+        provisionObjectStorage?: boolean;
+        exposeObjectStorage?: boolean;
+        ownObjectStore?: boolean;
+    }[];
+    /** Project secrets, by name and entry: a value each, never listed. */
+    secrets?: {
+        projectId: string;
+        name: string;
+        entries: Record<string, string>;
+    }[];
+    /** Brokers a project declares beside the installation's. */
+    brokers?: {
+        projectId: string;
+        name: string;
+        bootstrap: string;
+        shape: string;
+        secret: string;
+    }[];
+    /** Topics a project declares, as the control plane holds them, with the broker's report. */
+    topics?: {
+        projectId: string;
+        name: string;
+        partitions: number;
+        phase?: string;
+        detail?: string;
+        compacted?: boolean;
+        contract?: {
+            name: string;
+            schema: unknown;
+        };
     }[];
 }
 export declare function fakeControlPlane(options?: FakeControlPlaneOptions): Promise<FakeControlPlane>;

package/dist/testing/fake-control-plane.js

@@ -11,7 +11,38 @@
  * template exercised, which the parity test reads.
  */
 import { createServer } from "node:http";
-import { randomBytes } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
+/** The entries a project secret must hold for a broker's shape, as the control plane checks. */
+const brokerNeeds = (shape) => shape === "certificate" ? ["ca.crt", "tls.crt", "tls.key"] : shape === "sasl" ? ["ca.crt", "username", "password"] : [];
+const topicSourceOnTheWire = (t) => ({
+    kind: t.kind,
+    component: t.component,
+    topic: t.topic,
+    group: t.group,
+    start: t.start ?? "earliest",
+    version: t.version ?? 1,
+    recordedVersion: null,
+    behind: false,
+    broker: t.broker ?? null,
+    contract: t.contract ?? null,
+    lag: t.lag ?? null,
+    failing: t.failing ?? null,
+});
+const checkOnTheWire = (c) => ({ service: c.service, component: c.component, direction: c.direction, stated: c.stated ?? null, state: c.state });
+/** A stable fingerprint of the right shape; the control plane's is RFC 8785 over the document, which the fake need not reproduce. */
+function fakeFingerprint(schema) {
+    const text = JSON.stringify(schema);
+    let h1 = 0x811c9dc5;
+    let h2 = 0x01000193;
+    for (let i = 0; i < text.length; i++) {
+        h1 = Math.imul(h1 ^ text.charCodeAt(i), 0x01000193) >>> 0;
+        h2 = Math.imul(h2 + text.charCodeAt(i), 0x9e3779b1) >>> 0;
+    }
+    const hex = (h1.toString(16).padStart(8, "0") + h2.toString(16).padStart(8, "0")).repeat(4);
+    return `sha256:${hex}`;
+}
+/** The hostings whose pods hold the platform's container beside the developer's. */
+const twoContainers = (hosting) => hosting === "process" || hosting === "web";
 class HttpError extends Error {
     status;
     constructor(status, message) {
@@ -68,6 +99,29 @@ export async function fakeControlPlane(options = {}) {
         };
     };
     const registrySummary = (r) => r ? { server: r.server, username: r.username, setAt: r.setAt, setBy: r.setBy ?? null } : null;
+    /** An apply, or a rollback when `rolledBackTo` is given: a new generation with this descriptor. */
+    const record = (s, descriptor, by, rolledBackTo) => {
+        const d = descriptor;
+        s.generation += 1;
+        s.image = d.service?.image ?? "";
+        // Object storage (feature 034), from the descriptor, so a rolled-back one says what it said then.
+        s.provisionObjectStorage = d.service?.provisionObjectStorage ?? false;
+        s.exposeObjectStorage = d.service?.exposeObjectStorage ?? false;
+        s.ownObjectStore = (d.service?.env ?? []).some((e) => e.name.startsWith("ANKKA_S3_"));
+        s.desiredInstances = d.service?.resources?.autoscaling?.minInstances ?? 1;
+        s.lifecycle = s.paused ? "Paused" : "UpdateInProgress";
+        s.descriptor = descriptor;
+        s.kept = [{ generation: s.generation, descriptor }, ...s.kept].slice(0, 50);
+        s.history.push({
+            kind: rolledBackTo === undefined ? "applied" : "rolled-back",
+            generation: s.generation,
+            actor: by,
+            at: now(),
+            image: s.image,
+            digest: digestOf(descriptor),
+            ...(rolledBackTo === undefined ? {} : { rolledBackTo }),
+        });
+    };
     const serviceStatus = (s) => {
         const org = organizations.get(projects.get(s.projectId)?.organizationId ?? "");
         const suspended = org?.disabled ?? false;
@@ -81,13 +135,25 @@ export async function fakeControlPlane(options = {}) {
             desiredInstances: s.desiredInstances,
             detail: s.detail ?? null,
             confirmed: true,
-            database: "provisioned",
+            database: s.hosting === "web" ? "none" : s.database,
             hostname: s.exposed ? `https://${s.name}-${s.projectId}.${options.baseDomain ?? "example.test"}` : null,
             exposed: s.exposed,
             suspended,
             paused: s.paused,
-            hosting: "embedded",
+            hosting: s.hosting ?? "embedded",
             protocol: null,
+            mounts: s.mounts ?? [],
+            callers: s.callers ?? [],
+            processPort: s.processPort ?? null,
+            broker: s.broker ?? null,
+            undeclaredTopics: s.undeclaredTopics ?? null,
+            topicChecks: s.topicChecks ? s.topicChecks.map(checkOnTheWire) : null,
+            topicSources: s.topicSources ? s.topicSources.map(topicSourceOnTheWire) : null,
+            objectStorage: s.provisionObjectStorage ? "provisioned" : s.ownObjectStore ? "supplied" : null,
+            bucket: s.provisionObjectStorage ? `${s.projectId}.${s.name}` : null,
+            bucketAddress: s.provisionObjectStorage && s.exposeObjectStorage
+                ? `https://storage.${options.baseDomain ?? "example.test"}/${s.projectId}.${s.name}`
+                : null,
         };
     };
     // ── Authorization, the control plane's rules ──────────────────────────────
@@ -432,6 +498,173 @@ export async function fakeControlPlane(options = {}) {
         project.registry = undefined;
         return "done";
     });
+    // Project secrets: the control plane's rules, its merge, and names only in what it answers.
+    const SecretName = /^[a-z0-9]([a-z0-9.-]*[a-z0-9])?$/;
+    const EntryName = /^[A-Za-z0-9._-]{1,253}$/;
+    const PlatformSuffixes = ["-db", "-cluster-tls", "-service-tls", "-database-tls", "-secret-key", "-mount-tls", "-storage"];
+    route("PUT", "/projects/{projectId}/secrets/{name}", (c, p, body) => {
+        const { project, org } = requireProject(c, p.projectId);
+        requireWrite(org);
+        const name = p.name;
+        const entries = (body.entries ?? {});
+        const problems = [];
+        if (!SecretName.test(name) || name.length > 253)
+            problems.push(`project secret name '${name}' must be lowercase letters, digits, '-' and '.', begin and end with a letter or digit, and be at most 253 characters`);
+        else if (name.startsWith("ankka-") || PlatformSuffixes.some((s) => name.endsWith(s)))
+            problems.push(`project secret name '${name}' is one the platform uses for its own Secrets in a project`);
+        if (Object.keys(entries).length === 0)
+            problems.push("a project secret is set with at least one entry");
+        for (const [entry, value] of Object.entries(entries)) {
+            if (!EntryName.test(entry))
+                problems.push(`entry name '${entry}' must be 1 to 253 letters, digits, '.', '_' or '-'`);
+            if (value === "")
+                problems.push(`entry '${entry}' must not be empty`);
+        }
+        if (problems.length > 0)
+            throw new HttpError(400, problems.join("; "));
+        project.secrets ??= new Map();
+        const held = project.secrets.get(name)?.entries ?? new Map();
+        for (const [entry, value] of Object.entries(entries))
+            held.set(entry, value);
+        project.secrets.set(name, { entries: held, setAt: now(), setBy: c.name ?? c.subject });
+        return "done";
+    });
+    route("DELETE", "/projects/{projectId}/secrets/{name}", (c, p, _body, url) => {
+        const { project, org } = requireProject(c, p.projectId);
+        requireWrite(org);
+        const entry = url.searchParams.get("entry") ?? "";
+        const secret = project.secrets?.get(p.name);
+        if (!secret?.entries.has(entry))
+            throw new HttpError(404, `project secret '${p.name}' has no entry '${entry}'`);
+        // A broker's credential is not pulled from under it: the broker goes first.
+        const naming = [...(project.brokers ?? new Map()).entries()].filter(([, b]) => b.secret === p.name && brokerNeeds(b.shape).includes(entry)).map(([name]) => `'${name}'`);
+        if (naming.length > 0)
+            throw new HttpError(409, `project secret '${p.name}' is the credential of broker ${naming.sort().join(", ")}; remove the broker first`);
+        secret.entries.delete(entry);
+        return "done";
+    });
+    route("GET", "/projects/{projectId}/secrets", (c, p) => {
+        const { project } = requireProject(c, p.projectId);
+        return [...(project.secrets ?? new Map()).entries()]
+            .filter(([, s]) => s.entries.size > 0)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([name, s]) => ({ name, entries: [...s.entries.keys()].sort(), setAt: s.setAt, setBy: s.setBy }));
+    });
+    // Project topics: the control plane's rules, one declaration per name, never fewer partitions.
+    const TopicName = /^[a-z0-9]([a-z0-9.-]{0,98}[a-z0-9])?$/;
+    const TopicNameRule = 'a name is lower-case letters, digits, "-" and ".", starting and ending with a letter or digit, at most 100 characters';
+    const ContractName = /^[a-z0-9][a-z0-9._-]{0,98}[a-z0-9]$/;
+    const ContractNameRule = "[a-z0-9][a-z0-9._-]{0,98}[a-z0-9]";
+    route("PUT", "/projects/{projectId}/topics/{name}", (c, p, body) => {
+        const { project, org } = requireProject(c, p.projectId);
+        requireWrite(org);
+        const name = p.name;
+        const request = body;
+        const partitions = Number(request.partitions);
+        const problems = [];
+        if (!TopicName.test(name))
+            problems.push(`topic '${name}': ${TopicNameRule}`);
+        if (!Number.isInteger(partitions) || partitions < 1 || partitions > 1000)
+            problems.push(`topic '${name}': partitions ${partitions} is outside the range 1-1000`);
+        // A contract's own rules: its name, and a schema that is a JSON document (feature 037).
+        if (request.contract !== undefined && request.contract !== null) {
+            const contractName = String(request.contract.name ?? "");
+            if (!ContractName.test(contractName))
+                problems.push(`topic '${name}': contract name '${contractName}' is not ${ContractNameRule}`);
+            if (request.contract.schema === undefined || request.contract.schema === null)
+                problems.push(`topic '${name}': the contract's schema is missing`);
+        }
+        if (problems.length > 0)
+            throw new HttpError(400, problems.join("; "));
+        project.topics ??= new Map();
+        const has = project.topics.get(name)?.partitions;
+        if (has !== undefined && has > partitions)
+            throw new HttpError(409, `topic '${name}' has ${has} partitions and cannot have fewer; ${partitions} was asked`);
+        const contract = request.contract
+            ? { name: String(request.contract.name), schema: request.contract.schema, fingerprint: fakeFingerprint(request.contract.schema) }
+            : undefined;
+        project.topics.set(name, { ...(project.topics.get(name) ?? {}), partitions, compacted: request.compacted === true, contract });
+        return "done";
+    });
+    // The schema a topic's contract was declared with (feature 037); 404 without a contract.
+    route("GET", "/projects/{projectId}/topics/{name}/schema", (c, p) => {
+        const { project } = requireProject(c, p.projectId);
+        const topic = project.topics?.get(p.name);
+        if (!topic?.contract)
+            throw new HttpError(404, `project '${p.projectId}' declares no contract on topic '${p.name}'`);
+        return topic.contract.schema;
+    });
+    route("DELETE", "/projects/{projectId}/topics/{name}", (c, p) => {
+        const { project, org } = requireProject(c, p.projectId);
+        requireWrite(org);
+        if (!project.topics?.delete(p.name))
+            throw new HttpError(404, `project '${p.projectId}' declares no topic '${p.name}'`);
+        return "done";
+    });
+    route("GET", "/projects/{projectId}/topics", (c, p) => {
+        const { project } = requireProject(c, p.projectId);
+        // The sides the project's services were seeded with, by topic: the control plane reads them
+        // from every service's instances; the fake reads them from what it was told.
+        const checks = [...services.values()].filter((s) => s.projectId === p.projectId).flatMap((s) => s.topicChecks ?? []);
+        return [...(project.topics ?? new Map()).entries()]
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([name, t]) => ({
+            name,
+            partitions: t.partitions,
+            phase: t.phase,
+            detail: t.detail,
+            compacted: t.compacted ?? false,
+            contract: t.contract ? { name: t.contract.name, fingerprint: t.contract.fingerprint } : null,
+            checks: t.contract ? checks.filter((c) => c.topic === name).map(checkOnTheWire) : [],
+        }));
+    });
+    // Declared brokers (feature 037): the control plane's rules, and the secret's entries checked by name.
+    const BrokerBootstrap = /^[A-Za-z0-9._-]+:[0-9]+(,[A-Za-z0-9._-]+:[0-9]+)*$/;
+    route("PUT", "/projects/{projectId}/brokers/{name}", (c, p, body) => {
+        const { project, org } = requireProject(c, p.projectId);
+        requireWrite(org);
+        const name = p.name;
+        const request = body;
+        const bootstrap = String(request.bootstrap ?? "").trim();
+        const shape = String(request.shape ?? "");
+        const secret = String(request.secret ?? "");
+        const problems = [];
+        if (!TopicName.test(name))
+            problems.push(`broker '${name}': ${TopicNameRule}`);
+        if (!BrokerBootstrap.test(bootstrap))
+            problems.push(`broker '${name}': bootstrap '${bootstrap}' is not host:port[,host:port]`);
+        if (shape !== "certificate" && shape !== "sasl")
+            problems.push(`broker '${name}': shape '${shape}' is not one of certificate, sasl`);
+        if (secret === "")
+            problems.push(`broker '${name}': secret a project secret needs a name`);
+        else if (secret.startsWith("ankka-") || PlatformSuffixes.some((s) => secret.endsWith(s)))
+            problems.push(`broker '${name}': secret project secret name '${secret}' is one the platform uses for its own Secrets in a project`);
+        if (problems.length > 0)
+            throw new HttpError(400, problems.join("; "));
+        const held = project.secrets?.get(secret);
+        if (!held)
+            throw new HttpError(400, `project '${p.projectId}' has no project secret '${secret}'`);
+        const missing = brokerNeeds(shape).filter((e) => !held.entries.has(e));
+        if (missing.length > 0)
+            throw new HttpError(400, `project secret '${secret}' lacks ${missing.map((m) => `'${m}'`).join(", ")}, which shape '${shape}' needs`);
+        project.brokers ??= new Map();
+        const declaredAt = project.brokers.get(name)?.declaredAt ?? now();
+        project.brokers.set(name, { bootstrap, shape, secret, declaredAt });
+        return "done";
+    });
+    route("DELETE", "/projects/{projectId}/brokers/{name}", (c, p) => {
+        const { project, org } = requireProject(c, p.projectId);
+        requireWrite(org);
+        if (!project.brokers?.delete(p.name))
+            throw new HttpError(404, `project '${p.projectId}' declares no broker '${p.name}'`);
+        return "done";
+    });
+    route("GET", "/projects/{projectId}/brokers", (c, p) => {
+        const { project } = requireProject(c, p.projectId);
+        return [...(project.brokers ?? new Map()).entries()]
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([name, b]) => ({ name, bootstrap: b.bootstrap, shape: b.shape, secret: b.secret, declaredAt: b.declaredAt }));
+    });
     route("GET", "/services/{projectId}", (c, p) => {
         requireProject(c, p.projectId);
         return [...services.values()].filter((s) => s.projectId === p.projectId).map(serviceStatus);
@@ -463,18 +696,58 @@ export async function fakeControlPlane(options = {}) {
             desiredInstances: instances,
             exposed: false,
             paused: false,
+            database: "provisioned",
             history: [],
+            kept: [],
             logs: new Map(),
             previousLogs: new Map(),
+            platformLogs: new Map(),
         };
-        s.image = d.service.image;
-        s.generation += 1;
-        s.desiredInstances = instances;
-        s.lifecycle = s.paused ? "Paused" : "UpdateInProgress";
-        s.history.push({ kind: "applied", generation: s.generation, actor: actor(c), at: now() });
+        record(s, d, actor(c));
         services.set(key, s);
         return serviceStatus(s);
     });
+    // Rollbacks, by the control plane's rules: the same refusals, in the same words and statuses. The
+    // digest need only be equal for equal descriptors; it is not the control plane's.
+    const descriptorAt = (s, n) => {
+        if (!Number.isInteger(n) || n < 1 || n > s.generation)
+            throw new HttpError(404, `service '${s.name}' has no generation ${n}`);
+        const found = s.kept.find((k) => k.generation === n);
+        if (found)
+            return found;
+        const oldest = s.kept.at(-1);
+        const ran = s.kept.find((k) => k.generation < n);
+        if (oldest && ran && n > oldest.generation)
+            throw new HttpError(409, `generation ${n} was a restart and ran the descriptor of generation ${ran.generation}`);
+        throw new HttpError(409, `the descriptor of generation ${n} is no longer kept; the oldest kept is generation ${oldest?.generation ?? s.generation}`);
+    };
+    route("POST", "/services/{projectId}/{name}/rollback", (c, p, body) => {
+        const { service: s, org } = requireService(c, p.projectId, p.name);
+        requireWrite(org);
+        const named = body?.generation;
+        const current = digestOf(s.descriptor);
+        let target;
+        if (named !== undefined) {
+            target = descriptorAt(s, named);
+            if (digestOf(target.descriptor) === current)
+                throw new HttpError(409, `service '${s.name}' already has the descriptor of generation ${named}`);
+        }
+        else {
+            const differs = s.kept.find((k) => digestOf(k.descriptor) !== current);
+            if (!differs)
+                throw new HttpError(409, `service '${s.name}' has no earlier generation with a different descriptor`);
+            target = differs;
+        }
+        record(s, target.descriptor, actor(c), target.generation);
+        return { rolledBackTo: target.generation, status: serviceStatus(s) };
+    });
+    route("GET", "/services/{projectId}/{name}/descriptor", (c, p, _body, url) => {
+        const { service: s } = requireService(c, p.projectId, p.name);
+        const raw = url.searchParams.get("generation");
+        if (raw === null)
+            throw new HttpError(400, "query parameter 'generation' is required");
+        return descriptorAt(s, Number(raw)).descriptor;
+    });
     const operation = (op) => (c, p) => {
         const { service: s, org } = requireService(c, p.projectId, p.name);
         requireWrite(org);
@@ -513,9 +786,12 @@ export async function fakeControlPlane(options = {}) {
         if (s.paused || s.readyInstances === 0 && s.logs.size === 0)
             throw new HttpError(404, `service '${s.name}' has no running instance`);
         const previous = url.searchParams.get("previous") === "true";
+        const platform = url.searchParams.get("platform") === "true";
+        if (platform && !twoContainers(s.hosting))
+            throw new HttpError(400, "--platform applies to a service with process or web hosting");
         const tail = url.searchParams.get("tail");
         const only = url.searchParams.get("instance");
-        const source = previous ? s.previousLogs : s.logs;
+        const source = platform ? s.platformLogs : previous ? s.previousLogs : s.logs;
         const names = s.readyInstances > 0 ? Array.from({ length: s.readyInstances }, (_x, i) => `${s.name}-${i}`) : [...source.keys()];
         return {
             instances: names
@@ -527,6 +803,32 @@ export async function fakeControlPlane(options = {}) {
             }),
         };
     });
+    // The control plane's rules: a non-member is told the service does not exist; no running instance
+    // is the logs route's 404; one instance that is not ok makes the result partial.
+    route("GET", "/services/{projectId}/{name}/topology", (c, p) => {
+        const { service: s } = requireService(c, p.projectId, p.name);
+        if (s.paused || s.readyInstances === 0)
+            throw new HttpError(404, `service '${s.name}' has no running instance; it may be paused`);
+        const t = s.topology ?? {
+            instances: Array.from({ length: s.readyInstances }, (_x, i) => ({ pod: `${s.name}-${i}`, status: "ok" })),
+            nodes: [{ id: s.name, kind: "EventSourcedEntity", layer: 1, platform: false, handlers: [] }],
+            declared: [],
+            calls: [],
+        };
+        const contributing = t.instances.filter((i) => i.status === "ok").length;
+        return {
+            service: s.name,
+            running: t.instances.length,
+            contributing,
+            partial: contributing < t.instances.length,
+            instances: t.instances.map((i) => ({ pod: i.pod, status: i.status, problem: i.problem ?? null, runtime: i.status === "ok" ? "0.0.0" : null, readAt: i.status === "ok" ? now() : null })),
+            window: t.window ?? { seconds: 600, since: now(), calls: 0, unanswered: 0 },
+            nodes: t.nodes,
+            declared: t.declared,
+            calls: t.calls,
+            differences: t.differences ?? [],
+        };
+    });
     route("GET", "/services/{projectId}/{name}/history", (c, p) => requireService(c, p.projectId, p.name).service.history);
     route("DELETE", "/services/{projectId}/{name}", (c, p) => {
         const { service: s, org } = requireService(c, p.projectId, p.name);
@@ -650,6 +952,12 @@ export async function fakeControlPlane(options = {}) {
                 }
             }
         },
+        scriptTopology(projectId, name, topology) {
+            const s = services.get(serviceKey(projectId, name));
+            if (!s)
+                throw new Error(`no service ${projectId}/${name}`);
+            s.topology = topology;
+        },
         appendLog(projectId, name, line, instance) {
             const s = services.get(serviceKey(projectId, name));
             if (!s)
@@ -688,8 +996,13 @@ export async function fakeControlPlane(options = {}) {
                 const n = s.instances ?? 1;
                 const ready = lifecycle === "Ready" ? n : 0;
                 const logs = new Map();
-                for (let i = 0; i < ready; i++)
+                const platformLogs = new Map();
+                for (let i = 0; i < ready; i++) {
                     logs.set(`${s.name}-${i}`, [`${s.name} started`]);
+                    if (twoContainers(s.hosting))
+                        platformLogs.set(`${s.name}-${i}`, [`${s.hosting === "web" ? "proxy" : "sidecar"} of ${s.name} started`]);
+                }
+                const seeded = { name: s.name, service: { image: s.image ?? `${s.name}:latest` } };
                 services.set(serviceKey(s.projectId, s.name), {
                     name: s.name,
                     projectId: s.projectId,
@@ -698,11 +1011,56 @@ export async function fakeControlPlane(options = {}) {
                     image: s.image ?? `${s.name}:latest`,
                     readyInstances: ready,
                     desiredInstances: n,
-                    exposed: false,
+                    exposed: s.exposed ?? false,
                     paused: lifecycle === "Paused",
-                    history: [{ kind: "applied", generation: 1, at: now() }],
+                    database: s.database === undefined ? "provisioned" : s.database,
+                    history: [{ kind: "applied", generation: 1, at: now(), image: s.image ?? `${s.name}:latest`, digest: digestOf(seeded) }],
+                    descriptor: seeded,
+                    kept: [{ generation: 1, descriptor: seeded }],
                     logs,
                     previousLogs: new Map(),
+                    platformLogs,
+                    hosting: s.hosting,
+                    mounts: s.mounts,
+                    callers: s.callers,
+                    processPort: s.processPort,
+                    broker: s.broker,
+                    undeclaredTopics: s.undeclaredTopics,
+                    topicChecks: s.topicChecks,
+                    topicSources: s.topicSources,
+                    provisionObjectStorage: s.provisionObjectStorage,
+                    exposeObjectStorage: s.exposeObjectStorage,
+                    ownObjectStore: s.ownObjectStore,
+                });
+            }
+            for (const sec of seed.secrets ?? []) {
+                const project = projects.get(sec.projectId);
+                if (!project)
+                    throw new Error(`no project ${sec.projectId}`);
+                project.secrets ??= new Map();
+                const held = project.secrets.get(sec.name)?.entries ?? new Map();
+                for (const [entry, value] of Object.entries(sec.entries))
+                    held.set(entry, value);
+                project.secrets.set(sec.name, { entries: held, setAt: now(), setBy: "seed" });
+            }
+            for (const b of seed.brokers ?? []) {
+                const project = projects.get(b.projectId);
+                if (!project)
+                    throw new Error(`no project ${b.projectId}`);
+                project.brokers ??= new Map();
+                project.brokers.set(b.name, { bootstrap: b.bootstrap, shape: b.shape, secret: b.secret, declaredAt: now() });
+            }
+            for (const t of seed.topics ?? []) {
+                const project = projects.get(t.projectId);
+                if (!project)
+                    throw new Error(`no project ${t.projectId}`);
+                project.topics ??= new Map();
+                project.topics.set(t.name, {
+                    partitions: t.partitions,
+                    phase: t.phase,
+                    detail: t.detail,
+                    compacted: t.compacted,
+                    contract: t.contract ? { ...t.contract, fingerprint: fakeFingerprint(t.contract.schema) } : undefined,
                 });
             }
         },
@@ -713,3 +1071,12 @@ export async function fakeControlPlane(options = {}) {
     };
     return fake;
 }
+/** Equal for equal descriptors, whatever order their keys were written in. */
+function digestOf(descriptor) {
+    const canonical = (v) => Array.isArray(v)
+        ? v.map(canonical)
+        : v && typeof v === "object"
+            ? Object.fromEntries(Object.keys(v).sort().map((k) => [k, canonical(v[k])]))
+            : v;
+    return createHash("sha256").update(JSON.stringify(canonical(descriptor ?? null))).digest("hex");
+}