@dokebi/cli 0.4.2 → 0.4.27

package/dist/check/timer-rules.js

@@ -0,0 +1,543 @@
+// The background timer rule of `dokebi check` (D-0105 §1), over the TypeScript AST:
+//   background-timer  (error) server code under src/ (not views/, not tests/) that runs periodic
+//                     work on its own timer instead of @dokebi/scheduler and @dokebi/job:
+//                     - any setInterval (global, node:timers, or the async iterator of
+//                       node:timers/promises),
+//                     - a setTimeout or setImmediate whose callback reschedules it: the callback
+//                       reaches (through the functions and methods of the same file) a function
+//                       that encloses the call (`const tick = () => { …; setTimeout(tick, ms) }`,
+//                       `#schedule() { setTimeout(() => this.#tick()) }` with #tick calling
+//                       #schedule again).
+//                     Not reported: one-shot delays and time limits (a setTimeout whose callback
+//                     does not come back to it: `setTimeout(() => controller.abort(), ms)`,
+//                     `new Promise((resolve) => setTimeout(resolve, ms))`), every awaited sleep
+//                     of node:timers/promises (`await setTimeout(ms, undefined, { signal })`,
+//                     which a job handler uses between bounded batches), and timers owned by one
+//                     connection: inside a function that takes a request, reply, socket or stream
+//                     parameter, or a handler passed to a route method (get, post, …, route),
+//                     unless the timer is stored where it outlives that function (`this.ticker =
+//                     setInterval(…)`, a variable declared outside it: R4 Codex T2 kept one
+//                     worker-wide ticker started by the first stream request).
+// A `// dokebi-check: allow background-timer <reason>` comment keeps a deliberate one (per-process
+// upkeep of in-memory state that no job can reach).
+import { field, nodes, property, } from './typescript.js';
+const CALLBACK_TIMERS = new Set(['setTimeout', 'setInterval', 'setImmediate']);
+const PROMISE_MODULES = new Set(['node:timers/promises', 'timers/promises']);
+const CALLBACK_MODULES = new Set(['node:timers', 'timers']);
+/** Parameters that tie a function to one connection: its timers end with the connection. */
+const CONNECTION_PARAMETERS = new Set([
+    'request',
+    'req',
+    'reply',
+    'res',
+    'response',
+    'socket',
+    'ws',
+    'websocket',
+    'stream',
+]);
+/** Route registration methods: a handler passed to one runs per request. */
+const ROUTE_METHODS = new Set([
+    'get',
+    'post',
+    'put',
+    'patch',
+    'delete',
+    'head',
+    'options',
+    'all',
+    'route',
+]);
+/** Paths the rule reads: server code under src/, without views (browser code) and tests. */
+export function isServerCode(path) {
+    return path.startsWith('src/') && !/(^|\/)(views|public)\//.test(path);
+}
+export const TIMER_FIX = 'run periodic work as a job: register the handler in the setup of the module that owns it (context.getDependency(job).queue(<queue>).handle(<type>, async (payload, { signal }) => …), src/shared/modules/<module>/module.ts) and add its entry to options.dokebi-scheduler.schedules in dokebi.yaml (npx dokebi add @dokebi/job, then @dokebi/scheduler); inside one job use await setTimeout(ms, undefined, { signal }) from node:timers/promises between bounded batches. Per-process upkeep of in-memory state that no job can reach: // dokebi-check: allow background-timer <reason>';
+export const POLLING_FIX = 'move the loop to background work the framework runs: an @dokebi/outbox handler (one coalesced item per owner and window with a dedupeKey, its handler doing one bounded batch through context.db and enqueuing the next while work remains) or a @dokebi/job handler with an options.dokebi-scheduler.schedules entry; a dokebi-check marker does not silence this rule';
+export function timerRules(file, kinds, report) {
+    const text = file.text;
+    // Most files have no timer at all: skip the walks.
+    if (!/\bset(?:Timeout|Interval|Immediate)\b/.test(text))
+        return;
+    const name = (node) => {
+        if (!node)
+            return undefined;
+        if (node.kind === kinds.Identifier || node.kind === kinds.PrivateIdentifier)
+            return String(property(node, 'text'));
+        return undefined;
+    };
+    const stringValue = (node) => node && (node.kind === kinds.StringLiteral || node.kind === kinds.NoSubstitutionTemplateLiteral)
+        ? String(property(node, 'text'))
+        : undefined;
+    // Imports of the timer modules: local name -> imported name, and namespace names.
+    const promiseNames = new Map();
+    const callbackNames = new Map();
+    const promiseSpaces = new Set();
+    const callbackSpaces = new Set(['globalThis']);
+    for (const statement of nodes(file, 'statements')) {
+        if (statement.kind !== kinds.ImportDeclaration)
+            continue;
+        const from = stringValue(field(statement, 'moduleSpecifier')) ?? '';
+        const promise = PROMISE_MODULES.has(from);
+        if (!promise && !CALLBACK_MODULES.has(from))
+            continue;
+        const clause = field(statement, 'importClause');
+        const bindings = clause && field(clause, 'namedBindings');
+        const spaces = promise ? promiseSpaces : callbackSpaces;
+        const own = name(clause && field(clause, 'name'));
+        if (own)
+            spaces.add(own);
+        if (bindings?.kind === kinds.NamespaceImport) {
+            const space = name(field(bindings, 'name'));
+            if (space)
+                spaces.add(space);
+        }
+        for (const element of bindings ? nodes(bindings, 'elements') : []) {
+            const local = name(field(element, 'name'));
+            const imported = name(field(element, 'propertyName')) ?? local;
+            if (local && imported)
+                (promise ? promiseNames : callbackNames).set(local, imported);
+        }
+    }
+    const functional = (node) => node.kind === kinds.ArrowFunction ||
+        node.kind === kinds.FunctionExpression ||
+        node.kind === kinds.FunctionDeclaration ||
+        node.kind === kinds.MethodDeclaration ||
+        node.kind === kinds.Constructor ||
+        node.kind === kinds.GetAccessor ||
+        node.kind === kinds.SetAccessor;
+    /** `this.x` / `this.#x` -> `x` / `#x`; an identifier -> its text. */
+    const reference = (node) => {
+        if (!node)
+            return undefined;
+        if (node.kind === kinds.Identifier)
+            return name(node);
+        if (node.kind === kinds.PropertyAccessExpression &&
+            field(node, 'expression')?.kind === kinds.ThisKeyword)
+            return name(field(node, 'name'));
+        return undefined;
+    };
+    /** The name a function is known by: its own, or the variable, property or field it is put in. */
+    const functionName = (node) => {
+        const own = name(field(node, 'name'));
+        if (own)
+            return own;
+        const parent = node.parent;
+        if (!parent)
+            return undefined;
+        if (parent.kind === kinds.VariableDeclaration ||
+            parent.kind === kinds.PropertyAssignment ||
+            parent.kind === kinds.PropertyDeclaration)
+            return name(field(parent, 'name'));
+        if (parent.kind === kinds.BinaryExpression && field(parent, 'right') === node)
+            return reference(field(parent, 'left'));
+        return undefined;
+    };
+    // Every named function of the file, and what each refers to (calls and functions passed on).
+    const bodies = new Map();
+    const collect = (node) => {
+        if (functional(node)) {
+            const own = functionName(node);
+            if (own)
+                bodies.set(own, [...(bodies.get(own) ?? []), node]);
+        }
+        node.forEachChild(collect);
+        return undefined;
+    };
+    collect(file);
+    const referenced = new Map();
+    const references = (root) => {
+        const cached = referenced.get(root);
+        if (cached)
+            return cached;
+        const found = new Set();
+        const direct = reference(root);
+        if (direct)
+            found.add(direct);
+        const walk = (node) => {
+            if (node.kind === kinds.CallExpression || node.kind === kinds.NewExpression) {
+                const callee = reference(field(node, 'expression'));
+                if (callee)
+                    found.add(callee);
+                for (const argument of nodes(node, 'arguments')) {
+                    const passed = reference(argument);
+                    if (passed)
+                        found.add(passed);
+                }
+            }
+            node.forEachChild(walk);
+            return undefined;
+        };
+        walk(root);
+        referenced.set(root, found);
+        return found;
+    };
+    /** Whether running `callback` comes back to one of `targets` through the file's functions. */
+    const reaches = (callback, targets) => {
+        const seen = new Set();
+        const queue = [...references(callback)];
+        while (queue.length) {
+            const next = queue.pop();
+            if (targets.has(next))
+                return true;
+            if (seen.has(next))
+                continue;
+            seen.add(next);
+            for (const body of bodies.get(next) ?? [])
+                queue.push(...references(body));
+        }
+        return false;
+    };
+    /** The timer a call starts: `interval`, `once` (setTimeout, setImmediate) or none. */
+    const timerOf = (call) => {
+        const callee = field(call, 'expression');
+        let imported;
+        let promise = false;
+        if (callee?.kind === kinds.Identifier) {
+            const local = name(callee);
+            if (promiseNames.has(local)) {
+                imported = promiseNames.get(local);
+                promise = true;
+            }
+            else
+                imported = callbackNames.get(local) ?? local;
+        }
+        else if (callee?.kind === kinds.PropertyAccessExpression) {
+            const space = name(field(callee, 'expression'));
+            if (!space)
+                return undefined;
+            imported = name(field(callee, 'name'));
+            if (promiseSpaces.has(space))
+                promise = true;
+            else if (!callbackSpaces.has(space))
+                return undefined;
+        }
+        if (!imported || !CALLBACK_TIMERS.has(imported))
+            return undefined;
+        // Awaited sleeps of node:timers/promises end by themselves; its setInterval is a loop.
+        if (promise)
+            return imported === 'setInterval' ? 'interval' : undefined;
+        return imported === 'setInterval' ? 'interval' : 'once';
+    };
+    /** The innermost function around `node` that serves one request or connection. */
+    const connectionFunction = (node) => {
+        for (let current = node.parent; current; current = current.parent) {
+            if (!functional(current))
+                continue;
+            if (nodes(current, 'parameters').some((parameter) => {
+                const own = name(field(parameter, 'name'));
+                return own !== undefined && CONNECTION_PARAMETERS.has(own);
+            }))
+                return current;
+            const call = current.parent;
+            if (call?.kind === kinds.CallExpression && nodes(call, 'arguments').includes(current)) {
+                const callee = field(call, 'expression');
+                if (callee?.kind === kinds.PropertyAccessExpression &&
+                    ROUTE_METHODS.has(name(field(callee, 'name')) ?? ''))
+                    return current;
+            }
+        }
+        return undefined;
+    };
+    /** Whether `scope` declares `local` itself (a parameter or a variable inside it). */
+    const declares = (scope, local) => {
+        let found = false;
+        const walk = (child) => {
+            if ((child.kind === kinds.Parameter ||
+                child.kind === kinds.VariableDeclaration ||
+                child.kind === kinds.BindingElement) &&
+                name(field(child, 'name')) === local)
+                found = true;
+            if (!found)
+                child.forEachChild(walk);
+            return undefined;
+        };
+        scope.forEachChild(walk);
+        return found;
+    };
+    const ASSIGNMENTS = new Set([
+        kinds.EqualsToken,
+        kinds.QuestionQuestionEqualsToken,
+        kinds.BarBarEqualsToken,
+    ]);
+    /** The timer `call` is assigned to `this.…` or to a variable `scope` does not declare. */
+    const outlives = (call, scope) => {
+        let value = call;
+        let parent = value.parent;
+        while (parent &&
+            (parent.kind === kinds.ParenthesizedExpression ||
+                parent.kind === kinds.AsExpression ||
+                parent.kind === kinds.NonNullExpression ||
+                parent.kind === kinds.TypeAssertionExpression)) {
+            value = parent;
+            parent = parent.parent;
+        }
+        if (parent?.kind !== kinds.BinaryExpression || field(parent, 'right') !== value)
+            return false;
+        const operator = field(parent, 'operatorToken');
+        if (!operator || !ASSIGNMENTS.has(operator.kind))
+            return false;
+        let target = field(parent, 'left');
+        while (target &&
+            (target.kind === kinds.PropertyAccessExpression ||
+                target.kind === kinds.ElementAccessExpression ||
+                target.kind === kinds.ParenthesizedExpression ||
+                target.kind === kinds.NonNullExpression))
+            target = field(target, 'expression');
+        if (target?.kind === kinds.ThisKeyword)
+            return true;
+        const local = name(target);
+        return local !== undefined && !declares(scope, local);
+    };
+    /** A timer owned by one request or connection: ends with it, never stored beyond it. */
+    const connectionScope = (node) => {
+        const scope = connectionFunction(node);
+        return scope !== undefined && !(node.kind === kinds.CallExpression && outlives(node, scope));
+    };
+    /** The names of the functions around `node`, innermost first. */
+    const enclosing = (node) => {
+        const found = new Set();
+        for (let current = node.parent; current; current = current.parent)
+            if (functional(current)) {
+                const own = functionName(current);
+                if (own)
+                    found.add(own);
+            }
+        return found;
+    };
+    const callee = (call) => {
+        const target = field(call, 'expression');
+        return target ? text.slice(target.getStart(), target.end) : 'setTimeout';
+    };
+    // A loop that sleeps inside a task the app starts and never awaits (M33: `task = (async () => {
+    // while (!stopped) { await step(); await new Promise((r) => setTimeout(r, ms)); } })()` in a
+    // module's start). Only background tasks: the same loop in a job handler or in a function its
+    // caller awaits is a bounded wait between batches, which the rule allows.
+    const LOOPS = new Set([
+        kinds.WhileStatement,
+        kinds.DoStatement,
+        kinds.ForStatement,
+        kinds.ForOfStatement,
+        kinds.ForInStatement,
+    ]);
+    const unwrap = (node) => {
+        let current = node;
+        while (current?.kind === kinds.ParenthesizedExpression)
+            current = field(current, 'expression');
+        return current;
+    };
+    /** The parent of `node`, past parentheses. */
+    const outer = (node) => {
+        let current = node.parent;
+        while (current?.kind === kinds.ParenthesizedExpression)
+            current = current.parent;
+        return current;
+    };
+    /** `new Promise((resolve) => … setTimeout(…) …)`: a sleep written by hand. */
+    const promiseSleep = (node) => {
+        if (node?.kind !== kinds.NewExpression || name(field(node, 'expression')) !== 'Promise')
+            return false;
+        let found = false;
+        const walk = (child) => {
+            if (child.kind === kinds.CallExpression && timerOf(child) === 'once')
+                found = true;
+            if (!found)
+                child.forEachChild(walk);
+            return undefined;
+        };
+        for (const argument of nodes(node, 'arguments'))
+            walk(argument);
+        return found;
+    };
+    /** The awaited expression sleeps: a hand-written sleep, timers/promises, or a helper of this file. */
+    const sleeps = (expression, seen = new Set()) => {
+        const value = unwrap(expression);
+        if (!value)
+            return false;
+        if (promiseSleep(value))
+            return true;
+        if (value.kind !== kinds.CallExpression)
+            return false;
+        const target = field(value, 'expression');
+        if (target?.kind === kinds.Identifier) {
+            const local = name(target);
+            const imported = promiseNames.get(local);
+            if (imported === 'setTimeout' || imported === 'setImmediate')
+                return true;
+            if (seen.has(local))
+                return false;
+            seen.add(local);
+            return (bodies.get(local) ?? []).some((body) => {
+                const result = field(body, 'body');
+                if (result && result.kind !== kinds.Block)
+                    return sleeps(result, seen);
+                let found = false;
+                const walk = (child) => {
+                    if (child.kind === kinds.ReturnStatement && sleeps(field(child, 'expression'), seen))
+                        found = true;
+                    if (!found && !functional(child))
+                        child.forEachChild(walk);
+                    return undefined;
+                };
+                if (result)
+                    result.forEachChild(walk);
+                return found;
+            });
+        }
+        if (target?.kind === kinds.PropertyAccessExpression) {
+            const space = name(field(target, 'expression'));
+            const member = name(field(target, 'name'));
+            return (space !== undefined &&
+                promiseSpaces.has(space) &&
+                (member === 'setTimeout' || member === 'setImmediate'));
+        }
+        return false;
+    };
+    /** Calls of `fn` by name in this file that nobody awaits or returns. */
+    const startedUnawaited = (own) => {
+        let found = false;
+        const walk = (node) => {
+            if (node.kind === kinds.CallExpression && reference(field(node, 'expression')) === own) {
+                const parent = outer(node);
+                const awaited = parent?.kind === kinds.AwaitExpression ||
+                    parent?.kind === kinds.ReturnStatement ||
+                    (parent?.kind === kinds.ArrowFunction && field(parent, 'body') === node);
+                if (!awaited)
+                    found = true;
+            }
+            if (!found)
+                node.forEachChild(walk);
+            return undefined;
+        };
+        walk(file);
+        return found;
+    };
+    /** A function the app starts in the background: an IIFE, or a function called without await. */
+    const background = (fn) => {
+        let current = fn;
+        while (current.parent?.kind === kinds.ParenthesizedExpression)
+            current = current.parent;
+        const parent = current.parent;
+        if (parent?.kind === kinds.CallExpression && field(parent, 'expression') === current)
+            return true;
+        const own = functionName(fn);
+        return own !== undefined && startedUnawaited(own);
+    };
+    /** The function a node is in (the nearest one). */
+    const owner = (node) => {
+        for (let current = node.parent; current; current = current.parent)
+            if (functional(current))
+                return current;
+        return undefined;
+    };
+    /** The loop sleeps: an awaited sleep in its body or condition, not inside a nested function. */
+    const loopSleeps = (loop) => {
+        let found = false;
+        const walk = (node) => {
+            if (functional(node))
+                return undefined;
+            if (node.kind === kinds.AwaitExpression && sleeps(field(node, 'expression')))
+                found = true;
+            if (!found)
+                node.forEachChild(walk);
+            return undefined;
+        };
+        loop.forEachChild(walk);
+        return found;
+    };
+    // M36: builders also put database work (claims, expiry sweeps, folds) on setInterval under
+    // an allow marker. A timer whose callback reaches database work is reported as polling-loop,
+    // which no marker silences; per-process upkeep of other state keeps background-timer.
+    const DB_RECEIVER = /^(?:db|pool|client|tx|trx|knex|sql|outbox|models?|repo|repository|dao|.*(?:Model|Repository|Repo|Dao|Pool))$/;
+    const DB_METHOD = new Set(['query', 'execute', 'transaction']);
+    const receivers = (target) => {
+        const names = [];
+        for (let current = target; current;) {
+            if (current.kind === kinds.PropertyAccessExpression) {
+                const member = name(field(current, 'name'));
+                if (member)
+                    names.push(member);
+                current = field(current, 'expression');
+            }
+            else if (current.kind === kinds.CallExpression)
+                current = field(current, 'expression');
+            else {
+                const own = name(current);
+                if (own)
+                    names.push(own);
+                break;
+            }
+        }
+        return names;
+    };
+    /** The region (a callback or a function and what it calls in this file) reaches database work. */
+    const touchesDatabase = (region, seen = new Set()) => {
+        if (!region)
+            return false;
+        let found = false;
+        const walk = (node) => {
+            if (found)
+                return undefined;
+            if (node.kind === kinds.CallExpression) {
+                const target = field(node, 'expression');
+                if (target?.kind === kinds.PropertyAccessExpression) {
+                    const method = name(field(target, 'name'));
+                    const chain = receivers(field(target, 'expression'));
+                    if ((method && DB_METHOD.has(method)) || chain.some((item) => DB_RECEIVER.test(item)))
+                        found = true;
+                }
+                const local = reference(target);
+                if (!found && local && !seen.has(local)) {
+                    seen.add(local);
+                    for (const body of bodies.get(local) ?? [])
+                        if (touchesDatabase(body, seen))
+                            found = true;
+                }
+            }
+            if (!found)
+                node.forEachChild(walk);
+            return undefined;
+        };
+        const direct = reference(region);
+        if (direct && !seen.has(direct)) {
+            seen.add(direct);
+            for (const body of bodies.get(direct) ?? [])
+                if (touchesDatabase(body, seen))
+                    return true;
+        }
+        walk(region);
+        return found;
+    };
+    const DB_TIMER = 'runs database work on a timer of every app worker (claims, sweeps, folds): nothing claims the work across workers, records a failure or limits its time, and a restart loses where it was. An allow marker does not cover it: per-process upkeep of in-memory state keeps background-timer, database work is background work (M36)';
+    const visit = (node) => {
+        if (LOOPS.has(node.kind) && !connectionScope(node)) {
+            const fn = owner(node);
+            if (fn && loopSleeps(node) && background(fn))
+                report(node, 'a loop that sleeps inside a task started in the background (a polling loop): periodic work outside @dokebi/scheduler and @dokebi/job runs in every app worker at once, nothing claims the work, records a failure or limits its time, and a restart loses where it was. An allow marker does not cover it: per-process upkeep uses a timer, never a sleeping loop (M34, M35)', POLLING_FIX, 'polling-loop');
+        }
+        if (node.kind === kinds.CallExpression) {
+            const timer = timerOf(node);
+            if (timer && !connectionScope(node)) {
+                const callback = nodes(node, 'arguments')[0];
+                if (timer === 'interval') {
+                    if (touchesDatabase(callback))
+                        report(node, `setInterval ${DB_TIMER}`, POLLING_FIX, 'polling-loop');
+                    else
+                        report(node, 'setInterval runs periodic work outside @dokebi/scheduler and @dokebi/job: it runs in every app worker at once, nothing claims the work, records a failure or limits its time, and a restart loses where it was', TIMER_FIX);
+                }
+                else if (callback) {
+                    const around = enclosing(node);
+                    if (around.size && reaches(callback, around)) {
+                        if (touchesDatabase(callback) || touchesDatabase(owner(node)))
+                            report(node, `${callee(node)} ${DB_TIMER}`, POLLING_FIX, 'polling-loop');
+                        else
+                            report(node, `${callee(node)} reschedules itself (a background loop): periodic work outside @dokebi/scheduler and @dokebi/job runs in every app worker at once, nothing claims the work, records a failure or limits its time, and a restart loses where it was`, TIMER_FIX);
+                    }
+                }
+            }
+        }
+        node.forEachChild(visit);
+        return undefined;
+    };
+    file.forEachChild(visit);
+}

package/dist/check/typescript.d.ts

@@ -22,7 +22,7 @@ export declare function nodes(node: TsNode, name: string): readonly TsNode[];
 /** A primitive property (`text` of identifiers and literals, `isExportEquals`, …). */
 export declare function property(node: TsNode, name: string): unknown;
 /** SyntaxKind names the rules use; each must exist in the loaded TypeScript. */
-declare const KIND_NAMES: readonly ['ArrowFunction', 'Block', 'CallExpression', 'CatchClause', 'Constructor', 'Decorator', 'DeclareKeyword', 'EnumDeclaration', 'ExportAssignment', 'ExportDeclaration', 'ExpressionStatement', 'ExternalModuleReference', 'FunctionExpression', 'Identifier', 'ImportDeclaration', 'ImportEqualsDeclaration', 'ImportKeyword', 'ImportType', 'InterfaceDeclaration', 'LiteralType', 'ModuleBlock', 'ModuleDeclaration', 'NewExpression', 'NoSubstitutionTemplateLiteral', 'OverrideKeyword', 'Parameter', 'ParenthesizedExpression', 'PrivateKeyword', 'PropertyAccessExpression', 'ProtectedKeyword', 'PublicKeyword', 'ReadonlyKeyword', 'StringLiteral', 'TypeAliasDeclaration', 'TypeAssertionExpression'];
+declare const KIND_NAMES: readonly ['ArrayLiteralExpression', 'ArrowFunction', 'AsExpression', 'AwaitExpression', 'BarBarEqualsToken', 'BarBarToken', 'BinaryExpression', 'BindingElement', 'Block', 'BreakStatement', 'CallExpression', 'CatchClause', 'ClassDeclaration', 'ClassExpression', 'ConditionalExpression', 'Constructor', 'ContinueStatement', 'DeclareKeyword', 'Decorator', 'DoStatement', 'ElementAccessExpression', 'EnumDeclaration', 'EqualsEqualsEqualsToken', 'EqualsEqualsToken', 'EqualsToken', 'ExclamationEqualsEqualsToken', 'ExclamationEqualsToken', 'ExportAssignment', 'ExportDeclaration', 'ExportKeyword', 'ExpressionStatement', 'ExternalModuleReference', 'FalseKeyword', 'ForInStatement', 'ForOfStatement', 'ForStatement', 'FunctionDeclaration', 'FunctionExpression', 'GetAccessor', 'GreaterThanEqualsToken', 'GreaterThanToken', 'Identifier', 'IfStatement', 'ImportDeclaration', 'ImportEqualsDeclaration', 'ImportKeyword', 'ImportType', 'InterfaceDeclaration', 'LessThanEqualsToken', 'LessThanToken', 'LiteralType', 'MethodDeclaration', 'ModuleBlock', 'ModuleDeclaration', 'NamedImports', 'NamespaceImport', 'NewExpression', 'NoSubstitutionTemplateLiteral', 'NonNullExpression', 'NullKeyword', 'NumericLiteral', 'ObjectBindingPattern', 'ObjectLiteralExpression', 'OverrideKeyword', 'Parameter', 'ParenthesizedExpression', 'PrivateIdentifier', 'PrivateKeyword', 'PropertyAccessExpression', 'PropertyAssignment', 'PropertyDeclaration', 'ProtectedKeyword', 'PublicKeyword', 'QuestionQuestionEqualsToken', 'QuestionQuestionToken', 'ReadonlyKeyword', 'ReturnStatement', 'SetAccessor', 'ShorthandPropertyAssignment', 'SpreadElement', 'StaticKeyword', 'StringLiteral', 'TemplateExpression', 'ThisKeyword', 'ThrowStatement', 'TrueKeyword', 'TypeAliasDeclaration', 'TypeAssertionExpression', 'TypeOfExpression', 'VariableDeclaration', 'VariableStatement', 'VoidExpression', 'WhileStatement'];
 export type KindName = (typeof KIND_NAMES)[number];
 export type Kinds = Readonly<Record<KindName, number>>;
 /** An open TypeScript project: its user source files and a thenable test over the checker. */
@@ -31,16 +31,46 @@ export interface TypeScriptProject {
     readonly kinds: Kinds;
     /** Program files under the root, outside node_modules, without declaration files. */
     readonly files: readonly TsSourceFile[];
-    /** Milliseconds to start tsgo and load the program (the part a check cannot avoid). */
+    /**
+     * D-0120: the browser sources given to openTypeScript (.vue scripts, views/ .js), parsed and
+     * typed in a second program of the same tsgo; `path` is the file problems name.
+     */
+    readonly browser: readonly {
+        readonly file: TsSourceFile;
+        readonly path: string;
+    }[];
+    /** Milliseconds to start tsgo and load the programs (the part a check cannot avoid). */
     readonly loadMs: number;
-    /** For each expression: is its type a Promise or PromiseLike (or a union with one)? */
-    promises(expressions: readonly TsNode[]): boolean[];
+    /**
+     * For each expression: is its type a Promise or PromiseLike (or a union with one)? `browser`:
+     * the expressions are nodes of the browser program.
+     */
+    promises(expressions: readonly TsNode[], browser?: boolean): boolean[];
+    /** For each node: has it no type (any, unknown, or none)? An import that resolved to nothing. */
+    untyped(nodes: readonly TsNode[], browser?: boolean): boolean[];
     close(): void;
 }
+/** A file outside the program, served to tsgo from memory (check/browser-sources.ts). */
+export interface VirtualSource {
+    /** What problems name: root-relative with `/`. */
+    readonly path: string;
+    /** Absolute file name of the virtual file. */
+    readonly fileName: string;
+    readonly text: string;
+}
+/** The virtual tsconfig of the browser program; never written to disk. */
+export declare const BROWSER_TSCONFIG = "tsconfig.dokebi-check.json";
 /**
  * Starts the project's TypeScript and loads the program of `<root>/tsconfig.json`. The caller
  * closes it. Throws TYPESCRIPT_UNAVAILABLE (TypeScript missing, older than 7, or its API changed)
  * and TSCONFIG_INVALID (the program cannot be loaded).
  */
-export declare function openTypeScript(root: string): Promise<TypeScriptProject>;
+export declare function openTypeScript(root: string, 
+/**
+ * The tsconfig file in `root` (the framework's check:catch gate also reads its other
+ * programs); null: no project program, only the browser sources (with standalone options).
+ */
+tsconfig?: string | null, 
+/** D-0120: files outside the program read in a second program that extends `tsconfig`. */
+browser?: readonly VirtualSource[]): Promise<TypeScriptProject>;
 export {};