Deploy AIOS web (React glide grid + FastAPI slice)

RELEASES.json

@@ -1,5 +1,5 @@
 {
- "current": "582a6c8",
+ "current": "bf8387b",
  "releases": [
   {
    "version": "v53",

VERSION

@@ -1 +1 @@
-582a6c8
+bf8387b

web/src/customer-grid/useVisibleRows.ts

@@ -23,8 +23,8 @@ import type {
   VisibleRow,
 } from "./types";
 import { FILTER_OPS, cohortIds, isCohortRule, isFilterGroup, isMeasureRule, isRankOp,
-  isViewRule, normalizeViewOp, viewRuleId,
-  isRuleActive, normalizeCohortOp, rhsColId } from "./types";
+  isViewRule, normalizeViewOp, viewRuleId, ROUTE_PROJECTION_KEY, routeStopPosition,
+  singleRouteScope, isRuleActive, normalizeCohortOp, rhsColId } from "./types";
 import { resolveAnchor, resolveWindow } from "./windows";
 import { computeAggs } from "./aggregations";
 import { NO_RANKING, hasRankLeaf, resolveRankLeaves, stripRankLeaves } from "./rankOps";
@@ -688,9 +688,29 @@ export function matchFilterTree(
  * numerics coerced to 0 and outranked real negatives. A blank is only a
  * tie-breaker skip, so later sort keys still decide between two blanks.
  */
-export function makeComparator(sorts: SortSpec, fieldByKey: Map<string, Field>) {
+export function makeComparator(
+  sorts: SortSpec,
+  fieldByKey: Map<string, Field>,
+  routeLabel?: string,
+) {
   return (a: Row, b: Row): number => {
     for (const s of sorts) {
+      // W42 R22: `routes` carries prose such as "North - 10, South - 2". It is not a
+      // sortable text value. The pipeline supplies `routeLabel` only after it has proved that
+      // the whole view is inside one named route; a stale stored sort otherwise becomes a
+      // no-op here instead of a confident lexical wrong answer.
+      if (s.colId === ROUTE_PROJECTION_KEY) {
+        if (!routeLabel) continue;
+        const av = routeStopPosition(a[s.colId], routeLabel);
+        const bv = routeStopPosition(b[s.colId], routeLabel);
+        const aBlank = av === null;
+        const bBlank = bv === null;
+        if (aBlank !== bBlank) return aBlank ? 1 : -1;
+        if (aBlank && bBlank) continue;
+        const c = (av ?? 0) - (bv ?? 0);
+        if (c !== 0) return s.dir === "asc" ? c : -c;
+        continue;
+      }
       const f = fieldByKey.get(s.colId);
       const numeric = f ? isNumericType(f.type) : false;
       const av = a[s.colId];
@@ -1096,7 +1116,13 @@ export function runPipeline(input: PipelineInput): VisibleRowsResult {
   const q = search.trim().toLowerCase();
   if (q) out = out.filter((r) => matchSearch(q, r, fields));
 
-  if (sorts.length) out = [...out].sort(makeComparator(sorts, fieldByKey));
+  // A route stop number is an ordinal only within one route. `singleRouteScope` is also the
+  // builder's refusal decision, so persisted sorts take the same fail-closed path as new ones.
+  // A missing label deliberately leaves the projection rule as a no-op; raw CSV text is never
+  // used as a fallback comparator.
+  const routeScope = singleRouteScope({ nodes: filters, conj: filterConj }, fields);
+  const routeLabel = routeScope.ok ? fieldByKey.get(routeScope.routeKey)?.label : undefined;
+  if (sorts.length) out = [...out].sort(makeComparator(sorts, fieldByKey, routeLabel));
 
   if (!groupBy) return asRows(out);
 

web/src/filter-kit/FieldsHidePanel.tsx

@@ -27,7 +27,7 @@ import { useMemo, useState } from "react";
 // miniature, where what a user searches and what they read answer the same question
 // differently. It lives in `types.ts` so the node harness can run it: this panel is JSX and
 // its search path only fires once somebody types, which no static render can do.
-import { fieldEditMode, fieldLabel, isPresetField, offerableFields,
+import { fieldEditMode, fieldLabel, isOfferableField, isPresetField,
   FIELD_EDIT_BLURBS, FIELD_EDIT_LABELS }
   from "../customer-grid/types";
 import { FieldTypeIcon } from "../customer-grid/icons";
@@ -493,8 +493,17 @@ export function FieldsHidePanel({
    * ⛔ PRESENTATION ONLY. Nothing is deleted and nothing is walled: the payload still carries
    * every withheld field, the grid still renders any that are visible, and a route column's own
    * doors (its column menu, `patchRouteOrderField`, `deleteRouteOrderField`) are untouched.
+   *
+   * R1's narrow exception is a route field whose host has already offered a delete affordance.
+   * It stays in THIS manager only so that affordance remains reachable; it remains absent from
+   * every picker. `deletableKeys` is a ceiling supplied by the host, so this cannot make a
+   * withheld field deletable or offer any field outside the Fields manager.
    */
-  const fields = useMemo(() => offerableFields(allFields), [allFields]);
+  const fields = useMemo(
+    () => allFields.filter((field) =>
+      isOfferableField(field) || !!deletableKeys?.has(field.key)),
+    [allFields, deletableKeys]
+  );
   /** W41-T27 - one name for "this mount is the Fields manager", so the title, the width class
    *  and anything a later ticket adds all key off the same answer instead of re-deriving it. */
   const managerMode = manager;

web/src/filter-kit/fieldClass.ts

@@ -862,30 +862,28 @@ export function fieldAuthorBadge(
 }
 
 /**
- * ⛔⛔ R16, AND THE PAYLOAD CANNOT EXPRESS IT YET. The ruling: a SHARED
+ * ⛔⛔ R16, AND THE PAYLOAD EXPRESSES IT UNDER THE SERVER'S OWN KEY. The ruling: a SHARED
  * definition wins a key collision, the local one is superseded rather than
  * deleted, and the field manager says so. The first two halves are real
  * server-side facts (`core.field_permissions.migrate_legacy_fields` re-promotes
  * a per-user fork of a key on every read, and `routes_tables`' delete door
  * clears both strata precisely because a fork survives), but NOTHING ON THE
- * WIRE MARKS THE ROW: `routes_customers._merge_shared_fields` skips a shared
- * definition whose key the canonical contract already declares (`if k in have:
- * continue`) and `routes_tables`' field index is deduped first writer wins, so
- * the client receives exactly one entry per key and no record that a second one
- * exists.
- *
- * So this is a C8 READER, not an invented state: it returns the sentence when a
- * producer ships `supersededLocal: true` on the entry, and null on every field
- * today, which paints nothing. The missing half is named in the handoff rather
- * than guessed at here, because the only client-side alternative would be to
- * decide a collision happened from a key the server never sent.
+ * WIRE MARKS THE ROW: `routes_customers._merge_shared_fields` projects the shared
+ * definition in place and carries its thin `{ superseded: { stratum: "personal" } }`
+ * marker. The local definition stays in the workspace member, but nothing needs to
+ * copy it back onto the served field to tell the person what happened.
+ *
+ * This is a C8 reader, not an invented state: it returns the sentence only for
+ * that explicit personal-stratum marker. Any absent, malformed, or other-stratum
+ * payload stays null rather than turning an unrelated field into a collision.
  */
 export const SUPERSEDED_NOTE =
   "Superseded: the shared version of this column is the one in use, and your own copy is kept rather than deleted.";
 
 export function supersededNoteOf(field: unknown): string | null {
   if (typeof field !== "object" || field === null) return null;
-  return (field as { supersededLocal?: unknown }).supersededLocal === true
+  const marker = (field as { superseded?: { stratum?: unknown } }).superseded;
+  return marker?.stratum === "personal"
     ? SUPERSEDED_NOTE
     : null;
 }