@abide/abide 0.100.0 → 0.102.0

package/src/compiler/compiledEntry.ts

@@ -1,8 +1,14 @@
+import { tablePath } from '#server/abideModules.ts'
 import type { AppPackage } from '#server/config.ts'
-import type { LauncherOptions } from '#server/launcherOptions.ts'
+import type { SourceMaps } from '#server/installSourceMaps.ts'
+import { SERVER_TABLE } from '#server/TABLES.ts'
 import abidePackage from '../../package.json' with { type: 'json' }
 
-// What the executable starts from: `abide compile`'s, and `abide bundle`'s window over it (38.71).
+// What the executable starts from: `abide compile`'s, and `abide bundle`'s window over it (38.70).
+const INSTALL_SOURCE_MAPS = Bun.fileURLToPath(
+    new URL('../server/installSourceMaps.ts', import.meta.url),
+)
+
 const RUNNERS = {
     compiled: {
         name: 'runCompiled',
@@ -22,7 +28,7 @@ const PACKAGE = Bun.fileURLToPath(new URL('../../', import.meta.url))
 /**
  * Abide's own package entries, by the specifier an app imports each with, to the module behind it.
  *
- * 38.57 — the compiler is not among them: the executable does not hold it.
+ * 38.56 — the compiler is not among them: the executable does not hold it.
  */
 function abideEntries(): Map<string, string> {
     const specifiers = new Map<string, string>()
@@ -41,8 +47,8 @@ function abideEntries(): Map<string, string> {
 /**
  * The source of the module a compiled app starts from, written into the build beside `server.ts`.
  *
- * 38.11 — every part `runCompiled` boots over, named by a static import the bundler follows into
- * the executable. 38.45 — NOTHING IN IT IS FOUND AT RUN TIME — a file this module does not name is
+ * 38.10 — every part `runCompiled` boots over, named by a static import the bundler follows into
+ * the executable. 38.44 — NOTHING IN IT IS FOUND AT RUN TIME — a file this module does not name is
  * a file the executable does not hold, which is what makes the artifact a property of the build
  * rather than of the machine it lands on.
  *
@@ -52,24 +58,25 @@ function abideEntries(): Map<string, string> {
  */
 export function compiledEntry(app: {
     /**
-     * 38.71 — what `abide bundle` read out of `src/bundle/`, and `launch` the path of its
-     * `launch.abide`; `undefined` for `abide compile`.
+     * 38.70 — what `abide bundle` read of the launcher's files: `launch` the path of its
+     * `launcher.abide`, and `custom` whether that file has markup of its own; `undefined` for
+     * `abide compile`.
      */
     desktop:
         | {
-              options: LauncherOptions
               launch: string | undefined
-              shell: string
+              custom: boolean
+              document: string
+              icon: string | undefined
+              accent: string | undefined
           }
         | undefined
-    out: string
-    /** 37.1 — `src/server/app.ts`, where the app has one. */
-    hooks: string | undefined
+    /** The app's root, below which the server's table is served (`abideModules`). */
+    root: string
+    /** 38.97 — each server module's map, by the `.abide` it is served at. */
+    sourceMaps: SourceMaps
     package: AppPackage
-    shell: string
     manifest: unknown
-    /** 16.2 — each handler's source path as its row names it, to the file. */
-    handlerModules: Map<string, string>
     /** Every file under the build's `client/`, by name to the file. */
     client: Map<string, string>
     /** Every file under the build's `public/`, by name to the file. */
@@ -77,8 +84,8 @@ export function compiledEntry(app: {
 }): string {
     const runner = RUNNERS[app.desktop === undefined ? 'compiled' : 'desktop']
     let imports = `import { ${runner.name} } from ${JSON.stringify(runner.path)}
-import * as table from ${JSON.stringify(`${app.out}/server.ts`)}
-import { handlers } from ${JSON.stringify(`${app.out}/rpc.ts`)}
+import { installSourceMaps } from ${JSON.stringify(INSTALL_SOURCE_MAPS)}
+import * as table from ${JSON.stringify(tablePath(app.root, SERVER_TABLE))}
 `
     const files = (kind: string, paths: Map<string, string>): string => {
         let entries = ''
@@ -92,49 +99,46 @@ import { handlers } from ${JSON.stringify(`${app.out}/rpc.ts`)}
     }
     const client = files('client', app.client)
     const published = files('published', app.published)
-    let modules = ''
-    for (const [source, path] of app.handlerModules)
-        modules += `\n    ${JSON.stringify(source)}: () => import(${JSON.stringify(path)}),`
-    // A handler module as a script names it: `#server/rpc/invoices`, with or without its extension.
     let specifiers = ''
     for (const [specifier, path] of abideEntries())
         specifiers += `\n    ${JSON.stringify(specifier)}: () => import(${JSON.stringify(path)}),`
-    for (const source of app.handlerModules.keys())
-        for (const specifier of [
-            `#${source}`,
-            `#${source.replace(/\.ts$/, '')}`,
-        ])
-            specifiers += `\n    ${JSON.stringify(specifier)}: handlerModules[${JSON.stringify(source)}],`
-    const hooks =
-        app.hooks === undefined
-            ? 'undefined'
-            : `() => import(${JSON.stringify(app.hooks)})`
     const desktop =
         app.desktop === undefined
             ? ''
             : `
     {
-        options: ${JSON.stringify(app.desktop.options)},
+        custom: ${app.desktop.custom},
         launch: ${app.desktop.launch === undefined ? 'undefined' : `() => import(${JSON.stringify(app.desktop.launch)})`},
-        shell: ${JSON.stringify(app.desktop.shell)},
+        document: ${JSON.stringify(app.desktop.document)},
+        icon: ${JSON.stringify(app.desktop.icon)},
+        accent: ${JSON.stringify(app.desktop.accent)},
     },`
     return `// Written by \`abide compile\`. The whole app, as what one executable holds.
 ${imports}
-const handlerModules = {${modules}
-}
+// 38.56 — a file declaring handlers as a script names it through the app's one alias:
+// \`#src/invoices/page.abide\`, to the module its server block compiled into.
+const declared = {}
+for (const row of table.handlers) declared[\`#src/\${row.source}\`] = row.load
+
+// 38.97 — before anything runs, a script \`run\` included: the executable's frames name each
+// \`.abide\` as it was bundled.
+installSourceMaps(${JSON.stringify(app.sourceMaps)}, undefined)
 
 await ${runner.name}(
-    { hooks: ${hooks}, package: ${JSON.stringify(app.package)} },
+    // 37.1 — every server block, imported before the boot.
+    {
+        hooks: () => Promise.all(table.servers.map((load) => load())),
+        package: ${JSON.stringify(app.package)},
+    },
     {
         table,
-        handlers,
-        handlerModule: (source) => handlerModules[source](),
-        shell: ${JSON.stringify(app.shell)},
+        handlers: table.handlers,
         manifest: ${JSON.stringify(app.manifest)},
         client: ${client},
         published: ${published},
     },
     {${specifiers}
+        ...declared,
     },${desktop}
 )
 `

package/src/compiler/componentGraph.ts

@@ -1,57 +1,40 @@
-import { dirname, posix, relative as relativePath } from 'node:path' // bun exposes no path helpers of its own
-import { type FileKind, fileKind, routeOf } from '#shared/routePattern.ts'
-import type { AbideFile } from './parseAbide.ts'
-import { abideImports, relativeSpecifiers } from './splitImports.ts'
+import { dirname, relative as relativeTo } from 'node:path' // bun exposes no path helpers of its own
+import {
+    type FileKind,
+    fileKind,
+    placeOf,
+    routeOf,
+} from '#shared/routePattern.ts'
+import { type AbideFile, scriptBodies } from './parseAbide.ts'
+import { abideImports, attributedImports } from './splitImports.ts'
 
 type Resolve = (specifier: string, from: string) => string | undefined
 
 /**
- * The build's component graph: which files are invoked as components, and where each file's
- * `.abide` imports land in the output tree.
+ * Which files are invoked as components: every source path another file imports.
  *
- * 32.17 — off ONE reading of every file's imports: each `.abide` specifier is resolved once,
- * against the file that wrote it, and both answers the build needs are read off that resolution.
- *
- * `invoked` is every source path another file imports as a component (`emitClient`'s `selfFill`).
- * By PATH, not by file name: two `Row.abide` in two directories are two components, and only the
- * one somebody imports carries its own markup.
- *
- * `imports` is, per importing file, where each `.abide` specifier it wrote lands in the output
- * tree, relative and without an extension (`splitImports`). The output mirrors the source, so
- * the path between two sources IS the path between their modules — which is what turns a seam
- * specifier (`#ui/components/Row.abide`) into one that resolves inside the build rather than into
- * a source tree where the compiler wrote nothing.
+ * 32.17 — off ONE reading of every file's imports, each `.abide` specifier resolved once against
+ * the file that wrote it. By PATH, not by file name: two `Row.abide` in two directories are two
+ * components, and only the one somebody imports carries its own markup (`emitClient`'s `selfFill`).
  *
  * `resolve` is the app's: a build asks bun, and a harness that lays an app out by hand answers for
- * its own seams. A specifier it cannot resolve, or that lands outside `files`, is left as written.
+ * its own seams. A specifier it cannot resolve, or that lands outside `files`, invokes nothing.
  */
 export function componentGraph(
     files: readonly { path: string; file: AbideFile }[],
     resolve: Resolve,
-): {
-    invoked: Set<string>
-    imports: Map<string, Map<string, string>>
-} {
+): { invoked: Set<string> } {
     const known = new Set<string>()
     for (const entry of files) known.add(entry.path)
     const invoked = new Set<string>()
-    const imports = new Map<string, Map<string, string>>()
-    for (const entry of files) {
-        const from = dirname(entry.path)
-        const landed = new Map<string, string>()
-        for (const [specifier, target] of abideImportsOf(
+    for (const entry of files)
+        for (const target of abideImportsOf(
             entry.path,
             entry.file,
             resolve,
-        )) {
-            if (!known.has(target)) continue
-            invoked.add(target)
-            const path = relativePath(from, target.slice(0, -'.abide'.length))
-            landed.set(specifier, path.startsWith('.') ? path : `./${path}`)
-        }
-        imports.set(entry.path, landed)
-    }
-    return { invoked, imports }
+        ).values())
+            if (known.has(target)) invoked.add(target)
+    return { invoked }
 }
 
 /**
@@ -69,7 +52,7 @@ export function abideImportsOf(
 ): Map<string, string> {
     const from = dirname(path)
     const resolved = new Map<string, string>()
-    for (const script of [...file.modules, ...file.scripts])
+    for (const script of scriptBodies(file))
         for (const { specifier } of abideImports(script)) {
             if (resolved.has(specifier)) continue
             const target = resolve(specifier, from)
@@ -81,6 +64,8 @@ export function abideImportsOf(
 /** One source in the app graph: where it is below the root, what it is, and its address. */
 export type AppNode<Source> = Source & {
     relative: string
+    /** 23.19 — the path it answers by: its own below the root, or the one its mount gives it. */
+    position: string
     kind: FileKind
     /** 23.3 — the address of a page or an error page, and `undefined` for anything else. */
     route: string | undefined
@@ -88,52 +73,54 @@ export type AppNode<Source> = Source & {
 
 /**
  * The app as one graph, built once per build or check: every source with its kind and address,
- * which files are invoked as components, and where each file's every import lands.
- *
- * `imports` is `componentGraph`'s with the relative specifiers landed beside the `.abide` ones —
- * 34.14, A RELATIVE IMPORT RESOLVES FROM THE FILE THAT WROTE IT. The module that file compiles to
- * is in the output tree, which holds compiled `.abide` files and nothing else, so a stylesheet or
- * a `.ts` beside the source is reached by the path from the module back to it.
- *
- * `output` is where the modules are written, relative to `root`.
+ * and which files are invoked as components.
  */
-export function appGraph<Source extends { path: string; file: AbideFile }>(
+export function appGraph<
+    Source extends {
+        path: string
+        file: AbideFile
+        position?: string | undefined
+    },
+>(
     root: string,
     sources: readonly Source[],
-    output: string,
     resolve: Resolve,
-): {
-    nodes: AppNode<Source>[]
-    invoked: Set<string>
-    imports: Map<string, Map<string, string>>
-} {
+): { nodes: AppNode<Source>[]; invoked: Set<string> } {
     const nodes: AppNode<Source>[] = []
     for (const source of sources) {
-        const relative = source.path.slice(root.length + 1)
-        const kind = fileKind(relative)
+        // Below the root for the app's own files, and above it — `../node_modules/…` — for a
+        // dependency's (34.28).
+        const relative = relativeTo(root, source.path)
+        const position = source.position ?? relative
+        // 34.21 — a server block of the app's own under a `server` or `public` directory has no
+        // address: refused here, before anything reads one off it. A dependency's has none of its own
+        // (34.31); the app mounts what it declares where the app re-exports it.
+        const place = placeOf(position)
+        if (
+            source.file.servers.length > 0 &&
+            (place === 'server' || place === 'public')
+        )
+            throw new Error(
+                `abide: ${relative} has a <script server>, and it is under a ${place} directory, where nothing has an address. Move the file out of it, or the code into a module under a server directory. RULEBOOK 34.21.`,
+            )
+        // 34.25 — a file imported as text is found at build, not when its module first loads.
+        for (const script of scriptBodies(source.file))
+            for (const { specifier } of attributedImports(script, 'text'))
+                if (resolve(specifier, dirname(source.path)) === undefined)
+                    throw new Error(
+                        `abide: ${relative} imports ${specifier} as text, and there is no such file. RULEBOOK 34.25.`,
+                    )
+        const kind = fileKind(position)
         nodes.push({
             ...source,
             relative,
+            position,
             kind,
             route:
                 kind === 'page' || kind === 'error'
-                    ? routeOf(relative)
+                    ? routeOf(position)
                     : undefined,
         })
     }
-    const { invoked, imports } = componentGraph(sources, resolve)
-    for (const node of nodes) {
-        const landed = imports.get(node.path) as Map<string, string>
-        const written = dirname(node.path)
-        const emitted = posix.join(root, output, dirname(node.relative))
-        for (const script of [...node.file.modules, ...node.file.scripts])
-            for (const specifier of relativeSpecifiers(script)) {
-                const path = posix.relative(
-                    emitted,
-                    posix.join(written, specifier),
-                )
-                landed.set(specifier, path.startsWith('.') ? path : `./${path}`)
-            }
-    }
-    return { nodes, invoked, imports }
+    return { nodes, invoked: componentGraph(sources, resolve).invoked }
 }

package/src/compiler/declaredExports.ts

@@ -189,8 +189,8 @@ async function declaringMethod(
       }
     | undefined
 > {
-    const declaration = await symbol.valueDeclaration?.resolve()
-    const call =
+    let declaration = await symbol.valueDeclaration?.resolve()
+    let call =
         declaration === undefined
             ? undefined
             : isVariableDeclaration(declaration)
@@ -198,6 +198,24 @@ async function declaringMethod(
               : isExportAssignment(declaration)
                 ? declaration.expression
                 : undefined
+    // 19.15 — A BINDING NAMING ANOTHER BINDING is the call that one was declared by: `export const
+    // named = drop` is `drop`'s handler under another name. Bounded, so a cycle the checker would
+    // refuse anyway cannot spin here.
+    for (
+        let hops = 0;
+        hops < 8 && call !== undefined && isIdentifier(call);
+        hops += 1
+    ) {
+        const bound = await checker.getSymbolAtLocation(call)
+        if (bound === undefined) return undefined
+        declaration = await (
+            await aliasedSymbol(checker, bound)
+        ).valueDeclaration?.resolve()
+        call =
+            declaration !== undefined && isVariableDeclaration(declaration)
+                ? declaration.initializer
+                : undefined
+    }
     if (call === undefined || !isCallExpression(call)) return undefined
     const callee = isPropertyAccessExpression(call.expression)
         ? call.expression.name
@@ -520,11 +538,10 @@ function describedAs(
 /**
  * What a handler call's inline `clients` declares for `surface`, or `undefined` where it does not.
  *
- * 20.4, 38.63 — written on the declaration, which is what the build can read without running it:
- * `ui: false` hands a browser no wrapper, and importing the handler from `#ui` is 16.29's compile
- * error; `cli: false` keeps it off the shell's listing, which reads the table the build wrote (38.7);
- * and an explicit `true` overrides 16.37's default. An options object built elsewhere, or a value
- * that is not a literal, is not read.
+ * 20.4, 38.62 — written on the declaration, which is what the build can read without running it:
+ * `ui: false` gives the file's browser copy no stand-in for it; `cli: false` keeps it off the
+ * shell's listing, which reads the table the build wrote (38.7); and an explicit `true` overrides
+ * 16.37's default. An options object built elsewhere, or a value that is not a literal, is not read.
  */
 function declaredFor(
     call: Node & { arguments?: readonly Node[] },