@defold-typescript/transpiler 0.52.0 → 0.54.0

package/dist/index.js

@@ -1,8 +1,53 @@
 // src/companion-closure.ts
-import * as ts3 from "typescript";
+import * as ts4 from "typescript";
+
+// src/debug-bootstrap.ts
+import * as ts from "typescript";
+var DEBUG_BLOCK_BEGIN = "// defold-typescript:setup-debug BEGIN — managed block, do not edit";
+var DEBUG_BLOCK_END = "// defold-typescript:setup-debug END";
+var DEBUG_MANAGED_BLOCK = `${DEBUG_BLOCK_BEGIN}
+import * as lldebugger from "lldebugger.debug";
+
+if (sys.get_engine_info().is_debug) {
+  lldebugger.start();
+}
+
+${DEBUG_BLOCK_END}`;
+function occurrences(haystack, needle) {
+  return haystack.split(needle).length - 1;
+}
+function bodyTokens(text) {
+  const scanner = ts.createScanner(ts.ScriptTarget.Latest, true, ts.LanguageVariant.Standard, text);
+  const tokens = [];
+  for (let kind = scanner.scan();kind !== ts.SyntaxKind.EndOfFileToken; kind = scanner.scan()) {
+    if (kind === ts.SyntaxKind.SemicolonToken) {
+      continue;
+    }
+    const spelling = kind === ts.SyntaxKind.StringLiteral ? scanner.getTokenValue() : scanner.getTokenText();
+    tokens.push(`${kind}:${spelling}`);
+  }
+  return tokens;
+}
+var CANONICAL_BODY_TOKENS = bodyTokens(DEBUG_MANAGED_BLOCK.slice(DEBUG_BLOCK_BEGIN.length, DEBUG_MANAGED_BLOCK.length - DEBUG_BLOCK_END.length));
+function findManagedBootstrap(sourceFile) {
+  const text = sourceFile.text;
+  if (occurrences(text, DEBUG_BLOCK_BEGIN) !== 1 || occurrences(text, DEBUG_BLOCK_END) !== 1) {
+    return;
+  }
+  const beginAt = text.indexOf(DEBUG_BLOCK_BEGIN);
+  const endAt = text.indexOf(DEBUG_BLOCK_END);
+  if (endAt < beginAt) {
+    return;
+  }
+  const bodyStart = beginAt + DEBUG_BLOCK_BEGIN.length;
+  const statements = sourceFile.statements.filter((statement) => statement.getStart(sourceFile) >= bodyStart && statement.end <= endAt);
+  const tokens = bodyTokens(text.slice(bodyStart, endAt));
+  const canonical = tokens.length === CANONICAL_BODY_TOKENS.length && tokens.every((token, index) => token === CANONICAL_BODY_TOKENS[index]);
+  return { statements, canonical };
+}
 
 // src/lifecycle-erasure.ts
-import * as ts2 from "typescript";
+import * as ts3 from "typescript";
 import {
   createAssignmentStatement,
   createBinaryExpression as createBinaryExpression2,
@@ -19,11 +64,11 @@ import {
   createTableIndexExpression,
   createVariableDeclarationStatement as createVariableDeclarationStatement2,
   NodeFlags as NodeFlags2,
-  SyntaxKind as SyntaxKind4
+  SyntaxKind as SyntaxKind5
 } from "typescript-to-lua";
 
 // src/message-dispatch-lowering.ts
-import * as ts from "typescript";
+import * as ts2 from "typescript";
 import {
   createBinaryExpression,
   createBlock,
@@ -34,7 +79,7 @@ import {
   createStringLiteral,
   createVariableDeclarationStatement,
   NodeFlags,
-  SyntaxKind as SyntaxKind2
+  SyntaxKind as SyntaxKind3
 } from "typescript-to-lua";
 var DISPATCH_MODULE = "@defold-typescript/types";
 var DISPATCH_NAME = "onMessage";
@@ -44,7 +89,7 @@ function resolvesToDispatchExport(callee, checker) {
   if (symbol === undefined) {
     return false;
   }
-  if (symbol.flags & ts.SymbolFlags.Alias) {
+  if (symbol.flags & ts2.SymbolFlags.Alias) {
     symbol = checker.getAliasedSymbol(symbol);
   }
   if (symbol.getName() !== DISPATCH_NAME) {
@@ -61,13 +106,13 @@ function handlerName(property, checker) {
   if (name === undefined) {
     return;
   }
-  if (ts.isIdentifier(name) || ts.isStringLiteral(name)) {
+  if (ts2.isIdentifier(name) || ts2.isStringLiteral(name)) {
     return name.text;
   }
-  if (ts.isNumericLiteral(name)) {
+  if (ts2.isNumericLiteral(name)) {
     return String(Number(name.text));
   }
-  if (ts.isComputedPropertyName(name)) {
+  if (ts2.isComputedPropertyName(name)) {
     const type = checker.getTypeAtLocation(name.expression);
     if (type.isStringLiteral() || type.isNumberLiteral()) {
       return String(type.value);
@@ -82,32 +127,32 @@ function unlowerableHandler(node, text) {
     file,
     start,
     length: node.getEnd() - start,
-    category: ts.DiagnosticCategory.Error,
+    category: ts2.DiagnosticCategory.Error,
     code: 0,
     messageText: `${DISPATCH_NAME} cannot lower \`${text}\`: pass an object literal whose keys are an identifier, a quoted or numeric literal, or a computed literal constant, each with its handler written inline.`
   };
 }
 function handlerFunction(property) {
-  if (ts.isMethodDeclaration(property) && property.body !== undefined) {
+  if (ts2.isMethodDeclaration(property) && property.body !== undefined) {
     return property;
   }
-  if (ts.isPropertyAssignment(property)) {
+  if (ts2.isPropertyAssignment(property)) {
     const initializer = property.initializer;
-    if (ts.isFunctionExpression(initializer) || ts.isArrowFunction(initializer)) {
+    if (ts2.isFunctionExpression(initializer) || ts2.isArrowFunction(initializer)) {
       return initializer;
     }
   }
   return;
 }
 function isThisParameter(param) {
-  return ts.isIdentifier(param.name) && ts.identifierToKeywordKind(param.name) === ts.SyntaxKind.ThisKeyword;
+  return ts2.isIdentifier(param.name) && ts2.identifierToKeywordKind(param.name) === ts2.SyntaxKind.ThisKeyword;
 }
 function aliasStatements(fn) {
   const params = fn.parameters.filter((param) => !isThisParameter(param));
   const aliases = [];
   params.forEach((param, index) => {
     const engineName = HANDLER_PARAM_TARGETS[index];
-    if (engineName === undefined || !ts.isIdentifier(param.name)) {
+    if (engineName === undefined || !ts2.isIdentifier(param.name)) {
       return;
     }
     if (param.name.text !== engineName) {
@@ -117,19 +162,19 @@ function aliasStatements(fn) {
   return aliases;
 }
 function handlerBody(fn, context) {
-  if (ts.isBlock(fn.body)) {
+  if (ts2.isBlock(fn.body)) {
     return context.transformStatements(fn.body.statements);
   }
-  return context.transformStatements([ts.factory.createExpressionStatement(fn.body)]);
+  return context.transformStatements([ts2.factory.createExpressionStatement(fn.body)]);
 }
 var messageDispatchLoweringPlugin = {
   visitors: {
-    [ts.SyntaxKind.CallExpression]: (node, context) => {
+    [ts2.SyntaxKind.CallExpression]: (node, context) => {
       if (!resolvesToDispatchExport(node.expression, context.checker)) {
         return context.superTransformExpression(node);
       }
       const [handlersArg] = node.arguments;
-      if (node.arguments.length === 1 && handlersArg !== undefined && ts.isObjectLiteralExpression(handlersArg)) {
+      if (node.arguments.length === 1 && handlersArg !== undefined && ts2.isObjectLiteralExpression(handlersArg)) {
         let chain;
         const properties = [...handlersArg.properties];
         for (let i = properties.length - 1;i >= 0; i--) {
@@ -144,7 +189,7 @@ var messageDispatchLoweringPlugin = {
             context.diagnostics.push(unlowerableHandler(property, offending.getText()));
             continue;
           }
-          const condition = createBinaryExpression(createIdentifier("message_id"), createCallExpression(createIdentifier("hash"), [createStringLiteral(name)]), SyntaxKind2.EqualityOperator);
+          const condition = createBinaryExpression(createIdentifier("message_id"), createCallExpression(createIdentifier("hash"), [createStringLiteral(name)]), SyntaxKind3.EqualityOperator);
           const body = [...aliasStatements(fn), ...handlerBody(fn, context)];
           chain = createIfStatement(condition, createBlock(body), chain);
         }
@@ -177,7 +222,7 @@ function factoryExportName(callee, checker) {
   if (symbol === undefined) {
     return;
   }
-  if (symbol.flags & ts2.SymbolFlags.Alias) {
+  if (symbol.flags & ts3.SymbolFlags.Alias) {
     symbol = checker.getAliasedSymbol(symbol);
   }
   const name = symbol.getName();
@@ -194,51 +239,51 @@ function resolvesToFactoryExport(callee, checker) {
   return factoryExportName(callee, checker) !== undefined;
 }
 function isThisParameter2(param) {
-  return ts2.isIdentifier(param.name) && ts2.identifierToKeywordKind(param.name) === ts2.SyntaxKind.ThisKeyword;
+  return ts3.isIdentifier(param.name) && ts3.identifierToKeywordKind(param.name) === ts3.SyntaxKind.ThisKeyword;
 }
 function hookName(property) {
   const name = property.name;
   if (name === undefined) {
     return;
   }
-  if (ts2.isIdentifier(name) || ts2.isStringLiteral(name)) {
+  if (ts3.isIdentifier(name) || ts3.isStringLiteral(name)) {
     return name.text;
   }
   return;
 }
 function hookFunction(property) {
-  if (ts2.isMethodDeclaration(property) && property.body !== undefined) {
+  if (ts3.isMethodDeclaration(property) && property.body !== undefined) {
     return property;
   }
-  if (ts2.isPropertyAssignment(property)) {
+  if (ts3.isPropertyAssignment(property)) {
     const initializer = property.initializer;
-    if (ts2.isFunctionExpression(initializer) || ts2.isArrowFunction(initializer)) {
+    if (ts3.isFunctionExpression(initializer) || ts3.isArrowFunction(initializer)) {
       return initializer;
     }
   }
   return;
 }
 function dispatcherInitializer(property, checker) {
-  if (!ts2.isPropertyAssignment(property)) {
+  if (!ts3.isPropertyAssignment(property)) {
     return;
   }
   const initializer = property.initializer;
-  if (!ts2.isCallExpression(initializer)) {
+  if (!ts3.isCallExpression(initializer)) {
     return;
   }
   return resolvesToDispatchExport(initializer.expression, checker) ? initializer : undefined;
 }
 function transformHookBody(fn, context) {
-  if (ts2.isBlock(fn.body)) {
+  if (ts3.isBlock(fn.body)) {
     return context.transformStatements(fn.body.statements);
   }
   return [createExpressionStatement(context.transformExpression(fn.body))];
 }
 function crossesFunctionBoundary(node) {
-  return ts2.isFunctionDeclaration(node) || ts2.isFunctionExpression(node) || ts2.isArrowFunction(node) || ts2.isMethodDeclaration(node) || ts2.isGetAccessorDeclaration(node) || ts2.isSetAccessorDeclaration(node);
+  return ts3.isFunctionDeclaration(node) || ts3.isFunctionExpression(node) || ts3.isArrowFunction(node) || ts3.isMethodDeclaration(node) || ts3.isGetAccessorDeclaration(node) || ts3.isSetAccessorDeclaration(node);
 }
 function initReturnsValue(fn) {
-  if (!ts2.isBlock(fn.body)) {
+  if (!ts3.isBlock(fn.body)) {
     return true;
   }
   let found = false;
@@ -246,23 +291,23 @@ function initReturnsValue(fn) {
     if (found || crossesFunctionBoundary(node)) {
       return;
     }
-    if (ts2.isReturnStatement(node) && node.expression !== undefined) {
+    if (ts3.isReturnStatement(node) && node.expression !== undefined) {
       found = true;
       return;
     }
-    ts2.forEachChild(node, visit);
+    ts3.forEachChild(node, visit);
   };
-  ts2.forEachChild(fn.body, visit);
+  ts3.forEachChild(fn.body, visit);
   return found;
 }
 function initBuilderBody(fn, context) {
-  if (ts2.isBlock(fn.body)) {
+  if (ts3.isBlock(fn.body)) {
     return context.transformStatements(fn.body.statements);
   }
   return [createReturnStatement([context.transformExpression(fn.body)])];
 }
 function emitInitMerge(fn, context, property) {
-  const authorParam = fn.parameters.find((param) => !isThisParameter2(param) && ts2.isIdentifier(param.name));
+  const authorParam = fn.parameters.find((param) => !isThisParameter2(param) && ts3.isIdentifier(param.name));
   const builderParams = authorParam === undefined ? [] : [context.transformExpression(authorParam.name)];
   const builder = createFunctionExpression2(createBlock2(initBuilderBody(fn, context)), builderParams, undefined, NodeFlags2.Declaration, fn);
   const builderDecl = createVariableDeclarationStatement2(createIdentifier2("____init"), builder);
@@ -270,7 +315,7 @@ function emitInitMerge(fn, context, property) {
   const stateDecl = createVariableDeclarationStatement2(createIdentifier2("____s"), createCallExpression2(createIdentifier2("____init"), builderArgs));
   const mergeAssignment = createAssignmentStatement(createTableIndexExpression(createIdentifier2("self"), createIdentifier2("____k")), createIdentifier2("____v"));
   const forIn = createForInStatement(createBlock2([mergeAssignment]), [createIdentifier2("____k"), createIdentifier2("____v")], [createCallExpression2(createIdentifier2("pairs"), [createIdentifier2("____s")])]);
-  const guard = createIfStatement2(createBinaryExpression2(createIdentifier2("____s"), createNilLiteral(), SyntaxKind4.InequalityOperator), createBlock2([forIn]));
+  const guard = createIfStatement2(createBinaryExpression2(createIdentifier2("____s"), createNilLiteral(), SyntaxKind5.InequalityOperator), createBlock2([forIn]));
   const initFn = createFunctionExpression2(createBlock2([stateDecl, guard]), [createIdentifier2("self")], undefined, NodeFlags2.Declaration, fn);
   return [builderDecl, createAssignmentStatement(createIdentifier2("init"), initFn, property)];
 }
@@ -284,16 +329,16 @@ var RESOURCE_PROPERTY_MARKERS = new Set([
   "resource.tile_source"
 ]);
 function propertyMembers(property) {
-  if (!ts2.isPropertyAssignment(property) || !ts2.isObjectLiteralExpression(property.initializer)) {
+  if (!ts3.isPropertyAssignment(property) || !ts3.isObjectLiteralExpression(property.initializer)) {
     return [];
   }
   const members = [];
   for (const member of property.initializer.properties) {
-    if (!ts2.isPropertyAssignment(member)) {
+    if (!ts3.isPropertyAssignment(member)) {
       continue;
     }
     const key = member.name;
-    if (!ts2.isIdentifier(key) && !ts2.isStringLiteral(key)) {
+    if (!ts3.isIdentifier(key) && !ts3.isStringLiteral(key)) {
       continue;
     }
     members.push({ name: key.text, initializer: member.initializer });
@@ -301,14 +346,14 @@ function propertyMembers(property) {
   return members;
 }
 function factoryHooks(expression, checker) {
-  if (!ts2.isCallExpression(expression)) {
+  if (!ts3.isCallExpression(expression)) {
     return;
   }
   if (!resolvesToFactoryExport(expression.expression, checker)) {
     return;
   }
   const hooks = expression.arguments[0];
-  if (hooks === undefined || !ts2.isObjectLiteralExpression(hooks)) {
+  if (hooks === undefined || !ts3.isObjectLiteralExpression(hooks)) {
     return;
   }
   return hooks;
@@ -326,21 +371,21 @@ function scriptOnlyProperties(property, factory) {
     file,
     start,
     length: property.getEnd() - start,
-    category: ts2.DiagnosticCategory.Error,
+    category: ts3.DiagnosticCategory.Error,
     code: 0,
     messageText: `\`${factory}\` cannot declare \`properties\`: Defold builds \`go.property\` only in \`.script\` files. Declare the property in a \`defineScript\` and send its value with \`msg.post\`.`
   };
 }
 function outermostWrapper(node) {
   let current = node;
-  while (ts2.isParenthesizedExpression(current.parent) || ts2.isAsExpression(current.parent) || ts2.isSatisfiesExpression(current.parent) || ts2.isNonNullExpression(current.parent) || ts2.isTypeAssertionExpression(current.parent)) {
+  while (ts3.isParenthesizedExpression(current.parent) || ts3.isAsExpression(current.parent) || ts3.isSatisfiesExpression(current.parent) || ts3.isNonNullExpression(current.parent) || ts3.isTypeAssertionExpression(current.parent)) {
     current = current.parent;
   }
   return current;
 }
 function innermostExpression(node) {
   let current = node;
-  while (ts2.isParenthesizedExpression(current) || ts2.isAsExpression(current) || ts2.isSatisfiesExpression(current) || ts2.isNonNullExpression(current) || ts2.isTypeAssertionExpression(current)) {
+  while (ts3.isParenthesizedExpression(current) || ts3.isAsExpression(current) || ts3.isSatisfiesExpression(current) || ts3.isNonNullExpression(current) || ts3.isTypeAssertionExpression(current)) {
     current = current.expression;
   }
   return current;
@@ -354,7 +399,7 @@ function globalName(symbol, checker) {
 }
 function calledGlobal(call, checker) {
   const declaration = checker.getResolvedSignature(call)?.declaration;
-  if (declaration === undefined || !ts2.isFunctionDeclaration(declaration) || declaration.name === undefined) {
+  if (declaration === undefined || !ts3.isFunctionDeclaration(declaration) || declaration.name === undefined) {
     return;
   }
   return globalName(checker.getSymbolAtLocation(declaration.name), checker);
@@ -362,15 +407,15 @@ function calledGlobal(call, checker) {
 function isPropertyDefault(call, checker) {
   const value = outermostWrapper(call);
   const parent = value.parent;
-  if (ts2.isCallExpression(parent)) {
+  if (ts3.isCallExpression(parent)) {
     return parent.arguments[1] === value && calledGlobal(parent, checker) === "go.property";
   }
   const properties = parent?.parent?.parent;
-  if (properties === undefined || !ts2.isPropertyAssignment(properties) || !isPropertiesHook(properties)) {
+  if (properties === undefined || !ts3.isPropertyAssignment(properties) || !isPropertiesHook(properties)) {
     return false;
   }
   const hooks = properties.parent;
-  return ts2.isObjectLiteralExpression(hooks) && factoryHooks(hooks.parent, checker) === hooks && propertyMembers(properties).some((member) => member.initializer === value);
+  return ts3.isObjectLiteralExpression(hooks) && factoryHooks(hooks.parent, checker) === hooks && propertyMembers(properties).some((member) => member.initializer === value);
 }
 function misplacedMarker(node, marker) {
   const file = node.getSourceFile();
@@ -379,25 +424,25 @@ function misplacedMarker(node, marker) {
     file,
     start,
     length: node.getEnd() - start,
-    category: ts2.DiagnosticCategory.Error,
+    category: ts3.DiagnosticCategory.Error,
     code: 0,
     messageText: `\`${marker}\` is a build-time marker: Defold's build reads it only in a \`go.property\` default, and the engine binds no such function. Use it as a \`defineScript\` \`properties\` default.`
   };
 }
 function readsAsMarker(call) {
   const callee = innermostExpression(call.expression);
-  if (ts2.isOptionalChain(call) || ts2.isOptionalChain(callee)) {
+  if (ts3.isOptionalChain(call) || ts3.isOptionalChain(callee)) {
     return false;
   }
-  if (!ts2.isPropertyAccessExpression(callee) && !(ts2.isElementAccessExpression(callee) && ts2.isStringLiteralLike(innermostExpression(callee.argumentExpression)))) {
+  if (!ts3.isPropertyAccessExpression(callee) && !(ts3.isElementAccessExpression(callee) && ts3.isStringLiteralLike(innermostExpression(callee.argumentExpression)))) {
     return false;
   }
   const receiver = innermostExpression(callee.expression);
-  if (!ts2.isIdentifier(receiver) || receiver.text !== "resource") {
+  if (!ts3.isIdentifier(receiver) || receiver.text !== "resource") {
     return false;
   }
   const [path] = call.arguments;
-  return path === undefined || ts2.isStringLiteralLike(innermostExpression(path));
+  return path === undefined || ts3.isStringLiteralLike(innermostExpression(path));
 }
 function unreadableMarker(node, marker) {
   const file = node.getSourceFile();
@@ -406,18 +451,18 @@ function unreadableMarker(node, marker) {
     file,
     start,
     length: node.getEnd() - start,
-    category: ts2.DiagnosticCategory.Error,
+    category: ts3.DiagnosticCategory.Error,
     code: 0,
     messageText: `\`${marker}\` in a property default must be written \`${marker}("<path>")\`, with a string literal path: Defold's build reads no other form.`
   };
 }
 function isCallee(node) {
   const callee = outermostWrapper(node);
-  return ts2.isCallExpression(callee.parent) && callee.parent.expression === callee;
+  return ts3.isCallExpression(callee.parent) && callee.parent.expression === callee;
 }
 function eraseFactoryCall(expression, context) {
   const hooks = factoryHooks(expression, context.checker);
-  if (hooks === undefined || !ts2.isCallExpression(expression)) {
+  if (hooks === undefined || !ts3.isCallExpression(expression)) {
     return;
   }
   const factory = factoryExportName(expression.expression, context.checker);
@@ -448,14 +493,14 @@ function eraseFactoryCall(expression, context) {
       statements.push(...emitInitMerge(fn, context, property));
       continue;
     }
-    const params = fn.parameters.filter((param) => !isThisParameter2(param) && ts2.isIdentifier(param.name)).map((param) => context.transformExpression(param.name));
+    const params = fn.parameters.filter((param) => !isThisParameter2(param) && ts3.isIdentifier(param.name)).map((param) => context.transformExpression(param.name));
     const fnExpression = createFunctionExpression2(createBlock2(transformHookBody(fn, context)), params, undefined, NodeFlags2.Declaration, fn);
     statements.push(createAssignmentStatement(createIdentifier2(name), fnExpression, property));
   }
   return [...registrations, ...statements];
 }
 function isFactoryOnlyImport(node) {
-  if (!ts2.isStringLiteral(node.moduleSpecifier) || !FACTORY_SPECIFIERS.has(node.moduleSpecifier.text)) {
+  if (!ts3.isStringLiteral(node.moduleSpecifier) || !FACTORY_SPECIFIERS.has(node.moduleSpecifier.text)) {
     return false;
   }
   const clause = node.importClause;
@@ -466,7 +511,7 @@ function isFactoryOnlyImport(node) {
     return false;
   }
   const bindings = clause.namedBindings;
-  if (bindings === undefined || !ts2.isNamedImports(bindings)) {
+  if (bindings === undefined || !ts3.isNamedImports(bindings)) {
     return false;
   }
   const runtime = bindings.elements.filter((element) => !element.isTypeOnly);
@@ -477,8 +522,8 @@ function isFactoryOnlyImport(node) {
 }
 var lifecycleErasurePlugin = {
   visitors: {
-    [ts2.SyntaxKind.ExpressionStatement]: (node, context) => eraseFactoryCall(node.expression, context) ?? context.superTransformStatements(node),
-    [ts2.SyntaxKind.ExportAssignment]: (node, context) => {
+    [ts3.SyntaxKind.ExpressionStatement]: (node, context) => eraseFactoryCall(node.expression, context) ?? context.superTransformStatements(node),
+    [ts3.SyntaxKind.ExportAssignment]: (node, context) => {
       if (!node.isExportEquals) {
         const erased = eraseFactoryCall(node.expression, context);
         if (erased !== undefined) {
@@ -487,8 +532,8 @@ var lifecycleErasurePlugin = {
       }
       return context.superTransformStatements(node);
     },
-    [ts2.SyntaxKind.ImportDeclaration]: (node, context) => isFactoryOnlyImport(node) ? [] : context.superTransformStatements(node),
-    [ts2.SyntaxKind.CallExpression]: (node, context) => {
+    [ts3.SyntaxKind.ImportDeclaration]: (node, context) => isFactoryOnlyImport(node) ? [] : context.superTransformStatements(node),
+    [ts3.SyntaxKind.CallExpression]: (node, context) => {
       const marker = node.parent === undefined ? undefined : calledGlobal(node, context.checker);
       if (marker !== undefined && RESOURCE_PROPERTY_MARKERS.has(marker)) {
         if (!isPropertyDefault(node, context.checker)) {
@@ -499,7 +544,7 @@ var lifecycleErasurePlugin = {
       }
       return context.superTransformExpression(node);
     },
-    [ts2.SyntaxKind.PropertyAccessExpression]: (node, context) => {
+    [ts3.SyntaxKind.PropertyAccessExpression]: (node, context) => {
       if (node.parent !== undefined && !isCallee(node)) {
         const marker = globalName(context.checker.getSymbolAtLocation(node.name), context.checker);
         if (marker !== undefined && RESOURCE_PROPERTY_MARKERS.has(marker)) {
@@ -508,10 +553,10 @@ var lifecycleErasurePlugin = {
       }
       return context.superTransformExpression(node);
     },
-    [ts2.SyntaxKind.ElementAccessExpression]: (node, context) => {
+    [ts3.SyntaxKind.ElementAccessExpression]: (node, context) => {
       if (node.parent !== undefined && !isCallee(node)) {
         const key = innermostExpression(node.argumentExpression);
-        const marker = ts2.isStringLiteralLike(key) ? globalName(context.checker.getPropertyOfType(context.checker.getTypeAtLocation(node.expression), key.text), context.checker) : undefined;
+        const marker = ts3.isStringLiteralLike(key) ? globalName(context.checker.getPropertyOfType(context.checker.getTypeAtLocation(node.expression), key.text), context.checker) : undefined;
         if (marker !== undefined && RESOURCE_PROPERTY_MARKERS.has(marker)) {
           context.diagnostics.push(misplacedMarker(node, marker));
         }
@@ -524,12 +569,12 @@ var lifecycleErasurePlugin = {
 // src/companion-closure.ts
 var COMPANION_INTERNAL_FIELD = "____closure";
 function isAssignmentOperator(kind) {
-  return kind >= ts3.SyntaxKind.FirstAssignment && kind <= ts3.SyntaxKind.LastAssignment;
+  return kind >= ts4.SyntaxKind.FirstAssignment && kind <= ts4.SyntaxKind.LastAssignment;
 }
 function isTypePosition(node) {
   let current = node.parent;
-  while (current !== undefined && !ts3.isSourceFile(current)) {
-    if (ts3.isTypeNode(current)) {
+  while (current !== undefined && !ts4.isSourceFile(current)) {
+    if (ts4.isTypeNode(current)) {
       return true;
     }
     current = current.parent;
@@ -541,57 +586,57 @@ function isDeclarationName(node) {
   if (parent === undefined) {
     return false;
   }
-  if (ts3.isPropertyAccessExpression(parent)) {
+  if (ts4.isPropertyAccessExpression(parent)) {
     return parent.name === node;
   }
-  if (ts3.isQualifiedName(parent)) {
+  if (ts4.isQualifiedName(parent)) {
     return parent.right === node;
   }
-  if ((ts3.isBindingElement(parent) || ts3.isImportSpecifier(parent) || ts3.isExportSpecifier(parent)) && parent.propertyName === node) {
+  if ((ts4.isBindingElement(parent) || ts4.isImportSpecifier(parent) || ts4.isExportSpecifier(parent)) && parent.propertyName === node) {
     return true;
   }
   const named = parent;
   if (named.name !== node) {
     return false;
   }
-  return ts3.isVariableDeclaration(parent) || ts3.isFunctionDeclaration(parent) || ts3.isClassDeclaration(parent) || ts3.isEnumDeclaration(parent) || ts3.isEnumMember(parent) || ts3.isParameter(parent) || ts3.isBindingElement(parent) || ts3.isImportClause(parent) || ts3.isImportSpecifier(parent) || ts3.isNamespaceImport(parent) || ts3.isPropertyAssignment(parent) || ts3.isPropertyDeclaration(parent) || ts3.isPropertySignature(parent) || ts3.isMethodDeclaration(parent) || ts3.isMethodSignature(parent) || ts3.isTypeAliasDeclaration(parent) || ts3.isInterfaceDeclaration(parent) || ts3.isGetAccessor(parent) || ts3.isSetAccessor(parent);
+  return ts4.isVariableDeclaration(parent) || ts4.isFunctionDeclaration(parent) || ts4.isClassDeclaration(parent) || ts4.isEnumDeclaration(parent) || ts4.isEnumMember(parent) || ts4.isParameter(parent) || ts4.isBindingElement(parent) || ts4.isImportClause(parent) || ts4.isImportSpecifier(parent) || ts4.isNamespaceImport(parent) || ts4.isPropertyAssignment(parent) || ts4.isPropertyDeclaration(parent) || ts4.isPropertySignature(parent) || ts4.isMethodDeclaration(parent) || ts4.isMethodSignature(parent) || ts4.isTypeAliasDeclaration(parent) || ts4.isInterfaceDeclaration(parent) || ts4.isGetAccessor(parent) || ts4.isSetAccessor(parent);
 }
 function forEachReference(root, checker, visit) {
   const walk = (node) => {
-    if (ts3.isIdentifier(node) && !isDeclarationName(node) && !isTypePosition(node)) {
+    if (ts4.isIdentifier(node) && !isDeclarationName(node) && !isTypePosition(node)) {
       const symbol = resolveReferencedSymbol(node, checker);
       if (symbol !== undefined) {
         visit(node, symbol);
       }
     }
-    ts3.forEachChild(node, walk);
+    ts4.forEachChild(node, walk);
   };
   walk(root);
 }
 function resolveReferencedSymbol(node, checker) {
   const parent = node.parent;
-  if (parent !== undefined && ts3.isShorthandPropertyAssignment(parent) && parent.name === node) {
+  if (parent !== undefined && ts4.isShorthandPropertyAssignment(parent) && parent.name === node) {
     return checker.getShorthandAssignmentValueSymbol(parent) ?? checker.getSymbolAtLocation(node);
   }
   return checker.getSymbolAtLocation(node);
 }
 function forEachAssignmentTarget(root, checker, visit) {
   const classify = (target) => {
-    if (ts3.isParenthesizedExpression(target)) {
+    if (ts4.isParenthesizedExpression(target)) {
       classify(target.expression);
       return;
     }
-    if (ts3.isPropertyAccessExpression(target) || ts3.isElementAccessExpression(target)) {
+    if (ts4.isPropertyAccessExpression(target) || ts4.isElementAccessExpression(target)) {
       return;
     }
-    if (ts3.isArrayLiteralExpression(target)) {
+    if (ts4.isArrayLiteralExpression(target)) {
       for (const element of target.elements) {
-        if (ts3.isOmittedExpression(element)) {
+        if (ts4.isOmittedExpression(element)) {
           continue;
         }
-        if (ts3.isSpreadElement(element)) {
+        if (ts4.isSpreadElement(element)) {
           classify(element.expression);
-        } else if (ts3.isBinaryExpression(element) && element.operatorToken.kind === ts3.SyntaxKind.EqualsToken) {
+        } else if (ts4.isBinaryExpression(element) && element.operatorToken.kind === ts4.SyntaxKind.EqualsToken) {
           classify(element.left);
         } else {
           classify(element);
@@ -599,13 +644,13 @@ function forEachAssignmentTarget(root, checker, visit) {
       }
       return;
     }
-    if (ts3.isObjectLiteralExpression(target)) {
+    if (ts4.isObjectLiteralExpression(target)) {
       for (const property of target.properties) {
-        if (ts3.isPropertyAssignment(property)) {
+        if (ts4.isPropertyAssignment(property)) {
           classify(property.initializer);
-        } else if (ts3.isSpreadAssignment(property)) {
+        } else if (ts4.isSpreadAssignment(property)) {
           classify(property.expression);
-        } else if (ts3.isShorthandPropertyAssignment(property)) {
+        } else if (ts4.isShorthandPropertyAssignment(property)) {
           const symbol = checker.getShorthandAssignmentValueSymbol(property);
           if (symbol !== undefined) {
             visit(property.name, symbol);
@@ -614,7 +659,7 @@ function forEachAssignmentTarget(root, checker, visit) {
       }
       return;
     }
-    if (ts3.isIdentifier(target)) {
+    if (ts4.isIdentifier(target)) {
       const symbol = checker.getSymbolAtLocation(target);
       if (symbol !== undefined) {
         visit(target, symbol);
@@ -622,14 +667,14 @@ function forEachAssignmentTarget(root, checker, visit) {
     }
   };
   const walk = (node) => {
-    if (ts3.isBinaryExpression(node) && isAssignmentOperator(node.operatorToken.kind)) {
+    if (ts4.isBinaryExpression(node) && isAssignmentOperator(node.operatorToken.kind)) {
       classify(node.left);
-    } else if ((ts3.isPrefixUnaryExpression(node) || ts3.isPostfixUnaryExpression(node)) && (node.operator === ts3.SyntaxKind.PlusPlusToken || node.operator === ts3.SyntaxKind.MinusMinusToken)) {
+    } else if ((ts4.isPrefixUnaryExpression(node) || ts4.isPostfixUnaryExpression(node)) && (node.operator === ts4.SyntaxKind.PlusPlusToken || node.operator === ts4.SyntaxKind.MinusMinusToken)) {
       classify(node.operand);
-    } else if ((ts3.isForInStatement(node) || ts3.isForOfStatement(node)) && !ts3.isVariableDeclarationList(node.initializer)) {
+    } else if ((ts4.isForInStatement(node) || ts4.isForOfStatement(node)) && !ts4.isVariableDeclarationList(node.initializer)) {
       classify(node.initializer);
     }
-    ts3.forEachChild(node, walk);
+    ts4.forEachChild(node, walk);
   };
   walk(root);
 }
@@ -637,7 +682,7 @@ function collectTopLevel(sourceFile, checker) {
   const declarations = new Map;
   let order = 0;
   const add = (name, statement, node) => {
-    if (name === undefined || !ts3.isIdentifier(name)) {
+    if (name === undefined || !ts4.isIdentifier(name)) {
       return;
     }
     const symbol = checker.getSymbolAtLocation(name);
@@ -647,24 +692,24 @@ function collectTopLevel(sourceFile, checker) {
     declarations.set(symbol, { name: name.text, statement, node, order: order++ });
   };
   const addBinding = (name, statement, node) => {
-    if (ts3.isIdentifier(name)) {
+    if (ts4.isIdentifier(name)) {
       add(name, statement, node);
       return;
     }
     for (const element of name.elements) {
-      if (ts3.isBindingElement(element)) {
+      if (ts4.isBindingElement(element)) {
         addBinding(element.name, statement, node);
       }
     }
   };
   for (const statement of sourceFile.statements) {
-    if (ts3.isVariableStatement(statement)) {
+    if (ts4.isVariableStatement(statement)) {
       for (const declaration of statement.declarationList.declarations) {
         addBinding(declaration.name, statement, declaration);
       }
-    } else if (ts3.isFunctionDeclaration(statement) || ts3.isClassDeclaration(statement) || ts3.isEnumDeclaration(statement)) {
+    } else if (ts4.isFunctionDeclaration(statement) || ts4.isClassDeclaration(statement) || ts4.isEnumDeclaration(statement)) {
       add(statement.name, statement, statement);
-    } else if (ts3.isImportDeclaration(statement)) {
+    } else if (ts4.isImportDeclaration(statement)) {
       const clause = statement.importClause;
       if (clause === undefined) {
         continue;
@@ -674,7 +719,7 @@ function collectTopLevel(sourceFile, checker) {
       if (bindings === undefined) {
         continue;
       }
-      if (ts3.isNamespaceImport(bindings)) {
+      if (ts4.isNamespaceImport(bindings)) {
         add(bindings.name, statement, statement);
       } else {
         for (const element of bindings.elements) {
@@ -686,14 +731,14 @@ function collectTopLevel(sourceFile, checker) {
   return declarations;
 }
 function hasExportModifier(statement) {
-  return ts3.canHaveModifiers(statement) && (ts3.getModifiers(statement) ?? []).some((modifier) => modifier.kind === ts3.SyntaxKind.ExportKeyword);
+  return ts4.canHaveModifiers(statement) && (ts4.getModifiers(statement) ?? []).some((modifier) => modifier.kind === ts4.SyntaxKind.ExportKeyword);
 }
 function isValueSymbol(symbol, checker) {
   if (symbol === undefined) {
     return false;
   }
-  const resolved = symbol.flags & ts3.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
-  return (resolved.flags & ts3.SymbolFlags.Value) !== 0;
+  const resolved = symbol.flags & ts4.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+  return (resolved.flags & ts4.SymbolFlags.Value) !== 0;
 }
 function collectExports(sourceFile, checker, topLevel) {
   const exported = [];
@@ -721,12 +766,12 @@ function collectExports(sourceFile, checker, topLevel) {
     take(symbol, name.text, declaration.node);
   };
   for (const statement of sourceFile.statements) {
-    if (ts3.isExportDeclaration(statement)) {
+    if (ts4.isExportDeclaration(statement)) {
       if (statement.moduleSpecifier !== undefined || statement.isTypeOnly) {
         continue;
       }
       const clause = statement.exportClause;
-      if (clause === undefined || !ts3.isNamedExports(clause)) {
+      if (clause === undefined || !ts4.isNamedExports(clause)) {
         continue;
       }
       for (const element of clause.elements) {
@@ -740,11 +785,11 @@ function collectExports(sourceFile, checker, topLevel) {
     if (!hasExportModifier(statement)) {
       continue;
     }
-    if (ts3.isVariableStatement(statement)) {
+    if (ts4.isVariableStatement(statement)) {
       for (const declaration of statement.declarationList.declarations) {
         forEachDeclaredName(declaration.name, (name) => takeLocal(checker.getSymbolAtLocation(name), name));
       }
-    } else if (ts3.isFunctionDeclaration(statement) || ts3.isClassDeclaration(statement) || ts3.isEnumDeclaration(statement)) {
+    } else if (ts4.isFunctionDeclaration(statement) || ts4.isClassDeclaration(statement) || ts4.isEnumDeclaration(statement)) {
       if (statement.name !== undefined) {
         takeLocal(checker.getSymbolAtLocation(statement.name), statement.name);
       }
@@ -753,74 +798,74 @@ function collectExports(sourceFile, checker, topLevel) {
   return exported;
 }
 function forEachDeclaredName(name, visit) {
-  if (ts3.isIdentifier(name)) {
+  if (ts4.isIdentifier(name)) {
     visit(name);
     return;
   }
   for (const element of name.elements) {
-    if (ts3.isBindingElement(element)) {
+    if (ts4.isBindingElement(element)) {
       forEachDeclaredName(element.name, visit);
     }
   }
 }
 function isLifecycleFactoryCall(expression, checker) {
-  return ts3.isCallExpression(expression) && resolvesToFactoryExport(expression.expression, checker);
+  return ts4.isCallExpression(expression) && resolvesToFactoryExport(expression.expression, checker);
 }
 function isEffectFreeExpression(expression) {
   if (expression === undefined) {
     return true;
   }
-  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+  if (ts4.isParenthesizedExpression(expression) || ts4.isAsExpression(expression) || ts4.isTypeAssertionExpression(expression) || ts4.isNonNullExpression(expression)) {
     return isEffectFreeExpression(expression.expression);
   }
-  if (ts3.isIdentifier(expression) || ts3.isLiteralExpression(expression)) {
+  if (ts4.isIdentifier(expression) || ts4.isLiteralExpression(expression)) {
     return true;
   }
   switch (expression.kind) {
-    case ts3.SyntaxKind.TrueKeyword:
-    case ts3.SyntaxKind.FalseKeyword:
-    case ts3.SyntaxKind.NullKeyword:
-    case ts3.SyntaxKind.ThisKeyword:
+    case ts4.SyntaxKind.TrueKeyword:
+    case ts4.SyntaxKind.FalseKeyword:
+    case ts4.SyntaxKind.NullKeyword:
+    case ts4.SyntaxKind.ThisKeyword:
       return true;
     default:
       break;
   }
-  if (ts3.isFunctionExpression(expression) || ts3.isArrowFunction(expression)) {
+  if (ts4.isFunctionExpression(expression) || ts4.isArrowFunction(expression)) {
     return true;
   }
-  if (ts3.isPrefixUnaryExpression(expression)) {
-    return expression.operator !== ts3.SyntaxKind.PlusPlusToken && expression.operator !== ts3.SyntaxKind.MinusMinusToken && isEffectFreeExpression(expression.operand);
+  if (ts4.isPrefixUnaryExpression(expression)) {
+    return expression.operator !== ts4.SyntaxKind.PlusPlusToken && expression.operator !== ts4.SyntaxKind.MinusMinusToken && isEffectFreeExpression(expression.operand);
   }
-  if (ts3.isBinaryExpression(expression)) {
+  if (ts4.isBinaryExpression(expression)) {
     return !isAssignmentOperator(expression.operatorToken.kind) && isEffectFreeExpression(expression.left) && isEffectFreeExpression(expression.right);
   }
-  if (ts3.isConditionalExpression(expression)) {
+  if (ts4.isConditionalExpression(expression)) {
     return isEffectFreeExpression(expression.condition) && isEffectFreeExpression(expression.whenTrue) && isEffectFreeExpression(expression.whenFalse);
   }
-  if (ts3.isArrayLiteralExpression(expression)) {
+  if (ts4.isArrayLiteralExpression(expression)) {
     return expression.elements.every(isEffectFreeExpression);
   }
-  if (ts3.isObjectLiteralExpression(expression)) {
+  if (ts4.isObjectLiteralExpression(expression)) {
     return expression.properties.every((property) => {
-      if (ts3.isPropertyAssignment(property)) {
+      if (ts4.isPropertyAssignment(property)) {
         return isEffectFreeExpression(property.initializer);
       }
-      return ts3.isShorthandPropertyAssignment(property) || ts3.isMethodDeclaration(property);
+      return ts4.isShorthandPropertyAssignment(property) || ts4.isMethodDeclaration(property);
     });
   }
   return false;
 }
 function isEffectFreeStatement(statement, checker) {
-  if (ts3.isImportDeclaration(statement) || ts3.isInterfaceDeclaration(statement) || ts3.isTypeAliasDeclaration(statement) || ts3.isFunctionDeclaration(statement) || ts3.isExportDeclaration(statement)) {
+  if (ts4.isImportDeclaration(statement) || ts4.isInterfaceDeclaration(statement) || ts4.isTypeAliasDeclaration(statement) || ts4.isFunctionDeclaration(statement) || ts4.isExportDeclaration(statement)) {
     return true;
   }
-  if (ts3.isVariableStatement(statement)) {
+  if (ts4.isVariableStatement(statement)) {
     return statement.declarationList.declarations.every((declaration) => isEffectFreeExpression(declaration.initializer));
   }
-  if (ts3.isExpressionStatement(statement)) {
+  if (ts4.isExpressionStatement(statement)) {
     return isLifecycleFactoryCall(statement.expression, checker) || isEffectFreeExpression(statement.expression);
   }
-  if (ts3.isExportAssignment(statement) && !statement.isExportEquals) {
+  if (ts4.isExportAssignment(statement) && !statement.isExportEquals) {
     return isLifecycleFactoryCall(statement.expression, checker) || isEffectFreeExpression(statement.expression);
   }
   return false;
@@ -860,7 +905,7 @@ function computeCompanionClosure(sourceFile, checker) {
     if (declaration === undefined) {
       continue;
     }
-    if (ts3.isImportDeclaration(declaration.statement)) {
+    if (ts4.isImportDeclaration(declaration.statement)) {
       importBindingSymbols.add(symbol);
       continue;
     }
@@ -880,7 +925,7 @@ function computeCompanionClosure(sourceFile, checker) {
   }
   const splits = closureStatements.size > 0;
   for (const statement of sourceFile.statements) {
-    if (!ts3.isExportDeclaration(statement) || statement.isTypeOnly) {
+    if (!ts4.isExportDeclaration(statement) || statement.isTypeOnly) {
       continue;
     }
     if (statement.moduleSpecifier !== undefined) {
@@ -890,7 +935,7 @@ function computeCompanionClosure(sourceFile, checker) {
       continue;
     }
     const clause = statement.exportClause;
-    if (clause === undefined || !ts3.isNamedExports(clause)) {
+    if (clause === undefined || !ts4.isNamedExports(clause)) {
       continue;
     }
     const readsMember = clause.elements.some((element) => {
@@ -913,7 +958,7 @@ function computeCompanionClosure(sourceFile, checker) {
   });
   const scriptReferences = new Map;
   for (const statement of sourceFile.statements) {
-    if (closureStatements.has(statement) || ts3.isExportDeclaration(statement)) {
+    if (closureStatements.has(statement) || ts4.isExportDeclaration(statement)) {
       continue;
     }
     forEachReference(statement, checker, (node, symbol) => {
@@ -957,8 +1002,12 @@ function computeCompanionClosure(sourceFile, checker) {
       message: `"${COMPANION_INTERNAL_FIELD}" is reserved for the companion's own internals ` + `and cannot be exported (${formatSites(sites)}). Rename the export.`
     });
   }
+  const managed = findManagedBootstrap(sourceFile);
+  const bootstrap = managed?.canonical === true ? managed.statements : [];
+  const editedBlock = new Set(managed?.canonical === false ? managed.statements : []);
+  const exempt = new Set(bootstrap);
   for (const statement of sourceFile.statements) {
-    if (closureStatements.has(statement) || isEffectFreeStatement(statement, checker)) {
+    if (closureStatements.has(statement) || exempt.has(statement) || isEffectFreeStatement(statement, checker)) {
       continue;
     }
     const start = statement.getStart(sourceFile);
@@ -970,11 +1019,12 @@ function computeCompanionClosure(sourceFile, checker) {
       siteOf(statement, "runs in the script"),
       siteOf(hoisted.declaration.node, "moves into the companion")
     ];
+    const name = hoisted.declaration.name;
     violations.push({
       kind: "initialization-order",
-      member: hoisted.declaration.name,
+      member: name,
       sites,
-      message: `top-level work precedes "${hoisted.declaration.name}", which the companion would run first, ` + `reversing their order (${formatSites(sites)}). ` + "Move that work below the companion's declarations, or into a lifecycle hook."
+      message: editedBlock.has(statement) ? `the setup-debug managed block was edited and now runs top-level work before "${name}", ` + `which the companion would run first (${formatSites(sites)}). ` + "Run `defold-typescript setup-debug` to restore the block." : `top-level work precedes "${name}", which the companion would run first, ` + `reversing their order (${formatSites(sites)}). ` + "Move that work below the companion's declarations, or into a lifecycle hook."
     });
   }
   return {
@@ -983,6 +1033,7 @@ function computeCompanionClosure(sourceFile, checker) {
     statements: sourceFile.statements.filter((statement) => closureStatements.has(statement)),
     importBindings: ordered.filter(({ symbol }) => importBindingSymbols.has(symbol)).map(({ declaration }) => declaration.name),
     internals: ordered.filter(({ symbol }) => !exportSet.has(symbol) && scriptReferences.has(symbol)).map(({ declaration }) => declaration.name),
+    bootstrap,
     violations
   };
 }
@@ -1531,7 +1582,7 @@ function readGameProjectSetting(gameProjectText, section, key) {
 import { existsSync, readdirSync } from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-import * as ts4 from "typescript";
+import * as ts5 from "typescript";
 import { LuaLibFeature } from "typescript-to-lua";
 
 // src/lua-require-scan.ts
@@ -1614,6 +1665,41 @@ function mask(lua) {
   return { text, literals };
 }
 var REQUIRE_RE = new RegExp(String.raw`(?<![A-Za-z0-9_.])require\s*\(\s*${PLACEHOLDER}(\d+)${PLACEHOLDER}\s*\)`, "g");
+function isLuaSpace(c) {
+  return c === " " || c === "\t" || c === `
+` || c === "\r";
+}
+var REQUIRE_WORD = "require";
+function callSpan(lua, literal) {
+  let i = literal.start - 1;
+  while (isLuaSpace(lua[i])) {
+    i--;
+  }
+  if (lua[i] !== "(") {
+    return;
+  }
+  i--;
+  while (isLuaSpace(lua[i])) {
+    i--;
+  }
+  const wordEnd = i + 1;
+  const wordStart = wordEnd - REQUIRE_WORD.length;
+  if (wordStart < 0 || lua.slice(wordStart, wordEnd) !== REQUIRE_WORD) {
+    return;
+  }
+  const before = lua[wordStart - 1];
+  if (before !== undefined && /[A-Za-z0-9_.]/.test(before)) {
+    return;
+  }
+  let j = literal.end;
+  while (isLuaSpace(lua[j])) {
+    j++;
+  }
+  if (lua[j] !== ")") {
+    return;
+  }
+  return { callStart: wordStart, callEnd: j + 1 };
+}
 function scanEmittedRequires(lua) {
   const { text, literals } = mask(lua);
   const sites = [];
@@ -1622,7 +1708,12 @@ function scanEmittedRequires(lua) {
     if (literal === undefined) {
       continue;
     }
-    sites.push({ path: literal.value, start: literal.start, end: literal.end });
+    sites.push({
+      path: literal.value,
+      start: literal.start,
+      end: literal.end,
+      ...callSpan(lua, literal)
+    });
   }
   return sites;
 }
@@ -1679,7 +1770,7 @@ function isHsmRequireName(requirePath) {
   return hsmModuleOfRequire(requirePath) !== undefined;
 }
 function hsmModuleOfSpecifier(node) {
-  if (node === undefined || !ts4.isStringLiteral(node)) {
+  if (node === undefined || !ts5.isStringLiteral(node)) {
     return;
   }
   const { text } = node;
@@ -1719,7 +1810,7 @@ function hsmClosure(chunks, compile) {
   return Object.fromEntries(Object.entries(selected).sort(([a], [b]) => a.localeCompare(b)));
 }
 function lowerSpecifier(module) {
-  return ts4.factory.createStringLiteral(`@NoResolution:${module.requireName}`);
+  return ts5.factory.createStringLiteral(`@NoResolution:${module.requireName}`);
 }
 function loweredAnything(lowered) {
   return Array.isArray(lowered) ? lowered.length > 0 : lowered !== undefined;
@@ -1737,7 +1828,7 @@ function importSurvivesElision(node, context) {
   if (bindings === undefined) {
     return false;
   }
-  if (ts4.isNamespaceImport(bindings)) {
+  if (ts5.isNamespaceImport(bindings)) {
     return resolver.isReferencedAliasDeclaration(bindings);
   }
   return bindings.elements.some((element) => resolver.isReferencedAliasDeclaration(element));
@@ -1750,20 +1841,20 @@ function registerLualib(module, emitted, context) {
 }
 var hsmLoweringPlugin = {
   visitors: {
-    [ts4.SyntaxKind.ImportDeclaration]: (node, context) => {
+    [ts5.SyntaxKind.ImportDeclaration]: (node, context) => {
       const module = hsmModuleOfSpecifier(node.moduleSpecifier);
       if (module === undefined) {
         return context.superTransformStatements(node);
       }
       registerLualib(module, importSurvivesElision(node, context), context);
-      return context.superTransformStatements(ts4.factory.updateImportDeclaration(node, node.modifiers, node.importClause, lowerSpecifier(module), node.attributes));
+      return context.superTransformStatements(ts5.factory.updateImportDeclaration(node, node.modifiers, node.importClause, lowerSpecifier(module), node.attributes));
     },
-    [ts4.SyntaxKind.ExportDeclaration]: (node, context) => {
+    [ts5.SyntaxKind.ExportDeclaration]: (node, context) => {
       const module = hsmModuleOfSpecifier(node.moduleSpecifier);
       if (module === undefined) {
         return context.superTransformStatements(node);
       }
-      const lowered = context.superTransformStatements(ts4.factory.updateExportDeclaration(node, node.modifiers, node.isTypeOnly, node.exportClause, lowerSpecifier(module), node.attributes));
+      const lowered = context.superTransformStatements(ts5.factory.updateExportDeclaration(node, node.modifiers, node.isTypeOnly, node.exportClause, lowerSpecifier(module), node.attributes));
       registerLualib(module, loweredAnything(lowered), context);
       return lowered;
     }
@@ -2283,20 +2374,20 @@ function readLibrarySceneDocuments(host, projectRoot, extensions = LIBRARY_SCENE
   return { documents, unreadable };
 }
 // src/main-entry-factory-imports.ts
-import * as ts5 from "typescript";
+import * as ts6 from "typescript";
 function findMainEntryFactoryImports(fileName, source) {
-  const sourceFile = ts5.createSourceFile(fileName, source, ts5.ScriptTarget.Latest, true);
+  const sourceFile = ts6.createSourceFile(fileName, source, ts6.ScriptTarget.Latest, true);
   const factories = [];
   for (const statement of sourceFile.statements) {
-    if (!ts5.isImportDeclaration(statement)) {
+    if (!ts6.isImportDeclaration(statement)) {
       continue;
     }
     const specifier = statement.moduleSpecifier;
-    if (!ts5.isStringLiteral(specifier) || specifier.text !== FACTORY_MODULE) {
+    if (!ts6.isStringLiteral(specifier) || specifier.text !== FACTORY_MODULE) {
       continue;
     }
     const bindings = statement.importClause?.namedBindings;
-    if (bindings === undefined || !ts5.isNamedImports(bindings)) {
+    if (bindings === undefined || !ts6.isNamedImports(bindings)) {
       continue;
     }
     for (const element of bindings.elements) {
@@ -2369,16 +2460,16 @@ function computeOutputRel(rel, config, kind) {
   return baseRel.replace(/\.ts$/, SCRIPT_SUFFIX_BY_KIND[kind]);
 }
 // src/program-diagnostics.ts
-import * as ts11 from "typescript";
+import * as ts12 from "typescript";
 import * as tstl from "typescript-to-lua";
 
 // src/message-guard-lowering.ts
-import * as ts6 from "typescript";
+import * as ts7 from "typescript";
 import {
   createBinaryExpression as createBinaryExpression3,
   createCallExpression as createCallExpression3,
   createIdentifier as createIdentifier3,
-  SyntaxKind as SyntaxKind8
+  SyntaxKind as SyntaxKind9
 } from "typescript-to-lua";
 var GUARD_MODULE = "@defold-typescript/types";
 var GUARD_NAME = "isMessage";
@@ -2387,7 +2478,7 @@ function resolvesToGuardExport(callee, checker) {
   if (symbol === undefined) {
     return false;
   }
-  if (symbol.flags & ts6.SymbolFlags.Alias) {
+  if (symbol.flags & ts7.SymbolFlags.Alias) {
     symbol = checker.getAliasedSymbol(symbol);
   }
   if (symbol.getName() !== GUARD_NAME) {
@@ -2401,12 +2492,12 @@ function resolvesToGuardExport(callee, checker) {
 }
 var messageGuardLoweringPlugin = {
   visitors: {
-    [ts6.SyntaxKind.CallExpression]: (node, context) => {
+    [ts7.SyntaxKind.CallExpression]: (node, context) => {
       const [messageIdArg, , expectedArg] = node.arguments;
       if (node.arguments.length === 3 && messageIdArg !== undefined && expectedArg !== undefined && resolvesToGuardExport(node.expression, context.checker)) {
         const messageId = context.transformExpression(messageIdArg);
         const expected = context.transformExpression(expectedArg);
-        return createBinaryExpression3(messageId, createCallExpression3(createIdentifier3("hash"), [expected]), SyntaxKind8.EqualityOperator, node);
+        return createBinaryExpression3(messageId, createCallExpression3(createIdentifier3("hash"), [expected]), SyntaxKind9.EqualityOperator, node);
       }
       return context.superTransformExpression(node);
     }
@@ -2414,14 +2505,14 @@ var messageGuardLoweringPlugin = {
 };
 
 // src/physics-event-guard-lowering.ts
-import * as ts7 from "typescript";
+import * as ts8 from "typescript";
 import {
   createBinaryExpression as createBinaryExpression4,
   createCallExpression as createCallExpression4,
   createIdentifier as createIdentifier4,
   createStringLiteral as createStringLiteral3,
   createTableIndexExpression as createTableIndexExpression2,
-  SyntaxKind as SyntaxKind10
+  SyntaxKind as SyntaxKind11
 } from "typescript-to-lua";
 var GUARD_MODULE2 = "@defold-typescript/types";
 var GUARD_NAME2 = "isPhysicsEvent";
@@ -2430,7 +2521,7 @@ function resolvesToGuardExport2(callee, checker) {
   if (symbol === undefined) {
     return false;
   }
-  if (symbol.flags & ts7.SymbolFlags.Alias) {
+  if (symbol.flags & ts8.SymbolFlags.Alias) {
     symbol = checker.getAliasedSymbol(symbol);
   }
   if (symbol.getName() !== GUARD_NAME2) {
@@ -2444,12 +2535,12 @@ function resolvesToGuardExport2(callee, checker) {
 }
 var physicsEventGuardLoweringPlugin = {
   visitors: {
-    [ts7.SyntaxKind.CallExpression]: (node, context) => {
+    [ts8.SyntaxKind.CallExpression]: (node, context) => {
       const [eventArg, nameArg] = node.arguments;
       if (node.arguments.length === 2 && eventArg !== undefined && nameArg !== undefined && resolvesToGuardExport2(node.expression, context.checker)) {
         const event = context.transformExpression(eventArg);
         const name = context.transformExpression(nameArg);
-        return createBinaryExpression4(createTableIndexExpression2(event, createStringLiteral3("type")), createCallExpression4(createIdentifier4("hash"), [name]), SyntaxKind10.EqualityOperator, node);
+        return createBinaryExpression4(createTableIndexExpression2(event, createStringLiteral3("type")), createCallExpression4(createIdentifier4("hash"), [name]), SyntaxKind11.EqualityOperator, node);
       }
       return context.superTransformExpression(node);
     }
@@ -2457,37 +2548,37 @@ var physicsEventGuardLoweringPlugin = {
 };
 
 // src/timers-lowering.ts
-import * as ts8 from "typescript";
+import * as ts9 from "typescript";
 import { LuaLibFeature as LuaLibFeature2 } from "typescript-to-lua";
 function isTimersSpecifier(node) {
-  return ts8.isStringLiteral(node) && node.text === TIMERS_MODULE_SPECIFIER;
+  return ts9.isStringLiteral(node) && node.text === TIMERS_MODULE_SPECIFIER;
 }
 function importsTimersModule(sourceFile) {
-  return sourceFile.statements.some((statement) => ts8.isImportDeclaration(statement) && isTimersSpecifier(statement.moduleSpecifier));
+  return sourceFile.statements.some((statement) => ts9.isImportDeclaration(statement) && isTimersSpecifier(statement.moduleSpecifier));
 }
 var TIMERS_REQUIRE_PATH = `@NoResolution:${TIMERS_REQUIRE_NAME}`;
 var timersLoweringPlugin = {
   visitors: {
-    [ts8.SyntaxKind.ImportDeclaration]: (node, context) => {
+    [ts9.SyntaxKind.ImportDeclaration]: (node, context) => {
       if (!isTimersSpecifier(node.moduleSpecifier)) {
         return context.superTransformStatements(node);
       }
       context.usedLuaLibFeatures.add(LuaLibFeature2.Promise);
       context.usedLuaLibFeatures.add(LuaLibFeature2.New);
-      const rewritten = ts8.factory.updateImportDeclaration(node, node.modifiers, node.importClause, ts8.factory.createStringLiteral(TIMERS_REQUIRE_PATH), node.attributes);
+      const rewritten = ts9.factory.updateImportDeclaration(node, node.modifiers, node.importClause, ts9.factory.createStringLiteral(TIMERS_REQUIRE_PATH), node.attributes);
       return context.superTransformStatements(rewritten);
     }
   }
 };
 
 // src/type-application-erasure.ts
-import * as ts9 from "typescript";
+import * as ts10 from "typescript";
 var TYPE_APPLICATION_APIS = new Set(["go.get", "go.set"]);
 function isTypeApplication(call, checker) {
   if (call.arguments.length !== 0)
     return false;
   const declaration = checker.getResolvedSignature(call)?.declaration;
-  if (declaration === undefined || !ts9.isFunctionDeclaration(declaration))
+  if (declaration === undefined || !ts10.isFunctionDeclaration(declaration))
     return false;
   if (declaration.parameters.length !== 0 || declaration.typeParameters === undefined)
     return false;
@@ -2501,7 +2592,7 @@ function isTypeApplication(call, checker) {
 }
 var typeApplicationErasurePlugin = {
   visitors: {
-    [ts9.SyntaxKind.CallExpression]: (node, context) => {
+    [ts10.SyntaxKind.CallExpression]: (node, context) => {
       if (isTypeApplication(node, context.checker)) {
         return context.transformExpression(node.expression);
       }
@@ -2511,10 +2602,10 @@ var typeApplicationErasurePlugin = {
 };
 
 // src/window-event-guard-lowering.ts
-import * as ts10 from "typescript";
+import * as ts11 from "typescript";
 import {
   createBinaryExpression as createBinaryExpression5,
-  SyntaxKind as SyntaxKind14
+  SyntaxKind as SyntaxKind15
 } from "typescript-to-lua";
 var GUARD_MODULE3 = "@defold-typescript/types";
 var GUARD_NAME3 = "isWindowEvent";
@@ -2523,7 +2614,7 @@ function resolvesToGuardExport3(callee, checker) {
   if (symbol === undefined) {
     return false;
   }
-  if (symbol.flags & ts10.SymbolFlags.Alias) {
+  if (symbol.flags & ts11.SymbolFlags.Alias) {
     symbol = checker.getAliasedSymbol(symbol);
   }
   if (symbol.getName() !== GUARD_NAME3) {
@@ -2537,12 +2628,12 @@ function resolvesToGuardExport3(callee, checker) {
 }
 var windowEventGuardLoweringPlugin = {
   visitors: {
-    [ts10.SyntaxKind.CallExpression]: (node, context) => {
+    [ts11.SyntaxKind.CallExpression]: (node, context) => {
       const [eventArg, , expectedArg] = node.arguments;
       if (node.arguments.length === 3 && eventArg !== undefined && expectedArg !== undefined && resolvesToGuardExport3(node.expression, context.checker)) {
         const event = context.transformExpression(eventArg);
         const expected = context.transformExpression(expectedArg);
-        return createBinaryExpression5(event, expected, SyntaxKind14.EqualityOperator, node);
+        return createBinaryExpression5(event, expected, SyntaxKind15.EqualityOperator, node);
       }
       return context.superTransformExpression(node);
     }
@@ -2564,7 +2655,7 @@ function isAmbient(fileName) {
   return /[\\/]node_modules[\\/]/.test(fileName) || /(^|[\\/])lib\.[^\\/]*\.d\.ts$/.test(fileName);
 }
 function getProgramDiagnostics(program, sourceFile) {
-  const { diagnostics } = tstl.getProgramTranspileResult(ts11.sys, noopWriteFile, {
+  const { diagnostics } = tstl.getProgramTranspileResult(ts12.sys, noopWriteFile, {
     program,
     plugins: LUA_PLUGINS,
     ...sourceFile ? { sourceFiles: [sourceFile] } : {}
@@ -3135,11 +3226,11 @@ function relativeAddressesFrom(index, context) {
 import { readFileSync as readFileSync2 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 import * as path4 from "node:path";
-import * as ts15 from "typescript";
+import * as ts17 from "typescript";
 import * as tstl3 from "typescript-to-lua";
 
 // src/companion-emit.ts
-import * as ts12 from "typescript";
+import * as ts13 from "typescript";
 import {
   createAssignmentStatement as createAssignmentStatement2,
   createCallExpression as createCallExpression5,
@@ -3173,8 +3264,8 @@ function exportsIdentifier() {
 }
 function isRuntimeScriptSource(sourceFile, checker) {
   return sourceFile.statements.some((statement) => {
-    const expression = ts12.isExpressionStatement(statement) ? statement.expression : ts12.isExportAssignment(statement) && !statement.isExportEquals ? statement.expression : undefined;
-    return expression !== undefined && ts12.isCallExpression(expression) && resolvesToFactoryExport(expression.expression, checker);
+    const expression = ts13.isExpressionStatement(statement) ? statement.expression : ts13.isExportAssignment(statement) && !statement.isExportEquals ? statement.expression : undefined;
+    return expression !== undefined && ts13.isCallExpression(expression) && resolvesToFactoryExport(expression.expression, checker);
   });
 }
 function planFor(sourceFile, checker) {
@@ -3187,6 +3278,7 @@ function planFor(sourceFile, checker) {
   }
   return {
     closureStarts: new Set(closure.statements.map((statement) => statement.pos)),
+    bootstrapStarts: new Set(closure.bootstrap.map((statement) => statement.pos)),
     internals: closure.internals,
     importBindings: closure.importBindings,
     requirePath: requirePathForRel(sourceFile.fileName)
@@ -3326,11 +3418,11 @@ function freeNames(statements) {
 function resolvedRequirePaths(sourceFile, checker) {
   const paths = new Map;
   for (const statement of sourceFile.statements) {
-    const specifier = ts12.isImportDeclaration(statement) || ts12.isExportDeclaration(statement) ? statement.moduleSpecifier : undefined;
-    if (specifier === undefined || !ts12.isStringLiteral(specifier)) {
+    const specifier = ts13.isImportDeclaration(statement) || ts13.isExportDeclaration(statement) ? statement.moduleSpecifier : undefined;
+    if (specifier === undefined || !ts13.isStringLiteral(specifier)) {
       continue;
     }
-    const target = checker.getSymbolAtLocation(specifier)?.declarations?.find((declaration) => ts12.isSourceFile(declaration));
+    const target = checker.getSymbolAtLocation(specifier)?.declarations?.find((declaration) => ts13.isSourceFile(declaration));
     if (target === undefined || target.isDeclarationFile) {
       continue;
     }
@@ -3473,6 +3565,7 @@ function split(statements, owned) {
 function createCompanionEmitPlugin() {
   const plans = new Map;
   const owned = new Map;
+  const bootstraps = new Map;
   const companions = new Map;
   function planOf(sourceFile, checker) {
     const key = sourceFile.fileName;
@@ -3498,12 +3591,30 @@ function createCompanionEmitPlugin() {
     }
     return statements;
   }
+  function captureBootstrap(node, context) {
+    const statements = context.superTransformStatements(node);
+    const sourceFile = context.sourceFile;
+    const plan = planOf(sourceFile, context.checker);
+    if (plan === undefined || !plan.bootstrapStarts.has(node.pos)) {
+      return statements;
+    }
+    let bucket = bootstraps.get(sourceFile.fileName);
+    if (bucket === undefined) {
+      bucket = new Set;
+      bootstraps.set(sourceFile.fileName, bucket);
+    }
+    for (const statement of statements) {
+      bucket.add(statement);
+    }
+    return statements;
+  }
   const visitors = {
-    [ts12.SyntaxKind.VariableStatement]: capture,
-    [ts12.SyntaxKind.FunctionDeclaration]: capture,
-    [ts12.SyntaxKind.ClassDeclaration]: capture,
-    [ts12.SyntaxKind.EnumDeclaration]: capture,
-    [ts12.SyntaxKind.ExportDeclaration]: capture
+    [ts13.SyntaxKind.VariableStatement]: capture,
+    [ts13.SyntaxKind.FunctionDeclaration]: capture,
+    [ts13.SyntaxKind.ClassDeclaration]: capture,
+    [ts13.SyntaxKind.EnumDeclaration]: capture,
+    [ts13.SyntaxKind.ExportDeclaration]: capture,
+    [ts13.SyntaxKind.IfStatement]: captureBootstrap
   };
   let configuredNoResolvePaths = [];
   const plugin = {
@@ -3523,7 +3634,8 @@ function createCompanionEmitPlugin() {
         if (plan === undefined || bucket === undefined || bucket.size === 0) {
           continue;
         }
-        emitCompanion(program, emitHost, file, sourceFile, plan, bucket, companions);
+        const bootstrap = bootstraps.get(sourceFile.fileName) ?? new Set;
+        emitCompanion(program, emitHost, file, sourceFile, plan, bucket, bootstrap, companions);
         emitted.push(plan.requirePath);
       }
       if (emitted.length > 0) {
@@ -3533,7 +3645,7 @@ function createCompanionEmitPlugin() {
   };
   return { plugin, companions };
 }
-function emitCompanion(program, emitHost, file, sourceFile, plan, owned, companions) {
+function emitCompanion(program, emitHost, file, sourceFile, plan, owned, bootstrap, companions) {
   const luaAst = file.luaAst;
   if (luaAst === undefined) {
     return;
@@ -3552,12 +3664,14 @@ function emitCompanion(program, emitHost, file, sourceFile, plan, owned, compani
     createReturnStatement2([exportsIdentifier()])
   ];
   const reads = new Set([EXPORTS_NAME, ...plan.internals]);
-  const insertAt = requireInsertionPoint(halves.script, reads);
+  const rest = halves.script.filter((statement) => !bootstrap.has(statement));
+  const insertAt = requireInsertionPoint(rest, reads);
   const scriptStatements = [
-    ...halves.script.slice(0, insertAt),
+    ...rest.slice(0, insertAt),
+    ...halves.script.filter((statement) => bootstrap.has(statement)),
     createVariableDeclarationStatement3(exportsIdentifier(), createCallExpression5(createIdentifier5("require"), [createStringLiteral4(plan.requirePath)])),
     ...plan.internals.map((name) => createVariableDeclarationStatement3(createIdentifier5(name), internalsField(name))),
-    ...halves.script.slice(insertAt),
+    ...rest.slice(insertAt),
     createReturnStatement2([exportsIdentifier()])
   ];
   const features = new Set(luaAst.luaLibFeatures);
@@ -3572,7 +3686,7 @@ function emitCompanion(program, emitHost, file, sourceFile, plan, owned, compani
 }
 
 // src/editor-script-erasure.ts
-import * as ts13 from "typescript";
+import * as ts14 from "typescript";
 import {
   createReturnStatement as createReturnStatement3
 } from "typescript-to-lua";
@@ -3592,7 +3706,7 @@ function resolveEditorFactoryExport(callee, checker) {
   if (symbol === undefined) {
     return;
   }
-  if (symbol.flags & ts13.SymbolFlags.Alias) {
+  if (symbol.flags & ts14.SymbolFlags.Alias) {
     symbol = checker.getAliasedSymbol(symbol);
   }
   const name = symbol.getName();
@@ -3606,7 +3720,7 @@ function resolveEditorFactoryExport(callee, checker) {
   return declaration.getSourceFile().fileName.includes(EDITOR_FACTORY_MODULE) ? name : undefined;
 }
 function lowerEditorFactoryCall(expression, context) {
-  if (!ts13.isCallExpression(expression)) {
+  if (!ts14.isCallExpression(expression)) {
     return;
   }
   if (resolveEditorFactoryExport(expression.expression, context.checker) !== EDITOR_SCRIPT_FACTORY_NAME) {
@@ -3619,7 +3733,7 @@ function lowerEditorFactoryCall(expression, context) {
   return [createReturnStatement3([context.transformExpression(module)])];
 }
 function isEditorFactoryOnlyImport(node) {
-  if (!ts13.isStringLiteral(node.moduleSpecifier) || !EDITOR_FACTORY_SPECIFIERS.has(node.moduleSpecifier.text)) {
+  if (!ts14.isStringLiteral(node.moduleSpecifier) || !EDITOR_FACTORY_SPECIFIERS.has(node.moduleSpecifier.text)) {
     return false;
   }
   const clause = node.importClause;
@@ -3630,7 +3744,7 @@ function isEditorFactoryOnlyImport(node) {
     return false;
   }
   const bindings = clause.namedBindings;
-  if (bindings === undefined || !ts13.isNamedImports(bindings)) {
+  if (bindings === undefined || !ts14.isNamedImports(bindings)) {
     return false;
   }
   const runtime = bindings.elements.filter((element) => !element.isTypeOnly);
@@ -3641,7 +3755,7 @@ function isEditorFactoryOnlyImport(node) {
 }
 var editorScriptErasurePlugin = {
   visitors: {
-    [ts13.SyntaxKind.ExportAssignment]: (node, context) => {
+    [ts14.SyntaxKind.ExportAssignment]: (node, context) => {
       if (!node.isExportEquals) {
         const lowered = lowerEditorFactoryCall(node.expression, context);
         if (lowered !== undefined) {
@@ -3650,17 +3764,139 @@ var editorScriptErasurePlugin = {
       }
       return context.superTransformStatements(node);
     },
-    [ts13.SyntaxKind.CallExpression]: (node, context) => {
+    [ts14.SyntaxKind.CallExpression]: (node, context) => {
       const command = node.arguments[0];
       if (command !== undefined && resolveEditorFactoryExport(node.expression, context.checker) === EDITOR_COMMAND_FACTORY_NAME) {
         return context.transformExpression(command);
       }
       return context.superTransformExpression(node);
     },
-    [ts13.SyntaxKind.ImportDeclaration]: (node, context) => isEditorFactoryOnlyImport(node) ? [] : context.superTransformStatements(node)
+    [ts14.SyntaxKind.ImportDeclaration]: (node, context) => isEditorFactoryOnlyImport(node) ? [] : context.superTransformStatements(node)
   }
 };
 
+// src/native-global-modules.ts
+import * as ts15 from "typescript";
+var GLOBAL_TABLE_TAG = "globalTable";
+var GLOBAL_TABLE_REQUIRE_MARKER = "@defold-typescript:global-table:";
+var NO_RESOLUTION_PREFIX = "@NoResolution:";
+var LUA_GLOBAL_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*$/;
+function resolveGlobalTableTag(specifier, checker) {
+  if (!ts15.isStringLiteral(specifier)) {
+    return { kind: "untagged" };
+  }
+  const symbol = checker.getSymbolAtLocation(specifier);
+  for (const declaration of symbol?.declarations ?? []) {
+    if (!ts15.isModuleDeclaration(declaration) || !ts15.isStringLiteral(declaration.name)) {
+      continue;
+    }
+    const tag = ts15.getJSDocTags(declaration).find((t) => t.tagName.text === GLOBAL_TABLE_TAG);
+    if (tag === undefined) {
+      continue;
+    }
+    const comment = ts15.getTextOfJSDocComment(tag.comment)?.trim();
+    const globalName = comment === undefined || comment === "" ? specifier.text : comment.split(/\s+/)[0] ?? specifier.text;
+    if (!LUA_GLOBAL_NAME_RE.test(globalName)) {
+      return { kind: "invalid", globalName, moduleId: specifier.text };
+    }
+    return { kind: "tagged", globalName };
+  }
+  return { kind: "untagged" };
+}
+function markerRequirePath(globalName) {
+  return `${NO_RESOLUTION_PREFIX}${GLOBAL_TABLE_REQUIRE_MARKER}${globalName}`;
+}
+function invalidGlobalName(node, resolution) {
+  const file = node.getSourceFile();
+  const start = node.getStart(file);
+  return {
+    file,
+    start,
+    length: node.getEnd() - start,
+    category: ts15.DiagnosticCategory.Error,
+    code: 0,
+    messageText: `@${GLOBAL_TABLE_TAG} on module "${resolution.moduleId}" names \`${resolution.globalName}\`, which is not a valid Lua global name; use dotted identifiers (\`pixels\`, \`b2d.body\`).`
+  };
+}
+var nativeGlobalModulesPlugin = {
+  visitors: {
+    [ts15.SyntaxKind.ImportDeclaration]: (node, context) => {
+      const resolution = resolveGlobalTableTag(node.moduleSpecifier, context.checker);
+      if (resolution.kind === "invalid") {
+        context.diagnostics.push(invalidGlobalName(node.moduleSpecifier, resolution));
+        return context.superTransformStatements(node);
+      }
+      if (resolution.kind === "untagged") {
+        return context.superTransformStatements(node);
+      }
+      if (node.importClause === undefined) {
+        return [];
+      }
+      const rewritten = ts15.factory.updateImportDeclaration(node, node.modifiers, node.importClause, ts15.factory.createStringLiteral(markerRequirePath(resolution.globalName)), node.attributes);
+      return context.superTransformStatements(rewritten);
+    },
+    [ts15.SyntaxKind.ExportDeclaration]: (node, context) => {
+      const specifier = node.moduleSpecifier;
+      if (specifier === undefined) {
+        return context.superTransformStatements(node);
+      }
+      const resolution = resolveGlobalTableTag(specifier, context.checker);
+      if (resolution.kind === "invalid") {
+        context.diagnostics.push(invalidGlobalName(specifier, resolution));
+        return context.superTransformStatements(node);
+      }
+      if (resolution.kind === "untagged") {
+        return context.superTransformStatements(node);
+      }
+      const rewritten = ts15.factory.updateExportDeclaration(node, node.modifiers, node.isTypeOnly, node.exportClause, ts15.factory.createStringLiteral(markerRequirePath(resolution.globalName)), node.attributes);
+      return context.superTransformStatements(rewritten);
+    },
+    [ts15.SyntaxKind.CallExpression]: (node, context) => {
+      const specifier = node.arguments[0];
+      if (node.expression.kind !== ts15.SyntaxKind.ImportKeyword || specifier === undefined) {
+        return context.superTransformExpression(node);
+      }
+      const resolution = resolveGlobalTableTag(specifier, context.checker);
+      if (resolution.kind === "invalid") {
+        context.diagnostics.push(invalidGlobalName(specifier, resolution));
+        return context.superTransformExpression(node);
+      }
+      if (resolution.kind === "untagged") {
+        return context.superTransformExpression(node);
+      }
+      const rewritten = ts15.factory.updateCallExpression(node, node.expression, node.typeArguments, [
+        ts15.factory.createStringLiteral(markerRequirePath(resolution.globalName)),
+        ...node.arguments.slice(1)
+      ]);
+      return context.superTransformExpression(rewritten);
+    }
+  }
+};
+function rewriteGlobalAliasRequires(lua) {
+  let out = "";
+  let cursor = 0;
+  for (const site of scanEmittedRequires(lua)) {
+    if (!site.path.startsWith(GLOBAL_TABLE_REQUIRE_MARKER)) {
+      continue;
+    }
+    if (site.callStart === undefined || site.callEnd === undefined) {
+      continue;
+    }
+    out += lua.slice(cursor, site.callStart);
+    out += `_G.${site.path.slice(GLOBAL_TABLE_REQUIRE_MARKER.length)}`;
+    cursor = site.callEnd;
+  }
+  return out + lua.slice(cursor);
+}
+function findGlobalAliasMarkerLeak(lua) {
+  for (const site of scanEmittedRequires(lua)) {
+    if (site.path.startsWith(GLOBAL_TABLE_REQUIRE_MARKER)) {
+      return site.path.slice(GLOBAL_TABLE_REQUIRE_MARKER.length);
+    }
+  }
+  return;
+}
+
 // src/transpile.ts
 import { readdirSync as readdirSync2, readFileSync } from "node:fs";
 import { createRequire } from "node:module";
@@ -3668,17 +3904,17 @@ import * as path3 from "node:path";
 import * as tstl2 from "typescript-to-lua";
 
 // src/go-property-direct-call.ts
-import * as ts14 from "typescript";
+import * as ts16 from "typescript";
 var GO_PROPERTY_DIRECT_CALL_MESSAGE = "`go.property` called directly is deprecated; declare the property in `defineScript({ properties })` so it types onto `self` (the transpiler emits the registration for you).";
 function findDirectGoPropertyCalls(sourceFile) {
   const calls = [];
   const visit = (node) => {
-    if (ts14.isCallExpression(node) && ts14.isPropertyAccessExpression(node.expression) && node.expression.name.text === "property" && ts14.isIdentifier(node.expression.expression) && node.expression.expression.text === "go") {
+    if (ts16.isCallExpression(node) && ts16.isPropertyAccessExpression(node.expression) && node.expression.name.text === "property" && ts16.isIdentifier(node.expression.expression) && node.expression.expression.text === "go") {
       calls.push(node);
     }
-    ts14.forEachChild(node, visit);
+    ts16.forEachChild(node, visit);
   };
-  ts14.forEachChild(sourceFile, visit);
+  ts16.forEachChild(sourceFile, visit);
   return calls;
 }
 
@@ -3786,6 +4022,7 @@ function collectOutputs(transpiledFiles, diagnostics, userKeys, emittedCompanion
   const lua = {};
   const sourceMaps = {};
   const companions = {};
+  const markerLeaks = [];
   let lualib;
   for (const file of transpiledFiles) {
     if (isLualibBundle(file) && typeof file.lua === "string") {
@@ -3796,13 +4033,23 @@ function collectOutputs(transpiledFiles, diagnostics, userKeys, emittedCompanion
     if (!userSource || typeof file.lua !== "string") {
       continue;
     }
-    lua[userSource.fileName] = file.lua;
+    const swapped = rewriteGlobalAliasRequires(file.lua);
+    lua[userSource.fileName] = swapped;
+    const leaked = findGlobalAliasMarkerLeak(swapped);
+    if (leaked !== undefined) {
+      markerLeaks.push({ file: userSource.fileName, globalName: leaked });
+    }
     if (typeof file.luaSourceMap === "string") {
       sourceMaps[userSource.fileName] = file.luaSourceMap;
     }
     const companion = emittedCompanions.get(userSource.fileName);
     if (companion !== undefined) {
-      companions[userSource.fileName] = companion;
+      const swappedCompanion = rewriteGlobalAliasRequires(companion);
+      companions[userSource.fileName] = swappedCompanion;
+      const companionLeak = findGlobalAliasMarkerLeak(swappedCompanion);
+      if (companionLeak !== undefined) {
+        markerLeaks.push({ file: userSource.fileName, globalName: companionLeak });
+      }
     }
   }
   const collectedDiagnostics = diagnostics.map((d) => {
@@ -3817,6 +4064,12 @@ function collectOutputs(transpiledFiles, diagnostics, userKeys, emittedCompanion
     const { line, character } = d.file.getLineAndCharacterOfPosition(d.start);
     return { file: fileName, message, line: line + 1, column: character + 1 };
   });
+  for (const leak of markerLeaks) {
+    collectedDiagnostics.push({
+      file: leak.file,
+      message: `@globalTable lowering left an unrewritten require for \`${leak.globalName}\` in the emitted chunk; the output would fail to load in Defold.`
+    });
+  }
   const scanned = new Set;
   let timersImported = false;
   for (const file of transpiledFiles) {
@@ -3877,6 +4130,7 @@ function transpileVirtual(files, companionEmit, overrides = {}) {
       { plugin: physicsEventGuardLoweringPlugin },
       { plugin: messageDispatchLoweringPlugin },
       { plugin: timersLoweringPlugin },
+      { plugin: nativeGlobalModulesPlugin },
       { plugin: hsmLoweringPlugin },
       { plugin: typeApplicationErasurePlugin },
       { plugin: companionEmit.plugin }
@@ -3968,6 +4222,7 @@ function compilerOptions(companionEmit) {
       { plugin: physicsEventGuardLoweringPlugin },
       { plugin: messageDispatchLoweringPlugin },
       { plugin: timersLoweringPlugin },
+      { plugin: nativeGlobalModulesPlugin },
       { plugin: hsmLoweringPlugin },
       { plugin: typeApplicationErasurePlugin },
       { plugin: companionEmit.plugin }
@@ -4012,7 +4267,7 @@ function createTranspileSession() {
       if (cached) {
         return cached;
       }
-      const created = ts15.createSourceFile(fileName, content, ts15.ScriptTarget.Latest, false);
+      const created = ts17.createSourceFile(fileName, content, ts17.ScriptTarget.Latest, false);
       sourceFileCache.set(normalized, created);
       return created;
     }
@@ -4031,7 +4286,7 @@ function createTranspileSession() {
         return cached;
       }
       const fileContent = readFileSync2(filePath, "utf8");
-      const created = ts15.createSourceFile(filePath, fileContent, ts15.ScriptTarget.Latest, false);
+      const created = ts17.createSourceFile(filePath, fileContent, ts17.ScriptTarget.Latest, false);
       libCache.set(fileName, created);
       return created;
     }
@@ -4044,10 +4299,10 @@ function createTranspileSession() {
     return AMBIENT_FILES[normalized];
   }
   const host = {
-    fileExists: (fileName) => mergedContent(normalizeSlashes(fileName)) !== undefined || ts15.sys.fileExists(fileName),
+    fileExists: (fileName) => mergedContent(normalizeSlashes(fileName)) !== undefined || ts17.sys.fileExists(fileName),
     getCanonicalFileName: (fileName) => fileName,
     getCurrentDirectory: () => "",
-    getDefaultLibFileName: ts15.getDefaultLibFileName,
+    getDefaultLibFileName: ts17.getDefaultLibFileName,
     readFile: () => "",
     getNewLine: () => `
 `,
@@ -4069,15 +4324,15 @@ function createTranspileSession() {
     const userKeys = new Set(userFiles.keys());
     const rootNames = [...Object.keys(AMBIENT_FILES).map(normalizeSlashes), ...userKeys];
     const companionEmit = createCompanionEmitPlugin();
-    program = ts15.createProgram(rootNames, compilerOptions(companionEmit), host, program);
-    const preEmitDiagnostics = ts15.getPreEmitDiagnostics(program);
+    program = ts17.createProgram(rootNames, compilerOptions(companionEmit), host, program);
+    const preEmitDiagnostics = ts17.getPreEmitDiagnostics(program);
     const collector = createOutputCollector();
     const { diagnostics: transpileDiagnostics } = new tstl3.Transpiler().emit({
       program,
       writeFile: collector.writeFile
     });
     const diagnostics = [
-      ...ts15.sortAndDeduplicateDiagnostics([...preEmitDiagnostics, ...transpileDiagnostics])
+      ...ts17.sortAndDeduplicateDiagnostics([...preEmitDiagnostics, ...transpileDiagnostics])
     ];
     return collectOutputs(collector.files, diagnostics, userKeys, companionEmit.companions);
   }
@@ -4087,7 +4342,7 @@ function createTranspileSession() {
   };
 }
 // src/text-script-property.ts
-import * as ts16 from "typescript";
+import * as ts18 from "typescript";
 function findTextScriptProperties(program, fileNames) {
   const checker = program.getTypeChecker();
   const findings = [];
@@ -4098,7 +4353,7 @@ function findTextScriptProperties(program, fileNames) {
     }
     const located = [];
     const visit = (node) => {
-      if (ts16.isCallExpression(node)) {
+      if (ts18.isCallExpression(node)) {
         const hooks = factoryHooks(node, checker);
         for (const property of hooks?.properties ?? []) {
           if (!isPropertiesHook(property)) {
@@ -4111,7 +4366,7 @@ function findTextScriptProperties(program, fileNames) {
           }
         }
       }
-      ts16.forEachChild(node, visit);
+      ts18.forEachChild(node, visit);
     };
     visit(sourceFile);
     for (const call of findDirectGoPropertyCalls(sourceFile)) {
@@ -4120,7 +4375,7 @@ function findTextScriptProperties(program, fileNames) {
         continue;
       }
       if (mayHoldString(checker.getTypeAtLocation(value), checker)) {
-        const name = ts16.isStringLiteralLike(nameArgument) ? nameArgument.text : nameArgument.getText(sourceFile);
+        const name = ts18.isStringLiteralLike(nameArgument) ? nameArgument.text : nameArgument.getText(sourceFile);
         located.push({ name, value });
       }
     }
@@ -4137,20 +4392,20 @@ function mayHoldString(type, checker, visited = new Set) {
     return false;
   }
   visited.add(type);
-  if (type.flags & ts16.TypeFlags.StringLike) {
+  if (type.flags & ts18.TypeFlags.StringLike) {
     return true;
   }
   if (type.isUnionOrIntersection()) {
     return type.types.some((member) => mayHoldString(member, checker, visited));
   }
-  if (type.flags & ts16.TypeFlags.Instantiable) {
+  if (type.flags & ts18.TypeFlags.Instantiable) {
     const constraint = checker.getBaseConstraintOfType(type);
     return constraint !== undefined && constraint !== type ? mayHoldString(constraint, checker, visited) : false;
   }
   return false;
 }
 // src/url-address-slots.ts
-import * as ts17 from "typescript";
+import * as ts19 from "typescript";
 var ADDRESS_CLASSES = {
   "game-object": true,
   component: true,
@@ -4169,7 +4424,7 @@ function isFragmentCaret(slot, position) {
   return slot.fragmentStart !== -1 && position >= slot.fragmentStart;
 }
 function tableKey(checker, callee) {
-  const symbol = checker.getSymbolAtLocation(ts17.isIdentifier(callee) ? callee : callee.name);
+  const symbol = checker.getSymbolAtLocation(ts19.isIdentifier(callee) ? callee : callee.name);
   if (!symbol)
     return;
   const fqn = checker.getFullyQualifiedName(symbol);
@@ -4177,43 +4432,43 @@ function tableKey(checker, callee) {
 }
 function parameterName(checker, call, index) {
   const declaration = checker.getResolvedSignature(call)?.declaration;
-  if (!declaration || !ts17.isFunctionLike(declaration))
+  if (!declaration || !ts19.isFunctionLike(declaration))
     return;
   const parameter = declaration.parameters[index];
-  if (!parameter || parameter.dotDotDotToken || !ts17.isIdentifier(parameter.name))
+  if (!parameter || parameter.dotDotDotToken || !ts19.isIdentifier(parameter.name))
     return;
   return parameter.name.text;
 }
 var EQUALITY_OPERATORS = new Set([
-  ts17.SyntaxKind.EqualsEqualsEqualsToken,
-  ts17.SyntaxKind.ExclamationEqualsEqualsToken,
-  ts17.SyntaxKind.EqualsEqualsToken,
-  ts17.SyntaxKind.ExclamationEqualsToken
+  ts19.SyntaxKind.EqualsEqualsEqualsToken,
+  ts19.SyntaxKind.ExclamationEqualsEqualsToken,
+  ts19.SyntaxKind.EqualsEqualsToken,
+  ts19.SyntaxKind.ExclamationEqualsToken
 ]);
 function comparisonSatisfied(checker, entry, call) {
   if (entry.comparedParameter === undefined)
     return true;
   let node = call;
-  while (ts17.isParenthesizedExpression(node.parent))
+  while (ts19.isParenthesizedExpression(node.parent))
     node = node.parent;
   const comparison = node.parent;
-  if (!ts17.isBinaryExpression(comparison))
+  if (!ts19.isBinaryExpression(comparison))
     return false;
   if (!EQUALITY_OPERATORS.has(comparison.operatorToken.kind))
     return false;
   const other = comparison.left === node ? comparison.right : comparison.left;
   const symbol = checker.getSymbolAtLocation(other);
-  return (symbol?.declarations ?? []).some((declaration) => ts17.isParameter(declaration) && ts17.isIdentifier(declaration.name) && declaration.name.text === entry.comparedParameter);
+  return (symbol?.declarations ?? []).some((declaration) => ts19.isParameter(declaration) && ts19.isIdentifier(declaration.name) && declaration.name.text === entry.comparedParameter);
 }
 function classifiedEntryOfArgument(checker, table, argument) {
   const call = argument.parent;
-  if (!ts17.isCallExpression(call))
+  if (!ts19.isCallExpression(call))
     return;
   const argumentIndex = call.arguments.indexOf(argument);
   if (argumentIndex === -1)
     return;
   const callee = call.expression;
-  if (!ts17.isPropertyAccessExpression(callee) && !ts17.isIdentifier(callee))
+  if (!ts19.isPropertyAccessExpression(callee) && !ts19.isIdentifier(callee))
     return;
   const fqn = tableKey(checker, callee);
   if (fqn === undefined)
@@ -4230,10 +4485,10 @@ function classifiedEntryOfArgument(checker, table, argument) {
 }
 function slotThroughHashedCall(checker, table, literal) {
   const call = literal.parent;
-  if (!ts17.isCallExpression(call))
+  if (!ts19.isCallExpression(call))
     return;
   const callee = call.expression;
-  if (!ts17.isPropertyAccessExpression(callee) && !ts17.isIdentifier(callee))
+  if (!ts19.isPropertyAccessExpression(callee) && !ts19.isIdentifier(callee))
     return;
   if (tableKey(checker, callee) !== "hash")
     return;
@@ -4251,24 +4506,24 @@ function addressTextOf(checker, entry, call) {
   if (entry.addressParameter === undefined)
     return;
   const declaration = checker.getResolvedSignature(call)?.declaration;
-  if (!declaration || !ts17.isFunctionLike(declaration))
+  if (!declaration || !ts19.isFunctionLike(declaration))
     return;
-  const index = declaration.parameters.findIndex((parameter) => !parameter.dotDotDotToken && ts17.isIdentifier(parameter.name) && parameter.name.text === entry.addressParameter);
+  const index = declaration.parameters.findIndex((parameter) => !parameter.dotDotDotToken && ts19.isIdentifier(parameter.name) && parameter.name.text === entry.addressParameter);
   if (index === -1)
     return;
   const argument = call.arguments[index];
-  return argument && ts17.isStringLiteralLike(argument) ? argument.text : undefined;
+  return argument && ts19.isStringLiteralLike(argument) ? argument.text : undefined;
 }
 function innermostLiteralAt(sourceFile, position) {
   let found;
   const visit = (node) => {
     if (position < node.getStart(sourceFile) || position > node.getEnd())
       return;
-    if (ts17.isStringLiteralLike(node))
+    if (ts19.isStringLiteralLike(node))
       found = node;
-    ts17.forEachChild(node, visit);
+    ts19.forEachChild(node, visit);
   };
-  ts17.forEachChild(sourceFile, visit);
+  ts19.forEachChild(sourceFile, visit);
   return found;
 }
 function resolveClassifiedSlotAtPosition(input) {
@@ -4302,23 +4557,23 @@ function resolveClassifiedSlotAtPosition(input) {
   };
 }
 // src/url-cross-world-address.ts
-import * as ts19 from "typescript";
+import * as ts21 from "typescript";
 
 // src/url-address-literals.ts
-import * as ts18 from "typescript";
+import * as ts20 from "typescript";
 function isAmbient2(fileName) {
   return /[\\/]node_modules[\\/]/.test(fileName) || /(^|[\\/])lib\.[^\\/]*\.d\.ts$/.test(fileName);
 }
 function referenceTargetSymbol(type) {
-  if ((type.flags & ts18.TypeFlags.Object) === 0)
+  if ((type.flags & ts20.TypeFlags.Object) === 0)
     return;
-  if ((type.objectFlags & ts18.ObjectFlags.Reference) === 0)
+  if ((type.objectFlags & ts20.ObjectFlags.Reference) === 0)
     return;
   return type.target.symbol;
 }
 function ambientHashAliasTargets(checker, anchor) {
   const targets = new Set;
-  for (const symbol of checker.getSymbolsInScope(anchor, ts18.SymbolFlags.Type)) {
+  for (const symbol of checker.getSymbolsInScope(anchor, ts20.SymbolFlags.Type)) {
     if (symbol.name !== "Hash")
       continue;
     const target = referenceTargetSymbol(checker.getDeclaredTypeOfSymbol(symbol));
@@ -4334,7 +4589,7 @@ function canonicalHashSymbols(checker, program) {
   if (!anchor)
     return canonical;
   const aliased = ambientHashAliasTargets(checker, anchor);
-  for (const symbol of checker.getSymbolsInScope(anchor, ts18.SymbolFlags.Function)) {
+  for (const symbol of checker.getSymbolsInScope(anchor, ts20.SymbolFlags.Function)) {
     if (symbol.name !== "hash")
       continue;
     const declaration = symbol.declarations?.[0];
@@ -4356,7 +4611,7 @@ function hashedSourceOfType(checker, type, canonical) {
   return source?.isStringLiteral() ? source.value : undefined;
 }
 function staticAddressTextOf(checker, node, canonical) {
-  return ts18.isStringLiteralLike(node) ? node.text : hashedSourceOfType(checker, checker.getTypeAtLocation(node), canonical);
+  return ts20.isStringLiteralLike(node) ? node.text : hashedSourceOfType(checker, checker.getTypeAtLocation(node), canonical);
 }
 
 // src/url-cross-world-address.ts
@@ -4380,7 +4635,7 @@ function checkCrossWorldAddresses(input) {
     if (worlds.length === 0)
       continue;
     const visit = (node) => {
-      if (ts19.isExpression(node)) {
+      if (ts21.isExpression(node)) {
         const entry = addressEntryOfArgument(checker, table, node);
         if (entry !== undefined && slotRejectsForeignSocket(entry)) {
           const address = staticAddressTextOf(checker, node, canonical);
@@ -4397,14 +4652,14 @@ function checkCrossWorldAddresses(input) {
           }
         }
       }
-      ts19.forEachChild(node, visit);
+      ts21.forEachChild(node, visit);
     };
-    ts19.forEachChild(sourceFile, visit);
+    ts21.forEachChild(sourceFile, visit);
   }
   return findings;
 }
 // src/url-fragment-reachability.ts
-import * as ts20 from "typescript";
+import * as ts22 from "typescript";
 function pathOfKey(key) {
   const socket = socketOfAddress(key);
   return socket === undefined ? key : key.slice(socket.length + 1);
@@ -4449,7 +4704,7 @@ function checkUrlFragmentReachability(input) {
     if (isAmbient2(sourceFile.fileName))
       continue;
     const visit = (node) => {
-      if (ts20.isExpression(node) && isAddressClass(addressClassOfArgument(checker, table, node))) {
+      if (ts22.isExpression(node) && isAddressClass(addressClassOfArgument(checker, table, node))) {
         const text = staticAddressTextOf(checker, node, canonical);
         if (text !== undefined) {
           const hash = text.indexOf("#");
@@ -4468,9 +4723,9 @@ function checkUrlFragmentReachability(input) {
           }
         }
       }
-      ts20.forEachChild(node, visit);
+      ts22.forEachChild(node, visit);
     };
-    ts20.forEachChild(sourceFile, visit);
+    ts22.forEachChild(sourceFile, visit);
   }
   return { kind: "checked", findings };
 }
@@ -4478,6 +4733,9 @@ export {
   ANIMATION_ASSET_EXTENSIONS,
   COLLECTION_REFERENCE_EXTENSIONS,
   COMPANION_INTERNAL_FIELD,
+  DEBUG_BLOCK_BEGIN,
+  DEBUG_BLOCK_END,
+  DEBUG_MANAGED_BLOCK,
   DEFAULT_INCLUDE,
   GAME_PROJECT_DOCUMENT,
   GUI_EXTENSIONS,
@@ -4518,6 +4776,7 @@ export {
   displayPathOf,
   findEmittedRequires,
   findMainEntryFactoryImports,
+  findManagedBootstrap,
   findTextScriptProperties,
   getProgramDiagnostics,
   guiScriptResourceOf,