@tsplc/compiler 0.0.0-stage → 0.2.0

package/src/frontend/async.ts

@@ -0,0 +1,1060 @@
+import { runtimeSources } from "./module-graph.ts";
+import ts from "typescript";
+import { dirname, resolve, relative } from "node:path";
+import { cooperativeSite, taskSite } from "./cooperative.ts";
+import { staticString } from "./configuration.ts";
+import { error, type Diagnostic, type FunctionBlock, type PlcProgram } from "@tsplc/compiler/ir";
+
+export interface AsyncLowering {
+  sources: Map<string, string>;
+  blocks: Map<string, NonNullable<FunctionBlock["runtime"]>>;
+  programs: Record<string, { module: string; export: string }>;
+  schedules: Map<string, NonNullable<PlcProgram["background"]>>;
+  diagnostics: Diagnostic[];
+  continuations: Map<string, NonNullable<PlcProgram["continuation"]>>;
+}
+
+const copyValue = (value: string, aggregate: boolean) => (aggregate ? `copy(${value})` : value);
+
+/** Lower suspension into ordinary typed blocks before the PLC semantic pass. */
+export const lowerAsync = (program: ts.Program, sdk: string): AsyncLowering => {
+  const result: AsyncLowering = {
+    sources: new Map(),
+    blocks: new Map(),
+    programs: {},
+    schedules: new Map(),
+    diagnostics: [],
+    continuations: new Map(),
+  };
+  const checker = program.getTypeChecker();
+  const symbol = (node: ts.Node): ts.Symbol | undefined => {
+    let s = checker.getSymbolAtLocation(node);
+    while (s && s.flags & ts.SymbolFlags.Alias) s = checker.getAliasedSymbol(s);
+    return s;
+  };
+  const official = (node: ts.Node, name: string) => {
+    const s = symbol(node);
+    return (
+      s?.name === name &&
+      s.declarations?.some((d) => d.getSourceFile().fileName.startsWith(dirname(sdk) + "/"))
+    );
+  };
+  const diagnosticFor = (node: ts.Node, message: string): Diagnostic => {
+    const source = node.getSourceFile();
+    const start = node.getStart(source);
+    const position = source.getLineAndCharacterOfPosition(start);
+    return error("PLC1010", message, {
+      file: source.fileName,
+      start,
+      end: node.end,
+      line: position.line + 1,
+      column: position.character + 1,
+    });
+  };
+  const fail: (node: ts.Node, message: string) => never = (node, message) => {
+    throw { asyncDiagnostic: diagnosticFor(node, message) };
+  };
+  type Routine = ts.FunctionDeclaration | ts.MethodDeclaration;
+  const functions = new Map<ts.Symbol, Routine>();
+  const methods = new Map<
+    ts.Symbol,
+    { start: string; reset: string; snapshot: string; advance: string }
+  >();
+  for (const source of runtimeSources(program)) {
+    if (source.isDeclarationFile) continue;
+    for (const statement of source.statements) {
+      const routines = ts.isClassDeclaration(statement)
+        ? statement.members.filter(ts.isMethodDeclaration)
+        : [statement];
+      for (const fn of routines) {
+        if (
+          (!ts.isFunctionDeclaration(fn) && !ts.isMethodDeclaration(fn)) ||
+          !fn.name ||
+          !fn.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)
+        )
+          continue;
+        functions.set(symbol(fn.name)!, fn);
+        if (ts.isMethodDeclaration(fn)) {
+          const prefix = `tsplcAsync${fn.name.getText(source)}${fn.getStart(source)}`;
+          methods.set(symbol(fn.name)!, {
+            start: prefix + "Start",
+            reset: prefix + "Reset",
+            snapshot: prefix + "Snapshot",
+            advance: prefix + "Advance",
+          });
+        }
+      }
+    }
+  }
+  if (!functions.size) return result;
+  const aliasPrefix = (fn: Routine) =>
+    `TsplcAsync${fn.name!.getText(fn.getSourceFile())}${fn.getStart(fn.getSourceFile())}`;
+  const printer = ts.createPrinter({ removeComments: false });
+  let sequence = 0;
+  const ownedContinuations = new Map<ts.Symbol, string[]>();
+  const ownedJobs = new Map<
+    ts.Symbol,
+    { method: string; schedule: NonNullable<PlcProgram["background"]> }[]
+  >();
+  for (const source of runtimeSources(program)) {
+    if (source.isDeclarationFile) continue;
+    try {
+      const replacements: { start: number; end: number; text: string }[] = [],
+        extra: string[] = [];
+      const text = (node: ts.Node) => node.getText(source);
+      for (const fn of functions.values()) {
+        if (fn.getSourceFile() !== source) continue;
+        const method = methods.get(symbol(fn.name!)!);
+        if (!fn.name || !functions.has(symbol(fn.name)!)) continue;
+        if (
+          !fn.body ||
+          fn.typeParameters?.length ||
+          !fn.type ||
+          !ts.isTypeReferenceNode(fn.type) ||
+          fn.type.typeName.getText(source) !== "Promise" ||
+          fn.type.typeArguments?.length !== 1
+        )
+          fail(
+            fn,
+            "Async functions require concrete parameters and an explicit Promise<T> result.",
+          );
+        const returnsVoid = fn.type.typeArguments[0]!.kind === ts.SyntaxKind.VoidKeyword;
+        const returnType = returnsVoid ? "BOOL" : text(fn.type.typeArguments[0]!);
+        const resultAggregate = Boolean(
+          checker.getTypeFromTypeNode(fn.type.typeArguments[0]!).flags & ts.TypeFlags.Object,
+        );
+        const fields = new Map<ts.Symbol, { name: string; type: string; aggregate: boolean }>();
+        const parameters = fn.parameters.map((p, index) => {
+          if (
+            !ts.isIdentifier(p.name) ||
+            !p.type ||
+            p.initializer ||
+            p.questionToken ||
+            p.dotDotDotToken
+          )
+            fail(p, "Async parameters require explicit concrete value types.");
+          if (/\bInOut\b/.test(text(p.type)))
+            fail(p, "InOut cannot cross an async suspension; pass a value snapshot.");
+          fields.set(symbol(p.name)!, {
+            name: `argument${index}`,
+            type: text(p.type),
+            aggregate: Boolean(checker.getTypeFromTypeNode(p.type).flags & ts.TypeFlags.Object),
+          });
+          return {
+            name: p.name.text,
+            type: text(p.type),
+            aggregate: Boolean(checker.getTypeFromTypeNode(p.type).flags & ts.TypeFlags.Object),
+            field: `argument${index}`,
+          };
+        });
+        const containsAwait = (node: ts.Node): boolean =>
+          ts.isAwaitExpression(node) || node.getChildren(source).some(containsAwait);
+        const collect = (node: ts.Node) => {
+          if (ts.isForStatement(node)) {
+            if (containsAwait(node))
+              fail(node, "Await inside loops is not supported yet; use bounded async calls.");
+            return;
+          }
+          if (ts.isFunctionLike(node) && node !== fn)
+            fail(node, "Closures and nested functions are not supported in async PLC routines.");
+          if (ts.isCatchClause(node)) {
+            const declaration = node.variableDeclaration;
+            if (declaration) {
+              if (!ts.isIdentifier(declaration.name))
+                fail(declaration, "Catch requires a named error code or no binding.");
+              fields.set(symbol(declaration.name)!, {
+                name: `caught${fields.size}`,
+                type: "UDINT",
+                aggregate: false,
+              });
+            }
+            collect(node.block);
+            return;
+          }
+          if (ts.isVariableDeclaration(node)) {
+            if (!ts.isIdentifier(node.name) || !node.initializer)
+              fail(node, "Async locals need names and initializers.");
+            let type = node.type ? text(node.type) : undefined;
+            if (!type) {
+              if (
+                node.initializer.kind === ts.SyntaxKind.TrueKeyword ||
+                node.initializer.kind === ts.SyntaxKind.FalseKeyword
+              )
+                type = "BOOL";
+              else if (
+                ts.isAwaitExpression(node.initializer) &&
+                ts.isCallExpression(node.initializer.expression)
+              ) {
+                const call = node.initializer.expression;
+                const target = ts.isPropertyAccessExpression(call.expression)
+                  ? call.expression.name
+                  : call.expression;
+                const called = functions.get(symbol(target)!);
+                if (called?.type && ts.isTypeReferenceNode(called.type)) {
+                  type = called.type.typeArguments![0]!.getText(called.getSourceFile());
+                  if (called.getSourceFile() !== source) {
+                    type = `${aliasPrefix(called)}Result`;
+                    const path = relative(
+                      dirname(source.fileName),
+                      called.getSourceFile().fileName,
+                    ).replaceAll("\\", "/");
+                    const statement = `import type {${type}} from ${JSON.stringify(path.startsWith(".") ? path : `./${path}`)};`;
+                    if (!extra.includes(statement)) extra.push(statement);
+                  }
+                }
+              }
+              if (!type) fail(node, "Annotate async locals with their concrete PLC type.");
+            }
+            fields.set(symbol(node.name)!, {
+              name: `local${fields.size}`,
+              type,
+              aggregate: Boolean(checker.getTypeAtLocation(node).flags & ts.TypeFlags.Object),
+            });
+          }
+          ts.forEachChild(node, collect);
+        };
+        collect(fn.body);
+        const rewrite = (node: ts.Node): string => {
+          const transformed = ts.transform(node, [
+            (context) => (root) => {
+              const visit = (n: ts.Node): ts.VisitResult<ts.Node> => {
+                if (
+                  method &&
+                  ts.isPropertyAccessExpression(n) &&
+                  n.expression.kind === ts.SyntaxKind.ThisKeyword
+                ) {
+                  return ts.factory.createElementAccessExpression(
+                    ts.factory.createThis(),
+                    ts.factory.createStringLiteral(n.name.text),
+                  );
+                }
+                if (ts.isIdentifier(n)) {
+                  const field = fields.get(symbol(n)!);
+                  if (
+                    field &&
+                    !(ts.isPropertyAccessExpression(n.parent) && n.parent.name === n) &&
+                    !(ts.isPropertyAssignment(n.parent) && n.parent.name === n)
+                  )
+                    return ts.factory.createPropertyAccessExpression(
+                      ts.factory.createThis(),
+                      field.name,
+                    );
+                }
+                if (ts.isShorthandPropertyAssignment(n)) {
+                  const value = checker.getShorthandAssignmentValueSymbol(n),
+                    field = value && fields.get(value);
+                  if (field)
+                    return ts.factory.createPropertyAssignment(
+                      n.name,
+                      ts.factory.createPropertyAccessExpression(
+                        ts.factory.createThis(),
+                        field.name,
+                      ),
+                    );
+                }
+                return ts.visitEachChild(n, visit, context);
+              };
+              return ts.visitNode(root, visit) as typeof root;
+            },
+          ]);
+          const value = printer.printNode(
+            ts.EmitHint.Unspecified,
+            transformed.transformed[0]!,
+            source,
+          );
+          transformed.dispose();
+          return value;
+        };
+        const nodes = new Map<number, string>();
+        const yielding = new Set<number>();
+        let nextId = 1;
+        const state = (body: string, yields = false) => {
+          const id = nextId++;
+          nodes.set(id, body);
+          if (yields) yielding.add(id);
+          return id;
+        };
+        const children: string[] = [],
+          resets: string[] = [],
+          cancels: string[] = [];
+        const finish = (value: string) =>
+          `this.value = ${copyValue(value, resultAggregate)}; this.busy = false; this.done = true; this.step = 0;`;
+        const failure = (error: string) =>
+          `this.error = ${error}; if(this.error === 0)this.error=4; this.busy = false; this.done = true; this.step = 0;`;
+        const awaitState = (
+          awaited: ts.AwaitExpression | ts.CallExpression,
+          target: string | undefined,
+          next: number,
+          reject: (error: string, cancellable?: boolean) => string,
+        ): number => {
+          const expression = ts.isAwaitExpression(awaited) ? awaited.expression : awaited;
+          if (!ts.isCallExpression(expression))
+            fail(awaited, "Await requires a tsPLC operation or a statically named async function.");
+          const call = expression,
+            name = ts.isPropertyAccessExpression(call.expression)
+              ? call.expression.name
+              : call.expression;
+          const child = `child${children.length}`;
+          if (official(name, "sleep")) {
+            if (call.arguments.length !== 1 || call.typeArguments?.length || target)
+              fail(call, "sleep takes one TIME and returns void.");
+            children.push(`private ${child} = new OnDelayTimer();`);
+            resets.push(`this.${child}.update({enabled:false,duration:ms(0)});`);
+            const poll = state(
+              `this.${child}.update({enabled:true,duration:${rewrite(call.arguments[0]!)}}); if(this.${child}.out.done) { this.step = ${next}; }`,
+            );
+            return state(
+              `this.${child}.update({enabled:true,duration:${rewrite(call.arguments[0]!)}});this.step=${poll};`,
+              true,
+            );
+          }
+          if (official(name, "fetch") || official(name, "opcuaCall")) {
+            const rpc = official(name, "opcuaCall");
+            if (
+              call.arguments.length < 1 ||
+              call.arguments.length > 2 ||
+              !call.typeArguments?.length ||
+              call.typeArguments.length > 2
+            )
+              fail(
+                call,
+                "fetch<Response, Request?> requires a URL and optional { method, json } options.",
+              );
+            const url = staticString(checker, call.arguments[0]!);
+            if (url === undefined)
+              fail(
+                call.arguments[0]!,
+                "fetch URL must be a literal or compile-time const string; configuration properties must be readonly.",
+              );
+            const options = rpc ? undefined : call.arguments[1];
+            if (options && !ts.isObjectLiteralExpression(options))
+              fail(options, "fetch options must be an inline { method, json } object.");
+            let method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" = rpc ? "POST" : "GET";
+            let json: ts.Expression | undefined = rpc ? call.arguments[1] : undefined;
+            if (options && ts.isObjectLiteralExpression(options))
+              for (const property of options.properties) {
+                if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name))
+                  fail(property, "fetch options require named properties.");
+                if (property.name.text === "method") {
+                  const value = staticString(checker, property.initializer);
+                  if (
+                    value !== "GET" &&
+                    value !== "POST" &&
+                    value !== "PUT" &&
+                    value !== "PATCH" &&
+                    value !== "DELETE"
+                  )
+                    fail(property, "Unsupported fetch method.");
+                  method = value;
+                } else if (property.name.text === "json") json = property.initializer;
+                else fail(property, "Unsupported fetch option.");
+              }
+            if (method === "GET" && json) fail(call, "GET requests cannot contain json.");
+            const responseType = text(call.typeArguments[0]!),
+              httpName = `Tsplc${rpc ? "Rpc" : "Http"}${sequence++}`;
+            let requestType = `${httpName}Request`;
+            if (!json) extra.push(`interface ${requestType} {reserved:BOOL}`);
+            if (json) {
+              if (call.typeArguments[1]) requestType = text(call.typeArguments[1]);
+              else {
+                const layout = checker.getTypeAtLocation(json);
+                if (!layout.aliasSymbol && (!layout.symbol || layout.symbol.name === "__type"))
+                  fail(
+                    json,
+                    "Annotate json with a named PLC record or supply the Request type argument.",
+                  );
+                requestType = checker.typeToString(
+                  layout,
+                  json,
+                  ts.TypeFormatFlags.NoTruncation |
+                    ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope,
+                );
+              }
+            }
+            extra.push(`interface ${httpName}Input {start:BOOL;cancel:BOOL;request:${requestType}}
+interface ${httpName}Output {busy:BOOL;done:BOOL;error:UDINT;result:${responseType}}
+class ${httpName} extends FunctionBlock<${httpName}Input,${httpName}Output> { protected execute(input:${httpName}Input):${httpName}Output {return {busy:false,done:false,error:0,result:defaultValue<${responseType}>()};} }`);
+            result.blocks.set(
+              `${source.fileName}:${httpName}`,
+              rpc
+                ? { kind: "rpc", path: url }
+                : {
+                    kind: "http",
+                    url,
+                    method,
+                    json: Boolean(json),
+                  },
+            );
+            children.push(`private ${child} = new ${httpName}();`);
+            resets.push(
+              `this.${child}.update({start:false,cancel:false,request:defaultValue<${requestType}>()});`,
+            );
+            cancels.push(
+              `this.${child}.update({start:false,cancel:true,request:defaultValue<${requestType}>()});`,
+            );
+            return state(
+              `this.${child}.update({start:true,cancel:false,request:${json ? rewrite(json) : `defaultValue<${requestType}>()`}}); if(this.${child}.out.done) { if(this.${child}.out.error !== 0) {${reject(`this.${child}.out.error`, true)}} else {${target ? `${target} = ${copyValue(`this.${child}.out.result`, Boolean(checker.getAwaitedType(checker.getTypeAtLocation(call))!.flags & ts.TypeFlags.Object))};` : ""}this.step = ${next};} }`,
+            );
+          }
+          const jobDeclaration = symbol(name)?.declarations?.find(
+            (node) => ts.isVariableDeclaration(node) || ts.isPropertyDeclaration(node),
+          );
+          const jobInitializer =
+            jobDeclaration &&
+            (ts.isVariableDeclaration(jobDeclaration) || ts.isPropertyDeclaration(jobDeclaration))
+              ? jobDeclaration.initializer
+              : undefined;
+          if (
+            jobInitializer &&
+            ts.isCallExpression(jobInitializer) &&
+            ts.isPropertyAccessExpression(jobInitializer.expression) &&
+            official(jobInitializer.expression.expression, "backgroundTasks") &&
+            jobInitializer.expression.name.text === "define"
+          ) {
+            const receiver = rewrite(call.expression),
+              borrow = `borrow${children.length}`;
+            children.push(`private ${borrow}:BOOL=false;`);
+            resets.push(`this.${borrow}=false;`);
+            cancels.push(
+              `if(this.${borrow}){${receiver}.cancel();const borrowed=${receiver}.snapshot();if(!borrowed.valid||borrowed.busy)return;if(!${receiver}.reset())return;this.${borrow}=false;}`,
+            );
+            const poll = state(
+              `const borrowed=${receiver}.snapshot();if(borrowed.valid&&borrowed.done){if(${receiver}.reset()){this.${borrow}=false;if(borrowed.error!==0){${reject("borrowed.error", true)}}else{${target ? `${target}=${copyValue("borrowed.result", Boolean(checker.getAwaitedType(checker.getTypeAtLocation(call))!.flags & ts.TypeFlags.Object))};` : ""}this.step=${next};}}}`,
+            );
+            return state(
+              `const available=${receiver}.snapshot();if(!available.valid)return;if(available.busy||available.done){${reject("7")}}else{const accepted:BOOL=${receiver}.start(${call.arguments.map(rewrite).join(",")});if(accepted){this.${borrow}=true;this.step=${poll};}}`,
+              true,
+            );
+          }
+          const called = functions.get(symbol(name)!);
+          if (!called) fail(call, "Await requires a known async helper or SDK operation.");
+          const calledMethod = methods.get(symbol(name)!);
+          if (calledMethod) {
+            if (!ts.isPropertyAccessExpression(call.expression))
+              fail(call, "Async methods require a static receiver.");
+            const receiver = rewrite(call.expression.expression);
+            const borrow = `methodBorrow${children.length}`;
+            children.push(`private ${borrow}:BOOL=false;`);
+            resets.push(
+              `if(this.${borrow}){${receiver}.${calledMethod.reset}();this.${borrow}=false;}`,
+            );
+            cancels.push(
+              `if(this.${borrow}){${receiver}.${calledMethod.advance}({cancel:true});const cancellingChild=${receiver}.${calledMethod.snapshot}();if(cancellingChild.busy)return;${receiver}.${calledMethod.reset}();this.${borrow}=false;}`,
+            );
+            const poll = state(
+              `${receiver}.${calledMethod.advance}({cancel:false});const childState=${receiver}.${calledMethod.snapshot}();if(childState.done){${receiver}.${calledMethod.reset}();this.${borrow}=false;if(childState.error!==0){${reject("childState.error", true)}}else{${target ? `${target}=${copyValue("childState.result", Boolean(checker.getAwaitedType(checker.getTypeAtLocation(call))!.flags & ts.TypeFlags.Object))};` : ""}this.step=${next};}}`,
+            );
+            return state(
+              `const accepted:BOOL=${receiver}.${calledMethod.start}(${call.arguments.map(rewrite).join(",")});if(!accepted){${reject("7")}}else{this.${borrow}=true;${receiver}.${calledMethod.advance}({cancel:false});this.step=${poll};}`,
+              true,
+            );
+          }
+          if (!ts.isIdentifier(call.expression))
+            fail(call, "Async helpers require a static function.");
+          children.push(`private ${child} = new ${text(call.expression)}();`);
+          resets.push(`this.${child}.reset();`);
+          cancels.push(
+            `this.${child}.update({cancel:true});const cancellingChild=this.${child}.snapshot();if(cancellingChild.busy)return;`,
+          );
+          const poll = state(
+            `this.${child}.update({cancel:false}); const childState = this.${child}.snapshot(); if(childState.done) {if(childState.error !== 0) {${reject("childState.error", true)}} else {${target ? `${target} = ${copyValue("childState.result", Boolean(checker.getAwaitedType(checker.getTypeAtLocation(call))!.flags & ts.TypeFlags.Object))};` : ""}this.step = ${next};} }`,
+          );
+          return state(
+            `const accepted:BOOL = this.${child}.start(${call.arguments.map(rewrite).join(",")}); if(accepted){this.${child}.update({cancel:false});this.step = ${poll};}`,
+            true,
+          );
+        };
+        const block = (
+          statements: readonly ts.Statement[],
+          next: number,
+          reject: (error: string, cancellable?: boolean) => string = failure,
+        ): number => {
+          let entry = next;
+          for (const stmt of [...statements].reverse()) {
+            if (ts.isBlock(stmt)) {
+              entry = block(stmt.statements, entry, reject);
+              continue;
+            }
+            if (ts.isIfStatement(stmt)) {
+              const yes = block([stmt.thenStatement], entry, reject),
+                no = stmt.elseStatement ? block([stmt.elseStatement], entry, reject) : entry;
+              entry = state(
+                `if(${rewrite(stmt.expression)}) this.step = ${yes}; else this.step = ${no};`,
+              );
+              continue;
+            }
+            if (ts.isTryStatement(stmt)) {
+              if (!stmt.catchClause || stmt.finallyBlock)
+                fail(stmt, "Async try requires catch; finally is not supported yet.");
+              const caught = block(stmt.catchClause.block.statements, entry, reject);
+              const declaration = stmt.catchClause.variableDeclaration;
+              const field = declaration && fields.get(symbol(declaration.name)!);
+              entry = block(stmt.tryBlock.statements, entry, (error, cancellable) => {
+                const recover = `${field ? `this.${field.name} = ${error};` : ""}this.step = ${caught};`;
+                return cancellable
+                  ? `if(${error} === 1) {${failure(error)}} else {${recover}}`
+                  : recover;
+              });
+              continue;
+            }
+            if (ts.isThrowStatement(stmt)) {
+              if (
+                !checker.isTypeAssignableTo(
+                  checker.getTypeAtLocation(stmt.expression),
+                  checker.getNumberType(),
+                )
+              )
+                fail(stmt, "Async throw requires a numeric error code.");
+              entry = state(reject(rewrite(stmt.expression)));
+              continue;
+            }
+            if (ts.isReturnStatement(stmt)) {
+              if (!stmt.expression) {
+                if (!returnsVoid) fail(stmt, "Async routines must return a value.");
+                entry = state(finish("true"));
+                continue;
+              }
+              const adopted =
+                ts.isCallExpression(stmt.expression) &&
+                checker.getAwaitedType(checker.getTypeAtLocation(stmt.expression)) !==
+                  checker.getTypeAtLocation(stmt.expression)
+                  ? stmt.expression
+                  : undefined;
+              const suspension = ts.isAwaitExpression(stmt.expression) ? stmt.expression : adopted;
+              entry = suspension
+                ? awaitState(
+                    suspension,
+                    returnsVoid ? undefined : "this.value",
+                    state(finish(returnsVoid ? "true" : "this.value")),
+                    reject,
+                  )
+                : state(finish(rewrite(stmt.expression)));
+              continue;
+            }
+            if (ts.isVariableStatement(stmt)) {
+              for (const dec of [...stmt.declarationList.declarations].reverse()) {
+                const field = fields.get(symbol(dec.name)!);
+                if (!field || !dec.initializer) fail(dec, "Invalid async local.");
+                const target = `this.${field.name}`;
+                entry = ts.isAwaitExpression(dec.initializer)
+                  ? awaitState(dec.initializer, target, entry, reject)
+                  : state(
+                      `${target} = ${copyValue(rewrite(dec.initializer), field.aggregate)}; this.step = ${entry};`,
+                    );
+              }
+              continue;
+            }
+            if (ts.isExpressionStatement(stmt) && ts.isAwaitExpression(stmt.expression)) {
+              entry = awaitState(stmt.expression, undefined, entry, reject);
+              continue;
+            }
+            if (containsAwait(stmt))
+              fail(
+                stmt,
+                "This suspension position is not supported; await into a named local or return.",
+              );
+            if (ts.isWhileStatement(stmt) || ts.isDoStatement(stmt))
+              fail(stmt, "Unbounded loops are not supported in async routines.");
+            entry = state(`${rewrite(stmt)} this.step = ${entry};`);
+          }
+          return entry;
+        };
+        const entry = block(fn.body.statements, state(returnsVoid ? finish("true") : failure("4")));
+        const exported = fn.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)
+          ? "export "
+          : "";
+        const aliases = `export type ${aliasPrefix(fn)}Result = ${returnType};\n${parameters.map((p, i) => `export type ${aliasPrefix(fn)}Argument${i} = ${p.type};`).join("\n")}`;
+        const generated = `${aliases}\n${exported}class ${fn.name!.getText(source)} extends FunctionBlock<{cancel:BOOL}> {
+private step:UINT=0; private cancelling:BOOL=false; private busy:BOOL=false; private done:BOOL=false; private error:UDINT=0; private value:${returnType}=defaultValue<${returnType}>();
+${[...fields.values()].map((f) => `private ${f.name}:${f.type}=defaultValue<${f.type}>();`).join("\n")}
+${children.join("\n")}
+start(${parameters.map((p) => `${p.name}:${p.type}`).join(",")}):BOOL {if(this.busy || this.done)return false; ${parameters.map((p) => `this.${p.field} = ${copyValue(p.name, p.aggregate)};`).join(" ")} ${resets.join(" ")} this.value = defaultValue<${returnType}>(); this.error=0;this.cancelling=false;this.busy=true;this.done=false;this.step=${entry};return true;}
+reset():void {${resets.join(" ")} this.busy=false;this.cancelling=false;this.done=false;this.error=0;this.step=0;}
+snapshot():{busy:BOOL;done:BOOL;error:UDINT;result:${returnType}} {return {busy:this.busy,done:this.done,error:this.error,result:${copyValue("this.value", resultAggregate)}};}
+protected execute(input:{cancel:BOOL}):void {if(!this.busy)return;if(input.cancel)this.cancelling=true;if(this.cancelling){${cancels.map((cancel) => `{${cancel}}`).join(" ")}${failure("1")}return;}for(let transition:DINT=0;transition<${nodes.size + 1};transition++){const previous:UINT=this.step;switch(this.step){${[...nodes].map(([id, body]) => `case ${id}: {${body}} break;`).join("\n")} }if(!this.busy||this.step===previous${[...yielding].map((id) => `||previous===${id}`).join("")})return;}}
+
+}`;
+        if (!method)
+          replacements.push({ start: fn.getStart(source), end: fn.end, text: generated });
+        else {
+          const parsed = ts.createSourceFile(
+            source.fileName,
+            generated,
+            ts.ScriptTarget.Latest,
+            true,
+          );
+          const worker = parsed.statements.find(ts.isClassDeclaration)!;
+          const names = new Map(
+            worker.members.map((member) => [
+              member.name!.getText(parsed),
+              `tsplcAsync${fn.getStart(source)}_${member.name!.getText(parsed)}`,
+            ]),
+          );
+          names.set("start", method.start);
+          names.set("reset", method.reset);
+          names.set("snapshot", method.snapshot);
+          names.set("execute", method.advance);
+          const transformed = ts.transform(worker, [
+            (context) => (root) => {
+              const visit = (node: ts.Node): ts.VisitResult<ts.Node> => {
+                if (
+                  ts.isElementAccessExpression(node) &&
+                  node.expression.kind === ts.SyntaxKind.ThisKeyword &&
+                  ts.isStringLiteral(node.argumentExpression)
+                )
+                  return ts.factory.createPropertyAccessExpression(
+                    ts.factory.createThis(),
+                    node.argumentExpression.text,
+                  );
+                if (
+                  ts.isPropertyAccessExpression(node) &&
+                  node.expression.kind === ts.SyntaxKind.ThisKeyword &&
+                  names.has(node.name.text)
+                )
+                  return ts.factory.createPropertyAccessExpression(
+                    ts.factory.createThis(),
+                    names.get(node.name.text)!,
+                  );
+                if (
+                  (ts.isPropertyDeclaration(node) || ts.isMethodDeclaration(node)) &&
+                  ts.isIdentifier(node.name) &&
+                  names.has(node.name.text)
+                ) {
+                  const updated = ts.visitEachChild(node, visit, context);
+                  const name = ts.factory.createIdentifier(names.get(node.name.text)!);
+                  if (ts.isPropertyDeclaration(updated))
+                    return ts.factory.updatePropertyDeclaration(
+                      updated,
+                      updated.modifiers,
+                      name,
+                      updated.questionToken ?? updated.exclamationToken,
+                      updated.type,
+                      updated.initializer,
+                    );
+                  if (ts.isMethodDeclaration(updated))
+                    return ts.factory.updateMethodDeclaration(
+                      updated,
+                      [ts.factory.createModifier(ts.SyntaxKind.PublicKeyword)],
+                      updated.asteriskToken,
+                      name,
+                      updated.questionToken,
+                      updated.typeParameters,
+                      updated.parameters,
+                      updated.type,
+                      updated.body,
+                    );
+                }
+                return ts.visitEachChild(node, visit, context);
+              };
+              return ts.visitNode(root, visit) as typeof root;
+            },
+          ]);
+          const generatedClass = transformed.transformed[0]!;
+          replacements.push({
+            start: fn.getStart(source),
+            end: fn.end,
+            text: generatedClass.members
+              .map((member) => printer.printNode(ts.EmitHint.Unspecified, member, parsed))
+              .join("\n"),
+          });
+          transformed.dispose();
+        }
+      }
+      const workTypes = (fn: Routine, dec: ts.VariableDeclaration | ts.PropertyDeclaration) => {
+        const reference = fn.type as ts.TypeReferenceNode;
+        const returnType =
+          reference.typeArguments![0]!.kind === ts.SyntaxKind.VoidKeyword
+            ? "BOOL"
+            : reference.typeArguments![0]!.getText(fn.getSourceFile());
+        // Types in the job module must be visible: use the original inferred Promise result annotation at the definition boundary.
+        const signature = checker.getSignatureFromDeclaration(fn)!;
+        const promised = checker.getAwaitedType(checker.getReturnTypeOfSignature(signature))!;
+        const resultType =
+          promised.flags & ts.TypeFlags.Void
+            ? "BOOL"
+            : checker.typeToString(
+                promised,
+                dec,
+                ts.TypeFormatFlags.NoTruncation |
+                  ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope,
+              );
+        const params = fn.parameters.map((p, i) => ({
+          field: `argument${i}`,
+          name: `argument${i}`,
+          aggregate: Boolean(checker.getTypeAtLocation(p).flags & ts.TypeFlags.Object),
+          type: checker.typeToString(
+            checker.getTypeAtLocation(p),
+            dec,
+            ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope,
+          ),
+        }));
+        // Preserve PLC widths erased by the TS checker when declarations share the module.
+        for (let i = 0; i < params.length; i++)
+          if (fn.getSourceFile() === source)
+            params[i]!.type = fn.parameters[i]!.type!.getText(source);
+        let valueType = fn.getSourceFile() === source ? returnType : resultType;
+        if (fn.getSourceFile() !== source) {
+          const prefix = aliasPrefix(fn);
+          valueType = `${prefix}Result`;
+          for (let i = 0; i < params.length; i++) params[i]!.type = `${prefix}Argument${i}`;
+          const path = relative(dirname(source.fileName), fn.getSourceFile().fileName).replaceAll(
+            "\\",
+            "/",
+          );
+          extra.push(
+            `import type {${valueType},${params.map((p) => p.type).join(",")}} from ${JSON.stringify(path.startsWith(".") ? path : `./${path}`)};`,
+          );
+        }
+        const valueAggregate = Boolean(promised.flags & ts.TypeFlags.Object);
+        return { params, valueType, valueAggregate };
+      };
+      const definitions = source.statements.flatMap<
+        ts.VariableDeclaration | ts.PropertyDeclaration
+      >((stmt) => {
+        if (ts.isVariableStatement(stmt)) return [...stmt.declarationList.declarations];
+        if (ts.isClassDeclaration(stmt)) return stmt.members.filter(ts.isPropertyDeclaration);
+        return [];
+      });
+      for (const dec of definitions) {
+        const owner = ts.isPropertyDeclaration(dec) ? dec.parent : undefined;
+        const init = dec.initializer;
+        if (
+          !init ||
+          !ts.isCallExpression(init) ||
+          !ts.isPropertyAccessExpression(init.expression) ||
+          (!official(init.expression.expression, "backgroundTasks") &&
+            !official(init.expression.expression, "cooperativeTasks") &&
+            !official(init.expression.expression, "tasks")) ||
+          init.expression.name.text !== "define"
+        )
+          continue;
+        if (official(init.expression.expression, "tasks")) {
+          const fn = functions.get(symbol(init.arguments[0] ?? init)!);
+          if (!ts.isIdentifier(dec.name) || init.arguments.length !== 1 || !fn?.type)
+            fail(init, "tasks.define requires one named async function with a return type.");
+          const { params, valueType, valueAggregate } = workTypes(fn, dec);
+          const worker = `tsplcTaskWorker${sequence++}`;
+          const receiver = `this.${worker}`;
+          const site = taskSite(
+            dec.name.text,
+            params,
+            {
+              start: `${receiver}.start`,
+              advance: `${receiver}.update`,
+              snapshot: `${receiver}.snapshot`,
+              reset: `${receiver}.reset`,
+              declaration: `private ${worker}=new ${init.arguments[0]!.getText(source)}();`,
+            },
+            Boolean(owner),
+            { type: valueType, aggregate: valueAggregate },
+          );
+          if (owner) {
+            if (!owner.name) fail(owner, "Task owners require a named block.");
+            replacements.push({ start: dec.getStart(source), end: dec.end, text: site.body });
+            ownedContinuations.set(symbol(owner.name)!, [
+              ...(ownedContinuations.get(symbol(owner.name)!) ?? []),
+              site.poll,
+            ]);
+            const visit = (node: ts.Node): void => {
+              if (
+                ts.isCallExpression(node) &&
+                ts.isPropertyAccessExpression(node.expression) &&
+                ts.isPropertyAccessExpression(node.expression.expression) &&
+                node.expression.expression.expression.kind === ts.SyntaxKind.ThisKeyword &&
+                symbol(node.expression.expression.name) === symbol(dec.name)
+              ) {
+                const renamed = site.renames.get(node.expression.name.text);
+                if (renamed)
+                  replacements.push({
+                    start: node.expression.getStart(source),
+                    end: node.expression.end,
+                    text: `this.${renamed}`,
+                  });
+              }
+              ts.forEachChild(node, visit);
+            };
+            visit(owner);
+          } else {
+            const name = `TsplcTaskSite${sequence++}`,
+              entry = `tsplcContinuation${sequence++}`;
+            extra.push(`class ${name} extends FunctionBlock<{}>{${site.body}protected execute(input:{}):void{}}
+export function ${entry}():void{${dec.name.text}.poll();}`);
+            replacements.push({
+              start: init.getStart(source),
+              end: init.end,
+              text: `new ${name}()`,
+            });
+            result.programs[entry] = { module: resolve(source.fileName), export: entry };
+            result.continuations.set(entry, { instance: dec.name.text, file: source.fileName });
+          }
+          continue;
+        }
+        const cooperative = official(init.expression.expression, "cooperativeTasks");
+        if (cooperative) {
+          if (!ts.isIdentifier(dec.name) || init.arguments.length !== 1)
+            fail(init, "Invalid compiler-owned continuation slot.");
+          const workNode = init.arguments[0]!;
+          const work = functions.get(
+            symbol(ts.isPropertyAccessExpression(workNode) ? workNode.name : workNode)!,
+          );
+          if (!work) fail(workNode, "A continuation requires a named async routine.");
+          const params = work.parameters.map((parameter, index) => ({
+            name: `argument${index}`,
+            type: parameter.type!.getText(work.getSourceFile()),
+            aggregate: Boolean(checker.getTypeAtLocation(parameter).flags & ts.TypeFlags.Object),
+          }));
+          const workMethod = methods.get(symbol(work.name!)!);
+          const worker = `tsplcCooperativeWorker${sequence++}`;
+          const receiver = workMethod ? "this" : `this.${worker}`;
+          const site = cooperativeSite(
+            dec.name.text,
+            params,
+            {
+              start: `${receiver}.${workMethod?.start ?? "start"}`,
+              advance: `${receiver}.${workMethod?.advance ?? "update"}`,
+              snapshot: `${receiver}.${workMethod?.snapshot ?? "snapshot"}`,
+              reset: `${receiver}.${workMethod?.reset ?? "reset"}`,
+              declaration: workMethod ? "" : `private ${worker}=new ${workNode.getText(source)}();`,
+            },
+            Boolean(owner),
+          );
+          if (owner) {
+            if (!owner.name) fail(owner, "Continuation owners require a named block.");
+            replacements.push({ start: dec.getStart(source), end: dec.end, text: site.body });
+            ownedContinuations.set(symbol(owner.name)!, [
+              ...(ownedContinuations.get(symbol(owner.name)!) ?? []),
+              site.poll,
+            ]);
+            const visit = (node: ts.Node): void => {
+              if (
+                ts.isCallExpression(node) &&
+                ts.isPropertyAccessExpression(node.expression) &&
+                ts.isPropertyAccessExpression(node.expression.expression) &&
+                node.expression.expression.expression.kind === ts.SyntaxKind.ThisKeyword &&
+                symbol(node.expression.expression.name) === symbol(dec.name)
+              ) {
+                const renamed =
+                  node.expression.name.text === "start"
+                    ? site.start
+                    : node.expression.name.text === "cancel"
+                      ? site.cancel
+                      : undefined;
+                if (renamed)
+                  replacements.push({
+                    start: node.expression.getStart(source),
+                    end: node.expression.end,
+                    text: `this.${renamed}`,
+                  });
+              }
+              ts.forEachChild(node, visit);
+            };
+            visit(owner);
+          } else {
+            const name = `TsplcCooperativeSite${sequence++}`,
+              entry = `tsplcContinuation${sequence++}`;
+            extra.push(`class ${name} extends FunctionBlock<{}>{${site.body}protected execute(input:{}):void{}}
+export function ${entry}():void{${dec.name.text}.poll();}`);
+            replacements.push({
+              start: init.getStart(source),
+              end: init.end,
+              text: `new ${name}()`,
+            });
+            result.programs[entry] = { module: resolve(source.fileName), export: entry };
+            result.continuations.set(entry, { instance: dec.name.text, file: source.fileName });
+          }
+          continue;
+        }
+        if (
+          !ts.isIdentifier(dec.name) ||
+          init.arguments.length !== 2 ||
+          !ts.isObjectLiteralExpression(init.arguments[1]!)
+        )
+          fail(
+            dec,
+            "Define background tasks at module scope or as function-block fields with a named async function and scheduling options.",
+          );
+        const fn = functions.get(symbol(init.arguments[0]!)!);
+        if (!fn?.type || !ts.isTypeReferenceNode(fn.type))
+          fail(init, "backgroundTasks.define requires a named async function.");
+        const { params, valueType, valueAggregate } = workTypes(fn, dec);
+        const mailbox = `TsplcMailbox${sequence++}`,
+          worker = `tsplcWorker${sequence++}`,
+          entry = `tsplcBackground${sequence++}`;
+        const requestType = `{ready:BOOL;${params.map((p) => `${p.field}:${p.type}`).join(";")}}`;
+        const snapshotType = `{valid:BOOL;busy:BOOL;done:BOOL;cancelRequested:BOOL;error:UDINT;result:${valueType}}`;
+        const emptySnapshot = `{valid:true,busy:this.pending || this.active,done:this.completed,cancelRequested:this.cancelRequested,error:this.failure,result:${copyValue("this.value", valueAggregate)}}`;
+        extra.push(`class ${mailbox} extends FunctionBlock<{}> {
+private pending:BOOL=false;private active:BOOL=false;private completed:BOOL=false;private cancelRequested:BOOL=false;private failure:UDINT=0;private value:${valueType}=defaultValue<${valueType}>();
+${params.map((p) => `private ${p.field}:${p.type}=defaultValue<${p.type}>();`).join("\n")}
+start(${params.map((p) => `${p.name}:${p.type}`).join(",")}):BOOL {if(this.pending || this.active || this.completed)return false;${params.map((p) => `this.${p.field}=${copyValue(p.name, p.aggregate)};`).join("")}this.pending=true;return true;}
+take():${requestType} {const ready:BOOL=this.pending; if(ready){this.pending=false;this.active=true;}return {ready,${params.map((p) => `${p.field}:${copyValue(`this.${p.field}`, p.aggregate)}`).join(",")}};}
+publish(value:${valueType},error:UDINT):BOOL {if(!this.active)return false;if(this.cancelRequested){this.value=defaultValue<${valueType}>();this.failure=1;}else{this.value=${copyValue("value", valueAggregate)};this.failure=error;}this.active=false;this.completed=true;this.cancelRequested=false;return true;}
+snapshot():${snapshotType} {return ${emptySnapshot};}
+cancel():BOOL {if(this.pending){this.pending=false;this.completed=true;this.failure=1;return true;}if(this.active){this.cancelRequested=true;return true;}return false;}
+reset():BOOL {if(this.pending || this.active)return false;this.completed=false;this.failure=0;this.cancelRequested=false;this.value=defaultValue<${valueType}>();return true;}
+protected execute(input:{}):void {}
+}
+`);
+        const receiver = owner ? `this.${dec.name.text}` : dec.name.text;
+        const workerReceiver = owner ? `this.${worker}` : worker;
+        const run = `const request=${receiver}.take();if(request.ready){const accepted:BOOL=${workerReceiver}.start(${params.map((p) => `request.${p.field}`).join(",")});}const control=${receiver}.snapshot();if(!control.valid)return;${workerReceiver}.update({cancel:control.cancelRequested});const state=${workerReceiver}.snapshot();if(state.done){const published:BOOL=${receiver}.publish(state.result,state.error);if(published)${workerReceiver}.reset();}`;
+        if (owner) {
+          if (!owner.name) fail(owner, "Background job owners need a named function block.");
+          replacements.push({
+            start: owner.end - 1,
+            end: owner.end - 1,
+            text: `private ${worker}=new ${text(init.arguments[0]!)}();public ${entry}():void{${run}}`,
+          });
+          result.blocks.set(`${source.fileName}:${owner.name.text}`, { kind: "backgroundHost" });
+        } else
+          extra.push(
+            `const ${worker}=new ${text(init.arguments[0]!)}();export function ${entry}():void{${run}}`,
+          );
+        result.blocks.set(`${source.fileName}:${mailbox}`, { kind: "mailbox" });
+        const opts = new Map(
+          init.arguments[1]!.properties.filter(ts.isPropertyAssignment).map((p) => [
+            p.name.getText(source),
+            p.initializer,
+          ]),
+        );
+        const interval = opts.get("interval"),
+          priority = opts.get("priority");
+        if (
+          !interval ||
+          !ts.isCallExpression(interval) ||
+          interval.arguments.length !== 1 ||
+          !ts.isNumericLiteral(interval.arguments[0]!) ||
+          !priority ||
+          !ts.isNumericLiteral(priority) ||
+          !["ms", "seconds"].some((n) => official(interval.expression, n))
+        )
+          fail(init, "Background schedules require a literal ms/seconds interval and priority.");
+        const milliseconds =
+          Number(interval.arguments[0]!.text) *
+          (official(interval.expression, "seconds") ? 1000 : 1);
+        if (
+          !Number.isSafeInteger(milliseconds) ||
+          milliseconds <= 0 ||
+          milliseconds > 4294967295 ||
+          Number(priority.text) < 1 ||
+          Number(priority.text) > 31
+        )
+          fail(init, "Background interval must be positive and priority must be 1..31.");
+        const schedule = {
+          intervalNanoseconds: String(BigInt(milliseconds) * 1000000n),
+          priority: Number(priority.text),
+          mailbox: dec.name.text,
+          worker,
+        };
+        if (owner) {
+          const key = symbol(owner.name!)!;
+          ownedJobs.set(key, [...(ownedJobs.get(key) ?? []), { method: entry, schedule }]);
+        } else {
+          result.programs[entry] = { module: resolve(source.fileName), export: entry };
+          result.schedules.set(entry, schedule);
+        }
+        replacements.push({
+          start: init.getStart(source),
+          end: init.end,
+          text: `new ${mailbox}()`,
+        });
+      }
+      if (replacements.length) {
+        let changed = source.text;
+        for (const edit of replacements.sort((a, b) => b.start - a.start))
+          changed = changed.slice(0, edit.start) + edit.text + changed.slice(edit.end);
+        const generated = ts.createSourceFile(
+          source.fileName,
+          extra.join("\n"),
+          ts.ScriptTarget.Latest,
+          true,
+        );
+        const before = generated.statements
+          .filter(ts.isClassDeclaration)
+          .map((n) => n.getText(generated))
+          .join("\n");
+        const after = generated.statements
+          .filter((n) => !ts.isClassDeclaration(n))
+          .map((n) => n.getText(generated))
+          .join("\n");
+        result.sources.set(source.fileName, before + "\n" + changed + "\n" + after);
+      }
+    } catch (cause) {
+      if (typeof cause === "object" && cause !== null && "asyncDiagnostic" in cause)
+        result.diagnostics.push(cause.asyncDiagnostic as Diagnostic);
+      else throw cause;
+    }
+  }
+  for (const source of runtimeSources(program)) {
+    if (source.isDeclarationFile) continue;
+    const entries: string[] = [];
+    // `new Block()` allocates one instance; `defaultValue<FixedArray<Block, N, Lower>>()` one per element.
+    const allocated = (node: ts.Node) => {
+      if (ts.isNewExpression(node)) return { block: node.expression };
+      const type = ts.isCallExpression(node) ? node.typeArguments?.[0] : undefined;
+      const [element, length, lower] =
+        type && ts.isTypeReferenceNode(type) && type.typeName.getText(source) === "FixedArray"
+          ? (type.typeArguments ?? [])
+          : [];
+      if (!element || !ts.isTypeReferenceNode(element) || !length) return undefined;
+      // A literal, or a table's `(typeof table)["length"]`.
+      const integer = (node: ts.TypeNode) => {
+        const type = checker.getTypeFromTypeNode(node);
+        return type.isNumberLiteral() ? type.value : NaN;
+      };
+      const first = lower ? integer(lower) : 0;
+      return { block: element.typeName, first, last: first + integer(length) - 1 };
+    };
+    const visit = (node: ts.Node): void => {
+      const instance = allocated(node);
+      if (instance) {
+        const jobs = ownedJobs.get(symbol(instance.block)!);
+        const polls = ownedContinuations.get(symbol(instance.block)!);
+        if (jobs || polls) {
+          const declaration = node.parent;
+          if (
+            !ts.isVariableDeclaration(declaration) ||
+            !ts.isIdentifier(declaration.name) ||
+            !ts.isVariableDeclarationList(declaration.parent) ||
+            !ts.isVariableStatement(declaration.parent.parent) ||
+            !ts.isSourceFile(declaration.parent.parent.parent) ||
+            (jobs && instance.first !== undefined)
+          ) {
+            result.diagnostics.push(
+              diagnosticFor(
+                node,
+                "Function blocks with background jobs require module-level named instances.",
+              ),
+            );
+            return;
+          }
+          const name = declaration.name.text;
+          for (const poll of polls ?? []) {
+            const entry = `tsplcContinuation${sequence++}`;
+            entries.push(
+              instance.first === undefined
+                ? `export function ${entry}():void{${name}.${poll}();}`
+                : `export function ${entry}():void{for(let element:DINT=${instance.first};element<=${instance.last};element++){${name}[element].${poll}();}}`,
+            );
+            result.programs[entry] = { module: resolve(source.fileName), export: entry };
+            result.continuations.set(entry, { instance: name, file: source.fileName });
+          }
+          for (const job of jobs ?? []) {
+            const entry = `tsplcBackground${sequence++}`;
+            entries.push(`export function ${entry}():void{${name}.${job.method}();}`);
+            result.programs[entry] = { module: resolve(source.fileName), export: entry };
+            result.schedules.set(entry, { ...job.schedule, worker: name });
+          }
+        }
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(source);
+    if (entries.length)
+      result.sources.set(
+        source.fileName,
+        (result.sources.get(source.fileName) ?? source.text) + "\n" + entries.join("\n"),
+      );
+  }
+  return result;
+};