@abide/abide 0.123.2 → 0.124.0

package/src/server/argsFor.ts

@@ -1,39 +0,0 @@
-// WHAT A CALL'S ARGS ARE BEFORE ITS HANDLER SEES THEM, for every lane that lets a call to a handler in
-// off the wire: over http (16.2) and a `GET` followed over the socket mux (18.3). Each lane reads the
-// args off its own transport and answers a refusal in its own form.
-
-import { DERIVED_ARGS } from '#shared/DERIVED_ARGS.ts'
-import { normalized } from '#shared/reactive/argsContract.ts'
-import { validationError } from '#shared/refuse.ts'
-
-import type { Mounted } from './answerRpc.ts'
-import { coerceArgs } from './coerceArgs.ts'
-
-/**
- * The args a call over the wire is answered with, out of the args it sent: the text a URL or a form
- * carried coerced where `query` says the args are text, the handler's parameter defaults laid in, and
- * the result held to the handler's annotation. Throws the refusal where it is not held.
- *
- * 19.7 — the text as the types the handler's `args` declares. 11.27 — then the defaults, ahead of
- * every key taken after it: the seed a render filed and the `global` entry standing were both filed
- * under them (11.29). 19.9 — THE WIRE HELD TO THE ANNOTATION, where no `args` schema is declared to
- * hold it — the check the handler carries (`derivedArgs`), which its in-process call makes too (15.8).
- */
-export function argsFor(
-    found: Pick<Mounted, 'handler' | 'argsDocument'>,
-    sent: unknown,
-    query: string | undefined,
-): unknown {
-    const coerced =
-        query === undefined
-            ? sent
-            : coerceArgs(
-                  sent as Record<string, string | string[]> | undefined,
-                  found.argsDocument,
-                  query,
-              )
-    const args = normalized(found.handler, coerced)
-    const issues = found.handler[DERIVED_ARGS]?.(args) ?? null
-    if (issues !== null) throw validationError(issues)
-    return args
-}

package/src/server/buildDirectory.ts

@@ -1,10 +0,0 @@
-import { dirname } from 'node:path' // bun exposes no path helpers of its own
-
-/**
- * Where an app's build goes: `.abide` in the directory above its source root.
- *
- * BESIDE THE APP RATHER THAN BESIDE THE SHELL: an app's build belongs to the app.
- */
-export function buildDirectory(root: string): string {
-    return `${dirname(root)}/.abide`
-}

package/src/server/coerceArgs.ts

@@ -1,109 +0,0 @@
-// 19.7 — A `GET` OR `DELETE`'s TEXT ARGS, COERCED FROM THE TYPE THE `JsonSchema` DECLARES, before
-// anything validates them. A URL carries text, so `?id=42` is `'42'` until the schema says the member
-// is a number. Coercion is the pipeline's and not the schema's (19.6): the schema is handed what this
-// made of the text, and refuses what would not coerce.
-//
-// Read off a `Schema` built by `jsonSchema`, where the document is exposed; a schema with no document
-// has declared no types, and its args stay the text they arrived as.
-
-import { numberFromText } from '#shared/numberFromText.ts'
-import { bareName } from '#shared/queryText.ts'
-import { type Gated, gateOf } from '#shared/reactive/argsContract.ts'
-
-export type Document = {
-    type?: string | string[]
-    properties?: Record<string, Document>
-    items?: Document
-}
-
-/** The document a handler's `args` schema declares, or `undefined`. */
-export function argsDocumentOf(handler: Gated<unknown>): Document | undefined {
-    const gate = gateOf(handler) as
-        { '~standard'?: { jsonSchema?: { input?: () => unknown } } } | undefined
-    const document = gate?.['~standard']?.jsonSchema?.input?.()
-    return document !== null && typeof document === 'object'
-        ? (document as Document)
-        : undefined
-}
-
-/**
- * Name and value pairs as args: a name given more than once is a list, one given once its text.
- *
- * 16.18 — a query's and a form's members, and 38.61 — `abide call`'s `name=value` words, alike.
- */
-export function collapsed(
-    entries: URLSearchParams | FormData,
-): Record<string, string | string[]> {
-    const args: Record<string, string | string[]> = {}
-    for (const name of new Set(entries.keys())) {
-        const values = entries.getAll(name) as string[]
-        args[name] = values.length === 1 ? (values[0] as string) : values
-    }
-    return args
-}
-
-/**
- * The text args, each member coerced to the type `document` declares.
- *
- * `query` is the raw `?…` the args were read from: `URLSearchParams` reads `rpcRequest`'s empty
- * list, a bare name, as `''` — the same as `tags=`, the list `['']` — so a declared array tells the
- * two apart there. A text member keeps the `''`.
- */
-export function coerceArgs(
-    args: Record<string, string | string[]> | undefined,
-    document: Document | undefined,
-    query: string,
-): unknown {
-    if (args === undefined || document?.properties === undefined) return args
-    const coerced: Record<string, unknown> = {}
-    for (const [name, text] of Object.entries(args)) {
-        const member = document.properties[name]
-        if (member === undefined) coerced[name] = text
-        else if (
-            text === '' &&
-            typesOf(member).includes('array') &&
-            `&${query.slice(1)}&`.includes(`&${bareName(name)}&`)
-        )
-            coerced[name] = []
-        else coerced[name] = coerceMember(text, member)
-    }
-    return coerced
-}
-
-function typesOf(member: Document): string[] {
-    if (member.type === undefined) return []
-    return Array.isArray(member.type) ? member.type : [member.type]
-}
-
-function coerceMember(text: string | string[], member: Document): unknown {
-    const types = typesOf(member)
-    // A list is its member repeated, and one given once still answers a declared array.
-    if (types.includes('array')) {
-        const items = Array.isArray(text) ? text : [text]
-        const item = member.items
-        return item === undefined
-            ? items
-            : items.map((each) => coerceScalar(each, item))
-    }
-    if (Array.isArray(text)) return text
-    return coerceScalar(text, member)
-}
-
-/**
- * The text as the first declared type it reads as, in the order the schema lists them.
- *
- * Text that reads as none stays text, for the schema to refuse.
- */
-function coerceScalar(text: string, member: Document): unknown {
-    for (const type of typesOf(member)) {
-        if (type === 'string') return text
-        if (type === 'number' || type === 'integer') {
-            const number = numberFromText(text)
-            if (number !== undefined) return number
-        }
-        if (type === 'boolean' && (text === 'true' || text === 'false'))
-            return text === 'true'
-        if (type === 'null' && text === 'null') return null
-    }
-    return text
-}

package/src/server/derivedArgs.ts

@@ -1,26 +0,0 @@
-import { DERIVED_ARGS } from '#shared/DERIVED_ARGS.ts'
-import type { JsonValue } from '#shared/JsonValue.ts'
-import type { Gated } from '#shared/reactive/argsContract.ts'
-import type { HeldToAnnotation } from '#shared/rpc.ts'
-import { validateJson } from '#shared/validateJson.ts'
-
-import { argsDocumentOf } from './coerceArgs.ts'
-
-/**
- * Holds `handler`'s args to `schema`, the one the build derived off its annotation, for every call
- * of it from now on: in process and over the wire (15.8, 19.9).
- *
- * What the module a handler is loaded through calls once its handler is built — a handler file's
- * face and a `<script server>`'s module — so the schema is there wherever the handler can be
- * called, whether or not an app mounted it. Not where its `args` gate publishes a document of its
- * own, which holds the args itself (19.7). Args that did not come are held as an empty record: a
- * schema is only derived where the handler's args are a required record, so a required member
- * missing is refused, not read off nothing.
- */
-export function derivedArgs(
-    handler: HeldToAnnotation & Gated<unknown>,
-    schema: JsonValue,
-): void {
-    if (argsDocumentOf(handler) !== undefined) return
-    handler[DERIVED_ARGS] = (args) => validateJson(schema, args ?? {})
-}

package/src/server/runBuild.ts

@@ -1,24 +0,0 @@
-// The CLI, spawned rather than imported: the compiler is not reachable from the server seam.
-const ABIDE_BIN = Bun.fileURLToPath(
-    new URL('../../bin/abide.ts', import.meta.url),
-)
-
-/**
- * `abide build` of the app under `root` into `out`, run as the CLI.
- *
- * SPAWNED RATHER THAN IMPORTED: the compiler is not reachable from the server seam.
- */
-export async function runBuild(root: string, out: string): Promise<void> {
-    const child = Bun.spawn(
-        [process.execPath, ABIDE_BIN, 'build', '--root', root, '--out', out],
-        { stdout: 'ignore', stderr: 'pipe' },
-    )
-    const [exitCode, said] = await Promise.all([
-        child.exited,
-        new Response(child.stderr).text(),
-    ])
-    if (exitCode !== 0)
-        throw new Error(
-            `abide: could not build the app under ${root}.\n${said}`,
-        )
-}

package/src/server/serveBuild.ts

@@ -1,144 +0,0 @@
-// 38.6 and 38.10 — `abide start` and a compiled app: the built app, over http. The request path is
-// `answerRequest`'s, shared with `abide dev`; what this module is, is the SUPPLIER — where each part
-// comes from when the parts are what `abide build` produced.
-//
-// THE ROUTE TABLE IS THE BUILD'S, not this module's. `abide build` walks the tree once and writes
-// what it found, so the addresses the server answers and the addresses the client router knows
-// are two readings of one walk rather than two walks that have to agree (30.8).
-
-import {
-    type Compilation,
-    serveCompilation,
-    servedTable,
-} from './abideModules.ts'
-import {
-    type AppSources,
-    appSources,
-    type SourceParts,
-} from './answerRequest.ts'
-import {
-    CLIENT_DIRECTORY,
-    COMPILATION,
-    ENCODING_SUFFIX,
-    MANIFEST,
-    PUBLIC_DIRECTORY,
-} from './CLIENT_BUILD.ts'
-import { bundleServer, type ServedFile } from './clientBundle.ts'
-import { settingOn } from './config.ts'
-import type { Manifest } from './manifestOf.ts'
-import { namesUnder } from './namesUnder.ts'
-import { ENCODINGS } from './negotiateEncoding.ts'
-import { runBuild } from './runBuild.ts'
-
-/**
- * What `abide build` produced, as the parts an `App` is booted over.
- *
- * Read off disk by `abide start` (`loadBuild`), and out of the executable itself by a compiled app
- * (38.10). ONE SHAPE, so the two are answered by one path and differ only in where a byte is read
- * from — a file is a PATH in both, and `Bun.file` reads the executable's own the same way it reads
- * the disk's.
- */
-export type BuildParts = Omit<SourceParts, 'client' | 'explained'> & {
-    manifest: Manifest
-    /** Every file under `client/`, the precompressed copies among them, by name to its path. */
-    client: Map<string, string>
-}
-
-/**
- * Serves the compilation `abide build` kept in `out` to this process's imports; `false` where there
- * is none, because the app under `root` holds nothing to build.
- *
- * 38.6 — what `abide start` boots: no compiler is loaded, and every `.abide` the app imports is
- * answered out of what the build compiled. 38.100 — AN APP NOBODY BUILT IS BUILT, by `build`, rather
- * than refused, so every caller boots the same way whether or not a build came first. The CLI passes
- * its own build, in-process; anything else spawns it.
- */
-export async function serveBuild(
-    root: string,
-    out: string,
-    build: (root: string, out: string) => Promise<unknown> = runBuild,
-): Promise<boolean> {
-    const path = `${out}/${COMPILATION}`
-    if (!(await Bun.file(path).exists())) {
-        await build(root, out)
-        // A FRESH HANDLE: one taken before the build wrote the file reads it as empty.
-        if (!(await Bun.file(path).exists())) return false
-    }
-    serveCompilation(root, (await Bun.file(path).json()) as Compilation)
-    return true
-}
-
-/**
- * What `abide build` left on disk, as the sources an `App` is booted over — its compilation served
- * already (`serveBuild`).
- */
-export async function loadBuild(options: {
-    /**
-     * The app's source root — the directory its pages sit under.
-     */
-    root: string
-    /** Where `abide build` put its output. */
-    out: string
-}): Promise<AppSources> {
-    // THE BOOT READS OVERLAP: the tables and the manifest are independent of each other. The
-    // manifest names the stylesheet only where the bundler collected one, so an app that imports
-    // none links none.
-    const [table, manifest] = await Promise.all([
-        servedTable(options.root),
-        Bun.file(`${options.out}/${MANIFEST}`).json() as Promise<Manifest>,
-    ])
-    return builtSources({
-        table,
-        handlers: table.handlers,
-        manifest,
-        client: pathsUnder(`${options.out}/${CLIENT_DIRECTORY}`),
-        published: pathsUnder(`${options.out}/${PUBLIC_DIRECTORY}`),
-    })
-}
-
-/** Every file under `directory`, by the name below it to its path. */
-export function pathsUnder(directory: string): Map<string, string> {
-    const paths = new Map<string, string>()
-    for (const name of namesUnder(directory))
-        paths.set(name, `${directory}/${name}`)
-    return paths
-}
-
-/** The sources an `App` is booted over, out of the parts `abide build` produced. */
-export function builtSources(parts: BuildParts): Promise<AppSources> {
-    // THE PRECOMPRESSED COPIES ARE NOT ADDRESSES OF THEIR OWN. They are the same file in another
-    // encoding (38.5), so they are found under the name they encode and served as that name.
-    const suffixes = Object.values(ENCODING_SUFFIX) as string[]
-    const files = new Map<string, ServedFile>()
-    for (const [name, path] of parts.client) {
-        if (suffixes.some((suffix) => name.endsWith(suffix))) continue
-        const encoded: ServedFile['encoded'] = {}
-        for (const encoding of ENCODINGS) {
-            const copy = parts.client.get(name + ENCODING_SUFFIX[encoding])
-            if (copy !== undefined) encoded[encoding] = () => Bun.file(copy)
-        }
-        files.set(name, {
-            // THE TYPE IS THE NAME'S, not the path's: a compiled app's path carries a hash the
-            // bundler put before the extension, and a `.br`'s extension names nothing.
-            type: Bun.file(name).type,
-            body: () => Bun.file(path),
-            encoded,
-        })
-    }
-    return appSources({
-        ...parts,
-        explained: undefined,
-        client: {
-            manifest: parts.manifest,
-            head: '',
-            // 21.5 — EVERY NAME IN THE BUNDLE CARRIES A HASH OF ITS BYTES, the entry's too (38.5), so
-            // a name never answers two different files and a year is safe for all of them. A deploy
-            // is new names in a new document, never new bytes at an old address.
-            framework: bundleServer(
-                files,
-                'public, max-age=31536000, immutable',
-            ),
-            offline: settingOn('ABIDE_OFFLINE', true),
-        },
-    })
-}

package/src/server/testBuild.ts

@@ -1,220 +0,0 @@
-// 42.16 — UNDER `bun test`, `createApp` BUILDS THE APP rather than reading whatever `abide build` last
-// left, ONCE PER STATE OF ITS SOURCES: the build's directory is named after a hash of what made it,
-// so a build either matches the sources or does not exist, and every test process — every
-// `--parallel` worker, every spawned child — reuses the one that does. Eight workers each building
-// their own copy of a 1.3 s build waited 7–10 s apiece.
-
-import { mkdir, rename, rm, utimes, writeFile } from 'node:fs/promises' // bun exposes no directory creation, rename, removal, mtime write or exclusive create of its own
-import { dirname } from 'node:path' // bun exposes no path helpers of its own
-
-import { namesUnder } from './namesUnder.ts'
-import { runBuild } from './runBuild.ts'
-
-// The framework's own source is part of what made a build: a compiler change is a new build.
-const FRAMEWORK = Bun.fileURLToPath(new URL('../..', import.meta.url))
-const POLL_MS = 50
-// A build no test process has reused for this long is swept by the next one that builds.
-const UNUSED_FOR_MS = 24 * 60 * 60 * 1000
-
-// One lookup per app per test process, however many files in it call `createApp`.
-const TEST_BUILDS = new Map<string, Promise<string>>()
-
-/**
- * The build of the app under `root` for its sources as they stand, made if no process has made it.
- *
- * UNDER `node_modules`, so a bare import in the built modules resolves as it does from the app, and
- * so it is ignored wherever `node_modules` is.
- */
-export function testBuild(root: string): Promise<string> {
-    let built = TEST_BUILDS.get(root)
-    if (built === undefined) {
-        built = sourceHash(root).then((key) =>
-            sharedBuild(
-                `${dirname(root)}/node_modules/.cache/abide`,
-                `build-${key}`,
-                (out) => runBuild(root, out),
-            ),
-        )
-        TEST_BUILDS.set(root, built)
-    }
-    return built
-}
-
-/**
- * `builds/key`, made by `build` in exactly one process however many ask at once.
- *
- * THE FIRST TO CREATE `key.lock` BUILDS — an exclusive create is atomic, so one process wins — into
- * a staging directory renamed into place, so nothing reads a half-written build. The rest wait for
- * it, and take the lock over if the process holding it has ended.
- */
-export async function sharedBuild(
-    builds: string,
-    key: string,
-    build: (out: string) => Promise<void>,
-): Promise<string> {
-    const out = `${builds}/${key}`
-    const lock = `${out}.lock`
-    await mkdir(builds, { recursive: true })
-    for (;;) {
-        if (await isDirectory(out)) {
-            const now = new Date()
-            await utimes(out, now, now)
-            return out
-        }
-        if (await claim(lock)) {
-            try {
-                if (!(await isDirectory(out))) await buildInto(out, build)
-            } finally {
-                await rm(lock, { force: true })
-            }
-            await sweep(builds, key)
-            return out
-        }
-        if (await holderEnded(lock)) await rm(lock, { force: true })
-        else await Bun.sleep(POLL_MS)
-    }
-}
-
-async function buildInto(
-    out: string,
-    build: (out: string) => Promise<void>,
-): Promise<void> {
-    const staging = `${out}.tmp-${process.pid}`
-    await rm(staging, { recursive: true, force: true })
-    try {
-        await build(staging)
-        await rename(staging, out)
-    } catch (thrown) {
-        await rm(staging, { recursive: true, force: true })
-        // TWO HOLDERS, where one took over a lock the other had just taken over: the first rename
-        // stands, and it is the same build.
-        if (await isDirectory(out)) return
-        throw thrown
-    }
-}
-
-/**
- * A hash of everything a build of the app under `root` is made from.
- *
- * The app's files, the package and lockfile above it, the framework's own source, and `root`
- * itself, since a build carries the paths it was made at.
- */
-export async function sourceHash(root: string): Promise<string> {
-    const app = dirname(root)
-    const paths = [
-        ...filesUnder(root),
-        ...filesUnder(`${FRAMEWORK}src`),
-        ...filesUnder(`${FRAMEWORK}bin`),
-        `${app}/package.json`,
-        `${app}/tsconfig.json`,
-    ]
-    const lockfile = await lockfileAbove(app)
-    if (lockfile !== undefined) paths.push(lockfile)
-    const contents = await Promise.all(
-        paths.map((path) =>
-            Bun.file(path)
-                .bytes()
-                .catch(() => undefined),
-        ),
-    )
-    const hasher = new Bun.CryptoHasher('sha256')
-    hasher.update(root)
-    for (let at = 0; at < paths.length; at += 1) {
-        const bytes = contents[at]
-        if (bytes === undefined) continue
-        hasher.update(paths[at] as string)
-        hasher.update(bytes)
-    }
-    return hasher.digest('hex').slice(0, 16)
-}
-
-// Sorted, so the hash does not depend on the order a directory lists in. Dot entries and
-// `node_modules` are skipped: neither is the app's source, and the builds live in one.
-function filesUnder(directory: string): string[] {
-    const found: string[] = []
-    for (const name of namesUnder(directory))
-        if (!`/${name}`.includes('/node_modules/'))
-            found.push(`${directory}/${name}`)
-    return found.sort()
-}
-
-async function lockfileAbove(directory: string): Promise<string | undefined> {
-    for (let at = directory; ; at = dirname(at)) {
-        for (const name of ['bun.lock', 'bun.lockb'])
-            if (await Bun.file(`${at}/${name}`).exists()) return `${at}/${name}`
-        if (dirname(at) === at) return undefined
-    }
-}
-
-async function claim(lock: string): Promise<boolean> {
-    try {
-        await writeFile(lock, String(process.pid), { flag: 'wx' })
-        return true
-    } catch (thrown) {
-        if ((thrown as { code?: string }).code === 'EEXIST') return false
-        throw thrown
-    }
-}
-
-async function holderEnded(lock: string): Promise<boolean> {
-    const text = await Bun.file(lock)
-        .text()
-        .catch(() => undefined)
-    // Gone is not ended: the holder finished, and the next pass finds its build.
-    if (text === undefined) return false
-    // Empty is a holder between creating the lock and writing its pid.
-    return text !== '' && !isRunning(Number(text))
-}
-
-/** Removes builds unused for a day, and what an ended process left half-made. */
-async function sweep(builds: string, kept: string): Promise<void> {
-    const names = new Bun.Glob('*').scanSync({ cwd: builds, onlyFiles: false })
-    const removals: Promise<void>[] = []
-    const now = Date.now()
-    for (const name of names) {
-        if (name === kept) continue
-        const staged = /\.tmp-(\d+)$/.exec(name)
-        if (staged !== null) {
-            if (!isRunning(Number(staged[1])))
-                removals.push(
-                    rm(`${builds}/${name}`, { recursive: true, force: true }),
-                )
-            continue
-        }
-        if (name.endsWith('.lock')) continue
-        removals.push(
-            Bun.file(`${builds}/${name}`)
-                .stat()
-                .then((found) =>
-                    now - found.mtimeMs > UNUSED_FOR_MS
-                        ? rm(`${builds}/${name}`, {
-                              recursive: true,
-                              force: true,
-                          })
-                        : undefined,
-                )
-                .catch(() => undefined),
-        )
-    }
-    await Promise.all(removals)
-}
-
-async function isDirectory(path: string): Promise<boolean> {
-    return (
-        (
-            await Bun.file(path)
-                .stat()
-                .catch(() => undefined)
-        )?.isDirectory() === true
-    )
-}
-
-function isRunning(pid: number): boolean {
-    try {
-        process.kill(pid, 0)
-        return true
-    } catch (thrown) {
-        // EPERM is a process that exists and is someone else's.
-        return (thrown as { code?: string }).code === 'EPERM'
-    }
-}

package/src/shared/LOAD_OFFLINE.ts

@@ -1,15 +0,0 @@
-/**
- * The `offline` of the call that is starting a load, while it starts.
- *
- * 16.81 — SET AROUND THE REACH as `LOAD_SIGNAL` is, and read by the browser's wire as its body
- * starts: what stands in for an answer the call could not get. A leaf, because `callLoad` sets it
- * and the wire reads it.
- */
-export const LOAD_OFFLINE: {
-    current: ((args: unknown) => unknown) | undefined
-    /**
-     * Where the body that queues the call asks for the value the call reached, which `callLoad`
-     * fills once the reach returns: what the delivered answer lands in (46.7).
-     */
-    standing: { value: unknown } | undefined
-} = { current: undefined, standing: undefined }

package/src/shared/LOAD_SIGNAL.ts

@@ -1,10 +0,0 @@
-/**
- * The abort signal of the call that is starting a load, while it starts.
- *
- * 16.49 — THE SIGNAL OF THE CALL THAT IS STARTING A LOAD, set around the reach and read by a
- * transport's body as it starts: the browser's wire hands it to `fetch`, so a load every caller
- * aborted ends its request too. A leaf, because `callLoad` sets it and the wire reads it.
- */
-export const LOAD_SIGNAL: { current: AbortSignal | undefined } = {
-    current: undefined,
-}

package/src/shared/issuesOf.ts

@@ -1,18 +0,0 @@
-/**
- * Issues in the shape `Issues<T>` gives them for the value refused: by path for an object or an
- * array, the bare list for anything else.
- *
- * DECIDED BY THE VALUE, because the value is all the runtime holds — `T` is erased. A scalar has
- * no path to key by, so every issue about one stands on `''`, and handing back `{ '': [...] }`
- * there is the wrapper `Issues<T>` says a reader never unwraps: `error().data[0]` read `undefined`.
- */
-export function issuesOf(
-    found: Record<string, string[]>,
-    value: unknown,
-): Record<string, string[]> | string[] {
-    if (typeof value === 'object' && value !== null) return found
-    const listed: string[] = []
-    for (const path in found)
-        for (const said of found[path] as string[]) listed.push(said)
-    return listed
-}

package/src/shared/reactive/ENTRY_LIVES.ts

@@ -1,7 +0,0 @@
-/**
- * When each entry of a `Keyed` declaring `ttl` last produced, and how long it lives, by entry cell.
- *
- * 11.45. A leaf because `Keyed.ts` writes it and `Reactive.ts` reads it (`deadlineOf`), and the
- * second cannot import the first.
- */
-export const ENTRY_LIVES = new WeakMap<object, { at: number; ms: number }>()

package/src/shared/reactive/FOLLOWED.ts

@@ -1,8 +0,0 @@
-/**
- * What an invalidate of a value the server feeds over the mux sends on, by the cell its past is on.
- *
- * 7.10. The core calls these for every cell it invalidates, however the trigger was spelled — the
- * value's own, a `Keyed`'s, an `Rpc`'s or a tag's — and only a value a browser follows has any, so
- * every other invalidate is one miss. A leaf, for `PATCH_SINKS`'s reason.
- */
-export const FOLLOWED = new WeakMap<object, Set<() => void>>()

package/src/shared/reactive/PATCHES.ts

@@ -1,11 +0,0 @@
-/**
- * Which objects an `s.patch` wrote to, and when.
- *
- * 32.33. `epoch` moves once per patch and `written` holds the epoch an object was last written at,
- * so a row that took its item at epoch `e` is stale exactly where its item's entry is past `e`. A leaf, because
- * `reconcile` reads it from the `@abide/abide/runtime` barrel.
- */
-export const PATCHES: { epoch: number; written: WeakMap<object, number> } = {
-    epoch: 0,
-    written: new WeakMap(),
-}