@rubytech/create-maxy-code 0.1.571 → 0.1.573

package/payload/platform/lib/dispatch-read/src/__tests__/read.test.ts

@@ -0,0 +1,181 @@
+import { describe, expect, it } from "vitest";
+import { buildJobListQuery, nonZuluStarts, projectJob, projectVisit } from "../read.js";
+import type { PlannerVisit } from "../types.js";
+
+function row(pairs: Record<string, unknown>): { get(key: string): unknown } {
+  return { get: (k: string) => pairs[k] };
+}
+
+describe("projectVisit", () => {
+  it("carries customer and job type, which the planner card needs and the shipped projection omitted", () => {
+    const v = projectVisit(
+      row({
+        visitId: "V1",
+        jobId: "J1",
+        status: "Travelling",
+        startDate: "2026-08-07T09:00:00.000Z",
+        endDate: "2026-08-07T10:00:00.000Z",
+        purpose: null,
+        workerId: "W1",
+        siteName: "Mill Lane",
+        customerId: "C1",
+        customerName: "Ecolec",
+        jobType: "EV charger",
+        arrivedPressedAt: null,
+        arrivedObservedAt: null,
+        arrivedObservedDistanceM: null,
+      }),
+    );
+    expect(v.customerName).toBe("Ecolec");
+    expect(v.customerId).toBe("C1");
+    expect(v.jobType).toBe("EV charger");
+    expect(v.siteName).toBe("Mill Lane");
+  });
+
+  it("keeps pressed and observed arrival separate, never merged into one value", () => {
+    const v = projectVisit(
+      row({
+        visitId: "V2",
+        jobId: null,
+        status: "On site",
+        startDate: "2026-08-07T09:00:00.000Z",
+        endDate: null,
+        purpose: null,
+        workerId: "W1",
+        siteName: null,
+        customerId: null,
+        customerName: null,
+        jobType: null,
+        arrivedPressedAt: "2026-08-07T09:05:00.000Z",
+        arrivedObservedAt: "2026-08-07T08:58:00.000Z",
+        arrivedObservedDistanceM: 42,
+      }),
+    );
+    expect(v.arrivedPressedAt).toBe("2026-08-07T09:05:00.000Z");
+    expect(v.arrivedObservedAt).toBe("2026-08-07T08:58:00.000Z");
+    expect(v.arrivedObservedDistanceM).toBe(42);
+  });
+
+  it("coerces a neo4j integer distance without losing the value", () => {
+    const v = projectVisit(
+      row({
+        visitId: "V3",
+        jobId: null,
+        status: "On site",
+        startDate: null,
+        endDate: null,
+        purpose: null,
+        workerId: null,
+        siteName: null,
+        customerId: null,
+        customerName: null,
+        jobType: null,
+        arrivedPressedAt: null,
+        arrivedObservedAt: null,
+        arrivedObservedDistanceM: { low: 137, high: 0 },
+      }),
+    );
+    expect(v.arrivedObservedDistanceM).toBe(137);
+  });
+
+  it("renders an empty string as null so a blank never reads as a real value", () => {
+    const v = projectVisit(
+      row({
+        visitId: "V4",
+        jobId: "",
+        status: "Booked",
+        startDate: "",
+        endDate: null,
+        purpose: null,
+        workerId: null,
+        siteName: null,
+        customerId: null,
+        customerName: null,
+        jobType: null,
+        arrivedPressedAt: null,
+        arrivedObservedAt: null,
+        arrivedObservedDistanceM: null,
+      }),
+    );
+    expect(v.jobId).toBeNull();
+    expect(v.startDate).toBeNull();
+  });
+});
+
+describe("projectJob", () => {
+  it("returns the shipped JobRow shape unchanged", () => {
+    const j = projectJob(
+      row({
+        jobId: "M0016452",
+        status: "Booked",
+        jobType: "EV charger",
+        slaTargetAt: "2026-08-10T00:00:00.000Z",
+        createdAt: "2026-08-01T00:00:00.000Z",
+        siteId: "S1",
+        siteName: "Mill Lane",
+        customerId: "C1",
+      }),
+    );
+    expect(j).toEqual({
+      jobId: "M0016452",
+      status: "Booked",
+      jobType: "EV charger",
+      slaTargetAt: "2026-08-10T00:00:00.000Z",
+      createdAt: "2026-08-01T00:00:00.000Z",
+      siteId: "S1",
+      siteName: "Mill Lane",
+      customerId: "C1",
+    });
+  });
+});
+
+describe("nonZuluStarts", () => {
+  /**
+   * The window compare is lexical, so an offset-bearing start is wrong by the
+   * offset: correct under GMT, an hour out under BST. The writer stores the
+   * caller's string verbatim, so this cannot be fixed on read — only seen.
+   */
+  it("names the visits whose start would break the lexical window compare", () => {
+    const visits = [
+      { visitId: "V1", startDate: "2026-08-07T09:00:00.000Z" },
+      { visitId: "V2", startDate: "2026-08-07T09:00:00+01:00" },
+      { visitId: "V3", startDate: null },
+    ] as PlannerVisit[];
+    expect(nonZuluStarts(visits)).toEqual(["V2"]);
+  });
+
+  it("is empty when every start is Zulu-normalised", () => {
+    const visits = [{ visitId: "V1", startDate: "2026-08-07T09:00:00.000Z" }] as PlannerVisit[];
+    expect(nonZuluStarts(visits)).toEqual([]);
+  });
+});
+
+describe("buildJobListQuery", () => {
+  it("carries both window bounds in one EXISTS so two different visits cannot satisfy them", () => {
+    const { text } = buildJobListQuery({
+      from: "2026-08-03T00:00:00.000Z",
+      to: "2026-08-10T00:00:00.000Z",
+    });
+    expect((text.match(/EXISTS \{/g) ?? []).length).toBe(1);
+    expect(text).toContain("wv.startDate >= $from AND wv.startDate < $to");
+  });
+
+  it("scopes by the accountId property, never by an ownership edge", () => {
+    const { text } = buildJobListQuery({});
+    expect(text).toContain("j.accountId = $accountId");
+    expect(text).not.toContain("OWNS");
+  });
+
+  it("clamps the limit into the shipped bounds", () => {
+    expect(buildJobListQuery({ limit: 9999 }).params.limit).toBe(500);
+    expect(buildJobListQuery({ limit: 0 }).params.limit).toBe(1);
+    expect(buildJobListQuery({}).params.limit).toBe(50);
+  });
+
+  it("adds the unallocated clause only when asked", () => {
+    expect(buildJobListQuery({ unallocatedOnly: true }).text).toContain(
+      "NOT (j)-[:HAS_VISIT]->(:Visit)",
+    );
+    expect(buildJobListQuery({}).text).not.toContain("NOT (j)-[:HAS_VISIT]->(:Visit)");
+  });
+});

package/payload/platform/lib/dispatch-read/src/__tests__/window.test.ts

@@ -0,0 +1,137 @@
+import { describe, expect, it } from "vitest";
+import {
+  MAX_RANGE_DAYS,
+  currentWeekYmd,
+  minutesIntoDay,
+  ymdInZone,
+  zonedDayStartUtc,
+  zonedRangeBounds,
+} from "../window.js";
+
+/**
+ * These are the cases `dispatch-day` could not express. It bounded a day with a
+ * literal `Z`, so a London account in summer lost every visit between local
+ * midnight and 01:00 to the previous day.
+ */
+
+describe("zonedDayStartUtc", () => {
+  it("is an hour before midnight UTC during British Summer Time", () => {
+    expect(zonedDayStartUtc("2026-08-07", "Europe/London")).toBe("2026-08-06T23:00:00.000Z");
+  });
+
+  it("is midnight UTC in London in winter", () => {
+    expect(zonedDayStartUtc("2026-01-15", "Europe/London")).toBe("2026-01-15T00:00:00.000Z");
+  });
+
+  it("is thirteen hours earlier in Auckland during their summer", () => {
+    expect(zonedDayStartUtc("2026-01-15", "Pacific/Auckland")).toBe("2026-01-14T11:00:00.000Z");
+  });
+
+  it("resolves the spring-forward boundary without landing an hour out", () => {
+    // BST began 2026-03-29 at 01:00 UTC. The 29th still starts at 00:00 GMT;
+    // the 30th starts an hour earlier in UTC terms because the clocks moved.
+    expect(zonedDayStartUtc("2026-03-29", "Europe/London")).toBe("2026-03-29T00:00:00.000Z");
+    expect(zonedDayStartUtc("2026-03-30", "Europe/London")).toBe("2026-03-29T23:00:00.000Z");
+  });
+
+  it("refuses a malformed date rather than coercing it", () => {
+    expect(() => zonedDayStartUtc("last-tuesday", "Europe/London")).toThrow(/bad-date/);
+  });
+});
+
+describe("zonedRangeBounds", () => {
+  it("makes the upper bound the exclusive start of the day after", () => {
+    const { fromUtc, toUtc } = zonedRangeBounds("2026-08-03", "2026-08-09", "Europe/London");
+    expect(fromUtc).toBe("2026-08-02T23:00:00.000Z");
+    expect(toUtc).toBe("2026-08-09T23:00:00.000Z");
+  });
+
+  it("refuses a range wider than the cap rather than truncating it", () => {
+    expect(() => zonedRangeBounds("2026-01-01", "2026-03-01", "Europe/London")).toThrow(
+      /range-too-wide/,
+    );
+  });
+
+  it("allows a range exactly at the cap", () => {
+    expect(() => zonedRangeBounds("2026-01-01", "2026-01-31", "Europe/London")).not.toThrow();
+  });
+
+  it("refuses an inverted range", () => {
+    expect(() => zonedRangeBounds("2026-08-09", "2026-08-03", "Europe/London")).toThrow(
+      /range-inverted/,
+    );
+  });
+
+  it("allows a single day", () => {
+    const { fromUtc, toUtc } = zonedRangeBounds("2026-08-07", "2026-08-07", "Europe/London");
+    expect(fromUtc).toBe("2026-08-06T23:00:00.000Z");
+    expect(toUtc).toBe("2026-08-07T23:00:00.000Z");
+  });
+});
+
+describe("ymdInZone", () => {
+  it("reads the local date, not the UTC one, either side of midnight", () => {
+    // 22:30Z on the 5th is 23:30 on the 5th in London during BST.
+    expect(ymdInZone(Date.parse("2026-08-05T22:30:00.000Z"), "Europe/London")).toBe("2026-08-05");
+    // 23:30Z on the 5th is 00:30 on the 6th in London during BST.
+    expect(ymdInZone(Date.parse("2026-08-05T23:30:00.000Z"), "Europe/London")).toBe("2026-08-06");
+  });
+
+  it("is a day ahead in Auckland", () => {
+    expect(ymdInZone(Date.parse("2026-08-05T22:30:00.000Z"), "Pacific/Auckland")).toBe("2026-08-06");
+  });
+});
+
+describe("minutesIntoDay", () => {
+  it("counts from local midnight, not UTC midnight", () => {
+    expect(minutesIntoDay(Date.parse("2026-08-05T22:30:00.000Z"), "Europe/London")).toBe(
+      23 * 60 + 30,
+    );
+  });
+
+  it("is zero at local midnight", () => {
+    expect(minutesIntoDay(Date.parse("2026-08-04T23:00:00.000Z"), "Europe/London")).toBe(0);
+  });
+});
+
+describe("currentWeekYmd", () => {
+  it("runs Monday to Sunday in the account zone", () => {
+    const ms = Date.parse("2026-08-07T00:30:00.000Z");
+    expect(currentWeekYmd(ms, "Europe/London")).toEqual({
+      fromYmd: "2026-08-03",
+      toYmd: "2026-08-09",
+    });
+  });
+
+  it("puts a Sunday in the week that ends on it, not the one that follows", () => {
+    const ms = Date.parse("2026-08-09T12:00:00.000Z");
+    expect(currentWeekYmd(ms, "Europe/London")).toEqual({
+      fromYmd: "2026-08-03",
+      toYmd: "2026-08-09",
+    });
+  });
+
+  it("puts a Monday at the start of its own week", () => {
+    const ms = Date.parse("2026-08-03T09:00:00.000Z");
+    expect(currentWeekYmd(ms, "Europe/London")).toEqual({
+      fromYmd: "2026-08-03",
+      toYmd: "2026-08-09",
+    });
+  });
+
+  it("uses the account zone, so a late-Sunday UTC instant is already Monday in Auckland", () => {
+    // 2026-08-09T22:00Z is Sunday in London and Monday 10th in Auckland.
+    expect(currentWeekYmd(Date.parse("2026-08-09T22:00:00.000Z"), "Europe/London").fromYmd).toBe(
+      "2026-08-03",
+    );
+    expect(currentWeekYmd(Date.parse("2026-08-09T22:00:00.000Z"), "Pacific/Auckland").fromYmd).toBe(
+      "2026-08-10",
+    );
+  });
+});
+
+describe("MAX_RANGE_DAYS", () => {
+  it("is 31", () => {
+    expect(MAX_RANGE_DAYS).toBe(31);
+  });
+});

package/payload/platform/lib/dispatch-read/src/__tests__/worker-day.test.ts

@@ -0,0 +1,141 @@
+import { describe, expect, it, vi } from "vitest";
+import { __setDriverForTests } from "../session.js";
+import { readWorkerDay, readSiteHistory } from "../read.js";
+import { workerForTelegramUser } from "../config.js";
+import type { DispatchConfig } from "../types.js";
+
+function driverReturning(rows: Array<Record<string, unknown>>) {
+  return {
+    session: () => ({
+      run: vi.fn(async () => ({
+        records: rows.map((r) => ({ get: (k: string) => r[k] })),
+      })),
+      close: vi.fn(async () => {}),
+    }),
+  } as never;
+}
+
+const ROW = {
+  visitId: "v1",
+  jobId: "j1",
+  status: "Allocated",
+  startDate: "2026-08-07T08:00:00.000Z",
+  endDate: null,
+  purpose: "No hot water",
+  workerId: "w1",
+  arrivedPressedAt: null,
+  arrivedObservedAt: null,
+  arrivedObservedDistanceM: null,
+  siteId: "s1",
+  siteName: "Ladywell Prospect",
+  customerName: "Acme",
+  contactName: "Jo Bell",
+  contactTelephone: "01234 567890",
+};
+
+describe("readWorkerDay", () => {
+  it("returns the field card shape", async () => {
+    __setDriverForTests(driverReturning([ROW]));
+    const [visit] = await readWorkerDay(
+      "a1", "w1", "2026-08-07T00:00:00.000Z", "2026-08-08T00:00:00.000Z",
+    );
+    expect(visit.siteName).toBe("Ladywell Prospect");
+    expect(visit.customerName).toBe("Acme");
+    expect(visit.contactName).toBe("Jo Bell");
+    expect(visit.contactTelephone).toBe("01234 567890");
+    expect(visit.purpose).toBe("No hot water");
+    expect(visit.siteId).toBe("s1");
+    __setDriverForTests(null);
+  });
+
+  it("carries no address and no postcode key at all", async () => {
+    __setDriverForTests(driverReturning([ROW]));
+    const [visit] = await readWorkerDay(
+      "a1", "w1", "2026-08-07T00:00:00.000Z", "2026-08-08T00:00:00.000Z",
+    );
+    // Conflict 7 of the design: the ontology has no address for a :Site. The
+    // keys must be ABSENT, not null, so the deferral to task 2514 cannot be
+    // half-implemented as an always-empty column that reads to a worker as
+    // "this site has no address".
+    expect(Object.keys(visit)).not.toContain("address");
+    expect(Object.keys(visit)).not.toContain("postcode");
+    __setDriverForTests(null);
+  });
+
+  it("survives a visit with no job, site, customer or contact", async () => {
+    // Every one of those is an OPTIONAL MATCH, so a visit allocated before its
+    // job was linked returns nulls rather than dropping out of the day.
+    __setDriverForTests(driverReturning([
+      { ...ROW, jobId: null, siteId: null, siteName: null, customerName: null,
+        contactName: null, contactTelephone: null },
+    ]));
+    const [visit] = await readWorkerDay(
+      "a1", "w1", "2026-08-07T00:00:00.000Z", "2026-08-08T00:00:00.000Z",
+    );
+    expect(visit.visitId).toBe("v1");
+    expect(visit.contactName).toBeNull();
+    __setDriverForTests(null);
+  });
+});
+
+describe("readSiteHistory", () => {
+  it("reports a photograph count per prior visit", async () => {
+    const session = {
+      run: vi.fn(async () => ({
+        records: [{
+          get: (k: string) => ({
+            jobId: "j0", jobStatus: "Closed", visitId: "v0", status: "Complete",
+            startDate: "2026-01-02T09:00:00.000Z", endDate: null, purpose: "Annual service",
+            workerId: "w2", notes: ["Valve replaced"], mediaCount: 3,
+            arrivedPressedAt: null, arrivedObservedAt: null, arrivedObservedDistanceM: null,
+          }[k]),
+        }],
+      })),
+    } as never;
+    const [prior] = await readSiteHistory(session, "a1", "s1", 20);
+    // A count, not the references: a worker on a bad signal decides whether to
+    // load them.
+    expect(prior.mediaCount).toBe(3);
+    expect(prior.notes).toEqual(["Valve replaced"]);
+  });
+
+  it("reports zero rather than undefined for a visit with no media", async () => {
+    const session = {
+      run: vi.fn(async () => ({
+        records: [{ get: (k: string) => ({
+          jobId: "j0", jobStatus: "Closed", visitId: "v0", status: "Complete",
+          startDate: null, endDate: null, purpose: null, workerId: null,
+          notes: [], mediaCount: 0,
+          arrivedPressedAt: null, arrivedObservedAt: null, arrivedObservedDistanceM: null,
+        }[k]) }],
+      })),
+    } as never;
+    const [prior] = await readSiteHistory(session, "a1", "s1", 20);
+    expect(prior.mediaCount).toBe(0);
+  });
+});
+
+describe("workerForTelegramUser", () => {
+  const cfg = {
+    workers: [
+      { workerId: "w1", name: "Oli", qualifications: [], workingHours: {}, telegramUserId: "44551122" },
+      { workerId: "w2", name: "Sam", qualifications: [], workingHours: {} },
+    ],
+  } as unknown as DispatchConfig;
+
+  it("resolves a bound worker", () => {
+    expect(workerForTelegramUser(cfg, "44551122")?.workerId).toBe("w1");
+  });
+
+  it("returns null for a telegram user nobody claims", () => {
+    expect(workerForTelegramUser(cfg, "99999999")).toBeNull();
+  });
+
+  it("never matches a worker who carries no binding", () => {
+    // Without the empty guard, an undefined lookup compares equal to every
+    // worker with no telegramUserId, so the first unbound worker on the roster
+    // would answer for any stranger.
+    expect(workerForTelegramUser(cfg, undefined as unknown as string)).toBeNull();
+    expect(workerForTelegramUser(cfg, "")).toBeNull();
+  });
+});

package/payload/platform/lib/dispatch-read/src/config.d.ts

@@ -0,0 +1,26 @@
+import type { DispatchConfig, LoadResult } from "./types.js";
+/**
+ * Field names `records.requiredBeforeTerminal` may demand of a visit.
+ *
+ * Task 2502 moved this here from the dispatch plugin's own config module. Two
+ * packages now need it: the plugin still validates a config against it, and
+ * `dispatch-write`'s required-field gate answers with one of these names. A
+ * copy in each would be two lists that drift, and the drift would show up as a
+ * visit that cannot be closed for a reason the config never declared.
+ */
+export declare const RECORDABLE_FIELDS: readonly ["notes", "media", "parts", "checklist", "signature"];
+export type RecordableField = (typeof RECORDABLE_FIELDS)[number];
+/**
+ * Read `$ACCOUNT_DIR/dispatch/config.json`.
+ *
+ * Every outcome is a named state. A caller can tell "this account never enabled
+ * dispatch" from "this account's config is corrupt", which matters because the
+ * first is the ordinary case and the second needs an operator. Collapsing them
+ * into one falsy result is how a broken config comes to look like a quiet day.
+ */
+export declare function loadDispatchConfig(accountDir: string): LoadResult;
+/** The account's terminal job status names, for the overdue and open rules. */
+export declare function terminalJobStatuses(cfg: DispatchConfig): string[];
+/** The account's terminal visit status names. */
+export declare function terminalVisitStatuses(cfg: DispatchConfig): string[];
+//# sourceMappingURL=config.d.ts.map

package/payload/platform/lib/dispatch-read/src/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["config.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7D;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,gEAMpB,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjE;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU,CA2BjE;AAED,+EAA+E;AAC/E,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM,EAAE,CAEjE;AAED,iDAAiD;AACjD,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM,EAAE,CAEnE"}

package/payload/platform/lib/dispatch-read/src/config.ts

@@ -0,0 +1,85 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { DispatchConfig, LoadResult, Worker } from "./types.js";
+
+/**
+ * Field names `records.requiredBeforeTerminal` may demand of a visit.
+ *
+ * Task 2502 moved this here from the dispatch plugin's own config module. Two
+ * packages now need it: the plugin still validates a config against it, and
+ * `dispatch-write`'s required-field gate answers with one of these names. A
+ * copy in each would be two lists that drift, and the drift would show up as a
+ * visit that cannot be closed for a reason the config never declared.
+ */
+export const RECORDABLE_FIELDS = [
+  "notes",
+  "media",
+  "parts",
+  "checklist",
+  "signature",
+] as const;
+
+export type RecordableField = (typeof RECORDABLE_FIELDS)[number];
+
+/**
+ * The worker a Telegram user id belongs to, or null (Task 2502).
+ *
+ * The empty-input guard is load-bearing rather than defensive. Without it an
+ * undefined lookup would compare equal to every worker who carries no
+ * `telegramUserId`, so the first unbound worker on the roster would answer for
+ * any stranger who opened the sheet.
+ */
+export function workerForTelegramUser(
+  cfg: DispatchConfig,
+  telegramUserId: string,
+): Worker | null {
+  if (!telegramUserId) return null;
+  return cfg.workers.find((w) => w.telegramUserId === telegramUserId) ?? null;
+}
+
+/**
+ * Read `$ACCOUNT_DIR/dispatch/config.json`.
+ *
+ * Every outcome is a named state. A caller can tell "this account never enabled
+ * dispatch" from "this account's config is corrupt", which matters because the
+ * first is the ordinary case and the second needs an operator. Collapsing them
+ * into one falsy result is how a broken config comes to look like a quiet day.
+ */
+export function loadDispatchConfig(accountDir: string): LoadResult {
+  if (!accountDir || !existsSync(accountDir)) {
+    return { present: false, reason: "no-account-dir" };
+  }
+  const path = join(accountDir, "dispatch", "config.json");
+  if (!existsSync(path)) return { present: false, reason: "no-file" };
+
+  let raw: string;
+  try {
+    raw = readFileSync(path, "utf-8");
+  } catch (err) {
+    return {
+      present: false,
+      reason: "unreadable",
+      detail: err instanceof Error ? err.message : String(err),
+    };
+  }
+
+  try {
+    return { present: true, value: JSON.parse(raw) as DispatchConfig };
+  } catch (err) {
+    return {
+      present: false,
+      reason: "invalid",
+      detail: err instanceof Error ? err.message : String(err),
+    };
+  }
+}
+
+/** The account's terminal job status names, for the overdue and open rules. */
+export function terminalJobStatuses(cfg: DispatchConfig): string[] {
+  return cfg.statuses.job.filter((s) => s.terminal).map((s) => s.name);
+}
+
+/** The account's terminal visit status names. */
+export function terminalVisitStatuses(cfg: DispatchConfig): string[] {
+  return cfg.statuses.visit.filter((s) => s.terminal).map((s) => s.name);
+}

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

@@ -0,0 +1,54 @@
+/**
+ * Dispatch reads, shared by the MCP tools and the office planner.
+ *
+ * One implementation of the account-scoped queries, the config contract and the
+ * timezone arithmetic. Before this package existed the UI server re-implemented
+ * the census queries against the same on-disk config, which was a second source
+ * of truth with nothing watching it.
+ *
+ * Two consumption shapes, both supported: `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 {
+  RECORDABLE_FIELDS,
+  loadDispatchConfig,
+  terminalJobStatuses,
+  terminalVisitStatuses,
+  workerForTelegramUser,
+} from "./config.js";
+export type { RecordableField } from "./config.js";
+export { withSession } from "./session.js";
+export { resolveAccountZone } from "./zone.js";
+export {
+  MAX_RANGE_DAYS,
+  addDaysYmd,
+  currentWeekYmd,
+  daysBetween,
+  minutesIntoDay,
+  ymdInZone,
+  zonedDayStartUtc,
+  zonedRangeBounds,
+} from "./window.js";
+
+// Session-taking reads: the dispatch plugin's, moved here unchanged.
+export {
+  buildJobListQuery,
+  projectJob,
+  projectVisit,
+  readCommitments,
+  readJob,
+  readJobs,
+  readNodeId,
+  readSiteHistory,
+  readVisit,
+  readVisitRecordState,
+  readVisitsForJob,
+  readVisitsInWindow,
+} from "./read.js";
+
+// Session-owning reads: the planner's, so a route holds no graph access.
+export { nonZuluStarts, readCounts, readDay, readJobList, readWorkerDay } from "./read.js";
+
+export type { Commitment, VisitRecordState } from "./read.js";
+export type * from "./types.js";