@shortlink-org/portolan 0.2.2 → 0.2.3

package/src/components/{PageHeader.test.ts → PageHeader.test.tsx}

@@ -1,4 +1,3 @@
-import { createElement } from "react";
 import { renderToStaticMarkup } from "react-dom/server";
 import { describe, expect, it } from "vitest";
 
@@ -6,15 +5,15 @@ import { CapabilityEmpty } from "./PageHeader";
 
 describe("CapabilityEmpty", () => {
   it("keeps the explanation, action and evidence signal together", () => {
-    const markup = renderToStaticMarkup(createElement(
-      CapabilityEmpty,
-      {
-        title: "No dependency graph yet",
-        actions: createElement("button", { type: "button" }, "Review extraction"),
-        signal: "Signals: domain events and consumers.",
-      },
-      "The catalog has components, but no events to connect.",
-    ));
+    const markup = renderToStaticMarkup(
+      <CapabilityEmpty
+        title="No dependency graph yet"
+        actions={<button type="button">Review extraction</button>}
+        signal="Signals: domain events and consumers."
+      >
+        The catalog has components, but no events to connect.
+      </CapabilityEmpty>,
+    );
 
     expect(markup).toContain("next useful step");
     expect(markup).toContain("No dependency graph yet");

package/src/components/ProblemRow.tsx

@@ -27,6 +27,7 @@ const KIND_OF: Record<Problem["kind"], "service" | "event" | "table"> = {
   "column-type": "table",
   "outbox-payload": "table",
   "proto-missing": "service",
+  "proto-drift": "service",
   "shared-channel": "event",
   "channel-undeclared": "event",
   "channel-unpublished": "service",
@@ -44,6 +45,7 @@ const KIND_NOTE: Record<Problem["kind"], string> = {
   "outbox-payload": "an outbox with no payload column",
   "proto-missing":
     "the provider is in the catalog but answers on no such method",
+  "proto-drift": "the vendored proto and provider schema disagree",
   "shared-channel": "a second service publishes on this channel",
   "channel-undeclared":
     "this event goes out on a channel the service does not declare",
@@ -60,6 +62,7 @@ function nearPath(problem: Problem): string | null {
     // peer is nobody; this is a call whose peer is known and whose method is
     // not - and in both the thing to go and look at is the caller.
     case "proto-missing":
+    case "proto-drift":
       return servicePath(problem.service);
     case "consumer":
     case "channel-undeclared":

package/src/components/SourcePreview.tsx

@@ -106,7 +106,7 @@ function AccessForm({
         <button
           type="submit"
           disabled={!draft.trim()}
-          className="btn-accent shrink-0 disabled:opacity-40"
+          className="product-primary shrink-0 disabled:opacity-40"
         >
           {connected ? "Replace token" : "Connect"}
         </button>

package/src/index.css

@@ -573,22 +573,6 @@
     background: color-mix(in srgb, var(--accent) 10%, transparent);
   }
 
-  /* Sanctioned gradient 2 - the accent surface. Reserved for a primary button;
-     white on --accent-lo clears 4.5:1 in both themes. */
-  .btn-accent {
-    @apply mono flex items-center gap-1.5 rounded-control px-3 py-1.5;
-    color: #fff;
-    background-image: linear-gradient(
-      to bottom,
-      var(--accent-hi),
-      var(--accent-lo)
-    );
-    transition: filter var(--dur-micro) var(--ease-out);
-  }
-  .btn-accent:hover {
-    filter: brightness(1.06);
-  }
-
   /* The landing's primary action should feel like a control from the map,
      not a bright rectangle pasted over it. The depth is always present; the
      brief chart-line sweep only appears when a reader points at the action. */
@@ -697,7 +681,6 @@
     outline: 2px solid color-mix(in srgb, var(--accent) 55%, white);
     outline-offset: 3px;
   }
-  .btn-accent:disabled,
   .product-primary:disabled,
   .tbtn:disabled {
     cursor: not-allowed;

package/src/landing/LandingPage.tsx

@@ -97,7 +97,7 @@ function Header() {
           >
             <GitBranch size={15} /> GitHub
           </a>
-          <Link to={exampleTo} className="btn-accent landing-primary">
+          <Link to={exampleTo} className="landing-primary">
             Explore example <ArrowRight size={14} />
           </Link>
         </div>
@@ -319,7 +319,7 @@ export function LandingPage() {
               >
                 <Link
                   to={exampleTo}
-                  className="btn-accent landing-primary px-4 py-2.5"
+                  className="landing-primary px-4 py-2.5"
                 >
                   Explore example catalog <ArrowRight size={15} />
                 </Link>
@@ -647,7 +647,7 @@ export function LandingPage() {
               <div className="mt-4 flex flex-wrap gap-3">
                 <Link
                   to={exampleTo}
-                  className="btn-accent landing-primary px-4 py-2.5"
+                  className="landing-primary px-4 py-2.5"
                 >
                   Open the example <ArrowRight size={15} />
                 </Link>
@@ -719,7 +719,7 @@ export function LandingPage() {
             <div className="mt-8 flex flex-wrap justify-center gap-3">
               <Link
                 to={exampleTo}
-                className="btn-accent landing-primary px-4 py-2.5"
+                className="landing-primary px-4 py-2.5"
               >
                 Explore example catalog <ArrowRight size={15} />
               </Link>

package/src/lib/all-problems.ts

@@ -1,7 +1,7 @@
 // Every reading the catalog makes of itself, in one list.
 //
 // Four readers, each answering a different question: edges that resolve to
-// nothing, schemas that name a method the module lacks, tables and columns
+// nothing, producer and consumer schemas that disagree, tables and columns
 // that disagree with the model, and channels that documents and events do not
 // agree on. The problems page, the overview and the landing all want the
 // union, errors first - a boundary leak is not the same kind of news as a

package/src/lib/derive.ts

@@ -420,6 +420,7 @@ export type ProblemKind =
   | "column-type"
   | "outbox-payload"
   | "proto-missing"
+  | "proto-drift"
   | "shared-channel"
   | "channel-undeclared"
   | "channel-unpublished"

package/src/lib/local-api.ts

@@ -70,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;
 }
@@ -86,7 +96,7 @@ export interface DeliveryPreset {
   defaultBranch: string;
   status: "available" | "installed" | "update" | "conflict";
   revision: string;
-  features: string[];
+  features: DeliveryFeature[];
   files: DeliveryPresetFile[];
 }
 
@@ -168,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 }),
   });
 }
 

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/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`);
+    }
+  }
+}