@abide/abide 0.58.0 → 0.101.0

package/src/shared/menuItem.ts

@@ -0,0 +1,80 @@
+// 38.89 — THE DESKTOP APP'S MENU BAR IS THE ROUTE'S: a layout or a page exports `menu` from its
+// `<script module>`, and the window shows what the route it stands on exports. An item made by
+// `menuItem` is one a page answers; the rest are an address or a role, which need no page.
+
+/** What a menu item does natively, where an address or a page's own answer could not. 38.90. */
+export type MenuRole =
+    | 'about'
+    | 'hide'
+    | 'hideOthers'
+    | 'showAll'
+    | 'quit'
+    | 'connect'
+    | 'disconnect'
+    | 'close'
+    | 'undo'
+    | 'redo'
+    | 'cut'
+    | 'copy'
+    | 'paste'
+    | 'selectAll'
+    | 'reload'
+    | 'fullscreen'
+    | 'minimize'
+    | 'zoom'
+    | 'front'
+
+/** One entry in the desktop app's menu bar, or in a menu under it. */
+export type MenuItem =
+    | 'separator'
+    | {
+          label: string
+          /** The shortcut, modifiers first: `cmd+shift+k`. */
+          key?: string
+          role?: MenuRole
+          /** An address in the app, navigated to when the item is picked. */
+          href?: string
+          items?: MenuItem[]
+      }
+
+/** An item a page answers: each function `on` filed runs when it is picked. 38.92. */
+export class MenuEntry {
+    label: string
+    key: string | undefined
+    href: string | undefined
+    private readonly answers = new Set<() => unknown>()
+
+    constructor(item: { label: string; key?: string; href?: string }) {
+        this.label = item.label
+        this.key = item.key
+        this.href = item.href
+    }
+
+    /** Files `answer` to run each time the item is picked; returns what unfiles it. */
+    on(answer: () => unknown): () => void {
+        this.answers.add(answer)
+        return () => {
+            this.answers.delete(answer)
+        }
+    }
+
+    /** Runs every answer filed, a throw from one reported without stopping the rest. */
+    pick(): void {
+        for (const answer of [...this.answers])
+            try {
+                const answered = answer()
+                if (answered instanceof Promise) answered.catch(reportError)
+            } catch (thrown) {
+                reportError(thrown)
+            }
+    }
+}
+
+/** A menu item a page answers with `on`. */
+export function menuItem(item: {
+    label: string
+    key?: string
+    href?: string
+}): MenuEntry {
+    return new MenuEntry(item)
+}

package/src/shared/mount.ts

@@ -0,0 +1,45 @@
+// 16.10, 36.11 — WHERE THE APP IS MOUNTED, read at run time and never baked into a build: a browser
+// reads it from the `<meta>` the document carries, and a server from `config().APP_URL`, which fills
+// the slot. `''` is the root.
+//
+// EVERY ABSOLUTE ADDRESS abide produces goes through `mounted`, and every one it matches through
+// `unmounted`, so an app that has never thought about a sub-path already serves under one.
+
+import { MOUNT_META } from './MOUNT_META.ts'
+
+/** The app's mount, `''` for the root: the document's `<meta>` until a server fills the slot. */
+export const MOUNT: { current: () => string } = { current: documentMount }
+
+// READ ONCE PER DOCUMENT. A document abide did not render carries no `<meta>`, and a selector that
+// finds nothing has walked the whole document to say so — `url()` in a `{#for}` row paid that per
+// row, 10.3 ms against 1.4 ms for a 1000-row build in chromium. The server writes the tag ahead of
+// the script, so the first read already sees the answer every later one would.
+let documentMountRead: string | undefined
+
+function documentMount(): string {
+    if (typeof document === 'undefined') return ''
+    documentMountRead ??=
+        document
+            .querySelector(`meta[name="${MOUNT_META}"]`)
+            ?.getAttribute('content') ?? ''
+    return documentMountRead
+}
+
+/** An address below the app's root, as the address it is served at. */
+export function mounted(address: string): string {
+    const mount = MOUNT.current()
+    return mount === '' ? address : `${mount}${address}`
+}
+
+/**
+ * A served pathname, as the address below the app's root — or `undefined` where it is not under
+ * the mount at all.
+ */
+export function unmounted(pathname: string): string | undefined {
+    const mount = MOUNT.current()
+    if (mount === '') return pathname
+    if (pathname === mount) return '/'
+    return pathname.startsWith(`${mount}/`)
+        ? pathname.slice(mount.length)
+        : undefined
+}

package/src/shared/muxFrames.ts

@@ -0,0 +1,35 @@
+// 18.1 — THE MUX'S FRAMES, as JSON over the one web socket a page follows its `GET`s on: a browser
+// subscribes and unsubscribes, and is sent each followed value's changes — the same `value` and
+// `patch` an event stream writes as events (18.20), multiplexed by `id`.
+
+import type { Problem } from './Failed.ts'
+import type { PatchOp } from './reactive/PATCH_SINKS.ts'
+
+/**
+ * What a browser sends over the mux: a subscription, naming the version it holds (18.9), or its end.
+ *
+ * 18.3 — a subscription names a handler's address and the args its `GET` is answered with.
+ */
+export type BrowserFrame = {
+    op: 'sub' | 'unsub'
+    id: number
+    address?: string
+    args?: unknown
+    version?: number | undefined
+}
+
+/**
+ * What a browser is sent over the mux.
+ *
+ * A refusal as Problem Details (15.21), a value where it moved (18.6), what patches wrote over
+ * `base` (18.11), and a handler's trigger per match (7.10, 7.18, 13.15).
+ */
+export type ServerFrame = {
+    op: 'error' | 'value' | 'patch' | 'invalidate' | 'refresh'
+    id: number
+    version?: number
+    base?: number
+    ops?: PatchOp[]
+    value?: unknown
+    error?: Problem
+}

package/src/shared/navigate.ts

@@ -0,0 +1,26 @@
+import { CURRENT_ROUTER, type NavigateOptions } from './CURRENT_ROUTER.ts'
+
+/**
+ * Navigates the document's router to a URL without reloading; rejects where there is no router.
+ *
+ * 30.7 — NAVIGATES, AND MUST NOT RELOAD THE DOCUMENT. The whole of that clause lives in the client
+ * router; this is the app-facing name, and it sits on the isomorphic seam because that is the
+ * specifier an app imports it through, with the same intent on both sides.
+ *
+ * ON A SERVER THERE IS NO DOCUMENT NOT TO RELOAD, so there is nothing this can mean yet and it
+ * refuses rather than resolving quietly — a `navigate` that no-ops during a render is a page that
+ * renders the wrong thing and says nothing.
+ */
+export function navigate(
+    url: URL | string = '',
+    options: NavigateOptions = {},
+): Promise<void> {
+    const router = CURRENT_ROUTER.current
+    if (router === null)
+        return Promise.reject(
+            new Error(
+                'navigate() was called with no router in this document. A browser gets one from the routes the build emitted; a server render has no document to navigate (RULEBOOK 30.7).',
+            ),
+        )
+    return router.go(url, options)
+}

package/src/shared/note.ts

@@ -0,0 +1,24 @@
+import { putOwn } from './putOwn.ts'
+
+/**
+ * Appends one issue under its path in an issues record.
+ *
+ * ONE ISSUE, APPENDED UNDER ITS PATH, into an ORDINARY record — so what is handed out is the
+ * record that was filled, and `String(report)` prints `[object Object]` rather than throwing
+ * `No default value` out of a slot writer (`escapeText`, `escapeless`) on a null prototype.
+ *
+ * A path is built from the INPUT's own keys, so both halves go through the own-member door. The
+ * READ: `found['constructor']` answers `Object` rather than `undefined`, and the append threw
+ * `standing.push is not a function` out of the validator for any of the twelve names
+ * `Object.prototype` carries — so it is asked with `Object.hasOwn`. The WRITE: see `putOwn` —
+ * `found['__proto__'] = [...]` recorded nothing, the report came back empty, and
+ * `{"__proto__": …}` passed `additionalProperties: false` as valid.
+ */
+export function note(
+    found: Record<string, string[]>,
+    path: string,
+    said: string,
+): void {
+    if (Object.hasOwn(found, path)) (found[path] as string[]).push(said)
+    else putOwn(found, path, [said])
+}

package/src/shared/numberFromText.ts

@@ -0,0 +1,10 @@
+/**
+ * The number a text reads as, or `undefined` where it reads as none.
+ *
+ * Blank text is not zero, though `Number('')` says it is.
+ */
+export function numberFromText(text: string): number | undefined {
+    if (text.trim() === '') return undefined
+    const number = Number(text)
+    return Number.isNaN(number) ? undefined : number
+}

package/src/shared/online.ts

@@ -0,0 +1,19 @@
+// 23.7, 23.8 — WHETHER THE CALLER CAN REACH THE APP. A browser answers with `navigator.onLine` and
+// its two events; a server is the app, so it can always reach it.
+//
+// `window` AND NOT `navigator` tells the two apart: bun defines a `navigator` of its own, with no
+// `onLine` on it.
+//
+// PURE, SO AN APP THAT NEVER NAMES `online` DOES NOT SHIP IT: the listeners are a side effect at
+// load, and a top-level side effect keeps the module in the shared chunk whether anything reads it.
+
+import { ambient } from './reactive/index.ts'
+
+/** Whether the caller can reach the app, as a `Reactive<boolean>`. */
+export const online = /* @__PURE__ */ (() => {
+    if (typeof window === 'undefined') return ambient<boolean>(true)
+    const value = ambient<boolean>(navigator.onLine)
+    window.addEventListener('online', () => value.set(true))
+    window.addEventListener('offline', () => value.set(false))
+    return value
+})()

package/src/shared/paint.ts

@@ -0,0 +1,4 @@
+/** `text` in the ANSI style `code` names when `color` allows it — `useColor()` decides that. */
+export function paint(color: boolean, code: string, text: string): string {
+    return color ? `\x1b[${code}m${text}\x1b[0m` : text
+}

package/src/shared/principal.ts

@@ -0,0 +1,145 @@
+// SECTION 26 — WHO IS CALLING, on both sides. Each member is its own `Reactive` (26.1) and the identity
+// members read ONE document, resolved once per request (26.2, 26.14): the server resolves it from the
+// sealed cookie (`#server/principal.ts`, which `installServer` fills `PRINCIPAL` with), and a browser loads it from
+// `/__abide/principal` — the handler abide mounts there, seeded as any handler is (26.17).
+//
+// THE MEMBERS ARE BUILT ON FIRST ACCESS. A body runs when its value is built, so members built at
+// import would load the document on every page whether anything read it or not.
+
+import { PRINCIPAL_ADDRESS } from './ADDRESSES.ts'
+import { type Failed, isFailed } from './Failed.ts'
+import { onPrincipalRotated } from './principalRotated.ts'
+import { ambient } from './reactive/index.ts'
+import type { Reactive } from './reactive/Reactive.ts'
+import { seededDocument } from './seededDocument.ts'
+
+/**
+ * The principal document: whether the caller is authenticated, and its claims.
+ *
+ * AN INTERFACE, as `Config` (27.12) and `Health` (25.4) are, so an app declares what its `onPrincipal` resolves to by merging into it, and
+ * `principal.resolved()` reads those fields typed. A claim is absent for a caller who is not signed in,
+ * so one declared without `?` is a promise the app is making about every reader.
+ */
+export interface Principal {
+    [claim: string]: unknown
+    authenticated: boolean
+    expiresAt?: string | undefined
+    error?: Failed<string, unknown> | undefined
+}
+
+/** A browser's defaults for the slots `principal` reads through. */
+export const BROWSER_PRINCIPAL: {
+    document: () => Principal | Promise<Principal>
+    caller: () => string
+    set: (claims: Record<string, unknown>) => Promise<void>
+    clear: () => void
+} = {
+    // 26.17 — seeded as any handler's answer is. 26.23 — a refused one is the unauthenticated
+    // document carrying the refusal, as a resolver that failed is on the server (26.3), so
+    // `principal` is never without a document (26.10). 41.27 — settled at once where the seed is.
+    document: () => {
+        const seeded = seededDocument<Principal>(PRINCIPAL_ADDRESS)
+        return seeded instanceof Promise
+            ? seeded.then(documentOf)
+            : documentOf(seeded)
+    },
+    // 26.22.
+    caller: () => {
+        throw new Error(
+            "abide: principal.caller was read in a browser. Which browser is calling is the server's to know. RULEBOOK 26.22.",
+        )
+    },
+    set: () =>
+        Promise.reject(
+            new Error(
+                'abide: principal.set runs where the sealed cookie is written — call it in a handler.',
+            ),
+        ),
+    clear: () => {
+        throw new Error(
+            'abide: principal.clear runs where the sealed cookie is written — call it in a handler.',
+        )
+    },
+}
+
+/**
+ * The slots `principal` reads through: a browser's defaults, which the server replaces
+ * (`#server/principal.ts`).
+ */
+export const PRINCIPAL: typeof BROWSER_PRINCIPAL = { ...BROWSER_PRINCIPAL }
+
+function documentOf(seeded: Principal | Failed<string, unknown>): Principal {
+    return isFailed(seeded)
+        ? { authenticated: false, expiresAt: undefined, error: seeded }
+        : seeded
+}
+
+type Members = {
+    document: Reactive<Principal>
+    authenticated: Reactive<boolean>
+    expiresAt: Reactive<string | undefined>
+    error: Reactive<Failed<string, unknown> | undefined>
+    resolved: Reactive<Principal>
+    caller: Reactive<string>
+}
+
+let members: Members | undefined
+
+/** The principal's members, each its own `Reactive`, built on first access. */
+export function principalMembers(): Members {
+    if (members !== undefined) return members
+    const document = ambient(() =>
+        PRINCIPAL.document(),
+    ) as unknown as Reactive<Principal>
+    members = {
+        document,
+        authenticated: ambient(
+            () => document().authenticated,
+        ) as unknown as Reactive<boolean>,
+        expiresAt: ambient(() => document().expiresAt) as unknown as Reactive<
+            string | undefined
+        >,
+        error: ambient(() => document().error) as unknown as Reactive<
+            Failed<string, unknown> | undefined
+        >,
+        resolved: ambient(() => document()) as unknown as Reactive<Principal>,
+        // 26.5 — NEEDS NO RESOLUTION: read off its own cookie, apart from the document.
+        caller: ambient(() =>
+            PRINCIPAL.caller(),
+        ) as unknown as Reactive<string>,
+    }
+    // A SIGN-IN OR SIGN-OUT A HANDLER ANSWERED reloads the document, and every member reads
+    // through it. A REFRESH, not an invalidate: 7.4 keeps the document a click handler reads
+    // served until the new one lands. 26.24 — another tab's is heard too (`principalRotated.ts`);
+    // a browser's alone: a server, which replaced these slots, answers no `abide-principal` to itself.
+    onPrincipalRotated(
+        () => document.refresh(),
+        PRINCIPAL.document === BROWSER_PRINCIPAL.document,
+    )
+    return members
+}
+
+/** Who is calling (26.1): each member a `Reactive`, and `set` / `clear` for the sealed cookie. */
+export const principal = {
+    get authenticated(): Reactive<boolean> {
+        return principalMembers().authenticated
+    },
+    get expiresAt(): Reactive<string | undefined> {
+        return principalMembers().expiresAt
+    },
+    get error(): Reactive<Failed<string, unknown> | undefined> {
+        return principalMembers().error
+    },
+    get resolved(): Reactive<Principal> {
+        return principalMembers().resolved
+    },
+    get caller(): Reactive<string> {
+        return principalMembers().caller
+    },
+    set(claims: Record<string, unknown>): Promise<void> {
+        return PRINCIPAL.set(claims)
+    },
+    clear(): void {
+        PRINCIPAL.clear()
+    },
+}

package/src/shared/principalRotated.ts

@@ -0,0 +1,47 @@
+// 26.24 — A SIGN-IN OR SIGN-OUT A HANDLER ANSWERED is heard by everything in this tab that holds
+// something read by the caller's cookie, and every other tab of this browser is told over a
+// `BroadcastChannel`, since the cookie each reads by is the same one. Here rather than in
+// `principal.ts` because the tab that made the call may never have read `principal` — the sign-in
+// page whose form calls the handler — and that tab still has to tell the rest.
+
+import { PRINCIPAL_HEADER } from './PRINCIPAL_HEADER.ts'
+
+const LISTENERS: (() => void)[] = []
+
+let tabs: BroadcastChannel | undefined
+
+function rotated(): void {
+    for (const listener of LISTENERS) listener()
+}
+
+/**
+ * The one channel this tab is told and tells on. One instance, because a `BroadcastChannel`
+ * delivers to every OTHER instance of its name — a second one in this tab would hear its own
+ * sign-in.
+ */
+function channel(): BroadcastChannel | undefined {
+    if (tabs === undefined && typeof BroadcastChannel === 'function') {
+        tabs = new BroadcastChannel('abide:principal')
+        tabs.onmessage = rotated
+    }
+    return tabs
+}
+
+/**
+ * Runs `listener` on every sign-in or sign-out this tab's calls answer, and — where `tabs` — on
+ * every one another tab's do.
+ *
+ * Nothing listens until something is read by the cookie, so a page that reads nothing of it opens
+ * no channel.
+ */
+export function onPrincipalRotated(listener: () => void, tabs: boolean): void {
+    LISTENERS.push(listener)
+    if (tabs) channel()
+}
+
+/** Tells this tab and the others, where `answer` says the cookie changed. */
+export function principalRotated(answer: Response): void {
+    if (!answer.headers.has(PRINCIPAL_HEADER)) return
+    rotated()
+    channel()?.postMessage('rotated')
+}

package/src/shared/propCell.ts

@@ -0,0 +1,99 @@
+// 33.6, 33.7 — A PROP THE CHILD WRITES, as one cell whichever way the caller passed it: a
+// `reactive` over the caller's accessor. Where the caller bound it (32.6) the accessor hands back
+// the caller's `Reactive`, which the cell adopts (11.12) and every write reaches (11.59); passed
+// as a value, a write stands until the caller's expression changes (11.8). The child never learns
+// which, and that is 33.8.
+//
+// ONLY A WRITTEN PROP PAYS FOR ONE. A prop the child only reads stays the caller's accessor, so a
+// row component reading ten props builds no `reactive` at all.
+
+import { CHILDREN } from './CHILDREN.ts'
+import { reactive } from './reactive/index.ts'
+import type { Reactive } from './reactive/Reactive.ts'
+
+// `true` asks a bound accessor for the `Reactive` it binds rather than its value (`boundProp`);
+// every other accessor takes no argument and hands back its value either way.
+type Accessor = (hold?: true) => unknown
+
+/** A prop the child writes, as a getter for one `reactive` cell over the caller's accessor. */
+export function propCell(read: Accessor): () => Reactive<unknown> {
+    const cell = reactive(() => read(true))
+    return () => cell
+}
+
+/**
+ * 33.20 — a defaulted prop's accessor: the caller's, answering the default wherever it reads
+ * `undefined`, and the default alone where the caller passed nothing. A bound accessor asked to
+ * `hold` hands back the caller's `Reactive`, never `undefined`, so a bind still reaches the caller.
+ */
+export function propOr(
+    read: Accessor | undefined,
+    fallback: Accessor,
+): Accessor {
+    if (read === undefined) return fallback
+    return (hold) => {
+        const value = read(hold)
+        return value === undefined ? fallback(hold) : value
+    }
+}
+
+/** The record without `keys`, so the pattern's default always stands for them (33.20). */
+export function withoutKeys(
+    record: Record<string, Accessor>,
+    keys: readonly string[],
+): Record<string, Accessor> {
+    // A copy that skips the keys rather than one that deletes them — `delete` leaves a slow shape.
+    const rest: Record<string, Accessor> = {}
+    for (const key in record)
+        if (!keys.includes(key)) rest[key] = record[key] as Accessor
+    return rest
+}
+
+// One view per rest record: a component hands its rest on at every read of a prop spread from it.
+const REST_VALUES = new WeakMap<
+    Record<string, Accessor>,
+    Record<string, unknown>
+>()
+
+/**
+ * 33.22 — a `props` rest element handed on whole: each key a getter calling its accessor, so
+ * whatever enumerates it — a `{...rest}`, a function it is passed to — reads values, live.
+ *
+ * 33.25 — `children` LEFT OUT. Every caller's record carries it (33.16), and spread onto an element
+ * it rendered the caller's content a second time, as an attribute, outside the slot it is for.
+ */
+export function restValues(
+    record: Record<string, Accessor>,
+): Record<string, unknown> {
+    let values = REST_VALUES.get(record)
+    if (values === undefined) {
+        values = {}
+        for (const key in record) {
+            if (key === CHILDREN) continue
+            Object.defineProperty(values, key, {
+                enumerable: true,
+                get: () => (record[key] as Accessor)(),
+            })
+        }
+        REST_VALUES.set(record, values)
+    }
+    return values
+}
+
+/**
+ * The record the caller passed, with each written key the child's cell rather than the caller's
+ * accessor.
+ *
+ * A key the caller did not pass stays absent, so the pattern's default still applies.
+ */
+export function propCells(
+    record: Record<string, Accessor>,
+    written: readonly string[],
+): Record<string, Accessor> {
+    const cells = { ...record }
+    for (const key of written) {
+        const read = record[key]
+        if (read !== undefined) cells[key] = propCell(read)
+    }
+    return cells
+}

package/src/shared/props.ts

@@ -0,0 +1,24 @@
+/**
+ * A component's props, as the child declares them. Compiled away inside a `.abide` file.
+ *
+ * Section 33. NOTHING HERE RUNS IN A COMPILED PAGE. `props<Props>()` is LOWERED: the compiler
+ * replaces the call with the record of accessors the caller passed, and every name the pattern
+ * binds becomes a read of its accessor (33.4, 33.5, 33.9). The export exists because the import an
+ * author writes has to resolve — 19.11 has valid TypeScript go on compiling — and because the TYPE
+ * is what makes a prop's shape the one the child declared.
+ *
+ * THE RETURN TYPE IS THE PLAIN SHAPE, not one accessor per key, and that is the point of the
+ * lowering rather than a gap in it: `amount.toFixed(2)` is what an author writes and what the
+ * checker sees, and the accessor is the compiler's business. A prop is declared as its value's
+ * type, never as a `Reactive`, and one the child writes is lowered to a cell (33.6, 33.7).
+ */
+export function props<Props = Record<string, unknown>>(): {
+    [Key in keyof Props]: Props[Key]
+} {
+    // Reached only from a `.abide` nothing compiled, or from a `.ts` that imported it. Either way
+    // there is no instance to read, and answering an empty record would make a missing prop read
+    // `undefined` instead of saying so.
+    throw new Error(
+        'abide: props() is compiled away inside a .abide file, and there is no component instance to read outside one. RULEBOOK 33.1.',
+    )
+}

package/src/shared/putOwn.ts

@@ -0,0 +1,24 @@
+/**
+ * Assigns `target[key] = value` as an own member, `__proto__` included.
+ *
+ * `__proto__` IS A SETTER ON `Object.prototype`, not a member, so `target[key] = value` for that
+ * key re-parents the target and writes nothing. Every record here keyed by something the INPUT
+ * named — a path step, a wire field, a refusal's path — is one runtime string away from it: a
+ * write lost entirely, or a `state.pwned` that reads back while `JSON.stringify(state)` has never
+ * heard of it. `defineProperty` makes the own member the assignment was meant to; a spread and
+ * `JSON.stringify` already treat an own `__proto__` as a member, so only the assignment is told.
+ */
+export function putOwn(
+    target: Record<string | number, unknown>,
+    key: string | number,
+    value: unknown,
+): void {
+    if (key === '__proto__')
+        Object.defineProperty(target, key, {
+            value,
+            writable: true,
+            enumerable: true,
+            configurable: true,
+        })
+    else target[key] = value
+}

package/src/shared/queryText.ts

@@ -0,0 +1,18 @@
+/**
+ * A record of members as a query string.
+ *
+ * ONE QUERY-STRING RULE for `rpcRequest`'s args (16.18) and `url`'s `Query` (30.6): a member left
+ * `undefined` is omitted, a list is its member repeated, and anything else is its text — `null`
+ * included, which 19.7 reads back as `null` where the schema declares it. An empty list writes
+ * nothing here; `rpcRequest` spells it as a bare name.
+ */
+export function queryText(members: Record<string, unknown>): string {
+    const query = new URLSearchParams()
+    for (const [name, value] of Object.entries(members)) {
+        if (value === undefined) continue
+        if (Array.isArray(value))
+            for (const each of value) query.append(name, String(each))
+        else query.append(name, String(value))
+    }
+    return query.toString()
+}

package/src/shared/reactive/CELL.ts

@@ -0,0 +1,8 @@
+/**
+ * Where a `Reactive` callable keeps the record its state lives on.
+ *
+ * A symbol rather than a named field so the record stays off the value's app-visible surface, and
+ * a leaf because `watch.ts` has to reach through it and cannot import `Reactive.ts`, which
+ * imports it.
+ */
+export const CELL: unique symbol = Symbol('abide.cell')