@shortlink-org/portolan 0.2.1 → 0.2.3

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;
@@ -65,10 +70,20 @@ export interface GeneratedFileDiff {
 }
 
 export type DeliveryProvider = "github" | "gitlab";
+export type DeliveryFeatureId = "check" | "diff" | "sarif" | "pages";
+
+export interface DeliveryFeature {
+  id: DeliveryFeatureId;
+  label: string;
+  description: string;
+  selected: boolean;
+  available: boolean;
+  requires: DeliveryFeatureId[];
+}
 
 export interface DeliveryPresetFile {
   path: string;
-  status: "added" | "changed" | "unchanged" | "conflict";
+  status: "added" | "changed" | "removed" | "unchanged" | "conflict";
   diff: string;
   message?: string;
 }
@@ -81,7 +96,7 @@ export interface DeliveryPreset {
   defaultBranch: string;
   status: "available" | "installed" | "update" | "conflict";
   revision: string;
-  features: string[];
+  features: DeliveryFeature[];
   files: DeliveryPresetFile[];
 }
 
@@ -163,16 +178,18 @@ export async function localStatus(): Promise<{ local: true; workspace: string; s
   return json("/status");
 }
 
-export async function previewDeliveryPreset(provider?: DeliveryProvider): Promise<DeliveryPreset> {
-  const query = provider ? `?provider=${encodeURIComponent(provider)}` : "";
-  return json(`/delivery-presets${query}`);
+export async function previewDeliveryPreset(provider?: DeliveryProvider, features?: DeliveryFeatureId[]): Promise<DeliveryPreset> {
+  const query = new URLSearchParams();
+  if (provider) query.set("provider", provider);
+  if (features) query.set("features", features.join(","));
+  return json(`/delivery-presets${query.size ? `?${query}` : ""}`);
 }
 
-export async function installDeliveryPreset(provider: DeliveryProvider, revision: string): Promise<DeliveryPreset & { written: string[] }> {
+export async function installDeliveryPreset(provider: DeliveryProvider, revision: string, features: DeliveryFeatureId[]): Promise<DeliveryPreset & { written: string[] }> {
   return json("/delivery-presets/install", {
     method: "POST",
     headers: LOCAL_HEADER,
-    body: JSON.stringify({ provider, revision }),
+    body: JSON.stringify({ provider, revision, features }),
   });
 }
 
@@ -196,15 +213,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/motion.test.ts

@@ -102,10 +102,12 @@ describe("presence", () => {
     expect(rise.initial.y).toBe(8);
   });
 
-  it("a page arrives on the page duration and leaves faster, opacity only", () => {
+  it("a page rises in and lifts out faster", () => {
     expect(page.animate.transition).toBe(transitions.page);
     expect(page.exit.transition).toBe(transitions.micro);
-    expect(Object.keys(page.exit)).toEqual(["opacity", "transition"]);
+    expect(page.initial.y).toBe(8);
+    expect(page.animate.y).toBe(0);
+    expect(page.exit.y).toBe(-4);
   });
 
   it("scaleIn grows the two percent palette-in grows", () => {

package/src/lib/motion.tsx

@@ -91,14 +91,15 @@ export const scaleIn: Presence = {
 };
 
 /**
- * A route: rises the eight pixels on the page duration, and leaves on the
- * micro duration, opacity only. The reader has already asked for the next
- * page; the old one should be out of the way, not making an exit.
+ * A route: rises the eight pixels on the page duration while the old page
+ * lifts four pixels and fades on the micro duration. Route presence uses
+ * `popLayout`, so those two short movements overlap instead of inserting a
+ * blank beat between pages.
  */
 export const page: Presence = {
   initial: { opacity: 0, y: 8 },
   animate: { opacity: 1, y: 0, transition: transitions.page },
-  exit: { opacity: 0, transition: transitions.micro },
+  exit: { opacity: 0, y: -4, transition: transitions.micro },
 };
 
 /** A row, a toast: rises the same eight pixels a page rises. */

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/proto-problems.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { buildIndex, type Catalog, type Service } from "../catalog";
+import type { Catalog, CatalogIndex, Service } from "../catalog";
 import { protoProblems } from "./proto-problems";
 
 function service(id: string, overrides: Partial<Service> = {}): Service {
@@ -43,8 +43,39 @@ const pricing = () =>
     provides: [
       {
         id: "pricing.v1.Pricing",
-        methods: [{ name: "GetQuote" }],
+        methods: [
+          {
+            name: "GetQuote",
+            request: "GetQuoteRequest",
+            response: "Quote",
+          },
+        ],
         source: "proto/pricing/v1/pricing.proto:7",
+        messages: [
+          {
+            name: "GetQuoteRequest",
+            fields: [
+              { name: "sku", type: "string", number: 1, doc: "" },
+              { name: "locale", type: "string", number: 2, doc: "" },
+            ],
+          },
+          {
+            name: "Quote",
+            fields: [
+              { name: "amount", type: "int64", number: 1, doc: "" },
+              { name: "status", type: "QuoteStatus", number: 2, doc: "" },
+            ],
+          },
+        ],
+        enums: [
+          {
+            name: "QuoteStatus",
+            values: [
+              { name: "QUOTE_STATUS_UNSPECIFIED", number: 0 },
+              { name: "QUOTE_STATUS_READY", number: 1 },
+            ],
+          },
+        ],
       },
     ],
   });
@@ -61,8 +92,75 @@ const calling = (id: string, status: "declared" | "unresolved" = "declared") =>
     ],
   });
 
+const copiedPricing = (overrides = {}) =>
+  service("shop.oms", {
+    consumes: [
+      {
+        id: "pricing.v1.Pricing/GetQuote",
+        peer: "shop.pricing",
+        status: "declared",
+        source: "internal/infrastructure/pricing/pricing.proto:8",
+      },
+    ],
+    copies: [
+      {
+        id: "pricing.v1.Pricing",
+        methods: [
+          {
+            name: "GetQuote",
+            request: "GetQuoteRequest",
+            response: "Quote",
+          },
+        ],
+        source: "internal/infrastructure/pricing/pricing.proto:7",
+        messages: [
+          {
+            name: "GetQuoteRequest",
+            fields: [{ name: "sku", type: "string", number: 1, doc: "" }],
+          },
+          {
+            name: "Quote",
+            fields: [
+              { name: "amount", type: "int64", number: 1, doc: "" },
+              { name: "status", type: "QuoteStatus", number: 2, doc: "" },
+            ],
+          },
+        ],
+        enums: [
+          {
+            name: "QuoteStatus",
+            values: [
+              { name: "QUOTE_STATUS_UNSPECIFIED", number: 0 },
+              { name: "QUOTE_STATUS_READY", number: 1 },
+            ],
+          },
+        ],
+        ...overrides,
+      },
+    ],
+  });
+
 function found(catalog: Catalog) {
-  return protoProblems(catalog, buildIndex(catalog));
+  const serviceById = new Map<string, Service>();
+  const serviceContext = new Map<string, Catalog["contexts"][number]>();
+  const rpcProviderByMethod = new Map<string, Service>();
+  for (const context of catalog.contexts) {
+    for (const item of context.services) {
+      serviceById.set(item.id, item);
+      serviceContext.set(item.id, context);
+      for (const provided of item.provides) {
+        for (const method of provided.methods) {
+          rpcProviderByMethod.set(`${provided.id}/${method.name}`, item);
+        }
+      }
+    }
+  }
+  const index = {
+    serviceById,
+    serviceContext,
+    rpcProviderByMethod,
+  } as CatalogIndex;
+  return protoProblems(catalog, index);
 }
 
 describe("protoProblems", () => {
@@ -118,4 +216,73 @@ describe("protoProblems", () => {
   it("finds nothing in a catalog where nobody calls anybody", () => {
     expect(found(catalogWith([pricing()]))).toEqual([]);
   });
+
+  it("accepts a narrowed copy whose retained fields and enum agree", () => {
+    expect(found(catalogWith([pricing(), copiedPricing()]))).toEqual([]);
+  });
+
+  it("reports copied fields whose type, number, or existence drifted", () => {
+    const caller = copiedPricing({
+      messages: [
+        {
+          name: "GetQuoteRequest",
+          fields: [
+            { name: "sku", type: "bytes", number: 3, doc: "" },
+            { name: "currency", type: "string", number: 4, doc: "" },
+          ],
+        },
+      ],
+    });
+
+    const problems = found(catalogWith([pricing(), caller]));
+
+    expect(problems).toHaveLength(1);
+    expect(problems[0]).toMatchObject({
+      kind: "proto-drift",
+      severity: "warning",
+      service: "shop.oms",
+      id: "pricing.v1.Pricing",
+      peer: "shop.pricing",
+    });
+    expect(problems[0]?.note).toContain("GetQuoteRequest.sku is bytes");
+    expect(problems[0]?.note).toContain("GetQuoteRequest.sku is field 3");
+    expect(problems[0]?.note).toContain(
+      "GetQuoteRequest.currency is absent from the provider",
+    );
+  });
+
+  it("reports enum values added, removed, or renumbered", () => {
+    const caller = copiedPricing({
+      enums: [
+        {
+          name: "QuoteStatus",
+          values: [
+            { name: "QUOTE_STATUS_UNSPECIFIED", number: 0 },
+            { name: "QUOTE_STATUS_READY", number: 7 },
+            { name: "QUOTE_STATUS_OLD", number: 1 },
+          ],
+        },
+      ],
+    });
+
+    const [problem] = found(catalogWith([pricing(), caller]));
+
+    expect(problem?.note).toContain("QUOTE_STATUS_READY is 7, provider has 1");
+    expect(problem?.note).toContain("QUOTE_STATUS_OLD is absent from the provider");
+  });
+
+  it("reports an enum value present only in the provider", () => {
+    const caller = copiedPricing({
+      enums: [
+        {
+          name: "QuoteStatus",
+          values: [{ name: "QUOTE_STATUS_UNSPECIFIED", number: 0 }],
+        },
+      ],
+    });
+
+    const [problem] = found(catalogWith([pricing(), caller]));
+
+    expect(problem?.note).toContain("QUOTE_STATUS_READY is missing from the copy");
+  });
 });

package/src/lib/proto-problems.ts

@@ -2,8 +2,9 @@
 //
 // docs/adr/org.0001.md promises this: producers publish their schema, consumers
 // keep a narrowed copy, and "a field, method or enum value that differs between
-// the two is reported against the consuming service". This is the first half of
-// that promise - a call naming a method no provider declares.
+// the two is reported against the consuming service". The extractor retains
+// those copies on the consumer; this reader compares them after every source
+// has met in the merged catalog.
 //
 // It is deliberately NOT done in the merge. src/merge.ts is documented as
 // union-by-id plus first-non-empty and nothing else, and teaching it to compare
@@ -16,11 +17,20 @@
 // is about a call whose peer is known and whose METHOD is not - the copy is
 // stale, or the producer removed something, and the two are different repairs.
 
-import type { Catalog, CatalogIndex } from "../catalog";
+import type {
+  Catalog,
+  CatalogIndex,
+  RpcEnum,
+  RpcMessage,
+  RpcMethod,
+  RpcService,
+  Service,
+} from "../catalog";
 import type { Problem } from "./derive";
 
 /**
- * Every call that names a method no interface in the catalog declares.
+ * Every missing method and every retained consumer descriptor that disagrees
+ * with the provider's method, field, or enum value.
  *
  * An unresolved call is skipped: it already has a problem of its own from
  * `problems()`, and reporting the same edge twice under two headings would make
@@ -58,8 +68,170 @@ export function protoProblems(
           source: call.source,
         });
       }
+
+      for (const copy of service.copies ?? []) {
+        const drift = driftAgainstProvider(service, copy, index);
+        if (drift) out.push(drift);
+      }
     }
   }
 
   return out;
 }
+
+/** Compare one consumer copy only when one of its calls resolves to a provider. */
+function driftAgainstProvider(
+  consumer: Service,
+  copy: RpcService,
+  index: CatalogIndex,
+): Problem | undefined {
+  const calls = new Map(
+    consumer.consumes
+      .filter((call) => call.id.startsWith(`${copy.id}/`))
+      .map((call) => [call.id, call]),
+  );
+  const resolved = copy.methods
+    .map((method) => calls.get(`${copy.id}/${method.name}`))
+    .find(
+      (call) =>
+        call?.status !== "unresolved" && index.serviceById.has(call?.peer ?? ""),
+    );
+  if (!resolved) return undefined;
+
+  const providerService = index.serviceById.get(resolved.peer);
+  const provider = providerService?.provides.find(
+    (candidate) => candidate.id === copy.id,
+  );
+  if (!providerService || !provider) return undefined;
+
+  const differences = compareInterfaces(copy, provider);
+  if (differences.length === 0) return undefined;
+
+  return {
+    kind: "proto-drift",
+    severity: "warning",
+    context: index.serviceContext.get(consumer.id)?.id ?? "",
+    service: consumer.id,
+    id: copy.id,
+    peer: providerService.id,
+    note: `Vendored copy differs from ${providerService.id}: ${differences.join("; ")}.`,
+    source: copy.source,
+  };
+}
+
+function compareInterfaces(copy: RpcService, provider: RpcService): string[] {
+  const out: string[] = [];
+  const methods = new Map(provider.methods.map((method) => [method.name, method]));
+
+  for (const method of copy.methods) {
+    const actual = methods.get(method.name);
+    // A missing method already has the stronger proto-missing error.
+    if (!actual) continue;
+    compareMethod(method, actual, out);
+  }
+
+  const messages = new Map(
+    (provider.messages ?? []).map((message) => [message.name, message]),
+  );
+  for (const message of copy.messages ?? []) {
+    compareMessage(message, messages.get(message.name), out);
+  }
+
+  const enums = new Map(
+    (provider.enums ?? []).map((item) => [item.name, item]),
+  );
+  for (const item of copy.enums ?? []) {
+    compareEnum(item, enums.get(item.name), out);
+  }
+
+  return out;
+}
+
+function compareMethod(
+  copy: RpcMethod,
+  provider: RpcMethod,
+  out: string[],
+): void {
+  for (const side of ["request", "response"] as const) {
+    if (copy[side] !== provider[side]) {
+      out.push(
+        `${copy.name} ${side} is ${copy[side] || "unnamed"}, provider has ${provider[side] || "unnamed"}`,
+      );
+    }
+  }
+  if (copy.streaming !== provider.streaming) {
+    out.push(
+      `${copy.name} streaming is ${copy.streaming ?? "unary"}, provider has ${provider.streaming ?? "unary"}`,
+    );
+  }
+}
+
+/**
+ * A narrowed copy may omit provider fields it does not read. Every field it
+ * does carry must still have the provider's type and protobuf number.
+ */
+function compareMessage(
+  copy: RpcMessage,
+  provider: RpcMessage | undefined,
+  out: string[],
+): void {
+  if (!provider) {
+    out.push(`message ${copy.name} is absent from the provider`);
+    return;
+  }
+
+  const fields = new Map(provider.fields.map((field) => [field.name, field]));
+  for (const field of copy.fields) {
+    const actual = fields.get(field.name);
+    if (!actual) {
+      out.push(`${copy.name}.${field.name} is absent from the provider`);
+      continue;
+    }
+    if (field.type !== actual.type) {
+      out.push(
+        `${copy.name}.${field.name} is ${field.type}, provider has ${actual.type}`,
+      );
+    }
+    if (
+      field.number !== undefined &&
+      actual.number !== undefined &&
+      field.number !== actual.number
+    ) {
+      out.push(
+        `${copy.name}.${field.name} is field ${field.number}, provider has ${actual.number}`,
+      );
+    }
+  }
+}
+
+/** Enum names and numbers are both wire claims, so the sets must match whole. */
+function compareEnum(
+  copy: RpcEnum,
+  provider: RpcEnum | undefined,
+  out: string[],
+): void {
+  if (!provider) {
+    out.push(`enum ${copy.name} is absent from the provider`);
+    return;
+  }
+
+  const copyByName = new Map(copy.values.map((value) => [value.name, value]));
+  const providerByName = new Map(
+    provider.values.map((value) => [value.name, value]),
+  );
+  for (const value of copy.values) {
+    const actual = providerByName.get(value.name);
+    if (!actual) {
+      out.push(`${copy.name}.${value.name} is absent from the provider`);
+    } else if (value.number !== actual.number) {
+      out.push(
+        `${copy.name}.${value.name} is ${value.number}, provider has ${actual.number}`,
+      );
+    }
+  }
+  for (const value of provider.values) {
+    if (!copyByName.has(value.name)) {
+      out.push(`${copy.name}.${value.name} is missing from the copy`);
+    }
+  }
+}

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: [