@shortlink-org/portolan 0.2.1 → 0.2.2

package/src/lib/api.test.ts

@@ -23,15 +23,13 @@ function auth(): Service {
 
 describe("interfaceDeclaring", () => {
   it("finds the interface a method belongs to", () => {
-    expect(interfaceDeclaring(auth(), "registerUser")?.id).toBe(
-      "auth.v1.Users",
-    );
-    expect(interfaceDeclaring(auth(), "login")?.id).toBe("auth.v1.Sessions");
+    expect(interfaceDeclaring(auth(), "registerUser")?.id).toBe("auth.v1");
+    expect(interfaceDeclaring(auth(), "login")?.id).toBe("auth.v1");
     expect(interfaceDeclaring(auth(), "nothing")).toBeUndefined();
   });
 
   it("writes a method the way the rest of the app writes one", () => {
-    expect(methodId(auth(), "registerUser")).toBe("auth.v1.Users/registerUser");
+    expect(methodId(auth(), "registerUser")).toBe("auth.v1/registerUser");
   });
 });
 
@@ -92,7 +90,7 @@ describe("methods, now that a method is more than a name", () => {
     const declared = declaredMethods(auth());
 
     expect(declared.length).toBe(methodCount(auth()));
-    expect(declared[0]?.provided.id).toBe("auth.v1.Users");
+    expect(declared[0]?.provided.id).toBe("auth.v1");
     expect(declared.map((d) => d.method.name)).toContain("login");
   });
 

package/src/lib/build-info.test.ts

@@ -3,6 +3,7 @@ import {
   buildHref,
   buildLabel,
   buildTitle,
+  repositoryCommitHref,
   type BuildInfo,
 } from "./build-info";
 
@@ -45,6 +46,34 @@ describe("buildHref", () => {
   });
 });
 
+describe("repositoryCommitHref", () => {
+  it("links a GitLab commit through the repository page", () => {
+    expect(repositoryCommitHref("abc123", CI)).toBe(
+      "https://gitlab.com/acme/portolan/-/commit/abc123",
+    );
+  });
+
+  it("links a GitHub commit through the repository page", () => {
+    expect(
+      repositoryCommitHref("abc123", {
+        ...CI,
+        repoUrl: "https://github.com/acme/portolan/",
+        forge: "github",
+      }),
+    ).toBe("https://github.com/acme/portolan/commit/abc123");
+  });
+
+  it("does not guess a route for an unknown forge", () => {
+    expect(
+      repositoryCommitHref("abc123", {
+        ...CI,
+        repoUrl: "https://code.example.com/acme/portolan",
+        forge: undefined,
+      }),
+    ).toBeNull();
+  });
+});
+
 describe("buildLabel", () => {
   it("reads as the commit, not the build number, even on CI", () => {
     expect(buildLabel(CI)).toBe("4f1c9ae");

package/src/lib/build-info.ts

@@ -50,6 +50,27 @@ export function buildHref(info: BuildInfo = buildInfo): string | null {
   return info.commitUrl || info.buildUrl || null;
 }
 
+/** An immutable commit in the repository this bundle was built from. */
+export function repositoryCommitHref(
+  commit: string,
+  info: BuildInfo = buildInfo,
+): string | null {
+  if (!commit || !info.repoUrl) return null;
+
+  const repo = info.repoUrl.replace(/\/$/, "");
+  const forge =
+    info.forge ??
+    (/gitlab/i.test(repo)
+      ? "gitlab"
+      : /github/i.test(repo)
+        ? "github"
+        : null);
+  if (!forge) return null;
+
+  const route = forge === "gitlab" ? "/-/commit/" : "/commit/";
+  return `${repo}${route}${encodeURIComponent(commit)}`;
+}
+
 /**
  * What the stamp reads: the commit, because that is the thing you can look up
  * in the repo. The build number is CI bookkeeping and lives in the tooltip.

package/src/lib/data-model.ts

@@ -15,6 +15,7 @@ import type {
   Column,
   ColumnOwner,
   Field,
+  RedisKeyspace,
   Service,
   Store,
   Table,
@@ -128,6 +129,19 @@ export interface PersistedTable {
   store: Store;
 }
 
+export interface PersistedRedisKeyspace {
+  keyspace: RedisKeyspace;
+  store: Store;
+}
+
+/** Redis key families whose serialized value is an aggregate snapshot. */
+export function redisKeyspacesPersisting(
+  index: CatalogIndex,
+  aggregateId: string,
+): PersistedRedisKeyspace[] {
+  return index.keyspacesByAggregate.get(aggregateId) ?? [];
+}
+
 /**
  * The tables that hold an aggregate — those naming it in `persists`, plus the
  * ones naming one of its blocks. A child table pointing at a value object of

package/src/lib/flow-tree.ts

@@ -42,7 +42,7 @@ export function flowHealth(flow: Flow): FlowHealth {
   const steps = walkSteps(flow.steps);
   const statuses: Status[] = steps.map((s) => s.status);
   if (statuses.some((s) => s === "unresolved")) return "unresolved";
-  const hops = steps.filter((s) => s.kind !== "call");
+  const hops = steps.filter((s) => s.kind !== "call" && s.kind !== "response");
   if (hops.length > 0 && hops.every((s) => s.status === "verified"))
     return "verified";
   return "declared";

package/src/lib/github-catalog.test.ts

@@ -6,6 +6,7 @@ import {
   listForgeBranches,
   listForgeRefs,
   listGitHubBranches,
+  loadForgeCommit,
   loadForgeCatalog,
   loadGitHubCatalog,
 } from "./github-catalog";
@@ -140,6 +141,56 @@ describe("listGitHubBranches", () => {
   });
 });
 
+describe("loadForgeCommit", () => {
+  it("normalizes GitHub commit metadata for the hover card", async () => {
+    const fetch = vi.fn().mockResolvedValue(new Response(JSON.stringify({
+      sha: SHA,
+      html_url: `${REPO.webUrl}/commit/${SHA}`,
+      commit: {
+        message: "Explain the decision\n\nKeep the useful detail.",
+        author: { name: "Ada", date: "2026-09-08T10:00:00Z" },
+      },
+      author: { login: "ada", avatar_url: "https://avatars.example/ada" },
+      stats: { additions: 12, deletions: 3 },
+    }), { status: 200 }));
+    vi.stubGlobal("fetch", fetch);
+
+    await expect(loadForgeCommit(REPO, SHA, { token: "secret" })).resolves.toEqual({
+      sha: SHA,
+      title: "Explain the decision",
+      body: "Keep the useful detail.",
+      author: "ada",
+      authoredAt: "2026-09-08T10:00:00Z",
+      avatarUrl: "https://avatars.example/ada",
+      additions: 12,
+      deletions: 3,
+      webUrl: `${REPO.webUrl}/commit/${SHA}`,
+    });
+    expect(new Headers(fetch.mock.calls[0]?.[1]?.headers).get("authorization")).toBe("Bearer secret");
+  });
+
+  it("normalizes GitLab commit metadata for the same card", async () => {
+    vi.stubGlobal("fetch", vi.fn().mockResolvedValue(new Response(JSON.stringify({
+      id: SHA,
+      title: "Explain the decision",
+      message: "Explain the decision\n\nKeep the useful detail.",
+      author_name: "Ada",
+      authored_date: "2026-09-08T10:00:00Z",
+      web_url: `${GITLAB_REPO.webUrl}/-/commit/${SHA}`,
+      stats: { additions: 12, deletions: 3 },
+    }), { status: 200 })));
+
+    await expect(loadForgeCommit(GITLAB_REPO, SHA)).resolves.toMatchObject({
+      sha: SHA,
+      title: "Explain the decision",
+      body: "Keep the useful detail.",
+      author: "Ada",
+      additions: 12,
+      deletions: 3,
+    });
+  });
+});
+
 describe("loadGitHubCatalog", () => {
   it("discovers manifest sources at an immutable SHA and validates the merge", async () => {
     const source = {

package/src/lib/github-catalog.ts

@@ -33,6 +33,18 @@ export type ForgeRepo = GitHubRepo | GitLabRepo;
 
 export type ForgeAccess = { token?: string };
 
+export type ForgeCommit = {
+  sha: string;
+  title: string;
+  body: string;
+  author: string;
+  authoredAt: string;
+  avatarUrl: string;
+  additions: number | null;
+  deletions: number | null;
+  webUrl: string;
+};
+
 /**
  * A name the forge resolves to a commit: a branch head as it is now, or a
  * tag. Both are what a reader compares against; the kind is kept because a
@@ -263,6 +275,63 @@ function gitlabError(response: Response): Error {
   return new Error(`GitLab API request failed (${response.status}).`);
 }
 
+/** Commit metadata for a hover card, normalized across GitHub and GitLab. */
+export async function loadForgeCommit(
+  repo: ForgeRepo,
+  sha: string,
+  access: ForgeAccess = {},
+): Promise<ForgeCommit> {
+  if (repo.provider === "github") {
+    const found = await githubJson<{
+      sha: string;
+      html_url: string;
+      commit: {
+        message: string;
+        author: { name: string; date: string } | null;
+      };
+      author: { login: string; avatar_url: string } | null;
+      stats?: { additions: number; deletions: number };
+    }>(apiUrl(repo, `/commits/${encodeURIComponent(sha)}`), access.token);
+    const [title = found.sha.slice(0, 7), ...body] = found.commit.message.split("\n");
+    return {
+      sha: found.sha,
+      title,
+      body: body.join("\n").trim(),
+      author: found.author?.login || found.commit.author?.name || "unknown",
+      authoredAt: found.commit.author?.date || "",
+      avatarUrl: found.author?.avatar_url || "",
+      additions: found.stats?.additions ?? null,
+      deletions: found.stats?.deletions ?? null,
+      webUrl: found.html_url,
+    };
+  }
+
+  const found = await gitlabJson<{
+    id: string;
+    title: string;
+    message: string;
+    author_name: string;
+    authored_date: string;
+    web_url: string;
+    stats?: { additions: number; deletions: number };
+  }>(
+    gitlabApiUrl(repo, `/repository/commits/${encodeURIComponent(sha)}`),
+    access.token,
+  );
+  const body = found.message.slice(found.title.length).trim();
+  return {
+    sha: found.id,
+    title: found.title,
+    body,
+    author: found.author_name || "unknown",
+    authoredAt: found.authored_date || "",
+    avatarUrl: "",
+    additions: found.stats?.additions ?? null,
+    deletions: found.stats?.deletions ?? null,
+    webUrl: found.web_url,
+  };
+}
+
 async function fetchText(
   url: string,
   label: string,

package/src/lib/grpc-reference.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from "vitest";
+import type { RpcMethod, RpcService } from "../catalog";
+import { grpcRequestJson, grpcurlCommand } from "./grpc-reference";
+
+const method: RpcMethod = {
+  name: "Create",
+  request: "CreateRequest",
+  response: "CreateResponse",
+};
+
+const provided: RpcService = {
+  id: "shop.v1.Orders",
+  source: "proto/shop/v1/orders.proto:10",
+  methods: [method],
+  enums: [
+    {
+      name: "Priority",
+      values: [
+        { name: "PRIORITY_UNSPECIFIED", number: 0 },
+        { name: "PRIORITY_HIGH", number: 1 },
+      ],
+    },
+  ],
+  messages: [
+    {
+      name: "CreateRequest",
+      fields: [
+        { name: "name", type: "string", doc: "" },
+        { name: "quantity", type: "int64", doc: "" },
+        { name: "expedited", type: "bool", doc: "" },
+        { name: "priority", type: "Priority", doc: "" },
+        { name: "lines", type: "[]Line", doc: "" },
+        { name: "when", type: "Timestamp", doc: "" },
+        { name: "money", type: "Money", ref: "Money", doc: "" },
+      ],
+    },
+    { name: "CreateResponse", fields: [] },
+  ],
+};
+
+describe("gRPC reference examples", () => {
+  it("builds a ProtoJSON request from scalars, enums, lists and shared defs", () => {
+    expect(JSON.parse(grpcRequestJson(provided, method, {
+      Money: {
+        fields: [
+          { name: "currency", type: "string", doc: "" },
+          { name: "minor", type: "int64", doc: "" },
+        ],
+      },
+    }))).toEqual({
+      name: "",
+      quantity: "0",
+      expedited: false,
+      priority: "PRIORITY_UNSPECIFIED",
+      lines: [],
+      when: "1970-01-01T00:00:00Z",
+      money: { currency: "", minor: "0" },
+    });
+  });
+
+  it("emits a ready-to-edit grpcurl command", () => {
+    const command = grpcurlCommand(provided, method, {});
+    expect(command).toContain("grpcurl -plaintext");
+    expect(command).toContain("localhost:50051");
+    expect(command).toContain("shop.v1.Orders/Create");
+    expect(command).toContain(`"quantity": "0"`);
+  });
+
+  it("falls back to an empty body when no request shape was extracted", () => {
+    expect(grpcRequestJson(provided, { name: "Ping" }, {})).toBe("{}");
+  });
+});

package/src/lib/grpc-reference.ts

@@ -0,0 +1,117 @@
+// Small, executable examples for a gRPC method.
+//
+// The protobuf extractor already leaves the catalog with enough information
+// to sketch a request. Keeping that derivation here means the reference UI
+// does not need to understand scalar mappings, recursive messages or shell
+// quoting, and it gives the generated command a focused test surface.
+
+import type { Field, RpcMethod, RpcService, TypeDef } from "../catalog";
+import { parseType } from "./shape";
+
+const NUMBER = new Set([
+  "double",
+  "float",
+  "int32",
+  "sint32",
+  "sfixed32",
+  "uint32",
+  "fixed32",
+]);
+const LONG = new Set([
+  "int64",
+  "sint64",
+  "sfixed64",
+  "uint64",
+  "fixed64",
+]);
+
+function shortName(name: string): string {
+  return name.split(".").at(-1) ?? name;
+}
+
+function fieldsFor(
+  provided: RpcService,
+  name: string,
+  ref: string | undefined,
+  defs: Record<string, TypeDef>,
+): Field[] | null {
+  if (ref && defs[ref]) return defs[ref].fields;
+  const bare = shortName(name);
+  return (
+    provided.messages?.find(
+      (message) => message.name === name || message.name === bare,
+    )?.fields ?? null
+  );
+}
+
+function valueFor(
+  provided: RpcService,
+  field: Field,
+  defs: Record<string, TypeDef>,
+  visiting: ReadonlySet<string>,
+): unknown {
+  const parsed = parseType(field.type);
+  if (parsed.cardinality === "many") return [];
+  if (parsed.cardinality === "map") return {};
+
+  const type = shortName(parsed.base);
+  if (type === "string" || type === "bytes") return "";
+  if (type === "bool") return false;
+  if (NUMBER.has(type)) return 0;
+  // ProtoJSON writes 64-bit integers as decimal strings so their precision is
+  // not lost in JavaScript.
+  if (LONG.has(type)) return "0";
+  if (type === "Timestamp") return "1970-01-01T00:00:00Z";
+  if (type === "Duration") return "0s";
+  if (type === "FieldMask") return "";
+  if (type === "Struct") return {};
+  if (type === "Value") return null;
+  if (type === "ListValue") return [];
+  if (type === "Empty") return {};
+  if (type === "Any") return { "@type": "" };
+
+  const set = provided.enums?.find(
+    (candidate) => candidate.name === parsed.base || candidate.name === type,
+  );
+  if (set) return set.values[0]?.name ?? "";
+
+  const nested = fieldsFor(provided, parsed.base, field.ref, defs);
+  if (!nested || visiting.has(parsed.base)) return {};
+
+  const next = new Set(visiting).add(parsed.base);
+  return Object.fromEntries(
+    nested.map((child) => [child.name, valueFor(provided, child, defs, next)]),
+  );
+}
+
+/** A valid ProtoJSON-shaped starting point for a method request. */
+export function grpcRequestJson(
+  provided: RpcService,
+  method: RpcMethod,
+  defs: Record<string, TypeDef>,
+): string {
+  if (!method.request) return "{}";
+  const fields = fieldsFor(provided, method.request, method.requestRef, defs);
+  if (!fields) return "{}";
+
+  const visiting = new Set([method.request]);
+  const value = Object.fromEntries(
+    fields.map((field) => [field.name, valueFor(provided, field, defs, visiting)]),
+  );
+  return JSON.stringify(value, null, 2);
+}
+
+/** A copyable local-development invocation. The endpoint is deliberately visible. */
+export function grpcurlCommand(
+  provided: RpcService,
+  method: RpcMethod,
+  defs: Record<string, TypeDef>,
+): string {
+  const body = grpcRequestJson(provided, method, defs).replace(/'/g, `'"'"'`);
+  return [
+    "grpcurl -plaintext \\",
+    `  -d '${body}' \\`,
+    "  localhost:50051 \\",
+    `  ${provided.id}/${method.name}`,
+  ].join("\n");
+}

package/src/lib/local-api.ts

@@ -1,4 +1,4 @@
-import type { SetupInfo, SetupPhase, SetupRunStepStatus } from "./setup-info";
+import type { SetupInfo, SetupPhase, SetupProject, SetupRunStepStatus } from "./setup-info";
 
 const ROOT = `${import.meta.env.BASE_URL}__portolan`;
 const LOCAL_HEADER = { "Content-Type": "application/json", "X-Portolan-Local": "1" };
@@ -18,6 +18,7 @@ export interface Discovery {
   truncated: boolean;
   components: Array<{ path: string; name: string; markers: string[]; technologies: string[] }>;
   componentsTruncated: boolean;
+  deployables: Array<{ slug: string; name: string; path: string; kind: "service"; confidence: "high" | "medium"; evidence: string[] }>;
   defaults: { id: string; name: string; group: string; component: string; context: string; service: string };
   detections: Detection[];
 }
@@ -35,13 +36,17 @@ export interface ProjectDraft {
   component: string;
   context?: string;
   service?: string;
+  contextName?: string;
+  contextSummary?: string;
+  classification?: "core" | "supporting" | "generic";
+  replaceStarter?: boolean;
   groupKind?: "bounded-context" | "system" | "product" | "team" | "namespace";
   componentKind?: "service" | "application" | "webapp" | "worker" | "job" | "function" | "cli" | "library" | "data-pipeline";
   plugins: string[];
 }
 
 export interface ProjectPlan {
-  project: { id: string; name: string; root: string; group?: string; component?: string; groupKind?: string; componentKind?: string; context?: string; service?: string; repository?: string };
+  project: { id: string; name: string; root: string; group?: string; component?: string; components?: string[]; groupKind?: string; componentKind?: string; context?: string; service?: string; repository?: string };
   plugins: string[];
   steps: Array<{ plugin: string; in: string; out: string; options: Record<string, unknown> }>;
   source: string;
@@ -196,15 +201,23 @@ export async function previewProject(draft: ProjectDraft): Promise<ProjectPlan>
   return json("/projects/preview", { method: "POST", headers: LOCAL_HEADER, body: JSON.stringify(draft) });
 }
 
-export async function addProject(draft: ProjectDraft): Promise<ProjectPlan & { setup: SetupInfo }> {
+export async function addProject(draft: ProjectDraft): Promise<ProjectPlan & { undoToken: string; setup: SetupInfo }> {
   return json("/projects", { method: "POST", headers: LOCAL_HEADER, body: JSON.stringify(draft) });
 }
 
+export async function removeProject(id: string): Promise<{ project: SetupProject; removedOutputs: string[]; undoToken: string; setup: SetupInfo }> {
+  return json(`/projects/${encodeURIComponent(id)}/remove`, { method: "POST", headers: LOCAL_HEADER, body: "{}" });
+}
+
+export async function undoProjectRemoval(undoToken: string): Promise<{ restored: true; setup: SetupInfo }> {
+  return json("/projects/removals/undo", { method: "POST", headers: LOCAL_HEADER, body: JSON.stringify({ undoToken }) });
+}
+
 export async function startProjectTrial(draft: ProjectDraft): Promise<{ runId: string; mode: "project-preview"; plan: ProjectPlan }> {
   return json("/projects/trials", { method: "POST", headers: LOCAL_HEADER, body: JSON.stringify(draft) });
 }
 
-export async function applyProjectTrial(runId: string, generate: boolean): Promise<ProjectPlan & { setup: SetupInfo; run: { runId: string; mode: "write" } | null }> {
+export async function applyProjectTrial(runId: string, generate: boolean): Promise<ProjectPlan & { undoToken: string; setup: SetupInfo; run: { runId: string; mode: "write" } | null }> {
   return json(`/projects/trials/${encodeURIComponent(runId)}/apply`, { method: "POST", headers: LOCAL_HEADER, body: JSON.stringify({ generate }) });
 }
 

package/src/lib/product.ts

@@ -0,0 +1,7 @@
+/** Canonical public pages for Portolan itself, not the catalog being viewed. */
+export const PRODUCT_REPOSITORY =
+  "https://github.com/shortlink-org/portolan";
+
+export const PRODUCT_README = `${PRODUCT_REPOSITORY}#readme`;
+export const PRODUCT_ISSUES = `${PRODUCT_REPOSITORY}/issues`;
+export const PRODUCT_LICENSE = `${PRODUCT_REPOSITORY}/blob/main/LICENSE`;

package/src/lib/queries.ts

@@ -16,7 +16,7 @@ import type { Catalog } from "../catalog";
 import { diffCatalogs } from "./catalog-diff";
 import type { Change } from "./catalog-diff";
 import { findRef } from "./forge-refs";
-import { listForgeRefs, loadForgeCatalog } from "./github-catalog";
+import { listForgeRefs, loadForgeCatalog, loadForgeCommit } from "./github-catalog";
 import type { ForgeRef, ForgeRepo } from "./github-catalog";
 import { localStatus } from "./local-api";
 import { loadSourceCode } from "./source-code";
@@ -30,6 +30,8 @@ export const forgeKeys = {
     ["forge", "refs", repo?.provider ?? "", repo?.webUrl ?? "", token] as const,
   comparison: (repo: ForgeRepo | null, token: string, baseSha: string, headSha: string) =>
     ["forge", "comparison", repo?.provider ?? "", repo?.webUrl ?? "", baseSha, headSha, token] as const,
+  commit: (repo: ForgeRepo | null, token: string, sha: string) =>
+    ["forge", "commit", repo?.provider ?? "", repo?.webUrl ?? "", sha, token] as const,
 };
 
 export const sourceKeys = {
@@ -56,6 +58,19 @@ export function forgeRefsQuery(repo: ForgeRepo | null, token: string) {
   });
 }
 
+/** One immutable commit, fetched only when its hover card is open. */
+export function forgeCommitQuery(repo: ForgeRepo | null, token: string, sha: string) {
+  return queryOptions({
+    queryKey: forgeKeys.commit(repo, token, sha),
+    queryFn: () => {
+      if (!repo) throw new Error("No forge repository is configured.");
+      return loadForgeCommit(repo, sha, { token });
+    },
+    enabled: repo !== null && Boolean(sha),
+    staleTime: Infinity,
+  });
+}
+
 /**
  * One side of a comparison: the name a reader typed, the commit it resolves
  * to, and the catalog itself when the side is the one this build was made

package/src/lib/readme-assets.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from "vitest";
+import { readmeAssetHref } from "./readme-assets";
+
+describe("readmeAssetHref", () => {
+  it("mounts README-relative files below the configured site base", () => {
+    expect(readmeAssetHref("vendor/repos/acme/shop", "./docs/example.png", "/catalog/")).toBe(
+      "/catalog/portolan-assets/vendor/repos/acme/shop/docs/example.png",
+    );
+    expect(readmeAssetHref("services/api", "docs/file.json#example", "/")).toBe(
+      "/portolan-assets/services/api/docs/file.json#example",
+    );
+  });
+
+  it("leaves remote, root-relative and escaping references alone", () => {
+    expect(readmeAssetHref("services/api", "https://example.com/image.png")).toBeNull();
+    expect(readmeAssetHref("services/api", "/logo.svg")).toBeNull();
+    expect(readmeAssetHref("services/api", "../secret.png")).toBeNull();
+  });
+});

package/src/lib/readme-assets.ts

@@ -0,0 +1,34 @@
+/** Turn a README-relative file into the public asset staged beside the app. */
+export function readmeAssetHref(
+  root: string,
+  target: string,
+  base = "/",
+): string | null {
+  const value = target.trim();
+  if (
+    !value ||
+    value.startsWith("#") ||
+    value.startsWith("/") ||
+    /^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(value)
+  ) return null;
+
+  const suffixAt = value.search(/[?#]/);
+  const pathname = suffixAt < 0 ? value : value.slice(0, suffixAt);
+  const suffix = suffixAt < 0 ? "" : value.slice(suffixAt);
+  const rootParts = root.replaceAll("\\", "/").split("/").filter(Boolean);
+  const parts = [...rootParts];
+  for (const part of pathname.replaceAll("\\", "/").split("/")) {
+    if (!part || part === ".") continue;
+    if (part === "..") {
+      if (parts.length === rootParts.length) return null;
+      parts.pop();
+      continue;
+    }
+    try { parts.push(decodeURIComponent(part)); }
+    catch { return null; }
+  }
+  if (parts.length === rootParts.length) return null;
+
+  const prefix = base.endsWith("/") ? base : `${base}/`;
+  return `${prefix}portolan-assets/${parts.map((part) => encodeURIComponent(part)).join("/")}${suffix}`;
+}

package/src/lib/setup-info.test.ts

@@ -91,6 +91,13 @@ describe("publicSetupFrom", () => {
     });
   });
 
+  it("publishes the deployable components of one repository", () => {
+    const setup = publicSetupFrom({
+      projects: [{ id: "platform", name: "Platform", root: "platform", group: "platform", components: ["api", "billing", "book", "user"] }],
+    });
+    expect(setup.projects[0]?.components).toEqual(["api", "billing", "book", "user"]);
+  });
+
   it("claims the sandbox only for a plugin that declares a module", () => {
     const setup = publicSetupFrom({
       plugins: [

package/src/lib/setup-info.ts

@@ -17,6 +17,7 @@ export interface SetupProject {
   service?: string;
   group?: string;
   component?: string;
+  components?: string[];
   groupKind?: string;
   componentKind?: string;
   repository?: string;
@@ -99,6 +100,7 @@ interface ManifestProject {
   service?: unknown;
   group?: unknown;
   component?: unknown;
+  components?: unknown;
   groupKind?: unknown;
   componentKind?: unknown;
   repository?: unknown;
@@ -289,6 +291,9 @@ function projectFrom(value: unknown): SetupProject | null {
     ...(typeof item.service === "string" ? { service: item.service } : {}),
     ...(typeof item.group === "string" ? { group: item.group } : {}),
     ...(typeof item.component === "string" ? { component: item.component } : {}),
+    ...(array(item.components).every((component) => typeof component === "string") && array(item.components).length > 0
+      ? { components: array(item.components) as string[] }
+      : {}),
     ...(typeof item.groupKind === "string" ? { groupKind: item.groupKind } : {}),
     ...(typeof item.componentKind === "string" ? { componentKind: item.componentKind } : {}),
     ...(repository ? { repository } : {}),