@abide/abide 0.58.0 → 0.101.0

package/src/lib/server/runtime/amendBroadcaster.ts

@@ -1,53 +0,0 @@
-import { AMEND_TOPIC_PREFIX } from '../../shared/AMEND_TOPIC_PREFIX.ts'
-import { encodeRefJson } from '../../shared/encodeRefJson.ts'
-import { keyForRemoteCall } from '../../shared/keyForRemoteCall.ts'
-import { REMOTE_FUNCTION } from '../../shared/REMOTE_FUNCTION.ts'
-import type { CacheSelector } from '../../shared/types/CacheSelector.ts'
-import type { RawRemoteFunction } from '../../shared/types/RawRemoteFunction.ts'
-import type { SocketServerFrame } from '../../shared/types/SocketServerFrame.ts'
-import { getActiveServer } from './getActiveServer.ts'
-
-/*
-The server half of the isomorphic amend value form (ADR-0043): serialize the keyed
-value to a standard socket `msg` frame and publish it on the per-call reserved topic
-`__abide/amend/<key>`, so every browser with a live reader of that exact call (and thus
-already authorized for it) sets the pushed value locally with no refetch. Installed as
-the amendBroadcastSlot resolver by serverEntry ONLY — never imported from a shared or ui
-module — so this server socket code stays out of the client reachability graph; the
-resolver-slot indirection is the guarantee, not the ADR-0022 DCE guard (which polices the
-app's own src/server edge, not abide's internal lib/server modules). Do not import this
-from a client-reachable module.
-
-Only the value form broadcasts: an updater is a closure with no wire form, so it throws
-here (the mistake surfaces at the mutation site). The value must target an exact call — a
-remote function with its args, or a no-input rpc's single key — since a value has to land
-on one entry; a producer/closure or `{ tags }` selector has no single cross-client key and
-throws. The rpc's own key derivation (keyForRemoteCall) names the topic, so it agrees with
-the client cache key by construction. Subscriber-gated: skip the encode + native publish
-when no client is reading that key (the topic evaporates — it holds no tail).
-*/
-export function broadcastAmend<Args, Return>(
-    selector: CacheSelector<Args, Return>,
-    args: Args | undefined,
-    isValue: boolean,
-    payload: Return | ((current: Return) => Return),
-): void {
-    if (!isValue) {
-        throw new Error(
-            '[abide] amend() with an updater is client-local (a closure has no wire form) — pass a value to broadcast from the server.',
-        )
-    }
-    if (typeof selector !== 'function' || !(REMOTE_FUNCTION in selector)) {
-        throw new Error(
-            '[abide] amend(value) can only broadcast for a remote function — a producer/closure or { tags } selector has no cross-client key.',
-        )
-    }
-    const remote = selector as RawRemoteFunction<Args>
-    const topic = `${AMEND_TOPIC_PREFIX}${keyForRemoteCall(remote.method, remote.url, args)}`
-    const server = getActiveServer()
-    if (server === undefined || server.subscriberCount(`socket:${topic}`) === 0) {
-        return
-    }
-    const frame: SocketServerFrame = { type: 'msg', socket: topic, message: payload }
-    server.publish(`socket:${topic}`, encodeRefJson(frame))
-}

package/src/lib/server/runtime/buildCacheSnapshot.ts

@@ -1,63 +0,0 @@
-import { sharedCacheStore } from '../../shared/sharedCacheStore.ts'
-import type { CacheEntry } from '../../shared/types/CacheEntry.ts'
-import type { InspectorCacheEntry } from './types/InspectorCacheEntry.ts'
-import type { InspectorCacheSnapshot } from './types/InspectorCacheSnapshot.ts'
-
-const PREVIEW_LIMIT = 200
-
-/* A short JSON peek at a warm value, degrading non-serializable values to String. */
-function preview(value: unknown): string | undefined {
-    if (value === undefined) {
-        return undefined
-    }
-    try {
-        const json = JSON.stringify(value)
-        return json.length > PREVIEW_LIMIT ? `${json.slice(0, PREVIEW_LIMIT)}…` : json
-    } catch {
-        return String(value)
-    }
-}
-
-/* The entry's armed refetch (stale-while-revalidate) policy as a label, if it declared
-   one. A windowless policy refetches immediately, so it labels as plain `refetch`. */
-function policyLabel(entry: CacheEntry): string | undefined {
-    const policy = entry.invalidation
-    if (!policy) {
-        return undefined
-    }
-    if (policy.debounce !== undefined) {
-        return `refetch debounce ${policy.debounce}ms`
-    }
-    if (policy.throttle !== undefined) {
-        return `refetch throttle ${policy.throttle}ms`
-    }
-    return 'refetch'
-}
-
-function projectEntry(entry: CacheEntry, now: number): InspectorCacheEntry {
-    return {
-        key: entry.key,
-        status: entry.refreshing ? 'refreshing' : entry.settled ? 'settled' : 'in-flight',
-        remote: entry.request !== undefined,
-        ttl: entry.ttl,
-        expiresInMs: entry.expiresAt !== undefined ? entry.expiresAt - now : undefined,
-        tags: entry.tags ? [...entry.tags] : [],
-        value: preview(entry.value),
-        policy: policyLabel(entry),
-    }
-}
-
-/*
-Snapshots the process-level cache store (the persistent one an endpoint declaring
-`cache: { shared: true, ttl }` — or a producer `cache(fn, args, { shared: true, ttl })`
-— writes to) for the inspector. Read at call time, so it reflects the store as it
-stands; request-scoped stores are deliberately excluded — they're ephemeral and
-already visible as per-request cache tallies.
-*/
-export function buildCacheSnapshot(): InspectorCacheSnapshot {
-    const now = Date.now()
-    const entries = Array.from(sharedCacheStore().entries.values(), (entry) =>
-        projectEntry(entry, now),
-    )
-    return { entries }
-}

package/src/lib/server/runtime/buildHealthPayload.ts

@@ -1,34 +0,0 @@
-import { ABIDE_VERSION } from '../../shared/ABIDE_VERSION.ts'
-import { abideLog } from '../../shared/abideLog.ts'
-import type { AppModule } from '../AppModule.ts'
-
-/*
-The canonical /__abide/health payload: the app health(request) hook's fields
-under the framework identity keys, which win on collision. A thrown or
-non-object hook degrades to no fields — an app bug must not masquerade as an
-unreachable server, so the base payload always builds. Shared by the
-health/identity routes and the SSR renderer's __SSR__.health seed so the
-wire and the seed can't drift.
-*/
-export async function buildHealthPayload(
-    request: Request,
-    opts: { app?: AppModule; appName: string; appVersion: string },
-): Promise<Record<string, unknown>> {
-    let fields: Record<string, unknown> = {}
-    if (opts.app?.health) {
-        try {
-            const result = await opts.app.health(request)
-            if (result && typeof result === 'object' && !Array.isArray(result)) {
-                fields = result as Record<string, unknown>
-            }
-        } catch (error) {
-            abideLog.error(error)
-        }
-    }
-    /*
-    `abide` carries the framework version — truthy for the probe check,
-    informative for skew diagnosis. The IDENTITY_PATH alias overrides it to
-    the legacy `abide: true` shape at its call site.
-    */
-    return { ...fields, abide: ABIDE_VERSION, name: opts.appName, version: opts.appVersion }
-}

package/src/lib/server/runtime/buildInFlightSnapshot.ts

@@ -1,35 +0,0 @@
-import { inFlightRequests } from './inFlightRequests.ts'
-import type { InspectorInFlightRequest } from './types/InspectorInFlightRequest.ts'
-import type { InspectorInFlightSnapshot } from './types/InspectorInFlightSnapshot.ts'
-import type { RequestStore } from './types/RequestStore.ts'
-
-function projectStore(store: RequestStore, now: number): InspectorInFlightRequest {
-    return {
-        trace: store.trace.traceId,
-        method: store.req.method,
-        path: `${store.url.pathname}${store.url.search}`,
-        /* store.start is Bun.nanoseconds() at scope entry; elapsed is current at the read. */
-        elapsedMs: (now - store.start) / 1e6,
-        route: store.route,
-        params: store.params,
-    }
-}
-
-/*
-Snapshots the request scopes currently executing their handler. Read at call
-time so it reflects the in-flight set as it stands; returns empty when the
-inspector hasn't installed the tracking Set or the server is idle. Sorted by
-elapsed ascending — newest (least elapsed) first, so a long-running request
-sinks to the bottom as its elapsed grows.
-*/
-export function buildInFlightSnapshot(): InspectorInFlightSnapshot {
-    const tracked = inFlightRequests.tracked
-    if (!tracked) {
-        return { requests: [] }
-    }
-    const now = Bun.nanoseconds()
-    const requests = Array.from(tracked, (store) => projectStore(store, now)).sort(
-        (left, right) => left.elapsedMs - right.elapsedMs,
-    )
-    return { requests }
-}

package/src/lib/server/runtime/buildInspectorSurface.ts

@@ -1,47 +0,0 @@
-import { promptRegistry } from '../prompts/promptRegistry.ts'
-import { resolveInputJsonSchema, resolveOutputJsonSchema } from '../rpc/resolveRpcJsonSchema.ts'
-import { rpcRegistry } from '../rpc/rpcRegistry.ts'
-import { socketOperations } from '../sockets/socketOperations.ts'
-import { socketRegistry } from '../sockets/socketRegistry.ts'
-import type { InspectorSurface } from './types/InspectorSurface.ts'
-
-/*
-Projects the live rpc + socket registries into the inspector's catalog. Read
-at call time (not cached) so rpcs constructed after boot — lazily on first
-hit, or eagerly once ensureRegistriesLoaded walked the manifest — show up.
-Schemas go through jsonSchemaForSchema, the same projection MCP and OpenAPI
-use, so the three can't disagree on a rpc's shape; a missing schema stays
-undefined to mark a rpc that carries no machine-advertisable contract.
-*/
-export function buildInspectorSurface(): InspectorSurface {
-    const rpcs = Array.from(rpcRegistry.values()).map((entry) => ({
-        url: entry.remote.url,
-        method: entry.remote.method,
-        clients: { ...entry.remote.clients },
-        // The declared inputSchema VALIDATOR wins; else the build-projected input-type schema
-        // (ADR-0030 input side); with neither the rpc advertises no input shape, as before.
-        inputSchema: resolveInputJsonSchema(entry),
-        outputSchema: resolveOutputJsonSchema(entry),
-        files: entry.filesSchema !== undefined,
-        timeout: entry.timeout,
-        maxBodySize: entry.maxBodySize,
-        crossOrigin: entry.remote.crossOrigin,
-    }))
-    const sockets = Array.from(socketRegistry.values()).map((entry) => ({
-        name: entry.socket.name,
-        operations: socketOperations(entry).map((operation) => ({
-            kind: operation.kind,
-            name: operation.name,
-            method: operation.method,
-            restUrl: operation.restUrl,
-        })),
-    }))
-    /* jsonSchema is already JSON Schema (built from the frontmatter `arguments`
-       list by the resolver plugin), so it's passed through, not re-projected. */
-    const prompts = Array.from(promptRegistry.values()).map((entry) => ({
-        name: entry.prompt.name,
-        description: entry.prompt.description,
-        inputSchema: entry.jsonSchema,
-    }))
-    return { rpcs, sockets, prompts }
-}

package/src/lib/server/runtime/buildOpenApiSpec.ts

@@ -1,150 +0,0 @@
-import { carriesBodyArgs } from '../../shared/carriesBodyArgs.ts'
-import { commandNameForUrl } from '../../shared/commandNameForUrl.ts'
-import { jsonSchemaForSchema } from '../../shared/jsonSchemaForSchema.ts'
-import type { ErrorJsonSchemas } from '../../shared/types/ErrorJsonSchemas.ts'
-import { resolveInputJsonSchema, resolveOutputJsonSchema } from '../rpc/resolveRpcJsonSchema.ts'
-import { rpcRegistry } from '../rpc/rpcRegistry.ts'
-import { STATUS_TEXT } from './STATUS_TEXT.ts'
-
-/*
-Turns a rpc's resolved JSON Schema into OpenAPI query parameters — one
-per top-level property, marked required when the schema lists it. Used
-for GET/DELETE/HEAD operations, which carry their args on the query
-string (mirroring buildRpcRequest).
-*/
-function queryParameters(jsonSchema: Record<string, unknown>): Array<Record<string, unknown>> {
-    const properties = jsonSchema.properties as Record<string, unknown> | undefined
-    if (!properties) {
-        return []
-    }
-    const required = new Set((jsonSchema.required as string[] | undefined) ?? [])
-    return Object.entries(properties).map(([name, schema]) => ({
-        name,
-        in: 'query',
-        required: required.has(name),
-        schema,
-    }))
-}
-
-/*
-Request body schema for a multipart upload rpc: the text fields from
-inputSchema, plus the binary parts. A File has no honest
-Standard-Schema→JSON-Schema conversion, so the file parts are advertised
-generically as additional binary properties rather than named per field.
-*/
-function multipartBodySchema(textSchema: Record<string, unknown>): Record<string, unknown> {
-    const textProperties = (textSchema.properties as Record<string, unknown> | undefined) ?? {}
-    const schema: Record<string, unknown> = {
-        type: 'object',
-        properties: { ...textProperties },
-        additionalProperties: { type: 'string', format: 'binary' },
-    }
-    const required = (textSchema.required as string[] | undefined) ?? []
-    if (required.length > 0) {
-        schema.required = required
-    }
-    return schema
-}
-
-/*
-Adds one `responses[status]` entry per typed-error branch (ADR-0030) — its description is the
-status's standard reason phrase, and its `application/json` content is the error's projected `data`
-schema (omitted for a bare `{}`, a nullary error with no payload). An already-present status (the
-200, or any explicit response) is left untouched, so the success body and validation responses win a
-collision. A no-op when the handler declared no typed errors (`errorJsonSchemas` undefined).
-*/
-function mergeErrorResponses(
-    responses: Record<string, unknown>,
-    errorJsonSchemas: ErrorJsonSchemas | undefined,
-): void {
-    if (errorJsonSchemas === undefined) {
-        return
-    }
-    for (const [status, schema] of Object.entries(errorJsonSchemas)) {
-        if (responses[status] !== undefined) {
-            continue
-        }
-        const response: Record<string, unknown> = {
-            description: STATUS_TEXT[Number(status)] ?? 'Error',
-        }
-        if (Object.keys(schema).length > 0) {
-            response.content = { 'application/json': { schema } }
-        }
-        responses[status] = response
-    }
-}
-
-/*
-Builds an OpenAPI 3.1 document from the rpc registry — the HTTP surface
-every rpc exposes regardless of which non-browser clients it advertises.
-GET/DELETE/HEAD args become query parameters; POST/PUT/PATCH args become
-a JSON request body. operationId is the folder-prefixed command name so
-it lines up with the MCP tool / CLI subcommand identifiers.
-*/
-export function buildOpenApiSpec(info: {
-    title: string
-    version: string
-}): Record<string, unknown> {
-    const paths: Record<string, Record<string, unknown>> = {}
-    for (const entry of rpcRegistry.values()) {
-        const url = entry.remote.url
-        const method = entry.remote.method
-        /*
-        Describe the parameters/request body from the `inputSchema` VALIDATOR when declared, else from
-        the handler's input parameter type projected to JSON Schema at build time (ADR-0030 input side —
-        `entry.inputJsonSchema`); otherwise the opaque fallback. The validator overrides the projection
-        (a runtime narrowing the type can't express), mirroring the 200-body output path below.
-        */
-        const jsonSchema = resolveInputJsonSchema(entry) ?? jsonSchemaForSchema(undefined)
-        const description = jsonSchema.description as string | undefined
-        /*
-        Describe the 200 body from the `outputSchema` VALIDATOR when declared, else from the handler
-        return type projected to JSON Schema at build time (ADR-0030 D2 — `entry.outputJsonSchema`);
-        otherwise fall back to a bare OK. The validator overrides the projection (a runtime narrowing
-        the type can't express).
-        */
-        const okResponse: Record<string, unknown> = { description: 'OK' }
-        const outputSchema = resolveOutputJsonSchema(entry)
-        if (outputSchema) {
-            okResponse.content = { 'application/json': { schema: outputSchema } }
-        }
-        /*
-        Merge the handler's typed-error branches (ADR-0030 — `entry.errorJsonSchemas`, a status-keyed
-        data-schema map baked from the `error.typed(...)` return branches) into the responses. Each
-        status gets a `responses[status]` entry describing the error's data payload; an existing
-        response (the 200, or a future explicit entry) is never clobbered. So the 200 success body and
-        every typed error's status + payload are documented from the one handler return type.
-        */
-        const responses: Record<string, unknown> = { '200': okResponse }
-        mergeErrorResponses(responses, entry.errorJsonSchemas)
-        const operation: Record<string, unknown> = {
-            operationId: commandNameForUrl(url),
-            ...(description ? { description } : {}),
-            responses,
-        }
-        if (carriesBodyArgs(method)) {
-            operation.requestBody = entry.filesSchema
-                ? {
-                      content: {
-                          'multipart/form-data': {
-                              schema: multipartBodySchema(jsonSchema),
-                          },
-                      },
-                  }
-                : { content: { 'application/json': { schema: jsonSchema } } }
-        } else {
-            const parameters = queryParameters(jsonSchema)
-            if (parameters.length > 0) {
-                operation.parameters = parameters
-            }
-        }
-        paths[url] ??= {}
-        const path = paths[url]
-        path[method.toLowerCase()] = operation
-    }
-    return {
-        openapi: '3.1.0',
-        info: { title: info.title, version: info.version },
-        paths,
-    }
-}

package/src/lib/server/runtime/buildPreloadManifest.ts

@@ -1,153 +0,0 @@
-import { existsSync } from 'node:fs'
-import { Glob, gunzipSync } from 'bun'
-import { layoutChainForRoute } from '../../shared/layoutChainForRoute.ts'
-import type { Assets } from './types/Assets.ts'
-
-/* A static-import specifier in a built chunk: `import {…} from "./chunk.js"` and
-   side-effect `import "./chunk.js"`, minified or not. The leading `import` plus the
-   `[^"'()]` guard excludes dynamic `import("./page-….js")` — so only the runtime graph
-   matches, never a lazy route chunk. Mirrors the shell injector in abideResolverPlugin. */
-const STATIC_IMPORT = /import\s*(?:[^"'()]*?\bfrom\s*)?["']\.\/([\w.-]+\.js)["']/g
-
-/* A pages/layouts manifest entry in the entry chunk:
-   `"<route>": () => import("./page-<hash>.js")` (page chunk) or the layout form.
-   The route/layout key plus its lazily-loaded chunk — the only place route → chunk is
-   recorded, since every page chunk shares the `page-` stem and can't be told apart by name. */
-const ROUTE_CHUNK = /"(\/[^"]*)"\s*:\s*\(\)\s*=>\s*import\("\.\/((?:page|layout)-[\w.-]+\.js)"\)/g
-
-/* Reads a `_app` chunk's source by filename — gunzipped from the embedded asset map
-   (standalone compile) or off disk (dev + `abide start`). Undefined on a miss. */
-function chunkReader(
-    appDir: string,
-    assets?: Assets,
-): (name: string) => Promise<string | undefined> {
-    if (assets) {
-        return async (name) => {
-            const bytes = assets[`/_app/${name}`]
-            return bytes ? new TextDecoder().decode(gunzipSync(bytes)) : undefined
-        }
-    }
-    return async (name) => {
-        const file = Bun.file(`${appDir}/${name}`)
-        return (await file.exists()) ? file.text() : undefined
-    }
-}
-
-/* The hashed client entry filename (`client-<hash>.js`), from the asset map or disk.
-   Each build's `appDir` holds exactly one entry (production `_app`, or a dev
-   generation dir), so `.find` is unambiguous. */
-async function findEntry(appDir: string, assets?: Assets): Promise<string | undefined> {
-    const isEntry = (name: string): boolean => /^client-[a-z0-9]+\.js$/i.test(name)
-    if (assets) {
-        const key = Object.keys(assets).find((path) => isEntry(path.replace('/_app/', '')))
-        return key?.replace('/_app/', '')
-    }
-    if (!existsSync(appDir)) {
-        return undefined
-    }
-    const names = await Array.fromAsync(
-        new Glob('client-*.js').scan({ cwd: appDir, onlyFiles: true }),
-    )
-    return names.find(isEntry)
-}
-
-/*
-Maps each page route to the extra `_app` chunks worth preloading for it: the route's
-page chunk, its layout-chain chunks, and the transitive static-import closure of each
-— minus the entry's own static graph, which the shell already preloads. Built once at
-server boot from the built bundle (the route → chunk mapping lives in the entry's
-compiled pages/layouts manifest; the static graph is parsed from each chunk's source).
-
-Those route chunks are dynamically imported by the entry, so the browser can't discover
-them until it has downloaded, parsed, and RUN the entry — on a streamed page that's
-~stream-close. Preloading them per render (the renderer knows the matched route) lets
-the route's whole chain transfer DURING the stream, so hydration is network-ready at
-stream-close instead of waterfalling after it. Returns an empty map when the bundle is
-absent or unparseable, so rendering degrades to the entry-only preload.
-*/
-export async function buildPreloadManifest({
-    appDir,
-    assets,
-}: {
-    appDir: string
-    assets?: Assets
-}): Promise<Record<string, string[]>> {
-    const read = chunkReader(appDir, assets)
-    const entryName = await findEntry(appDir, assets)
-    const entrySource = entryName ? await read(entryName) : undefined
-    if (entryName === undefined || entrySource === undefined) {
-        return {}
-    }
-
-    /* route/layout key → its lazy chunk, split by the page-/layout- stem. */
-    const pageChunk: Record<string, string> = {}
-    const layoutChunk: Record<string, string> = {}
-    for (const match of entrySource.matchAll(ROUTE_CHUNK)) {
-        /* Both capture groups are present whenever the regex matches. */
-        const key = match[1] as string
-        const chunk = match[2] as string
-        if (chunk.startsWith('page-')) {
-            pageChunk[key] = chunk
-        } else {
-            layoutChunk[key] = chunk
-        }
-    }
-
-    /* Memoised direct static imports per chunk; closure walks them to a fixpoint. */
-    const directCache = new Map<string, Promise<string[]>>()
-    const direct = (name: string): Promise<string[]> => {
-        const cached = directCache.get(name)
-        if (cached) {
-            return cached
-        }
-        const deps = read(name).then((source) =>
-            source
-                ? [
-                      ...new Set(
-                          [...source.matchAll(STATIC_IMPORT)].map((match) => match[1] as string),
-                      ),
-                  ]
-                : [],
-        )
-        directCache.set(name, deps)
-        return deps
-    }
-    const closure = async (name: string): Promise<Set<string>> => {
-        const seen = new Set<string>()
-        const queue = [name]
-        while (queue.length > 0) {
-            const current = queue.shift() as string
-            if (seen.has(current)) {
-                continue
-            }
-            seen.add(current)
-            for (const dependency of await direct(current)) {
-                if (!seen.has(dependency)) {
-                    queue.push(dependency)
-                }
-            }
-        }
-        return seen
-    }
-
-    /* The entry + its static runtime — already preloaded by the shell, so excluded. */
-    const excluded = await closure(entryName)
-    const layoutKeys = Object.keys(layoutChunk)
-    const manifest: Record<string, string[]> = {}
-    for (const route of Object.keys(pageChunk)) {
-        const chunks = new Set<string>(await closure(pageChunk[route] as string))
-        for (const key of layoutChainForRoute(route, layoutKeys)) {
-            const chunk = layoutChunk[key]
-            if (chunk) {
-                for (const dependency of await closure(chunk)) {
-                    chunks.add(dependency)
-                }
-            }
-        }
-        const preload = [...chunks].filter((chunk) => !excluded.has(chunk))
-        if (preload.length > 0) {
-            manifest[route] = preload
-        }
-    }
-    return manifest
-}

package/src/lib/server/runtime/cacheControlForAsset.ts

@@ -1,22 +0,0 @@
-import {
-    IMMUTABLE_ASSET_CACHE_CONTROL,
-    REVALIDATE_ASSET_CACHE_CONTROL,
-} from '../../shared/CACHE_CONTROL_VALUES.ts'
-
-/*
-Bun.build emits `[name]-[hash].[ext]` for chunks; hash is alnum and >=8 chars.
-Source maps inherit the same name (e.g. foo-abc12345.js.map), so the suffix may be `.map`.
-*/
-const HASHED = /-[a-z0-9]{8,}\.[a-z0-9]+(\.map)?$/i
-
-/*
-Returns the right `Cache-Control` for an asset path served under `/_app/`.
-Hashed chunk filenames are content-addressed and immutable; everything else
-(the entry bundle, the html shell, etc.) must revalidate every time.
-*/
-export function cacheControlForAsset(pathname: string): string {
-    if (HASHED.test(pathname)) {
-        return IMMUTABLE_ASSET_CACHE_CONTROL
-    }
-    return REVALIDATE_ASSET_CACHE_CONTROL
-}

package/src/lib/server/runtime/cacheStalenessBroadcaster.ts

@@ -1,33 +0,0 @@
-import { CACHE_STALENESS_SOCKET } from '../../shared/CACHE_STALENESS_SOCKET.ts'
-import { serializeSelector } from '../../shared/serializeSelector.ts'
-import type { CacheSelector } from '../../shared/types/CacheSelector.ts'
-import { lookupSocket } from '../sockets/lookupSocket.ts'
-
-/*
-The server half of the isomorphic staleness verbs (ADR-0041): serialize the selector
-to the cross-client envelope and publish it on the reserved __abide/cache socket so
-every connected browser applies the same drop/refetch locally. Installed as the
-cacheStalenessSlot resolver by serverEntry ONLY — never imported from a shared or ui
-module. That single discipline is what keeps this server socket code (and lookupSocket)
-out of the client bundle: the ADR-0022 DCE guard polices the app's own src/server edge,
-NOT abide's internal lib/server modules, so it would NOT catch a leak from here — the
-resolver-slot indirection is the actual guarantee. Do not import this from a
-client-reachable module.
-
-serializeSelector throws for a producer/closure or bare match-all selector (not
-cross-client serializable) — the throw surfaces at the mutation site as the
-programming error it is. Publishing is subscriber-gated by defineSocket.publish
-(it skips the encode + native fan-out when no ws client is subscribed), and the
-reserved socket keeps no tail, so a frame published to nobody simply evaporates.
-*/
-export function broadcastCacheStaleness<Args, Return>(
-    op: 'invalidate' | 'refresh',
-    selector: CacheSelector<Args, Return>,
-    args?: Args,
-): void {
-    const frame = serializeSelector(op, selector, args)
-    /* Resolved lazily from the registry — the socket is minted at server boot, before any
-       request-scoped mutation can call a staleness verb. Absent only in a degenerate boot. */
-    const entry = lookupSocket(CACHE_STALENESS_SOCKET)
-    entry?.socket.publish(frame)
-}

package/src/lib/server/runtime/containsTraversal.ts

@@ -1,41 +0,0 @@
-/*
-Inspects the raw request URL's PATH portion (not the parsed pathname) for
-path-traversal patterns. The WHATWG URL parser decodes `%2E%2E` to `..` and
-then collapses dot-segments out of the pathname during normalization, so by
-the time `url.pathname` is observable any encoded traversal has been masked.
-The remaining literal `..` check guards against any future URL-parser quirk
-that lets a normalised path through.
-
-Only the path is scanned — an encoded slash or backslash in a QUERY value
-(`/logo.png?from=%2Fblog`) is legitimate and must not 404 a real asset.
-
-Hot path early-out: if none of the suspect substrings appear in the raw
-path we never lowercase it nor walk segments.
-*/
-export function containsTraversal(rawUrl: string): boolean {
-    const rawPath = rawPathPortion(rawUrl)
-    if (rawPath.includes('\\')) {
-        return true
-    }
-    if (rawPath.includes('..') && rawPath.split('/').some((segment) => segment === '..')) {
-        return true
-    }
-    if (rawPath.indexOf('%') === -1) {
-        return false
-    }
-    const lower = rawPath.toLowerCase()
-    return lower.includes('%2e%2e') || lower.includes('%2f') || lower.includes('%5c')
-}
-
-/* The raw path of an absolute request URL: first `/` after the authority up
-   to the query. Requests never carry a fragment, so `?` is the only cutoff. */
-function rawPathPortion(rawUrl: string): string {
-    const queryStart = rawUrl.indexOf('?')
-    const pathEnd = queryStart === -1 ? rawUrl.length : queryStart
-    const schemeEnd = rawUrl.indexOf('://')
-    const pathStart = rawUrl.indexOf('/', schemeEnd === -1 ? 0 : schemeEnd + 3)
-    if (pathStart === -1 || pathStart >= pathEnd) {
-        return ''
-    }
-    return rawUrl.slice(pathStart, pathEnd)
-}