@mistriwork/engine 1.0.0-rc.58 → 1.0.0-rc.60

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -99,7 +99,8 @@ export const LOOK_PALETTES = [
99
99
  onSignal: '#15130f',
100
100
  chart: '#0c8ab0',
101
101
  },
102
- looks: { workshop: { light: { link: '#00687e' } } },
102
+ /* A step deeper on Workshop's paper and on Atelier's, whose menu's hover is the warm ground a shade down. */
103
+ looks: { workshop: { light: { link: '#00687e' } }, atelier: { light: { link: '#00687e' } } },
103
104
  },
104
105
  {
105
106
  id: 'cobalt',
@@ -244,9 +245,69 @@ function ledSeries(series, lead) {
244
245
  * ink, on paper, with no tint.
245
246
  * - Lumen: the accent and its pale tint, links, the ring, the menu's mark and the first chart series.
246
247
  * - Mono and Sage: the same, on their own neutral tint for what is chosen (Mono's gray, Sage's warm cream).
248
+ * - Atelier: Mono's reach, on paper: links, the current tab, the ring, the first series, and the hue's wash under what
249
+ * is chosen; its primary stays the ink.
250
+ * - Graphite: Lumen's reach, and the dark menu's marker in the hue's night depth by day as by night.
251
+ * - Bloom: Lumen's reach and the primary verb's fill.
247
252
  * - Ledger: Lumen's reach and the primary verb's fill, and the hue's ink and the rules (a table's double-ruled heads, a box's top rule) in it;
248
253
  * the paper and the cover stay the book's own green, with the gilt mark for the current entry.
249
254
  */
255
+ /** OKLab back to a hex colour, clipped to what a screen draws. */
256
+ function hexOf([L, a, b]) {
257
+ const l = (L + 0.3963377774 * a + 0.2158037573 * b) ** 3, m = (L - 0.1055613458 * a - 0.0638541728 * b) ** 3, s = (L - 0.0894841775 * a - 1.291485548 * b) ** 3;
258
+ const channel = (value) => {
259
+ const lit = Math.min(1, Math.max(0, value));
260
+ const coded = lit <= 0.0031308 ? lit * 12.92 : 1.055 * lit ** (1 / 2.4) - 0.055;
261
+ return Math.round(coded * 255)
262
+ .toString(16)
263
+ .padStart(2, '0');
264
+ };
265
+ return `#${channel(4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s)}${channel(-1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s)}${channel(-0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s)}`;
266
+ }
267
+ /** A palette's hue as one look draws it. */
268
+ export function paletteAccent(look, palette, mode) {
269
+ return { ...palette[mode], ...palette.looks?.[look]?.[mode] }.accent;
270
+ }
271
+ /** Whether two colours are near enough in hue to be taken for one: within forty degrees of each other on OKLab's
272
+ wheel, both with colour enough to have a hue at all. */
273
+ export function sameHue(a, b) {
274
+ const [, aA, aB] = oklab(linear(a));
275
+ const [, bA, bB] = oklab(linear(b));
276
+ if (Math.hypot(aA, aB) < 0.03 || Math.hypot(bA, bB) < 0.03)
277
+ return false;
278
+ const turn = Math.abs(Math.atan2(aB, aA) - Math.atan2(bB, bA));
279
+ return Math.min(turn, 2 * Math.PI - turn) < (40 * Math.PI) / 180;
280
+ }
281
+ /**
282
+ * A look's own colours turned to another hue: every neutral keeps how light it is and how much colour it holds, and
283
+ * takes the hue of `like` in place of the hue of `was` (the look's default palette's accent). A look whose page is a
284
+ * tint of its hue (Bloom's lavender ground under violet) is that look in another palette only if the page turns with
285
+ * it: an emerald button on a lavender page is two looks at once. A palette with next to no colour of its own (Slate,
286
+ * Ink) takes the tint out in proportion, so the page under it is grey and not a guess at a hue. What a colour means
287
+ * (`status`) and a chart's series are not neutrals and stay as written.
288
+ */
289
+ export function rehued(colors, like, was) {
290
+ const [, likeA, likeB] = oklab(linear(like));
291
+ const [, wasA, wasB] = oklab(linear(was));
292
+ const turn = Math.atan2(likeB, likeA) - Math.atan2(wasB, wasA);
293
+ const hold = Math.min(1, Math.hypot(likeA, likeB) / Math.max(Math.hypot(wasA, wasB), 1e-6));
294
+ const one = (hex) => {
295
+ if (!/^#[0-9a-f]{6}$/i.test(hex))
296
+ return hex;
297
+ const [L, a, b] = oklab(linear(hex));
298
+ const chroma = Math.hypot(a, b) * hold;
299
+ const hue = Math.atan2(b, a) + turn;
300
+ return hexOf([L, chroma * Math.cos(hue), chroma * Math.sin(hue)]);
301
+ };
302
+ const walk = (value, key) => key === 'status' || key === 'chart'
303
+ ? value
304
+ : typeof value === 'string'
305
+ ? one(value)
306
+ : value && typeof value === 'object' && !Array.isArray(value)
307
+ ? Object.fromEntries(Object.entries(value).map(([name, inner]) => [name, walk(inner, name)]))
308
+ : value;
309
+ return walk(colors, '');
310
+ }
250
311
  export function paletteColors(look, palette, mode, series) {
251
312
  const tone = { ...palette[mode], ...palette.looks?.[look]?.[mode] };
252
313
  const link = tone.link ?? tone.accent;
@@ -302,5 +363,38 @@ export function paletteColors(look, palette, mode, series) {
302
363
  chart: ledSeries(series, tone.chart),
303
364
  };
304
365
  }
366
+ case 'atelier':
367
+ /* A second colour on a printed page: links, the current tab's rule, the ring and the first series. The primary
368
+ stays the ink and the paper its own. It says no soft accent: what is chosen sits on the hue's wash over the
369
+ paper, which the builder works out for each palette (themeBuild.ts). */
370
+ return { accent: tone.accent, link, focus: tone.focus, nav: { accent: link }, chart: ledSeries(series, tone.chart) };
371
+ case 'graphite': {
372
+ /* The menu is near-black by day too, so its marker is the hue at its night depth, which reads on it; the page
373
+ wears the day's. */
374
+ const night = { ...palette.dark, ...palette.looks?.[look]?.dark };
375
+ return {
376
+ accent: tone.accent,
377
+ accentSoft: tone.soft,
378
+ link,
379
+ focus: tone.focus,
380
+ nav: { accent: night.link ?? night.accent },
381
+ chart: ledSeries(series, tone.chart),
382
+ };
383
+ }
384
+ case 'bloom':
385
+ /* The hue is the look: the primary button is filled in it, what is chosen sits on its tint. What is merely so
386
+ (a step that is new or under way, a note) is said in it too: the look's own blue beside an emerald page was a
387
+ second hue with nothing to say, and a tile tinted in it read as left over from another palette. What a colour
388
+ warns of or confirms keeps its own. */
389
+ return {
390
+ accent: tone.accent,
391
+ primary: tone.accent,
392
+ accentSoft: tone.soft,
393
+ link,
394
+ focus: tone.focus,
395
+ status: { info: link },
396
+ nav: { accent: link },
397
+ chart: ledSeries(series, tone.chart),
398
+ };
305
399
  }
306
400
  }
@@ -152,6 +152,8 @@ const VOCABULARY_WORD = /^[a-z][a-z0-9]*(?:(?:_+| |-)[a-z0-9]+)*$/;
152
152
  export function vocabularyWord(text) {
153
153
  return VOCABULARY_WORD.test(text) ? humanName(text.replaceAll(' ', '_')) : text;
154
154
  }
155
+ const TRUE_SPELLINGS = ['1', 't'];
156
+ const FALSE_SPELLINGS = ['0', 'f'];
155
157
  /**
156
158
  * The word a display rule says a stored value as: the author's own
157
159
  * (`values`), the value made words where the rule says `humanize`
@@ -163,6 +165,14 @@ export function vocabularyWord(text) {
163
165
  export function displayWord(rule, text) {
164
166
  if (rule?.values && Object.hasOwn(rule.values, text))
165
167
  return rule.values[text];
168
+ /* A truth is stored as the engine spells it (`true` on Postgres, `1` on SQLite, and a computed one as either): a
169
+ rule that words `true` and `false` words every spelling of them, or a SQLite list read 1 and 0 under an author's
170
+ "Low" and "OK". */
171
+ if (rule?.values) {
172
+ const truth = TRUE_SPELLINGS.includes(text) ? 'true' : FALSE_SPELLINGS.includes(text) ? 'false' : undefined;
173
+ if (truth && Object.hasOwn(rule.values, truth))
174
+ return rule.values[truth];
175
+ }
166
176
  if (rule?.humanize && text.trim()) {
167
177
  const plain = /^[A-Z0-9_]+$/.test(text) ? text.toLowerCase() : text;
168
178
  const word = vocabularyWord(plain);
@@ -878,6 +878,7 @@ export function sectionConfig(s) {
878
878
  ...(s.presentation ? { presentation: s.presentation } : {}),
879
879
  ...(s.edit ? { editable: true } : {}),
880
880
  ...(s.emptyMode ? { empty: s.emptyMode } : {}),
881
+ ...(s.notes ? { notes: s.notes } : {}),
881
882
  };
882
883
  case 'timeline':
883
884
  return {
@@ -49,6 +49,18 @@ export interface AnatomyHints {
49
49
  /** What the caller calls a column (its `labels`): a reference's card is titled as its field is ("Class", not
50
50
  "Class session"). */
51
51
  caption?: (table: TableMeta, column: string) => string | undefined;
52
+ /** The card a person-facing list draws this table's records as (a list view's `cards(...)` with a `value` and an
53
+ `image`), where the App has one: the record it opens is drawn as that card is read, large — its pictures first,
54
+ its figure beside them with presence, its facts under the name — rather than as an office's record. */
55
+ card?: (table: TableMeta) => {
56
+ value: string;
57
+ facts?: readonly string[];
58
+ image: {
59
+ from: string;
60
+ whose: string;
61
+ sort?: string;
62
+ };
63
+ } | undefined;
52
64
  }
53
65
  interface RelatedPick {
54
66
  title?: string;
@@ -498,15 +498,60 @@ export function anatomyPage(schema, baseId, hints = {}) {
498
498
  const sections = base ? inferredSections(schema, base, hints) : null;
499
499
  if (!base || !sections)
500
500
  return null;
501
+ const shown = showcaseOf(schema, base, sections, hints);
501
502
  return {
502
503
  id: `suggested:${base.id}`,
503
504
  name: base.name,
504
505
  base: base.id,
505
- sections,
506
- listTabs: true,
506
+ sections: shown ?? sections,
507
+ listTabs: !shown,
508
+ ...(shown ? { layout: 'showcase' } : {}),
507
509
  source: 'suggested',
508
510
  };
509
511
  }
512
+ /**
513
+ * A record the App shows people as a card (a list's `cards(...)` with a `value` and an `image`) is drawn, when nobody
514
+ * wrote its page, the way that card reads, large: a showcase (pageLayouts.ts) — its pictures first, its figure beside
515
+ * them in the panel with presence, the card's facts under the name, and the rest of the record under both. The
516
+ * vocabulary is the card's own, so there is no second place to name a product's price.
517
+ */
518
+ function showcaseOf(schema, base, sections, hints) {
519
+ const card = hints.card?.(base);
520
+ if (!card || !findTable(schema, card.image.from) || !base.columns.some((column) => column.name === card.value))
521
+ return null;
522
+ const [sort, way] = (card.image.sort ?? '').trim().split(/\s+/);
523
+ const gallery = {
524
+ kind: 'list',
525
+ title: 'Photos',
526
+ from: card.image.from,
527
+ path: card.image.whose,
528
+ columns: [],
529
+ presentation: 'gallery',
530
+ limit: 6,
531
+ ...(sort ? { orderBy: [{ column: sort, direction: way === 'desc' ? 'desc' : 'asc' }] } : {}),
532
+ };
533
+ const figure = { kind: 'fields', presentation: 'headline', region: 'aside', paths: [card.value] };
534
+ const head = sections.find((section) => section.kind === 'fields' && section.presentation === 'header');
535
+ const headPaths = head?.kind === 'fields' ? (head.paths ?? []) : [];
536
+ const facts = (card.facts?.length ? [...card.facts] : [...headPaths]).filter((path) => path !== card.value);
537
+ /* What the head and the figure say is not said again under them: a fact read through its reference
538
+ ("category_id.name") is its reference's column. */
539
+ const said = new Set([card.value, ...facts.map((path) => path.split('.')[0])]);
540
+ const rest = sections.flatMap((section) => {
541
+ if (section === head && section.kind === 'fields')
542
+ return [{ ...section, paths: facts }];
543
+ /* The figure is said beside the pictures; the office's cards and its history stay the office's page. */
544
+ if (section.region === 'aside' || section.kind === 'history')
545
+ return [];
546
+ if (section.kind === 'fields') {
547
+ const paths = (section.paths ?? []).filter((path) => !said.has(path.split('.')[0]));
548
+ return paths.length ? [{ ...section, paths }] : [];
549
+ }
550
+ return [section];
551
+ });
552
+ const [lead, ...body] = rest;
553
+ return [lead, gallery, figure, ...body];
554
+ }
510
555
  /**
511
556
  * An App's record page that declares no aside gets the generated page's: the
512
557
  * record's remaining fields as a property rail, titled by its noun ("Bike").
@@ -80,7 +80,7 @@ const MAX_TAB_NAME = 40;
80
80
  /* `view` is an authored kind with no section of its own: `embed(view, { whose })`
81
81
  is read into a related list that remembers the view (PageList.view). */
82
82
  export const PAGE_SECTION_KEYS = {
83
- fields: [...SECTION_COMMON, 'show', 'columns', 'names', 'presentation', 'editable', 'empty'],
83
+ fields: [...SECTION_COMMON, 'show', 'columns', 'names', 'presentation', 'editable', 'empty', 'notes'],
84
84
  /* The record a reference names, in a box of its own: the first shown field is its title, the rest its facts. */
85
85
  card: [...SECTION_COMMON, 'show'],
86
86
  /* A figure with its facts, its earlier value, its estimate and the calls to action beside it. */
@@ -137,6 +137,7 @@ export const PAGE_SECTION_KEYS = {
137
137
  'opens',
138
138
  'rowActions',
139
139
  'actions',
140
+ 'primary',
140
141
  'group',
141
142
  ],
142
143
  };
@@ -427,6 +428,22 @@ function parseSection(entry, at, config) {
427
428
  if (s.note !== undefined && (typeof s.note !== 'string' || !s.note.trim() || s.note.trim().length > 300)) {
428
429
  throw new Error(`${at} has a "note" that is not text of at most 300 characters.`);
429
430
  }
431
+ /* A line under a summary's figure, by the field it stands under: what the figure counts, as a breakdown's `notes`
432
+ say of its steps (appDashShapes.ts). Words only: a second value is a second field. */
433
+ if (s.notes !== undefined) {
434
+ const notes = s.notes;
435
+ if (written !== 'fields' || (s.presentation !== undefined && s.presentation !== 'summary'))
436
+ throw new Error(`${at} has "notes", which only a summary of figures carries: fields([...], { notes }) with no other presentation.`);
437
+ if (!notes || typeof notes !== 'object' || Array.isArray(notes) || Object.keys(notes).length > 12)
438
+ throw new Error(`${at} has "notes" that is not a map of at most 12 fields to a line each: { balance: 'Charged less paid' }.`);
439
+ const shown = new Set(Array.isArray(s.show) ? s.show.map(String) : []);
440
+ for (const [field, note] of Object.entries(notes)) {
441
+ if (!shown.has(field))
442
+ throw new Error(`${at} has a note for "${field}", which it does not show: a note stands under a field named in "show".`);
443
+ if (typeof note !== 'string' || !note.trim() || note.trim().length > 80)
444
+ throw new Error(`${at} has a note for "${field}" that is not a line of 1 to 80 characters.`);
445
+ }
446
+ }
430
447
  /* A reference says the record it names by default in an App, so the
431
448
  one thing worth writing is the opt-out. */
432
449
  if (s.names !== undefined && s.names !== false) {
@@ -452,6 +469,9 @@ function parseSection(entry, at, config) {
452
469
  ...(s.subtitle === undefined ? {} : { subtitle: s.subtitle.trim() }),
453
470
  ...(s.was === undefined ? {} : { was: s.was.trim() }),
454
471
  ...(s.note === undefined ? {} : { note: s.note.trim() }),
472
+ ...(s.notes === undefined
473
+ ? {}
474
+ : { notes: Object.fromEntries(Object.entries(s.notes).map(([field, note]) => [field, note.trim()])) }),
455
475
  };
456
476
  }
457
477
  if (kind === 'timeline') {
@@ -863,6 +883,13 @@ function parseSection(entry, at, config) {
863
883
  throw new Error(`${at} has a "show" that is not an array of column names.`);
864
884
  }
865
885
  const shown = s.show === undefined ? undefined : parseShowEntries(s.show, at);
886
+ /* What a row is called in this list alone, as on a list view: one of the columns it shows. */
887
+ if (s.primary !== undefined) {
888
+ if (typeof s.primary !== 'string' || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(s.primary.trim()))
889
+ throw new Error(`${at}: "primary" must name one of the list's own columns, the one a row is titled by: primary: 'title'.`);
890
+ if (!shown?.columns.includes(s.primary.trim()))
891
+ throw new Error(`${at}: "primary" names "${s.primary.trim()}", which "show" does not list: a row is titled by a column the list shows.`);
892
+ }
866
893
  /* A gallery draws a related list of image files; whether the rows are
867
894
  files is the App's to say (`file` on the resource), judged where the
868
895
  page meets the App. */
@@ -975,6 +1002,7 @@ function parseSection(entry, at, config) {
975
1002
  ...(totals ? { totals } : {}),
976
1003
  ...(s.rowActions === true ? { rowActions: true } : {}),
977
1004
  ...(listActions ? { listActions } : {}),
1005
+ ...(typeof s.primary === 'string' ? { primary: s.primary.trim() } : {}),
978
1006
  };
979
1007
  }
980
1008
  /**
@@ -45,9 +45,12 @@ export declare const FIELD_COLUMNS: readonly FieldColumns[];
45
45
  */
46
46
  export interface ResolvedWorkflowStatus {
47
47
  field: string;
48
+ /** `outcome`: a way the record can end that is off the road (cancelled, returned): drawn apart from the steps, never
49
+ as the next of them. */
48
50
  steps: Array<{
49
51
  value: string;
50
52
  label: string;
53
+ outcome?: true;
51
54
  }>;
52
55
  /** The steps are an order: those before the current one draw as passed. The author's statement, not a history. */
53
56
  ordered?: true;
@@ -121,6 +124,8 @@ export interface PageFields {
121
124
  spans?: Record<string, string>;
122
125
  /** A headline's earlier value of its figure — a was-price — struck through beside it when it has one above the figure. */
123
126
  was?: string;
127
+ /** A summary's lines under its figures, by the field each stands under: what the figure counts. */
128
+ notes?: Record<string, string>;
124
129
  /** A headline's line of small print under its actions: what the figures assume. */
125
130
  note?: string;
126
131
  }
@@ -292,6 +297,8 @@ export interface PageList {
292
297
  totals?: string[];
293
298
  /** A ⋯ menu at the end of each row with the row's own actions and verbs, as its page offers them. */
294
299
  rowActions?: true;
300
+ /** The shown column a row is titled by where the list is read as records, in place of the record's name. */
301
+ primary?: string;
295
302
  /** Authored `create: false`: no Add, where the reader could otherwise add a row from the list. */
296
303
  noCreate?: true;
297
304
  /** Authored `actions`: the page record's own verbs, by id, drawn in this list's head and not in the record's. */
@@ -480,12 +480,27 @@ export function recordPageReads(names, page, base, plans, key, options) {
480
480
  view({ view: listed, offset: 0 });
481
481
  }
482
482
  }
483
- /* An inferred page's tabs say how many rows each holds, all of them in one read; a list alone says it in its head. */
484
- if (isInferredPage(page, names.app))
485
- for (const run of runs) {
486
- const body = relatedCountsBody(names.schema, run.map((index) => page.sections[index]), base, key);
483
+ /* An App page's tabs say how many rows each holds, all of them in one read; a list alone says it in its head. An
484
+ inferred page's lists are all runs, of one or more; a page an author wrote also stands lists alone outside any
485
+ strip (`listTabs: false`), and each of those asks for its own count, as the kit's list does (PageSections.tsx). */
486
+ if (names.app) {
487
+ const counted = (sections) => {
488
+ const body = relatedCountsBody(names.schema, sections, base, key);
487
489
  if (body)
488
490
  reads.push({ path: '/api/counts', body, kind: 'related' });
491
+ };
492
+ for (const run of runs)
493
+ counted(run.map((index) => page.sections[index]));
494
+ if (!isInferredPage(page, names.app)) {
495
+ const inRun = new Set(runs.flat());
496
+ for (const index of [...drawn].sort((a, b) => a - b)) {
497
+ const section = page.sections[index];
498
+ /* A list that hides or collapses while empty is drawn with its neighbours' line and says no count (PageEmptyRun.tsx). */
499
+ const leaves = Boolean(section.emptyMode) && (section.presentation !== 'card' || section.emptyMode === 'hide');
500
+ if (!inRun.has(index) && section.kind === 'list' && !section.hidden && !leaves)
501
+ counted([section]);
502
+ }
489
503
  }
504
+ }
490
505
  return { row: [...new Set(parts.flatMap((part) => part.columns))], parts, reads };
491
506
  }
@@ -13,10 +13,12 @@ export function parseRelatedCreate(raw, at) {
13
13
  if (typeof raw === 'string')
14
14
  raw = { label: raw };
15
15
  if (!isPlain(raw))
16
- throw new Error(`${at}: create must be an object.`);
16
+ throw new Error(`${at}: create must be an object: create: {} for the list's own New form, or { label, show, defaults, prefill } to say it.`);
17
17
  const value = raw;
18
- if (Object.keys(value).some((key) => !CREATE_KEYS.includes(key)))
19
- throw new Error(`${at}: create accepts label, show, defaults and prefill.`);
18
+ const unknown = Object.keys(value).filter((key) => !CREATE_KEYS.includes(key));
19
+ if (unknown.length)
20
+ throw new Error(`${at}: create accepts label, show, defaults and prefill; it was given ${unknown.map((key) => `"${key}"`).join(', ')}.` +
21
+ (unknown.includes('fields') ? ' The fields its form asks are "show".' : ''));
20
22
  if (typeof value.label !== 'string' || !value.label.trim())
21
23
  throw new Error(`${at}: create needs a label.`);
22
24
  if (value.show !== undefined && (!Array.isArray(value.show) || value.show.some((c) => typeof c !== 'string' || !c.trim())))
@@ -693,6 +693,8 @@ export interface ServedApp<View extends object = ServedDashboardView | ServedFor
693
693
  /** The tables whose records' capability links this reader may revoke from the record page (appPayload.ts). */
694
694
  revokesLinks?: string[];
695
695
  viewerRoles?: string[];
696
+ /** `'person'` where the reader is the App's own public (a visitor, or a `portal` role's holder): no office tools. */
697
+ viewerAudience?: 'person';
696
698
  grantedCommands?: string[];
697
699
  grantedActions?: Record<string, string[]>;
698
700
  assistant?: {
@@ -733,6 +735,9 @@ export declare function viewOrder(app: {
733
735
  export declare const ASSISTANT_ROOM = "assistant";
734
736
  /** The Directory's address, `/{app}/all-pages`: every list, page and New of a long menu, with a filter box. */
735
737
  export declare const DIRECTORY_ROOM = "all-pages";
738
+ /** The reader's settings, `/{app}/settings`: their profile and their preferences on one page. An App that already
739
+ * uses the word keeps it, as with the Directory, and the account menu still opens the room. */
740
+ export declare const SETTINGS_ROOM = "settings";
736
741
  /** How many places a menu holds before a Directory is offered beside it: past a dozen, scanning a menu is a search. */
737
742
  export declare const DIRECTORY_AT = 12;
738
743
  /** The places a served menu leads to — its views and its links, not the headings over them. */
@@ -49,6 +49,9 @@ export function viewOrder(app) {
49
49
  export const ASSISTANT_ROOM = 'assistant';
50
50
  /** The Directory's address, `/{app}/all-pages`: every list, page and New of a long menu, with a filter box. */
51
51
  export const DIRECTORY_ROOM = 'all-pages';
52
+ /** The reader's settings, `/{app}/settings`: their profile and their preferences on one page. An App that already
53
+ * uses the word keeps it, as with the Directory, and the account menu still opens the room. */
54
+ export const SETTINGS_ROOM = 'settings';
52
55
  /** How many places a menu holds before a Directory is offered beside it: past a dozen, scanning a menu is a search. */
53
56
  export const DIRECTORY_AT = 12;
54
57
  /** The places a served menu leads to — its views and its links, not the headings over them. */