File size: 33,653 Bytes
e88a3a3
 
 
 
 
 
 
 
 
 
 
 
 
 
a83fcff
e88a3a3
 
a83fcff
e88a3a3
a83fcff
 
e88a3a3
 
 
a83fcff
 
e88a3a3
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3e19b1e
e88a3a3
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
cfa8541
e88a3a3
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3e19b1e
 
 
 
e88a3a3
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
cfa8541
 
e88a3a3
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
a83fcff
e88a3a3
85f794d
 
a83fcff
 
e88a3a3
 
 
cfa8541
e88a3a3
 
 
 
a83fcff
 
 
 
 
 
 
 
 
 
 
e88a3a3
 
85f794d
 
 
e88a3a3
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
85f794d
 
 
 
e88a3a3
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
a83fcff
 
 
 
 
e88a3a3
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
cfa8541
e88a3a3
 
cfa8541
e88a3a3
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3e19b1e
85f794d
 
e88a3a3
 
 
 
 
 
 
 
 
 
 
 
 
a83fcff
3e19b1e
 
 
a83fcff
3e19b1e
e88a3a3
 
 
 
 
 
 
 
a83fcff
e88a3a3
a83fcff
e88a3a3
 
a83fcff
e88a3a3
a83fcff
e88a3a3
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3e19b1e
e88a3a3
 
 
 
 
 
3e19b1e
 
e88a3a3
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
cfa8541
e88a3a3
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
a83fcff
 
 
 
e88a3a3
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
85f794d
e88a3a3
 
 
 
 
85f794d
 
 
e88a3a3
 
 
 
 
 
 
85f794d
e88a3a3
 
 
3e19b1e
e88a3a3
 
85f794d
 
 
3e19b1e
85f794d
 
e88a3a3
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
a83fcff
e88a3a3
a83fcff
 
 
e88a3a3
a83fcff
 
 
 
 
 
 
e88a3a3
a83fcff
e88a3a3
a83fcff
e88a3a3
 
 
85f794d
e88a3a3
85f794d
 
 
 
e88a3a3
 
85f794d
e88a3a3
 
 
3e19b1e
e88a3a3
 
 
 
 
 
85f794d
e88a3a3
85f794d
e88a3a3
 
 
 
 
 
3e19b1e
 
e88a3a3
 
a83fcff
e88a3a3
 
 
 
a83fcff
e88a3a3
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
a83fcff
e88a3a3
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3e19b1e
 
 
 
e88a3a3
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
a83fcff
 
 
 
e88a3a3
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
// ---------------------------------------------------------------------------
// shell/ShareDialog.tsx β€” WAVE 20 items 18 / 23 / 26 (R10, contract C-SHARE):
// ONE dialog that shares a view, a folder or a database, and edits who already
// has it.
//
// ONE dialog for three kinds is the ruling, not a convenience: R10 says folders
// and databases share "with the SAME two-role vocabulary views use". Three
// dialogs would drift into three vocabularies within a wave.
//
// It renders over the ALREADY-LOADED state and decides nothing itself β€” every
// rule (what a junk entry means, who may administer, what the PUT carries) is in
// `shareModel.ts`, where the access gate can run it.
// ---------------------------------------------------------------------------

import { useCallback, useEffect, useRef, useState } from "react";
import { API_V1, CREDENTIALS } from "../apiContract";
import PublishPanel from "../publish/PublishPanel";
import { useEscapeClose } from "../ui/useEscapeClose";
import {
  EVERYONE,
  EVERYONE_LABEL,
  SHARE_ROLES,
  addablePeople,
  parseShare,
  resolveShareRecipient,
  shareAccessStatus,
  sharePutBody,
  withEntry,
  withoutEntry,
} from "./shareModel";
import type { ShareEntry, ShareKind, ShareRole, ShareState } from "./shareModel";

/**
 * β›”β›” W39-T17 β€” THIS MAP DOES NOT DEGRADE, IT PRINTS THE WORD `undefined`. A kind with no entry
 * renders "Share undefined" in the heading AND "no longer has this undefined" in the revoke toast:
 * two live strings, not one. `Record<ShareKind, string>` is what stops that being a discovery β€”
 * add a member to `SHARE_KINDS` without one here and `tsc` names this line.
 */
const KIND_WORD: Record<ShareKind, string> = {
  view: "view",
  folder: "folder",
  database: "database",
  field: "field",
  workbook: "workbook",
  report: "report",
};

// A newly-created field is posted through the standalone event queue. The
// share dialog can open before that POST reaches the API, so give field lookups
// a short, bounded chance to observe the definition before showing a 404.
//
// W50-T23 KEPT THIS DELIBERATELY, AND THE SERVER CHANGE IS WHAT SCOPED IT.
// `GET /share/field/...` used to answer 404 for two different situations: a
// column that does not exist yet (the create race above) and a column that
// exists but is not this account's, which is far commoner. The route now
// answers the second one with a 403 that names the column and its owner, so a
// 404 on this kind means only "no definition in any stratum" -- which is the
// race, and the one thing waiting can actually fix. Deleting the loop would
// take the guard away from the race it was written for; the retry is now bounded
// to that race by what the server can still answer, not by a client-side flag.
const FIELD_SHARE_RETRY_MS = [150, 300, 600, 1000] as const;

/** What each role MEANS on each kind, in the reader's own terms. A role picker
 * whose options are two nouns makes the reader guess; these sentences describe
 * the effective capability at the point where the role is chosen. */
const ROLE_BLURB: Record<ShareKind, Record<ShareRole, string>> = {
  view: {
    view: "Can open this view. Cannot rename, refilter or delete it.",
    edit: "Can change this view's filters, sorts and columns, then share it with other people.",
  },
  folder: {
    view: "Can open the folder and the views inside it.",
    edit: "Can rename the folder and move views in and out of it.",
  },
  database: {
    view: "Can open this database and read its records.",
    edit: "Can add, edit and delete its records.",
  },
  field: {
    view: "Can see this column. Cannot change its values or field settings.",
    edit: "Can change this column's values and field settings when the view is editable.",
  },
  /* R16, and the wording tracks the picker: a workbook's view role reads "View only", so the
     sentence under it says what "only" leaves out rather than restating the label. */
  workbook: {
    view: "View only: can open this workbook and read every sheet in it. Cannot change a cell, a formula or a binding.",
    edit: "Can change this workbook's cells, formulas and bindings.",
  },
  report: {
    view: "Can download this report.",
    edit: "Reports cannot be edited.",
  },
};

/**
 * ⭐⭐ W51-T10 / R16 β€” WHAT A WORKBOOK SHARE ACTUALLY HANDS OVER, AND THE HALF NOBODY EXPECTS.
 * A workbook's cells are not all values: a bound cell is a QUERY, and it is run again under
 * whoever is reading. So two people can open one shared workbook and honestly see two different
 * numbers, and the person doing the sharing has to be told that before they share.
 *
 * β›” A `const`, NOT INLINE JSX, FOR THE REASON THIS FILE ALREADY RECORDS TWICE: `verify_prose`'s
 * JSX pass skips any run containing a newline, and a pinning regex cannot span a prettier line
 * wrap. `verify_wiring.py`'s W51-T10 section matches this literal.
 *
 * ⚠ IT RENDERS ABOVE THE ROLE PICKER RATHER THAN INSIDE IT. The picker's blurb only paints once
 * the GET has answered, and the workbook share routes do not exist yet, so a sentence that lived
 * there alone would be absent in the only case that exists today.
 */
const WORKBOOK_BOUND_CELLS =
  "Bound cells show what each person may see: every bound cell is read again under the reader's own scope, so one workbook can honestly show two people different numbers.";

/**
 * β›”β›” THE DEGRADE, AND IT IS KEYED ON A RANGE RATHER THAN ON A LIST OF CODES. `GET
 * /share/workbook/{id}` sits under a `/{kind}/{oid}` path param, so an id this account cannot
 * reach answers 404 while a shape the server dislikes can surface as 400, 405 or 500. A code
 * list would miss the very answer the server actually gives, and the reader would get the
 * generic "The server answered 405." instead: a status number, which is not a sentence and
 * tells them nothing they can act on. 403 stays on the ordinary path, because "you may not" is
 * a real answer about a route that exists.
 *
 * β›” THE SENTENCE CHANGED AT THE WAVE-51 GO-LIVE QA, AND THE OLD ONE WAS THE DEFECT.
 * It read *"Workbook sharing is still being built"*, which was true when W51-T10 shipped
 * against an unbuilt server half and FALSE the moment W51-T25 landed beside it in the combine.
 * The QA pass then found the real cause: `routes_shares.py::_owns_object` carried no
 * `workbook` branch, so the owner of an unshared workbook was answered `404 no_object` and this
 * copy explained a shipped feature away as unbuilt. The branch exists now; this string is the
 * ordinary degrade for a workbook that genuinely cannot be reached, and it no longer makes a
 * claim about the product's roadmap that only a code reader could falsify.
 * β›” NO EM DASH AND NO EN DASH: this reaches a screen (standing rule 2).
 */
const WORKBOOK_SHARE_UNREACHABLE =
  "This workbook's sharing list could not be loaded. Close and reopen the dialog; if it keeps failing, the workbook may have been deleted, or it may no longer be yours to share.";

/**
 * ⭐⭐ W42-T26 (owner instruction 8, R9, contract C7) β€” THE SHARER IS TOLD WHICH FIELDS TRAVEL.
 * Sharing a view grants every field the view NAMES, and until this landed the dialog said nothing
 * about fields at all. The trap the ticket names: T25 makes the behaviour correct and nothing on
 * screen changes, so the disclosure is the half that gets dropped.
 *
 * β›” THESE ARE CONSTANTS, NOT INLINE JSX TEXT, FOR TWO REASONS. (1) `verify_prose`'s JSX pass skips
 * any run containing a newline [[web-prose-blind-to-wrapped-jsx]], and this file's own comments
 * record that blind spot twice; a `const` string literal is seen by the gate whatever prettier does
 * to the markup around it. (2) `wiring_rows/wave42_g.py` pins this copy by regex, and a regex
 * cannot span a JSX line wrap. Standing rule 2: no em dash and no en dash below.
 */
const VIEW_FIELD_TRAVEL =
  "Sharing a view also shares the fields it uses: the columns it shows, and the columns it groups by, colors by and sorts by.";
/** ⚠ ITS OWN SENTENCE ON PURPOSE, and the non-obvious half of the disclosure. A sharer reasons
 *  about the columns they can SEE; a condition may name one they never put on screen, and the
 *  grant covers it all the same. The done-when calls this clause out separately, so it has to be
 *  readable on its own rather than being a word inside a list.
 *  β›” Do NOT restate the literal below in prose here: `wave42_g.py` pins it, and the WIRINGS loop
 *  matches raw file text (comments included), so a paraphrase close enough to match would let the
 *  row pass off its own explanation. */
const VIEW_FILTER_FIELDS =
  "The filters count too. A filter can test a column that is not on screen, and sharing this view hands that column over as well.";
/** ⚠ The grant is TOPIC-WIDE by construction (C7), so the dialog has to say so in the reader's
 *  terms rather than let them assume it stops at this view. */
const VIEW_FIELD_TOPIC_WIDE =
  "Each of those fields then shows on every view of this database, not only on this one.";
const VIEW_EDITOR_REDISTRIBUTION =
  "People with Can edit may share this View with others. They may include any field they can read.";

export default function ShareDialog({
  kind,
  id,
  label,
  topic,
  me,
  onClose,
  onToast,
}: {
  kind: ShareKind;
  id: string;
  label: string;
  /**
   * ⭐ W33-T27 (item 8b, R5) β€” the DATABASE a shared VIEW belongs to, so the publish control can
   * address it as `(topic, view)`. Empty for a folder or a database share, and empty is honest:
   * the panel simply does not render, which is also what happens on a view the server refuses to
   * publish. ⚠ Supplied by `Shell` at the mount (`shareModel.ShareRequest.topic`), not by this
   * dialog β€” see that field's note for why it is optional and how the mount is asserted.
   */
  topic?: string;
  /** The signed-in account's username, so the reader recognises themselves in the
   *  list. `people` is deliberately the OTHER accounts (it is the add-picker's
   *  source), so without this the owner row prints a raw login where every other
   *  row prints a name. */
  me: string;
  onClose: () => void;
  onToast: (message: string) => void;
}) {
  const [state, setState] = useState<ShareState | null>(null);
  const [entries, setEntries] = useState<ShareEntry[]>([]);
  const [error, setError] = useState("");
  const [busy, setBusy] = useState(false);
  const [recipientQuery, setRecipientQuery] = useState("");
  const [pickRole, setPickRole] = useState<ShareRole>("view");
  // The shared parser drops response extensions, so retain the server ceiling separately.
  const [maxGrantableRole, setMaxGrantableRole] = useState<ShareRole | null>(null);
  const dialogRef = useRef<HTMLDivElement>(null);
  const focusReturnRef = useRef<HTMLElement | null>(null);
  // W50-T23 / R7 -- the owner in the words a person reads, resolved by the server
  // through the account registry, with "System (Odoo)" standing in for a column
  // the connector wrote. `parseShare` builds a fixed five-key object and drops
  // everything else, so this display-only label rides off the raw body.
  const [ownerLabel, setOwnerLabel] = useState("");

  const path = `${API_V1}/share/${encodeURIComponent(kind)}/${encodeURIComponent(id)}`;

  useEffect(() => {
    focusReturnRef.current = document.activeElement instanceof HTMLElement
      ? document.activeElement
      : null;
    dialogRef.current?.focus();
    return () => {
      const opener = focusReturnRef.current;
      if (opener?.isConnected) opener.focus();
    };
  }, []);

  useEffect(() => {
    let dead = false;
    setState(null);
    setMaxGrantableRole(null);
    setPickRole("view");
    setError("");
    void (async () => {
      try {
        let res: Response;
        for (let attempt = 0; ; attempt += 1) {
          res = await fetch(path, { credentials: CREDENTIALS });
          if (
            res.status !== 404 ||
            kind !== "field" ||
            attempt >= FIELD_SHARE_RETRY_MS.length
          ) {
            break;
          }
          await new Promise<void>((resolve) => {
            window.setTimeout(resolve, FIELD_SHARE_RETRY_MS[attempt]);
          });
          if (dead) return;
        }
        if (!res.ok) {
          // W51-T10: a workbook the server will not answer for. A sentence, never a status
          // number, and never a blank dialog. See `WORKBOOK_SHARE_UNREACHABLE` for why the
          // test is a RANGE rather than a code list.
          if (kind === "workbook" && res.status >= 400 && res.status !== 403) {
            if (!dead) setError(WORKBOOK_SHARE_UNREACHABLE);
            return;
          }
          // 4xx text is policy the reader needs; a 5xx's internals are not theirs.
          if (!dead) setError(res.status >= 500
            ? "Something went wrong on our side. Try again in a moment."
            : `The server answered ${res.status}.`);
          return;
        }
        const body = (await res.json().catch(() => null)) as unknown;
        if (dead) return;
        const parsed = parseShare(body);
        const ceiling = body && typeof body === "object"
          ? (body as { maxGrantableRole?: unknown }).maxGrantableRole
          : null;
        setMaxGrantableRole(ceiling === "view" || ceiling === "edit" ? ceiling : null);
        setState(parsed);
        setEntries(parsed.entries);
        setOwnerLabel(
          body && typeof body === "object"
            && typeof (body as { ownerLabel?: unknown }).ownerLabel === "string"
            ? ((body as { ownerLabel?: string }).ownerLabel ?? "").trim()
            : ""
        );
      } catch {
        if (!dead) setError("Cannot reach the server.");
      }
    })();
    return () => {
      dead = true;
    };
  }, [path]);

  // The Share modal joins the one overlay stack. A local key listener races any picker or
  // nested publish control mounted inside it and can close two surfaces from one Escape.
  useEscapeClose(true, () => {
    if (!busy) onClose();
  }, { container: () => dialogRef.current });

  const save = useCallback(
    async (next: ShareEntry[]) => {
      setBusy(true);
      setError("");
      try {
        const res = await fetch(path, {
          method: "PUT",
          credentials: CREDENTIALS,
          headers: { "Content-Type": "application/json" },
          // The WHOLE list, every time: the PUT replaces, so a body assembled from
          // a delta would revoke everyone it failed to mention.
          body: JSON.stringify(sharePutBody(next)),
        });
        if (!res.ok) {
          const body = (await res.json().catch(() => null)) as
            | { error?: { code?: string; message?: string } }
            | null;
          setError(
            res.status >= 500 && body?.error?.code !== "view_share_failed"
              ? "Something went wrong on our side. Try again in a moment."
              : body?.error?.message || `The server answered ${res.status}.`
          );
          return false;
        }
        const body = (await res.json().catch(() => null)) as unknown;
        // Re-read the SERVER's copy rather than trusting the draft: `_clean_entries`
        // drops what it will not store, and an editor that kept showing a row the
        // store rejected would be the "shared, silently inert" failure this feature
        // exists to avoid.
        // ⚠ Only `.entries` is consumed here β€” the PUT answers with the stored record
        // (`{owner, entries}`) and says nothing about this session's standing, so the
        // literal below feeds the parser's required field and is never read back. The
        // editor's `mayAdminister` stays the one the GET established; a save cannot
        // promote anybody, and this line must never be the reason it looks like it can.
        const saved = parseShare({ ...(body as object), mayAdminister: true });
        setEntries(saved.entries);
        return true;
      } catch {
        setError("Cannot reach the server.");
        return false;
      } finally {
        setBusy(false);
      }
    },
    [path]
  );

  const mayAdminister = !!state?.mayAdminister;
  const grantableRoles = SHARE_ROLES.filter((role) => mayAdminister && (kind !== "report" || role === "view") && (
    maxGrantableRole === "edit" || (maxGrantableRole === "view" && role === "view")
  ));
  const assign = useCallback(async (user: string) => {
    setBusy(true); setError("");
    try {
      const res = await fetch(`${path}/assign`, {
        method: "POST", credentials: CREDENTIALS,
        headers: { "Content-Type": "application/json" }, body: JSON.stringify({ user }),
      });
      if (!res.ok) { setError(`The server answered ${res.status}.`); return; }
      onToast(`${nameOf(user)} now has this assigned view.`);
    } catch { setError("Cannot reach the server."); }
    finally { setBusy(false); }
  }, [path, onToast]);
  const options = state ? addablePeople(state.people, entries) : [];
  const pick = state
    ? kind === "report"
      ? resolveShareRecipient(state.people, entries, recipientQuery, kind)
      : resolveShareRecipient(state.people, entries, recipientQuery)
    : null;
  const canAddEveryone = kind !== "report" && !entries.some((entry) => entry.user === EVERYONE);
  const nameOf = (user: string) =>
    user === "*"
      ? "Everyone"
      : user && user === me.trim().toLowerCase()
        ? "You"
        : state?.people.find((p) => p.user === user)?.name ?? user;

  return (
    <div className="shell-newdb-scrim">
      <div
        ref={dialogRef}
        className="shell-newdb shell-share"
        role="dialog"
        aria-modal="true"
        aria-label={`Share ${label}`}
        tabIndex={-1}
        onClick={(e) => e.stopPropagation()}
      >
        <h2>Share {KIND_WORD[kind]}</h2>
        {/* β›”β›” W33-T30 / audit S-8 β€” THIS SENTENCE WAS FALSE FOR ONE OF THE THREE KINDS.
            It read, unconditionally, "Sharing never widens past this workspace: everyone here
            can already open the surface it lives on." True for a VIEW or a FOLDER on a governed
            module, where the receiver's row scope and hidden-field closure run before any
            foreign view is merged. FALSE for a `database` grant on a `ut_*` table: no row filter
            and no hidden field can even be DECLARED there (`_PERM_MODULES` is two keys and
            `_clean_perms` 400s the rest), so the grant registry IS the only wall and the grant
            is all-or-nothing. The audit's fix is "say so at BOTH doors"; `core/shares.py` and
            `routes_shares.py` are the other two, and this is the one a PERSON reads. */}
        {/* β›” STANDING RULE 2 (D-490, W39-T17) β€” THIS LINE CARRIED AN EM DASH TO THE SCREEN AND
            `verify_prose.py` SCORED THE FILE ZERO. The prose run WRAPS, and the gate's JSX pass
            skips any run containing a newline [[web-prose-blind-to-wrapped-jsx]] β€” the same blind
            spot already recorded twenty lines below. REWRITTEN, not stripped: the question the
            dialog answers is now the sentence's subject, which needs no dash at all. */}
        <p className="shell-newdb-sub">
          {kind !== "report" ? <>Who can reach <strong>{label}</strong>, and what they can do with it.{" "}</> : null}
          {kind === "workbook"
            ? WORKBOOK_BOUND_CELLS
            : kind === "database"
            ? "Sharing a database shares all of it: every record and every column. There is no per-row or per-column limit on a database grant."
             : kind === "field"
             ? "A shared column starts out hidden from everybody else on this database. This is what lets the people you choose see it and its values."
             : kind === "report"
             ? "Only the people you add here see this report."
             : "Sharing never widens past this workspace: everyone here can already open the surface it lives on."}
        </p>
        {kind === "view" ? (
          <>
            <p className="shell-share-note">
              View access is the general rule. A field's own Share field access takes precedence, so
              a field shared as Can view stays read-only even inside an editable view.
            </p>
            {/* ⭐⭐ W42-T26 / C7 β€” WHICH FIELDS TRAVEL, and how far. Two paragraphs, not one and
                not four: the done-when reads for three statements (what travels, the FILTER's
                fields by name, and the topic-wide reach), and a sharer must be able to point at a
                sentence for each without reading an essay in a dialog subtitle. */}
            <p className="shell-share-note">
              {VIEW_FIELD_TRAVEL} {VIEW_FIELD_TOPIC_WIDE}
            </p>
            <p className="shell-share-note">{VIEW_FILTER_FIELDS}</p>
            <p className="shell-share-note">{VIEW_EDITOR_REDISTRIBUTION}</p>
          </>
        ) : kind === "field" ? (
          <p className="shell-share-note">
            Field access takes precedence over the view. Can view keeps values and field settings
            read-only; Can edit allows changes when the view is editable.
          </p>
        ) : null}

        {!state && !error ? (
          <div className="shell-share-wait">
            <span className="lp-spin" role="status" aria-label="Loading" />
          </div>
        ) : null}

        {state ? (
          <>
            {/* THE MANAGE-ACCESS EDITOR (item 23): the list first, because the
                question people open this for is "who has this already" β€” with the
                one-line answer above it, since the fact that changes everything
                ("Everyone can edit") is the one a list of rows buries. */}
            <h3 className="shell-share-summary">Manage access</h3>
            <p className="shell-share-note">
              Workspace access: {shareAccessStatus(entries)}.
            </p>
            <div className="shell-share-list">
              {/* W50-T23 / R7 -- THE OWNER ROW IS NEVER BLANK AND NEVER ABSENT. Under R7
                  every editable field has an owner (its creator, else the tenant
                  Administrator) and a connector column reads "System (Odoo)", so there is
                  always something true to print. The old `: null` arm rendered NOTHING for
                  a column whose owner the server could not name, which is how a member
                  ended up being told to ask somebody the dialog never showed them.
                  `ownerLabel` is preferred over `nameOf` only when `nameOf` could not
                  resolve the username: a member gets `people: []`, so `nameOf` would print
                  a raw login where the server already knows the real name. */}
              {state.owner || (kind === "field" && ownerLabel) ? (
                <div className="shell-share-row is-owner">
                  <span className="shell-share-who">
                    {state.owner
                      ? nameOf(state.owner) === state.owner
                        ? ownerLabel || state.owner
                        : nameOf(state.owner)
                      : ownerLabel}
                  </span>
                  <span className="shell-share-role">Owner</span>
                </div>
              ) : null}
              {entries.length === 0 ? (
                <div className="shell-share-empty">
                  Not shared with anyone yet.
                </div>
              ) : null}
              {entries.map((e) => (
                <div className="shell-share-row" key={e.user}>
                  <span className="shell-share-who">{nameOf(e.user)}</span>
                  {grantableRoles.includes(e.role) ? <select
                    className="shell-share-select"
                    value={e.role}
                    disabled={!mayAdminister || busy}
                    aria-label={`Role for ${nameOf(e.user)}`}
                    onChange={(ev) => {
                      const role = ev.target.value as ShareRole;
                      if (!grantableRoles.includes(role)) return;
                      const next = withEntry(entries, e.user, role);
                      void save(next);
                    }}
                  >
                    {/* ⭐ W51-T10 / R16 β€” THE LABEL IS PER KIND, exactly as `KIND_WORD` and
                        `ROLE_BLURB` are. A workbook's read role is "View only" (the ruling's own
                        words); the other four kinds keep "Can view" byte for byte, because
                        re-wording one label across a shared control is a repo-wide gate grep. */}
                    {grantableRoles.map((r) => (
                      <option key={r} value={r}>
                        {r === "edit"
                          ? "Can edit"
                          : kind === "report" ? "Can download" : kind === "workbook" ? "View only" : "Can view"}
                      </option>
                    ))}
                  </select> : (
                    // Existing grants above the ceiling stay unchanged in every replacing PUT.
                    <span className="shell-share-role">
                      {e.role === "edit" ? "Can edit" : kind === "report" ? "Can download" : kind === "workbook" ? "View only" : "Can view"}
                    </span>
                  )}
                  <button
                    type="button"
                    className="shell-share-revoke"
                    disabled={!mayAdminister || busy}
                    onClick={() => {
                      const next = withoutEntry(entries, e.user);
                      void save(next).then((ok) => {
                        if (ok) onToast(`${nameOf(e.user)} no longer has this ${KIND_WORD[kind]}.`);
                      });
                    }}
                  >
                    Remove
                  </button>
                  {kind === "view" && mayAdminister && e.user !== "*" ? (
                    <button type="button" className="shell-share-revoke" disabled={busy}
                      onClick={() => void assign(e.user)}>
                      Assign
                    </button>
                  ) : null}
                </div>
              ))}
            </div>

            {mayAdminister ? (
              <div className="shell-share-add">
                <input
                  className="shell-share-select"
                  type="search"
                  list="shell-share-recipient-options"
                  value={recipientQuery}
                  disabled={busy}
                  aria-label="Search people to share with"
                  placeholder="Search people"
                  autoFocus
                  onChange={(e) => setRecipientQuery(e.target.value)}
                />
                <datalist id="shell-share-recipient-options">
                  {canAddEveryone ? <option value={EVERYONE_LABEL} /> : null}
                  {options.map((p) => (
                    <option key={p.user} value={`${p.name} (${p.user})`} />
                  ))}
                </datalist>
                <select
                  className="shell-share-select"
                  value={pickRole}
                  disabled={busy || !grantableRoles.length}
                  aria-label="Role for the person being added"
                  onChange={(e) => {
                    const role = e.target.value as ShareRole;
                    if (grantableRoles.includes(role)) setPickRole(role);
                  }}
                >
                  {/* The add-person picker says the same words the row picker says. */}
                  {grantableRoles.map((r) => (
                    <option key={r} value={r}>
                      {r === "edit"
                        ? "Can edit"
                        : kind === "report" ? "Can download" : kind === "workbook" ? "View only" : "Can view"}
                    </option>
                  ))}
                </select>
                <button
                  type="button"
                  className="login-submit shell-share-grant"
                  disabled={busy || !pick || !grantableRoles.includes(pickRole)}
                  onClick={() => {
                    if (!pick || !grantableRoles.includes(pickRole)) return;
                    const next = withEntry(entries, pick, pickRole);
                    void save(next).then((ok) => {
                      if (ok) {
                        onToast(
                           kind === "field"
                             ? `${nameOf(pick)} can now ${pickRole === "edit" ? "edit" : "view"} this field.`
                             : kind === "report"
                             ? `${nameOf(pick)} can now download this report.`
                             : `${nameOf(pick)} can now ${pickRole} this ${KIND_WORD[kind]}.`
                        );
                        setRecipientQuery("");
                      }
                    });
                  }}
                >
                  Send
                </button>
                <p className="shell-share-blurb">{ROLE_BLURB[kind][pickRole]}</p>
                {/* β›” W33-T30 / audit S-5 β€” `*` + `edit` IS A TENANT-WIDE WRITE GRANT AND LOOKED
                    LIKE ANY OTHER ROW. Two ordinary choices β€” a population and a role, each
                    unremarkable alone β€” combine into "anybody here may change this", and the
                    dialog said nothing at the point where the two meet. The audit's fix is
                    "make the population legible at the point of choice": one sentence, only on
                    the combination, in the words of the consequence rather than of the setting.
                    ⚠ It is NOT a confirm step. The capability is real and deliberate; a person
                    choosing it on purpose should not be interrogated, only told what it means. */}
                {/* ⚠ `shell-share-note`, the class the refusal below already uses, rather than a
                    new `shell-share-warn`: `index.css` is B's file this wave (contract C4), and a
                    new class with no rule renders as unstyled body text β€” which for a sentence
                    whose whole job is to be NOTICED is worse than reusing a quiet one. */}
                {/* β›” STANDING RULE 2 (wave-36 QA) β€” the sentence below carried an em dash and
                    `web_prose` scored this file 0 findings: the prose run WRAPS, and the gate's
                    JSX pass skips any run containing a newline [[web-prose-blind-to-wrapped-jsx]].
                    REWRITTEN, not merely stripped β€” the comma keeps the contrast the sentence
                    exists to draw. */}
                {pick === EVERYONE && pickRole === "edit" ? (
                  <p className="shell-share-note">
                    Everyone in this workspace will be able to change this {KIND_WORD[kind]},
                    not just open it.
                  </p>
                ) : null}
              </div>
            ) : (
              // β›” NOT A HIDDEN EDITOR β€” a stated refusal. A collaborator who can
              // change this object's CONTENT still cannot change who else reaches
              // it (the server's rule; this is the courtesy half). Saying why beats
              // greying three controls and letting the reader guess.
              // β›” STANDING RULE 2 (W39-T17) β€” TWO em dashes, live on screen, and `verify_prose`
              // green over both for the wrapped-JSX reason recorded above. NOT a pre-existing
              // violation this ticket may leave alone: adding `field` to `KIND_WORD` is what
              // brings this sentence to a NEW surface, so it ships the dash rather than merely
              // inheriting it. Rewritten with the owner in the subject, so no aside is needed.
              <p className="shell-share-note">
                {kind === "report"
                  ? "Only workspace administrators can change who this report is shared with."
                  : <>Only this {KIND_WORD[kind]}'s owner and workspace administrators can change who
                    it is shared with. You can still use it as your role allows.</>}
              </p>
            )}
          </>
        ) : null}

        {/* ⭐⭐ W33-T27 (item 8b, R5) β€” PUBLISH, below the grant editor and inside the same
            dialog, because this is where a person comes to ask "who can reach this?".
            β›” IT IS NOT A FOURTH ROLE IN THE LIST ABOVE, and the panel says so in its own
            words: a published link names nobody, creates no grant and is revoked by replacing
            the link rather than by removing a person. Folding it into the entries list would
            have made "the public" look like a grantee β€” which is precisely the conflation the
            sharing audit's S-4 row is about (two systems already answer "is this shared"; this
            is a third thing).
            ⚠ ONLY FOR A VIEW, and only when the shell knew which database it belongs to. The
            panel then asks the SERVER whether this particular view may be published and renders
            nothing if not β€” so "absent on non-interface views" is one evaluator, not two. */}
        {kind === "view" && topic ? <PublishPanel topic={topic} view={id} /> : null}

        {error ? <p className="shell-newdb-err" role="alert">{error}</p> : null}
        <div className="shell-newdb-actions">
          <button type="button" disabled={busy} onClick={onClose}>Close</button>
        </div>
      </div>
    </div>
  );
}