@abide/abide 0.28.0

package/src/lib/ui/compile/generateSSR.ts

@@ -0,0 +1,380 @@
+import { OUTLET_TAG } from '../runtime/OUTLET_TAG.ts'
+import { branchElements } from './branchElements.ts'
+import { escapeHtml } from './escapeHtml.ts'
+import { groupBindParts } from './groupBindParts.ts'
+import { lowerDocAccess } from './lowerDocAccess.ts'
+import { partitionSlots } from './partitionSlots.ts'
+import { nestedBindingNames } from './prepareNestedScript.ts'
+import { renameSignalRefs } from './renameSignalRefs.ts'
+import { staticAttrValue } from './staticAttrValue.ts'
+import { stripEffects } from './stripEffects.ts'
+import type { TemplateNode } from './types/TemplateNode.ts'
+import { VOID_TAGS } from './VOID_TAGS.ts'
+
+/*
+Server code generator: turns the parsed template into statements that push HTML
+fragments onto an output array, reading the document synchronously (no DOM, no
+listeners). Same expression lowering as the client back-end, so server and client
+render the same markup. Dynamic values go through `$esc`; `if` is a plain `if`,
+`each` a `for…of`.
+
+An `await` block emits boundary comments (`<!--abide:await:N-->…<!--/abide:await:N-->`)
+and registers the promise plus its resolved/error string-renderers on `$awaits`. A
+streaming block (no `then` on the tag) puts its pending branch between the markers;
+`renderToStream` flushes each resolved fragment out of order — the await-block-streams
+half of the cache rule. A blocking block (`then` on the tag) emits an empty boundary
+and flags the entry, so `renderToStream` settles it before the first flush.
+*/
+export function generateSSR(
+    nodes: TemplateNode[],
+    stateNames: ReadonlySet<string>,
+    derivedNames: ReadonlySet<string>,
+    isLayout = false,
+): string {
+    /* Compile-time counter for unique temp var names (runtime block ids, child render
+       results) — block ids themselves are allocated at runtime via nextBlockId(). */
+    let varCounter = 0
+    const nextVar = (prefix: string): string => `${prefix}${varCounter++}`
+
+    /* Branch-scoped nested-script bindings, deref'd to `.value` (see generateBuild). */
+    const localDerived = new Set<string>()
+    const derefScope = (): ReadonlySet<string> =>
+        localDerived.size === 0 ? derivedNames : new Set([...derivedNames, ...localDerived])
+
+    function lowerExpression(code: string): string {
+        return lowerDocAccess(renameSignalRefs(code, stateNames, derefScope()), 'model')
+            .trim()
+            .replace(/;$/, '')
+    }
+
+    /* Lowers a scoped-script body for SSR: rename refs, lower doc access, then strip
+       effects (client-only lifecycle that emits no HTML). */
+    function lowerScript(code: string): string {
+        return stripEffects(
+            lowerDocAccess(renameSignalRefs(code, stateNames, derefScope()), 'model').trim(),
+        )
+    }
+
+    function push(target: string, literal: string): string {
+        return `${target}.push(${JSON.stringify(literal)});\n`
+    }
+
+    function generateInto(children: TemplateNode[], target: string): string {
+        return children.map((child) => generate(child, target)).join('')
+    }
+
+    /* A control-flow branch's body: run its nested `<script>`s (lowered, in scope)
+       first, then push the element markup — so SSR re-seeds the same local signals
+       the client build does, keeping hydration aligned. */
+    function branchInto(children: TemplateNode[], context: string, target: string): string {
+        const added: string[] = []
+        for (const child of children) {
+            if (child.kind === 'script') {
+                for (const name of nestedBindingNames(child.code)) {
+                    if (!localDerived.has(name)) {
+                        localDerived.add(name)
+                        added.push(name)
+                    }
+                }
+            }
+        }
+        const scriptCode = children
+            .filter(
+                (child): child is Extract<TemplateNode, { kind: 'script' }> =>
+                    child.kind === 'script',
+            )
+            .map((child) => `${lowerScript(child.code)}\n`)
+            .join('')
+        const markup = generateInto(branchElements(children, context, true), target)
+        for (const name of added) {
+            localDerived.delete(name)
+        }
+        return scriptCode + markup
+    }
+
+    function generate(node: TemplateNode, target: string): string {
+        if (node.kind === 'text') {
+            return node.parts
+                .map((part) => {
+                    if (part.kind === 'static') {
+                        return part.value.trim() === '' ? '' : push(target, escapeHtml(part.value))
+                    }
+                    return `${target}.push($text(${lowerExpression(part.code)}));\n`
+                })
+                .join('')
+        }
+        if (node.kind === 'if') {
+            const elseBranch = node.children.find((child) => child.kind === 'case')
+            const thenChildren = node.children.filter((child) => child.kind !== 'case')
+            let code = `if (${lowerExpression(node.condition)}) {\n${branchInto(thenChildren, '<template if>', target)}}`
+            if (elseBranch !== undefined && elseBranch.kind === 'case') {
+                code += ` else {\n${branchInto(elseBranch.children, '<template else>', target)}}`
+            }
+            return `${code}\n`
+        }
+        if (node.kind === 'switch') {
+            const cases = node.children.filter(
+                (child): child is Extract<TemplateNode, { kind: 'case' }> => child.kind === 'case',
+            )
+            let code = `{ const $s = (${lowerExpression(node.subject)});\n`
+            let started = false
+            for (const branch of cases) {
+                if (branch.match !== undefined) {
+                    code += `${started ? 'else ' : ''}if ($s === (${lowerExpression(branch.match)})) {\n${branchInto(branch.children, '<template case>', target)}}\n`
+                    started = true
+                }
+            }
+            const fallback = cases.find((branch) => branch.match === undefined)
+            if (fallback !== undefined) {
+                code += `${started ? 'else ' : ''}{\n${branchInto(fallback.children, '<template case>', target)}}\n`
+            }
+            return `${code}}\n`
+        }
+        if (node.kind === 'case') {
+            return ''
+        }
+        if (node.kind === 'snippet') {
+            /* A hoisted function returning the snippet's `$snip`-branded HTML string;
+               `{name(args)}` pushes it via `$text`, which wraps it in markers. */
+            const body = generateInto(node.children, '$o')
+            return `function ${node.name}(${node.params ?? ''}) {\nconst $o = [];\n${body}return $snip($o.join(''));\n}\n`
+        }
+        if (node.kind === 'script') {
+            /* A scoped reactive block: re-seed its local signals (lowered, in scope)
+               so SSR renders the same values the client build will. */
+            return `${lowerScript(node.code)}\n`
+        }
+        /* A `<style>` emits no markup — its scope attribute is already on the elements
+           it covers (above) and its CSS is bundled, not inlined. */
+        if (node.kind === 'style') {
+            return ''
+        }
+        if (node.kind === 'each') {
+            /* Async each (`await`) is drained on the client — render no rows on the
+               server (an infinite stream would hang SSR); the client inserts its anchor
+               before the next sibling during hydration, like an empty sync each. */
+            if (node.async) {
+                return ''
+            }
+            return `for (const ${node.as} of (${lowerExpression(node.items)})) {\n${branchInto(node.children, '<template each>', target)}}\n`
+        }
+        if (node.kind === 'await') {
+            return generateAwait(node, target)
+        }
+        if (node.kind === 'try') {
+            return generateTry(node, target)
+        }
+        if (node.kind === 'branch') {
+            return ''
+        }
+        if (node.kind === 'component') {
+            /* Server-render the child via its `render` and inline the HTML inside
+               the same wrapper the client mounts into, so SSR and client agree.
+               Props pass as thunks; slot content passes as a string-returning
+               `$children` the child invokes from its <slot>. */
+            const tag = node.name.toLowerCase()
+            const parts = node.props.map(
+                (prop) => `${JSON.stringify(prop.name)}: () => (${lowerExpression(prop.code)})`,
+            )
+            const groups = partitionSlots(node.children)
+            const slotCode = generateInto(groups.default, '$slot')
+            if (slotCode.trim() !== '') {
+                parts.push(
+                    `"$children": () => { const $slot = []; ${slotCode}return $slot.join(''); }`,
+                )
+            }
+            if (groups.named.length > 0) {
+                const entries = groups.named
+                    .map((group) => {
+                        const code = generateInto(group.nodes, '$slot')
+                        return `${JSON.stringify(group.name)}: () => { const $slot = []; ${code}return $slot.join(''); }`
+                    })
+                    .join(', ')
+                parts.push(`"$slots": { ${entries} }`)
+            }
+            /* Render the child and MERGE its await blocks into this page's `$awaits`
+               so they join the page's SSR stream — their markers carry render-pass
+               block ids (nextBlockId), unique across page + children, so the streamed
+               fragments resolve into the right boundaries. ($awaits is captured from
+               the enclosing render body, including from branch closures.) */
+            const result = nextVar('$child')
+            return (
+                push(target, `<${tag}>`) +
+                `const ${result} = ${node.name}.render({ ${parts.join(', ')} });\n` +
+                `${target}.push(${result}.html);\n` +
+                `for (const $a of ${result}.awaits) { $awaits.push($a); }\n` +
+                push(target, `</${tag}>`)
+            )
+        }
+        if (node.kind === 'element' && node.tag === 'slot') {
+            /* A layout's unnamed `<slot/>` is the router's page outlet: emit an empty
+               placeholder the chain composer folds the child layer's html into. */
+            if (isLayout && staticAttrValue(node, 'name') === undefined) {
+                return push(target, `<${OUTLET_TAG}></${OUTLET_TAG}>`)
+            }
+            return generateSlot(node, target)
+        }
+        let code = push(target, `<${node.tag}`)
+        /* Every `<style>` active at this element (own siblings + ancestors) — same set
+           the client stamps, so server and client markup carry identical attributes. */
+        for (const scope of node.scopes ?? []) {
+            code += push(target, ` ${scope}=""`)
+        }
+        for (const attr of node.attrs) {
+            if (attr.kind === 'static') {
+                /* Escape the literal value so a `"`/`&`/`<` in it can't break out of
+                   the attribute or inject markup (the client uses setAttribute, which
+                   needs no escaping — escaping here keeps SSR and client in sync). */
+                code += push(target, ` ${attr.name}="${escapeHtml(attr.value)}"`)
+            } else if (attr.kind === 'expression') {
+                /* present/absent semantics matching the client `attr` binding:
+                   false/null/undefined drops it, true emits the bare attribute. */
+                code += `${target}.push($attr(${JSON.stringify(attr.name)}, ${lowerExpression(attr.code)}));\n`
+            } else if (attr.kind === 'bind' && attr.property === 'group') {
+                /* Render the checked state as a boolean attribute: present when the
+                   path holds (radio) or contains (checkbox) this control's value. */
+                const { valueCode, isRadio } = groupBindParts(node)
+                const present = isRadio
+                    ? `(${lowerExpression(attr.code)}) === (${lowerExpression(valueCode)})`
+                    : `(${lowerExpression(attr.code)}).includes(${lowerExpression(valueCode)})`
+                code += `${target}.push((${present}) ? ' checked' : '');\n`
+            } else if (attr.kind === 'bind' && attr.property === 'checked') {
+                /* A boolean property — its mere presence means checked, so emit the
+                   attribute only when truthy (a string `checked="false"` still checks). */
+                code += `${target}.push((${lowerExpression(attr.code)}) ? ' checked' : '');\n`
+            } else if (attr.kind === 'bind') {
+                code += `${target}.push(${JSON.stringify(` ${attr.property}="`)} + $esc(${lowerExpression(attr.code)}) + '"');\n`
+            }
+        }
+        code += push(target, '>')
+        if (!VOID_TAGS.has(node.tag)) {
+            /* A `<script>` child scopes its bindings to this element's subtree. */
+            const added: string[] = []
+            for (const child of node.children) {
+                if (child.kind === 'script') {
+                    for (const name of nestedBindingNames(child.code)) {
+                        if (!localDerived.has(name)) {
+                            localDerived.add(name)
+                            added.push(name)
+                        }
+                    }
+                }
+            }
+            code += generateInto(node.children, target)
+            for (const name of added) {
+                localDerived.delete(name)
+            }
+            code += push(target, `</${node.tag}>`)
+        }
+        return code
+    }
+
+    /* A `<slot>` outlet: emit the parent-provided content for this slot (default
+       via `$children`, named via `$slots[name]`), falling back to the slot's own
+       children when none was supplied. */
+    function generateSlot(
+        node: Extract<TemplateNode, { kind: 'element' }>,
+        target: string,
+    ): string {
+        const name = staticAttrValue(node, 'name')
+        const guard =
+            name === undefined
+                ? '$props && $props.$children'
+                : `$props && $props.$slots && $props.$slots[${JSON.stringify(name)}]`
+        const provided =
+            name === undefined ? '$props.$children' : `$props.$slots[${JSON.stringify(name)}]`
+        const fallback = generateInto(node.children, target)
+        if (fallback.trim() === '') {
+            return `if (${guard}) { ${target}.push(${provided}()); }\n`
+        }
+        return `if (${guard}) { ${target}.push(${provided}()); } else {\n${fallback}}\n`
+    }
+
+    /* Boundary markers + a `$awaits` registration carrying the promise and
+       string-renderers for the resolved/error branches. Streaming emits the pending
+       branch between the markers (flushed now, value streamed later); blocking emits
+       an empty boundary — its resolved branch is the children bound to `node.as` — and
+       flags the entry so `renderToStream` settles it before the first flush. */
+    function generateAwait(node: Extract<TemplateNode, { kind: 'await' }>, target: string): string {
+        const branchOf = (which: 'then' | 'catch' | 'finally') =>
+            node.children.find(
+                (child): child is Extract<TemplateNode, { kind: 'branch' }> =>
+                    child.kind === 'branch' && child.branch === which,
+            )
+        const catchBranch = branchOf('catch')
+        const finallyChildren = branchOf('finally')?.children ?? []
+        /* Resolved branch + its bound value: the children directly when blocking, the
+           `then` child when streaming. Pending (streaming only) is the non-branch
+           children. */
+        const thenBranch = branchOf('then')
+        const resolvedChildren = node.blocking
+            ? node.children.filter((child) => child.kind !== 'branch')
+            : (thenBranch?.children ?? [])
+        const resolvedAs = node.blocking ? node.as : thenBranch?.as
+        const pending = node.blocking
+            ? []
+            : node.children.filter((child) => child.kind !== 'branch')
+        /* Runtime block id (shared with the client + child components in this pass). */
+        const id = nextVar('$aid')
+        let code = `const ${id} = nextBlockId();\n`
+        code += `${target}.push("<!--abide:await:" + ${id} + "-->");\n`
+        code += branchInto(pending, '<template await> pending', target)
+        code += `${target}.push("<!--/abide:await:" + ${id} + "-->");\n`
+        /* The settled closures append `finally` after the outcome markup, matching the
+           client's concatenated node range so hydration aligns. */
+        const settled = (binding: string, children: TemplateNode[], context: string) =>
+            `(${binding}) => { const $o = []; ${branchInto(children, context, '$o')}${branchInto(finallyChildren, '<template finally>', '$o')}return $o.join(''); }`
+        /* Neither catch nor finally → omit `catch` so a rejection surfaces to the
+           stream/error path (renderToStream re-throws) instead of rendering an empty
+           branch. A finally-only block keeps a catch closure that renders just finally. */
+        const catchProp =
+            catchBranch === undefined && finallyChildren.length === 0
+                ? ''
+                : `catch: ${settled(catchBranch?.as ?? '_error', catchBranch?.children ?? [], '<template catch>')} `
+        code +=
+            `$awaits.push({ id: ${id}, ` +
+            (node.blocking ? 'blocking: true, ' : '') +
+            `promise: () => (${lowerExpression(node.promise)}), ` +
+            `then: ${settled(resolvedAs ?? '_value', resolvedChildren, node.blocking ? '<template await then>' : '<template then>')}, ` +
+            `${catchProp}});\n`
+        return code
+    }
+
+    /* A sync error boundary: push the guarded markup (++ finally) inside a real
+       try/catch; on a throw, truncate the output back to the boundary start and push
+       the catch markup (++ finally) instead — so even mid-stream a render throw
+       becomes catch markup, not a broken response. No catch re-throws (propagates to
+       an enclosing boundary / the 500 / the stream). Boundary comments let hydration
+       discard the server content if the client adoption fails. */
+    function generateTry(node: Extract<TemplateNode, { kind: 'try' }>, target: string): string {
+        const branchOf = (which: 'catch' | 'finally') =>
+            node.children.find(
+                (child): child is Extract<TemplateNode, { kind: 'branch' }> =>
+                    child.kind === 'branch' && child.branch === which,
+            )
+        const catchBranch = branchOf('catch')
+        const finallyChildren = branchOf('finally')?.children ?? []
+        const guarded = node.children.filter((child) => child.kind !== 'branch')
+        const errName = catchBranch?.as ?? '_error'
+        const id = nextVar('$tid')
+        const mark = nextVar('$trim')
+        let code = `const ${id} = nextBlockId();\n`
+        code += `${target}.push("<!--abide:try:" + ${id} + "-->");\n`
+        code += `const ${mark} = ${target}.length;\n`
+        code += `try {\n`
+        code += branchInto(guarded, '<template try>', target)
+        code += branchInto(finallyChildren, '<template finally>', target)
+        code += `} catch (${errName}) {\n${target}.length = ${mark};\n`
+        if (catchBranch !== undefined) {
+            code += branchInto(catchBranch.children, '<template catch>', target)
+            code += branchInto(finallyChildren, '<template finally>', target)
+        } else {
+            code += `throw ${errName};\n`
+        }
+        code += `}\n`
+        code += `${target}.push("<!--/abide:try:" + ${id} + "-->");\n`
+        return code
+    }
+
+    return generateInto(nodes, '$out')
+}

package/src/lib/ui/compile/groupBindParts.ts

@@ -0,0 +1,28 @@
+import { staticAttrValue } from './staticAttrValue.ts'
+import type { TemplateNode } from './types/TemplateNode.ts'
+
+/*
+The pieces a `bind:group` needs from its own element: `valueCode` is the JS source
+of the control's `value` (a string literal for static `value="x"`, the expression
+for `value={expr}`); `isRadio` selects single-value (radio) vs array-membership
+(checkbox) semantics. Throws on the two cases the binding can't mean anything for —
+a missing `value`, or a `type` not statically `radio`/`checkbox` (the semantics are
+chosen at compile time, so the type can't be dynamic).
+*/
+export function groupBindParts(node: Extract<TemplateNode, { kind: 'element' }>): {
+    valueCode: string
+    isRadio: boolean
+} {
+    const value = node.attrs.find(
+        (attr) => (attr.kind === 'static' || attr.kind === 'expression') && attr.name === 'value',
+    )
+    if (value === undefined || (value.kind !== 'static' && value.kind !== 'expression')) {
+        throw new Error('bind:group requires a `value` attribute on the same element')
+    }
+    const valueCode = value.kind === 'static' ? JSON.stringify(value.value) : value.code
+    const type = staticAttrValue(node, 'type')
+    if (type !== 'radio' && type !== 'checkbox') {
+        throw new Error('bind:group requires a static type="radio" or type="checkbox"')
+    }
+    return { valueCode, isRadio: type === 'radio' }
+}

package/src/lib/ui/compile/hoistCells.ts

@@ -0,0 +1,120 @@
+import ts from 'typescript'
+
+/*
+The perf pass that follows `lowerDocAccess`. Within a render scope, a static path
+is read and written many times; resolving it to a node + parent + key on every
+access (what `read`/`replace` do) is the path-string floor the bench measured.
+This hoists each distinct static path to a `cell` bound once at the top of the
+scope and rewrites accesses to the string-free `get`/`set` — the form that runs
+~20x faster than re-resolving:
+
+  model.read("count")          →  _cell0.get()
+  model.replace("count", v)    →  _cell0.set(v)
+  // with, prepended once:        const _cell0 = model.cell("count")
+
+The input is a render-scope body where `docName` is already in scope (the cell
+decls are prepended to it, so the doc must exist first). Dynamic-path accesses
+(`read(`a/${i}`)`) and structural ops (`add`/`remove`) are left untouched — a
+cell binds one fixed scalar leaf.
+*/
+export function hoistCells(code: string, docName: string): string {
+    const source = ts.createSourceFile('component.ts', code, ts.ScriptTarget.Latest, true)
+    const cellIdForPath = new Map<string, string>()
+
+    /* Pass 1: assign a cell id to each distinct static read/replace path. */
+    const collect = (node: ts.Node): void => {
+        const path = staticDocPath(node, docName, 'read') ?? staticDocPath(node, docName, 'replace')
+        if (path !== undefined && !cellIdForPath.has(path)) {
+            cellIdForPath.set(path, `_cell${cellIdForPath.size}`)
+        }
+        ts.forEachChild(node, collect)
+    }
+    collect(source)
+    if (cellIdForPath.size === 0) {
+        return code
+    }
+
+    const result = ts.transform(source, [hoistTransformer(docName, cellIdForPath)])
+    const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed })
+    const output = printer.printFile(result.transformed[0] as ts.SourceFile)
+    result.dispose()
+    return output
+}
+
+/* Returns the literal path of a `docName.method("literal", …)` call, else undefined. */
+function staticDocPath(node: ts.Node, docName: string, method: string): string | undefined {
+    if (
+        ts.isCallExpression(node) &&
+        ts.isPropertyAccessExpression(node.expression) &&
+        ts.isIdentifier(node.expression.expression) &&
+        node.expression.expression.text === docName &&
+        node.expression.name.text === method
+    ) {
+        const first = node.arguments[0]
+        if (first !== undefined && ts.isStringLiteral(first)) {
+            return first.text
+        }
+    }
+    return undefined
+}
+
+function hoistTransformer(
+    docName: string,
+    cellIdForPath: Map<string, string>,
+): ts.TransformerFactory<ts.SourceFile> {
+    return (context) => (root) => {
+        function visit(node: ts.Node): ts.Node {
+            const readPath = staticDocPath(node, docName, 'read')
+            if (readPath !== undefined) {
+                return cellCall(cellIdForPath.get(readPath) as string, 'get', [])
+            }
+            const replacePath = staticDocPath(node, docName, 'replace')
+            if (replacePath !== undefined) {
+                const value = (node as ts.CallExpression).arguments[1]
+                return cellCall(cellIdForPath.get(replacePath) as string, 'set', [
+                    ts.visitNode(value, visit) as ts.Expression,
+                ])
+            }
+            return ts.visitEachChild(node, visit, context)
+        }
+        const visited = ts.visitNode(root, visit) as ts.SourceFile
+        const declarations = [...cellIdForPath].map(([path, id]) =>
+            cellDeclaration(docName, id, path),
+        )
+        return ts.factory.updateSourceFile(visited, [...declarations, ...visited.statements])
+    }
+}
+
+/* Builds `cellId.method(...args)`. */
+function cellCall(cellId: string, method: string, args: ts.Expression[]): ts.CallExpression {
+    return ts.factory.createCallExpression(
+        ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(cellId), method),
+        undefined,
+        args,
+    )
+}
+
+/* Builds `const cellId = docName.cell("path")`. */
+function cellDeclaration(docName: string, cellId: string, path: string): ts.VariableStatement {
+    return ts.factory.createVariableStatement(
+        undefined,
+        ts.factory.createVariableDeclarationList(
+            [
+                ts.factory.createVariableDeclaration(
+                    cellId,
+                    undefined,
+                    undefined,
+                    ts.factory.createCallExpression(
+                        ts.factory.createPropertyAccessExpression(
+                            ts.factory.createIdentifier(docName),
+                            'cell',
+                        ),
+                        undefined,
+                        [ts.factory.createStringLiteral(path)],
+                    ),
+                ),
+            ],
+            ts.NodeFlags.Const,
+        ),
+    )
+}

package/src/lib/ui/compile/loadShadowTsConfig.ts

@@ -0,0 +1,31 @@
+import ts from 'typescript'
+
+/*
+Loads the project's tsconfig (for lib/paths/baseUrl/strictness — the shadows must
+type-check against the same world the app does), then forces the overrides the
+shadow needs: `noUnusedLocals`/`noUnusedParameters` off because the shadow
+legitimately declares scope bindings a template may not read, and `noEmit`/
+`skipLibCheck` because it only ever type-checks. Falls back to permissive defaults
+when no tsconfig is found. Shared by the check Program and the LSP LanguageService.
+*/
+export function loadShadowTsConfig(cwd: string): ts.ParsedCommandLine {
+    const configPath = ts.findConfigFile(cwd, ts.sys.fileExists, 'tsconfig.json')
+    const base = configPath
+        ? ts.parseJsonConfigFileContent(
+              ts.readConfigFile(configPath, ts.sys.readFile).config,
+              ts.sys,
+              cwd,
+          )
+        : { options: {}, fileNames: [], errors: [] }
+    return {
+        ...base,
+        options: {
+            ...base.options,
+            noEmit: true,
+            skipLibCheck: true,
+            noUnusedLocals: false,
+            noUnusedParameters: false,
+            allowUnreachableCode: true,
+        },
+    }
+}