@rubytech/create-maxy-code 0.1.570 → 0.1.572

package/payload/platform/lib/dispatch-write/src/index.ts

@@ -0,0 +1,37 @@
+/**
+ * Dispatch writes, shared by the MCP tools and the field job sheet.
+ *
+ * One implementation of the visit-write semantics and the transition contract.
+ * Before this package existed both lived inside the dispatch plugin, where a
+ * UI route cannot reach them, so the field job sheet's only options were a
+ * second implementation or a process spawn per checklist tick.
+ *
+ * Two consumption shapes, matching `dispatch-read`: `platform/ui` imports from
+ * `src` (tsup bundles the TypeScript), plugins import from `dist` (built by the
+ * platform `build:lib` chain, which runs before the plugin glob).
+ */
+export {
+  checkTransition,
+  firstMissingRequiredField,
+  formatTransitionRefused,
+  initialStatus,
+  isTerminal,
+} from "./lifecycle.js";
+
+export type {
+  TransitionCheck,
+  TransitionKind,
+  VisitRecordState,
+} from "./lifecycle.js";
+
+// Session-taking writes: the plugin's, which owns its own driver.
+export { visitRecord, visitStatusSet } from "./write.js";
+
+export type {
+  StatusSource,
+  VisitRecordParams,
+  VisitRecordResult,
+  VisitStatusResult,
+  VisitStatusSetParams,
+  WriteOutcome,
+} from "./write.js";

package/payload/platform/lib/dispatch-write/src/lifecycle.ts

@@ -0,0 +1,128 @@
+/**
+ * Dispatch writes, shared by the MCP tools and the field job sheet.
+ *
+ * The sibling of `dispatch-read`, and for the same reason: the field Mini App's
+ * route must be assertable as holding no graph access while still writing to
+ * the graph. Two consumption shapes, matching that package — session-taking
+ * functions for the plugin, which owns its driver, and session-owning wrappers
+ * for the UI route, which must not.
+ */
+
+/**
+ * Transition legality, read from the account's own edge list.
+ *
+ * Legality is data. No status string appears in this file: the caller passes
+ * the config and the pair, and the answer is membership in that config's
+ * transition list for the matching kind. A taxi firm's Booked → Dispatched and
+ * a contractor's New → Allocated run this same function against different data.
+ *
+ * A refusal is never swallowed. `op=transition-refused` carries both ends and
+ * the reason, because "the status did not change" with no line is
+ * indistinguishable from a request nobody made.
+ */
+// A sibling library is consumed through its `dist`, never its `src`: this
+// package's `rootDir` is its own `src`, so a source import fails the build.
+// Same shape as graph-mcp → graph-write/dist and graph-search → graph-trash/dist.
+import type { DispatchConfig, RecordableField } from "../../dispatch-read/dist/index.js";
+import { RECORDABLE_FIELDS } from "../../dispatch-read/dist/index.js";
+
+export type TransitionKind = "job" | "visit";
+
+export type TransitionCheck =
+  | { readonly legal: true }
+  | { readonly legal: false; readonly reason: "not-in-config" };
+
+export function checkTransition(
+  kind: TransitionKind,
+  from: string,
+  to: string,
+  cfg: DispatchConfig,
+): TransitionCheck {
+  const edges =
+    kind === "job" ? cfg.statuses.jobTransitions : cfg.statuses.visitTransitions;
+  const legal = edges.some(([f, t]) => f === from && t === to);
+  return legal ? { legal: true } : { legal: false, reason: "not-in-config" };
+}
+
+/** Is this a declared terminal status of the given kind? */
+export function isTerminal(
+  kind: TransitionKind,
+  status: string,
+  cfg: DispatchConfig,
+): boolean {
+  const list = kind === "job" ? cfg.statuses.job : cfg.statuses.visit;
+  return list.some((s) => s.name === status && s.terminal);
+}
+
+/** The status a newly created job or visit starts in: the first declared. */
+export function initialStatus(kind: TransitionKind, cfg: DispatchConfig): string {
+  const list = kind === "job" ? cfg.statuses.job : cfg.statuses.visit;
+  return list[0].name;
+}
+
+/** What a visit currently carries, for the required-before-terminal check. */
+export interface VisitRecordState {
+  readonly notes: number;
+  readonly media: number;
+  readonly parts: number;
+  readonly checklistDone: number;
+  readonly checklistTotal: number;
+  readonly signatures: number;
+}
+
+function fieldSatisfied(field: RecordableField, state: VisitRecordState): boolean {
+  switch (field) {
+    case "notes":
+      return state.notes > 0;
+    case "media":
+      return state.media > 0;
+    case "parts":
+      return state.parts > 0;
+    case "signature":
+      return state.signatures > 0;
+    case "checklist":
+      // Every item, not merely one: a half-done checklist is the case this
+      // guard exists for.
+      return state.checklistTotal > 0 && state.checklistDone >= state.checklistTotal;
+    default:
+      // Unreachable while RECORDABLE_FIELDS and this switch agree. Answering
+      // false rather than throwing keeps an unknown field a REFUSAL to close
+      // the visit, which is the safe direction: a throw here would abort the
+      // status change with a stack trace instead of a named missing field.
+      return false;
+  }
+}
+
+/**
+ * The first `records.requiredBeforeTerminal` field this visit does not carry,
+ * or null when it carries them all. Returns the FIRST rather than all of them
+ * so the refusal names one concrete thing to go and do.
+ */
+export function firstMissingRequiredField(
+  toStatus: string,
+  cfg: DispatchConfig,
+  state: VisitRecordState,
+): RecordableField | null {
+  const required = cfg.records.requiredBeforeTerminal[toStatus];
+  if (!required) return null;
+  for (const field of required) {
+    if (!RECORDABLE_FIELDS.includes(field as RecordableField)) continue;
+    if (!fieldSatisfied(field as RecordableField, state)) {
+      return field as RecordableField;
+    }
+  }
+  return null;
+}
+
+export function formatTransitionRefused(p: {
+  jobId: string;
+  visitId: string | null;
+  from: string;
+  to: string;
+  reason: string;
+}): string {
+  return (
+    `[dispatch] op=transition-refused jobId=${p.jobId} visitId=${p.visitId ?? "none"} ` +
+    `from=${p.from} to=${p.to} reason=${p.reason}`
+  );
+}

package/payload/platform/lib/dispatch-write/src/write.ts

@@ -0,0 +1,389 @@
+/**
+ * The two visit writes, shared by the MCP tools and the field job sheet.
+ *
+ * Moved out of `platform/plugins/dispatch/mcp/src/tools/` unchanged except for
+ * the return shape. The plugin's tool files are now adapters that map the
+ * outcome below onto `ToolResult`.
+ */
+import type { Session } from "neo4j-driver";
+import type { DispatchConfig } from "../../dispatch-read/dist/index.js";
+import {
+  readVisit,
+  readVisitRecordState,
+  readVisitsForJob,
+} from "../../dispatch-read/dist/index.js";
+import {
+  checkTransition,
+  firstMissingRequiredField,
+  formatTransitionRefused,
+  isTerminal,
+  type VisitRecordState,
+} from "./lifecycle.js";
+
+/**
+ * A domain answer, not an MCP one.
+ *
+ * The plugin maps this onto `ToolResult`; the field route maps it onto an HTTP
+ * status and a JSON body. Returning the MCP shape from a shared library would
+ * have made the route parse a JSON string out of a text block to learn whether
+ * a write succeeded.
+ *
+ * `reason` is a stable machine token and `message` is the operator-facing text.
+ * They are separate because the route branches on the first and renders the
+ * second, and a route that branched on prose would break the day somebody
+ * improved the wording.
+ */
+export type WriteOutcome<T> =
+  | { readonly ok: true; readonly value: T }
+  | { readonly ok: false; readonly reason: string; readonly message: string };
+
+function refuse(reason: string, message: string): { ok: false; reason: string; message: string } {
+  return { ok: false, reason, message };
+}
+
+// ---------------------------------------------------------------------------
+// visit-record
+// ---------------------------------------------------------------------------
+
+/**
+ * Record what happened on the visit: a note, a photo, a part, a ticked
+ * checklist item, a signature, an arrival.
+ *
+ * Each arrival property is written with its **own** SET clause and only when
+ * that call supplies it. That is the load-bearing detail of the whole tool. A
+ * pressed arrival is what somebody said; an observed one is what was measured.
+ * If a single write set both, recording one would blank the other, and the
+ * disagreement between them — which is the finding worth having — would be
+ * destroyed by the act of recording it.
+ *
+ * An observation with no press is stored and flagged, not dropped: a worker who
+ * never pressed arrive is precisely the case the geofence exists to cover.
+ */
+export interface VisitRecordParams {
+  session: Session;
+  accountId: string;
+  cfg: DispatchConfig;
+  emit: (line: string) => void;
+  visitId: string;
+  note?: string;
+  mediaRef?: string;
+  partId?: string;
+  checklistItem?: string;
+  signature?: string;
+  arrivedPressedAt?: string;
+  arrivedObservedAt?: string;
+  arrivedObservedDistanceM?: number;
+}
+
+export interface VisitRecordResult {
+  visitId: string;
+  jobId: string | null;
+  recorded: VisitRecordState;
+  arrivedPressedAt: string | null;
+  arrivedObservedAt: string | null;
+  arrivedObservedDistanceM: number | null;
+  vocabulary: DispatchConfig["vocabulary"];
+}
+
+export async function visitRecord(
+  p: VisitRecordParams,
+): Promise<WriteOutcome<VisitRecordResult>> {
+  const visit = await readVisit(p.session, p.accountId, p.visitId);
+  if (!visit) {
+    return refuse(
+      "not-found",
+      `No ${p.cfg.vocabulary.visit} "${p.visitId}" on this account.`,
+    );
+  }
+
+  const sets: string[] = [];
+  const params: Record<string, unknown> = {
+    accountId: p.accountId,
+    visitId: p.visitId,
+  };
+
+  if (p.note !== undefined) {
+    sets.push("v.notes = coalesce(v.notes, []) + $note");
+    params.note = p.note;
+  }
+  if (p.mediaRef !== undefined) {
+    sets.push("v.media = coalesce(v.media, []) + $mediaRef");
+    params.mediaRef = p.mediaRef;
+  }
+  if (p.partId !== undefined) {
+    sets.push("v.parts = coalesce(v.parts, []) + $partId");
+    params.partId = p.partId;
+  }
+  if (p.checklistItem !== undefined) {
+    // Not validated against the job type's template. A worker who ticks
+    // something the template does not list has still done it, and refusing the
+    // record would lose the only account of it.
+    sets.push(
+      "v.checklistDone = CASE WHEN $checklistItem IN coalesce(v.checklistDone, []) " +
+        "THEN v.checklistDone ELSE coalesce(v.checklistDone, []) + $checklistItem END",
+    );
+    params.checklistItem = p.checklistItem;
+  }
+  if (p.signature !== undefined) {
+    sets.push("v.signatures = coalesce(v.signatures, []) + $signature");
+    params.signature = p.signature;
+  }
+
+  // Three separate SET clauses, never one object assignment. Each fires only
+  // when this call supplied that value, so neither arrival can clear the other.
+  if (p.arrivedPressedAt !== undefined) {
+    sets.push("v.arrivedPressedAt = $arrivedPressedAt");
+    params.arrivedPressedAt = p.arrivedPressedAt;
+  }
+  if (p.arrivedObservedAt !== undefined) {
+    sets.push("v.arrivedObservedAt = $arrivedObservedAt");
+    params.arrivedObservedAt = p.arrivedObservedAt;
+  }
+  if (p.arrivedObservedDistanceM !== undefined) {
+    sets.push("v.arrivedObservedDistanceM = $arrivedObservedDistanceM");
+    params.arrivedObservedDistanceM = p.arrivedObservedDistanceM;
+  }
+
+  if (sets.length === 0) {
+    return refuse(
+      "nothing-to-record",
+      `Nothing to record. Supply at least one of: note, mediaRef, partId, checklistItem, signature, arrivedPressedAt, arrivedObservedAt.`,
+    );
+  }
+
+  await p.session.run(
+    `MATCH (v:Visit {accountId: $accountId, visitId: $visitId}) SET ${sets.join(", ")}`,
+    params,
+  );
+
+  const state = await readVisitRecordState(p.session, p.accountId, p.visitId);
+  p.emit(
+    `[dispatch] op=visit-record visitId=${p.visitId} notes=${state.notes} ` +
+      `media=${state.media} parts=${state.parts} ` +
+      `checklist=${state.checklistDone}/${state.checklistTotal} ` +
+      `signatures=${state.signatures}`,
+  );
+
+  if (p.arrivedObservedAt !== undefined) {
+    // The press this observation is being compared against is whichever one the
+    // visit already carried, or the one this same call supplied.
+    const pressedAt = p.arrivedPressedAt ?? visit.arrivedPressedAt;
+    const deltaS =
+      pressedAt === null || pressedAt === undefined
+        ? null
+        : Math.round(
+            (Date.parse(p.arrivedObservedAt) - Date.parse(pressedAt)) / 1000,
+          );
+    p.emit(
+      `[dispatch] op=arrival-observed visitId=${p.visitId} ` +
+        `distanceM=${p.arrivedObservedDistanceM ?? "none"} ` +
+        `observedAt=${p.arrivedObservedAt} pressedAt=${pressedAt ?? "none"} ` +
+        `deltaS=${deltaS ?? "none"}`,
+    );
+  }
+
+  const after = await readVisit(p.session, p.accountId, p.visitId);
+  return {
+    ok: true,
+    value: {
+      visitId: p.visitId,
+      jobId: visit.jobId,
+      recorded: state,
+      arrivedPressedAt: after?.arrivedPressedAt ?? null,
+      arrivedObservedAt: after?.arrivedObservedAt ?? null,
+      arrivedObservedDistanceM: after?.arrivedObservedDistanceM ?? null,
+      vocabulary: p.cfg.vocabulary,
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// visit-status-set
+// ---------------------------------------------------------------------------
+
+/**
+ * Move a visit between statuses, and close the job when the last one lands.
+ *
+ * Two refusals, both loud, both naming what was attempted:
+ *
+ *   - the transition is not in the account's edge list → `not-in-config`
+ *   - the visit does not carry a field the target status requires →
+ *     `missing-required-field:<f>`
+ *
+ * Neither is swallowed. A status that quietly failed to change is
+ * indistinguishable from one nobody tried to change, and that is the whole
+ * failure mode this tool exists inside of.
+ *
+ * `op=job-close` carries `recordLagS`: the gap between the work ending and the
+ * record being written. On the reference account one worker closed Monday's
+ * jobs on Tuesday morning, so every finish time was when a button was pressed.
+ * The number is the only way to see that happening again.
+ */
+export type StatusSource = "press" | "geofence" | "office";
+
+export interface VisitStatusSetParams {
+  session: Session;
+  accountId: string;
+  cfg: DispatchConfig;
+  emit: (line: string) => void;
+  now: () => number;
+  by: string;
+  visitId: string;
+  to: string;
+  source: StatusSource;
+}
+
+export interface VisitStatusResult {
+  visitId: string;
+  jobId: string | null;
+  from: string;
+  to: string;
+  at: string;
+  source: StatusSource;
+  jobClosed: string | null;
+  vocabulary: DispatchConfig["vocabulary"];
+}
+
+export async function visitStatusSet(
+  p: VisitStatusSetParams,
+): Promise<WriteOutcome<VisitStatusResult>> {
+  const visit = await readVisit(p.session, p.accountId, p.visitId);
+  if (!visit) {
+    return refuse(
+      "not-found",
+      `No ${p.cfg.vocabulary.visit} "${p.visitId}" on this account.`,
+    );
+  }
+
+  const declared = p.cfg.statuses.visit.some((s) => s.name === p.to);
+  if (!declared) {
+    p.emit(
+      formatTransitionRefused({
+        jobId: visit.jobId ?? "none",
+        visitId: p.visitId,
+        from: visit.status,
+        to: p.to,
+        reason: "not-in-config",
+      }),
+    );
+    return refuse(
+      "not-in-config",
+      `"${p.to}" is not a ${p.cfg.vocabulary.visit} status on this account. Declared: ${p.cfg.statuses.visit.map((s) => s.name).join(", ")}.`,
+    );
+  }
+
+  const check = checkTransition("visit", visit.status, p.to, p.cfg);
+  if (!check.legal) {
+    p.emit(
+      formatTransitionRefused({
+        jobId: visit.jobId ?? "none",
+        visitId: p.visitId,
+        from: visit.status,
+        to: p.to,
+        reason: check.reason,
+      }),
+    );
+    const legalNext = p.cfg.statuses.visitTransitions
+      .filter(([from]) => from === visit.status)
+      .map(([, to]) => to);
+    return refuse(
+      check.reason,
+      `This account allows no move from "${visit.status}" to "${p.to}". From "${visit.status}" it allows: ${legalNext.join(", ") || "nothing"}.`,
+    );
+  }
+
+  const state = await readVisitRecordState(p.session, p.accountId, p.visitId);
+  const missing = firstMissingRequiredField(p.to, p.cfg, state);
+  if (missing) {
+    p.emit(
+      formatTransitionRefused({
+        jobId: visit.jobId ?? "none",
+        visitId: p.visitId,
+        from: visit.status,
+        to: p.to,
+        reason: `missing-required-field:${missing}`,
+      }),
+    );
+    return refuse(
+      `missing-required-field:${missing}`,
+      `This account requires ${missing} on a ${p.cfg.vocabulary.visit} before it reaches "${p.to}". Record it with dispatch-visit-record first.`,
+    );
+  }
+
+  const at = new Date(p.now()).toISOString();
+  const terminal = isTerminal("visit", p.to, p.cfg);
+  // `closedAt` only. `endDate` is the PLANNED end, written at allocation from
+  // the job type's duration, and it is the closest thing this ontology has to
+  // when the worker left. Overwriting it with the close instant would destroy
+  // the plan and make the two identical, so every lag computed from it would
+  // be zero — which is exactly the number this task exists to stop reporting.
+  await p.session.run(
+    `MATCH (v:Visit {accountId: $accountId, visitId: $visitId})
+     SET v.status = $status` + (terminal ? `, v.closedAt = $at` : ``),
+    { accountId: p.accountId, visitId: p.visitId, status: p.to, at },
+  );
+
+  p.emit(
+    `[dispatch] op=visit-status jobId=${visit.jobId ?? "none"} visitId=${p.visitId} ` +
+      `from=${visit.status} to=${p.to} by=${p.by} at=${at} source=${p.source}`,
+  );
+
+  let jobClosed: string | null = null;
+  if (terminal && visit.jobId) {
+    const siblings = await readVisitsForJob(p.session, p.accountId, visit.jobId);
+    const allTerminal = siblings.every(
+      (v) => v.visitId === p.visitId || isTerminal("visit", v.status, p.cfg),
+    );
+    if (allTerminal) {
+      const terminalJobStatus = p.cfg.statuses.job.find((s) => s.terminal)?.name;
+      if (terminalJobStatus) {
+        await p.session.run(
+          `MATCH (j:Job {accountId: $accountId, jobId: $jobId}) SET j.status = $status, j.closedAt = $at`,
+          {
+            accountId: p.accountId,
+            jobId: visit.jobId,
+            status: terminalJobStatus,
+            at,
+          },
+        );
+        jobClosed = terminalJobStatus;
+      }
+      // Measured from when the worker was due to LEAVE, not from when they
+      // arrived. Nothing in this ontology records leaving site, so the planned
+      // `endDate` is the proxy — and it is the right one, because measuring
+      // from arrival adds the whole job duration to every lag and would report
+      // a two-hour job closed on the doorstep as two hours late.
+      //
+      // The ladder falls back to an arrival and then to the start only when a
+      // visit carries no planned end, which allocation always writes. Falling
+      // back to `at` would make every lag zero and hide what this counts.
+      const dueToLeaveAt =
+        visit.endDate ??
+        visit.arrivedPressedAt ??
+        visit.arrivedObservedAt ??
+        visit.startDate;
+      const recordLagS =
+        dueToLeaveAt === null
+          ? 0
+          : Math.max(0, Math.round((Date.parse(at) - Date.parse(dueToLeaveAt)) / 1000));
+      p.emit(
+        `[dispatch] op=job-close jobId=${visit.jobId} visits=${siblings.length} ` +
+          `terminal=${p.to} recordLagS=${recordLagS}`,
+      );
+    }
+  }
+
+  return {
+    ok: true,
+    value: {
+      visitId: p.visitId,
+      jobId: visit.jobId,
+      from: visit.status,
+      to: p.to,
+      at,
+      source: p.source,
+      jobClosed,
+      vocabulary: p.cfg.vocabulary,
+    },
+  };
+}

package/payload/platform/lib/dispatch-write/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"],
+  "exclude": ["src/__tests__"]
+}

package/payload/platform/lib/graph-style/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAmOtD,CAAA;AAED,eAAO,MAAM,qBAAqB,YAAY,CAAA;AAE9C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,sBAAsB,EAAE,WAAW,CAAC,MAAM,CAE/B,CAAA;AAExB,eAAO,MAAM,gBAAgB,EAAE,SAAS,MAAM,EAE7C,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,GAAG,IAAI,CAOzE;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEpD;AAiBD,eAAO,MAAM,qBAAqB,sFAQxB,CAAA;AAEV,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,CAAC,CAAA;AAEnE,eAAO,MAAM,oBAAoB,EAAE,cAAsB,CAAA;AAUzD,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,CAE3D;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,EAAE,WAAW,CAAC,MAAM,CAEjC,CAAA;AA4IxB;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAIzD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAY7D;AAED,MAAM,WAAW,kBAAkB;IACjC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,MAAM,EAAE,MAAM,CAAA;IACd,eAAe,EAAE,MAAM,CAAA;CACxB;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,kBAAkB,CAU/E;AASD;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACpC;AAKD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAI7D;AAED,iEAAiE;AACjE,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAIjE;AA2BD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CA+H1D;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CA2F3D"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CA2OtD,CAAA;AAED,eAAO,MAAM,qBAAqB,YAAY,CAAA;AAE9C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,sBAAsB,EAAE,WAAW,CAAC,MAAM,CAE/B,CAAA;AAExB,eAAO,MAAM,gBAAgB,EAAE,SAAS,MAAM,EAE7C,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,GAAG,IAAI,CAOzE;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEpD;AAiBD,eAAO,MAAM,qBAAqB,sFAQxB,CAAA;AAEV,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,CAAC,CAAA;AAEnE,eAAO,MAAM,oBAAoB,EAAE,cAAsB,CAAA;AAUzD,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,CAE3D;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,EAAE,WAAW,CAAC,MAAM,CAEjC,CAAA;AA4IxB;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAIzD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAY7D;AAED,MAAM,WAAW,kBAAkB;IACjC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,MAAM,EAAE,MAAM,CAAA;IACd,eAAe,EAAE,MAAM,CAAA;CACxB;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,kBAAkB,CAU/E;AASD;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACpC;AAKD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAI7D;AAED,iEAAiE;AACjE,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAIjE;AA2BD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CA+H1D;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CA2F3D"}

package/payload/platform/lib/graph-style/dist/index.js

@@ -60,6 +60,14 @@ exports.GRAPH_LABEL_COLOURS = {
     // and takes the Person colour; :Supplier is an additional label on
     // Organization and takes the tobacco Organization colour. All hexes here are
     // pairwise-unique across the registry.
+    //
+    // Task 2499 split their DECLARED home without changing a hue: Job, Customer,
+    // Site, Asset, Visit and Part now live in schema-dispatch.md, which any
+    // businessType resolves when the dispatch plugin is enabled; Quote,
+    // WhatsAppGroup, PurchaseOrder and PpmContract stay in
+    // schema-construction.md. The colours are the same family either way, because
+    // an operator reading a legend cares what the node is, not which markdown
+    // file declares it.
     Job: '#8C3B2E',
     Quote: '#A65A4A',
     Invoice: '#6E4A1F',