@abide/abide 0.123.2 → 0.124.0

package/src/compiler/readsIn.ts

@@ -7,6 +7,7 @@ import {
     isBinaryExpression,
     isCallExpression,
     isClassDeclaration,
+    isElementAccessExpression,
     isEnumDeclaration,
     isExpressionStatement,
     isForOfStatement,
@@ -32,9 +33,11 @@ import {
     SymbolFlags,
     type Type,
     TypeFlags,
+    type TypeReference,
 } from 'typescript/unstable/async'
 
 import { aliasedSymbol } from './aliasedSymbol.ts'
+import { ARRAY_MUTATORS } from './ARRAY_MUTATORS.ts'
 import { CheckerAnswer } from './CheckerAnswer.ts'
 import {
     classifyPropRead,
@@ -45,7 +48,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,
@@ -53,12 +56,13 @@ import {
     type PositionKind,
     type PositionTable,
 } from './PositionTable.ts'
-import { INLINE_PROPS, type Span } from './projectShadow.ts'
+import { INLINE_PROPS, type Projection, type Span } from './projectShadow.ts'
 import { REACTIVE_MEMBERS } from './REACTIVE_MEMBERS.ts'
 import { optionNamed, reactiveOptions } from './reactiveOptions.ts'
 import {
     type Abide,
     boundInitializer,
+    isReactiveSymbol,
     isReactiveType,
     unionMembers,
     valueTypeOf,
@@ -66,19 +70,6 @@ import {
 import { sharedModuleWrites } from './sharedModuleWrites.ts'
 import { trackingWarnings } from './trackingWarnings.ts'
 
-/** Where in a `.abide`'s shadow each kind of question is asked (`projectShadow`). */
-export type ShadowSpans = {
-    /** Where the shadow's scripts end and its template begins. */
-    scriptsEnd: number
-    /** The `<script module>`, `<script server>` and `<script>` bodies, in the shadow. */
-    modules: Span
-    servers: Span
-    scripts: Span
-    positions: PositionTable
-    /** 32.67 — where each `{#for}` row's item binding starts. */
-    items: Set<number>
-}
-
 const SETUP: ReadonlySet<PositionKind> = new Set(['setup'])
 const HEAD: ReadonlySet<PositionKind> = new Set(['head'])
 /**
@@ -121,19 +112,22 @@ const RAW_LOWERED: ReadonlySet<PositionKind> = new Set([...PROVABLE, 'prop'])
  * absent. What each reference DOES — a read, a write, an update, a shorthand — is read off its
  * parents by `classifyRead`, so no token walk re-derives the grammar.
  *
- * Asked of one snapshot (`TypeSession.readsFor`), and every offset — a read's and a warning's — is
- * the shadow's; the session places them in the `.abide`.
+ * Asked of one snapshot (`reactiveReads`), and every offset — a read's and a warning's — is the
+ * shadow's; `reactiveReads` places them in the `.abide`. `suspects` are where each binding starts
+ * whose type the projection cannot vouch for (`bindingsOfReads`), for the next round to ask.
  */
 export async function readsIn(
     checker: Checker,
     abide: Abide,
     sourceFile: SourceFile,
     shadowPath: string,
-    spans: ShadowSpans,
+    projection: Projection,
     file: AbideFile,
     /** Where each name the lowered program proved a `Reactive` starts (`bindingsOfReads`). */
     held: ReadonlySet<number>,
 ): Promise<{ answer: CheckerAnswer; warnings: Finding[]; suspects: number[] }> {
+    const scriptsEnd = projection.scripts.end
+    const positions = projection.positions
     // A destructuring pattern binds names this does not see, and that is 31.12's case.
     const names: Node[] = []
     const spelled = new Set<string>()
@@ -143,7 +137,7 @@ export async function readsIn(
         names.push(name)
     }
     for (const statement of sourceFile.statements) {
-        if (statement.getStart() >= spans.scriptsEnd) break
+        if (statement.getStart() >= scriptsEnd) break
         if (isVariableStatement(statement)) {
             for (const declaration of statement.declarationList.declarations)
                 bind(declaration.name)
@@ -172,12 +166,11 @@ export async function readsIn(
     const topLevel = names.length
     // The script's own statements, as the top-level walk takes the page's: a declaration inside
     // one of its functions is not a name the body reads.
-    for (const { node } of spans.positions.nodesIn(sourceFile, SETUP))
+    for (const { node } of positions.nodesIn(sourceFile, SETUP))
         if (isVariableStatement(node))
             for (const declaration of node.declarationList.declarations)
                 if (isIdentifier(declaration.name)) names.push(declaration.name)
-    refuseDeclared(sourceFile.statements, spans.scriptsEnd, file)
-    const reads: Read[] = []
+    refuseDeclared(sourceFile.statements, scriptsEnd, file)
     // 33's pass runs whatever 31.3's found: a `props` pattern binds no name the walk
     // above collects — `const { amount } = props()` declares a PATTERN — so a file
     // whose only declaration is one would have returned with its props unread.
@@ -186,22 +179,21 @@ export async function readsIn(
         abide,
         sourceFile,
         shadowPath,
-        spans.scriptsEnd,
-        spans.positions,
-        reads,
+        scriptsEnd,
+        positions,
     )
     // 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, reads)
-    const rows = rowReads(checker, sourceFile, shadowPath, spans, reads)
-    const configs = configReads(
+    const params = routeReads(checker, abide, sourceFile)
+    const rows = rowReads(
         checker,
-        abide,
         sourceFile,
-        spans.servers,
-        reads,
+        shadowPath,
+        positions,
+        new Set(projection.items.values()),
     )
+    const configs = configReads(checker, abide, sourceFile, projection.servers)
     // No name is no round trip to ask about none.
     const symbols =
         names.length === 0 ? [] : await checker.getSymbolAtLocation(names)
@@ -249,30 +241,34 @@ export async function readsIn(
     const owned = await ownMembers(checker, nodes.flat(), (node) =>
         valueTypeOf(checker, node),
     )
+    const lifted = await liftedMutators(checker, nodes.flat(), (node) =>
+        valueTypeOf(checker, node),
+    )
     const holding: Promise<void>[] = []
     const located: { node: Node; read: Read }[] = []
+    const named: Read[] = []
     for (let index = 0; index < nodes.length; index += 1)
         for (const node of nodes[index] as (Node | undefined)[]) {
             if (node === undefined) continue
-            const read = classifyRead(node, owned.has(node))
+            const read = classifyRead(node, owned.has(node), lifted.has(node))
             if (read === undefined) continue
             read.byValue = byValue[index] as boolean
             read.local = index >= topLevel
-            reads.push(read)
+            named.push(read)
             located.push({ node, read })
             if (read.shape === 'value')
                 holding.push(holdIn(checker, abide, node, read))
         }
     await Promise.all(holding)
-    await props
-    await params
-    await rows
-    await configs
+    const reads = [
+        ...(await props),
+        ...(await params),
+        ...(await rows),
+        ...(await configs),
+        ...named,
+    ]
     const statics = new Set<number>()
-    const expressions = spans.positions.nodesIn(
-        sourceFile,
-        TEMPLATE_EXPRESSIONS,
-    )
+    const expressions = positions.nodesIn(sourceFile, TEMPLATE_EXPRESSIONS)
     const rawCallees: Node[] = []
     for (const { position, node } of expressions)
         expressionFacts(
@@ -281,15 +277,15 @@ export async function readsIn(
         )
     // A `Reactive` the page named `raw` is a read, and the read's rewrite is the answer.
     if (rawCallees.length > 0) {
-        const named = new Set<number>()
-        for (const one of reads) named.add(one.start)
+        const starts = new Set<number>()
+        for (const one of reads) starts.add(one.start)
         for (const callee of rawCallees)
-            if (!named.has(callee.getStart()))
+            if (!starts.has(callee.getStart()))
                 reads.push(newRead(callee.getStart(), callee.end, 'raw'))
     }
     await proveSlots(checker, expressions, reads, statics)
     reads.sort(byPosition)
-    const warnings = await warningsFor(checker, located, spans.positions)
+    const warnings = await warningsFor(checker, located, positions)
     // 34.18.
     for (const warning of await sharedModuleWrites(
         checker,
@@ -297,8 +293,8 @@ export async function readsIn(
         names.slice(0, topLevel),
         symbols,
         reactive,
-        spans.modules,
-        spans.scripts,
+        projection.modules,
+        projection.scripts,
     ))
         warnings.push(warning)
     const answer = new CheckerAnswer(reads, statics)
@@ -317,7 +313,7 @@ export async function readsIn(
 
 /**
  * Where each binding starts whose type the projection cannot vouch for, for the lowered program to
- * answer (`TypeSession.classify`).
+ * answer (`reactiveReads`).
  *
  * 31.1 — A BINDING TYPED FROM A READ IS TYPED FROM THE `Reactive` IN THE PROJECTION, and the read is
  * of its value. `reactive(route.url.pathname)` asks a `Reactive<URL>` for a `pathname` it does not
@@ -549,7 +545,7 @@ function annotated(
 async function proveSlots(
     checker: Checker,
     expressions: readonly { position: Position; node: Node }[],
-    reads: Read[],
+    reads: readonly Read[],
     /** Where each position it proves static starts, added to. */
     statics: Set<number>,
 ): Promise<void> {
@@ -761,9 +757,9 @@ async function routeReads(
     checker: Checker,
     abide: Abide,
     sourceFile: Node,
-    reads: Read[],
-): Promise<void> {
-    if (abide.route === undefined) return
+): Promise<Read[]> {
+    const reads: Read[] = []
+    if (abide.route === undefined) return reads
     const accesses: Node[] = []
     const owners: Node[] = []
     const visit = (node: Node): void => {
@@ -779,7 +775,7 @@ async function routeReads(
         node.forEachChild(visit)
     }
     sourceFile.forEachChild(visit)
-    if (owners.length === 0) return
+    if (owners.length === 0) return reads
     const symbols = await checker.getSymbolAtLocation(owners)
     for (let at = 0; at < accesses.length; at += 1) {
         const symbol = symbols[at]
@@ -794,6 +790,7 @@ async function routeReads(
             (access as { name?: { text: string } }).name?.text === 'params'
         reads.push(read)
     }
+    return reads
 }
 
 /**
@@ -810,10 +807,12 @@ async function rowReads(
     checker: Checker,
     sourceFile: Node,
     shadowPath: string,
-    spans: ShadowSpans,
-    reads: Read[],
-): Promise<void> {
-    if (spans.items.size === 0) return
+    positions: PositionTable,
+    /** Where each `{#for}` row's item binding starts. */
+    items: Set<number>,
+): Promise<Read[]> {
+    const reads: Read[] = []
+    if (items.size === 0) return reads
     const bound: Node[] = []
     const loops: Node[] = []
     const bind = (name: Node | undefined, loop: Node): void => {
@@ -828,12 +827,12 @@ async function rowReads(
                 bind((element as { name?: Node }).name, loop)
     }
     const visit = (node: Node): void => {
-        const declared = rowItemOf(node, spans.items)
+        const declared = rowItemOf(node, items)
         if (declared !== undefined) bind(declared, node)
         node.forEachChild(visit)
     }
     sourceFile.forEachChild(visit)
-    if (bound.length === 0) return
+    if (bound.length === 0) return reads
     const symbols = await checker.getSymbolAtLocation(bound)
     const found = await Promise.all(
         symbols.map(async (symbol) =>
@@ -852,12 +851,12 @@ async function rowReads(
     for (let at = 0; at < found.length; at += 1) {
         const name = bound[at] as Node
         const loop = loops[at] as Node
-        const item = (rowItemOf(loop, spans.items) as Node).getStart()
+        const item = (rowItemOf(loop, items) as Node).getStart()
         for (const node of found[at] as (Node | undefined)[]) {
             if (node === undefined || node === name) continue
             if (
-                spans.positions.holding(node.getStart())?.kind === 'key' &&
-                rowLoopOf(node, spans.items) === loop
+                positions.holding(node.getStart())?.kind === 'key' &&
+                rowLoopOf(node, items) === loop
             )
                 continue
             const read = classifyPropRead(node)
@@ -866,6 +865,7 @@ async function rowReads(
             reads.push(read)
         }
     }
+    return reads
 }
 
 /** The item binding `node` declares, where it is a `{#for}` row loop. */
@@ -933,7 +933,7 @@ 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`.
+ * its callee.
  *
  * 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.
@@ -943,9 +943,9 @@ async function configReads(
     abide: Abide,
     sourceFile: Node & { statements: readonly Node[] },
     servers: Span,
-    reads: Read[],
-): Promise<void> {
-    if (abide.onConfig === undefined) return
+): Promise<Read[]> {
+    const reads: Read[] = []
+    if (abide.onConfig === undefined) return reads
     const callees: Node[] = []
     for (const statement of sourceFile.statements) {
         const start = statement.getStart()
@@ -958,7 +958,7 @@ async function configReads(
         )
             callees.push(statement.expression.expression)
     }
-    if (callees.length === 0) return
+    if (callees.length === 0) return reads
     const named = await checker.getSymbolAtLocation(callees)
     for (let at = 0; at < callees.length; at += 1) {
         const symbol = named[at]
@@ -972,10 +972,11 @@ async function configReads(
         const node = callees[at] as Node
         reads.push(newRead(node.getStart(), node.end, 'config'))
     }
+    return reads
 }
 
 /**
- * The reads a `props<Props>()` destructuring contributes, pushed onto `reads`.
+ * The reads a `props<Props>()` destructuring contributes.
  *
  * 33 — WHAT `props<Props>()` BINDS, and it is a second question from 31.3's rather than a case of
  * it: a prop is not a `Reactive` and is not typed as one, so no type answers this. The CALLEE
@@ -997,8 +998,8 @@ async function propsReads(
     shadowPath: string,
     scriptsEnd: number,
     positions: PositionTable,
-    reads: Read[],
-): Promise<void> {
+): Promise<Read[]> {
+    const reads: Read[] = []
     // The spelling only says which calls are worth asking about; the callee says which are abide's.
     const calls: { pattern: Node; call: Node; local: boolean }[] = []
     const callees: Node[] = []
@@ -1024,7 +1025,7 @@ async function propsReads(
     // 32.40 — AND EACH INLINE COMPONENT'S HEAD, inside the function it is projected as. Its names
     // are that function's, so a read of one is local as a branch-local name is (14.8).
     for (const { node } of positions.nodesIn(sourceFile, HEAD)) take(node, true)
-    if (calls.length === 0 || abide.props === undefined) return
+    if (calls.length === 0 || abide.props === undefined) return reads
     const named = await checker.getSymbolAtLocation(callees)
     // One entry per name a pattern binds: the key it takes, the call's read its key joins where
     // the child writes it, and its default's pair.
@@ -1091,7 +1092,7 @@ async function propsReads(
             })
         }
     }
-    if (bound.length === 0) return
+    if (bound.length === 0) return reads
 
     const symbols = await checker.getSymbolAtLocation(bound)
     const found = await Promise.all(
@@ -1111,6 +1112,9 @@ async function propsReads(
     const owned = await ownMembers(checker, found.flat(), (node) =>
         checker.getTypeAtLocation(node),
     )
+    const lifted = await liftedMutators(checker, found.flat(), (node) =>
+        checker.getTypeAtLocation(node),
+    )
     // 33.27 — each prop asked whether its position holds the `Reactive`, all at once.
     const holding: Promise<void>[] = []
     for (let at = 0; at < found.length; at += 1) {
@@ -1128,11 +1132,12 @@ async function propsReads(
                 node.parent?.kind === SyntaxKind.BindingElement
             )
                 continue
-            const read = classifyRead(node, owned.has(node))
+            const read = classifyRead(node, owned.has(node), lifted.has(node))
             if (read === undefined) continue
             if (
                 read.shape === 'write' ||
                 read.shape === 'update' ||
+                read.shape === 'mutate' ||
                 isBindOperand(positions, node) ||
                 writesThrough(node, owned)
             )
@@ -1178,6 +1183,7 @@ async function propsReads(
         }
     }
     await Promise.all(holding)
+    return reads
 }
 
 /**
@@ -1232,6 +1238,108 @@ async function ownMembers(
     return owned
 }
 
+/**
+ * 31.9 — the occurrences among `nodes` that call an array mutator through a member path, where the
+ * receiver's type is an array: `tags.push(t)`, `deal.notes.splice(0, 1)`. The name says which
+ * method and the type says whose, so a class's own `push` is left a call on the class.
+ *
+ * The receiver's type is walked down from the value's, step by step: in the projection a member of
+ * the name is the `Reactive`'s, which declares none of the value's.
+ */
+async function liftedMutators(
+    checker: Checker,
+    nodes: readonly (Node | undefined)[],
+    valueOf: (node: Node) => Promise<Type | undefined>,
+): Promise<Set<Node>> {
+    const lifted = new Set<Node>()
+    const asked: Promise<void>[] = []
+    for (const node of nodes) {
+        if (node === undefined) continue
+        const steps: (string | undefined)[] = []
+        let receiver: Node = node
+        let mutator = false
+        while (true) {
+            const up = receiver.parent
+            if (isPropertyAccessExpression(up) && up.expression === receiver) {
+                if (
+                    ARRAY_MUTATORS.has(up.name.text) &&
+                    isCallExpression(up.parent) &&
+                    up.parent.expression === up
+                ) {
+                    mutator = true
+                    break
+                }
+                steps.push(up.name.text)
+            } else if (
+                isElementAccessExpression(up) &&
+                up.expression === receiver
+            )
+                steps.push(undefined)
+            else break
+            receiver = up
+        }
+        if (!mutator) continue
+        asked.push(
+            valueOf(node).then(async (value) => {
+                if (value === undefined) return
+                let types: Type[] = [value]
+                for (const step of steps)
+                    types = await stepTypes(checker, types, step)
+                if (types.length === 0) return
+                for (const type of types)
+                    if (
+                        !(await checker.isArrayType(type)) &&
+                        !(await checker.isTupleType(type))
+                    )
+                        return
+                lifted.add(node)
+            }),
+        )
+    }
+    await Promise.all(asked)
+    return lifted
+}
+
+/**
+ * The types one step down from `types`, `null` and `undefined` aside: a property's by its name, and
+ * an element's or an index signature's where the step is computed.
+ */
+async function stepTypes(
+    checker: Checker,
+    types: readonly Type[],
+    step: string | undefined,
+): Promise<Type[]> {
+    const next: Type[] = []
+    for (const type of types)
+        for (const held of await unionMembers(type)) {
+            if ((held.flags & NULLISH) !== 0) continue
+            if (step !== undefined) {
+                const member = await checker.getPropertyOfType(held, step)
+                const stepped =
+                    member === undefined
+                        ? undefined
+                        : await checker.getTypeOfSymbol(member)
+                if (stepped !== undefined)
+                    next.push(...(await unionMembers(stepped)))
+                continue
+            }
+            if (await checker.isArrayType(held)) {
+                const [element] = await checker.getTypeArguments(
+                    held as TypeReference,
+                )
+                if (element !== undefined)
+                    next.push(...(await unionMembers(element)))
+                continue
+            }
+            for (const index of await checker.getIndexInfosOfType(held))
+                next.push(...(await unionMembers(index.valueType)))
+        }
+    const present: Type[] = []
+    for (const type of next)
+        if ((type.flags & NULLISH) === 0) present.push(type)
+    return present
+}
+
 /**
  * 31.7, 33.6, 33.7 — `n.set(v)` and `n.patch(…)` are writes by name, called or handed on, where the
  * value's own type declares no member of that name — a `Map`'s `set` writes the map, not the prop.
@@ -1323,15 +1431,6 @@ function isBindOperand(positions: PositionTable, node: Node): boolean {
     return holdsReactive(positions.of(node))
 }
 
-async function isReactiveSymbol(
-    checker: Checker,
-    abide: Abide,
-    symbol: CheckedSymbol,
-): Promise<boolean> {
-    const type = await checker.getTypeOfSymbol(symbol)
-    return type !== undefined && isReactiveType(checker, abide, type, false)
-}
-
 /**
  * Orders reads by offset, a default's open before a read at the same offset and its close after.
  *

package/src/compiler/routesDeclaration.ts

@@ -0,0 +1,46 @@
+import { parseRoutePattern } from '#shared/routePattern.ts'
+
+import type { AppRoute } from './appLayout.ts'
+
+const URL_SOURCE = Bun.fileURLToPath(new URL('../shared/url', import.meta.url))
+
+/**
+ * 30.26 — each of `addresses` as a key of abide's `Routes`, and 23.9, 30.3 — a page route's params
+ * narrowed where its matcher is an alternation of literals, which is the one matcher a type can say.
+ */
+export function routesDeclaration(
+    addresses: readonly string[],
+    routes: readonly AppRoute[],
+): string {
+    const narrowed = new Map<string, string>()
+    for (const route of routes) {
+        let members = ''
+        for (const segment of parseRoutePattern(route.pattern)) {
+            if (segment.kind !== 'required' && segment.kind !== 'optional')
+                continue
+            const literals = literalsOf(
+                segment.matcher === undefined
+                    ? undefined
+                    : route.matchers[segment.matcher],
+            )
+            if (literals === undefined) continue
+            members += ` ${JSON.stringify(segment.name)}${segment.kind === 'optional' ? '?' : ''}: ${literals};`
+        }
+        if (members !== '') narrowed.set(route.pattern, `{${members} }`)
+    }
+    let keys = ''
+    for (const route of addresses)
+        keys += `        ${JSON.stringify(route)}: ${narrowed.get(route) ?? 'true'}\n`
+    return `export {}\ndeclare module ${JSON.stringify(URL_SOURCE)} {\n    interface Routes {\n${keys}    }\n}\n`
+}
+
+/** The union of the literals an anchored matcher source alternates between, or `undefined`. */
+function literalsOf(source: string | undefined): string | undefined {
+    const body = source?.match(/^\^\(\?!\\\.\\\.\?\$\)\(\?:(.*)\)\$$/)?.[1]
+    if (body === undefined || !/^[\w~-]+(?:\|[\w~-]+)*$/.test(body))
+        return undefined
+    return body
+        .split('|')
+        .map((literal) => JSON.stringify(literal))
+        .join(' | ')
+}

package/src/compiler/scaffold.ts

@@ -40,14 +40,19 @@ const SOURCE_ALIAS = { '#src/*': ['./src/*', './src/*.ts'] }
  * lands first on the PATH inside `bun run`, shadowing the bun that runs everything else.
  */
 export const BUNFIG =
-    '# 38.122 — a peer is not installed: an installed `bun` would shadow this one inside `bun run`.\n[install]\npeer = false\n\n# 38.43, 38.131 — the plugin that builds the stylesheet `src/lib/app.css` opens.\n[serve.static]\nplugins = ["bun-plugin-tailwind"]\n\n# 38.109, 38.119 — a DOM to mount into and measure, then the app\'s `.abide` files as modules.\n[test]\nroot = "src"\npreload = ["@abide/harness/abide/preload"]\n\n# What `bun fmt` and `abide format` print.\n[fmt]\ntabWidth = 4\nsemi = false\nsingleQuote = true\nsortImports = true\n'
+    '# 38.122 — no peers: an installed `bun` would shadow this one in `bun run`.\n[install]\npeer = false\n\n# 38.43, 38.131 — the plugin building the stylesheet `src/lib/app.css` opens.\n[serve.static]\nplugins = ["bun-plugin-tailwind"]\n\n# 38.109, 38.119 — a DOM to measure in, then the `.abide` files as modules.\n[test]\nroot = "src"\npreload = ["@abide/harness/abide/preload"]\n\n# What `bun fmt` and `abide format` print.\n[fmt]\ntabWidth = 4\nsemi = false\nsingleQuote = true\nsortImports = true\n'
 
 // WRITTEN, NOT COPIED, beside the manifests: a packer drops a `bunfig.toml` or a `.gitignore` from
-// the tarball (`bun pm pack` both, `npm pack` the second), so neither survives as a starter file.
+// the tarball (`bun pm pack` both, `npm pack` the second), so neither survives as a starter file —
+// and the Dockerfile names the bun that is running, which no file can.
 function filesFor(name: string): Record<string, string> {
     return {
         'bunfig.toml': BUNFIG,
         '.gitignore': 'node_modules\n.abide\n',
+        // 38.132 — the build stage on the bun that scaffolded the project, the image on nothing but
+        // the executable it compiles.
+        Dockerfile: `FROM oven/bun:${Bun.version} AS build\nWORKDIR /app\nCOPY package.json bun.lock bunfig.toml ./\nRUN bun install --frozen-lockfile\nCOPY . .\nRUN bun x abide compile --out /app/server\n\nFROM gcr.io/distroless/cc-debian12\nCOPY --from=build /app/server /server\nENV NODE_ENV=production\nEXPOSE 3000\nCMD ["/server", "start"]\n`,
+        '.dockerignore': 'node_modules\n.abide\n.git\n.env\n.env.*\n',
         'package.json': `${JSON.stringify(
             {
                 name,