@abide/abide 0.123.3 → 0.124.0

package/src/compiler/appLints.ts

@@ -0,0 +1,109 @@
+import { AMBIENT_SOURCES, ambientReadsIn } from './ambientReadsIn.ts'
+import { argsDefaultsIn } from './argsDefaultsIn.ts'
+import {
+    byPlace,
+    type Diagnosis,
+    type Finding,
+    placedFindings,
+} from './Diagnostics.ts'
+import { projectShadow } from './projectShadow.ts'
+import type { ParsedSource } from './readSources.ts'
+import type { ShadowHost } from './ShadowHost.ts'
+import { ShadowMap } from './ShadowMap.ts'
+
+/**
+ * What the build refuses and warns on in the app's `.ts` files and its `.abide` `sources`.
+ *
+ * 11.37 — `ambient`: every read of a request's ambient inside a `global` value's body, as errors.
+ * 11.30 — `unkeyed`: every `args` defaulting a member its body's parameter does not, as warnings.
+ * Both over every `.ts` under `within` and each of `sources` as the shadow its reads registered
+ * for it, because a keyed value is declared in a `.ts` as often as in a `.abide` — one walk of
+ * the files for the two, each finding on its own line of the file an author wrote. `scripts`
+ * as a diagnosis reads it: an editor asking about one page does not walk the app's `.ts`.
+ */
+export async function appLints(
+    host: ShadowHost,
+    within: string,
+    sources: readonly Omit<ParsedSource, 'quiet'>[],
+    scripts: boolean,
+): Promise<{ ambient: Diagnosis[]; unkeyed: Diagnosis[] }> {
+    const ambient: Diagnosis[] = []
+    const unkeyed: Diagnosis[] = []
+    await host.ask(async (project) => {
+        const checker = project.checker
+        const ambientPaths = new Map<string, string>()
+        const declared = await Promise.all(
+            AMBIENT_SOURCES.map((source) =>
+                project.program.getSourceFile(source),
+            ),
+        )
+        for (let at = 0; at < AMBIENT_SOURCES.length; at += 1) {
+            const found = declared[at]?.path
+            if (found !== undefined)
+                ambientPaths.set(AMBIENT_SOURCES[at] as string, found)
+        }
+        const authored = new Map<
+            string,
+            { source: (typeof sources)[number]; map: ShadowMap }
+        >()
+        for (const source of sources) {
+            const map = new ShadowMap(
+                host.canonical(source.path),
+                projectShadow(source.file).origins,
+            )
+            authored.set(host.keyOf(map.shadowPath), { source, map })
+        }
+        // A file of the host's own is one of `sources`' shadows or not walked at all: a checked
+        // module is the lowering's, and placed nowhere an author wrote.
+        const files: string[] = []
+        if (scripts)
+            for (const path of host.rootsUnder(project, within)) {
+                if (authored.has(host.keyOf(path)) || !host.holds(path))
+                    files.push(path)
+            }
+        else for (const { map } of authored.values()) files.push(map.shadowPath)
+        await Promise.all(
+            files.map(async (path) => {
+                const sourceFile = await project.program.getSourceFile(path)
+                if (sourceFile === undefined) return
+                const [reads, defaults] = await Promise.all([
+                    ambientPaths.size === 0
+                        ? []
+                        : ambientReadsIn(checker, sourceFile, ambientPaths),
+                    argsDefaultsIn(checker, sourceFile),
+                ])
+                if (reads.length === 0 && defaults.length === 0) return
+                const shadow = authored.get(host.keyOf(path))
+                const source = shadow?.source
+                const text =
+                    source === undefined
+                        ? await Bun.file(path).text()
+                        : source.text
+                const place = (at: number): number =>
+                    shadow === undefined ? at : shadow.map.toSource(path, at)
+                const named = source?.path ?? path
+                const ambientReads: Finding[] = []
+                for (const read of reads)
+                    ambientReads.push({
+                        at: read.at,
+                        message: `abide: a \`global\` value's body reads \`${read.ambient}\`, which belongs to the request it was built in — every later request would be answered with this one's. Take it out of the body, or drop \`global\`. RULEBOOK 11.37.`,
+                    })
+                ambient.push(
+                    ...placedFindings(
+                        named,
+                        text,
+                        ambientReads,
+                        place,
+                        'error',
+                    ),
+                )
+                unkeyed.push(
+                    ...placedFindings(named, text, defaults, place, 'warning'),
+                )
+            }),
+        )
+    })
+    ambient.sort(byPlace)
+    unkeyed.sort(byPlace)
+    return { ambient, unkeyed }
+}

package/src/compiler/checkedShadow.ts

@@ -40,7 +40,7 @@ export type CheckedShadow = {
 
 /**
  * What a checked module's default export is declared as. Scaffolding, so a jump to it is a jump to
- * the component's file (`TypeSession.inspect`).
+ * the component's file (`LoweredFile.inspect`).
  */
 export const COMPONENT_STAND_IN = '__component'
 

package/src/compiler/classifyRead.ts

@@ -46,7 +46,8 @@ export type Read = {
      * `value` lowers to `n()`; `asWritten` stays as written (`n.set(v)`, 31.5); `member` is one of
      * the `Reactive`'s own members referenced rather than called, named by `path`; `call` is the
      * explicit `n()` (31.7), which `arguments` says was given any; `shorthand` is `{ n }`;
-     * `write` and `update` are 31.4, and 31.8 where `path` is not empty.
+     * `write` and `update` are 31.4, and 31.8 where `path` is not empty. `mutate` is 31.9: an
+     * array mutator called through `path`, its `value` the call from the receiver's end.
      *
      * 33's five: the `props<Props>()` call, which lowers to the record the caller passed; the pair
      * that brackets a binding element's initializer, which together make a default an accessor;
@@ -63,6 +64,7 @@ export type Read = {
         | 'shorthand'
         | 'write'
         | 'update'
+        | 'mutate'
         | 'props'
         | 'defaultOpen'
         | 'defaultClose'
@@ -244,6 +246,7 @@ export function classifyPropRead(node: Node): Read | undefined {
 export function classifyRead(
     node: Node,
     valueMember = false,
+    mutator = false,
 ): Read | undefined {
     const parent = node.parent
     if (isNotARead(parent)) return undefined
@@ -325,6 +328,18 @@ export function classifyRead(
         top = up
     }
 
+    // 31.9 — the walk took the mutator's own name as a step: it is the call, not the path.
+    if (
+        mutator &&
+        isPropertyAccessExpression(top) &&
+        isCallExpression(top.parent)
+    ) {
+        read.path.pop()
+        read.shape = 'mutate'
+        read.to = top.parent.end
+        read.value = { start: top.expression.end, end: top.parent.end }
+        return read
+    }
     const outer = top.parent
     if (isAssigned(outer, top)) {
         read.shape = 'write'

package/src/compiler/compileApp.ts

@@ -6,9 +6,9 @@ import {
     type CompiledFile,
     resolvedFile,
 } from '#server/abideModules.ts'
-import type { Mount } from '#server/answerRpc.ts'
 import { CLIENT_ENTRY } from '#server/CLIENT_BUILD.ts'
 import { COMPONENT_QUERY } from '#server/MODULE_QUERIES.ts'
+import type { Mount } from '#server/mountHandlers.ts'
 import { ROUTES_TABLE, SERVER_TABLE } from '#server/TABLES.ts'
 import { VIRTUAL_DIRECTORY } from '#server/VIRTUAL_DIRECTORY.ts'
 import { CLIENT_ADDRESS } from '#shared/ADDRESSES.ts'
@@ -84,7 +84,7 @@ export type AppChecker = {
      * The same nearest tsconfig and package.json, neither touched since. Asked rather than heard,
      * because either can sit above the watched root — the dogfood's do — and either changes what
      * every file resolves to. Where it is, the session is told every move `saw` held
-     * (`TypeSession.edited`); where it is not, `KeptChecker` opens another.
+     * (`ShadowHost.edited`); where it is not, `KeptChecker` opens another.
      */
     current: () => boolean
     close: () => Promise<void>

package/src/compiler/declaredExports.ts

@@ -1,4 +1,4 @@
-import type { CallExpression, Node } from 'typescript/unstable/ast'
+import type { CallExpression, Node, SourceFile } from 'typescript/unstable/ast'
 import { SyntaxKind } from 'typescript/unstable/ast'
 import {
     isArrayLiteralExpression,
@@ -27,7 +27,7 @@ import {
     type UnionOrIntersectionType,
 } from 'typescript/unstable/async'
 
-import type { Mount } from '#server/answerRpc.ts'
+import type { Mount } from '#server/mountHandlers.ts'
 import type { CopyOptions } from '#shared/CopyOptions.ts'
 import {
     type Defaults,
@@ -51,6 +51,7 @@ import {
     isReactiveMember,
     valueTypeOf,
 } from './reactiveTypes.ts'
+import type { ShadowHost } from './ShadowHost.ts'
 
 /**
  * Every value each module exports, with the abide method that declares it.
@@ -62,15 +63,40 @@ import {
  * namespace is abide's, and an app's own function of that spelling is not. A type is not an
  * export here: it is erased, and has no address to answer at.
  *
- * `projectName` is the tsconfig the project was opened on, which a module outside it is refused by.
- * 38.33 — WHAT IS REFUSED OF A MODULE IS REFUSED AT ITS FILE, `named[at]` for `paths[at]`, every
- * export read either way: a module with a refusal is `undefined`, so nothing refuses it twice.
+ * Per module's `path`: a module `onDisk` is a file the host may not hold yet, which is made a root
+ * of the project where it has to be (`ShadowHost.ask`); a projection is one the host registered.
+ * Where the checker opened no project, every module exports nothing.
+ *
+ * 38.33 — WHAT IS REFUSED OF A MODULE IS REFUSED AT ITS `file`, every export read either way: a
+ * module with a refusal — one outside the project among them — is `undefined`, so nothing refuses
+ * it twice.
  */
 export async function declaredExports(
+    host: ShadowHost,
+    modules: readonly { path: string; file: string; onDisk: boolean }[],
+    refusals: Diagnostics,
+): Promise<Map<string, DeclaredExport[] | undefined>> {
+    const declared = new Map<string, DeclaredExport[] | undefined>()
+    if (modules.length === 0) return declared
+    const onDisk: string[] = []
+    for (const module of modules) if (module.onDisk) onDisk.push(module.path)
+    const asked = await host.ask(
+        (project) => exportsIn(host, project, modules, refusals),
+        { modules: onDisk },
+    )
+    for (let at = 0; at < modules.length; at += 1)
+        declared.set(
+            (modules[at] as (typeof modules)[number]).path,
+            asked === undefined ? [] : asked[at],
+        )
+    return declared
+}
+
+/** What each of `modules` exports in `project`, in their order (`declaredExports`). */
+async function exportsIn(
+    host: ShadowHost,
     project: Project,
-    projectName: string,
-    paths: readonly string[],
-    named: readonly string[],
+    modules: readonly { path: string; file: string }[],
     refusals: Diagnostics,
 ): Promise<(DeclaredExport[] | undefined)[]> {
     const checker = project.checker
@@ -81,16 +107,17 @@ export async function declaredExports(
         ?.path
     const abide = await abideIn(project)
     return allSettled(
-        paths.map(async (path, at) => {
-            const file = named[at] as string
-            const sourceFile = await project.program.getSourceFile(path)
-            if (sourceFile === undefined) {
-                refusals.at(
-                    file,
-                    new Error(
-                        `abide: ${path} is not inside the project ${projectName}, so what it exports cannot be read (RULEBOOK 16.73). Give the app a tsconfig whose include reaches it.`,
-                    ),
+        modules.map(async ({ path, file }) => {
+            let sourceFile: SourceFile
+            try {
+                sourceFile = await host.sourceFile(
+                    project,
+                    path,
+                    path,
+                    'what it exports cannot be read (RULEBOOK 16.73)',
                 )
+            } catch (thrown) {
+                refusals.at(file, thrown)
                 return undefined
             }
             const module = await checker.getSymbolAtLocation(sourceFile)

package/src/compiler/diagnoseSources.ts

@@ -0,0 +1,232 @@
+import type { AppLayout, PlacedSource } from './appLayout.ts'
+import { checkedShadow, moduleConfigShadow } from './checkedShadow.ts'
+import {
+    byPlace,
+    type Diagnosis,
+    type Finding,
+    placedFindings,
+} from './Diagnostics.ts'
+import { lineOf } from './lineOf.ts'
+import { LoweredFile } from './LoweredFile.ts'
+import { CHECKED_VALUES } from './Lowering.ts'
+import { projectShadow } from './projectShadow.ts'
+import type { ReadSource } from './readSources.ts'
+import { routesDeclaration } from './routesDeclaration.ts'
+import type { ShadowEdit, ShadowHost } from './ShadowHost.ts'
+import { ShadowMap } from './ShadowMap.ts'
+
+/** One source a diagnosis lowers: read, placed where it is a page or a layout, and maybe quiet. */
+export type DiagnosedSource = Omit<ReadSource, 'quiet'> &
+    Partial<Pick<PlacedSource, 'kind' | 'route'>> & {
+        quiet?: boolean
+    }
+
+/**
+ * The checker's diagnostics for each `.abide` source and the app's `.ts` roots, and each source's
+ * lowering.
+ *
+ * 38.3 — WHAT THE CHECKER SAYS ABOUT EACH FILE AS IT RUNS, placed on the `.abide` line. Each
+ * source is checked as its lowered program (`checkedShadow`), which is registered for the life
+ * of the host beside its shadow for the reason a shadow is; and every `.ts` root of the
+ * project under the app's root is checked as it stands, where `scripts` asks for them — an editor
+ * asking about one page does not want the whole app. `sources` carry their text, which is what
+ * a position is a line of. A `quiet` source is lowered and not reported on: a component an
+ * editor's page imports, which is there for the props the page is held to (33.4).
+ *
+ * `app` is the app the sources are checked in (`appLayout`): its route table, which `url`'s
+ * literal is held to (30.26), and its handler files, which type `Config` (27.13). A source placed
+ * as a page or a layout carries its `kind` and `route`, which its `route.params` is typed by (23.9).
+ *
+ * `refused` is the path of every source whose checked lowering refused, which `diagnoses` has
+ * reported at its line — `abide check` emits the rest of the app without them. `lowered` is each
+ * source's lowering, which the host keeps for an editor's questions about it (`LoweredFile`) —
+ * none where the checker opened no project.
+ */
+export async function diagnoseSources(
+    host: ShadowHost,
+    sources: readonly DiagnosedSource[],
+    app: Pick<AppLayout, 'root' | 'addresses' | 'handlers' | 'routes'>,
+    scripts: boolean,
+): Promise<{
+    diagnoses: Diagnosis[]
+    refused: Set<string>
+    lowered: LoweredFile[]
+}> {
+    const within = app.root
+    const edit: ShadowEdit = { created: [], changed: [] }
+    const checked: {
+        source: DiagnosedSource
+        map: ShadowMap
+        refusals: readonly Finding[]
+    }[] = []
+    for (const source of sources) {
+        const shadow = checkedShadow(
+            source.file,
+            source.answer,
+            (source.kind === 'page' || source.kind === 'layout') &&
+                source.route !== undefined
+                ? { route: source.route, kind: source.kind }
+                : undefined,
+        )
+        const map = new ShadowMap(
+            host.canonical(source.path),
+            projectShadow(source.file).origins,
+            shadow.origins,
+        )
+        host.write(map.checkedPath, shadow.text, edit)
+        // 23.19 — a package's page an editor opens is reported on, so its checked module is a
+        // root of the project as its shadow is (`reactiveReads`).
+        if (!source.quiet) host.openOutside(source.path, map.checkedPath, edit)
+        checked.push({ source, map, refusals: shadow.refusals })
+    }
+    // 34.6 — WHAT THE BUNDLER RESOLVES AND THE CHECKER CANNOT: a stylesheet imported for its
+    // effect, and (34.21) markdown imported as text into a `.ts`, which bun's own types leave
+    // out where they declare `.txt`. Declared in a file of its own at the app's root, which is
+    // a script, because a pattern module can only be declared outside a module.
+    host.write(
+        `${host.canonical(within)}/${AMBIENT}`,
+        AMBIENT_DECLARATIONS,
+        edit,
+    )
+    // 27.13 — what a handler file defaults, beside it.
+    for (const handler of app.handlers) {
+        const at = `${host.canonical(handler.path)}${CONFIG_SUFFIX}`
+        const shadow = handler.hooks.includes('onConfig')
+            ? moduleConfigShadow(handler.text)
+            : undefined
+        // One that stops filing keeps its place and declares nothing, so the next snapshot is
+        // told it moved.
+        if (shadow !== undefined || host.holds(at))
+            host.write(at, shadow ?? 'export {}\n', edit)
+    }
+    // 30.26 — THE APP'S ROUTE TABLE, which `url`'s literal is held to: every page the build
+    // routes, declared into abide's own `Routes`. A module rather than a script, since only a
+    // module augments one.
+    host.write(
+        `${host.canonical(within)}/${ROUTES_DECLARATION}`,
+        routesDeclaration(app.addresses, app.routes),
+        edit,
+    )
+    const refused = new Set<string>()
+    for (const { source, refusals } of checked)
+        if (refusals.length > 0) refused.add(source.path)
+    const answered = await host.ask(
+        async (project) => {
+            const program = project.program
+            // `path` is the file the author wrote, which for a checked module is not the file asked.
+            const report = async (
+                asked: string,
+                path: string,
+                place: (position: number) => { line: number; column: number },
+            ): Promise<Diagnosis[]> => {
+                const [syntactic, semantic] = await Promise.all([
+                    program.getSyntacticDiagnostics(asked),
+                    program.getSemanticDiagnostics(asked),
+                ])
+                const said: Diagnosis[] = []
+                for (const diagnostic of [...syntactic, ...semantic])
+                    said.push({
+                        path,
+                        ...place(diagnostic.pos),
+                        code: diagnostic.code,
+                        category: CATEGORIES[diagnostic.category] ?? 'error',
+                        // A checked module's own names are the lowering's, and read as the author's.
+                        message: flatten(diagnostic).replaceAll(
+                            `${CHECKED_VALUES}.`,
+                            '',
+                        ),
+                    })
+                return said
+            }
+            const reports: Promise<Diagnosis[]>[] = []
+            const refusing: Diagnosis[] = []
+            const lowered: LoweredFile[] = []
+            for (const { source, map, refusals } of checked) {
+                const lowering = new LoweredFile(host, source.text, map)
+                host.keep(lowering)
+                lowered.push(lowering)
+                if (source.quiet) continue
+                // A refusal is at a projection offset (`Lowering.refusals`).
+                refusing.push(
+                    ...placedFindings(
+                        source.path,
+                        source.text,
+                        refusals,
+                        (at) => map.toSource(map.shadowPath, at),
+                        'error',
+                    ),
+                )
+                reports.push(
+                    report(map.checkedPath, source.path, (position) =>
+                        lineOf(
+                            source.text,
+                            map.toSource(map.checkedPath, position),
+                        ),
+                    ),
+                )
+            }
+            const standing = scripts ? host.rootsUnder(project, within) : []
+            for (const path of standing)
+                if (!host.holds(path))
+                    reports.push(
+                        Bun.file(path)
+                            .text()
+                            .then((text) =>
+                                report(path, path, (position) =>
+                                    lineOf(text, position),
+                                ),
+                            ),
+                    )
+            const reported = [
+                ...refusing,
+                ...(await Promise.all(reports)).flat(),
+            ]
+            reported.sort(byPlace)
+            // A component's props type is checked twice — in its `props` call and in what a tag is
+            // held to (`checkedShadow`) — and both copies place a finding in it at the one place
+            // written.
+            const diagnoses: Diagnosis[] = []
+            const placed = new Set<string>()
+            for (const diagnosis of reported) {
+                const key = `${diagnosis.path}:${diagnosis.line}:${diagnosis.column}:${diagnosis.code}:${diagnosis.message}`
+                if (placed.has(key)) continue
+                placed.add(key)
+                diagnoses.push(diagnosis)
+            }
+            return { diagnoses, lowered }
+        },
+        { edit },
+    )
+    return {
+        diagnoses: answered?.diagnoses ?? [],
+        refused,
+        lowered: answered?.lowered ?? [],
+    }
+}
+
+const AMBIENT = 'abide-check.d.ts'
+const ROUTES_DECLARATION = 'abide-routes.d.ts'
+const AMBIENT_DECLARATIONS = `declare module '*.css' {}
+declare module '*.md' {
+    const text: string
+    export default text
+}
+`
+
+/** What a module that is no `.abide` is checked beside as, for the `Config` it files (27.13). */
+const CONFIG_SUFFIX = '.config-shadow.ts'
+
+/** Indexed by the API's `DiagnosticCategory`. */
+const CATEGORIES = ['warning', 'error', 'suggestion', 'message'] as const
+
+function flatten(diagnostic: {
+    text: string
+    messageChain?:
+        readonly { text: string; messageChain?: unknown }[] | undefined
+}): string {
+    let message = diagnostic.text
+    const chain = diagnostic.messageChain ?? []
+    for (const link of chain)
+        message += `\n  ${flatten(link as Parameters<typeof flatten>[0]).replaceAll('\n', '\n  ')}`
+    return message
+}

package/src/compiler/formatAbide.ts

@@ -669,12 +669,11 @@ function unwrap(entry: string, unit: string): string {
     if (inner.endsWith(';')) inner = inner.slice(0, -1)
     if (inner.endsWith(')')) inner = inner.slice(0, -1)
     if (!inner.startsWith('\n')) return inner.trimEnd()
-    inner = shiftLines(
-        inner.slice(1),
-        (line) =>
-            line.startsWith(unit) ? line.slice(unit.length) : line.trimStart(),
-        'ts',
-    ).trimEnd()
+    const outdent = (line: string): string =>
+        line.startsWith(unit) ? line.slice(unit.length) : line.trimStart()
+    // The first line opens the expression, so it is never inside a template literal — and
+    // `shiftLines` leaves it alone for that reason, which is why it is outdented here.
+    inner = outdent(shiftLines(inner.slice(1), outdent, 'ts')).trimEnd()
     return inner.endsWith(',') ? inner.slice(0, -1) : inner
 }
 

package/src/compiler/handlersUnder.ts

@@ -9,9 +9,9 @@
 // each module exports and which call declares each (16.73) — which is also what makes an export
 // that is not a handler a refusal here rather than an address that silently never answers.
 
-import type { Mount } from '#server/answerRpc.ts'
 import { frameworkRouteRefusal } from '#server/appTree.ts'
 import { handlerFileMount } from '#server/handlerFileMount.ts'
+import type { Mount } from '#server/mountHandlers.ts'
 import { PRIVATE_EXPORT } from '#server/PRIVATE_EXPORT.ts'
 import { surfaceName } from '#server/surfaceOf.ts'
 import { PRIVATE_HANDLERS_ADDRESS } from '#shared/ADDRESSES.ts'
@@ -54,40 +54,22 @@ export async function handlersUnder(
     const serving: Source[] = []
     for (const source of sources)
         if (source.file.servers.length > 0) serving.push(source)
-    const paths: string[] = []
-    const named: string[] = []
-    for (const file of files) {
-        paths.push(file.path)
-        named.push(file.relative)
-    }
-    // The project is asked of below, so the session keeps its snapshot until then.
-    using _held = session.hold()
-    const project = await session.projectWith(paths)
-    for (const source of serving) {
-        paths.push(session.projectionOf(source.path))
-        named.push(source.path)
-    }
+    const host = session.host
+    const modules: { path: string; file: string; onDisk: boolean }[] = []
+    for (const file of files)
+        modules.push({ path: file.path, file: file.relative, onDisk: true })
+    for (const source of serving)
+        modules.push({
+            path: host.projectionOf(source.path),
+            file: source.path,
+            onDisk: false,
+        })
     // A module whose read was refused is `undefined`, refused at its file already.
-    const declared =
-        project === undefined || paths.length === 0
-            ? paths.map(() => [])
-            : await declaredExports(
-                  project,
-                  session.tsconfig,
-                  paths,
-                  named,
-                  diagnostics,
-              )
+    const declared = await declaredExports(host, modules, diagnostics)
     const mounts: Mount[] = []
     const names = new Map<string, string>()
-    for (let at = 0; at < files.length; at += 1) {
-        const {
-            relative,
-            route: address,
-            scope,
-            matchers,
-        } = files[at] as (typeof files)[number]
-        const exported = declared[at]
+    for (const { path, relative, route: address, scope, matchers } of files) {
+        const exported = declared.get(path)
         if (exported === undefined) continue
         try {
             const handler = exported.find((each) => each.name === 'default')
@@ -125,12 +107,11 @@ export async function handlersUnder(
             diagnostics.at(relative, thrown)
         }
     }
-    for (let at = 0; at < serving.length; at += 1) {
-        const { relative, position, place, scope } = serving[at] as Source
+    for (const { path, relative, position, place, scope } of serving) {
         // 34.24 — a dependency's file answers where a mount places it, and its handlers below the
         // path it has there.
         const below = place === 'dependency' ? relative : position
-        for (const each of declared[files.length + at] ?? []) {
+        for (const each of declared.get(host.projectionOf(path)) ?? []) {
             if (each.method === undefined) continue
             if (!each.name.startsWith(PRIVATE_EXPORT)) continue
             const name = each.name.slice(PRIVATE_EXPORT.length)