@abide/abide 0.123.2 → 0.123.3

package/src/compiler/compileApp.ts

@@ -22,15 +22,19 @@ import {
     type PlacedSource,
     shapeOf,
 } from './appLayout.ts'
+import { type Diagnosis, Diagnostics } from './Diagnostics.ts'
 import { emitSource } from './emitSource.ts'
 import { handlersUnder } from './handlersUnder.ts'
 import { isAbideSpecifier } from './hookCalls.ts'
 import { nearest } from './nearest.ts'
 import { projectShadow } from './projectShadow.ts'
-import { type ReadSource, readSources } from './readSources.ts'
-import { Refusals } from './Refusals.ts'
+import {
+    type ParsedSource,
+    type ReadSource,
+    readSources,
+} from './readSources.ts'
 import { respecified } from './splitImports.ts'
-import { type Diagnosis, TypeSession } from './TypeSession.ts'
+import { TypeSession } from './TypeSession.ts'
 import { writeDefaultProject } from './writeDefaultProject.ts'
 
 // AN APP'S `.abide` SOURCES, COMPILED — every file keyed by its path below the root, and loaded
@@ -80,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, the caller opens another.
+     * (`TypeSession.edited`); where it is not, `KeptChecker` opens another.
      */
     current: () => boolean
     close: () => Promise<void>
@@ -102,8 +106,7 @@ export async function openChecker(appRoot: string): Promise<AppChecker> {
         found === undefined
             ? await writeDefaultProject(root)
             : { tsconfig: found, remove: async (): Promise<void> => {} }
-    const session = await TypeSession.open(project.tsconfig)
-    session.root = root
+    const session = await TypeSession.open(project.tsconfig, root)
     const moved = new Set<string>()
     let movedSomewhere = false
     let layout: Promise<AppLayout> | undefined
@@ -193,7 +196,7 @@ export async function compileApp(
 
 /**
  * The app at `appRoot` compiled — THE ONE PIPELINE `abide build` and `abide check` both run, the
- * layout, the reads, the lints and the emit, differing only in what a refusal does (`Refusals`) and
+ * layout, the reads, the lints and the emit, differing only in what a refusal does (`Diagnostics`) and
  * in what is checked beside: a build stops at the first refusal, and a check (`checking`) reports
  * every one at its file with what the checker says of each file (38.3), and goes on checking
  * whatever a refusal does not stop (38.33).
@@ -204,11 +207,11 @@ export async function compiled(
     checking: boolean,
 ): Promise<{ app: CompiledApp; findings: Diagnosis[] }> {
     const root = realpathSync(appRoot)
-    const refusals = new Refusals(root, checking)
+    const diagnostics = new Diagnostics(root, checking)
     // ONE LAYOUT for the sources, the handler files and the public files, and what the tree refuses
     // is met before the checker is asked anything.
     const layout = await (kept?.layout() ?? appLayout(root))
-    refusals.adopt([...layout.unparsed, ...layout.refused])
+    diagnostics.adopt([...layout.unparsed, ...layout.refused])
     const app: CompiledApp = {
         files: {},
         tables: {},
@@ -216,7 +219,7 @@ export async function compiled(
         routes: [],
         mounts: [],
         sources: layout.own,
-        warnings: [],
+        warnings: diagnostics.warnings,
         published: layout.published,
     }
     // 16.2 — an app of handler files alone is still an app; one of neither has nothing to build, and
@@ -231,62 +234,94 @@ export async function compiled(
     // One session for the whole compile: opening it spawns the checker, and the cost is paid once
     // rather than per file.
     return withChecker(root, kept, async (session) => {
-        // 38.33 — A FILE WHOSE PROJECTION IS REFUSED (34.3, 34.17) is refused at its file, found here
-        // because every later step projects it and would refuse it for the whole app.
-        const projected: PlacedSource[] = []
-        for (const source of layout.sources)
-            try {
-                projectShadow(source.file)
-                projected.push(source)
-            } catch (thrown) {
-                refusals.at(source.path, thrown)
-            }
-        const { read, warnings } = await readSources(
+        const emitted = await compiledSources(
+            layout,
             session,
-            projected,
-            refusals,
+            layout.sources,
+            [],
+            diagnostics,
+            checking,
+            true,
         )
-        let found: Diagnosis[] = []
-        let emittable = read
-        if (checking) {
-            // THE APP'S OWN FILES ARE REPORTED ON: a dependency's is compiled with them (34.23), and
-            // what is wrong inside a package is the package's to report.
-            const reported: typeof read = []
-            for (const source of read)
-                if (!source.dependency) reported.push(source)
-            const diagnosed = await session.diagnose(reported, layout)
-            found = diagnosed.diagnoses
-            // A FILE WHOSE LOWERING REFUSED is `found` already, at its line, and is not emitted.
-            emittable = []
-            for (const source of read)
-                if (!diagnosed.refused.has(source.path)) emittable.push(source)
-        }
-        const { ambient, unkeyed } = await session.lints(root, projected)
-        // 11.37 — a build error, every read named.
-        refusals.adopt(ambient)
-        // What the emit throws with no one file to name is refused at the root; a refusal of a file
-        // is refused at it.
-        let emitWarnings: Diagnosis[] = []
+        if (emitted !== undefined) Object.assign(app, emitted)
+        return { app, findings: diagnostics.findings }
+    })
+}
+
+/**
+ * What the compile makes of `own`, everything it finds in it kept in `diagnostics` — THE ONE STEP
+ * `abide check` runs over the app and an editor over the one file it holds (38.11), so the squiggle
+ * and the line CI fails on are one finding: the projection, the reads, the checker's diagnoses
+ * (`checking`), the lints and the emit.
+ *
+ * `beside` is lowered quietly with `own`, for the types it lends (33.4) and reported on by nobody;
+ * `scripts` is whether the app's `.ts` files are checked and read for handlers too, which an editor
+ * asking about one page does not want. `undefined` where the emit threw, which `diagnostics` holds
+ * at the root.
+ */
+export async function compiledSources(
+    layout: AppLayout,
+    session: TypeSession,
+    own: readonly PlacedSource[],
+    beside: readonly ParsedSource[],
+    diagnostics: Diagnostics,
+    checking: boolean,
+    scripts: boolean,
+): Promise<Awaited<ReturnType<typeof emitApp>> | undefined> {
+    // 38.33 — A FILE WHOSE PROJECTION IS REFUSED (34.3, 34.17) is refused at its file, found here
+    // because every later step projects it and would refuse it for the whole app.
+    const projected: PlacedSource[] = []
+    for (const source of own)
         try {
-            const whole = await emitApp(layout, session, emittable, refusals)
-            Object.assign(app, whole)
-            emitWarnings = whole.warnings
+            projectShadow(source.file)
+            projected.push(source)
         } catch (thrown) {
-            refusals.at(root, thrown)
+            diagnostics.at(source.path, thrown)
         }
-        // 11.30 — warned on, and the build goes on.
-        app.warnings = [...warnings, ...unkeyed, ...emitWarnings]
-        return {
-            app,
-            findings: [
-                ...refusals.found,
-                ...unkeyed,
-                ...warnings,
-                ...emitWarnings,
-                ...found,
-            ],
-        }
-    })
+    const read = await readSources(
+        session,
+        [...projected, ...beside],
+        diagnostics,
+    )
+    const placed: ReadSource<PlacedSource>[] = []
+    for (const source of read)
+        if (!source.quiet) placed.push(source as ReadSource<PlacedSource>)
+    let emittable = placed
+    if (checking) {
+        // THE APP'S OWN FILES ARE REPORTED ON: a dependency's is compiled with them (34.23), and
+        // what is wrong inside a package is the package's to report.
+        const reported: typeof read = []
+        for (const source of read)
+            if (source.quiet || !(source as Partial<PlacedSource>).dependency)
+                reported.push(source)
+        const diagnosed = await session.diagnose(reported, layout, scripts)
+        diagnostics.check(diagnosed.diagnoses)
+        // A FILE WHOSE LOWERING REFUSED is reported already, at its line, and is not emitted.
+        emittable = []
+        for (const source of placed)
+            if (!diagnosed.refused.has(source.path)) emittable.push(source)
+    }
+    const { ambient, unkeyed } = await session.lints(
+        layout.root,
+        projected,
+        scripts,
+    )
+    // 11.37 — a build error, every read named. 11.30 — warned on, and the build goes on.
+    diagnostics.adopt(ambient)
+    diagnostics.warn(unkeyed)
+    // What the emit throws with no one file to name is refused at the root; a refusal of a file
+    // is refused at it.
+    try {
+        return await emitApp(
+            scripts ? layout : { ...layout, handlers: [] },
+            session,
+            emittable,
+            diagnostics,
+        )
+    } catch (thrown) {
+        diagnostics.at(layout.root, thrown)
+        return undefined
+    }
 }
 
 /** The emit half of `compiled`, over sources already laid out and read. */
@@ -297,12 +332,9 @@ async function emitApp(
     >,
     session: TypeSession,
     sources: readonly ReadSource<PlacedSource>[],
-    refusals: Refusals,
+    refusals: Diagnostics,
 ): Promise<
-    Pick<
-        CompiledApp,
-        'files' | 'tables' | 'handlers' | 'routes' | 'mounts' | 'warnings'
-    >
+    Pick<CompiledApp, 'files' | 'tables' | 'handlers' | 'routes' | 'mounts'>
 > {
     const { root, routes, errors } = layout
     const files: Record<string, CompiledFile> = {}
@@ -311,7 +343,7 @@ async function emitApp(
     // and the browser holds its wrapper in its place — a handler file's as that file, a private
     // handler's in the server block's place in its own file's module. Written whether or not there
     // is a page: a handler is answered over http to a caller that has none.
-    const { mounts, warnings } = await handlersUnder(
+    const mounts = await handlersUnder(
         session,
         sources,
         layout.handlers,
@@ -387,7 +419,6 @@ async function emitApp(
         handlers,
         routes,
         mounts,
-        warnings,
     }
 }
 
@@ -442,7 +473,7 @@ function tableImport(source: string): string {
 function refuseSharedRoutes(
     routes: AppRoute[],
     mounts: Mount[],
-    refusals: Refusals,
+    refusals: Diagnostics,
 ): void {
     const owners = new Map<string, string>()
     const claim = (method: string, route: string, source: string): void => {
@@ -476,7 +507,7 @@ function refuseAddressCollision(
     routes: AppRoute[],
     mounts: Mount[],
     published: Map<string, string>,
-    refusals: Refusals,
+    refusals: Diagnostics,
 ): void {
     const patterns = new Set<string>()
     for (const route of routes) patterns.add(route.pattern)

package/src/compiler/declaredExports.ts

@@ -43,7 +43,7 @@ import {
     resultSchemaOf,
     type Walk,
 } from './argsSchemaOf.ts'
-import { diagnosisAt } from './lineOf.ts'
+import { type Diagnosis, diagnosisAt, type Diagnostics } from './Diagnostics.ts'
 import { isReactiveCall, METHODS, optionNamed } from './reactiveOptions.ts'
 import {
     abideIn,
@@ -51,8 +51,6 @@ import {
     isReactiveMember,
     valueTypeOf,
 } from './reactiveTypes.ts'
-import type { Refusals } from './Refusals.ts'
-import type { Diagnosis } from './TypeSession.ts'
 
 /**
  * Every value each module exports, with the abide method that declares it.
@@ -73,7 +71,7 @@ export async function declaredExports(
     projectName: string,
     paths: readonly string[],
     named: readonly string[],
-    refusals: Refusals,
+    refusals: Diagnostics,
 ): Promise<(DeclaredExport[] | undefined)[]> {
     const checker = project.checker
     // ABIDE'S FILE AS THE CHECKER NAMES IT, not as this module does: it canonicalizes a path to

package/src/compiler/emitClient.ts

@@ -143,7 +143,7 @@ class RegionEmission {
  */
 export type SelfFill = 'none' | 'routed' | 'invoked' | 'both'
 
-// The mount's third argument, which only the router passes (`Router.mountFrom`).
+// The mount's third argument, which only the router passes (`LevelChain.mountFrom`).
 const ROUTED = '__routed'
 
 /**

package/src/compiler/formatAbide.ts

@@ -2,7 +2,8 @@ import { dirname } from 'node:path' // bun exposes no path helpers of its own
 
 import { SyntaxKind } from 'typescript/unstable/ast'
 
-import { diagnosisAt, offsetOf } from './lineOf.ts'
+import { type Diagnosis, diagnosisAt } from './Diagnostics.ts'
+import { offsetOf } from './lineOf.ts'
 import { nearest } from './nearest.ts'
 import {
     type AbideFile,
@@ -13,7 +14,6 @@ import {
 } from './parseAbide.ts'
 import { sameTemplate } from './sameTemplate.ts'
 import { isSpace, slotEnd, tokenize } from './tokenize.ts'
-import type { Diagnosis } from './TypeSession.ts'
 import { VOID_ELEMENTS } from './VOID_ELEMENTS.ts'
 
 // 38.125, 38.126 — A `.abide` IS FORMATTED AS PIECES, and `bun fmt` formats every piece that is code: a

package/src/compiler/handlersUnder.ts

@@ -11,6 +11,7 @@
 
 import type { Mount } from '#server/answerRpc.ts'
 import { frameworkRouteRefusal } from '#server/appTree.ts'
+import { handlerFileMount } from '#server/handlerFileMount.ts'
 import { PRIVATE_EXPORT } from '#server/PRIVATE_EXPORT.ts'
 import { surfaceName } from '#server/surfaceOf.ts'
 import { PRIVATE_HANDLERS_ADDRESS } from '#shared/ADDRESSES.ts'
@@ -18,8 +19,8 @@ import { parseRoutePattern } from '#shared/routePattern.ts'
 
 import type { PlacedHandler, PlacedSource } from './appLayout.ts'
 import { declaredExports } from './declaredExports.ts'
-import type { Refusals } from './Refusals.ts'
-import type { Diagnosis, TypeSession } from './TypeSession.ts'
+import type { Diagnostics } from './Diagnostics.ts'
+import type { TypeSession } from './TypeSession.ts'
 
 /** A handler file, by its path and its path below the app's root. */
 export type HandlerFile = {
@@ -36,7 +37,7 @@ type Source = Pick<
 >
 
 /**
- * The app's handler mounts, with the warnings the build raised reading them.
+ * The app's handler mounts, the warnings the build raised reading them kept in `diagnostics`.
  *
  * Off one read of the checker. 18.15 — with what the build could not read of a copy's options.
  * 19.1's one owner per route and method is `compileApp`'s, which holds the pages as well.
@@ -48,8 +49,8 @@ export async function handlersUnder(
         PlacedHandler,
         'path' | 'relative' | 'route' | 'scope' | 'matchers'
     >[],
-    refusals: Refusals,
-): Promise<{ mounts: Mount[]; warnings: Diagnosis[] }> {
+    diagnostics: Diagnostics,
+): Promise<Mount[]> {
     const serving: Source[] = []
     for (const source of sources)
         if (source.file.servers.length > 0) serving.push(source)
@@ -75,10 +76,9 @@ export async function handlersUnder(
                   session.tsconfig,
                   paths,
                   named,
-                  refusals,
+                  diagnostics,
               )
     const mounts: Mount[] = []
-    const warnings: Diagnosis[] = []
     const names = new Map<string, string>()
     for (let at = 0; at < files.length; at += 1) {
         const {
@@ -114,27 +114,15 @@ export async function handlersUnder(
                     `abide: ${named} and ${relative} are both named ${surface} on the generated surfaces. RULEBOOK 20.13.`,
                 )
             names.set(surface, relative)
-            mounts.push({
-                address,
-                method: handler.method,
-                source: relative,
-                name: address.slice(address.lastIndexOf('/') + 1),
-                export: 'default',
-                scope,
-                matchers,
-                private: false,
-                ui: handler.ui,
-                cli: handler.cli,
-                mcp: handler.mcp,
-                description: handler.description,
-                copy: handler.copy,
-                defaults: handler.defaults,
-                args: handler.args,
-                result: handler.result,
-            })
-            warnings.push(...handler.unread)
+            mounts.push(
+                handlerFileMount(
+                    { address, source: relative, scope, matchers },
+                    { ...handler, method: handler.method },
+                ),
+            )
+            diagnostics.warn(handler.unread)
         } catch (thrown) {
-            refusals.at(relative, thrown)
+            diagnostics.at(relative, thrown)
         }
     }
     for (let at = 0; at < serving.length; at += 1) {
@@ -164,10 +152,10 @@ export async function handlersUnder(
                 args: each.args,
                 result: each.result,
             })
-            warnings.push(...each.unread)
+            diagnostics.warn(each.unread)
         }
     }
-    return { mounts, warnings }
+    return mounts
 }
 
 /**

package/src/compiler/lineOf.ts

@@ -1,5 +1,3 @@
-import type { Diagnosis } from './TypeSession.ts'
-
 /**
  * An offset into a file's text as the line and column an editor shows, both from 1.
  *
@@ -36,20 +34,3 @@ export function offsetOf(
     }
     return at + position.character
 }
-
-/** abide's own finding at `offset` into `text`, or at line 0 where the text was not handed in. */
-export function diagnosisAt(
-    path: string,
-    text: string | undefined,
-    offset: number,
-    category: Diagnosis['category'],
-    message: string,
-): Diagnosis {
-    return {
-        path,
-        ...(text === undefined ? { line: 0, column: 0 } : lineOf(text, offset)),
-        code: 0,
-        category,
-        message,
-    }
-}

package/src/compiler/matchersOf.ts

@@ -10,8 +10,8 @@
 
 import { parseRoutePattern } from '#shared/routePattern.ts'
 
+import type { Diagnostics } from './Diagnostics.ts'
 import { matcherOf } from './paramFile.ts'
-import type { Refusals } from './Refusals.ts'
 
 /** A directory a file mounts (23.19), where it mounts, and the param files under it, by path. */
 export type MountedTree = { directory: string; at: string; params: string[] }
@@ -28,7 +28,7 @@ type Routed = {
  * Each routed file's matchers, by its path: every name its route's segments give, to the anchored
  * source of the param file it resolves to — empty where its route names none.
  *
- * `params` is every param file of the app's own, by path. Refusals land at the file the fault is in:
+ * `params` is every param file of the app's own, by path. Diagnostics land at the file the fault is in:
  * a param file that declares no matcher at itself, a name that resolves to none at the segment's file.
  */
 export async function matchersOf(
@@ -36,7 +36,7 @@ export async function matchersOf(
     routed: readonly Routed[],
     params: readonly string[],
     trees: readonly MountedTree[],
-    refusals: Refusals,
+    refusals: Diagnostics,
 ): Promise<Map<string, Record<string, string>>> {
     // Every param file's matcher, read once whichever routes name it; `undefined` where 23.24 or
     // 23.25 refused the file, so a segment naming it refuses nothing more.

package/src/compiler/mountsOf.ts

@@ -14,9 +14,9 @@ import { dirname, relative, resolve } from 'node:path' // bun exposes no path he
 import { appFiles } from '#server/appTree.ts'
 import { placeOf } from '#server/placement.ts'
 
+import { Diagnostics } from './Diagnostics.ts'
 import { nearest } from './nearest.ts'
 import { type AbideFile, scriptBodies } from './parseAbide.ts'
-import { Refusals } from './Refusals.ts'
 import { attributedImports } from './splitImports.ts'
 
 /** A `.abide` on disk, and the position it takes in the app. */
@@ -49,7 +49,7 @@ export function mountsOf(
     path: string,
     position: string,
     file: AbideFile,
-    refusals: Refusals,
+    refusals: Diagnostics,
 ): DirectoryMount[] {
     const mounts: DirectoryMount[] = []
     const at = position.includes('/')
@@ -78,7 +78,7 @@ export function mountsOf(
                 return []
             }
             // The package's tree is the package's to refuse; a mount places what it finds.
-            const found = appFiles(directory, new Refusals(directory, true))
+            const found = appFiles(directory, new Diagnostics(directory, true))
             const placed = (below: string): Placed => ({
                 path: `${directory}/${below}`,
                 position: `${at}${below}`,

package/src/compiler/readSources.ts

@@ -1,11 +1,11 @@
 import { type CheckerAnswer, UNCHECKED } from './CheckerAnswer.ts'
+import type { Diagnostics } from './Diagnostics.ts'
 import { type AbideFile, parseAbide } from './parseAbide.ts'
-import type { Refusals } from './Refusals.ts'
-import type { Diagnosis, TypeSession } from './TypeSession.ts'
+import type { TypeSession } from './TypeSession.ts'
 
 // EVERY COMPILE OF A `.abide` STARTS THE SAME WAY: the text parsed, then every file read by the
 // checker in one snapshot. `abide build`, `abide check` and an editor's one file differ only in
-// what a refusal does (`Refusals`) — the build stops at it, and a check reports it and goes on with
+// what a refusal does (`Diagnostics`) — the build stops at it, and a check reports it and goes on with
 // the rest.
 
 /** One `.abide`, parsed. `quiet` is read for its props alone and reported on by nobody (33.4). */
@@ -28,7 +28,7 @@ export function parseSources(
         text: string
         quiet?: boolean
     }[],
-    refusals: Refusals,
+    refusals: Diagnostics,
 ): ParsedSource[] {
     const parsed: ParsedSource[] = []
     for (const source of sources) {
@@ -51,37 +51,35 @@ export function parseSources(
 }
 
 /**
- * Each parsed source with the checker's answer, and the compiler's warnings — in one snapshot.
+ * Each parsed source with the checker's answer — in one snapshot — the compiler's warnings kept in
+ * `diagnostics`.
  *
  * ONE SNAPSHOT FOR THE LOT, which is the whole of the compiler's build time (`readsFor`). Where
- * `refusals` collects, a batch that refuses is asked again a file at a time, so which file it was is
- * known and the others still answer; where it throws, so does the batch.
+ * `diagnostics` collects, a batch that refuses is asked again a file at a time, so which file it was
+ * is known and the others still answer; where it throws, so does the batch.
  */
 export async function readSources<Source extends ParsedSource>(
     session: TypeSession,
     parsed: readonly Source[],
-    refusals: Refusals,
-): Promise<{
-    read: ReadSource<Source>[]
-    warnings: Diagnosis[]
-}> {
+    diagnostics: Diagnostics,
+): Promise<ReadSource<Source>[]> {
     try {
         const { answers, warnings } = await session.readsFor(parsed)
-        return { read: answered(parsed, answers), warnings }
+        diagnostics.warn(warnings)
+        return answered(parsed, answers)
     } catch (thrown) {
-        if (!refusals.collecting) throw thrown
+        if (!diagnostics.collecting) throw thrown
     }
     const read: ReadSource<Source>[] = []
-    const warnings: Diagnosis[] = []
     for (const source of parsed)
         try {
             const alone = await session.readsFor([source])
             read.push(...answered([source], alone.answers))
-            warnings.push(...alone.warnings)
+            diagnostics.warn(alone.warnings)
         } catch (thrown) {
-            if (!source.quiet) refusals.at(source.path, thrown)
+            if (!source.quiet) diagnostics.at(source.path, thrown)
         }
-    return { read, warnings }
+    return read
 }
 
 function answered<Source extends ParsedSource>(

package/src/compiler/readsIn.ts

@@ -45,7 +45,7 @@ import {
     type Read,
     TRANSPARENT,
 } from './classifyRead.ts'
-import type { Finding } from './Finding.ts'
+import type { Finding } from './Diagnostics.ts'
 import type { AbideFile } from './parseAbide.ts'
 import {
     holdsReactive,