@abide/abide 0.100.0 → 0.102.0

package/src/compiler/reactiveTypes.ts

@@ -76,8 +76,8 @@ async function everyPresentMember(
     return present
 }
 
-// Where abide declares `Reactive`, `props`, `route` and `Selection`, found in the project the way
-// `METHODS_SOURCE` is.
+// Where abide declares `Reactive`, `props`, `route`, `Selection` and `onConfig`, found in the project
+// the way `METHODS_SOURCE` is.
 const REACTIVE_SOURCE = Bun.fileURLToPath(
     new URL('../shared/reactive/Reactive.ts', import.meta.url),
 )
@@ -90,16 +90,20 @@ const ROUTE_SOURCE = Bun.fileURLToPath(
 const SELECTION_SOURCE = Bun.fileURLToPath(
     new URL('../shared/reactive/index.ts', import.meta.url),
 )
+const HOOKS_SOURCE = Bun.fileURLToPath(
+    new URL('../server/hooks.ts', import.meta.url),
+)
 
 /**
- * Abide's own `Reactive`, `Selection`, `props` and `route` declarations, as this project's checker
- * names them.
+ * Abide's own `Reactive`, `Selection`, `props`, `route` and `onConfig` declarations, as this
+ * project's checker names them.
  *
  * 31.3 — A `Reactive` IS TOLD BY ITS DECLARATION, never by how it prints. Every instantiation of
  * abide's `Reactive` carries the symbol of the one type literal it is declared as, whatever alias
  * or re-export the app reached it through — so `type Counter = Reactive<number>` is one, and an
  * app's own type that happens to be spelled `Reactive` is not. `undefined` where the project never
- * reaches abide, and then nothing in it is one. `props` is abide's file as the checker names it.
+ * reaches abide, and then nothing in it is one. `props` and `onConfig` are abide's files as the
+ * checker names them.
  */
 export type Abide = {
     /** 23.9 — abide's `route`, as the file the checker names it. */
@@ -110,14 +114,17 @@ export type Abide = {
      */
     selection: CheckedSymbol | undefined
     props: string | undefined
+    /** 27.13 — abide's `onConfig`, as the file the checker names it. */
+    onConfig: string | undefined
 }
 
 export async function abideIn(project: Project): Promise<Abide> {
-    const [declares, props, selects, route] = await Promise.all([
+    const [declares, props, selects, route, hooks] = await Promise.all([
         project.program.getSourceFile(REACTIVE_SOURCE),
         project.program.getSourceFile(PROPS_SOURCE),
         project.program.getSourceFile(SELECTION_SOURCE),
         project.program.getSourceFile(ROUTE_SOURCE),
+        project.program.getSourceFile(HOOKS_SOURCE),
     ])
     let selection: CheckedSymbol | undefined
     for (const statement of selects?.statements ?? [])
@@ -142,7 +149,13 @@ export async function abideIn(project: Project): Promise<Abide> {
             reactive = await literal?.getSymbol()
             break
         }
-    return { route: route?.path, reactive, selection, props: props?.path }
+    return {
+        route: route?.path,
+        reactive,
+        selection,
+        props: props?.path,
+        onConfig: hooks?.path,
+    }
 }
 
 /**

package/src/compiler/readSources.ts

@@ -13,6 +13,8 @@ export type ParsedSource = {
     text: string
     file: AbideFile
     quiet: boolean
+    /** 23.19 — where a mounted package's file stands in the app; `undefined` for one at its own path. */
+    position: string | undefined
 }
 
 /** One `.abide` as the emitters and the checked lowering take it: parsed, and answered. */
@@ -25,7 +27,12 @@ export type ReadSource = ParsedSource & { answer: CheckerAnswer }
  * parsed around it — a quiet one's is nobody's. Without it the refusal is thrown, as a build stops.
  */
 export function parseSources(
-    sources: readonly { path: string; text: string; quiet?: boolean }[],
+    sources: readonly {
+        path: string
+        text: string
+        quiet?: boolean
+        position?: string
+    }[],
     refused?: Diagnosis[],
 ): ParsedSource[] {
     const parsed: ParsedSource[] = []
@@ -39,7 +46,13 @@ export function parseSources(
             if (!quiet) refused.push(refusal(source.path, thrown))
             continue
         }
-        parsed.push({ path: source.path, text: source.text, file, quiet })
+        parsed.push({
+            path: source.path,
+            text: source.text,
+            file,
+            quiet,
+            position: source.position,
+        })
     }
     return parsed
 }

package/src/compiler/readsIn.ts

@@ -8,6 +8,7 @@ import {
     isCallExpression,
     isClassDeclaration,
     isEnumDeclaration,
+    isExpressionStatement,
     isFunctionDeclaration,
     isFunctionExpression,
     isIdentifier,
@@ -66,8 +67,9 @@ import { trackingWarnings } from './trackingWarnings.ts'
 export type ShadowSpans = {
     /** Where the shadow's scripts end and its template begins. */
     scriptsEnd: number
-    /** The `<script module>` bodies, and the `<script>` bodies, in the shadow. */
+    /** The `<script module>`, `<script server>` and `<script>` bodies, in the shadow. */
     modules: Span
+    servers: Span
     scripts: Span
     positions: PositionTable
 }
@@ -123,7 +125,8 @@ export async function readsIn(
     sourceFile: SourceFile,
     shadowPath: string,
     spans: ShadowSpans,
-    abidePath: string,
+    // The file below the app's root, which its route is read off (23.14).
+    routedPath: string,
     file: AbideFile,
 ): Promise<{ answer: CheckerAnswer; warnings: Finding[] }> {
     // A destructuring pattern binds names this does not see, and that is 31.12's case.
@@ -185,7 +188,14 @@ export async function readsIn(
     // Awaited after the round trips below, so a 33.14 refusal would reject with nothing
     // listening and be reported unhandled; `await props` still throws it.
     props.catch(() => {})
-    const params = routeReads(checker, abide, sourceFile, abidePath, reads)
+    const params = routeReads(checker, abide, sourceFile, routedPath, reads)
+    const configs = configReads(
+        checker,
+        abide,
+        sourceFile,
+        spans.servers,
+        reads,
+    )
     // No name is no round trip to ask about none.
     const symbols =
         names.length === 0 ? [] : await checker.getSymbolAtLocation(names)
@@ -249,6 +259,7 @@ export async function readsIn(
     await Promise.all(holding)
     await props
     await params
+    await configs
     const statics = new Set<number>()
     const expressions = spans.positions.nodesIn(
         sourceFile,
@@ -683,7 +694,7 @@ const ROUTE_MEMBERS = new Set(['url', 'params', 'name', 'navigating'])
  * a name, and this read is spelled as a member.
  *
  * 23.9 — AND `route.params` IN A PAGE OR A LAYOUT IS WHAT THAT FILE'S OWN ROUTE PROMISES. The file
- * is the route: `ui/pages/media/[id]/page.abide` only ever renders where `id` matched, so its
+ * is the route: `media/[id]/page.abide` only ever renders where `id` matched, so its
  * `route.params` has an `id`, and a layout's has its own segments and whatever a page below adds.
  * Only the checker reads that — the running module reads the one `route` every page shares.
  */
@@ -691,11 +702,11 @@ async function routeReads(
     checker: Checker,
     abide: Abide,
     sourceFile: Node,
-    abidePath: string,
+    routedPath: string,
     reads: Read[],
 ): Promise<void> {
     if (abide.route === undefined) return
-    const routed = fileKind(abidePath)
+    const routed = fileKind(routedPath)
     const kind = routed === 'page' || routed === 'layout' ? routed : undefined
     const accesses: Node[] = []
     const owners: Node[] = []
@@ -714,7 +725,7 @@ async function routeReads(
     sourceFile.forEachChild(visit)
     if (owners.length === 0) return
     const symbols = await checker.getSymbolAtLocation(owners)
-    const pattern = routeOf(abidePath)
+    const pattern = routeOf(routedPath)
     for (let at = 0; at < accesses.length; at += 1) {
         const symbol = symbols[at]
         if (symbol === undefined) continue
@@ -777,6 +788,49 @@ function refuseDeclared(
             )
 }
 
+/**
+ * 27.13 — each `onConfig(…)` standing as a statement at the top of a `<script server>`, as a read of
+ * its callee, pushed onto `reads`.
+ *
+ * The callee says which are abide's, as `props`'s does. A call anywhere else — inside a function,
+ * or handing its unfiling back to a name — is filed all the same, and declares nothing.
+ */
+async function configReads(
+    checker: Checker,
+    abide: Abide,
+    sourceFile: Node & { statements: readonly Node[] },
+    servers: Span,
+    reads: Read[],
+): Promise<void> {
+    if (abide.onConfig === undefined) return
+    const callees: Node[] = []
+    for (const statement of sourceFile.statements) {
+        const start = statement.getStart()
+        if (start < servers.start) continue
+        if (start >= servers.end) break
+        if (
+            isExpressionStatement(statement) &&
+            isCallExpression(statement.expression) &&
+            isIdentifier(statement.expression.expression)
+        )
+            callees.push(statement.expression.expression)
+    }
+    if (callees.length === 0) return
+    const named = await checker.getSymbolAtLocation(callees)
+    for (let at = 0; at < callees.length; at += 1) {
+        const symbol = named[at]
+        if (symbol === undefined) continue
+        const callee = await aliasedSymbol(checker, symbol)
+        if (
+            callee.name !== 'onConfig' ||
+            callee.valueDeclaration?.path !== abide.onConfig
+        )
+            continue
+        const node = callees[at] as Node
+        reads.push(newRead(node.getStart(), node.end, 'config'))
+    }
+}
+
 /**
  * The reads a `props<Props>()` destructuring contributes, pushed onto `reads`.
  *

package/src/compiler/renderMarkup.ts

@@ -108,7 +108,7 @@ export const HEADS = '__heads'
  * EVERY MARKUP POSITION THAT EVALUATES AN AUTHOR EXPRESSION, rather than the two that were found
  * first. A GUARD HERE IS HALF A MECHANISM — it trades a throw for a HOLE, and something on the
  * client has to fill that hole once the value lands: a text slot has `runHere` and `textHere`, a
- * `{#for}` has `List.hydrate`'s count check, an attribute has its own binding re-running on the
+ * `{#for}` has `List.hydrate`'s count check, an attribute has its own binding rerunning on the
  * value that landed (32.3), and the `{#if}` chain has `isEmptyRegion` — which is why that one is
  * guarded at the REGION rather than per subject, and says so at its own arm. The ESCAPER STAYS
  * OUTSIDE: absence is `undefined` here and what it means is already decided where it lands (see
@@ -296,7 +296,7 @@ function renderPosition(
             `abide: a ${at.kind} position holds a ${node.kind} node.`,
         )
 
-    // 32.17 — A CAPITALISED TAG IS AN INVOCATION, and the capital is the whole of the
+    // 32.17 — A CAPITALIZED TAG IS AN INVOCATION, and the capital is the whole of the
     // distinction. It is emitted as a CALL, so the child's own module renders it.
     if (isComponentTag(node.tag)) return invocationMarkup(node, at, lowering)
 
@@ -536,7 +536,7 @@ function serverComponent(
     // standing side by side are two instances, each creating what no ancestor holds (10.6).
     const { opened, closed } = shareScope(lowering, '')
     return `function ${component.name}(${PROPS} = {}) {
-${opened}${head}${setup}${definitions(sink, lowering)}return { head: '', body: ${renderMarkup(sink, lowering, SERVER_LANE)} }${closed}
+${opened}${head}${setup}${definitions(sink, lowering)}return { head: '', body: ${renderMarkup(sink, lowering, SERVER_LANE)}, document: undefined }${closed}
 }`
 }
 

package/src/compiler/scaffold.ts

@@ -1,5 +1,6 @@
 // 38.1 — `abide scaffold <name>`: THE LAYOUT EVERY ABIDE APP HAS, written into `<name>`. There is
-// nothing to choose, because what is scaffolded is the three seams and the files the commands read.
+// nothing to choose, because what is scaffolded is a route, the shell and the hooks — the files the
+// commands read.
 // A file that is already there is left as it is and reported skipped, so a scaffold run over a
 // half-made project finishes it rather than overwriting it.
 
@@ -28,20 +29,26 @@ function filesFor(name: string): Record<string, string> {
                 name,
                 private: true,
                 type: 'module',
+                // 34.24 — `prepare` runs on `bun install`, so a `.ts` importing a `.abide` is typed
+                // before any other abide command has run; and never fails it, as it would where
+                // `package.json` is installed before `src` is there to sync (38.26).
                 scripts: {
+                    prepare: 'abide sync || true',
+                    // 38.103 — the checker over `.abide`, which `tsc` does not read.
+                    check: 'abide check',
                     dev: 'abide dev',
                     build: 'abide build',
                     start: 'abide start',
                 },
-                // TWO TARGETS A SEAM, because an extensionless specifier is how the seams are
-                // written and only bun probes for the extension: TypeScript takes an `imports`
-                // target as the exact file, so `#server/database` alone left every name it
-                // imports `any` and the checker could not type one of them (31.3). The first
-                // target is what bun resolves, and the one a `.ts` or `.abide` specifier needs.
+                // ONE ALIAS FOR THE SOURCE, and two targets for it, because an extensionless
+                // specifier is how an import is written and only bun probes for the extension:
+                // TypeScript takes an `imports` target as the exact file, so `#src/media/server/db`
+                // alone left every name it imports `any` and the checker could not type one of
+                // them (31.3). The first target is what bun resolves, and the one a `.ts` or
+                // `.abide` specifier needs. Which side a module is on is its directory's to say
+                // (36.10), not its alias's.
                 imports: {
-                    '#ui/*': ['./src/ui/*', './src/ui/*.ts'],
-                    '#server/*': ['./src/server/*', './src/server/*.ts'],
-                    '#shared/*': ['./src/shared/*', './src/shared/*.ts'],
+                    '#src/*': ['./src/*', './src/*.ts'],
                 },
                 dependencies: { '@abide/abide': ABIDE_DEPENDENCY },
                 // `Bun`, `bun:sqlite` and the rest of the runtime a server module reaches for are
@@ -53,8 +60,21 @@ function filesFor(name: string): Record<string, string> {
         )}\n`,
         'tsconfig.json': `${JSON.stringify(
             // TypeScript 7 includes no `@types` package it is not named, so the runtime's is named.
+            // 34.24 — `rootDirs` and the `#src/*` path reach what abide writes to `.abide/types`,
+            // where a `.ts` importing a `.abide` finds the names it exports.
             {
-                compilerOptions: { ...COMPILER_OPTIONS, types: ['bun'] },
+                compilerOptions: {
+                    ...COMPILER_OPTIONS,
+                    types: ['bun'],
+                    rootDirs: ['.', '.abide/types'],
+                    paths: {
+                        '#src/*': [
+                            './src/*',
+                            './src/*.ts',
+                            './.abide/types/src/*',
+                        ],
+                    },
+                },
                 include: ['src'],
             },
             null,
@@ -81,7 +101,6 @@ export async function scaffold(
     const written: string[] = []
     const skipped: string[] = []
     const files: [string, string | Blob][] = Object.entries(filesFor(name))
-    // The seam both sides import from is there from the first commit, `.gitkeep` and all.
     for (const path of new Bun.Glob('**/*').scanSync({
         cwd: STARTER,
         dot: true,

package/src/compiler/serveLanguage.ts

@@ -1,10 +1,15 @@
-import { type FSWatcher, watch } from 'node:fs' // bun exposes no file watcher of its own
-import { basename, dirname } from 'node:path' // bun exposes no path helpers of its own
+import { existsSync, type FSWatcher, watch } from 'node:fs' // bun exposes no file watcher or sync existence check of its own
+import { dirname } from 'node:path' // bun exposes no path helpers of its own
+import { realOrAsGiven } from '#server/realOrAsGiven.ts'
 import { checkSource } from './checkApp.ts'
 import { type AppChecker, openChecker } from './compileApp.ts'
+import { nearest } from './nearest.ts'
+import { parseAbide } from './parseAbide.ts'
+import { syncTypes } from './syncTypes.ts'
 import type { Diagnosis, Inspection, Place } from './TypeSession.ts'
+import { writeTypes } from './writeTypes.ts'
 
-// 38.12 — `abide lsp`: THE `.abide` LANGUAGE SERVER, OVER STDIO. It is `abide check` (38.3) asked
+// 38.11 — `abide lsp`: THE `.abide` LANGUAGE SERVER, OVER STDIO. It is `abide check` (38.3) asked
 // about one open document at a time, so the squiggle an editor draws and the line CI fails on are
 // one finding rather than two implementations that agree most of the time.
 //
@@ -15,10 +20,14 @@ import type { Diagnosis, Inspection, Place } from './TypeSession.ts'
 // same text.
 //
 // THE APP IS THE DOCUMENT'S. An editor starts this at the root of whatever it has open, which in a
-// monorepo is not an app at all, so each document is checked against the directory above the
-// OUTERMOST `ui/` it sits in (`appRootOf`) — with one checker per app, kept for the session.
+// monorepo is not an app at all, so each document is checked against the root of the NEAREST
+// package above it (`appRootOf`) — with one checker per app, kept for the session.
 // `--root` pins every document to one.
 //
+// THE EDITOR'S SPELLING STOPS HERE. An app opened through a link (`/tmp` is one on macOS) is
+// checked at its real path, the one bun resolves every import to (`openChecker`), so a path is
+// made real on its way in (`placed`) and spelled under the link again on its way out (`spelled`).
+//
 // ONE CHECK AT A TIME. The checker holds one snapshot, and two checks interleaving would each
 // register the other's text for a moment; a burst of keystrokes collapses onto the last one.
 
@@ -52,8 +61,33 @@ export async function serveLanguage(
     const timers = new Map<string, ReturnType<typeof setTimeout>>()
     const checkers = new Map<string, AppChecker>()
     const watchers = new Map<string, FSWatcher>()
+    // Each app's real root, to the root the editor reached it by.
+    const links = new Map<string, string>()
     let queue: Promise<void> = Promise.resolve()
 
+    // The document at `uri`, in its app's real spelling; `undefined` where no app holds it.
+    const placed = (uri: string): { app: string; path: string } | undefined => {
+        const path = Bun.fileURLToPath(uri)
+        const given = root ?? appRootOf(path)
+        if (given === undefined) return undefined
+        const app = realOrAsGiven(given)
+        if (app !== given) links.set(app, given)
+        return {
+            app,
+            path: path.startsWith(`${given}/`)
+                ? `${app}${path.slice(given.length)}`
+                : path,
+        }
+    }
+
+    // `path`, real, under the root the editor reached its app by.
+    const spelled = (path: string): string => {
+        for (const [app, given] of links)
+            if (path.startsWith(`${app}/`))
+                return `${given}${path.slice(app.length)}`
+        return path
+    }
+
     const send = (message: object): void => {
         const body = ENCODER.encode(
             JSON.stringify({ jsonrpc: '2.0', ...message }),
@@ -118,8 +152,7 @@ export async function serveLanguage(
                         )
                     // What an open page says may be decided by the file that moved.
                     for (const uri of documents.keys())
-                        if ((root ?? appRootOf(Bun.fileURLToPath(uri))) === app)
-                            check(uri)
+                        if (placed(uri)?.app === app) check(uri)
                 }),
             )
         return checker
@@ -129,18 +162,18 @@ export async function serveLanguage(
         const document = documents.get(uri)
         if (document === undefined) return
         const version = document.version
-        const path = Bun.fileURLToPath(uri)
-        const app = root ?? appRootOf(path)
         // A `.abide` belonging to no app has nothing to be checked against.
-        if (app === undefined) return
+        const at = placed(uri)
+        if (at === undefined) return
+        const { app, path } = at
         let found: Diagnosis[]
         try {
             found = await checkSource(
                 await checkerOf(app),
-                app,
                 path,
                 document.text,
-                (held) => documents.get(Bun.pathToFileURL(held).href)?.text,
+                (held) =>
+                    documents.get(Bun.pathToFileURL(spelled(held)).href)?.text,
             )
         } catch (thrown) {
             // The checker's own failure, not the page's: the next check opens another.
@@ -164,6 +197,27 @@ export async function serveLanguage(
         // A newer text has arrived while this one was checked, and will be published.
         if (documents.get(uri)?.version !== version) return
         publish(uri, found, document.text)
+        await typesFor(app, path, document.text)
+    }
+
+    // 34.24 — THE TYPES A PLAIN `.ts` READS AN OPEN FILE BY, as the editor holds it: the whole app's
+    // the first time an app is seen, and the one file as it is edited after that.
+    const synced = new Set<string>()
+    const typesFor = async (
+        app: string,
+        path: string,
+        text: string,
+    ): Promise<void> => {
+        try {
+            if (synced.has(app))
+                await writeTypes(app, [{ path, file: parseAbide(text) }], false)
+            else {
+                synced.add(app)
+                await syncTypes(app, new Map([[path, text]]))
+            }
+        } catch {
+            // A file that does not parse keeps the types it last had; its check already says why.
+        }
     }
 
     const check = (uri: string): void => {
@@ -179,7 +233,20 @@ export async function serveLanguage(
 
     // A question about a document is about the text the editor shows, so a check still settling
     // runs now rather than after the answer; and it is answered in the queue, after that check.
-    const inspect = (params: unknown): Promise<Inspection | undefined> => {
+    const inspect = (params: unknown): Promise<Inspection | undefined> =>
+        ask(params, (session, path, text, offset) =>
+            session.inspect(path, text, offset),
+        )
+
+    const ask = <Answer>(
+        params: unknown,
+        question: (
+            session: AppChecker['session'],
+            path: string,
+            text: string,
+            offset: number,
+        ) => Promise<Answer | undefined>,
+    ): Promise<Answer | undefined> => {
         const { textDocument, position } = params as {
             textDocument: { uri: string }
             position: { line: number; character: number }
@@ -192,12 +259,11 @@ export async function serveLanguage(
         }
         const answered = queue.then(async () => {
             const document = documents.get(uri)
-            if (document === undefined) return undefined
-            const path = Bun.fileURLToPath(uri)
-            const app = root ?? appRootOf(path)
-            if (app === undefined) return undefined
-            return (await checkerOf(app)).session.inspect(
-                path,
+            const at = placed(uri)
+            if (document === undefined || at === undefined) return undefined
+            return question(
+                (await checkerOf(at.app)).session,
+                at.path,
                 document.text,
                 offsetOf(document.text, position),
             )
@@ -220,6 +286,7 @@ export async function serveLanguage(
                             textDocumentSync: 1,
                             hoverProvider: true,
                             definitionProvider: true,
+                            completionProvider: { triggerCharacters: ['.'] },
                         },
                         serverInfo: { name: 'abide' },
                     },
@@ -279,11 +346,39 @@ export async function serveLanguage(
                 })
                 return true
             }
+            // 38.98 — the protocol's `CompletionItemKind` is the checker's own numbering.
+            case 'textDocument/completion': {
+                const trigger = (
+                    params?.context as { triggerCharacter?: string } | undefined
+                )?.triggerCharacter
+                const found = await ask(params, (session, path, text, offset) =>
+                    session.complete(path, text, offset, trigger),
+                )
+                const items: object[] = []
+                for (const entry of found?.entries ?? [])
+                    items.push({
+                        label: entry.name,
+                        kind: entry.kind,
+                        sortText: entry.sortText,
+                        filterText: entry.filterText,
+                        insertText: entry.insertText,
+                        detail: entry.detail,
+                        labelDetails: entry.labelDetails,
+                    })
+                send({
+                    id: message.id,
+                    result:
+                        found === undefined
+                            ? null
+                            : { isIncomplete: found.isIncomplete, items },
+                })
+                return true
+            }
             case 'textDocument/definition': {
                 const found = await inspect(params)
                 const locations: object[] = []
                 for (const place of found?.definitions ?? [])
-                    locations.push(locationOf(place))
+                    locations.push(locationOf(spelled(place.path), place))
                 send({ id: message.id, result: locations })
                 return true
             }
@@ -348,20 +443,16 @@ async function closeAll(
 }
 
 /**
- * The app a file at `path` belongs to: the directory above its outermost `ui/`.
+ * The app a file at `path` belongs to: the root 38.25 finds from the nearest package above it.
  *
- * OUTERMOST, so a component folder that happens to be called `ui` inside an app is not taken for
- * the app. `undefined` where the file is under no `ui/` at all.
+ * That package's `src` where it has one, and the package itself where it does not — the same root
+ * `abide dev` run in that package would find. `undefined` where no package lies above the file.
  */
 function appRootOf(path: string): string | undefined {
-    let found: string | undefined
-    let at = dirname(path)
-    for (;;) {
-        if (basename(at) === 'ui') found = dirname(at)
-        const up = dirname(at)
-        if (up === at) return found
-        at = up
-    }
+    const manifest = nearest(dirname(path), 'package.json')
+    if (manifest === undefined) return undefined
+    const at = dirname(manifest)
+    return existsSync(`${at}/src`) ? `${at}/src` : at
 }
 
 /**
@@ -390,10 +481,10 @@ function offsetOf(
     return at + position.character
 }
 
-/** A `Place`, lines and columns from 1, as the protocol's `Location`, from 0. */
-function locationOf(place: Place): object {
+/** A `Place` at `path`, lines and columns from 1, as the protocol's `Location`, from 0. */
+function locationOf(path: string, place: Place): object {
     return {
-        uri: Bun.pathToFileURL(place.path).href,
+        uri: Bun.pathToFileURL(path).href,
         range: {
             start: {
                 line: place.start.line - 1,