@abide/abide 0.123.1 → 0.123.3

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/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(),
-}

package/src/shared/reactive/PATCH_SINKS.ts

@@ -1,26 +0,0 @@
-/**
- * One JSON Patch operation (RFC 6902), its `path` and `from` JSON Pointers (RFC 6901).
- *
- * A patch abide records is `add`, `remove` and `replace` alone; `move`, `copy` and `test` are
- * applied where a client sends them.
- */
-export type PatchOp =
-    | { op: 'add'; path: string; value: unknown }
-    | { op: 'remove'; path: string }
-    | { op: 'replace'; path: string; value: unknown }
-    | { op: 'move'; from: string; path: string }
-    | { op: 'copy'; from: string; path: string }
-    | { op: 'test'; path: string; value: unknown }
-
-/**
- * Where a patch's writes are kept as data, by the cell they were made to.
- *
- * 18.11. Only a value the server follows over the mux has one, so every other patch records
- * nothing but its marks (32.33). `lost` where a write could not be kept as data, and then the
- * change is sent as the value (18.13). `fed` is how many followers the server is feeding it, and
- * the sink goes with the last. A leaf, because the reactive core writes it and the server reads it.
- */
-export const PATCH_SINKS = new WeakMap<
-    object,
-    { ops: PatchOp[]; lost: boolean; fed: number }
->()

package/src/shared/reactive/canonicalKey.ts

@@ -1,95 +0,0 @@
-import { putOwn } from '../putOwn.ts'
-
-/**
- * The entry key for an `Args` value: its canonical wire form, as a string.
- *
- * RULEBOOK 11.24: members sorted by name, `undefined` members dropped, `Date` written ISO.
- *
- * 11.26: the key is taken BEFORE any gate runs, because a browser holds no copy of the gate — a
- * key taken after normalizing is computed one way on a server and another in a browser, and every
- * handler with a normalizing schema would miss its seed buffer and re-issue the call on hydration.
- *
- * 11.64: WHAT THE WIRE FORM CANNOT WRITE IS REFUSED AT THE REACH. `JSON.stringify` does not fail
- * on any of it — a `Set`, a `Map` and a class instance each have no own enumerable keys and
- * canonicalize to `{}`, and a non-finite number is written `null` — so two different reaches
- * produced one key and 1.8 joined the second to the first's standing work. The value was right
- * for the first caller and wrong for every other one, with nothing to see.
- */
-export function canonicalKey(args: unknown): string {
-    if (args === undefined) return ''
-    return JSON.stringify(canonical(args, []))
-}
-
-// THE PATH IS A STACK OF STEPS, joined only when a refusal names it. Built as a string per member
-// it was a concatenation for every element and every nested key on every reach, for a message the
-// success path never reads.
-type Steps = (string | number)[]
-
-function canonical(value: unknown, path: Steps): unknown {
-    if (value === null) return value
-    const kind = typeof value
-    if (kind === 'number') {
-        if (!Number.isFinite(value)) throw outside(String(value), path)
-        return value
-    }
-    if (kind !== 'object') {
-        if (kind === 'boolean' || kind === 'string') return value
-        // `undefined` reaches here from an ARRAY element alone — a member is dropped above.
-        throw outside(kind === 'undefined' ? 'undefined' : `a ${kind}`, path)
-    }
-    if (value instanceof Date) return value.toISOString()
-    if (Array.isArray(value)) {
-        const out: unknown[] = []
-        for (let index = 0; index < value.length; index += 1) {
-            path.push(index)
-            out.push(canonical(value[index], path))
-            path.pop()
-        }
-        return out
-    }
-    const prototype = Object.getPrototypeOf(value)
-    if (prototype !== Object.prototype && prototype !== null)
-        throw outside(named(value as object), path)
-    const source = value as Record<string, unknown>
-    const keys = Object.keys(source).sort()
-    // AN ORDINARY OBJECT, AND `putOwn` FOR THE ONE KEY THAT NEEDS IT: `__proto__` is a SETTER on
-    // `Object.prototype`, so `out[key] = …` for that key creates no own property and
-    // `JSON.stringify` never sees it — `{id: 1, __proto__: {role: 'admin'}}` and `{id: 1}` then
-    // canonicalize to one string, and 1.8 joins the second reach to the first's standing work.
-    // `Object.create(null)` closed that too, and V8 builds it in DICTIONARY mode: the shipped key
-    // took 49-56% of the time without it there, and a standing keyed reach 53%, where JSC reads
-    // level to 110% (`abide/bench/sharedCases.ts`, two runs per engine).
-    const out: Record<string, unknown> = {}
-    for (let index = 0; index < keys.length; index += 1) {
-        const key = keys[index] as string
-        const member = source[key]
-        if (member === undefined) continue
-        path.push(key)
-        putOwn(out, key, canonical(member, path))
-        path.pop()
-    }
-    return out
-}
-
-function named(value: object): string {
-    const from = value.constructor as { name?: unknown } | undefined
-    return typeof from?.name === 'string' && from.name !== ''
-        ? `a ${from.name}`
-        : 'a class instance'
-}
-
-function outside(what: string, steps: Steps): Error {
-    let path = ''
-    for (const step of steps)
-        path +=
-            typeof step === 'number'
-                ? `[${step}]`
-                : path === ''
-                  ? step
-                  : `.${step}`
-    return new Error(
-        `An Args key cannot carry ${what} at ${
-            path === '' ? 'the arguments themselves' : `"${path}"`
-        }: the canonical wire form writes it as another entry's key (RULEBOOK 11.64).`,
-    )
-}