@abide/abide 0.57.1 → 0.100.0

package/src/lib/shared/buildSocketOverChannel.ts

@@ -1,102 +0,0 @@
-import { attachSocketSelectorMethods } from './attachSocketSelectorMethods.ts'
-import { browserClientFlags } from './browserClientFlags.ts'
-import { createPushIterator } from './createPushIterator.ts'
-import { SOCKETS_PATH } from './SOCKETS_PATH.ts'
-import type { Socket } from './types/Socket.ts'
-import type { SocketChannel } from './types/SocketChannel.ts'
-import type { TailHooks } from './types/TailHooks.ts'
-import { withBase } from './withBase.ts'
-
-/* Per-channel-agnostic sub id counter; uniqueness within a channel is all the
-   lifecycle routing needs, so one monotonic source across every socket is fine. */
-let nextId = 0
-
-/*
-Builds a Socket<T> over a SocketChannel — the one Socket surface every consumer
-side shares, so the browser proxy and the test harness can't drift on the
-Socket contract or the iterator wiring. `resolveChannel` is a thunk, called on
-first subscribe/publish rather than at construction, so the bundler's one
-socketProxy() per socket doesn't open a ws until the socket is actually read.
-
-Bare iteration is the live stream (replay 0); `.tail(n)` seeds from the
-retained tail (no-arg = the whole tail). Each iterator mints its own sub id for
-lifecycle routing (end/err), and `hooks.replayed` fires in-band after the
-replay batch so a window reader commits its seed strictly before any live frame.
-
-`initialFrame` warm-seeds `lastFrame` at construction (socketProxy passes the
-server's retained frame from `__SSR__.sockets`) so `peek()` returns the SSR value
-at hydration instead of undefined — congruent with the server HTML until the ws
-delivers its own replay of the same frame.
-*/
-export function buildSocketOverChannel<T>(
-    name: string,
-    resolveChannel: () => SocketChannel,
-    initialFrame?: T,
-): Socket<T> {
-    /* The latest frame seen across every iterator of this socket — what peek() returns and
-       what refresh() re-seeds from the server tail. A plain slot (not reactive): peek(socket)
-       is a synchronous snapshot; live reactivity is the for-await / watch(socket) path. Seeded
-       from the SSR-retained frame so a not-yet-connected client's peek matches the server. */
-    let lastFrame: T | undefined = initialFrame
-    function iterate(replay: number | undefined, hooks?: TailHooks): AsyncIterable<T> {
-        return {
-            [Symbol.asyncIterator](): AsyncIterator<T, void, undefined> {
-                const id = `s${++nextId}`
-                const channel = resolveChannel()
-                const iterator = createPushIterator<T>(() => channel.unsubscribe(id))
-                channel.subscribe(id, name, replay, {
-                    onMessage: (value) => {
-                        lastFrame = value as T
-                        iterator.push(value as T)
-                    },
-                    onReplay: (messages) => {
-                        for (const value of messages) {
-                            lastFrame = value as T
-                            iterator.push(value as T)
-                        }
-                        if (hooks?.replayed) {
-                            iterator.control(hooks.replayed)
-                        }
-                    },
-                    onEnd: () => iterator.end(),
-                    onError: (message) => iterator.error(message),
-                    onDisconnect: () => iterator.disconnect(),
-                })
-                return iterator
-            },
-        }
-    }
-    const publish = (message: T) => resolveChannel().publish(name, message)
-    const socket = {
-        name,
-        clients: browserClientFlags,
-        /* `publish` sends a server-validated `pub` frame (the dispatcher gates it on the
-           topic's `clientPublish`), mirroring Bun's `server.publish()`; the internal
-           channel-send function shares the name. */
-        publish,
-        tail: (count?: number, hooks?: TailHooks) => iterate(count, hooks),
-        /* The latest frame this client has seen, synchronously. */
-        peek: () => lastFrame,
-        /* Re-pull the server's retained tail over the HTTP face (GET /__abide/sockets/<name>
-           → JSON array of retained frames) and reset the local latest — a reconnect / ttl
-           resync. Fire-and-forget: the fetch runs in the background and updates what peek()
-           returns. A failed pull leaves the current value untouched. */
-        refresh: () => {
-            void fetch(withBase(`${SOCKETS_PATH}/${name}`))
-                .then((response) => (response.ok ? response.json() : undefined))
-                .then((frames) => {
-                    if (Array.isArray(frames) && frames.length > 0) {
-                        lastFrame = frames[frames.length - 1] as T
-                    }
-                })
-                .catch(() => undefined)
-        },
-        /* Inert default so the returned object satisfies Socket<T> without importing the ui-only
-           `watch` into this shared builder (which the test harness also uses). The client proxy
-           (socketProxy) overwrites it with the real `watch(socket, …)`. */
-        watch: () => () => {},
-        [Symbol.asyncIterator]: () => iterate(0)[Symbol.asyncIterator](),
-    }
-    attachSocketSelectorMethods(socket)
-    return socket
-}

package/src/lib/shared/bundleGraphFromMetafile.ts

@@ -1,68 +0,0 @@
-import { resolve } from 'node:path'
-import type { BuildMetafile } from 'bun'
-
-/* One surviving module in the post-DCE bundle graph: its absolute path and input source byte
-   size. `bytes` is the metafile's `inputs[key].bytes` — the source weight the budget diagnostic
-   measures (a tree-shaken module is absent from the metafile entirely, so every module here
-   SURVIVED into the bundle). */
-type BundleGraphModule = {
-    path: string
-    bytes: number
-}
-
-/*
-The post-DCE module graph reconstructed from a client build's `Bun.build` metafile — the reusable
-analysis seam ADR-0031 D2 factors out. `metafile.inputs` is the DCE-accurate graph (a
-textually-imported but tree-shaken module is ABSENT), so a single walk yields both the surviving
-modules and their child→importer edges; consumers then judge the graph without re-walking it.
-Two ride it today: the side-crossing reachability guard (a surviving server-only module is a
-violation) and the bundle-budget diagnostic (a surviving input over a size budget is a warning).
-The metafile carries module presence + input byte size, NOT export-level liveness — so a consumer
-can judge "this module survived / is this big", not "this export is unused" (ADR-0031 D2 spike).
-*/
-export type BundleGraph = {
-    /* Every module present in the post-DCE graph, keyed by absolute path. */
-    modules: BundleGraphModule[]
-    /* The import chain from a graph root down to `target`, in root→target order (absolute paths),
-       reconstructed from the graph's own first-wins child→importer edges — one witness, cycle-safe.
-       Returns `[target]` when nothing imports it (a graph root). */
-    importerChain(target: string): string[]
-}
-
-/*
-Walks a client build's metafile once into a `BundleGraph`. `inputs` keys are relative to
-`process.cwd()` while edge `path`s are absolute, so each module path is resolved against `cwd` to
-match on absolute paths throughout. First edge wins for the importer map — enough to render one
-witness chain, and cheap.
-*/
-export function bundleGraphFromMetafile(metafile: BuildMetafile, cwd: string): BundleGraph {
-    const modules: BundleGraphModule[] = []
-    /* child(absolute) → its importer(absolute); first edge wins — one witness chain. */
-    const importerOf = new Map<string, string>()
-    for (const [key, input] of Object.entries(metafile.inputs)) {
-        const modulePath = resolve(cwd, key)
-        modules.push({ path: modulePath, bytes: input.bytes })
-        for (const edge of input.imports) {
-            if (!importerOf.has(edge.path)) {
-                importerOf.set(edge.path, modulePath)
-            }
-        }
-    }
-    return {
-        modules,
-        importerChain(target) {
-            const chain = [target]
-            const seen = new Set([target])
-            let cursor = target
-            while (importerOf.has(cursor)) {
-                cursor = importerOf.get(cursor) as string
-                if (seen.has(cursor)) {
-                    break
-                }
-                seen.add(cursor)
-                chain.push(cursor)
-            }
-            return chain.reverse()
-        },
-    }
-}

package/src/lib/shared/bundleLayout.ts

@@ -1,36 +0,0 @@
-import { basename, dirname, join } from 'node:path'
-
-/*
-Where a bundle's files live relative to its binary directory (the dir holding the
-launcher + server — `dirname(process.execPath)` at runtime). A macOS `.app` nests
-binaries under `Contents/MacOS`, the webview lib under `Contents/Frameworks`, and
-data under `Contents/Resources` — the only one `codesign` seals as a *resource*,
-so the shipped `.env` survives signing. Every other platform keeps everything
-flat beside the binaries. The single source the bundler writes against and the
-boot readers resolve from, so build and runtime can't disagree. Pure: computes
-paths, never touches disk.
-*/
-export function bundleLayout(binaryDir: string): {
-    binDir: string
-    libDir: string
-    resourcesDir: string
-    envPath: string
-} {
-    const isMacApp = basename(binaryDir) === 'MacOS' && basename(dirname(binaryDir)) === 'Contents'
-    if (isMacApp) {
-        const contents = dirname(binaryDir)
-        const resourcesDir = join(contents, 'Resources')
-        return {
-            binDir: binaryDir,
-            libDir: join(contents, 'Frameworks'),
-            resourcesDir,
-            envPath: join(resourcesDir, '.env'),
-        }
-    }
-    return {
-        binDir: binaryDir,
-        libDir: binaryDir,
-        resourcesDir: binaryDir,
-        envPath: join(binaryDir, '.env'),
-    }
-}