@startsimpli/ui 0.4.104 → 0.4.106

package/src/foundry/__tests__/links.test.ts

@@ -0,0 +1,251 @@
+import {
+  countLinksByRecord,
+  countPublicLinksByRecord,
+  edgeEndpoints,
+  edgesForSide,
+  farDirection,
+  farIdOf,
+  joinLinkRows,
+  linkCandidates,
+  linkSidesFor,
+  nearDirection,
+  recordLabel,
+  sameId,
+} from '../links';
+import type { LinkSide } from '../links';
+import type {
+  EntityRecord,
+  EntityTypeDef,
+  RelationshipDef,
+  RelationshipInstance,
+} from '../types';
+
+const PRODUCT: EntityTypeDef = { id: 'T-product', key: 'product', label: 'Product', attributes: [] };
+const PATENT: EntityTypeDef = { id: 'T-patent', key: 'patent', label: 'Patent', attributes: [] };
+const CATEGORY: EntityTypeDef = { id: 'T-category', key: 'category', label: 'Category', attributes: [] };
+const TYPES = [PRODUCT, PATENT, CATEGORY];
+
+const MARKED_WITH: RelationshipDef = {
+  id: 'R1', key: 'marked_with', sourceType: 'T-product', targetType: 'T-patent',
+};
+const IN_CATEGORY: RelationshipDef = {
+  id: 'R2', key: 'in_category', sourceType: 'T-product', targetType: 'T-category',
+};
+
+function rec(id: string, name: string, externalId: string | null = null): EntityRecord {
+  return { id, entityType: 'x', externalId, name, data: {}, createdAt: '2026-08-01' };
+}
+function edge(id: string, relType: string, source: string, target: string): RelationshipInstance {
+  return { id, relType, source, target, createdAt: '2026-08-01' };
+}
+
+describe('sameId', () => {
+  it('compares across the string/number union the wire and the fixtures disagree on', () => {
+    expect(sameId('7', 7)).toBe(true);
+    expect(sameId('a', 'a')).toBe(true);
+    expect(sameId('a', 'b')).toBe(false);
+  });
+  it('never matches a missing id — null is not an id', () => {
+    expect(sameId(null, null)).toBe(false);
+    expect(sameId(undefined, '1')).toBe(false);
+  });
+});
+
+describe('linkSidesFor', () => {
+  it('gives a product both of its declared sides, pointing at the far types', () => {
+    const sides = linkSidesFor(PRODUCT, [MARKED_WITH, IN_CATEGORY], TYPES);
+    expect(sides).toEqual([
+      { relType: 'marked_with', role: 'source', farTypeKey: 'patent', farTypeLabel: 'Patent' },
+      { relType: 'in_category', role: 'source', farTypeKey: 'category', farTypeLabel: 'Category' },
+    ]);
+  });
+
+  it('gives a patent the REVERSE side of the same relationship — the join read from the other end', () => {
+    expect(linkSidesFor(PATENT, [MARKED_WITH, IN_CATEGORY], TYPES)).toEqual([
+      { relType: 'marked_with', role: 'target', farTypeKey: 'product', farTypeLabel: 'Product' },
+    ]);
+  });
+
+  it('yields BOTH sides of a self-referential relationship', () => {
+    const selfRef: RelationshipDef = {
+      id: 'R3', key: 'supersedes', sourceType: 'T-patent', targetType: 'T-patent',
+    };
+    const sides = linkSidesFor(PATENT, [selfRef], TYPES);
+    expect(sides.map((s) => s.role)).toEqual(['source', 'target']);
+  });
+
+  it('drops a def naming a type the caller cannot read, rather than rendering a headless panel', () => {
+    const dangling: RelationshipDef = {
+      id: 'R4', key: 'ghost', sourceType: 'T-product', targetType: 'T-missing',
+    };
+    expect(linkSidesFor(PRODUCT, [dangling], TYPES)).toEqual([]);
+  });
+
+  it('is empty for no type', () => {
+    expect(linkSidesFor(null, [MARKED_WITH], TYPES)).toEqual([]);
+  });
+});
+
+describe('farDirection', () => {
+  // Measured against the live tenant: `related_direction` names the RESULT
+  // record's end of the edge. Getting it backwards returns 0 rows with
+  // applied_filters still reporting success, so it is pinned here.
+  it("asks for the edge's TARGET when this record is the source", () => {
+    expect(farDirection(linkSidesFor(PRODUCT, [MARKED_WITH], TYPES)[0])).toBe('in');
+  });
+  it("asks for the edge's SOURCE when this record is the target", () => {
+    expect(farDirection(linkSidesFor(PATENT, [MARKED_WITH], TYPES)[0])).toBe('out');
+  });
+});
+
+describe('edgeEndpoints', () => {
+  const fromProduct = linkSidesFor(PRODUCT, [MARKED_WITH], TYPES)[0];
+  const fromPatent = linkSidesFor(PATENT, [MARKED_WITH], TYPES)[0];
+
+  it('writes the declared direction when linking from the product', () => {
+    expect(edgeEndpoints(fromProduct, 'P1', 'X9')).toEqual({
+      relType: 'marked_with', source: 'P1', target: 'X9',
+    });
+  });
+
+  it('STILL writes product -> patent when linking from the patent side', () => {
+    // The screen the user is on does not change the declared direction; the
+    // tenant's _validate_edge_types refuses the flipped edge. This is the bug
+    // the reverse panel would otherwise ship with.
+    expect(edgeEndpoints(fromPatent, 'X9', 'P1')).toEqual({
+      relType: 'marked_with', source: 'P1', target: 'X9',
+    });
+  });
+});
+
+describe('edgesForSide / farIdOf / joinLinkRows', () => {
+  const fromProduct = linkSidesFor(PRODUCT, [MARKED_WITH, IN_CATEGORY], TYPES)[0];
+  const fromPatent = linkSidesFor(PATENT, [MARKED_WITH], TYPES)[0];
+  const edges = [
+    edge('E1', 'marked_with', 'P1', 'X1'),
+    edge('E2', 'marked_with', 'P1', 'X2'),
+    edge('E3', 'in_category', 'P1', 'C1'),
+    edge('E4', 'marked_with', 'P2', 'X1'),
+  ];
+
+  it('keeps only the edges of that relationship on that end', () => {
+    expect(edgesForSide(edges, fromProduct, 'P1').map((e) => e.id)).toEqual(['E1', 'E2']);
+  });
+
+  it('reads the reverse end of the same edge set', () => {
+    expect(edgesForSide(edges, fromPatent, 'X1').map((e) => e.id)).toEqual(['E1', 'E4']);
+  });
+
+  it('resolves the far end according to the side', () => {
+    expect(farIdOf(edges[0], fromProduct)).toBe('X1');
+    expect(farIdOf(edges[0], fromPatent)).toBe('P1');
+  });
+
+  it('pairs every edge with its far record, keeping the edge id unlinking needs', () => {
+    const rows = joinLinkRows(edgesForSide(edges, fromProduct, 'P1'), fromProduct, [
+      rec('X1', 'Patent one'),
+      rec('X2', 'Patent two'),
+    ]);
+    expect(rows.map((r) => [r.edge.id, r.record?.name])).toEqual([
+      ['E1', 'Patent one'],
+      ['E2', 'Patent two'],
+    ]);
+  });
+
+  it('keeps an edge whose far record is unreadable rather than hiding the association', () => {
+    const rows = joinLinkRows(edgesForSide(edges, fromProduct, 'P1'), fromProduct, [rec('X1', 'Patent one')]);
+    expect(rows).toHaveLength(2);
+    expect(rows[1].record).toBeNull();
+  });
+});
+
+describe('linkCandidates', () => {
+  it('excludes what is already linked — nothing below enforces cardinality (768w.16.17)', () => {
+    const pool = [rec('X1', 'one'), rec('X2', 'two'), rec('X3', 'three')];
+    expect(linkCandidates(pool, ['X2'], 'P1').map((r) => r.id)).toEqual(['X1', 'X3']);
+  });
+  it('never offers the record itself, which a self-referential relationship would', () => {
+    const pool = [rec('X1', 'one'), rec('P1', 'self')];
+    expect(linkCandidates(pool, [], 'P1').map((r) => r.id)).toEqual(['X1']);
+  });
+});
+
+describe('countLinksByRecord', () => {
+  const fromProduct = linkSidesFor(PRODUCT, [MARKED_WITH], TYPES)[0];
+  const fromPatent = linkSidesFor(PATENT, [MARKED_WITH], TYPES)[0];
+  const edges = [
+    edge('E1', 'marked_with', 'P1', 'X1'),
+    edge('E2', 'marked_with', 'P1', 'X2'),
+    edge('E3', 'marked_with', 'P2', 'X1'),
+    edge('E4', 'in_category', 'P1', 'C1'),
+  ];
+
+  it('counts a page of products by their patents', () => {
+    const counts = countLinksByRecord(edges, fromProduct);
+    expect(counts.get('P1')).toBe(2);
+    expect(counts.get('P2')).toBe(1);
+  });
+
+  it('counts a page of patents by the articles asserting them — the public page number', () => {
+    const counts = countLinksByRecord(edges, fromPatent);
+    expect(counts.get('X1')).toBe(2);
+    expect(counts.get('X2')).toBe(1);
+  });
+});
+
+describe('recordLabel', () => {
+  it('prefers the name', () => expect(recordLabel(rec('X1', 'Widget', 'SKU1'))).toBe('Widget'));
+  it('falls back to the natural key, then to a short id', () => {
+    expect(recordLabel(rec('X1', '', 'US1234'))).toBe('US1234');
+    expect(recordLabel(rec('abcdef1234', '', null))).toBe('#abcdef12');
+  });
+  it('names an unreadable far end by its id rather than pretending it is absent', () => {
+    expect(recordLabel(null, 'abcdef1234')).toBe('#abcdef12');
+  });
+});
+
+describe('countPublicLinksByRecord / nearDirection (bd startsim-vc3ss)', () => {
+  const side: LinkSide = {
+    relType: 'marked_with',
+    role: 'source',
+    farTypeKey: 'patent',
+    farTypeLabel: 'Patents',
+  };
+  const reverse: LinkSide = {
+    relType: 'marked_with',
+    role: 'target',
+    farTypeKey: 'product',
+    farTypeLabel: 'Products',
+  };
+  const edges = [
+    { id: 'e1', relType: 'marked_with', source: 'prod', target: 'pat-pub', createdAt: '' },
+    { id: 'e2', relType: 'marked_with', source: 'prod', target: 'pat-draft', createdAt: '' },
+    { id: 'e3', relType: 'in_category', source: 'prod', target: 'cat', createdAt: '' },
+  ];
+
+  it('counts every edge for the admin, and only both-ends-published for the public', () => {
+    expect(countLinksByRecord(edges, side).get('prod')).toBe(2);
+    const published = new Set(['prod', 'pat-pub']);
+    expect(countPublicLinksByRecord(edges, side, published).get('prod')).toBe(1);
+  });
+
+  it('is zero when the record itself is not published — it has no public page at all', () => {
+    const published = new Set(['pat-pub', 'pat-draft']);
+    expect(countPublicLinksByRecord(edges, side, published).get('prod')).toBeUndefined();
+  });
+
+  it('reads the reverse side from the far end', () => {
+    const published = new Set(['prod', 'pat-pub']);
+    expect(countPublicLinksByRecord(edges, reverse, published).get('pat-pub')).toBe(1);
+    expect(countPublicLinksByRecord(edges, reverse, published).get('pat-draft')).toBeUndefined();
+  });
+
+  it('nearDirection is the OPPOSITE of farDirection — the trap, pinned', () => {
+    // farDirection returns the far records; nearDirection lists records OF THIS
+    // TYPE linked to a named far record ("products in this category").
+    expect(farDirection(side)).toBe('in');
+    expect(nearDirection(side)).toBe('out');
+    expect(farDirection(reverse)).toBe('out');
+    expect(nearDirection(reverse)).toBe('in');
+  });
+});

package/src/foundry/__tests__/list-query.test.ts

@@ -0,0 +1,200 @@
+import {
+  ALL_VALUE,
+  attributeForColumn,
+  farOptionLabels,
+  columnFiltersFor,
+  columnIdForAttribute,
+  isSortableColumn,
+  listParams,
+  orderParam,
+} from '../list-query';
+import type { AttributeShape } from '../types';
+
+function attr(name: string, dataType: AttributeShape['dataType'] = 'text'): AttributeShape {
+  return { id: `id-${name}`, name, dataType, required: false, config: {} };
+}
+
+// The four 287a types, exactly as the live tenant declares them.
+const PRODUCT = [attr('name'), attr('stock_no'), attr('description', 'longtext'), attr('legacy_uuid')];
+const PATENT = [
+  attr('number'),
+  attr('title'),
+  attr('description', 'longtext'),
+  attr('expiration', 'date'),
+  attr('legacy_uuid'),
+];
+
+describe('column id <-> attribute mapping', () => {
+  it('namespaces an attribute that collides with a framing column', () => {
+    // product declares an attribute literally called `name`; the framing column
+    // already owns the id `name`, so the attribute column is `attr_name`.
+    expect(columnIdForAttribute(attr('name'))).toBe('attr_name');
+    expect(columnIdForAttribute(attr('stock_no'))).toBe('stock_no');
+  });
+
+  it('maps the namespaced id back to the attribute, and the framing id to nothing', () => {
+    expect(attributeForColumn('attr_name', PRODUCT)?.name).toBe('name');
+    expect(attributeForColumn('name', PRODUCT)).toBeNull();
+    expect(attributeForColumn('createdAt', PRODUCT)).toBeNull();
+    expect(attributeForColumn('link_marked_with_source', PRODUCT)).toBeNull();
+  });
+
+  it('does not mistake an attribute whose own name starts with attr_', () => {
+    const odd = [attr('attr_name'), attr('name')];
+    // `attr_name` (the literal attribute) does not collide with a framing id, so
+    // it keeps its own name as the column id — and must map back to ITSELF.
+    expect(columnIdForAttribute(odd[0])).toBe('attr_name');
+    expect(attributeForColumn('attr_name', odd)?.name).toBe('attr_name');
+  });
+});
+
+describe('sortability', () => {
+  it('refuses the framing Name column (?order=name is a 400 server-side)', () => {
+    expect(isSortableColumn('name', PRODUCT)).toBe(false);
+    expect(orderParam({ columnId: 'name', direction: 'asc' }, PRODUCT)).toBeNull();
+  });
+
+  it('refuses derived columns (association counts have no server ordering)', () => {
+    expect(isSortableColumn('link_marked_with_source', PRODUCT)).toBe(false);
+  });
+
+  it('orders Created through the recent/oldest vocabulary, not attr.created_at', () => {
+    expect(orderParam({ columnId: 'createdAt', direction: 'desc' }, PRODUCT)).toBe('recent');
+    expect(orderParam({ columnId: 'createdAt', direction: 'asc' }, PRODUCT)).toBe('oldest');
+  });
+
+  it('orders a declared attribute by its ATTRIBUTE name, never by its column id', () => {
+    expect(orderParam({ columnId: 'attr_name', direction: 'asc' }, PRODUCT)).toBe('attr.name');
+    expect(orderParam({ columnId: 'attr_name', direction: 'desc' }, PRODUCT)).toBe('-attr.name');
+    expect(orderParam({ columnId: 'number', direction: 'asc' }, PATENT)).toBe('attr.number');
+  });
+});
+
+describe('column filters', () => {
+  it('offers text filters for text/longtext and a window for a date', () => {
+    expect(columnFiltersFor(PATENT)).toEqual([
+      { id: 'number', label: 'number', kind: 'text', attrName: 'number' },
+      { id: 'title', label: 'title', kind: 'text', attrName: 'title' },
+      { id: 'description', label: 'description', kind: 'text', attrName: 'description' },
+      { id: 'expiration', label: 'expiration', kind: 'date-window', attrName: 'expiration' },
+      { id: 'legacy_uuid', label: 'legacy uuid', kind: 'text', attrName: 'legacy_uuid' },
+    ]);
+  });
+});
+
+describe('listParams', () => {
+  it('is just type+page when nothing is asked for', () => {
+    expect(listParams({ type: 'product', page: 2 }, PRODUCT)).toEqual({ type: 'product', page: 2 });
+  });
+
+  it('sends search, order and an icontains filter under their RAW server names', () => {
+    expect(
+      listParams(
+        {
+          type: 'patent',
+          page: 1,
+          search: '  web  ',
+          sort: { columnId: 'number', direction: 'desc' },
+          filters: { title: 'scraping' },
+        },
+        PATENT,
+      ),
+    ).toEqual({
+      type: 'patent',
+      page: 1,
+      search: 'web',
+      order: '-attr.number',
+      'attr.title__icontains': 'scraping',
+    });
+  });
+
+  it('drops blank and "all" filter values, and filters for columns this type lacks', () => {
+    expect(
+      listParams(
+        { type: 'product', page: 1, filters: { stock_no: '', description: ALL_VALUE, nope: 'x' } },
+        PRODUCT,
+      ),
+    ).toEqual({ type: 'product', page: 1 });
+  });
+
+  it('turns a date window into a plain YYYY-MM-DD bound', () => {
+    const today = new Date('2026-08-24T18:30:00.000Z');
+    expect(
+      listParams({ type: 'patent', page: 1, filters: { expiration: 'past' } }, PATENT, today),
+    ).toEqual({ type: 'patent', page: 1, 'attr.expiration__lt': '2026-08-24' });
+    expect(
+      listParams({ type: 'patent', page: 1, filters: { expiration: 'future' } }, PATENT, today),
+    ).toEqual({ type: 'patent', page: 1, 'attr.expiration__gte': '2026-08-24' });
+  });
+
+  it('never sends __icontains against a date attribute (the server answers 400)', () => {
+    const params = listParams(
+      { type: 'patent', page: 1, filters: { expiration: 'anything else' } },
+      PATENT,
+    );
+    expect(Object.keys(params)).toEqual(['type', 'page']);
+  });
+
+  it('carries a link-side filter as the related_* triple', () => {
+    expect(
+      listParams(
+        {
+          type: 'product',
+          page: 1,
+          related: { relatedTo: 'cat-1', via: 'in_category', direction: 'out' },
+        },
+        PRODUCT,
+      ),
+    ).toEqual({
+      type: 'product',
+      page: 1,
+      related_to: 'cat-1',
+      related_via: 'in_category',
+      related_direction: 'out',
+    });
+  });
+});
+
+describe('farOptionLabels', () => {
+  it('uses the plain name when it is unique', () => {
+    const labels = farOptionLabels([
+      { id: 'cat-1', name: 'Software as a Service' },
+      { id: 'cat-2', name: 'Hardware' },
+    ]);
+    expect([...labels.keys()]).toEqual(['Software as a Service', 'Hardware']);
+    expect(labels.get('Hardware')).toBe('cat-2');
+  });
+
+  it('disambiguates a repeated name instead of collapsing two records into one', () => {
+    // `name` is free text on a category — only `code` is a business key — so two
+    // rows can share one. One option filtering by an arbitrary one of two ids is
+    // the silent-wrong-filter failure this module exists to avoid.
+    const labels = farOptionLabels([
+      { id: 'add566f1-754f-4582', name: 'Widgets' },
+      { id: 'bb112233-0000-0000', name: 'Widgets' },
+      { id: 'cc445566-0000-0000', name: 'Gadgets' },
+    ]);
+    expect([...labels.keys()]).toEqual([
+      'Widgets (#add566f1)',
+      'Widgets (#bb112233)',
+      'Gadgets',
+    ]);
+    expect(labels.get('Widgets (#bb112233)')).toBe('bb112233-0000-0000');
+  });
+
+  it('falls back to the id when a record has no name at all', () => {
+    expect([...farOptionLabels([{ id: 'x-1', name: '' }]).keys()]).toEqual(['x-1']);
+  });
+});
+
+describe('page size', () => {
+  it('SENDS page_size — the server default is 50 and the pager counts in 20s', () => {
+    // Without this the table renders 50 rows under a pager that computes its
+    // page count from 20: page 2 serves rows 51-100 and page 3 is out of range.
+    expect(listParams({ type: 'product', page: 2, pageSize: 20 }, PRODUCT)).toEqual({
+      type: 'product',
+      page: 2,
+      page_size: 20,
+    });
+  });
+});

package/src/foundry/__tests__/publication.test.ts

@@ -0,0 +1,227 @@
+import {
+  isLivePublic,
+  isPublished,
+  livePublicGrant,
+  dependentPublication,
+  publicGrantsFor,
+  publishOrder,
+  publishPlan,
+  publishedIds,
+  unpublishPlan,
+  withdrawOrder,
+} from '../publication';
+import type { EntityRecordShape, GrantShape, RelationshipEdgeShape } from '../types';
+
+const NOW = Date.parse('2026-08-22T12:00:00Z');
+const PAST = '2026-08-01T00:00:00Z';
+const FUTURE = '2027-01-01T00:00:00Z';
+
+function rec(id: string, name: string): EntityRecordShape {
+  return { id, externalId: null, name, data: {} };
+}
+function grant(
+  id: string,
+  entity: string,
+  expiresAt: string | null = null,
+  subjectType = 'public',
+): GrantShape {
+  return { id, entity, subjectType, expiresAt };
+}
+
+describe('isLivePublic', () => {
+  it('treats a null expiry as "until revoked", matching the RLS predicate', () => {
+    expect(isLivePublic(grant('G', 'P1', null), NOW)).toBe(true);
+  });
+  it('is live while the expiry is in the future and dead once it passes', () => {
+    expect(isLivePublic(grant('G', 'P1', FUTURE), NOW)).toBe(true);
+    expect(isLivePublic(grant('G', 'P1', PAST), NOW)).toBe(false);
+  });
+  it('ignores a grant that is not a PUBLIC one — a share with a person is not publication', () => {
+    expect(isLivePublic(grant('G', 'P1', null, 'user'), NOW)).toBe(false);
+  });
+});
+
+describe('livePublicGrant / isPublished / publishedIds', () => {
+  const grants = [grant('G1', 'P1', PAST), grant('G2', 'P1', null), grant('G3', 'P2', PAST)];
+
+  it('picks the live grant past a lapsed one on the same row', () => {
+    expect(livePublicGrant(grants, 'P1', NOW)?.id).toBe('G2');
+    expect(isPublished(grants, 'P1', NOW)).toBe(true);
+  });
+  it('a row whose only grant has lapsed is not published', () => {
+    expect(isPublished(grants, 'P2', NOW)).toBe(false);
+  });
+  it('keeps the lapsed grant visible as history rather than dropping it', () => {
+    expect(publicGrantsFor(grants, 'P1').map((g) => g.id)).toEqual(['G1', 'G2']);
+  });
+  it('collects exactly the live set', () => {
+    expect([...publishedIds(grants, NOW)]).toEqual(['P1']);
+  });
+});
+
+describe('publishPlan', () => {
+  const primary = rec('P1', 'Web Crawling Service');
+  const x1 = rec('X1', 'Dependent one');
+  const x2 = rec('X2', 'Dependent two');
+
+  it('publishes the primary AND every unpublished dependent linked to it', () => {
+    // Both ends must be published or the public policy hides the EDGE, and the
+    // primary renders as linked to nothing.
+    const plan = publishPlan(primary, [x1, x2], [], NOW);
+    expect(plan.primary?.entity).toBe('P1');
+    expect(plan.dependents.map((a) => a.entity)).toEqual(['X1', 'X2']);
+    expect(plan.alreadyPublic).toEqual([]);
+  });
+
+  it('leaves an already-public dependent alone and still names it in the outcome', () => {
+    const plan = publishPlan(primary, [x1, x2], [grant('G', 'X1', null)], NOW);
+    expect(plan.dependents.map((a) => a.entity)).toEqual(['X2']);
+    expect(plan.alreadyPublic.map((r) => r.id)).toEqual(['X1']);
+  });
+
+  it('revives a lapsed grant instead of minting a second row saying the same thing', () => {
+    const plan = publishPlan(primary, [], [grant('G-old', 'P1', PAST)], NOW);
+    expect(plan.primary?.reinstate?.id).toBe('G-old');
+  });
+
+  it('has nothing to do for a primary and dependents that are already public', () => {
+    const grants = [grant('G1', 'P1', null), grant('G2', 'X1', null)];
+    const plan = publishPlan(primary, [x1], grants, NOW);
+    expect(plan.primary).toBeNull();
+    expect(plan.dependents).toEqual([]);
+  });
+});
+
+describe('unpublishPlan', () => {
+  const p1 = rec('P1', 'Primary one');
+  const x1 = rec('X1', 'Shared dependent');
+  const x2 = rec('X2', 'Exclusive dependent');
+  const edges: RelationshipEdgeShape[] = [
+    { id: 'E1', relType: 'marked_with', source: 'P1', target: 'X1', createdAt: PAST },
+    { id: 'E2', relType: 'marked_with', source: 'P1', target: 'X2', createdAt: PAST },
+    { id: 'E3', relType: 'marked_with', source: 'P2', target: 'X1', createdAt: PAST },
+  ];
+
+  it('withdraws the primary and the dependents no other published primary asserts', () => {
+    const grants = [
+      grant('G-P1', 'P1', null),
+      grant('G-P2', 'P2', null), // another live primary
+      grant('G-X1', 'X1', null),
+      grant('G-X2', 'X2', null),
+    ];
+    const plan = unpublishPlan(p1, [x1, x2], edges, grants, { now: NOW });
+    expect(plan.primaryGrants.map((g) => g.id)).toEqual(['G-P1']);
+    // X1 stays: P2 is still published and still links to it.
+    expect(plan.dependentsKept.map((r) => r.id)).toEqual(['X1']);
+    expect(plan.dependentsToWithdraw.map((p) => p.record.id)).toEqual(['X2']);
+    expect(plan.dependentsToWithdraw[0].grants.map((g) => g.id)).toEqual(['G-X2']);
+  });
+
+  it('withdraws a shared dependent once the OTHER primary is no longer published', () => {
+    const grants = [grant('G-P1', 'P1', null), grant('G-X1', 'X1', null), grant('G-X2', 'X2', null)];
+    const plan = unpublishPlan(p1, [x1, x2], edges, grants, { now: NOW });
+    expect(plan.dependentsKept).toEqual([]);
+    expect(plan.dependentsToWithdraw.map((p) => p.record.id)).toEqual(['X1', 'X2']);
+  });
+
+  it('never counts the primary being withdrawn as its own justification', () => {
+    const onlyOwn: RelationshipEdgeShape[] = [edges[0]];
+    const grants = [grant('G-P1', 'P1', null), grant('G-X1', 'X1', null)];
+    const plan = unpublishPlan(p1, [x1], onlyOwn, grants, { now: NOW });
+    expect(plan.dependentsToWithdraw.map((p) => p.record.id)).toEqual(['X1']);
+  });
+
+  it('ignores a dependent that was never published', () => {
+    const plan = unpublishPlan(p1, [x1, x2], edges, [grant('G-P1', 'P1', null)], { now: NOW });
+    expect(plan.dependentsToWithdraw).toEqual([]);
+    expect(plan.dependentsKept).toEqual([]);
+  });
+});
+
+describe('dependentPublication', () => {
+  const x1 = rec('X1', 'Dependent one');
+  const p1 = rec('P1', 'Primary one');
+
+  it('is not published with no grant', () => {
+    expect(dependentPublication(x1, [p1], [], NOW)).toEqual({ kind: 'not-published' });
+  });
+
+  it('names the published primaries it is public THROUGH', () => {
+    const grants = [grant('G-X1', 'X1', null), grant('G-P1', 'P1', null)];
+    expect(dependentPublication(x1, [p1], grants, NOW)).toEqual({
+      kind: 'published', viaPrimaries: [p1],
+    });
+  });
+
+  it('flags a dependent that is public while no published primary links to it', () => {
+    // A public claim with nothing behind it — reachable only by publishing a
+    // dependent directly, which is why a dependent's screen offers no toggle.
+    expect(dependentPublication(x1, [p1], [grant('G-X1', 'X1', null)], NOW)).toEqual({
+      kind: 'published-orphan',
+    });
+  });
+});
+
+describe('publishOrder / withdrawOrder', () => {
+  // These orderings are a safety property, not a preference: every plan is N
+  // untransacted writes, so the only choice is which PARTIAL result is
+  // reachable when one of them fails.
+  const primary = rec('P1', 'Primary');
+  const x1 = rec('X1', 'Dependent one');
+  const x2 = rec('X2', 'Dependent two');
+
+  it('publishes every dependent BEFORE the primary', () => {
+    const plan = publishPlan(primary, [x1, x2], [], NOW);
+    expect(publishOrder(plan).map((a) => a.entity)).toEqual(['X1', 'X2', 'P1']);
+  });
+
+  it('still ends on the primary when some dependents are already public', () => {
+    const plan = publishPlan(primary, [x1, x2], [grant('G', 'X1', null)], NOW);
+    const order = publishOrder(plan).map((a) => a.entity);
+    expect(order[order.length - 1]).toBe('P1');
+  });
+
+  it('withdraws the primary BEFORE the dependents it was asserting', () => {
+    const edges: RelationshipEdgeShape[] = [
+      { id: 'E1', relType: 'marked_with', source: 'P1', target: 'X1', createdAt: PAST },
+    ];
+    const grants = [grant('G-P1', 'P1', null), grant('G-X1', 'X1', null)];
+    const plan = unpublishPlan(primary, [x1], edges, grants, { now: NOW });
+    expect(withdrawOrder(plan).map((g) => g.id)).toEqual(['G-P1', 'G-X1']);
+  });
+});
+
+describe('a primary that sits at the TARGET end of the cascading edge', () => {
+  // The fork this came from always drove publication from the edge's SOURCE.
+  // The declared direction is the tenant's choice, not the platform's, so the
+  // mirror has to work or the generalisation is a lie.
+  const primary = rec('A1', 'Primary at the target end');
+  const d1 = rec('D1', 'Shared dependent');
+  const edges: RelationshipEdgeShape[] = [
+    { id: 'E1', relType: 'covers', source: 'D1', target: 'A1' },
+    { id: 'E2', relType: 'covers', source: 'D1', target: 'A2' },
+  ];
+
+  it('leaves a dependent another live primary still reaches', () => {
+    const grants = [
+      grant('G-A1', 'A1', null),
+      grant('G-A2', 'A2', null),
+      grant('G-D1', 'D1', null),
+    ];
+    const plan = unpublishPlan(primary, [d1], edges, grants, {
+      primaryRole: 'target',
+      now: NOW,
+    });
+    expect(plan.dependentsKept.map((r) => r.id)).toEqual(['D1']);
+    expect(plan.dependentsToWithdraw).toEqual([]);
+  });
+
+  it('withdraws it once no other primary at that end is live', () => {
+    const grants = [grant('G-A1', 'A1', null), grant('G-D1', 'D1', null)];
+    const plan = unpublishPlan(primary, [d1], edges, grants, {
+      primaryRole: 'target',
+      now: NOW,
+    });
+    expect(plan.dependentsToWithdraw.map((d) => d.record.id)).toEqual(['D1']);
+  });
+});