pi-outpost 0.32.4 → 0.34.0

package/dist/contract/validate-structured-exchange.mjs

@@ -13,7 +13,10 @@ import path2 from "node:path";
 var STRUCTURED_EXCHANGE_SCHEMA_V1 = "urn:structured-exchange:1";
 var PROPOSABLE_KINDS = ["graph", "sequence"];
 function proposableKinds(schema2) {
-  return schema2 === STRUCTURED_EXCHANGE_SCHEMA_V2 ? ["graph", "sequence", "table"] : PROPOSABLE_KINDS;
+  return isEnrichedSchema(schema2) ? ["graph", "sequence", "table"] : PROPOSABLE_KINDS;
+}
+function isEnrichedSchema(schema2) {
+  return schema2 === STRUCTURED_EXCHANGE_SCHEMA_V2 || schema2 === STRUCTURED_EXCHANGE_SCHEMA_V3;
 }
 function readTableRow(row) {
   if (Array.isArray(row)) return { cells: row };
@@ -95,9 +98,11 @@ var STRUCTURED_EXCHANGE_CEILINGS_2 = {
   viewpointConcern: 500
 };
 var STRUCTURED_EXCHANGE_BYTES_CEILING_2 = 8e6;
+var STRUCTURED_EXCHANGE_SCHEMA_V3 = "urn:structured-exchange:3";
 var STRUCTURED_EXCHANGE_SUPPORTED_SCHEMAS = [
   STRUCTURED_EXCHANGE_SCHEMA_V1,
-  STRUCTURED_EXCHANGE_SCHEMA_V2
+  STRUCTURED_EXCHANGE_SCHEMA_V2,
+  STRUCTURED_EXCHANGE_SCHEMA_V3
 ];
 function supportedSchemaOf(declared) {
   return STRUCTURED_EXCHANGE_SUPPORTED_SCHEMAS.find((supported2) => supported2 === declared);
@@ -110,7 +115,7 @@ var STRUCTURED_EXCHANGE_BYTES_CEILING_ANY = Math.max(
   STRUCTURED_EXCHANGE_BYTES_CEILING_2
 );
 function bytesCeilingFor(declared) {
-  return declared === STRUCTURED_EXCHANGE_SCHEMA_V2 ? STRUCTURED_EXCHANGE_BYTES_CEILING_2 : STRUCTURED_EXCHANGE_BYTES_CEILING;
+  return isEnrichedSchema(declared) ? STRUCTURED_EXCHANGE_BYTES_CEILING_2 : STRUCTURED_EXCHANGE_BYTES_CEILING;
 }
 var utf8Bytes = (value) => new TextEncoder().encode(value).length;
 function ceilingFor(bound) {
@@ -174,11 +179,339 @@ function measureAccepted(envelope, serialized) {
   return { kind: envelope.kind, bytes: utf8Bytes(serialized), counts };
 }
 
+// shared/src/structuredExchangeTimeline.ts
+var MS_PER_DAY = 864e5;
+var CALENDAR_DATE = /^(\d{4})-(\d{2})-(\d{2})$/;
+function dayNumber(date) {
+  const match = CALENDAR_DATE.exec(date);
+  if (match === null) return void 0;
+  const [year, month, day] = [Number(match[1]), Number(match[2]), Number(match[3])];
+  const instant = new Date(Date.UTC(year, month - 1, day));
+  instant.setUTCFullYear(year, month - 1, day);
+  if (instant.getUTCFullYear() !== year || instant.getUTCMonth() !== month - 1 || instant.getUTCDate() !== day) {
+    return void 0;
+  }
+  return Math.round(instant.getTime() / MS_PER_DAY);
+}
+function itemDays(item) {
+  const start = dayNumber(item.type === "activity" ? item.start : item.date);
+  const end = dayNumber(item.type === "activity" ? item.end : item.date);
+  return start === void 0 || end === void 0 ? void 0 : { start, end };
+}
+function timelineEndpoints(data) {
+  const endpoints = /* @__PURE__ */ new Map();
+  data.rows.forEach((row, rowIndex) => {
+    if (row.type !== "task") return;
+    if (!endpoints.has(row.id)) endpoints.set(row.id, { id: row.id, type: "task", row: rowIndex, days: taskDays(row) });
+    row.items.forEach((item, itemIndex) => {
+      if (item.id === void 0 || endpoints.has(item.id)) return;
+      endpoints.set(item.id, { id: item.id, type: item.type, row: rowIndex, item: itemIndex, days: itemDays(item) });
+    });
+  });
+  return endpoints;
+}
+function taskDays(task) {
+  let span;
+  for (const item of task.items) {
+    const days = itemDays(item);
+    if (days === void 0) continue;
+    span = span === void 0 ? { ...days } : { start: Math.min(span.start, days.start), end: Math.max(span.end, days.end) };
+  }
+  return span;
+}
+function dependencyType(dependency) {
+  return dependency.type ?? "finish-to-start";
+}
+var TIMELINE_TODAY_BAND = 18;
+var TIMELINE_YEAR_BAND = 20;
+var TIMELINE_MONTH_BAND = 20;
+var TIMELINE_HEADER_HEIGHT = TIMELINE_TODAY_BAND + TIMELINE_YEAR_BAND + TIMELINE_MONTH_BAND;
+
+// shared/src/structuredExchangeTimelineValidation.ts
+function timelineIssues(data) {
+  const issues = [];
+  const day = (value, at) => {
+    const found = dayNumber(value);
+    if (found === void 0) {
+      issues.push({ rule: "invalid-date", path: at, message: `"${value}" is not a day of the calendar` });
+    }
+    return found;
+  };
+  const rangeStart = day(data.time.start, "/data/time/start");
+  const rangeEnd = day(data.time.end, "/data/time/end");
+  const range = rangeStart !== void 0 && rangeEnd !== void 0 && rangeStart <= rangeEnd ? { start: rangeStart, end: rangeEnd } : void 0;
+  if (rangeStart !== void 0 && rangeEnd !== void 0 && rangeStart > rangeEnd) {
+    issues.push({
+      rule: "inverted-range",
+      path: "/data/time",
+      message: `the timeline starts on ${data.time.start}, after it ends on ${data.time.end}`
+    });
+  }
+  const declaredRange = `${data.time.start} to ${data.time.end}`;
+  const seen = /* @__PURE__ */ new Map();
+  const identify = (id, at) => {
+    if (id === void 0) return;
+    const first = seen.get(id);
+    if (first === void 0) seen.set(id, at);
+    else {
+      issues.push({
+        rule: "duplicate-identifier",
+        path: `${at}/id`,
+        message: `identifier "${id}" is already declared at ${first}`
+      });
+    }
+  };
+  const compared = data.comparedTo !== void 0;
+  if (data.comparedTo?.date !== void 0) day(data.comparedTo.date, "/data/comparedTo/date");
+  const withoutReference = (at) => issues.push({
+    rule: "comparison-without-reference",
+    path: at,
+    message: "previous dates and change roles describe a comparison; declare `comparedTo` naming the plan they compare with"
+  });
+  const kinds = /* @__PURE__ */ new Set();
+  data.rows.forEach((row, rowIndex) => {
+    if (row.type !== "task") return;
+    const rowAt = `/data/rows/${rowIndex}`;
+    identify(row.id, rowAt);
+    if (row.role !== void 0 && !compared) withoutReference(`${rowAt}/role`);
+    row.items.forEach((item, itemIndex) => {
+      const at = `${rowAt}/items/${itemIndex}`;
+      identify(item.id, at);
+      if (item.kind !== void 0) kinds.add(item.kind);
+      if (item.role !== void 0 && !compared) withoutReference(`${at}/role`);
+      if (item.previous !== void 0) {
+        if (!compared) withoutReference(`${at}/previous`);
+        if (item.role !== void 0 || row.role !== void 0) {
+          issues.push({
+            rule: "contradictory-change",
+            path: `${at}/previous`,
+            message: `an item that is ${item.role ?? `in a task that is ${row.role}`} has no previous dates; it is new or dropped, not moved`
+          });
+        }
+        const previous = item.previous;
+        const before = item.type === "activity" ? { first: day(previous.start, `${at}/previous/start`), last: day(previous.end, `${at}/previous/end`) } : (() => {
+          const only = day(previous.date, `${at}/previous/date`);
+          return { first: only, last: only };
+        })();
+        if (before.first !== void 0 && before.last !== void 0) {
+          if (before.first > before.last) {
+            issues.push({ rule: "inverted-range", path: `${at}/previous`, message: `the previous dates start on ${previous.start}, after they end on ${previous.end}` });
+          } else if (range !== void 0 && (before.first < range.start || before.last > range.end)) {
+            issues.push({
+              rule: "item-outside-range",
+              path: `${at}/previous`,
+              message: `the previous dates fall outside the timeline's range ${declaredRange}; the range covers both plans, so widen \`time\``
+            });
+          }
+        }
+      }
+      if (item.role !== void 0 && row.role !== void 0 && item.role !== row.role) {
+        issues.push({
+          rule: "contradictory-change",
+          path: `${at}/role`,
+          message: `an item ${item.role} in a task that is ${row.role}`
+        });
+      }
+      let first;
+      let last;
+      if (item.type === "activity") {
+        first = day(item.start, `${at}/start`);
+        last = day(item.end, `${at}/end`);
+        if (first !== void 0 && last !== void 0 && first > last) {
+          issues.push({
+            rule: "inverted-range",
+            path: at,
+            message: `the activity starts on ${item.start}, after it ends on ${item.end}`
+          });
+          return;
+        }
+      } else {
+        first = last = day(item.date, `${at}/date`);
+      }
+      if (range === void 0 || first === void 0 || last === void 0) return;
+      if (first < range.start || last > range.end) {
+        issues.push({
+          rule: "item-outside-range",
+          path: at,
+          message: item.type === "activity" ? `the activity runs ${item.start} to ${item.end}, outside the timeline's range ${declaredRange}; widen \`time\` or move the activity` : `the milestone falls on ${item.date}, outside the timeline's range ${declaredRange}; widen \`time\` or move the milestone`
+        });
+      }
+    });
+  });
+  (data.periods ?? []).forEach((period, index3) => {
+    const at = `/data/periods/${index3}`;
+    if (period.kind !== void 0) kinds.add(period.kind);
+    const first = day(period.start, `${at}/start`);
+    const last = day(period.end, `${at}/end`);
+    if (first === void 0 || last === void 0) return;
+    if (first > last) {
+      issues.push({ rule: "inverted-range", path: at, message: `the period starts on ${period.start}, after it ends on ${period.end}` });
+    } else if (range !== void 0 && (last < range.start || first > range.end)) {
+      issues.push({
+        rule: "period-outside-range",
+        path: at,
+        message: `the period ${period.start} to ${period.end} lies wholly outside the timeline's range ${declaredRange}, so nothing of it could be drawn`
+      });
+    }
+  });
+  (data.references ?? []).forEach((reference, index3) => {
+    const at = `/data/references/${index3}`;
+    if (reference.kind !== void 0) kinds.add(reference.kind);
+    const only = day(reference.date, `${at}/date`);
+    if (only !== void 0 && range !== void 0 && (only < range.start || only > range.end)) {
+      issues.push({
+        rule: "item-outside-range",
+        path: at,
+        message: `the reference date ${reference.date} is outside the timeline's range ${declaredRange}; widen \`time\` or move it`
+      });
+    }
+  });
+  if (kinds.size > STRUCTURED_EXCHANGE_CEILINGS.kindsPerVocabulary) {
+    issues.push({
+      rule: "too-many-kinds",
+      path: "/data/rows",
+      message: `${kinds.size} distinct item types, and no more than ${STRUCTURED_EXCHANGE_CEILINGS.kindsPerVocabulary} can be told apart in a rendering`,
+      observed: kinds.size,
+      limit: STRUCTURED_EXCHANGE_CEILINGS.kindsPerVocabulary
+    });
+  }
+  issues.push(...dependencyIssues(data, timelineEndpoints(data)));
+  issues.push(...removedDependencyIssues(data));
+  return issues;
+}
+function removedDependencyIssues(data) {
+  const removed = /* @__PURE__ */ new Set();
+  for (const row of data.rows) {
+    if (row.type !== "task") continue;
+    if (row.role === "removed") removed.add(row.id);
+    for (const item of row.items) {
+      if (item.id !== void 0 && (item.role === "removed" || row.role === "removed")) removed.add(item.id);
+    }
+  }
+  const issues = [];
+  (data.dependencies ?? []).forEach((dependency, index3) => {
+    for (const side of ["from", "to"]) {
+      if (removed.has(dependency[side])) {
+        issues.push({
+          rule: "dependency-on-removed",
+          path: `/data/dependencies/${index3}/${side}`,
+          message: `"${dependency[side]}" was dropped from the plan, so nothing can depend on it any more; remove the dependency`
+        });
+      }
+    }
+  });
+  return issues;
+}
+function dependencyIssues(data, endpoints) {
+  const issues = [];
+  const dependencies = data.dependencies ?? [];
+  const usable = [];
+  const declared = /* @__PURE__ */ new Map();
+  dependencies.forEach((dependency, index3) => {
+    const at = `/data/dependencies/${index3}`;
+    let resolved = true;
+    for (const side of ["from", "to"]) {
+      const named = dependency[side];
+      const endpoint = endpoints.get(named);
+      if (endpoint === void 0) {
+        resolved = false;
+        issues.push({
+          rule: "unresolved-endpoint",
+          path: `${at}/${side}`,
+          message: `"${named}" is not the identifier of any task or item this timeline declares`
+        });
+      } else if (endpoint.type === "task" && endpoint.days === void 0) {
+        resolved = false;
+        const task = data.rows[endpoint.row];
+        if (task.type === "task" && task.items.length > 0) continue;
+        issues.push({
+          rule: "empty-task-endpoint",
+          path: `${at}/${side}`,
+          message: `task "${named}" holds no item, so it has no start or finish for a dependency to link`
+        });
+      }
+    }
+    if (!resolved) return;
+    const from = endpoints.get(dependency.from);
+    const to = endpoints.get(dependency.to);
+    const contains = (outer, inner) => outer.type === "task" && inner.type !== "task" && inner.row === outer.row;
+    if (from.id === to.id || contains(from, to) || contains(to, from)) {
+      issues.push({
+        rule: "self-dependency",
+        path: at,
+        message: from.id === to.id ? `"${from.id}" cannot depend on itself` : `a task and one of its own items cannot depend on each other: the task's span is made of its items`
+      });
+      return;
+    }
+    const key = JSON.stringify([dependency.from, dependency.to, dependencyType(dependency)]);
+    const first = declared.get(key);
+    if (first !== void 0) {
+      issues.push({
+        rule: "duplicate-dependency",
+        path: at,
+        message: `the same dependency is already declared at /data/dependencies/${first}`
+      });
+      return;
+    }
+    declared.set(key, index3);
+    usable.push({ from: dependency.from, to: dependency.to, index: index3 });
+  });
+  const cycle = findCycle(usable);
+  if (cycle !== void 0) {
+    issues.push({
+      rule: "dependency-cycle",
+      path: `/data/dependencies/${cycle.index}`,
+      message: `dependencies form a cycle, which no dates can honour: ${cycle.ids.join(" \u2192 ")}`
+    });
+  }
+  return issues;
+}
+function findCycle(edges) {
+  const outgoing = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    const list = outgoing.get(edge.from) ?? [];
+    list.push({ to: edge.to, index: edge.index });
+    outgoing.set(edge.from, list);
+  }
+  const state2 = /* @__PURE__ */ new Map();
+  const path3 = [];
+  for (const root of outgoing.keys()) {
+    if (state2.has(root)) continue;
+    const stack = [{ id: root, next: 0 }];
+    state2.set(root, "open");
+    path3.push({ id: root, index: -1 });
+    while (stack.length > 0) {
+      const frame = stack[stack.length - 1];
+      const edgesOut = outgoing.get(frame.id) ?? [];
+      if (frame.next >= edgesOut.length) {
+        state2.set(frame.id, "done");
+        stack.pop();
+        path3.pop();
+        continue;
+      }
+      const edge = edgesOut[frame.next++];
+      const seen = state2.get(edge.to);
+      if (seen === "open") {
+        const start = path3.findIndex((step) => step.id === edge.to);
+        const ids = [...path3.slice(start).map((step) => step.id), edge.to];
+        return { ids, index: edge.index };
+      }
+      if (seen === void 0) {
+        state2.set(edge.to, "open");
+        stack.push({ id: edge.to, next: 0 });
+        path3.push({ id: edge.to, index: edge.index });
+      }
+    }
+  }
+  return void 0;
+}
+
 // shared/src/structuredExchangeValidation.ts
 function dataMatchesKind(envelope) {
   const data = envelope.data;
   if (envelope.kind === "graph") return Array.isArray(data.nodes) && Array.isArray(data.edges);
   if (envelope.kind === "sequence") return Array.isArray(data.participants) && Array.isArray(data.messages);
+  if (envelope.kind === "timeline") return typeof data.time === "object" && data.time !== null && Array.isArray(data.rows);
   return Array.isArray(data.columns) && Array.isArray(data.rows);
 }
 function elementsOf(envelope) {
@@ -203,6 +536,7 @@ function relationshipsPointer(envelope) {
   return envelope.kind === "graph" ? "/data/edges" : "/data/messages";
 }
 function enrichedItemsOf(envelope) {
+  if (envelope.kind === "timeline") return [];
   const data = envelope.data;
   const items = [];
   for (const collection of ["nodes", "edges", "participants", "messages", "rows", "relations"]) {
@@ -254,6 +588,12 @@ function rowRelationsOf(envelope) {
   const relations = envelope.data.relations;
   return Array.isArray(relations) ? relations : [];
 }
+function notProposable(kind, consequence) {
+  if (kind === "timeline") {
+    return `a timeline is maintained by presenting the revised timeline again, not proposed as a change, ${consequence}`;
+  }
+  return `a ${kind} is a projection and cannot be proposed, ${consequence}`;
+}
 function validateStructuredExchangeSemantics(envelope) {
   const issues = [];
   if (!dataMatchesKind(envelope)) {
@@ -269,7 +609,7 @@ function validateStructuredExchangeSemantics(envelope) {
     issues.push({
       rule: "kind-not-proposable",
       path: "/target",
-      message: `a ${envelope.kind} is a projection and cannot be proposed, so it carries no target`
+      message: notProposable(envelope.kind, "so it carries no target")
     });
   }
   if (envelope.removals !== void 0) {
@@ -277,7 +617,7 @@ function validateStructuredExchangeSemantics(envelope) {
       issues.push({
         rule: "kind-not-proposable",
         path: "/removals",
-        message: `a ${envelope.kind} is a projection and cannot be proposed, so it declares no removals`
+        message: notProposable(envelope.kind, "so it declares no removals")
       });
     } else if (envelope.target === void 0) {
       issues.push({
@@ -338,15 +678,15 @@ function validateStructuredExchangeSemantics(envelope) {
     }
   });
   const claimed = /* @__PURE__ */ new Map();
-  const claim = (type, ref, at2) => {
+  const claim = (type, ref, at) => {
     if (ref === void 0) return;
     const key = `${type}:${ref}`;
     const first = claimed.get(key);
-    if (first === void 0) claimed.set(key, at2);
+    if (first === void 0) claimed.set(key, at);
     else {
       issues.push({
         rule: "duplicate-reference",
-        path: at2,
+        path: at,
         message: `${type} "${ref}" is already addressed at ${first}; a proposal states one intention per thing`
       });
     }
@@ -376,7 +716,7 @@ function validateStructuredExchangeSemantics(envelope) {
       issues.push({
         rule: "kind-not-proposable",
         path: `${candidate.at}/set`,
-        message: `a ${envelope.kind} is a projection and cannot be proposed, so nothing in it declares a change`
+        message: notProposable(envelope.kind, "so nothing in it declares a change")
       });
     } else if (envelope.target === void 0) {
       issues.push({
@@ -399,11 +739,11 @@ function validateStructuredExchangeSemantics(envelope) {
       countKinds(relationshipsOf(envelope))
     ]
   ];
-  for (const [noun, at2, kinds] of vocabularies) {
+  for (const [noun, at, kinds] of vocabularies) {
     if (kinds.size > STRUCTURED_EXCHANGE_CEILINGS.kindsPerVocabulary) {
       issues.push({
         rule: "too-many-kinds",
-        path: at2,
+        path: at,
         message: `${kinds.size} distinct ${noun} types, and no more than ${STRUCTURED_EXCHANGE_CEILINGS.kindsPerVocabulary} can be told apart in a rendering`,
         observed: kinds.size,
         limit: STRUCTURED_EXCHANGE_CEILINGS.kindsPerVocabulary
@@ -425,21 +765,21 @@ function validateStructuredExchangeSemantics(envelope) {
       );
       const seenViewpoints = /* @__PURE__ */ new Map();
       viewpoints.forEach((viewpoint, index3) => {
-        const at2 = `/viewpoints/${index3}`;
+        const at = `/viewpoints/${index3}`;
         const { id, elementKinds: retainedElements, relationshipKinds: retainedRelationships } = viewpoint;
         const first = seenViewpoints.get(id);
         if (first === void 0) seenViewpoints.set(id, index3);
         else {
           issues.push({
             rule: "duplicate-viewpoint-identifier",
-            path: `${at2}/id`,
+            path: `${at}/id`,
             message: `viewpoint "${id}" is already declared at /viewpoints/${first}`
           });
         }
         if (retainedElements === void 0 && retainedRelationships === void 0) {
           issues.push({
             rule: "empty-viewpoint",
-            path: at2,
+            path: at,
             message: `viewpoint "${id}" retains no kind, so it would show nothing it was not already showing; name elementKinds, relationshipKinds, or both`
           });
         }
@@ -452,7 +792,7 @@ function validateStructuredExchangeSemantics(envelope) {
             if (present.has(kind)) return;
             issues.push({
               rule: "unresolved-viewpoint-kind",
-              path: `${at2}/${list}/${position}`,
+              path: `${at}/${list}/${position}`,
               message: `viewpoint "${id}" retains ${noun} kind "${kind}", and no ${noun} of this document has it` + (other.has(kind) ? ` (it is a ${otherNoun} kind here, which is a different vocabulary)` : "")
             });
           });
@@ -476,6 +816,7 @@ function validateStructuredExchangeSemantics(envelope) {
       }
     });
   }
+  if (envelope.kind === "timeline") issues.push(...timelineIssues(envelope.data));
   for (const item of enrichedItemsOf(envelope)) {
     if (item.expect !== void 0) {
       if (envelope.target === void 0) {
@@ -9728,127 +10069,1452 @@ var structured_exchange_2_default = {
   }
 };
 
-// shared/src/structuredExchangeDocument.ts
-var STRUCTURED_EXCHANGE_SCHEMA_PREFIX = "urn:structured-exchange:";
-function declaredSchemaOf(document) {
-  if (typeof document !== "object" || document === null || Array.isArray(document)) return void 0;
-  const schema2 = document.schema;
-  if (typeof schema2 !== "string" || !schema2.startsWith(STRUCTURED_EXCHANGE_SCHEMA_PREFIX)) return void 0;
-  return schema2;
-}
-
-// shared/src/structuredExchangeSchemaNode.ts
-function unwrapSchemaModule(module) {
-  const raw = module;
-  const looksLikeSchema = "$id" in raw || "type" in raw;
-  const root = looksLikeSchema ? raw : raw.default;
-  if (root.default !== root) return root;
-  const { default: _interop, ...rest } = root;
-  return rest;
-}
-var schemas = {
-  "urn:structured-exchange:1": unwrapSchemaModule(structured_exchange_1_default),
-  "urn:structured-exchange:2": unwrapSchemaModule(structured_exchange_2_default)
-};
-var schema = schemas[STRUCTURED_EXCHANGE_SCHEMA_V1];
-var compiled = /* @__PURE__ */ new Map();
-function schemaFor(version, kind) {
-  const published = schemas[version];
-  const variants = published.properties.data?.oneOf ?? [];
-  const required = { graph: "nodes", sequence: "participants", table: "columns" };
-  const marker = typeof kind === "string" ? required[kind] : void 0;
-  const variant = marker === void 0 ? void 0 : variants.find((candidate) => candidate.properties?.[marker] !== void 0);
-  if (variant === void 0) return published;
-  return {
-    ...published,
-    properties: { ...published.properties, data: variant }
-  };
-}
-var NARROWABLE_KINDS = ["graph", "sequence", "table"];
-function validator(version, kind) {
-  const narrowable = typeof kind === "string" && NARROWABLE_KINDS.includes(kind);
-  const key = `${version}:${narrowable ? kind : "*"}`;
-  const existing = compiled.get(key);
-  if (existing !== void 0) return existing;
-  const built = Compile(schemaFor(version, narrowable ? kind : void 0));
-  compiled.set(key, built);
-  return built;
-}
-function observedFor(keyword, value) {
-  if (typeof value === "string" && (keyword === "maxLength" || keyword === "minLength")) return value.length;
-  if (Array.isArray(value) && (keyword === "maxItems" || keyword === "minItems")) return value.length;
-  return void 0;
-}
-function at(document, pointer) {
-  if (pointer === "") return document;
-  let current = document;
-  for (const rawSegment of pointer.slice(1).split("/")) {
-    if (current === null || typeof current !== "object") return void 0;
-    const segment4 = rawSegment.replace(/~1/g, "/").replace(/~0/g, "~");
-    current = current[segment4];
-  }
-  return current;
-}
-var checkStructuredExchangeSchema = (document) => {
-  const declared = declaredSchemaOf(document);
-  const version = supportedSchemaOf(declared);
-  if (version === void 0 && declared !== void 0) {
-    return [
-      {
-        rule: "unsupported-version",
-        path: "/schema",
-        message: `this build validates ${STRUCTURED_EXCHANGE_SUPPORTED_SCHEMAS.join(" and ")}`
+// shared/schemas/structured-exchange-3.json
+var structured_exchange_3_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "urn:structured-exchange:3",
+  title: "Structured exchange envelope v3",
+  description: "Version 2 plus one kind, the timeline. Every version 2 construct keeps its definition, so a version 2 document means the same thing once its identifier is changed to this one.",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "schema",
+    "kind",
+    "data"
+  ],
+  $defs: {
+    ref: {
+      type: "string",
+      minLength: 1,
+      maxLength: 200
+    },
+    localId: {
+      type: "string",
+      minLength: 1,
+      maxLength: 200
+    },
+    label: {
+      type: "string",
+      maxLength: 500
+    },
+    kind: {
+      description: "The producing tool's type or stereotype for this thing \u2014 'block', 'sensor', 'requirement', 'power'. Free text, because the vocabulary belongs to the domain and not to this contract; a profile names which domain owns it.",
+      type: "string",
+      minLength: 1,
+      maxLength: 100
+    },
+    reference: {
+      description: "Something owned elsewhere, named by the identifier its authority knows it by. Opaque: never parsed, resolved or fetched.",
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "ref"
+      ],
+      properties: {
+        ref: {
+          $ref: "#/$defs/ref"
+        }
       }
-    ];
-  }
-  const issues = [];
-  const contract = version ?? STRUCTURED_EXCHANGE_SCHEMA_V1;
-  const published = [...validator(contract, void 0).Errors(document)];
-  if (published.length === 0) return issues;
-  const kind = document?.kind;
-  const narrowed = [...validator(contract, kind).Errors(document)];
-  const seen = new Set(narrowed.map((error) => `${error.keyword}@${error.instancePath}`));
-  const combined = [
-    ...narrowed,
-    ...published.filter((error) => !seen.has(`${error.keyword}@${error.instancePath}`))
-  ];
-  for (const error of combined) {
-    const keyword = String(error.keyword ?? "schema");
-    const limit = error.params?.limit;
-    issues.push({
-      rule: `schema/${keyword}`,
-      path: error.instancePath ?? "",
-      message: error.message ?? "does not conform to the published schema",
-      ...limit !== void 0 ? { limit, level: "ceiling" } : {},
-      ...(() => {
-        const observed = observedFor(keyword, at(document, error.instancePath ?? ""));
-        return observed === void 0 ? {} : { observed };
-      })()
-    });
-  }
-  return issues.sort((left, right) => right.path.split("/").length - left.path.split("/").length);
-};
-
-// shared/src/structuredExchangeProfile.ts
-var STRUCTURED_EXCHANGE_PROFILE_REGISTRY_PATH = ".pi-outpost/structured-exchange.json";
-var STRUCTURED_EXCHANGE_CONFORMITY_REPORT_PROFILE = "urn:structured-exchange-conformity-report:1";
-var STRUCTURED_EXCHANGE_RULES_REGISTER_PROFILE = "urn:structured-exchange-rules-register:1";
-var STRUCTURED_EXCHANGE_RULE_PATTERNS_PROFILE = "urn:structured-exchange-rule-patterns:1";
-var RESERVED_PROFILE_IDENTIFIERS = /* @__PURE__ */ new Set([
-  STRUCTURED_EXCHANGE_CONFORMITY_REPORT_PROFILE,
-  STRUCTURED_EXCHANGE_RULES_REGISTER_PROFILE,
-  STRUCTURED_EXCHANGE_RULE_PATTERNS_PROFILE
-]);
-var STRUCTURED_EXCHANGE_PROFILE_CEILINGS = {
-  /** A profile's identifier, bounded like the `profile` a document names it by. */
-  id: 200,
-  label: 500,
-  description: 2e3,
-  /** Kinds per vocabulary, as a document's `kindsPerVocabulary`. */
-  kindsPerVocabulary: 64,
-  /** Attributes one kind declares, as a document's `attributesPerItem`. */
-  attributesPerKind: 50,
-  attributeName: 200,
+    },
+    attributeScalar: {
+      type: [
+        "string",
+        "number",
+        "boolean",
+        "null"
+      ],
+      maxLength: 1e3
+    },
+    attributeValue: {
+      description: "A scalar, an opaque reference, or one flat list of those. Lists never nest and no other object shape is allowed: recursive values would weaken size analysis, generic rendering and deterministic comparison.",
+      oneOf: [
+        {
+          $ref: "#/$defs/attributeScalar"
+        },
+        {
+          $ref: "#/$defs/reference"
+        },
+        {
+          type: "array",
+          maxItems: 50,
+          items: {
+            oneOf: [
+              {
+                $ref: "#/$defs/attributeScalar"
+              },
+              {
+                $ref: "#/$defs/reference"
+              }
+            ]
+          }
+        }
+      ]
+    },
+    attributes: {
+      description: "Domain-owned properties of this item. Names belong to the profile's vocabulary; this contract bounds them and reads none of them.",
+      type: "object",
+      maxProperties: 50,
+      propertyNames: {
+        minLength: 1,
+        maxLength: 200
+      },
+      additionalProperties: {
+        $ref: "#/$defs/attributeValue"
+      }
+    },
+    removeAttributes: {
+      description: "Attribute names this proposal takes away. Deletion is explicit because null is an ordinary value: a producer that means 'unset' says so here.",
+      type: "array",
+      maxItems: 50,
+      items: {
+        $ref: "#/$defs/localId"
+      }
+    },
+    revision: {
+      description: "The revision an authority knows its state by. Opaque: compared by the authority, never interpreted here.",
+      type: "string",
+      minLength: 1,
+      maxLength: 200
+    },
+    position: {
+      type: "integer",
+      minimum: 0,
+      maximum: 1e6
+    },
+    location: {
+      description: "Where this item can be found, as a hint for a reader. Never an identity: locations take no part in endpoint resolution, duplicate detection, or what a proposal addresses, and moving the thing does not change what it is.",
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "uri"
+      ],
+      properties: {
+        uri: {
+          type: "string",
+          minLength: 1,
+          maxLength: 2e3
+        },
+        revision: {
+          $ref: "#/$defs/revision"
+        },
+        range: {
+          type: "object",
+          additionalProperties: false,
+          required: [
+            "startLine",
+            "endLine"
+          ],
+          description: "A zero-based range inside the resource. Ordering is checked after the schema, which cannot conveniently compare two positions.",
+          properties: {
+            startLine: {
+              $ref: "#/$defs/position"
+            },
+            startCharacter: {
+              $ref: "#/$defs/position"
+            },
+            endLine: {
+              $ref: "#/$defs/position"
+            },
+            endCharacter: {
+              $ref: "#/$defs/position"
+            }
+          }
+        }
+      }
+    },
+    locations: {
+      type: "array",
+      maxItems: 10,
+      items: {
+        $ref: "#/$defs/location"
+      }
+    },
+    artifact: {
+      description: "A related artifact \u2014 an implementation, a report, a piece of evidence \u2014 named rather than carried. The digest is mandatory so an approval refers to stable bytes even when the URI is not: nothing here is retrieved by validation or by rendering.",
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "rel",
+        "uri",
+        "sha256"
+      ],
+      properties: {
+        rel: {
+          type: "string",
+          minLength: 1,
+          maxLength: 100
+        },
+        uri: {
+          type: "string",
+          minLength: 1,
+          maxLength: 2e3
+        },
+        sha256: {
+          type: "string",
+          pattern: "^sha256:[0-9a-f]{64}$"
+        },
+        mediaType: {
+          type: "string",
+          minLength: 1,
+          maxLength: 100
+        },
+        label: {
+          $ref: "#/$defs/label"
+        }
+      }
+    },
+    artifacts: {
+      type: "array",
+      maxItems: 20,
+      items: {
+        $ref: "#/$defs/artifact"
+      }
+    },
+    expect: {
+      description: "What the producer believes is true of this item right now. A declaration for the receiving authority to check immediately before applying, never a claim this application has established.",
+      type: "object",
+      additionalProperties: false,
+      minProperties: 1,
+      properties: {
+        label: {
+          $ref: "#/$defs/label"
+        },
+        kind: {
+          $ref: "#/$defs/kind"
+        },
+        container: {
+          $ref: "#/$defs/localId"
+        },
+        revision: {
+          $ref: "#/$defs/revision"
+        },
+        attributes: {
+          $ref: "#/$defs/attributes"
+        }
+      }
+    },
+    elementChange: {
+      type: "object",
+      additionalProperties: false,
+      minProperties: 1,
+      properties: {
+        label: {
+          $ref: "#/$defs/label"
+        },
+        kind: {
+          $ref: "#/$defs/kind"
+        },
+        container: {
+          $ref: "#/$defs/localId"
+        },
+        attributes: {
+          $ref: "#/$defs/attributes"
+        },
+        removeAttributes: {
+          $ref: "#/$defs/removeAttributes"
+        }
+      }
+    },
+    edgeChange: {
+      type: "object",
+      additionalProperties: false,
+      minProperties: 1,
+      properties: {
+        kind: {
+          $ref: "#/$defs/kind"
+        },
+        label: {
+          $ref: "#/$defs/label"
+        },
+        attributes: {
+          $ref: "#/$defs/attributes"
+        },
+        removeAttributes: {
+          $ref: "#/$defs/removeAttributes"
+        }
+      }
+    },
+    messageChange: {
+      type: "object",
+      additionalProperties: false,
+      minProperties: 1,
+      properties: {
+        label: {
+          $ref: "#/$defs/label"
+        },
+        attributes: {
+          $ref: "#/$defs/attributes"
+        },
+        removeAttributes: {
+          $ref: "#/$defs/removeAttributes"
+        }
+      }
+    },
+    rowChange: {
+      type: "object",
+      additionalProperties: false,
+      minProperties: 1,
+      properties: {
+        label: {
+          $ref: "#/$defs/label"
+        },
+        kind: {
+          $ref: "#/$defs/kind"
+        },
+        cells: {
+          $ref: "#/$defs/cells"
+        },
+        attributes: {
+          $ref: "#/$defs/attributes"
+        },
+        removeAttributes: {
+          $ref: "#/$defs/removeAttributes"
+        }
+      }
+    },
+    container: {
+      description: "A named group of elements or participants. Grouping only: relationships connect elements and cross container boundaries freely, and a container carries no relationship of its own.",
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "id",
+        "label"
+      ],
+      properties: {
+        id: {
+          $ref: "#/$defs/localId"
+        },
+        label: {
+          $ref: "#/$defs/label"
+        },
+        kind: {
+          $ref: "#/$defs/kind"
+        }
+      }
+    },
+    element: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "id"
+      ],
+      properties: {
+        id: {
+          $ref: "#/$defs/localId"
+        },
+        ref: {
+          $ref: "#/$defs/ref"
+        },
+        label: {
+          $ref: "#/$defs/label"
+        },
+        kind: {
+          $ref: "#/$defs/kind"
+        },
+        set: {
+          $ref: "#/$defs/elementChange"
+        },
+        container: {
+          $ref: "#/$defs/localId"
+        },
+        attributes: {
+          $ref: "#/$defs/attributes"
+        },
+        expect: {
+          $ref: "#/$defs/expect"
+        },
+        locations: {
+          $ref: "#/$defs/locations"
+        },
+        artifacts: {
+          $ref: "#/$defs/artifacts"
+        }
+      },
+      if: {
+        not: {
+          required: [
+            "ref"
+          ]
+        }
+      },
+      then: {
+        required: [
+          "label"
+        ]
+      }
+    },
+    edge: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "from",
+        "to"
+      ],
+      properties: {
+        from: {
+          $ref: "#/$defs/localId"
+        },
+        to: {
+          $ref: "#/$defs/localId"
+        },
+        kind: {
+          $ref: "#/$defs/kind"
+        },
+        ref: {
+          $ref: "#/$defs/ref"
+        },
+        label: {
+          $ref: "#/$defs/label"
+        },
+        set: {
+          $ref: "#/$defs/edgeChange"
+        },
+        attributes: {
+          $ref: "#/$defs/attributes"
+        },
+        expect: {
+          $ref: "#/$defs/expect"
+        },
+        locations: {
+          $ref: "#/$defs/locations"
+        },
+        artifacts: {
+          $ref: "#/$defs/artifacts"
+        }
+      },
+      if: {
+        not: {
+          required: [
+            "ref"
+          ]
+        }
+      },
+      then: {
+        required: [
+          "kind"
+        ]
+      }
+    },
+    message: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "from",
+        "to"
+      ],
+      properties: {
+        from: {
+          $ref: "#/$defs/localId"
+        },
+        to: {
+          $ref: "#/$defs/localId"
+        },
+        ref: {
+          $ref: "#/$defs/ref"
+        },
+        label: {
+          $ref: "#/$defs/label"
+        },
+        set: {
+          $ref: "#/$defs/messageChange"
+        },
+        attributes: {
+          $ref: "#/$defs/attributes"
+        },
+        expect: {
+          $ref: "#/$defs/expect"
+        },
+        locations: {
+          $ref: "#/$defs/locations"
+        },
+        artifacts: {
+          $ref: "#/$defs/artifacts"
+        }
+      },
+      if: {
+        not: {
+          required: [
+            "ref"
+          ]
+        }
+      },
+      then: {
+        required: [
+          "label"
+        ]
+      }
+    },
+    removal: {
+      description: "Something to take out of the target, named by the reference the authority knows it by. The other fields describe it and never identify it: they exist so a reader can see what they are approving the removal of.",
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "type",
+        "ref"
+      ],
+      properties: {
+        type: {
+          enum: [
+            "element",
+            "relationship",
+            "row"
+          ]
+        },
+        ref: {
+          $ref: "#/$defs/ref"
+        },
+        label: {
+          $ref: "#/$defs/label"
+        },
+        kind: {
+          $ref: "#/$defs/kind"
+        },
+        from: {
+          $ref: "#/$defs/localId"
+        },
+        to: {
+          $ref: "#/$defs/localId"
+        }
+      }
+    },
+    cells: {
+      type: "array",
+      items: {
+        type: [
+          "string",
+          "number",
+          "boolean",
+          "null"
+        ],
+        maxLength: 1e3
+      },
+      maxItems: 50
+    },
+    role: {
+      enum: [
+        "added",
+        "changed",
+        "context",
+        "removed"
+      ]
+    },
+    dataRow: {
+      description: "A row of the table. It may carry an identity of its own \u2014 a document-local id, the reference its authority knows it by, and the kind of thing it is \u2014 which is what lets a relation point at it and a patch address it.",
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "cells"
+      ],
+      properties: {
+        cells: {
+          $ref: "#/$defs/cells"
+        },
+        role: {
+          $ref: "#/$defs/role"
+        },
+        id: {
+          $ref: "#/$defs/localId"
+        },
+        ref: {
+          $ref: "#/$defs/ref"
+        },
+        kind: {
+          $ref: "#/$defs/kind"
+        },
+        label: {
+          $ref: "#/$defs/label"
+        },
+        set: {
+          $ref: "#/$defs/rowChange"
+        },
+        attributes: {
+          $ref: "#/$defs/attributes"
+        },
+        expect: {
+          $ref: "#/$defs/expect"
+        },
+        locations: {
+          $ref: "#/$defs/locations"
+        },
+        artifacts: {
+          $ref: "#/$defs/artifacts"
+        }
+      }
+    },
+    structuralRow: {
+      description: "A heading that organises the table \u2014 a chapter, a section \u2014 rather than a row of data. It spans the table and is not aligned to its columns; it is never inferred from a data row whose cells are empty.",
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "heading"
+      ],
+      properties: {
+        heading: {
+          type: "string",
+          minLength: 1,
+          maxLength: 500
+        },
+        depth: {
+          type: "integer",
+          minimum: 1,
+          maximum: 6
+        },
+        role: {
+          $ref: "#/$defs/role"
+        },
+        id: {
+          $ref: "#/$defs/localId"
+        },
+        ref: {
+          $ref: "#/$defs/ref"
+        }
+      }
+    },
+    endpoint: {
+      description: "One end of a relation: a row of this document by its local id, or something outside it by the reference its authority knows. Stated explicitly so an unresolvable local endpoint is an error rather than silently reread as external.",
+      type: "object",
+      additionalProperties: false,
+      minProperties: 1,
+      maxProperties: 1,
+      oneOf: [
+        {
+          required: [
+            "id"
+          ]
+        },
+        {
+          required: [
+            "ref"
+          ]
+        }
+      ],
+      properties: {
+        id: {
+          $ref: "#/$defs/localId"
+        },
+        ref: {
+          $ref: "#/$defs/ref"
+        }
+      }
+    },
+    relation: {
+      description: "A relation between rows \u2014 traceability. Carries an opaque kind from the profile's vocabulary, exactly as a relationship between graph elements does; unlike one, an end may leave the document, because the test that verifies a requirement usually lives elsewhere.",
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "from",
+        "to",
+        "kind"
+      ],
+      properties: {
+        from: {
+          $ref: "#/$defs/endpoint"
+        },
+        to: {
+          $ref: "#/$defs/endpoint"
+        },
+        kind: {
+          $ref: "#/$defs/kind"
+        },
+        ref: {
+          $ref: "#/$defs/ref"
+        },
+        label: {
+          $ref: "#/$defs/label"
+        },
+        attributes: {
+          $ref: "#/$defs/attributes"
+        }
+      }
+    },
+    viewpoint: {
+      description: "A named reading of a graph: the concern it frames, and the element and relationship kinds that address it. An inclusion \u2014 showing it shows what it retains and hides the rest, so a kind added to the model later is not shown unannounced. A vocabulary it names no kinds for is left whole. The term is ISO/IEC/IEEE 42010's.",
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "id",
+        "label",
+        "concern"
+      ],
+      properties: {
+        id: {
+          $ref: "#/$defs/localId"
+        },
+        label: {
+          description: "What a reader selects it by.",
+          type: "string",
+          minLength: 1,
+          maxLength: 500
+        },
+        concern: {
+          description: "What this reading is for \u2014 stated inside every figure drawn for it, so a figure taken out of its report still says what it is a reading of.",
+          type: "string",
+          minLength: 1,
+          maxLength: 500
+        },
+        elementKinds: {
+          description: "Element kinds this viewpoint retains. Absent leaves the element vocabulary whole.",
+          type: "array",
+          minItems: 1,
+          maxItems: 64,
+          uniqueItems: true,
+          items: {
+            $ref: "#/$defs/kind"
+          }
+        },
+        relationshipKinds: {
+          description: "Relationship kinds this viewpoint retains. Absent leaves the relationship vocabulary whole.",
+          type: "array",
+          minItems: 1,
+          maxItems: 64,
+          uniqueItems: true,
+          items: {
+            $ref: "#/$defs/kind"
+          }
+        }
+      }
+    },
+    calendarDate: {
+      description: "A calendar date, YYYY-MM-DD. A day, not an instant: no time and no zone, so a position derived from it is the same for every reader.",
+      type: "string",
+      pattern: "^[0-9]{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$"
+    },
+    timelineActivity: {
+      description: "A duration on a task, drawn as a bar from the start of its start day to the end of its end day.",
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "type",
+        "start",
+        "end"
+      ],
+      properties: {
+        type: {
+          const: "activity"
+        },
+        start: {
+          $ref: "#/$defs/calendarDate"
+        },
+        end: {
+          $ref: "#/$defs/calendarDate"
+        },
+        id: {
+          $ref: "#/$defs/localId"
+        },
+        label: {
+          $ref: "#/$defs/label"
+        },
+        kind: {
+          $ref: "#/$defs/kind"
+        },
+        previous: {
+          description: "Where the activity stood in the plan named by comparedTo.",
+          type: "object",
+          additionalProperties: false,
+          required: [
+            "start",
+            "end"
+          ],
+          properties: {
+            start: {
+              $ref: "#/$defs/calendarDate"
+            },
+            end: {
+              $ref: "#/$defs/calendarDate"
+            }
+          }
+        },
+        role: {
+          $ref: "#/$defs/timelineChangeRole"
+        }
+      }
+    },
+    timelineMilestone: {
+      description: "A point in time on a task, drawn as a star.",
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "type",
+        "date"
+      ],
+      properties: {
+        type: {
+          const: "milestone"
+        },
+        date: {
+          $ref: "#/$defs/calendarDate"
+        },
+        id: {
+          $ref: "#/$defs/localId"
+        },
+        label: {
+          $ref: "#/$defs/label"
+        },
+        kind: {
+          $ref: "#/$defs/kind"
+        },
+        previous: {
+          description: "Where the milestone stood in the plan named by comparedTo.",
+          type: "object",
+          additionalProperties: false,
+          required: [
+            "date"
+          ],
+          properties: {
+            date: {
+              $ref: "#/$defs/calendarDate"
+            }
+          }
+        },
+        role: {
+          $ref: "#/$defs/timelineChangeRole"
+        }
+      }
+    },
+    timelineTask: {
+      description: "A semantic row: a named task holding any number of activities and milestones, in any order.",
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "type",
+        "id",
+        "label",
+        "items"
+      ],
+      properties: {
+        type: {
+          const: "task"
+        },
+        id: {
+          $ref: "#/$defs/localId"
+        },
+        label: {
+          $ref: "#/$defs/label"
+        },
+        items: {
+          type: "array",
+          maxItems: 100,
+          items: {
+            $ref: "#/$defs/timelineItem"
+          }
+        },
+        role: {
+          $ref: "#/$defs/timelineChangeRole"
+        }
+      }
+    },
+    timelineSeparator: {
+      description: "A horizontal divider between groups of tasks, with an optional title. Carries no dates and takes no part in the time axis.",
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "type"
+      ],
+      properties: {
+        type: {
+          const: "separator"
+        },
+        label: {
+          $ref: "#/$defs/label"
+        }
+      }
+    },
+    timelineDependency: {
+      description: "A Gantt dependency: the successor `to` waits on the predecessor `from`. Endpoints name a task or an item by id; a task stands for the span of its items. Without a type it is finish-to-start.",
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "from",
+        "to"
+      ],
+      properties: {
+        from: {
+          $ref: "#/$defs/localId"
+        },
+        to: {
+          $ref: "#/$defs/localId"
+        },
+        type: {
+          enum: [
+            "finish-to-start",
+            "start-to-start",
+            "finish-to-finish",
+            "start-to-finish"
+          ]
+        }
+      }
+    },
+    timelineItem: {
+      description: "An activity or a milestone, selected by its type so a refusal speaks about the one it is.",
+      type: "object",
+      required: [
+        "type"
+      ],
+      properties: {
+        type: {
+          enum: [
+            "activity",
+            "milestone"
+          ]
+        }
+      },
+      allOf: [
+        {
+          if: {
+            properties: {
+              type: {
+                const: "activity"
+              }
+            }
+          },
+          then: {
+            $ref: "#/$defs/timelineActivity"
+          }
+        },
+        {
+          if: {
+            properties: {
+              type: {
+                const: "milestone"
+              }
+            }
+          },
+          then: {
+            $ref: "#/$defs/timelineMilestone"
+          }
+        }
+      ]
+    },
+    timelineRow: {
+      description: "A task or a separator, selected by its type so a refusal speaks about the one it is.",
+      type: "object",
+      required: [
+        "type"
+      ],
+      properties: {
+        type: {
+          enum: [
+            "task",
+            "separator"
+          ]
+        }
+      },
+      allOf: [
+        {
+          if: {
+            properties: {
+              type: {
+                const: "task"
+              }
+            }
+          },
+          then: {
+            $ref: "#/$defs/timelineTask"
+          }
+        },
+        {
+          if: {
+            properties: {
+              type: {
+                const: "separator"
+              }
+            }
+          },
+          then: {
+            $ref: "#/$defs/timelineSeparator"
+          }
+        }
+      ]
+    },
+    timelineChangeRole: {
+      description: "In a compared timeline: new since the previous plan, or dropped from it and kept so it can be shown.",
+      enum: [
+        "added",
+        "removed"
+      ]
+    },
+    timelinePeriod: {
+      description: "A span of the calendar the plan runs in \u2014 a closure, holidays. Drawn as a band across every row; constrains nothing.",
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "start",
+        "end"
+      ],
+      properties: {
+        start: {
+          $ref: "#/$defs/calendarDate"
+        },
+        end: {
+          $ref: "#/$defs/calendarDate"
+        },
+        label: {
+          $ref: "#/$defs/label"
+        },
+        kind: {
+          $ref: "#/$defs/kind"
+        }
+      }
+    },
+    timelineReference: {
+      description: "A named day the plan is judged against \u2014 a contractual date, a delivery. Drawn as a line across every row.",
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "date",
+        "label"
+      ],
+      properties: {
+        date: {
+          $ref: "#/$defs/calendarDate"
+        },
+        label: {
+          type: "string",
+          minLength: 1,
+          maxLength: 500
+        },
+        kind: {
+          $ref: "#/$defs/kind"
+        }
+      }
+    }
+  },
+  properties: {
+    schema: {
+      const: "urn:structured-exchange:3"
+    },
+    kind: {
+      enum: [
+        "graph",
+        "sequence",
+        "table",
+        "timeline"
+      ]
+    },
+    profile: {
+      description: "The vocabulary that owns the kinds and attribute names in this document. Opaque: never fetched, executed, or required to be known \u2014 an unknown profile is presented generically, not refused.",
+      type: "string",
+      minLength: 1,
+      maxLength: 200
+    },
+    target: {
+      description: "The artifact this document proposes a change to, and the revision it was prepared against. Its presence is what makes the document a proposal.",
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "ref"
+      ],
+      properties: {
+        ref: {
+          $ref: "#/$defs/ref"
+        },
+        revision: {
+          $ref: "#/$defs/revision"
+        }
+      }
+    },
+    removals: {
+      type: "array",
+      maxItems: 500,
+      items: {
+        $ref: "#/$defs/removal"
+      }
+    },
+    artifacts: {
+      type: "array",
+      maxItems: 50,
+      items: {
+        $ref: "#/$defs/artifact"
+      }
+    },
+    viewpoints: {
+      description: "Named readings of this document. Only a graph may declare them. Presentation only: selecting one never alters the document.",
+      type: "array",
+      maxItems: 20,
+      items: {
+        $ref: "#/$defs/viewpoint"
+      }
+    },
+    data: {
+      oneOf: [
+        {
+          type: "object",
+          additionalProperties: false,
+          required: [
+            "nodes",
+            "edges"
+          ],
+          properties: {
+            nodes: {
+              type: "array",
+              minItems: 1,
+              maxItems: 500,
+              items: {
+                $ref: "#/$defs/element"
+              }
+            },
+            edges: {
+              type: "array",
+              maxItems: 2e3,
+              items: {
+                $ref: "#/$defs/edge"
+              }
+            },
+            containers: {
+              type: "array",
+              maxItems: 50,
+              items: {
+                $ref: "#/$defs/container"
+              }
+            }
+          }
+        },
+        {
+          type: "object",
+          additionalProperties: false,
+          required: [
+            "participants",
+            "messages"
+          ],
+          properties: {
+            participants: {
+              type: "array",
+              minItems: 1,
+              maxItems: 100,
+              items: {
+                $ref: "#/$defs/element"
+              }
+            },
+            messages: {
+              type: "array",
+              maxItems: 1e3,
+              items: {
+                $ref: "#/$defs/message"
+              }
+            },
+            containers: {
+              type: "array",
+              maxItems: 50,
+              items: {
+                $ref: "#/$defs/container"
+              }
+            }
+          }
+        },
+        {
+          type: "object",
+          additionalProperties: false,
+          required: [
+            "columns",
+            "rows"
+          ],
+          properties: {
+            columns: {
+              type: "array",
+              minItems: 1,
+              maxItems: 50,
+              items: {
+                type: "string",
+                minLength: 1,
+                maxLength: 200
+              }
+            },
+            rows: {
+              type: "array",
+              maxItems: 5e3,
+              items: {
+                oneOf: [
+                  {
+                    $ref: "#/$defs/cells"
+                  },
+                  {
+                    $ref: "#/$defs/dataRow"
+                  },
+                  {
+                    $ref: "#/$defs/structuralRow"
+                  }
+                ]
+              }
+            },
+            relations: {
+              type: "array",
+              maxItems: 2e3,
+              items: {
+                $ref: "#/$defs/relation"
+              }
+            }
+          }
+        },
+        {
+          description: "A planning timeline: a calendar range and an ordered list of rows. Never coordinates, colours or a current date \u2014 the renderer derives those.",
+          type: "object",
+          additionalProperties: false,
+          required: [
+            "time",
+            "rows"
+          ],
+          properties: {
+            title: {
+              $ref: "#/$defs/label"
+            },
+            time: {
+              type: "object",
+              additionalProperties: false,
+              required: [
+                "start",
+                "end",
+                "scale"
+              ],
+              properties: {
+                start: {
+                  $ref: "#/$defs/calendarDate"
+                },
+                end: {
+                  $ref: "#/$defs/calendarDate"
+                },
+                scale: {
+                  enum: [
+                    "week",
+                    "month",
+                    "quarter"
+                  ]
+                }
+              }
+            },
+            rows: {
+              type: "array",
+              maxItems: 500,
+              items: {
+                $ref: "#/$defs/timelineRow"
+              }
+            },
+            dependencies: {
+              type: "array",
+              maxItems: 2e3,
+              items: {
+                $ref: "#/$defs/timelineDependency"
+              }
+            },
+            comparedTo: {
+              description: "The plan this timeline is compared with. Its presence makes the timeline a comparison: items may then carry previous dates and roles.",
+              type: "object",
+              additionalProperties: false,
+              required: [
+                "label"
+              ],
+              properties: {
+                label: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: 500
+                },
+                date: {
+                  $ref: "#/$defs/calendarDate"
+                }
+              }
+            },
+            periods: {
+              type: "array",
+              maxItems: 100,
+              items: {
+                $ref: "#/$defs/timelinePeriod"
+              }
+            },
+            references: {
+              type: "array",
+              maxItems: 50,
+              items: {
+                $ref: "#/$defs/timelineReference"
+              }
+            }
+          }
+        }
+      ]
+    }
+  }
+};
+
+// shared/src/structuredExchangeDocument.ts
+var STRUCTURED_EXCHANGE_SCHEMA_PREFIX = "urn:structured-exchange:";
+function declaredSchemaOf(document) {
+  if (typeof document !== "object" || document === null || Array.isArray(document)) return void 0;
+  const schema2 = document.schema;
+  if (typeof schema2 !== "string" || !schema2.startsWith(STRUCTURED_EXCHANGE_SCHEMA_PREFIX)) return void 0;
+  return schema2;
+}
+
+// shared/src/structuredExchangeSchemaNode.ts
+function unwrapSchemaModule(module) {
+  const raw = module;
+  const looksLikeSchema = "$id" in raw || "type" in raw;
+  const root = looksLikeSchema ? raw : raw.default;
+  if (root.default !== root) return root;
+  const { default: _interop, ...rest } = root;
+  return rest;
+}
+var schemas = {
+  "urn:structured-exchange:1": unwrapSchemaModule(structured_exchange_1_default),
+  "urn:structured-exchange:2": unwrapSchemaModule(structured_exchange_2_default),
+  "urn:structured-exchange:3": unwrapSchemaModule(structured_exchange_3_default)
+};
+var schema = schemas[STRUCTURED_EXCHANGE_SCHEMA_V1];
+var compiled = /* @__PURE__ */ new Map();
+function schemaFor(version, kind) {
+  const published = schemas[version];
+  const variants = published.properties.data?.oneOf ?? [];
+  const required = {
+    graph: "nodes",
+    sequence: "participants",
+    table: "columns",
+    timeline: "time"
+  };
+  const marker = typeof kind === "string" ? required[kind] : void 0;
+  const variant = marker === void 0 ? void 0 : variants.find((candidate) => candidate.properties?.[marker] !== void 0);
+  if (variant === void 0) return published;
+  return {
+    ...published,
+    properties: { ...published.properties, data: variant }
+  };
+}
+var NARROWABLE_KINDS = ["graph", "sequence", "table", "timeline"];
+function validator(version, kind) {
+  const narrowable = typeof kind === "string" && NARROWABLE_KINDS.includes(kind);
+  const key = `${version}:${narrowable ? kind : "*"}`;
+  const existing = compiled.get(key);
+  if (existing !== void 0) return existing;
+  const built = Compile(schemaFor(version, narrowable ? kind : void 0));
+  compiled.set(key, built);
+  return built;
+}
+var TIMELINE_BRANCHES = {
+  task: "timelineTask",
+  separator: "timelineSeparator",
+  activity: "timelineActivity",
+  milestone: "timelineMilestone"
+};
+var branchValidators = /* @__PURE__ */ new Map();
+function branchValidator(definition) {
+  const existing = branchValidators.get(definition);
+  if (existing !== void 0) return existing;
+  const defs = schemas[STRUCTURED_EXCHANGE_SCHEMA_V3].$defs;
+  const built = Compile({ $defs: defs, $ref: `#/$defs/${definition}` });
+  branchValidators.set(definition, built);
+  return built;
+}
+function expandTimelineBranches(document, errors) {
+  return errors.flatMap((error) => {
+    if (error.keyword === "additionalProperties") return namedExtras(error);
+    if (error.keyword === "enum") return [withAllowedValues(error)];
+    if (error.keyword !== "if") return [error];
+    const at = error.instancePath ?? "";
+    const value = atPointer(document, at);
+    const definition = typeof value?.type === "string" ? TIMELINE_BRANCHES[value.type] : void 0;
+    if (definition === void 0) return [error];
+    const inner = [...branchValidator(definition).Errors(value)].map((found) => ({
+      ...found,
+      instancePath: `${at}${found.instancePath ?? ""}`
+    }));
+    return inner.length === 0 ? [error] : expandTimelineBranches(document, inner);
+  });
+}
+function withAllowedValues(error) {
+  const allowed = error.params?.allowedValues;
+  if (!Array.isArray(allowed)) return error;
+  return { ...error, message: `must be one of ${allowed.map((value) => JSON.stringify(value)).join(", ")}` };
+}
+var PRESENTATION_NAMES = /* @__PURE__ */ new Set(["x", "y", "color", "colour", "fill", "stroke", "shape", "width", "height", "position", "style", "dash"]);
+function namedExtras(error) {
+  const names2 = error.params?.additionalProperties;
+  if (!Array.isArray(names2) || names2.length === 0) return [error];
+  return names2.map(
+    (name) => ({
+      ...error,
+      instancePath: `${error.instancePath ?? ""}/${String(name).replace(/~/g, "~0").replace(/\//g, "~1")}`,
+      message: PRESENTATION_NAMES.has(String(name).toLowerCase()) ? `"${String(name)}" is not defined here; a timeline carries what the plan means, and the renderer derives positions, colours and shapes` : `"${String(name)}" is not defined here`
+    })
+  );
+}
+function observedFor(keyword, value) {
+  if (typeof value === "string" && (keyword === "maxLength" || keyword === "minLength")) return value.length;
+  if (Array.isArray(value) && (keyword === "maxItems" || keyword === "minItems")) return value.length;
+  return void 0;
+}
+function atPointer(document, pointer) {
+  if (pointer === "") return document;
+  let current = document;
+  for (const rawSegment of pointer.slice(1).split("/")) {
+    if (current === null || typeof current !== "object") return void 0;
+    const segment4 = rawSegment.replace(/~1/g, "/").replace(/~0/g, "~");
+    current = current[segment4];
+  }
+  return current;
+}
+var checkStructuredExchangeSchema = (document) => {
+  const declared = declaredSchemaOf(document);
+  const version = supportedSchemaOf(declared);
+  if (version === void 0 && declared !== void 0) {
+    return [
+      {
+        rule: "unsupported-version",
+        path: "/schema",
+        message: `this build validates ${STRUCTURED_EXCHANGE_SUPPORTED_SCHEMAS.join(" and ")}`
+      }
+    ];
+  }
+  const issues = [];
+  const contract = version ?? STRUCTURED_EXCHANGE_SCHEMA_V1;
+  const published = [...validator(contract, void 0).Errors(document)];
+  if (published.length === 0) return issues;
+  const kind = document?.kind;
+  if (contract === STRUCTURED_EXCHANGE_SCHEMA_V3 && typeof kind === "string" && ["graph", "sequence", "table"].includes(kind)) {
+    const asVersionTwo = checkStructuredExchangeSchema({
+      ...document,
+      schema: STRUCTURED_EXCHANGE_SCHEMA_V2
+    });
+    if (asVersionTwo.length > 0) return asVersionTwo;
+  }
+  const narrowed = [...validator(contract, kind).Errors(document)];
+  const seen = new Set(narrowed.map((error) => `${error.keyword}@${error.instancePath}`));
+  const timeline = contract === STRUCTURED_EXCHANGE_SCHEMA_V3 && kind === "timeline";
+  const combined = timeline ? expandTimelineBranches(document, narrowed) : [...narrowed, ...published.filter((error) => !seen.has(`${error.keyword}@${error.instancePath}`))];
+  for (const error of combined) {
+    const keyword = String(error.keyword ?? "schema");
+    const limit = error.params?.limit;
+    issues.push({
+      rule: `schema/${keyword}`,
+      path: error.instancePath ?? "",
+      message: error.message ?? "does not conform to the published schema",
+      ...limit !== void 0 ? { limit, level: "ceiling" } : {},
+      ...(() => {
+        const observed = observedFor(keyword, atPointer(document, error.instancePath ?? ""));
+        return observed === void 0 ? {} : { observed };
+      })()
+    });
+  }
+  return issues.sort((left, right) => right.path.split("/").length - left.path.split("/").length);
+};
+
+// shared/src/structuredExchangeProfile.ts
+var STRUCTURED_EXCHANGE_PROFILE_REGISTRY_SCHEMA_V2 = "urn:structured-exchange-profile-registry:2";
+var STRUCTURED_EXCHANGE_PROFILE_REGISTRY_PATH = ".pi-outpost/structured-exchange.json";
+var STRUCTURED_EXCHANGE_CONFORMITY_REPORT_PROFILE = "urn:structured-exchange-conformity-report:1";
+var STRUCTURED_EXCHANGE_RULES_REGISTER_PROFILE = "urn:structured-exchange-rules-register:1";
+var STRUCTURED_EXCHANGE_RULE_PATTERNS_PROFILE = "urn:structured-exchange-rule-patterns:1";
+var RESERVED_PROFILE_IDENTIFIERS = /* @__PURE__ */ new Set([
+  STRUCTURED_EXCHANGE_CONFORMITY_REPORT_PROFILE,
+  STRUCTURED_EXCHANGE_RULES_REGISTER_PROFILE,
+  STRUCTURED_EXCHANGE_RULE_PATTERNS_PROFILE
+]);
+var STRUCTURED_EXCHANGE_PROFILE_CEILINGS = {
+  /** A profile's identifier, bounded like the `profile` a document names it by. */
+  id: 200,
+  label: 500,
+  description: 2e3,
+  /** Kinds per vocabulary, as a document's `kindsPerVocabulary`. */
+  kindsPerVocabulary: 64,
+  /** Attributes one kind declares, as a document's `attributesPerItem`. */
+  attributesPerKind: 50,
+  attributeName: 200,
   /**
    * Values one enumeration lists. Generous: a requirements tool's enumerations
    * include long ones — components, suppliers — and a profile that cannot hold its
@@ -10190,9 +11856,106 @@ var structured_exchange_profile_registry_1_default = {
   }
 };
 
+// shared/schemas/structured-exchange-profile-registry-2.json
+var structured_exchange_profile_registry_2_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "urn:structured-exchange-profile-registry:2",
+  title: "Structured exchange profile registry v2",
+  description: "Version 1 plus the project's appearance: colours for the kinds its documents use, applied wherever a kind is coloured and never written into a document. Profiles become optional, so a project may declare only its colours. Kept at .pi-outpost/structured-exchange.json in the project.",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "schema"
+  ],
+  properties: {
+    schema: {
+      description: "Which registry format this is.",
+      const: "urn:structured-exchange-profile-registry:2"
+    },
+    profiles: {
+      description: "Profile files, by path relative to the project directory. Each must stay inside the project. May be empty or absent: a registry without profiles constrains no document.",
+      type: "array",
+      minItems: 0,
+      maxItems: 20,
+      items: {
+        type: "string",
+        minLength: 1,
+        maxLength: 500
+      }
+    },
+    rules: {
+      description: "Rules files, by path relative to the project directory. Each names the registered profile it applies to, and is checked against that profile's vocabulary whenever it is read.",
+      type: "array",
+      maxItems: 20,
+      items: {
+        type: "string",
+        minLength: 1,
+        maxLength: 500
+      }
+    },
+    default: {
+      description: "The identifier of a registered profile that documents naming no profile are held to. Declaring one also refuses documents that name an unregistered profile, and version 1 documents.",
+      type: "string",
+      minLength: 1,
+      maxLength: 200
+    },
+    appearance: {
+      description: "The project's colours for kinds, by vocabulary. A name in one map does not colour the other vocabulary; a kind not named keeps its automatic colour.",
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        kinds: {
+          type: "object",
+          maxProperties: 64,
+          propertyNames: {
+            type: "string",
+            minLength: 1,
+            maxLength: 100
+          },
+          additionalProperties: {
+            $ref: "#/$defs/kindAppearance"
+          },
+          description: "Kinds of elements, participants, table rows and timeline items."
+        },
+        relationshipKinds: {
+          type: "object",
+          maxProperties: 64,
+          propertyNames: {
+            type: "string",
+            minLength: 1,
+            maxLength: 100
+          },
+          additionalProperties: {
+            $ref: "#/$defs/kindAppearance"
+          },
+          description: "Kinds of relationships and table relations."
+        }
+      }
+    }
+  },
+  $defs: {
+    kindAppearance: {
+      description: "How one kind is drawn. Colour only; the renderer derives lighter fills from it.",
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "color"
+      ],
+      properties: {
+        color: {
+          description: "A six-digit hexadecimal colour, #rrggbb.",
+          type: "string",
+          pattern: "^#[0-9a-fA-F]{6}$"
+        }
+      }
+    }
+  }
+};
+
 // shared/src/structuredExchangeProfileValidation.ts
 var profileCheck;
 var registryCheck;
+var registryCheckV2;
 function segment(name) {
   return name.replace(/~/g, "~0").replace(/\//g, "~1");
 }
@@ -10225,27 +11988,27 @@ function profileRuleIssues(profile) {
   for (const list of ["elementKinds", "relationshipKinds"]) {
     const seenKinds = /* @__PURE__ */ new Map();
     (profile[list] ?? []).forEach((declaration, k) => {
-      const at2 = `/${list}/${k}`;
+      const at = `/${list}/${k}`;
       declared[list].add(declaration.kind);
       const firstKind = seenKinds.get(declaration.kind);
       if (firstKind === void 0) seenKinds.set(declaration.kind, k);
       else {
         issues.push({
           rule: "profile-format/duplicate-kind",
-          path: `${at2}/kind`,
+          path: `${at}/kind`,
           message: `kind "${declaration.kind}" is already declared at /${list}/${firstKind}; declare each kind once, with all its attributes`
         });
       }
       const seenAttributes = /* @__PURE__ */ new Map();
       (declaration.attributes ?? []).forEach((attribute, a) => {
-        const attributeAt = `${at2}/attributes/${a}`;
+        const attributeAt = `${at}/attributes/${a}`;
         const firstAttribute = seenAttributes.get(attribute.name);
         if (firstAttribute === void 0) seenAttributes.set(attribute.name, a);
         else {
           issues.push({
             rule: "profile-format/duplicate-attribute",
             path: `${attributeAt}/name`,
-            message: `kind "${declaration.kind}" already declares attribute "${attribute.name}" at ${at2}/attributes/${firstAttribute}`
+            message: `kind "${declaration.kind}" already declares attribute "${attribute.name}" at ${at}/attributes/${firstAttribute}`
           });
         }
         if (attribute.type === "enumeration") {
@@ -10290,12 +12053,12 @@ function profileRuleIssues(profile) {
     for (const end of ["from", "to"]) {
       const seen = /* @__PURE__ */ new Map();
       declaration[end]?.forEach((kind, position) => {
-        const at2 = `/relationshipKinds/${k}/${end}/${position}`;
+        const at = `/relationshipKinds/${k}/${end}/${position}`;
         const first = seen.get(kind);
         if (first !== void 0) {
           issues.push({
             rule: "profile-format/repeated-end-kind",
-            path: at2,
+            path: at,
             message: `relationship kind "${declaration.kind}" already names "${kind}" at /relationshipKinds/${k}/${end}/${first}`
           });
           return;
@@ -10304,7 +12067,7 @@ function profileRuleIssues(profile) {
         if (declared.elementKinds.has(kind)) return;
         issues.push({
           rule: "profile-format/unresolved-end-kind",
-          path: at2,
+          path: at,
           message: `relationship kind "${declaration.kind}" allows element kind "${kind}" at its ${end === "from" ? "source" : "target"}, which this profile does not declare; it declares ${declaredElementKinds}` + (declared.relationshipKinds.has(kind) ? ` ("${kind}" is a relationship kind here, and a relationship joins elements)` : "")
         });
       });
@@ -10312,20 +12075,20 @@ function profileRuleIssues(profile) {
   });
   const seenViewpoints = /* @__PURE__ */ new Map();
   (profile.viewpoints ?? []).forEach((viewpoint, index3) => {
-    const at2 = `/viewpoints/${index3}`;
+    const at = `/viewpoints/${index3}`;
     const first = seenViewpoints.get(viewpoint.id);
     if (first === void 0) seenViewpoints.set(viewpoint.id, index3);
     else {
       issues.push({
         rule: "profile-format/duplicate-viewpoint-identifier",
-        path: `${at2}/id`,
+        path: `${at}/id`,
         message: `viewpoint "${viewpoint.id}" is already declared at /viewpoints/${first}`
       });
     }
     if (viewpoint.elementKinds === void 0 && viewpoint.relationshipKinds === void 0) {
       issues.push({
         rule: "profile-format/empty-viewpoint",
-        path: at2,
+        path: at,
         message: `viewpoint "${viewpoint.id}" retains no kind; name elementKinds, relationshipKinds, or both`
       });
     }
@@ -10338,7 +12101,7 @@ function profileRuleIssues(profile) {
         if (declared[list].has(kind)) return;
         issues.push({
           rule: "profile-format/unresolved-viewpoint-kind",
-          path: `${at2}/${list}/${position}`,
+          path: `${at}/${list}/${position}`,
           message: `viewpoint "${viewpoint.id}" retains ${noun} kind "${kind}", which this profile does not declare` + (declared[otherList].has(kind) ? ` (it is a ${otherNoun} kind here, which is a different vocabulary)` : "")
         });
       });
@@ -10356,19 +12119,62 @@ function validateProfile(value) {
   return rules.length > 0 ? { valid: false, issues: rules } : { valid: true, profile, issues: [] };
 }
 function validateRegistry(value) {
-  registryCheck ??= Compile(unwrapSchemaModule(structured_exchange_profile_registry_1_default));
-  const schema2 = schemaIssues(registryCheck, value, "registry");
-  if (schema2.length > 0) return { valid: false, issues: schema2 };
+  const declared = value?.schema;
+  let check;
+  if (declared === STRUCTURED_EXCHANGE_PROFILE_REGISTRY_SCHEMA_V2) {
+    registryCheckV2 ??= Compile(unwrapSchemaModule(structured_exchange_profile_registry_2_default));
+    check = registryCheckV2;
+  } else {
+    registryCheck ??= Compile(unwrapSchemaModule(structured_exchange_profile_registry_1_default));
+    check = registryCheck;
+  }
+  const schema2 = schemaIssues(check, value, "registry");
+  if (schema2.length > 0) return { valid: false, issues: preciseAppearanceIssues(value, schema2) };
   const registry = value;
   const issues = [];
   const seenPaths = /* @__PURE__ */ new Map();
-  registry.profiles.forEach((listed, index3) => {
+  (registry.profiles ?? []).forEach((listed, index3) => {
     const first = seenPaths.get(listed);
     if (first === void 0) seenPaths.set(listed, index3);
     else issues.push({ rule: "registry/repeated-profile-path", path: `/profiles/${index3}`, message: `"${listed}" is already listed at /profiles/${first}` });
   });
   return issues.length > 0 ? { valid: false, issues } : { valid: true, registry, issues: [] };
 }
+function preciseAppearanceIssues(value, issues) {
+  const appearance = value?.appearance;
+  if (appearance === null || typeof appearance !== "object") return issues;
+  const precise = [];
+  const explained = /* @__PURE__ */ new Set();
+  for (const vocabulary of ["kinds", "relationshipKinds"]) {
+    const map = appearance[vocabulary];
+    if (map === null || typeof map !== "object" || Array.isArray(map)) continue;
+    const at = `/appearance/${vocabulary}`;
+    for (const [kind, entry] of Object.entries(map)) {
+      const where = `${at}/${segment(kind)}`;
+      if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+        precise.push({ rule: "registry/schema/type", path: where, message: `the appearance of "${kind}" must be an object declaring a color` });
+        explained.add(at);
+        continue;
+      }
+      const { color, ...rest } = entry;
+      if (typeof color !== "string" || !/^#[0-9a-fA-F]{6}$/.test(color)) {
+        precise.push({
+          rule: "registry/appearance/color",
+          path: `${where}/color`,
+          message: `the colour of "${kind}" must be six hexadecimal digits after "#", such as "#dc2626"; got ${JSON.stringify(color)}`
+        });
+        explained.add(at);
+      }
+      for (const name of Object.keys(rest)) {
+        precise.push({ rule: "registry/schema/additionalProperties", path: `${where}/${segment(name)}`, message: `"${name}" is not part of a kind's appearance; only "color" is` });
+        explained.add(at);
+      }
+    }
+  }
+  if (precise.length === 0) return issues;
+  const within = (issue) => [...explained].some((map) => issue.path === map || issue.path.startsWith(`${map}/`));
+  return [...issues.filter((issue) => !within(issue)), ...precise];
+}
 function registryConsistencyIssues(registry, loaded) {
   const issues = [];
   const firstById = /* @__PURE__ */ new Map();
@@ -10384,7 +12190,7 @@ function registryConsistencyIssues(registry, loaded) {
     }
   });
   if (registry.default !== void 0 && !firstById.has(registry.default)) {
-    const registered = [...firstById.keys()].map((id) => `"${id}"`).join(", ");
+    const registered = firstById.size === 0 ? "none" : [...firstById.keys()].map((id) => `"${id}"`).join(", ");
     issues.push({
       rule: "registry/unregistered-default",
       path: "/default",
@@ -10592,7 +12398,7 @@ function selectProfile(envelope, context) {
   } else {
     selected = fallback;
   }
-  if (selected === void 0 || kind === "sequence") return { outcome: "unconstrained" };
+  if (selected === void 0 || kind === "sequence" || kind === "timeline") return { outcome: "unconstrained" };
   return { outcome: "held", profile: selected };
 }
 function checkAgainstProfile(envelope, profile, options = {}) {
@@ -10663,18 +12469,18 @@ function checkAgainstProfile(envelope, profile, options = {}) {
     if (Array.isArray(value)) value.forEach((item, index3) => checkScalar(attribute, kind, item, `${path3}/${index3}`));
     else checkScalar(attribute, kind, value, path3);
   }
-  function checkItem(item, at2, vocabulary, noun) {
+  function checkItem(item, at, vocabulary, noun) {
     const kinds = vocabularies[vocabulary];
     const other = vocabularies[vocabulary === "element" ? "relationship" : "element"];
     const set = item.set ?? void 0;
     const setKind = typeof set?.kind === "string" ? set.kind : void 0;
     const ownKind = typeof item.kind === "string" ? item.kind : void 0;
     const kind = setKind ?? ownKind;
-    const kindAt = setKind !== void 0 ? `${at2}/set/kind` : `${at2}/kind`;
+    const kindAt = setKind !== void 0 ? `${at}/set/kind` : `${at}/kind`;
     if (kind === void 0) {
       issues.push({
         rule: "profile/missing-kind",
-        path: at2,
+        path: at,
         message: `this ${noun} carries no kind; profile "${profile.id}" holds every ${noun} to one of its ${vocabulary} kinds: ${quoted([...kinds.keys()])}` + (item.ref !== void 0 ? ". A changed item states its kind too, so its attributes can be checked" : "")
       });
       return;
@@ -10705,8 +12511,8 @@ function checkAgainstProfile(envelope, profile, options = {}) {
         checkValue(attribute, kind, value, path3);
       }
     };
-    checkAttributes(item.attributes, `${at2}/attributes`);
-    checkAttributes(set?.attributes, `${at2}/set/attributes`);
+    checkAttributes(item.attributes, `${at}/attributes`);
+    checkAttributes(set?.attributes, `${at}/set/attributes`);
     const required = (declaration.attributes ?? []).filter((attribute) => attribute.required === true);
     const whole = !proposal || item.ref === void 0;
     if (whole) {
@@ -10715,7 +12521,7 @@ function checkAgainstProfile(envelope, profile, options = {}) {
         if (Object.hasOwn(carried, attribute.name)) continue;
         issues.push({
           rule: "profile/missing-required-attribute",
-          path: at2,
+          path: at,
           message: `kind "${kind}" requires attribute "${attribute.name}", and this ${noun} does not carry it`
         });
       }
@@ -10726,7 +12532,7 @@ function checkAgainstProfile(envelope, profile, options = {}) {
         if (!required.some((attribute) => attribute.name === name)) return;
         issues.push({
           rule: "profile/required-attribute-removed",
-          path: `${at2}/set/removeAttributes/${index3}`,
+          path: `${at}/set/removeAttributes/${index3}`,
           message: `attribute "${String(name)}" is required on kind "${kind}", so a proposal cannot remove it`
         });
       });
@@ -10952,17 +12758,17 @@ function formIssues(file) {
   const issues = [];
   const seen = /* @__PURE__ */ new Map();
   file.rules.forEach((rule, index3) => {
-    const at2 = `/rules/${index3}`;
+    const at = `/rules/${index3}`;
     const first = seen.get(rule.id);
     if (first === void 0) seen.set(rule.id, index3);
     else {
-      issues.push({ rule: "rules-format/duplicate-rule-identifier", path: `${at2}/id`, message: `rule "${rule.id}" is already declared at /rules/${first}` });
+      issues.push({ rule: "rules-format/duplicate-rule-identifier", path: `${at}/id`, message: `rule "${rule.id}" is already declared at /rules/${first}` });
     }
     const { element, relationship } = rule;
     if (element === void 0 === (relationship === void 0)) {
       issues.push({
         rule: "rules-format/rule-form",
-        path: at2,
+        path: at,
         message: `rule "${rule.id}" must name exactly one of "element" (an item rule) or "relationship" (a link rule)`
       });
       return;
@@ -10973,7 +12779,7 @@ function formIssues(file) {
     ];
     for (const [name, clause] of clauses) {
       if (clause === void 0 || clause === "forbidden") continue;
-      const clauseAt = `${at2}/${name}`;
+      const clauseAt = `${at}/${name}`;
       if (!isConditionSet(clause)) continue;
       if (name === "then" && Object.keys(clause).length === 0) {
         issues.push({ rule: "rules-format/empty-then", path: clauseAt, message: `rule "${rule.id}" requires nothing; name conditions, or "forbidden"` });
@@ -11035,9 +12841,9 @@ function rulesAgainstProfile(file, profile) {
   const issues = [];
   const elementKinds = new Map((profile.elementKinds ?? []).map((declaration) => [declaration.kind, declaration]));
   const relationshipKinds = new Map((profile.relationshipKinds ?? []).map((declaration) => [declaration.kind, declaration]));
-  const checkConditions = (rule, conditions, at2, kinds, declaredEnd) => {
+  const checkConditions = (rule, conditions, at, kinds, declaredEnd) => {
     for (const [name, values] of Object.entries(conditions ?? {})) {
-      const attributeAt = `${at2}/${segment3(name)}`;
+      const attributeAt = `${at}/${segment3(name)}`;
       const declarations = kinds.map((kind) => (elementKinds.get(kind)?.attributes ?? []).find((attribute) => attribute.name === name)).filter((attribute) => attribute !== void 0);
       if (declarations.length === 0) {
         issues.push({
@@ -11068,24 +12874,24 @@ function rulesAgainstProfile(file, profile) {
     }
   };
   file.rules.forEach((rule, index3) => {
-    const at2 = `/rules/${index3}`;
+    const at = `/rules/${index3}`;
     if (rule.element !== void 0) {
       if (!elementKinds.has(rule.element)) {
         issues.push({
           rule: "rules-format/undeclared-kind",
-          path: `${at2}/element`,
+          path: `${at}/element`,
           message: `rule "${rule.id}" applies to element kind "${rule.element}", which profile "${profile.id}" does not declare; it declares ${quoted2([...elementKinds.keys()])}`
         });
         return;
       }
-      checkConditions(rule, rule.when, `${at2}/when`, [rule.element]);
-      if (rule.then !== "forbidden") checkConditions(rule, rule.then, `${at2}/then`, [rule.element]);
+      checkConditions(rule, rule.when, `${at}/when`, [rule.element]);
+      if (rule.then !== "forbidden") checkConditions(rule, rule.then, `${at}/then`, [rule.element]);
       return;
     }
     if (!relationshipKinds.has(rule.relationship)) {
       issues.push({
         rule: "rules-format/undeclared-kind",
-        path: `${at2}/relationship`,
+        path: `${at}/relationship`,
         message: `rule "${rule.id}" applies to relationship kind "${rule.relationship}", which profile "${profile.id}" does not declare; it declares ${quoted2([...relationshipKinds.keys()])}`
       });
       return;
@@ -11101,7 +12907,7 @@ function rulesAgainstProfile(file, profile) {
       for (const [side, position] of [["from", "source"], ["to", "target"]]) {
         const allowed = declaration?.[side];
         const described = allowed === void 0 ? void 0 : `${position} of "${rule.relationship}"`;
-        checkConditions(rule, clause[side], `${at2}/${name}/${side}`, allowed ?? anyElement, described);
+        checkConditions(rule, clause[side], `${at}/${name}/${side}`, allowed ?? anyElement, described);
       }
     }
   });
@@ -11207,7 +13013,7 @@ async function readProjectRegistry(projectRoot, registryPath = STRUCTURED_EXCHAN
   const files = [];
   const issues = [];
   const loaded = [];
-  for (const [index3, listed] of registry.profiles.entries()) {
+  for (const [index3, listed] of (registry.profiles ?? []).entries()) {
     const read = await readConfinedJson(root, listed, STRUCTURED_EXCHANGE_PROFILE_CEILINGS.profileBytes, "profile-format");
     if (read.ok === "missing") {
       issues.push({ rule: "registry/missing-profile", path: `/profiles/${index3}`, message: `"${listed}" does not exist`, file: registryFile });
@@ -11269,7 +13075,8 @@ async function readProjectRegistry(projectRoot, registryPath = STRUCTURED_EXCHAN
     state: "usable",
     context: { profiles, ...registry.default !== void 0 ? { default: registry.default } : {}, ...rules.size > 0 ? { rules } : {} },
     files,
-    filesByProfile
+    filesByProfile,
+    ...registry.appearance !== void 0 ? { appearance: registry.appearance } : {}
   };
 }
 
@@ -12370,7 +14177,7 @@ function rulePatterns(profile, rules, sources) {
 }
 
 // shared/bin/validate-structured-exchange.mjs
-var VERSION = `validate-structured-exchange ${false ? "development" : "0.32.4"}`;
+var VERSION = `validate-structured-exchange ${false ? "development" : "0.34.0"}`;
 var USAGE = `validate-structured-exchange [file]
 validate-structured-exchange --profile <profile.json> [file]
 validate-structured-exchange --check-profile <profile.json>