@defold-typescript/transpiler 0.35.0 → 0.36.0

package/dist/index.js

@@ -1,1342 +1,1963 @@
-// src/scene-text-format.ts
-class SceneTextFormatError extends Error {
-  line;
-  constructor(message, line) {
-    super(`${message} (line ${line})`);
-    this.name = "SceneTextFormatError";
-    this.line = line;
+// src/companion-closure.ts
+import * as ts3 from "typescript";
+
+// src/lifecycle-erasure.ts
+import * as ts2 from "typescript";
+import {
+  createAssignmentStatement,
+  createBinaryExpression as createBinaryExpression2,
+  createBlock as createBlock2,
+  createCallExpression as createCallExpression2,
+  createExpressionStatement,
+  createForInStatement,
+  createFunctionExpression as createFunctionExpression2,
+  createIdentifier as createIdentifier2,
+  createIfStatement as createIfStatement2,
+  createNilLiteral,
+  createReturnStatement,
+  createStringLiteral as createStringLiteral2,
+  createTableIndexExpression,
+  createVariableDeclarationStatement as createVariableDeclarationStatement2,
+  NodeFlags as NodeFlags2,
+  SyntaxKind as SyntaxKind4
+} from "typescript-to-lua";
+
+// src/message-dispatch-lowering.ts
+import * as ts from "typescript";
+import {
+  createBinaryExpression,
+  createBlock,
+  createCallExpression,
+  createFunctionExpression,
+  createIdentifier,
+  createIfStatement,
+  createStringLiteral,
+  createVariableDeclarationStatement,
+  NodeFlags,
+  SyntaxKind as SyntaxKind2
+} from "typescript-to-lua";
+var DISPATCH_MODULE = "@defold-typescript/types";
+var DISPATCH_NAME = "onMessage";
+var HANDLER_PARAM_TARGETS = ["self", "message", "sender"];
+function resolvesToDispatchExport(callee, checker) {
+  let symbol = checker.getSymbolAtLocation(callee);
+  if (symbol === undefined) {
+    return false;
   }
-}
-var IDENTIFIER_PART = /[A-Za-z0-9_]/;
-function append(target, key, value) {
-  const existing = target.get(key);
-  if (existing === undefined) {
-    target.set(key, [value]);
-    return;
+  if (symbol.flags & ts.SymbolFlags.Alias) {
+    symbol = checker.getAliasedSymbol(symbol);
   }
-  existing.push(value);
+  if (symbol.getName() !== DISPATCH_NAME) {
+    return false;
+  }
+  const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
+  if (declaration === undefined) {
+    return false;
+  }
+  return declaration.getSourceFile().fileName.includes(DISPATCH_MODULE);
 }
-function parseSceneTextFormat(text) {
-  let pos = 0;
-  let line = 1;
-  function fail(message, at) {
-    throw new SceneTextFormatError(message, at);
+function handlerName(property) {
+  const name = property.name;
+  if (name === undefined) {
+    return;
   }
-  function advance() {
-    const ch = text.charAt(pos);
-    pos += 1;
-    if (ch === `
-`)
-      line += 1;
-    return ch;
+  if (ts.isIdentifier(name) || ts.isStringLiteral(name)) {
+    return name.text;
   }
-  function skipWhitespace() {
-    while (pos < text.length) {
-      const ch = text.charAt(pos);
-      if (ch !== " " && ch !== "\t" && ch !== "\r" && ch !== `
-`)
-        return;
-      advance();
-    }
+  return;
+}
+function handlerFunction(property) {
+  if (ts.isMethodDeclaration(property) && property.body !== undefined) {
+    return property;
   }
-  function skipInlineWhitespace() {
-    while (pos < text.length) {
-      const ch = text.charAt(pos);
-      if (ch !== " " && ch !== "\t")
-        return;
-      pos += 1;
+  if (ts.isPropertyAssignment(property)) {
+    const initializer = property.initializer;
+    if (ts.isFunctionExpression(initializer) || ts.isArrowFunction(initializer)) {
+      return initializer;
     }
   }
-  function readIdentifier(at) {
-    const start = pos;
-    while (pos < text.length && IDENTIFIER_PART.test(text.charAt(pos))) {
-      pos += 1;
+  return;
+}
+function isThisParameter(param) {
+  return ts.isIdentifier(param.name) && ts.identifierToKeywordKind(param.name) === ts.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)) {
+      return;
     }
-    if (pos === start) {
-      fail(`unexpected \`${text.charAt(start)}\``, at);
+    if (param.name.text !== engineName) {
+      aliases.push(createVariableDeclarationStatement(createIdentifier(param.name.text), createIdentifier(engineName)));
     }
-    return text.slice(start, pos);
+  });
+  return aliases;
+}
+function handlerBody(fn, context) {
+  if (ts.isBlock(fn.body)) {
+    return context.transformStatements(fn.body.statements);
   }
-  function readQuotedScalar() {
-    let value = "";
-    for (;; ) {
-      const openedAt = line;
-      advance();
-      let closed = false;
-      while (pos < text.length) {
-        const ch = advance();
-        if (ch === "\\") {
-          if (pos >= text.length)
-            break;
-          const escaped = advance();
-          if (escaped === '"')
-            value += '"';
-          else if (escaped === "\\")
-            value += "\\";
-          else if (escaped === "n")
-            value += `
-`;
-          else if (escaped === "r")
-            value += "\r";
-          else if (escaped === "t")
-            value += "\t";
-          else
-            value += `\\${escaped}`;
-          continue;
-        }
-        if (ch === '"') {
-          closed = true;
-          break;
+  return context.transformStatements([ts.factory.createExpressionStatement(fn.body)]);
+}
+var messageDispatchLoweringPlugin = {
+  visitors: {
+    [ts.SyntaxKind.CallExpression]: (node, context) => {
+      const [handlersArg] = node.arguments;
+      if (node.arguments.length === 1 && handlersArg !== undefined && ts.isObjectLiteralExpression(handlersArg) && resolvesToDispatchExport(node.expression, context.checker)) {
+        let chain;
+        const properties = [...handlersArg.properties];
+        for (let i = properties.length - 1;i >= 0; i--) {
+          const property = properties[i];
+          if (property === undefined) {
+            continue;
+          }
+          const name = handlerName(property);
+          const fn = handlerFunction(property);
+          if (name === undefined || fn === undefined) {
+            continue;
+          }
+          const condition = createBinaryExpression(createIdentifier("message_id"), createCallExpression(createIdentifier("hash"), [createStringLiteral(name)]), SyntaxKind2.EqualityOperator);
+          const body = [...aliasStatements(fn), ...handlerBody(fn, context)];
+          chain = createIfStatement(condition, createBlock(body), chain);
         }
-        if (ch === `
-`)
-          break;
-        value += ch;
-      }
-      if (!closed) {
-        fail("unterminated string literal", openedAt);
-      }
-      const resumePos = pos;
-      const resumeLine = line;
-      skipWhitespace();
-      if (text.charAt(pos) === '"') {
-        continue;
+        const params = [
+          createIdentifier("self"),
+          createIdentifier("message_id"),
+          createIdentifier("message"),
+          createIdentifier("sender")
+        ];
+        return createFunctionExpression(createBlock(chain === undefined ? [] : [chain]), params, undefined, NodeFlags.Declaration, node);
       }
-      pos = resumePos;
-      line = resumeLine;
-      return value;
+      return context.superTransformExpression(node);
     }
   }
-  function readUnquotedScalar() {
-    const newline = text.indexOf(`
-`, pos);
-    const end = newline === -1 ? text.length : newline;
-    const raw = text.slice(pos, end);
-    pos = end;
-    return raw.trim();
+};
+
+// src/lifecycle-erasure.ts
+var FACTORY_MODULE = "@defold-typescript/types";
+var FACTORY_NAMES = new Set(["defineScript", "defineGuiScript", "defineRenderScript"]);
+var FACTORY_SPECIFIERS = new Set([
+  FACTORY_MODULE,
+  `${FACTORY_MODULE}/script`,
+  `${FACTORY_MODULE}/gui-script`,
+  `${FACTORY_MODULE}/render-script`
+]);
+function resolvesToFactoryExport(callee, checker) {
+  let symbol = checker.getSymbolAtLocation(callee);
+  if (symbol === undefined) {
+    return false;
   }
-  function parseBody(nested, openedAt) {
-    const fields = new Map;
-    const messages = new Map;
-    for (;; ) {
-      skipWhitespace();
-      if (pos >= text.length) {
-        if (nested) {
-          fail("unclosed `{`", openedAt);
-        }
-        break;
-      }
-      if (text.charAt(pos) === "}") {
-        if (!nested) {
-          fail("unexpected `}`", line);
-        }
-        advance();
-        break;
-      }
-      const keyLine = line;
-      const key = readIdentifier(keyLine);
-      skipInlineWhitespace();
-      const delimiter = text.charAt(pos);
-      if (delimiter === "{") {
-        const braceLine = line;
-        advance();
-        append(messages, key, parseBody(true, braceLine));
-        continue;
-      }
-      if (delimiter === ":") {
-        advance();
-        skipInlineWhitespace();
-        append(fields, key, text.charAt(pos) === '"' ? readQuotedScalar() : readUnquotedScalar());
-        continue;
-      }
-      fail(`expected \`:\` or \`{\` after \`${key}\``, keyLine);
+  if (symbol.flags & ts2.SymbolFlags.Alias) {
+    symbol = checker.getAliasedSymbol(symbol);
+  }
+  if (!FACTORY_NAMES.has(symbol.getName())) {
+    return false;
+  }
+  const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
+  if (declaration === undefined) {
+    return false;
+  }
+  return declaration.getSourceFile().fileName.includes(FACTORY_MODULE);
+}
+function isThisParameter2(param) {
+  return ts2.isIdentifier(param.name) && ts2.identifierToKeywordKind(param.name) === ts2.SyntaxKind.ThisKeyword;
+}
+function hookName(property) {
+  const name = property.name;
+  if (name === undefined) {
+    return;
+  }
+  if (ts2.isIdentifier(name) || ts2.isStringLiteral(name)) {
+    return name.text;
+  }
+  return;
+}
+function hookFunction(property) {
+  if (ts2.isMethodDeclaration(property) && property.body !== undefined) {
+    return property;
+  }
+  if (ts2.isPropertyAssignment(property)) {
+    const initializer = property.initializer;
+    if (ts2.isFunctionExpression(initializer) || ts2.isArrowFunction(initializer)) {
+      return initializer;
     }
-    return { fields, messages };
   }
-  return parseBody(false, 1);
+  return;
 }
-
-// src/animation-sources.ts
-function resourceKey(resource) {
-  return resource.startsWith("/") ? resource.slice(1) : resource;
+function dispatcherInitializer(property, checker) {
+  if (!ts2.isPropertyAssignment(property)) {
+    return;
+  }
+  const initializer = property.initializer;
+  if (!ts2.isCallExpression(initializer)) {
+    return;
+  }
+  return resolvesToDispatchExport(initializer.expression, checker) ? initializer : undefined;
 }
-function normalizeDocumentKey(path) {
-  return path.replaceAll("\\", "/");
+function transformHookBody(fn, context) {
+  if (ts2.isBlock(fn.body)) {
+    return context.transformStatements(fn.body.statements);
+  }
+  return [createExpressionStatement(context.transformExpression(fn.body))];
 }
-var SPRITE_SUFFIX = ".sprite";
-var MODEL_SUFFIX = ".model";
-var ANIMATION_SET_SUFFIX = ".animationset";
-var HOP_ONLY_SUFFIXES = [SPRITE_SUFFIX, MODEL_SUFFIX, ANIMATION_SET_SUFFIX];
-function childrenOf(message, name) {
-  return message.messages.get(name) ?? [];
+function crossesFunctionBoundary(node) {
+  return ts2.isFunctionDeclaration(node) || ts2.isFunctionExpression(node) || ts2.isArrowFunction(node) || ts2.isMethodDeclaration(node) || ts2.isGetAccessorDeclaration(node) || ts2.isSetAccessorDeclaration(node);
 }
-function declaredAnimations(document) {
-  const ids = new Set;
-  for (const animation of childrenOf(document, "animations")) {
-    for (const id of animation.fields.get("id") ?? []) {
-      if (id !== "")
-        ids.add(id);
+function initReturnsValue(fn) {
+  if (!ts2.isBlock(fn.body)) {
+    return true;
+  }
+  let found = false;
+  const visit = (node) => {
+    if (found || crossesFunctionBoundary(node)) {
+      return;
+    }
+    if (ts2.isReturnStatement(node) && node.expression !== undefined) {
+      found = true;
+      return;
     }
+    ts2.forEachChild(node, visit);
+  };
+  ts2.forEachChild(fn.body, visit);
+  return found;
+}
+function initBuilderBody(fn, context) {
+  if (ts2.isBlock(fn.body)) {
+    return context.transformStatements(fn.body.statements);
   }
-  return ids;
+  return [createReturnStatement([context.transformExpression(fn.body)])];
 }
-function readAnimationSources(assets, unresolved) {
-  const animationsByTileSet = new Map;
-  for (const [path, text] of assets) {
-    const displayPath = normalizeDocumentKey(path);
-    if (HOP_ONLY_SUFFIXES.some((suffix) => displayPath.endsWith(suffix)))
+function emitInitMerge(fn, context, property) {
+  const authorParam = fn.parameters.find((param) => !isThisParameter2(param) && ts2.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);
+  const builderArgs = authorParam === undefined ? [] : [createIdentifier2("self")];
+  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 initFn = createFunctionExpression2(createBlock2([stateDecl, guard]), [createIdentifier2("self")], undefined, NodeFlags2.Declaration, fn);
+  return [builderDecl, createAssignmentStatement(createIdentifier2("init"), initFn, property)];
+}
+function emitPropertyRegistrations(property, context) {
+  if (!ts2.isPropertyAssignment(property) || !ts2.isObjectLiteralExpression(property.initializer)) {
+    return [];
+  }
+  const registrations = [];
+  for (const member of property.initializer.properties) {
+    if (!ts2.isPropertyAssignment(member)) {
       continue;
-    let document;
-    try {
-      document = parseSceneTextFormat(text);
-    } catch (error) {
-      if (!(error instanceof SceneTextFormatError))
-        throw error;
-      unresolved.push(`${displayPath}: could not be parsed (${error.message})`);
+    }
+    const key = member.name;
+    if (!ts2.isIdentifier(key) && !ts2.isStringLiteral(key)) {
       continue;
     }
-    animationsByTileSet.set(displayPath, declaredAnimations(document));
+    registrations.push(createExpressionStatement(createCallExpression2(createTableIndexExpression(createIdentifier2("go"), createStringLiteral2("property")), [createStringLiteral2(key.text), context.transformExpression(member.initializer)])));
   }
-  return animationsByTileSet;
+  return registrations;
 }
-function animationSetEntries(document) {
-  const entries = [];
-  for (const entry of childrenOf(document, "animations")) {
-    for (const animation of entry.fields.get("animation") ?? []) {
-      if (animation !== "")
-        entries.push(animation);
-    }
+function eraseFactoryCall(expression, context) {
+  if (!ts2.isCallExpression(expression)) {
+    return;
   }
-  return entries;
-}
-
-// src/component-animation-index.ts
-var SCRIPT_SUFFIX = ".script";
-var SPRITE_SUFFIX2 = ".sprite";
-var MODEL_SUFFIX2 = ".model";
-var ANIMATION_SET_SUFFIX2 = ".animationset";
-var MESH_SUFFIXES = [".gltf", ".glb"];
-function firstField(message, name) {
-  return (message.fields.get(name) ?? [])[0];
-}
-function childrenOf2(message, name) {
-  return message.messages.get(name) ?? [];
-}
-function basename(resource) {
-  const file = resource.slice(resource.lastIndexOf("/") + 1);
-  const dot = file.lastIndexOf(".");
-  return dot === -1 ? file : file.slice(0, dot);
-}
-function readAssets(assets, unresolved) {
-  const animationsByTileSet = readAnimationSources(assets, unresolved);
-  const tileSetBySprite = new Map;
-  const modelDocuments = new Set;
-  const animationSourceByModel = new Map;
-  const entriesByAnimationSet = new Map;
-  for (const [path, text] of assets) {
-    const displayPath = normalizeDocumentKey(path);
-    const isSprite = displayPath.endsWith(SPRITE_SUFFIX2);
-    const isModel = displayPath.endsWith(MODEL_SUFFIX2);
-    const isAnimationSet = displayPath.endsWith(ANIMATION_SET_SUFFIX2);
-    if (!isSprite && !isModel && !isAnimationSet)
+  if (!resolvesToFactoryExport(expression.expression, context.checker)) {
+    return;
+  }
+  const hooks = expression.arguments[0];
+  if (hooks === undefined || !ts2.isObjectLiteralExpression(hooks)) {
+    return;
+  }
+  const registrations = [];
+  const statements = [];
+  for (const property of hooks.properties) {
+    const name = hookName(property);
+    if (name === undefined) {
       continue;
-    let document;
-    try {
-      document = parseSceneTextFormat(text);
-    } catch (error) {
-      if (!(error instanceof SceneTextFormatError))
-        throw error;
-      unresolved.push(`${displayPath}: could not be parsed (${error.message})`);
+    }
+    if (name === "properties") {
+      registrations.push(...emitPropertyRegistrations(property, context));
       continue;
     }
-    if (isSprite) {
-      const tileSet = firstField(document, "tile_set");
-      if (tileSet !== undefined)
-        tileSetBySprite.set(displayPath, resourceKey(tileSet));
+    const fn = hookFunction(property);
+    if (fn === undefined) {
+      const dispatch = dispatcherInitializer(property, context.checker);
+      if (dispatch !== undefined) {
+        statements.push(createAssignmentStatement(createIdentifier2(name), context.transformExpression(dispatch), property));
+      }
       continue;
     }
-    if (isModel) {
-      modelDocuments.add(displayPath);
-      const animations = firstField(document, "animations");
-      if (animations !== undefined)
-        animationSourceByModel.set(displayPath, animations);
+    if (name === "init" && initReturnsValue(fn)) {
+      statements.push(...emitInitMerge(fn, context, property));
       continue;
     }
-    entriesByAnimationSet.set(displayPath, animationSetEntries(document));
+    const params = fn.parameters.filter((param) => !isThisParameter2(param) && ts2.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 {
-    animationsByTileSet,
-    tileSetBySprite,
-    modelDocuments,
-    animationSourceByModel,
-    entriesByAnimationSet
-  };
+  return [...registrations, ...statements];
 }
-function resolveAnimationSet(input) {
-  const { path, prefix, stack, assets, unresolved } = input;
-  const entries = assets.entriesByAnimationSet.get(path);
-  if (entries === undefined)
-    return;
-  stack.add(path);
-  try {
-    const ids = new Map;
-    for (const entry of entries) {
-      const key = resourceKey(entry);
-      if (MESH_SUFFIXES.some((suffix) => key.endsWith(suffix))) {
-        ids.set(prefix + basename(key), path);
-        continue;
-      }
-      if (!key.endsWith(ANIMATION_SET_SUFFIX2)) {
-        unresolved.push(`${path}: the entry ${entry} is not a .gltf, .glb or .animationset, so it declares no animation id`);
-        continue;
-      }
-      if (!assets.entriesByAnimationSet.has(key)) {
-        unresolved.push(`${path}: the entry ${entry} is not among the project's animation set documents`);
-        return;
-      }
-      if (stack.has(key)) {
-        unresolved.push(`${path}: the entry ${entry} re-enters an animation set already being read, so the chain is cyclic`);
-        return;
+function isFactoryOnlyImport(node) {
+  if (!ts2.isStringLiteral(node.moduleSpecifier) || !FACTORY_SPECIFIERS.has(node.moduleSpecifier.text)) {
+    return false;
+  }
+  const clause = node.importClause;
+  if (clause === undefined || clause.name !== undefined) {
+    return false;
+  }
+  if (clause.isTypeOnly) {
+    return false;
+  }
+  const bindings = clause.namedBindings;
+  if (bindings === undefined || !ts2.isNamedImports(bindings)) {
+    return false;
+  }
+  const runtime = bindings.elements.filter((element) => !element.isTypeOnly);
+  if (runtime.length === 0) {
+    return false;
+  }
+  return runtime.every((element) => FACTORY_NAMES.has((element.propertyName ?? element.name).text));
+}
+var lifecycleErasurePlugin = {
+  visitors: {
+    [ts2.SyntaxKind.ExpressionStatement]: (node, context) => eraseFactoryCall(node.expression, context) ?? context.superTransformStatements(node),
+    [ts2.SyntaxKind.ExportAssignment]: (node, context) => {
+      if (!node.isExportEquals) {
+        const erased = eraseFactoryCall(node.expression, context);
+        if (erased !== undefined) {
+          return erased;
+        }
       }
-      const nested = resolveAnimationSet({
-        path: key,
-        prefix: `${prefix + basename(key)}/`,
-        stack,
-        assets,
-        unresolved
-      });
-      if (nested === undefined)
-        return;
-      for (const [id, declaring] of nested)
-        if (!ids.has(id))
-          ids.set(id, declaring);
-    }
-    return ids;
-  } finally {
-    stack.delete(path);
+      return context.superTransformStatements(node);
+    },
+    [ts2.SyntaxKind.ImportDeclaration]: (node, context) => isFactoryOnlyImport(node) ? [] : context.superTransformStatements(node)
   }
+};
+
+// src/companion-closure.ts
+var COMPANION_INTERNAL_FIELD = "____closure";
+function isAssignmentOperator(kind) {
+  return kind >= ts3.SyntaxKind.FirstAssignment && kind <= ts3.SyntaxKind.LastAssignment;
 }
-function componentAnimationSources(object, displayPath, assets, unresolved) {
-  const sources = new Map;
-  function claimModel(id, animations) {
-    if (!animations.endsWith(ANIMATION_SET_SUFFIX2)) {
-      unresolved.push(`${displayPath}: the model component "${id}" names ${animations} rather than an animation set, so none of its animation ids are established`);
-      return;
+function isTypePosition(node) {
+  let current = node.parent;
+  while (current !== undefined && !ts3.isSourceFile(current)) {
+    if (ts3.isTypeNode(current)) {
+      return true;
     }
-    sources.set(id, { kind: "model", path: resourceKey(animations) });
+    current = current.parent;
   }
-  for (const embedded of childrenOf2(object, "embedded_components")) {
-    const type = firstField(embedded, "type");
-    if (type !== "sprite" && type !== "model")
-      continue;
-    const id = firstField(embedded, "id");
-    const payload = firstField(embedded, "data");
-    if (id === undefined || payload === undefined)
-      continue;
-    let document;
-    try {
-      document = parseSceneTextFormat(payload);
-    } catch (error) {
-      if (!(error instanceof SceneTextFormatError))
-        throw error;
-      unresolved.push(`${displayPath}: the embedded ${type} "${id}" could not be read (${error.message})`);
-      continue;
-    }
-    if (type === "sprite") {
-      const tileSet = firstField(document, "tile_set");
-      if (tileSet !== undefined)
-        sources.set(id, { kind: "sprite", path: resourceKey(tileSet) });
-      continue;
-    }
-    const animations = firstField(document, "animations");
-    if (animations !== undefined)
-      claimModel(id, animations);
+  return false;
+}
+function isDeclarationName(node) {
+  const parent = node.parent;
+  if (parent === undefined) {
+    return false;
   }
-  for (const referenced of childrenOf2(object, "components")) {
-    const component = firstField(referenced, "component");
-    const id = firstField(referenced, "id");
-    if (id === undefined || component === undefined)
-      continue;
-    if (component.endsWith(SPRITE_SUFFIX2)) {
-      const tileSet = assets.tileSetBySprite.get(resourceKey(component));
-      if (tileSet === undefined) {
-        unresolved.push(`${displayPath}: the sprite component "${id}" names ${component}, which is not among the project's sprite documents`);
-        continue;
+  if (ts3.isPropertyAccessExpression(parent)) {
+    return parent.name === node;
+  }
+  if (ts3.isQualifiedName(parent)) {
+    return parent.right === node;
+  }
+  if ((ts3.isBindingElement(parent) || ts3.isImportSpecifier(parent) || ts3.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);
+}
+function forEachReference(root, checker, visit) {
+  const walk = (node) => {
+    if (ts3.isIdentifier(node) && !isDeclarationName(node) && !isTypePosition(node)) {
+      const symbol = resolveReferencedSymbol(node, checker);
+      if (symbol !== undefined) {
+        visit(node, symbol);
       }
-      sources.set(id, { kind: "sprite", path: tileSet });
-      continue;
     }
-    if (!component.endsWith(MODEL_SUFFIX2))
-      continue;
-    const resource = resourceKey(component);
-    if (!assets.modelDocuments.has(resource)) {
-      unresolved.push(`${displayPath}: the model component "${id}" names ${component}, which is not among the project's model documents`);
-      continue;
-    }
-    const animations = assets.animationSourceByModel.get(resource);
-    if (animations !== undefined)
-      claimModel(id, animations);
-  }
-  return sources;
+    ts3.forEachChild(node, walk);
+  };
+  walk(root);
 }
-function scriptResourcesOf(object) {
-  const resources = [];
-  for (const component of childrenOf2(object, "components")) {
-    const resource = firstField(component, "component");
-    if (resource === undefined || !resource.endsWith(SCRIPT_SUFFIX))
-      continue;
-    const key = resourceKey(resource);
-    if (key !== SCRIPT_SUFFIX.slice(1))
-      resources.push(key);
+function resolveReferencedSymbol(node, checker) {
+  const parent = node.parent;
+  if (parent !== undefined && ts3.isShorthandPropertyAssignment(parent) && parent.name === node) {
+    return checker.getShorthandAssignmentValueSymbol(parent) ?? checker.getSymbolAtLocation(node);
   }
-  return resources;
-}
-function isGameObject(message) {
-  return message.messages.has("components") || message.messages.has("embedded_components");
+  return checker.getSymbolAtLocation(node);
 }
-function buildComponentAnimationIndex(input) {
-  const unresolved = [];
-  const assets = readAssets(input.assets, unresolved);
-  const byScriptResource = new Map;
-  const sourceByScriptResource = new Map;
-  const claimedBy = new Map;
-  function walk(message, blockName, displayPath) {
-    if (isGameObject(message)) {
-      claim(message, displayPath);
+function forEachAssignmentTarget(root, checker, visit) {
+  const classify = (target) => {
+    if (ts3.isParenthesizedExpression(target)) {
+      classify(target.expression);
+      return;
     }
-    if (blockName === "embedded_instances") {
-      for (const payload of message.fields.get("data") ?? []) {
-        try {
-          walk(parseSceneTextFormat(payload), "", displayPath);
-        } catch (error) {
-          if (!(error instanceof SceneTextFormatError))
-            throw error;
-          unresolved.push(`${displayPath}: an embedded game object could not be read (${error.message})`);
+    if (ts3.isPropertyAccessExpression(target) || ts3.isElementAccessExpression(target)) {
+      return;
+    }
+    if (ts3.isArrayLiteralExpression(target)) {
+      for (const element of target.elements) {
+        if (ts3.isOmittedExpression(element)) {
+          continue;
+        }
+        if (ts3.isSpreadElement(element)) {
+          classify(element.expression);
+        } else if (ts3.isBinaryExpression(element) && element.operatorToken.kind === ts3.SyntaxKind.EqualsToken) {
+          classify(element.left);
+        } else {
+          classify(element);
         }
       }
+      return;
     }
-    for (const [name, nested] of message.messages) {
-      for (const child of nested) {
-        walk(child, name, displayPath);
+    if (ts3.isObjectLiteralExpression(target)) {
+      for (const property of target.properties) {
+        if (ts3.isPropertyAssignment(property)) {
+          classify(property.initializer);
+        } else if (ts3.isSpreadAssignment(property)) {
+          classify(property.expression);
+        } else if (ts3.isShorthandPropertyAssignment(property)) {
+          const symbol = checker.getShorthandAssignmentValueSymbol(property);
+          if (symbol !== undefined) {
+            visit(property.name, symbol);
+          }
+        }
       }
+      return;
     }
-  }
-  function idsOf(id, source, displayPath) {
-    if (source.kind === "sprite") {
-      const declared = assets.animationsByTileSet.get(source.path);
-      if (declared !== undefined)
-        return new Map([...declared].map((name) => [name, source.path]));
-      unresolved.push(`${displayPath}: the sprite component "${id}" names the tile source /${source.path}, which is not among the project's asset documents`);
+    if (ts3.isIdentifier(target)) {
+      const symbol = checker.getSymbolAtLocation(target);
+      if (symbol !== undefined) {
+        visit(target, symbol);
+      }
+    }
+  };
+  const walk = (node) => {
+    if (ts3.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)) {
+      classify(node.operand);
+    } else if ((ts3.isForInStatement(node) || ts3.isForOfStatement(node)) && !ts3.isVariableDeclarationList(node.initializer)) {
+      classify(node.initializer);
+    }
+    ts3.forEachChild(node, walk);
+  };
+  walk(root);
+}
+function collectTopLevel(sourceFile, checker) {
+  const declarations = new Map;
+  let order = 0;
+  const add = (name, statement, node) => {
+    if (name === undefined || !ts3.isIdentifier(name)) {
       return;
     }
-    const resolved = resolveAnimationSet({
-      path: source.path,
-      prefix: "",
-      stack: new Set,
-      assets,
-      unresolved
-    });
-    if (resolved !== undefined)
-      return resolved;
-    if (!assets.entriesByAnimationSet.has(source.path)) {
-      unresolved.push(`${displayPath}: the model component "${id}" names the animation set /${source.path}, which is not among the project's asset documents`);
+    const symbol = checker.getSymbolAtLocation(name);
+    if (symbol === undefined || declarations.has(symbol)) {
+      return;
     }
-    return;
-  }
-  function claim(object, displayPath) {
-    const scripts = scriptResourcesOf(object);
-    if (scripts.length === 0)
+    declarations.set(symbol, { name: name.text, statement, node, order: order++ });
+  };
+  const addBinding = (name, statement, node) => {
+    if (ts3.isIdentifier(name)) {
+      add(name, statement, node);
       return;
-    const sources = componentAnimationSources(object, displayPath, assets, unresolved);
-    const animations = new Map;
-    const declaringSources = new Map;
-    for (const [id, source] of sources) {
-      const resolved = idsOf(id, source, displayPath);
-      if (resolved === undefined)
-        continue;
-      animations.set(id, new Set(resolved.keys()));
-      declaringSources.set(id, resolved);
     }
-    for (const key of scripts) {
-      const owner = claimedBy.get(key);
-      if (owner !== undefined) {
-        byScriptResource.delete(key);
-        sourceByScriptResource.delete(key);
-        unresolved.push(`${key}: claimed by both ${owner} and ${displayPath}, so its component animations are ambiguous`);
-        continue;
+    for (const element of name.elements) {
+      if (ts3.isBindingElement(element)) {
+        addBinding(element.name, statement, node);
       }
-      claimedBy.set(key, displayPath);
-      byScriptResource.set(key, animations);
-      sourceByScriptResource.set(key, declaringSources);
     }
-  }
-  for (const [path, text] of input.scenes) {
-    const displayPath = normalizeDocumentKey(path);
-    try {
-      walk(parseSceneTextFormat(text), "", displayPath);
-    } catch (error) {
-      if (!(error instanceof SceneTextFormatError))
-        throw error;
-      unresolved.push(`${displayPath}: could not be parsed (${error.message})`);
+  };
+  for (const statement of sourceFile.statements) {
+    if (ts3.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)) {
+      add(statement.name, statement, statement);
+    } else if (ts3.isImportDeclaration(statement)) {
+      const clause = statement.importClause;
+      if (clause === undefined) {
+        continue;
+      }
+      add(clause.name, statement, statement);
+      const bindings = clause.namedBindings;
+      if (bindings === undefined) {
+        continue;
+      }
+      if (ts3.isNamespaceImport(bindings)) {
+        add(bindings.name, statement, statement);
+      } else {
+        for (const element of bindings.elements) {
+          add(element.name, statement, statement);
+        }
+      }
     }
   }
-  return { byScriptResource, sourceByScriptResource, unresolved };
+  return declarations;
 }
-function componentIdOfSameObjectAddress(address) {
-  if (!address.startsWith("#"))
-    return;
-  const id = address.slice(1);
-  if (id === "" || id.includes("/") || id.includes("#"))
-    return;
-  return id;
+function hasExportModifier(statement) {
+  return ts3.canHaveModifiers(statement) && (ts3.getModifiers(statement) ?? []).some((modifier) => modifier.kind === ts3.SyntaxKind.ExportKeyword);
 }
-// src/config-key-index.ts
-function sectionNameOf(line) {
-  const match = line.trim().match(/^\[(.+)\]$/);
-  return match?.[1];
+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;
 }
-function buildConfigKeyIndex(gameProjectText) {
-  const keys = new Set;
-  let section;
-  for (const line of gameProjectText.split(`
-`)) {
-    const header = sectionNameOf(line);
-    if (header !== undefined) {
-      section = header;
-      continue;
+function collectExports(sourceFile, checker, topLevel) {
+  const exported = [];
+  const seen = new Set;
+  const take = (symbol, name, nameNode) => {
+    const declaration = symbol && topLevel.get(symbol);
+    if (symbol === undefined || declaration === undefined) {
+      return;
     }
-    if (section === undefined)
-      continue;
-    const separator = line.indexOf("=");
-    if (separator === -1)
+    if (!isValueSymbol(symbol, checker)) {
+      return;
+    }
+    const key = `${declaration.order}\x00${name}`;
+    if (seen.has(key)) {
+      return;
+    }
+    seen.add(key);
+    exported.push({ symbol, name, nameNode });
+  };
+  const takeLocal = (symbol, name) => {
+    const declaration = symbol && topLevel.get(symbol);
+    if (declaration === undefined) {
+      return;
+    }
+    take(symbol, name.text, declaration.node);
+  };
+  for (const statement of sourceFile.statements) {
+    if (ts3.isExportDeclaration(statement)) {
+      if (statement.moduleSpecifier !== undefined || statement.isTypeOnly) {
+        continue;
+      }
+      const clause = statement.exportClause;
+      if (clause === undefined || !ts3.isNamedExports(clause)) {
+        continue;
+      }
+      for (const element of clause.elements) {
+        if (element.isTypeOnly) {
+          continue;
+        }
+        take(checker.getExportSpecifierLocalTargetSymbol(element), element.name.text, element.name);
+      }
       continue;
-    const key = line.slice(0, separator).trim();
-    if (key === "")
+    }
+    if (!hasExportModifier(statement)) {
       continue;
-    keys.add(`${section}.${key}`);
+    }
+    if (ts3.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)) {
+      if (statement.name !== undefined) {
+        takeLocal(checker.getSymbolAtLocation(statement.name), statement.name);
+      }
+    }
   }
-  return keys;
+  return exported;
 }
-function readGameProjectSetting(gameProjectText, section, key) {
-  let current;
-  for (const line of gameProjectText.split(`
-`)) {
-    const header = sectionNameOf(line);
-    if (header !== undefined) {
-      current = header;
-      continue;
+function forEachDeclaredName(name, visit) {
+  if (ts3.isIdentifier(name)) {
+    visit(name);
+    return;
+  }
+  for (const element of name.elements) {
+    if (ts3.isBindingElement(element)) {
+      forEachDeclaredName(element.name, visit);
     }
-    if (current !== section)
-      continue;
-    const separator = line.indexOf("=");
-    if (separator === -1)
-      continue;
-    if (line.slice(0, separator).trim() !== key)
-      continue;
-    const value = line.slice(separator + 1).trim();
-    if (value !== "")
-      return value;
   }
-  return;
 }
-// src/gui-flipbook-index.ts
-var SCRIPT_SUFFIX2 = ".gui_script";
-function scriptKeyOf(script) {
-  if (!script.endsWith(SCRIPT_SUFFIX2))
-    return;
-  const key = resourceKey(script);
-  return key === SCRIPT_SUFFIX2 ? undefined : key;
+function isLifecycleFactoryCall(expression, checker) {
+  return ts3.isCallExpression(expression) && resolvesToFactoryExport(expression.expression, checker);
 }
-function buildGuiFlipbookIndex(input) {
-  const unresolved = [];
-  const animationsBySource = readAnimationSources(input.assets, unresolved);
-  const byScriptResource = new Map;
-  const claimedBy = new Map;
-  for (const [path, text] of input.scenes) {
-    const displayPath = normalizeDocumentKey(path);
-    let document;
-    try {
-      document = parseSceneTextFormat(text);
-    } catch (error) {
-      if (!(error instanceof SceneTextFormatError))
-        throw error;
-      unresolved.push(`${displayPath}: could not be parsed (${error.message})`);
+function isEffectFreeExpression(expression) {
+  if (expression === undefined) {
+    return true;
+  }
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
+    return isEffectFreeExpression(expression.expression);
+  }
+  if (ts3.isIdentifier(expression) || ts3.isLiteralExpression(expression)) {
+    return true;
+  }
+  switch (expression.kind) {
+    case ts3.SyntaxKind.TrueKeyword:
+    case ts3.SyntaxKind.FalseKeyword:
+    case ts3.SyntaxKind.NullKeyword:
+    case ts3.SyntaxKind.ThisKeyword:
+      return true;
+    default:
+      break;
+  }
+  if (ts3.isFunctionExpression(expression) || ts3.isArrowFunction(expression)) {
+    return true;
+  }
+  if (ts3.isPrefixUnaryExpression(expression)) {
+    return expression.operator !== ts3.SyntaxKind.PlusPlusToken && expression.operator !== ts3.SyntaxKind.MinusMinusToken && isEffectFreeExpression(expression.operand);
+  }
+  if (ts3.isBinaryExpression(expression)) {
+    return !isAssignmentOperator(expression.operatorToken.kind) && isEffectFreeExpression(expression.left) && isEffectFreeExpression(expression.right);
+  }
+  if (ts3.isConditionalExpression(expression)) {
+    return isEffectFreeExpression(expression.condition) && isEffectFreeExpression(expression.whenTrue) && isEffectFreeExpression(expression.whenFalse);
+  }
+  if (ts3.isArrayLiteralExpression(expression)) {
+    return expression.elements.every(isEffectFreeExpression);
+  }
+  if (ts3.isObjectLiteralExpression(expression)) {
+    return expression.properties.every((property) => {
+      if (ts3.isPropertyAssignment(property)) {
+        return isEffectFreeExpression(property.initializer);
+      }
+      return ts3.isShorthandPropertyAssignment(property) || ts3.isMethodDeclaration(property);
+    });
+  }
+  return false;
+}
+function isEffectFreeStatement(statement, checker) {
+  if (ts3.isImportDeclaration(statement) || ts3.isInterfaceDeclaration(statement) || ts3.isTypeAliasDeclaration(statement) || ts3.isFunctionDeclaration(statement) || ts3.isExportDeclaration(statement)) {
+    return true;
+  }
+  if (ts3.isVariableStatement(statement)) {
+    return statement.declarationList.declarations.every((declaration) => isEffectFreeExpression(declaration.initializer));
+  }
+  if (ts3.isExpressionStatement(statement)) {
+    return isLifecycleFactoryCall(statement.expression, checker) || isEffectFreeExpression(statement.expression);
+  }
+  if (ts3.isExportAssignment(statement) && !statement.isExportEquals) {
+    return isLifecycleFactoryCall(statement.expression, checker) || isEffectFreeExpression(statement.expression);
+  }
+  return false;
+}
+function siteOf(node, role) {
+  const sourceFile = node.getSourceFile();
+  const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+  return { role, line: line + 1, column: character + 1 };
+}
+function formatSites(sites) {
+  return sites.map((site) => `${site.role} at ${site.line}:${site.column}`).join(", ");
+}
+function bySourcePosition(a, b) {
+  return a.line === b.line ? a.column - b.column : a.line - b.line;
+}
+function computeCompanionClosure(sourceFile, checker) {
+  const topLevel = collectTopLevel(sourceFile, checker);
+  const exportEntries = collectExports(sourceFile, checker, topLevel);
+  const siblingsOf = new Map;
+  for (const [symbol, declaration] of topLevel) {
+    siblingsOf.set(declaration.statement, [
+      ...siblingsOf.get(declaration.statement) ?? [],
+      symbol
+    ]);
+  }
+  const memberSymbols = new Set;
+  const importBindingSymbols = new Set;
+  const closureStatements = new Set;
+  const queue = exportEntries.map((entry) => entry.symbol);
+  while (queue.length > 0) {
+    const symbol = queue.pop();
+    if (symbol === undefined || memberSymbols.has(symbol)) {
       continue;
     }
-    const [script] = document.fields.get("script") ?? [];
-    if (script === undefined)
-      continue;
-    const key = scriptKeyOf(script);
-    if (key === undefined)
+    memberSymbols.add(symbol);
+    const declaration = topLevel.get(symbol);
+    if (declaration === undefined) {
       continue;
-    const owner = claimedBy.get(key);
-    if (owner !== undefined) {
-      byScriptResource.delete(key);
-      unresolved.push(`${key}: claimed by both ${owner} and ${displayPath}, so its flipbook animations are ambiguous`);
+    }
+    if (ts3.isImportDeclaration(declaration.statement)) {
+      importBindingSymbols.add(symbol);
       continue;
     }
-    claimedBy.set(key, displayPath);
-    const declaredBy = new Map;
-    for (const message of document.messages.get("textures") ?? []) {
-      for (const texture of message.fields.get("texture") ?? []) {
-        if (texture === "")
-          continue;
-        const source = resourceKey(texture);
-        const ids = animationsBySource.get(source);
-        if (ids === undefined) {
-          unresolved.push(`${displayPath}: the texture ${texture} is not among the project's asset documents`);
-          continue;
-        }
-        for (const id of ids) {
-          const declarers = declaredBy.get(id);
-          if (declarers) {
-            declarers.add(source);
-          } else {
-            declaredBy.set(id, new Set([source]));
-          }
+    if (!closureStatements.has(declaration.statement)) {
+      closureStatements.add(declaration.statement);
+      for (const sibling of siblingsOf.get(declaration.statement) ?? []) {
+        if (!memberSymbols.has(sibling)) {
+          queue.push(sibling);
         }
       }
     }
-    byScriptResource.set(key, declaredBy);
+    forEachReference(declaration.node, checker, (_node, referenced) => {
+      if (topLevel.has(referenced) && !memberSymbols.has(referenced)) {
+        queue.push(referenced);
+      }
+    });
   }
-  return { byScriptResource, unresolved };
-}
-// src/gui-node-index.ts
-var SCRIPT_SUFFIX3 = ".gui_script";
-function scriptKeyOf2(script) {
-  if (!script.endsWith(SCRIPT_SUFFIX3))
-    return;
-  const key = script.startsWith("/") ? script.slice(1) : script;
-  return key === SCRIPT_SUFFIX3 ? undefined : key;
-}
-function guiScriptResourceOf(document) {
-  const [script] = document.fields.get("script") ?? [];
-  return script === undefined ? undefined : scriptKeyOf2(script);
-}
-function guiScriptResourcesOf(documents) {
-  const scripts = new Map;
-  for (const [displayPath, text] of documents) {
-    let resource;
-    try {
-      resource = guiScriptResourceOf(parseSceneTextFormat(text));
-    } catch (error) {
-      if (!(error instanceof SceneTextFormatError))
-        throw error;
+  const splits = closureStatements.size > 0;
+  for (const statement of sourceFile.statements) {
+    if (!ts3.isExportDeclaration(statement) || statement.isTypeOnly) {
       continue;
     }
-    if (resource !== undefined)
-      scripts.set(displayPath, resource);
+    if (statement.moduleSpecifier !== undefined) {
+      if (splits) {
+        closureStatements.add(statement);
+      }
+      continue;
+    }
+    const clause = statement.exportClause;
+    if (clause === undefined || !ts3.isNamedExports(clause)) {
+      continue;
+    }
+    const readsMember = clause.elements.some((element) => {
+      if (element.isTypeOnly) {
+        return false;
+      }
+      const local = checker.getExportSpecifierLocalTargetSymbol(element);
+      return local !== undefined && memberSymbols.has(local);
+    });
+    if (readsMember) {
+      closureStatements.add(statement);
+    }
   }
-  return scripts;
-}
-function buildGuiNodeIndex(documents) {
-  const byScriptResource = new Map;
-  const claimedBy = new Map;
-  const unresolved = [];
-  for (const [displayPath, text] of documents) {
-    let document;
-    try {
-      document = parseSceneTextFormat(text);
-    } catch (error) {
-      if (!(error instanceof SceneTextFormatError))
-        throw error;
-      unresolved.push(`${displayPath}: could not be parsed (${error.message})`);
+  const mutations = new Map;
+  forEachAssignmentTarget(sourceFile, checker, (node, symbol) => {
+    if (!memberSymbols.has(symbol)) {
+      return;
+    }
+    mutations.set(symbol, [...mutations.get(symbol) ?? [], node]);
+  });
+  const scriptReferences = new Map;
+  for (const statement of sourceFile.statements) {
+    if (closureStatements.has(statement) || ts3.isExportDeclaration(statement)) {
       continue;
     }
-    const key = guiScriptResourceOf(document);
-    if (key === undefined)
+    forEachReference(statement, checker, (node, symbol) => {
+      if (memberSymbols.has(symbol)) {
+        scriptReferences.set(symbol, [...scriptReferences.get(symbol) ?? [], node]);
+      }
+    });
+  }
+  const ordered = [...memberSymbols].flatMap((symbol) => {
+    const declaration = topLevel.get(symbol);
+    return declaration === undefined ? [] : [{ symbol, declaration }];
+  }).sort((a, b) => a.declaration.order - b.declaration.order);
+  const exportSet = new Set(exportEntries.map((entry) => entry.symbol));
+  const violations = [];
+  for (const { symbol, declaration } of ordered) {
+    const mutated = mutations.get(symbol);
+    const referenced = scriptReferences.get(symbol);
+    if (mutated === undefined || referenced === undefined) {
+      continue;
+    }
+    const sites = [
+      ...mutated.map((node) => siteOf(node, "reassigned")),
+      ...referenced.map((node) => siteOf(node, "read by the script"))
+    ].filter((site, index, all) => all.findIndex((other) => other.line === site.line && other.column === site.column) === index).sort(bySourcePosition);
+    violations.push({
+      kind: "shared-mutable",
+      member: declaration.name,
+      sites,
+      message: `"${declaration.name}" is reassigned and is also used outside the companion, ` + `so the script's copy would never see the update (${formatSites(sites)}). ` + "Move that state into a source with no lifecycle factory."
+    });
+  }
+  for (const entry of exportEntries) {
+    if (entry.name !== COMPANION_INTERNAL_FIELD) {
       continue;
-    const owner = claimedBy.get(key);
-    if (owner !== undefined) {
-      byScriptResource.delete(key);
-      unresolved.push(`${key}: claimed by both ${owner} and ${displayPath}, so its node ids are ambiguous`);
+    }
+    const sites = [siteOf(entry.nameNode, "exported")];
+    violations.push({
+      kind: "reserved-internal-name",
+      member: entry.name,
+      sites,
+      message: `"${COMPANION_INTERNAL_FIELD}" is reserved for the companion's own internals ` + `and cannot be exported (${formatSites(sites)}). Rename the export.`
+    });
+  }
+  for (const statement of sourceFile.statements) {
+    if (closureStatements.has(statement) || isEffectFreeStatement(statement, checker)) {
       continue;
     }
-    claimedBy.set(key, displayPath);
-    const ids = new Set;
-    for (const message of document.messages.get("nodes") ?? []) {
-      for (const id of message.fields.get("id") ?? []) {
-        if (id !== "")
-          ids.add(id);
+    const start = statement.getStart(sourceFile);
+    const hoisted = ordered.find((entry) => entry.declaration.statement.getStart(sourceFile) > start);
+    if (hoisted === undefined) {
+      continue;
+    }
+    const sites = [
+      siteOf(statement, "runs in the script"),
+      siteOf(hoisted.declaration.node, "moves into the companion")
+    ];
+    violations.push({
+      kind: "initialization-order",
+      member: hoisted.declaration.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."
+    });
+  }
+  return {
+    members: ordered.map(({ declaration }) => declaration.name),
+    exports: exportEntries.map((entry) => entry.name),
+    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),
+    violations
+  };
+}
+// src/scene-text-format.ts
+class SceneTextFormatError extends Error {
+  line;
+  constructor(message, line) {
+    super(`${message} (line ${line})`);
+    this.name = "SceneTextFormatError";
+    this.line = line;
+  }
+}
+var IDENTIFIER_PART = /[A-Za-z0-9_]/;
+function append(target, key, value) {
+  const existing = target.get(key);
+  if (existing === undefined) {
+    target.set(key, [value]);
+    return;
+  }
+  existing.push(value);
+}
+function parseSceneTextFormat(text) {
+  let pos = 0;
+  let line = 1;
+  function fail(message, at) {
+    throw new SceneTextFormatError(message, at);
+  }
+  function advance() {
+    const ch = text.charAt(pos);
+    pos += 1;
+    if (ch === `
+`)
+      line += 1;
+    return ch;
+  }
+  function skipWhitespace() {
+    while (pos < text.length) {
+      const ch = text.charAt(pos);
+      if (ch !== " " && ch !== "\t" && ch !== "\r" && ch !== `
+`)
+        return;
+      advance();
+    }
+  }
+  function skipInlineWhitespace() {
+    while (pos < text.length) {
+      const ch = text.charAt(pos);
+      if (ch !== " " && ch !== "\t")
+        return;
+      pos += 1;
+    }
+  }
+  function readIdentifier(at) {
+    const start = pos;
+    while (pos < text.length && IDENTIFIER_PART.test(text.charAt(pos))) {
+      pos += 1;
+    }
+    if (pos === start) {
+      fail(`unexpected \`${text.charAt(start)}\``, at);
+    }
+    return text.slice(start, pos);
+  }
+  function readQuotedScalar() {
+    let value = "";
+    for (;; ) {
+      const openedAt = line;
+      advance();
+      let closed = false;
+      while (pos < text.length) {
+        const ch = advance();
+        if (ch === "\\") {
+          if (pos >= text.length)
+            break;
+          const escaped = advance();
+          if (escaped === '"')
+            value += '"';
+          else if (escaped === "\\")
+            value += "\\";
+          else if (escaped === "n")
+            value += `
+`;
+          else if (escaped === "r")
+            value += "\r";
+          else if (escaped === "t")
+            value += "\t";
+          else
+            value += `\\${escaped}`;
+          continue;
+        }
+        if (ch === '"') {
+          closed = true;
+          break;
+        }
+        if (ch === `
+`)
+          break;
+        value += ch;
+      }
+      if (!closed) {
+        fail("unterminated string literal", openedAt);
+      }
+      const resumePos = pos;
+      const resumeLine = line;
+      skipWhitespace();
+      if (text.charAt(pos) === '"') {
+        continue;
+      }
+      pos = resumePos;
+      line = resumeLine;
+      return value;
+    }
+  }
+  function readUnquotedScalar() {
+    const newline = text.indexOf(`
+`, pos);
+    const end = newline === -1 ? text.length : newline;
+    const raw = text.slice(pos, end);
+    pos = end;
+    return raw.trim();
+  }
+  function parseBody(nested, openedAt) {
+    const fields = new Map;
+    const messages = new Map;
+    for (;; ) {
+      skipWhitespace();
+      if (pos >= text.length) {
+        if (nested) {
+          fail("unclosed `{`", openedAt);
+        }
+        break;
+      }
+      if (text.charAt(pos) === "}") {
+        if (!nested) {
+          fail("unexpected `}`", line);
+        }
+        advance();
+        break;
+      }
+      const keyLine = line;
+      const key = readIdentifier(keyLine);
+      skipInlineWhitespace();
+      const delimiter = text.charAt(pos);
+      if (delimiter === "{") {
+        const braceLine = line;
+        advance();
+        append(messages, key, parseBody(true, braceLine));
+        continue;
+      }
+      if (delimiter === ":") {
+        advance();
+        skipInlineWhitespace();
+        append(fields, key, text.charAt(pos) === '"' ? readQuotedScalar() : readUnquotedScalar());
+        continue;
       }
+      fail(`expected \`:\` or \`{\` after \`${key}\``, keyLine);
+    }
+    return { fields, messages };
+  }
+  return parseBody(false, 1);
+}
+
+// src/animation-sources.ts
+function resourceKey(resource) {
+  return resource.startsWith("/") ? resource.slice(1) : resource;
+}
+function normalizeDocumentKey(path) {
+  return path.replaceAll("\\", "/");
+}
+var SPRITE_SUFFIX = ".sprite";
+var MODEL_SUFFIX = ".model";
+var ANIMATION_SET_SUFFIX = ".animationset";
+var HOP_ONLY_SUFFIXES = [SPRITE_SUFFIX, MODEL_SUFFIX, ANIMATION_SET_SUFFIX];
+function childrenOf(message, name) {
+  return message.messages.get(name) ?? [];
+}
+function declaredAnimations(document) {
+  const ids = new Set;
+  for (const animation of childrenOf(document, "animations")) {
+    for (const id of animation.fields.get("id") ?? []) {
+      if (id !== "")
+        ids.add(id);
     }
-    byScriptResource.set(key, ids);
   }
-  return { byScriptResource, unresolved };
+  return ids;
 }
-// src/input-action-index.ts
-function buildInputActionIndex(documents) {
-  const actions = new Set;
-  for (const text of documents.values()) {
+function readAnimationSources(assets, unresolved) {
+  const animationsByTileSet = new Map;
+  for (const [path, text] of assets) {
+    const displayPath = normalizeDocumentKey(path);
+    if (HOP_ONLY_SUFFIXES.some((suffix) => displayPath.endsWith(suffix)))
+      continue;
     let document;
     try {
       document = parseSceneTextFormat(text);
     } catch (error) {
       if (!(error instanceof SceneTextFormatError))
         throw error;
+      unresolved.push(`${displayPath}: could not be parsed (${error.message})`);
       continue;
     }
-    for (const triggers of document.messages.values()) {
-      for (const trigger of triggers) {
-        for (const action of trigger.fields.get("action") ?? []) {
-          if (action !== "")
-            actions.add(action);
-        }
-      }
-    }
+    animationsByTileSet.set(displayPath, declaredAnimations(document));
   }
-  return actions;
+  return animationsByTileSet;
 }
-// src/project-resources.ts
-var SCAFFOLDED_DEFIGNORE_LINES = ["/node_modules", "/.defold-types", "/.vscode"];
-function isDefignoredPath(displayPath) {
-  const rooted = `/${displayPath.replace(/^\/+/, "")}`;
-  return SCAFFOLDED_DEFIGNORE_LINES.some((line) => rooted === line || rooted.startsWith(`${line}/`));
+function animationSetEntries(document) {
+  const entries = [];
+  for (const entry of childrenOf(document, "animations")) {
+    for (const animation of entry.fields.get("animation") ?? []) {
+      if (animation !== "")
+        entries.push(animation);
+    }
+  }
+  return entries;
 }
 
-// src/scene-documents.ts
-var SCENE_EXTENSIONS = [".go", ".collection"];
-var GUI_EXTENSIONS = [".gui"];
-var INPUT_BINDING_EXTENSIONS = [".input_binding"];
-var COLLECTION_REFERENCE_EXTENSIONS = [".collectionproxy", ".collectionfactory"];
-var ANIMATION_ASSET_EXTENSIONS = [
-  ".atlas",
-  ".tilesource",
-  ".sprite",
-  ".model",
-  ".animationset"
-];
-var LIBRARY_SCENE_EXTENSIONS = [
-  ...SCENE_EXTENSIONS,
-  ...GUI_EXTENSIONS,
-  ...ANIMATION_ASSET_EXTENSIONS,
-  ...COLLECTION_REFERENCE_EXTENSIONS
-];
-var PROJECT_EXTENSIONS = [".project"];
-var GAME_PROJECT_DOCUMENT = "game.project";
-function displayPathOf(projectRoot, filePath) {
-  const path = filePath.replace(/\\/g, "/");
-  const root = projectRoot.replace(/\\/g, "/").replace(/\/+$/, "");
-  return path.startsWith(`${root}/`) ? path.slice(root.length + 1) : path;
+// src/component-animation-index.ts
+var SCRIPT_SUFFIX = ".script";
+var SPRITE_SUFFIX2 = ".sprite";
+var MODEL_SUFFIX2 = ".model";
+var ANIMATION_SET_SUFFIX2 = ".animationset";
+var MESH_SUFFIXES = [".gltf", ".glb"];
+function firstField(message, name) {
+  return (message.fields.get(name) ?? [])[0];
 }
-function isBuildOutput(displayPath) {
-  return displayPath.split("/").includes("build");
+function childrenOf2(message, name) {
+  return message.messages.get(name) ?? [];
 }
-function isExcludedProjectPath(displayPath) {
-  return isBuildOutput(displayPath) || isDefignoredPath(displayPath);
+function basename(resource) {
+  const file = resource.slice(resource.lastIndexOf("/") + 1);
+  const dot = file.lastIndexOf(".");
+  return dot === -1 ? file : file.slice(0, dot);
 }
-function readSceneDocuments(host, projectRoot, extensions = SCENE_EXTENSIONS) {
-  const documents = new Map;
-  const origins = new Map;
-  const unreadable = [];
-  const paths = [];
-  if (!host.readDirectory) {
-    unreadable.push("the editor host cannot enumerate project files, so no scene source was read");
-    return { documents, origins, unreadable, paths };
-  }
-  for (const filePath of host.readDirectory(projectRoot, extensions)) {
-    const displayPath = displayPathOf(projectRoot, filePath);
-    if (isExcludedProjectPath(displayPath))
+function readAssets(assets, unresolved) {
+  const animationsByTileSet = readAnimationSources(assets, unresolved);
+  const tileSetBySprite = new Map;
+  const modelDocuments = new Set;
+  const animationSourceByModel = new Map;
+  const entriesByAnimationSet = new Map;
+  for (const [path, text] of assets) {
+    const displayPath = normalizeDocumentKey(path);
+    const isSprite = displayPath.endsWith(SPRITE_SUFFIX2);
+    const isModel = displayPath.endsWith(MODEL_SUFFIX2);
+    const isAnimationSet = displayPath.endsWith(ANIMATION_SET_SUFFIX2);
+    if (!isSprite && !isModel && !isAnimationSet)
       continue;
-    const text = host.readFile(filePath);
-    if (text === undefined) {
-      unreadable.push(`${displayPath}: could not be read`);
+    let document;
+    try {
+      document = parseSceneTextFormat(text);
+    } catch (error) {
+      if (!(error instanceof SceneTextFormatError))
+        throw error;
+      unresolved.push(`${displayPath}: could not be parsed (${error.message})`);
       continue;
     }
-    documents.set(displayPath, text);
-    paths.push(filePath);
-  }
-  const library = readLibrarySceneDocuments(host, projectRoot, extensions);
-  unreadable.push(...library.unreadable);
-  for (const { displayPath, hostPath, url, text } of library.documents) {
-    if (documents.has(displayPath)) {
-      unreadable.push(`${displayPath}: also declared by ${url}; the project's own file is used`);
+    if (isSprite) {
+      const tileSet = firstField(document, "tile_set");
+      if (tileSet !== undefined)
+        tileSetBySprite.set(displayPath, resourceKey(tileSet));
       continue;
     }
-    documents.set(displayPath, text);
-    origins.set(displayPath, url);
-    paths.push(hostPath);
-  }
-  return { documents, origins, unreadable, paths };
-}
-function listProjectResourcePaths(host, projectRoot, extensions) {
-  if (!host.readDirectory)
-    return new Set;
-  const paths = [];
-  for (const filePath of host.readDirectory(projectRoot, extensions)) {
-    const displayPath = displayPathOf(projectRoot, filePath);
-    if (isExcludedProjectPath(displayPath))
-      continue;
-    if (!extensions.some((extension) => displayPath.endsWith(extension)))
+    if (isModel) {
+      modelDocuments.add(displayPath);
+      const animations = firstField(document, "animations");
+      if (animations !== undefined)
+        animationSourceByModel.set(displayPath, animations);
       continue;
-    paths.push(`/${displayPath}`);
+    }
+    entriesByAnimationSet.set(displayPath, animationSetEntries(document));
   }
-  return new Set(paths.sort());
-}
-
-// src/library-dependencies.ts
-function isProjectHeader(line) {
-  return line.trim() === "[project]";
-}
-function isSectionHeader(line) {
-  return /^\[.+\]\s*$/.test(line.trim());
+  return {
+    animationsByTileSet,
+    tileSetBySprite,
+    modelDocuments,
+    animationSourceByModel,
+    entriesByAnimationSet
+  };
 }
-function readGameProjectDependencies(gameProjectText) {
-  const lines = gameProjectText.split(`
-`);
-  const deps = [];
-  let inProject = false;
-  for (const line of lines) {
-    if (isSectionHeader(line)) {
-      inProject = isProjectHeader(line);
-      continue;
-    }
-    if (!inProject) {
-      continue;
-    }
-    const match = line.match(/^dependencies#(\d+)\s*=\s*(.+)$/);
-    if (match?.[1] !== undefined && match[2] !== undefined) {
-      deps.push({ index: Number(match[1]), url: match[2] });
+function resolveAnimationSet(input) {
+  const { path, prefix, stack, assets, unresolved } = input;
+  const entries = assets.entriesByAnimationSet.get(path);
+  if (entries === undefined)
+    return;
+  stack.add(path);
+  try {
+    const ids = new Map;
+    for (const entry of entries) {
+      const key = resourceKey(entry);
+      if (MESH_SUFFIXES.some((suffix) => key.endsWith(suffix))) {
+        ids.set(prefix + basename(key), path);
+        continue;
+      }
+      if (!key.endsWith(ANIMATION_SET_SUFFIX2)) {
+        unresolved.push(`${path}: the entry ${entry} is not a .gltf, .glb or .animationset, so it declares no animation id`);
+        continue;
+      }
+      if (!assets.entriesByAnimationSet.has(key)) {
+        unresolved.push(`${path}: the entry ${entry} is not among the project's animation set documents`);
+        return;
+      }
+      if (stack.has(key)) {
+        unresolved.push(`${path}: the entry ${entry} re-enters an animation set already being read, so the chain is cyclic`);
+        return;
+      }
+      const nested = resolveAnimationSet({
+        path: key,
+        prefix: `${prefix + basename(key)}/`,
+        stack,
+        assets,
+        unresolved
+      });
+      if (nested === undefined)
+        return;
+      for (const [id, declaring] of nested)
+        if (!ids.has(id))
+          ids.set(id, declaring);
     }
+    return ids;
+  } finally {
+    stack.delete(path);
   }
-  return deps;
 }
-function archiveWrapperOf(entries) {
-  let wrapper;
-  for (const entry of entries) {
-    const separator = entry.indexOf("/");
-    if (separator <= 0) {
+function componentAnimationSources(object, displayPath, assets, unresolved) {
+  const sources = new Map;
+  function claimModel(id, animations) {
+    if (!animations.endsWith(ANIMATION_SET_SUFFIX2)) {
+      unresolved.push(`${displayPath}: the model component "${id}" names ${animations} rather than an animation set, so none of its animation ids are established`);
       return;
     }
-    const segment = entry.slice(0, separator);
-    if (wrapper === undefined) {
-      wrapper = segment;
-    } else if (wrapper !== segment) {
-      return;
+    sources.set(id, { kind: "model", path: resourceKey(animations) });
+  }
+  for (const embedded of childrenOf2(object, "embedded_components")) {
+    const type = firstField(embedded, "type");
+    if (type !== "sprite" && type !== "model")
+      continue;
+    const id = firstField(embedded, "id");
+    const payload = firstField(embedded, "data");
+    if (id === undefined || payload === undefined)
+      continue;
+    let document;
+    try {
+      document = parseSceneTextFormat(payload);
+    } catch (error) {
+      if (!(error instanceof SceneTextFormatError))
+        throw error;
+      unresolved.push(`${displayPath}: the embedded ${type} "${id}" could not be read (${error.message})`);
+      continue;
+    }
+    if (type === "sprite") {
+      const tileSet = firstField(document, "tile_set");
+      if (tileSet !== undefined)
+        sources.set(id, { kind: "sprite", path: resourceKey(tileSet) });
+      continue;
     }
+    const animations = firstField(document, "animations");
+    if (animations !== undefined)
+      claimModel(id, animations);
   }
-  return wrapper;
-}
-function readLibraryIncludeDirs(gameProjectText) {
-  let inLibrary = false;
-  for (const line of gameProjectText.split(`
-`)) {
-    if (isSectionHeader(line)) {
-      inLibrary = line.trim() === "[library]";
+  for (const referenced of childrenOf2(object, "components")) {
+    const component = firstField(referenced, "component");
+    const id = firstField(referenced, "id");
+    if (id === undefined || component === undefined)
       continue;
-    }
-    if (!inLibrary) {
+    if (component.endsWith(SPRITE_SUFFIX2)) {
+      const tileSet = assets.tileSetBySprite.get(resourceKey(component));
+      if (tileSet === undefined) {
+        unresolved.push(`${displayPath}: the sprite component "${id}" names ${component}, which is not among the project's sprite documents`);
+        continue;
+      }
+      sources.set(id, { kind: "sprite", path: tileSet });
       continue;
     }
-    const match = line.match(/^include_dirs\s*=\s*(.*)$/);
-    if (match?.[1] !== undefined) {
-      return match[1].split(",").map((dir) => dir.trim()).filter((dir) => dir.length > 0);
+    if (!component.endsWith(MODEL_SUFFIX2))
+      continue;
+    const resource = resourceKey(component);
+    if (!assets.modelDocuments.has(resource)) {
+      unresolved.push(`${displayPath}: the model component "${id}" names ${component}, which is not among the project's model documents`);
+      continue;
     }
+    const animations = assets.animationSourceByModel.get(resource);
+    if (animations !== undefined)
+      claimModel(id, animations);
   }
-  return [];
+  return sources;
 }
-function isContainedResourcePath(path) {
-  if (path.length === 0 || path.includes("\\")) {
-    return false;
+function scriptResourcesOf(object) {
+  const resources = [];
+  for (const component of childrenOf2(object, "components")) {
+    const resource = firstField(component, "component");
+    if (resource === undefined || !resource.endsWith(SCRIPT_SUFFIX))
+      continue;
+    const key = resourceKey(resource);
+    if (key !== SCRIPT_SUFFIX.slice(1))
+      resources.push(key);
   }
-  return path.split("/").every((segment) => segment.length > 0 && segment !== "." && segment !== "..");
+  return resources;
 }
-function libraryIncludedEntries(entries, gameProjectText) {
-  if (gameProjectText === undefined) {
-    return {
-      shared: [],
-      reasons: ["ships no game.project, so it declares no [library] include_dirs"],
-      refused: []
-    };
+function isGameObject(message) {
+  return message.messages.has("components") || message.messages.has("embedded_components");
+}
+function buildComponentAnimationIndex(input) {
+  const unresolved = [];
+  const assets = readAssets(input.assets, unresolved);
+  const byScriptResource = new Map;
+  const sourceByScriptResource = new Map;
+  const claimedBy = new Map;
+  function walk(message, blockName, displayPath) {
+    if (isGameObject(message)) {
+      claim(message, displayPath);
+    }
+    if (blockName === "embedded_instances") {
+      for (const payload of message.fields.get("data") ?? []) {
+        try {
+          walk(parseSceneTextFormat(payload), "", displayPath);
+        } catch (error) {
+          if (!(error instanceof SceneTextFormatError))
+            throw error;
+          unresolved.push(`${displayPath}: an embedded game object could not be read (${error.message})`);
+        }
+      }
+    }
+    for (const [name, nested] of message.messages) {
+      for (const child of nested) {
+        walk(child, name, displayPath);
+      }
+    }
   }
-  const includeDirs = new Set(readLibraryIncludeDirs(gameProjectText));
-  if (includeDirs.size === 0) {
-    return {
-      shared: [],
-      reasons: ["its game.project declares no [library] include_dirs"],
-      refused: []
-    };
+  function idsOf(id, source, displayPath) {
+    if (source.kind === "sprite") {
+      const declared = assets.animationsByTileSet.get(source.path);
+      if (declared !== undefined)
+        return new Map([...declared].map((name) => [name, source.path]));
+      unresolved.push(`${displayPath}: the sprite component "${id}" names the tile source /${source.path}, which is not among the project's asset documents`);
+      return;
+    }
+    const resolved = resolveAnimationSet({
+      path: source.path,
+      prefix: "",
+      stack: new Set,
+      assets,
+      unresolved
+    });
+    if (resolved !== undefined)
+      return resolved;
+    if (!assets.entriesByAnimationSet.has(source.path)) {
+      unresolved.push(`${displayPath}: the model component "${id}" names the animation set /${source.path}, which is not among the project's asset documents`);
+    }
+    return;
   }
-  const wrapper = archiveWrapperOf(entries);
-  const shared = [];
-  const refused = [];
-  for (const entry of entries) {
-    const path = wrapper === undefined ? entry : entry.slice(wrapper.length + 1);
-    const [head] = path.split("/");
-    if (head === undefined || !includeDirs.has(head)) {
-      continue;
+  function claim(object, displayPath) {
+    const scripts = scriptResourcesOf(object);
+    if (scripts.length === 0)
+      return;
+    const sources = componentAnimationSources(object, displayPath, assets, unresolved);
+    const animations = new Map;
+    const declaringSources = new Map;
+    for (const [id, source] of sources) {
+      const resolved = idsOf(id, source, displayPath);
+      if (resolved === undefined)
+        continue;
+      animations.set(id, new Set(resolved.keys()));
+      declaringSources.set(id, resolved);
     }
-    const dot = path.lastIndexOf(".");
-    if (dot === -1 || !LIBRARY_SCENE_EXTENSIONS.includes(path.slice(dot).toLowerCase())) {
-      continue;
+    for (const key of scripts) {
+      const owner = claimedBy.get(key);
+      if (owner !== undefined) {
+        byScriptResource.delete(key);
+        sourceByScriptResource.delete(key);
+        unresolved.push(`${key}: claimed by both ${owner} and ${displayPath}, so its component animations are ambiguous`);
+        continue;
+      }
+      claimedBy.set(key, displayPath);
+      byScriptResource.set(key, animations);
+      sourceByScriptResource.set(key, declaringSources);
     }
-    if (!isContainedResourcePath(path)) {
-      refused.push(entry);
-      continue;
+  }
+  for (const [path, text] of input.scenes) {
+    const displayPath = normalizeDocumentKey(path);
+    try {
+      walk(parseSceneTextFormat(text), "", displayPath);
+    } catch (error) {
+      if (!(error instanceof SceneTextFormatError))
+        throw error;
+      unresolved.push(`${displayPath}: could not be parsed (${error.message})`);
     }
-    shared.push({ entry, path });
   }
-  shared.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
-  return { shared, reasons: [], refused };
-}
-var LIBRARY_DEPENDENCY_ROOT = ".defold-types/dependencies";
-var LIBRARY_DEPENDENCY_MANIFEST = `${LIBRARY_DEPENDENCY_ROOT}/dependencies.json`;
-function joinProject(projectRoot, relative) {
-  return `${projectRoot.replace(/\\/g, "/").replace(/\/+$/, "")}/${relative}`;
+  return { byScriptResource, sourceByScriptResource, unresolved };
 }
-function readMaterializedKeys(manifestText) {
-  let parsed;
-  try {
-    parsed = JSON.parse(manifestText);
-  } catch {
+function componentIdOfSameObjectAddress(address) {
+  if (!address.startsWith("#"))
     return;
-  }
-  const entries = parsed?.dependencies;
-  if (!Array.isArray(entries))
+  const id = address.slice(1);
+  if (id === "" || id.includes("/") || id.includes("#"))
     return;
-  const keyByUrl = new Map;
-  for (const entry of entries) {
-    const { key, url } = entry ?? {};
-    if (typeof key === "string" && typeof url === "string")
-      keyByUrl.set(url, key);
-  }
-  return keyByUrl;
+  return id;
 }
-function readLibrarySceneDocuments(host, projectRoot, extensions = LIBRARY_SCENE_EXTENSIONS) {
-  const documents = [];
-  const unreadable = [];
-  if (!host.readDirectory)
-    return { documents, unreadable };
-  const gameProjectText = host.readFile(joinProject(projectRoot, GAME_PROJECT_DOCUMENT));
-  if (gameProjectText === undefined)
-    return { documents, unreadable };
-  const declared = [...readGameProjectDependencies(gameProjectText)].sort((a, b) => a.index - b.index);
-  if (declared.length === 0)
-    return { documents, unreadable };
-  const manifestText = host.readFile(joinProject(projectRoot, LIBRARY_DEPENDENCY_MANIFEST));
-  if (manifestText === undefined) {
-    for (const { url } of declared) {
-      unreadable.push(`${url}: is declared by game.project but ${LIBRARY_DEPENDENCY_MANIFEST} is absent`);
-    }
-    return { documents, unreadable };
-  }
-  const keyByUrl = readMaterializedKeys(manifestText);
-  if (keyByUrl === undefined) {
-    for (const { url } of declared) {
-      unreadable.push(`${url}: is declared by game.project but ${LIBRARY_DEPENDENCY_MANIFEST} is not a readable dependency manifest`);
+// src/config-key-index.ts
+function sectionNameOf(line) {
+  const match = line.trim().match(/^\[(.+)\]$/);
+  return match?.[1];
+}
+function buildConfigKeyIndex(gameProjectText) {
+  const keys = new Set;
+  let section;
+  for (const line of gameProjectText.split(`
+`)) {
+    const header = sectionNameOf(line);
+    if (header !== undefined) {
+      section = header;
+      continue;
     }
-    return { documents, unreadable };
-  }
-  const resolved = [];
-  const urlByKey = new Map;
-  for (const { url } of declared) {
-    const key = keyByUrl.get(url);
-    if (key === undefined) {
-      unreadable.push(`${url}: is declared by game.project but was not materialized by the last resolve`);
+    if (section === undefined)
+      continue;
+    const separator = line.indexOf("=");
+    if (separator === -1)
+      continue;
+    const key = line.slice(0, separator).trim();
+    if (key === "")
       continue;
-    }
-    resolved.push({ key, url });
-    urlByKey.set(key, url);
+    keys.add(`${section}.${key}`);
   }
-  const root = joinProject(projectRoot, LIBRARY_DEPENDENCY_ROOT);
-  const filesByKey = new Map;
-  const stray = new Set;
-  for (const filePath of host.readDirectory(root, extensions)) {
-    const relative = displayPathOf(root, filePath);
-    if (relative === filePath.replace(/\\/g, "/"))
+  return keys;
+}
+function readGameProjectSetting(gameProjectText, section, key) {
+  let current;
+  for (const line of gameProjectText.split(`
+`)) {
+    const header = sectionNameOf(line);
+    if (header !== undefined) {
+      current = header;
       continue;
-    const separator = relative.indexOf("/");
-    if (separator <= 0)
+    }
+    if (current !== section)
       continue;
-    const key = relative.slice(0, separator);
-    const url = urlByKey.get(key);
-    if (url === undefined) {
-      stray.add(key);
+    const separator = line.indexOf("=");
+    if (separator === -1)
       continue;
-    }
-    const bucket = filesByKey.get(key);
-    if (bucket === undefined)
-      filesByKey.set(key, [filePath]);
-    else
-      bucket.push(filePath);
+    if (line.slice(0, separator).trim() !== key)
+      continue;
+    const value = line.slice(separator + 1).trim();
+    if (value !== "")
+      return value;
   }
-  const claimed = new Map;
-  for (const { key, url } of resolved) {
-    for (const hostPath of (filesByKey.get(key) ?? []).sort()) {
-      const displayPath = displayPathOf(root, hostPath).slice(key.length + 1);
-      if (displayPath === "")
-        continue;
-      const owner = claimed.get(displayPath);
-      if (owner !== undefined) {
-        unreadable.push(`${displayPath}: also declared by ${url}; ${owner}'s file is used`);
-        continue;
+  return;
+}
+// src/lua-require-scan.ts
+var PLACEHOLDER = "\x00";
+function longBracketLevel(src, open) {
+  let i = open + 1;
+  let level = 0;
+  while (src[i] === "=") {
+    level++;
+    i++;
+  }
+  return src[i] === "[" ? level : undefined;
+}
+function skipLongBracket(src, open, level) {
+  const close = `]${"=".repeat(level)}]`;
+  const end = src.indexOf(close, open + level + 2);
+  return end === -1 ? src.length : end + close.length;
+}
+function mask(lua) {
+  const literals = [];
+  let text = "";
+  let i = 0;
+  while (i < lua.length) {
+    const c = lua[i];
+    if (c === "-" && lua[i + 1] === "-") {
+      const level = lua[i + 2] === "[" ? longBracketLevel(lua, i + 2) : undefined;
+      if (level !== undefined) {
+        i = skipLongBracket(lua, i + 2, level);
+      } else {
+        const newline = lua.indexOf(`
+`, i);
+        i = newline === -1 ? lua.length : newline;
       }
-      const text = host.readFile(hostPath);
-      if (text === undefined) {
-        unreadable.push(`${displayPath}: could not be read from ${url}`);
+      text += " ";
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      let j = i + 1;
+      let value = "";
+      while (j < lua.length) {
+        const ch = lua[j];
+        if (ch === "\\") {
+          const next = lua[j + 1] ?? "";
+          value += next === "n" ? `
+` : next === "t" ? "\t" : next;
+          j += 2;
+          continue;
+        }
+        if (ch === c) {
+          j++;
+          break;
+        }
+        if (ch === `
+`) {
+          break;
+        }
+        value += ch;
+        j++;
+      }
+      text += `${PLACEHOLDER}${literals.length}${PLACEHOLDER}`;
+      literals.push({ value, start: i, end: j });
+      i = j;
+      continue;
+    }
+    if (c === "[") {
+      const level = longBracketLevel(lua, i);
+      if (level !== undefined) {
+        const end = skipLongBracket(lua, i, level);
+        const close = `]${"=".repeat(level)}]`;
+        const inner = lua.slice(i + level + 2, Math.max(i + level + 2, end - close.length));
+        text += `${PLACEHOLDER}${literals.length}${PLACEHOLDER}`;
+        literals.push({ value: inner, start: i, end });
+        i = end;
         continue;
       }
-      claimed.set(displayPath, url);
-      documents.push({ displayPath, hostPath, url, text });
     }
+    text += c;
+    i++;
   }
-  for (const key of [...stray].sort()) {
-    unreadable.push(`${LIBRARY_DEPENDENCY_ROOT}/${key}: is materialized but no longer declared by game.project, so its scenes are left out`);
+  return { text, literals };
+}
+var REQUIRE_RE = new RegExp(String.raw`(?<![A-Za-z0-9_.])require\s*\(\s*${PLACEHOLDER}(\d+)${PLACEHOLDER}\s*\)`, "g");
+function scanEmittedRequires(lua) {
+  const { text, literals } = mask(lua);
+  const sites = [];
+  for (const match of text.matchAll(REQUIRE_RE)) {
+    const literal = literals[Number(match[1])];
+    if (literal === undefined) {
+      continue;
+    }
+    sites.push({ path: literal.value, start: literal.start, end: literal.end });
   }
-  return { documents, unreadable };
+  return sites;
 }
-// src/main-entry-factory-imports.ts
-import * as ts3 from "typescript";
 
-// src/lifecycle-erasure.ts
-import * as ts2 from "typescript";
-import {
-  createAssignmentStatement,
-  createBinaryExpression as createBinaryExpression2,
-  createBlock as createBlock2,
-  createCallExpression as createCallExpression2,
-  createExpressionStatement,
-  createForInStatement,
-  createFunctionExpression as createFunctionExpression2,
-  createIdentifier as createIdentifier2,
-  createIfStatement as createIfStatement2,
-  createNilLiteral,
-  createReturnStatement,
-  createStringLiteral as createStringLiteral2,
-  createTableIndexExpression,
-  createVariableDeclarationStatement as createVariableDeclarationStatement2,
-  NodeFlags as NodeFlags2,
-  SyntaxKind as SyntaxKind4
-} from "typescript-to-lua";
+// src/timers-runtime.ts
+var TIMERS_MODULE_SPECIFIER = "@defold-typescript/types/timers";
+var TIMERS_REQUIRE_NAME = "defold_typescript_timers";
+var TIMERS_RUNTIME = `local ____lualib = require("lualib_bundle")
+local __TS__Promise = ____lualib.__TS__Promise
+local __TS__New = ____lualib.__TS__New
 
-// src/message-dispatch-lowering.ts
-import * as ts from "typescript";
-import {
-  createBinaryExpression,
-  createBlock,
-  createCallExpression,
-  createFunctionExpression,
-  createIdentifier,
-  createIfStatement,
-  createStringLiteral,
-  createVariableDeclarationStatement,
-  NodeFlags,
-  SyntaxKind as SyntaxKind2
-} from "typescript-to-lua";
-var DISPATCH_MODULE = "@defold-typescript/types";
-var DISPATCH_NAME = "onMessage";
-var HANDLER_PARAM_TARGETS = ["self", "message", "sender"];
-function resolvesToDispatchExport(callee, checker) {
-  let symbol = checker.getSymbolAtLocation(callee);
-  if (symbol === undefined) {
-    return false;
-  }
-  if (symbol.flags & ts.SymbolFlags.Alias) {
-    symbol = checker.getAliasedSymbol(symbol);
-  }
-  if (symbol.getName() !== DISPATCH_NAME) {
-    return false;
-  }
-  const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
-  if (declaration === undefined) {
-    return false;
+local function setTimeout(callback, delayMs)
+    return timer.delay(delayMs / 1000, false, function()
+        callback()
+    end)
+end
+
+local function setInterval(callback, delayMs)
+    return timer.delay(delayMs / 1000, true, function()
+        callback()
+    end)
+end
+
+local function clearTimeout(handle)
+    timer.cancel(handle)
+end
+
+local function clearInterval(handle)
+    timer.cancel(handle)
+end
+
+local function wait(seconds)
+    return __TS__New(__TS__Promise, function(_, resolve)
+        timer.delay(seconds, false, function()
+            resolve()
+        end)
+    end)
+end
+
+return {
+    setTimeout = setTimeout,
+    setInterval = setInterval,
+    clearTimeout = clearTimeout,
+    clearInterval = clearInterval,
+    wait = wait,
+}
+`;
+
+// src/emitted-requires.ts
+var LUALIB_REQUIRE_NAME = "lualib_bundle";
+var GENERATED_RUNTIME_REQUIRES = new Set([
+  LUALIB_REQUIRE_NAME,
+  TIMERS_REQUIRE_NAME
+]);
+function findEmittedRequires(lua) {
+  const found = [];
+  const seen = new Set;
+  for (const { path } of scanEmittedRequires(lua)) {
+    if (GENERATED_RUNTIME_REQUIRES.has(path) || seen.has(path)) {
+      continue;
+    }
+    seen.add(path);
+    found.push(path);
   }
-  return declaration.getSourceFile().fileName.includes(DISPATCH_MODULE);
+  return found;
 }
-function handlerName(property) {
-  const name = property.name;
-  if (name === undefined) {
+// src/gui-flipbook-index.ts
+var SCRIPT_SUFFIX2 = ".gui_script";
+function scriptKeyOf(script) {
+  if (!script.endsWith(SCRIPT_SUFFIX2))
     return;
+  const key = resourceKey(script);
+  return key === SCRIPT_SUFFIX2 ? undefined : key;
+}
+function buildGuiFlipbookIndex(input) {
+  const unresolved = [];
+  const animationsBySource = readAnimationSources(input.assets, unresolved);
+  const byScriptResource = new Map;
+  const claimedBy = new Map;
+  for (const [path, text] of input.scenes) {
+    const displayPath = normalizeDocumentKey(path);
+    let document;
+    try {
+      document = parseSceneTextFormat(text);
+    } catch (error) {
+      if (!(error instanceof SceneTextFormatError))
+        throw error;
+      unresolved.push(`${displayPath}: could not be parsed (${error.message})`);
+      continue;
+    }
+    const [script] = document.fields.get("script") ?? [];
+    if (script === undefined)
+      continue;
+    const key = scriptKeyOf(script);
+    if (key === undefined)
+      continue;
+    const owner = claimedBy.get(key);
+    if (owner !== undefined) {
+      byScriptResource.delete(key);
+      unresolved.push(`${key}: claimed by both ${owner} and ${displayPath}, so its flipbook animations are ambiguous`);
+      continue;
+    }
+    claimedBy.set(key, displayPath);
+    const declaredBy = new Map;
+    for (const message of document.messages.get("textures") ?? []) {
+      for (const texture of message.fields.get("texture") ?? []) {
+        if (texture === "")
+          continue;
+        const source = resourceKey(texture);
+        const ids = animationsBySource.get(source);
+        if (ids === undefined) {
+          unresolved.push(`${displayPath}: the texture ${texture} is not among the project's asset documents`);
+          continue;
+        }
+        for (const id of ids) {
+          const declarers = declaredBy.get(id);
+          if (declarers) {
+            declarers.add(source);
+          } else {
+            declaredBy.set(id, new Set([source]));
+          }
+        }
+      }
+    }
+    byScriptResource.set(key, declaredBy);
   }
-  if (ts.isIdentifier(name) || ts.isStringLiteral(name)) {
-    return name.text;
-  }
-  return;
+  return { byScriptResource, unresolved };
+}
+// src/gui-node-index.ts
+var SCRIPT_SUFFIX3 = ".gui_script";
+function scriptKeyOf2(script) {
+  if (!script.endsWith(SCRIPT_SUFFIX3))
+    return;
+  const key = script.startsWith("/") ? script.slice(1) : script;
+  return key === SCRIPT_SUFFIX3 ? undefined : key;
+}
+function guiScriptResourceOf(document) {
+  const [script] = document.fields.get("script") ?? [];
+  return script === undefined ? undefined : scriptKeyOf2(script);
 }
-function handlerFunction(property) {
-  if (ts.isMethodDeclaration(property) && property.body !== undefined) {
-    return property;
-  }
-  if (ts.isPropertyAssignment(property)) {
-    const initializer = property.initializer;
-    if (ts.isFunctionExpression(initializer) || ts.isArrowFunction(initializer)) {
-      return initializer;
+function guiScriptResourcesOf(documents) {
+  const scripts = new Map;
+  for (const [displayPath, text] of documents) {
+    let resource;
+    try {
+      resource = guiScriptResourceOf(parseSceneTextFormat(text));
+    } catch (error) {
+      if (!(error instanceof SceneTextFormatError))
+        throw error;
+      continue;
     }
+    if (resource !== undefined)
+      scripts.set(displayPath, resource);
   }
-  return;
-}
-function isThisParameter(param) {
-  return ts.isIdentifier(param.name) && ts.identifierToKeywordKind(param.name) === ts.SyntaxKind.ThisKeyword;
+  return scripts;
 }
-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)) {
-      return;
+function buildGuiNodeIndex(documents) {
+  const byScriptResource = new Map;
+  const claimedBy = new Map;
+  const unresolved = [];
+  for (const [displayPath, text] of documents) {
+    let document;
+    try {
+      document = parseSceneTextFormat(text);
+    } catch (error) {
+      if (!(error instanceof SceneTextFormatError))
+        throw error;
+      unresolved.push(`${displayPath}: could not be parsed (${error.message})`);
+      continue;
     }
-    if (param.name.text !== engineName) {
-      aliases.push(createVariableDeclarationStatement(createIdentifier(param.name.text), createIdentifier(engineName)));
+    const key = guiScriptResourceOf(document);
+    if (key === undefined)
+      continue;
+    const owner = claimedBy.get(key);
+    if (owner !== undefined) {
+      byScriptResource.delete(key);
+      unresolved.push(`${key}: claimed by both ${owner} and ${displayPath}, so its node ids are ambiguous`);
+      continue;
     }
-  });
-  return aliases;
-}
-function handlerBody(fn, context) {
-  if (ts.isBlock(fn.body)) {
-    return context.transformStatements(fn.body.statements);
+    claimedBy.set(key, displayPath);
+    const ids = new Set;
+    for (const message of document.messages.get("nodes") ?? []) {
+      for (const id of message.fields.get("id") ?? []) {
+        if (id !== "")
+          ids.add(id);
+      }
+    }
+    byScriptResource.set(key, ids);
   }
-  return context.transformStatements([ts.factory.createExpressionStatement(fn.body)]);
+  return { byScriptResource, unresolved };
 }
-var messageDispatchLoweringPlugin = {
-  visitors: {
-    [ts.SyntaxKind.CallExpression]: (node, context) => {
-      const [handlersArg] = node.arguments;
-      if (node.arguments.length === 1 && handlersArg !== undefined && ts.isObjectLiteralExpression(handlersArg) && resolvesToDispatchExport(node.expression, context.checker)) {
-        let chain;
-        const properties = [...handlersArg.properties];
-        for (let i = properties.length - 1;i >= 0; i--) {
-          const property = properties[i];
-          if (property === undefined) {
-            continue;
-          }
-          const name = handlerName(property);
-          const fn = handlerFunction(property);
-          if (name === undefined || fn === undefined) {
-            continue;
-          }
-          const condition = createBinaryExpression(createIdentifier("message_id"), createCallExpression(createIdentifier("hash"), [createStringLiteral(name)]), SyntaxKind2.EqualityOperator);
-          const body = [...aliasStatements(fn), ...handlerBody(fn, context)];
-          chain = createIfStatement(condition, createBlock(body), chain);
+// src/input-action-index.ts
+function buildInputActionIndex(documents) {
+  const actions = new Set;
+  for (const text of documents.values()) {
+    let document;
+    try {
+      document = parseSceneTextFormat(text);
+    } catch (error) {
+      if (!(error instanceof SceneTextFormatError))
+        throw error;
+      continue;
+    }
+    for (const triggers of document.messages.values()) {
+      for (const trigger of triggers) {
+        for (const action of trigger.fields.get("action") ?? []) {
+          if (action !== "")
+            actions.add(action);
         }
-        const params = [
-          createIdentifier("self"),
-          createIdentifier("message_id"),
-          createIdentifier("message"),
-          createIdentifier("sender")
-        ];
-        return createFunctionExpression(createBlock(chain === undefined ? [] : [chain]), params, undefined, NodeFlags.Declaration, node);
       }
-      return context.superTransformExpression(node);
     }
   }
-};
+  return actions;
+}
+// src/project-resources.ts
+var SCAFFOLDED_DEFIGNORE_LINES = ["/node_modules", "/.defold-types", "/.vscode"];
+function isDefignoredPath(displayPath) {
+  const rooted = `/${displayPath.replace(/^\/+/, "")}`;
+  return SCAFFOLDED_DEFIGNORE_LINES.some((line) => rooted === line || rooted.startsWith(`${line}/`));
+}
 
-// src/lifecycle-erasure.ts
-var FACTORY_MODULE = "@defold-typescript/types";
-var FACTORY_NAMES = new Set(["defineScript", "defineGuiScript", "defineRenderScript"]);
-var FACTORY_SPECIFIERS = new Set([
-  FACTORY_MODULE,
-  `${FACTORY_MODULE}/script`,
-  `${FACTORY_MODULE}/gui-script`,
-  `${FACTORY_MODULE}/render-script`
-]);
-function resolvesToFactoryExport(callee, checker) {
-  let symbol = checker.getSymbolAtLocation(callee);
-  if (symbol === undefined) {
-    return false;
-  }
-  if (symbol.flags & ts2.SymbolFlags.Alias) {
-    symbol = checker.getAliasedSymbol(symbol);
-  }
-  if (!FACTORY_NAMES.has(symbol.getName())) {
-    return false;
-  }
-  const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
-  if (declaration === undefined) {
-    return false;
-  }
-  return declaration.getSourceFile().fileName.includes(FACTORY_MODULE);
+// src/scene-documents.ts
+var SCENE_EXTENSIONS = [".go", ".collection"];
+var GUI_EXTENSIONS = [".gui"];
+var INPUT_BINDING_EXTENSIONS = [".input_binding"];
+var COLLECTION_REFERENCE_EXTENSIONS = [".collectionproxy", ".collectionfactory"];
+var ANIMATION_ASSET_EXTENSIONS = [
+  ".atlas",
+  ".tilesource",
+  ".sprite",
+  ".model",
+  ".animationset"
+];
+var LIBRARY_SCENE_EXTENSIONS = [
+  ...SCENE_EXTENSIONS,
+  ...GUI_EXTENSIONS,
+  ...ANIMATION_ASSET_EXTENSIONS,
+  ...COLLECTION_REFERENCE_EXTENSIONS
+];
+var PROJECT_EXTENSIONS = [".project"];
+var GAME_PROJECT_DOCUMENT = "game.project";
+function displayPathOf(projectRoot, filePath) {
+  const path = filePath.replace(/\\/g, "/");
+  const root = projectRoot.replace(/\\/g, "/").replace(/\/+$/, "");
+  return path.startsWith(`${root}/`) ? path.slice(root.length + 1) : path;
 }
-function isThisParameter2(param) {
-  return ts2.isIdentifier(param.name) && ts2.identifierToKeywordKind(param.name) === ts2.SyntaxKind.ThisKeyword;
+function isBuildOutput(displayPath) {
+  return displayPath.split("/").includes("build");
 }
-function hookName(property) {
-  const name = property.name;
-  if (name === undefined) {
-    return;
-  }
-  if (ts2.isIdentifier(name) || ts2.isStringLiteral(name)) {
-    return name.text;
-  }
-  return;
+function isExcludedProjectPath(displayPath) {
+  return isBuildOutput(displayPath) || isDefignoredPath(displayPath);
 }
-function hookFunction(property) {
-  if (ts2.isMethodDeclaration(property) && property.body !== undefined) {
-    return property;
+function readSceneDocuments(host, projectRoot, extensions = SCENE_EXTENSIONS) {
+  const documents = new Map;
+  const origins = new Map;
+  const unreadable = [];
+  const paths = [];
+  if (!host.readDirectory) {
+    unreadable.push("the editor host cannot enumerate project files, so no scene source was read");
+    return { documents, origins, unreadable, paths };
   }
-  if (ts2.isPropertyAssignment(property)) {
-    const initializer = property.initializer;
-    if (ts2.isFunctionExpression(initializer) || ts2.isArrowFunction(initializer)) {
-      return initializer;
+  for (const filePath of host.readDirectory(projectRoot, extensions)) {
+    const displayPath = displayPathOf(projectRoot, filePath);
+    if (isExcludedProjectPath(displayPath))
+      continue;
+    const text = host.readFile(filePath);
+    if (text === undefined) {
+      unreadable.push(`${displayPath}: could not be read`);
+      continue;
     }
+    documents.set(displayPath, text);
+    paths.push(filePath);
   }
-  return;
-}
-function dispatcherInitializer(property, checker) {
-  if (!ts2.isPropertyAssignment(property)) {
-    return;
-  }
-  const initializer = property.initializer;
-  if (!ts2.isCallExpression(initializer)) {
-    return;
+  const library = readLibrarySceneDocuments(host, projectRoot, extensions);
+  unreadable.push(...library.unreadable);
+  for (const { displayPath, hostPath, url, text } of library.documents) {
+    if (documents.has(displayPath)) {
+      unreadable.push(`${displayPath}: also declared by ${url}; the project's own file is used`);
+      continue;
+    }
+    documents.set(displayPath, text);
+    origins.set(displayPath, url);
+    paths.push(hostPath);
   }
-  return resolvesToDispatchExport(initializer.expression, checker) ? initializer : undefined;
+  return { documents, origins, unreadable, paths };
 }
-function transformHookBody(fn, context) {
-  if (ts2.isBlock(fn.body)) {
-    return context.transformStatements(fn.body.statements);
+function listProjectResourcePaths(host, projectRoot, extensions) {
+  if (!host.readDirectory)
+    return new Set;
+  const paths = [];
+  for (const filePath of host.readDirectory(projectRoot, extensions)) {
+    const displayPath = displayPathOf(projectRoot, filePath);
+    if (isExcludedProjectPath(displayPath))
+      continue;
+    if (!extensions.some((extension) => displayPath.endsWith(extension)))
+      continue;
+    paths.push(`/${displayPath}`);
   }
-  return [createExpressionStatement(context.transformExpression(fn.body))];
+  return new Set(paths.sort());
+}
+
+// src/library-dependencies.ts
+function isProjectHeader(line) {
+  return line.trim() === "[project]";
 }
-function crossesFunctionBoundary(node) {
-  return ts2.isFunctionDeclaration(node) || ts2.isFunctionExpression(node) || ts2.isArrowFunction(node) || ts2.isMethodDeclaration(node) || ts2.isGetAccessorDeclaration(node) || ts2.isSetAccessorDeclaration(node);
+function isSectionHeader(line) {
+  return /^\[.+\]\s*$/.test(line.trim());
 }
-function initReturnsValue(fn) {
-  if (!ts2.isBlock(fn.body)) {
-    return true;
+function readGameProjectDependencies(gameProjectText) {
+  const lines = gameProjectText.split(`
+`);
+  const deps = [];
+  let inProject = false;
+  for (const line of lines) {
+    if (isSectionHeader(line)) {
+      inProject = isProjectHeader(line);
+      continue;
+    }
+    if (!inProject) {
+      continue;
+    }
+    const match = line.match(/^dependencies#(\d+)\s*=\s*(.+)$/);
+    if (match?.[1] !== undefined && match[2] !== undefined) {
+      deps.push({ index: Number(match[1]), url: match[2] });
+    }
   }
-  let found = false;
-  const visit = (node) => {
-    if (found || crossesFunctionBoundary(node)) {
+  return deps;
+}
+function archiveWrapperOf(entries) {
+  let wrapper;
+  for (const entry of entries) {
+    const separator = entry.indexOf("/");
+    if (separator <= 0) {
       return;
     }
-    if (ts2.isReturnStatement(node) && node.expression !== undefined) {
-      found = true;
+    const segment = entry.slice(0, separator);
+    if (wrapper === undefined) {
+      wrapper = segment;
+    } else if (wrapper !== segment) {
       return;
     }
-    ts2.forEachChild(node, visit);
-  };
-  ts2.forEachChild(fn.body, visit);
-  return found;
+  }
+  return wrapper;
 }
-function initBuilderBody(fn, context) {
-  if (ts2.isBlock(fn.body)) {
-    return context.transformStatements(fn.body.statements);
+function readLibraryIncludeDirs(gameProjectText) {
+  let inLibrary = false;
+  for (const line of gameProjectText.split(`
+`)) {
+    if (isSectionHeader(line)) {
+      inLibrary = line.trim() === "[library]";
+      continue;
+    }
+    if (!inLibrary) {
+      continue;
+    }
+    const match = line.match(/^include_dirs\s*=\s*(.*)$/);
+    if (match?.[1] !== undefined) {
+      return match[1].split(",").map((dir) => dir.trim()).filter((dir) => dir.length > 0);
+    }
   }
-  return [createReturnStatement([context.transformExpression(fn.body)])];
+  return [];
 }
-function emitInitMerge(fn, context, property) {
-  const authorParam = fn.parameters.find((param) => !isThisParameter2(param) && ts2.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);
-  const builderArgs = authorParam === undefined ? [] : [createIdentifier2("self")];
-  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 initFn = createFunctionExpression2(createBlock2([stateDecl, guard]), [createIdentifier2("self")], undefined, NodeFlags2.Declaration, fn);
-  return [builderDecl, createAssignmentStatement(createIdentifier2("init"), initFn, property)];
+function isContainedResourcePath(path) {
+  if (path.length === 0 || path.includes("\\")) {
+    return false;
+  }
+  return path.split("/").every((segment) => segment.length > 0 && segment !== "." && segment !== "..");
 }
-function emitPropertyRegistrations(property, context) {
-  if (!ts2.isPropertyAssignment(property) || !ts2.isObjectLiteralExpression(property.initializer)) {
-    return [];
+function libraryIncludedEntries(entries, gameProjectText) {
+  if (gameProjectText === undefined) {
+    return {
+      shared: [],
+      reasons: ["ships no game.project, so it declares no [library] include_dirs"],
+      refused: []
+    };
   }
-  const registrations = [];
-  for (const member of property.initializer.properties) {
-    if (!ts2.isPropertyAssignment(member)) {
+  const includeDirs = new Set(readLibraryIncludeDirs(gameProjectText));
+  if (includeDirs.size === 0) {
+    return {
+      shared: [],
+      reasons: ["its game.project declares no [library] include_dirs"],
+      refused: []
+    };
+  }
+  const wrapper = archiveWrapperOf(entries);
+  const shared = [];
+  const refused = [];
+  for (const entry of entries) {
+    const path = wrapper === undefined ? entry : entry.slice(wrapper.length + 1);
+    const [head] = path.split("/");
+    if (head === undefined || !includeDirs.has(head)) {
       continue;
     }
-    const key = member.name;
-    if (!ts2.isIdentifier(key) && !ts2.isStringLiteral(key)) {
+    const dot = path.lastIndexOf(".");
+    if (dot === -1 || !LIBRARY_SCENE_EXTENSIONS.includes(path.slice(dot).toLowerCase())) {
       continue;
     }
-    registrations.push(createExpressionStatement(createCallExpression2(createTableIndexExpression(createIdentifier2("go"), createStringLiteral2("property")), [createStringLiteral2(key.text), context.transformExpression(member.initializer)])));
+    if (!isContainedResourcePath(path)) {
+      refused.push(entry);
+      continue;
+    }
+    shared.push({ entry, path });
   }
-  return registrations;
+  shared.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+  return { shared, reasons: [], refused };
 }
-function eraseFactoryCall(expression, context) {
-  if (!ts2.isCallExpression(expression)) {
+var LIBRARY_DEPENDENCY_ROOT = ".defold-types/dependencies";
+var LIBRARY_DEPENDENCY_MANIFEST = `${LIBRARY_DEPENDENCY_ROOT}/dependencies.json`;
+function joinProject(projectRoot, relative) {
+  return `${projectRoot.replace(/\\/g, "/").replace(/\/+$/, "")}/${relative}`;
+}
+function readMaterializedKeys(manifestText) {
+  let parsed;
+  try {
+    parsed = JSON.parse(manifestText);
+  } catch {
     return;
   }
-  if (!resolvesToFactoryExport(expression.expression, context.checker)) {
+  const entries = parsed?.dependencies;
+  if (!Array.isArray(entries))
     return;
+  const keyByUrl = new Map;
+  for (const entry of entries) {
+    const { key, url } = entry ?? {};
+    if (typeof key === "string" && typeof url === "string")
+      keyByUrl.set(url, key);
   }
-  const hooks = expression.arguments[0];
-  if (hooks === undefined || !ts2.isObjectLiteralExpression(hooks)) {
-    return;
+  return keyByUrl;
+}
+function readLibrarySceneDocuments(host, projectRoot, extensions = LIBRARY_SCENE_EXTENSIONS) {
+  const documents = [];
+  const unreadable = [];
+  if (!host.readDirectory)
+    return { documents, unreadable };
+  const gameProjectText = host.readFile(joinProject(projectRoot, GAME_PROJECT_DOCUMENT));
+  if (gameProjectText === undefined)
+    return { documents, unreadable };
+  const declared = [...readGameProjectDependencies(gameProjectText)].sort((a, b) => a.index - b.index);
+  if (declared.length === 0)
+    return { documents, unreadable };
+  const manifestText = host.readFile(joinProject(projectRoot, LIBRARY_DEPENDENCY_MANIFEST));
+  if (manifestText === undefined) {
+    for (const { url } of declared) {
+      unreadable.push(`${url}: is declared by game.project but ${LIBRARY_DEPENDENCY_MANIFEST} is absent`);
+    }
+    return { documents, unreadable };
   }
-  const registrations = [];
-  const statements = [];
-  for (const property of hooks.properties) {
-    const name = hookName(property);
-    if (name === undefined) {
-      continue;
+  const keyByUrl = readMaterializedKeys(manifestText);
+  if (keyByUrl === undefined) {
+    for (const { url } of declared) {
+      unreadable.push(`${url}: is declared by game.project but ${LIBRARY_DEPENDENCY_MANIFEST} is not a readable dependency manifest`);
     }
-    if (name === "properties") {
-      registrations.push(...emitPropertyRegistrations(property, context));
+    return { documents, unreadable };
+  }
+  const resolved = [];
+  const urlByKey = new Map;
+  for (const { url } of declared) {
+    const key = keyByUrl.get(url);
+    if (key === undefined) {
+      unreadable.push(`${url}: is declared by game.project but was not materialized by the last resolve`);
       continue;
     }
-    const fn = hookFunction(property);
-    if (fn === undefined) {
-      const dispatch = dispatcherInitializer(property, context.checker);
-      if (dispatch !== undefined) {
-        statements.push(createAssignmentStatement(createIdentifier2(name), context.transformExpression(dispatch), property));
-      }
+    resolved.push({ key, url });
+    urlByKey.set(key, url);
+  }
+  const root = joinProject(projectRoot, LIBRARY_DEPENDENCY_ROOT);
+  const filesByKey = new Map;
+  const stray = new Set;
+  for (const filePath of host.readDirectory(root, extensions)) {
+    const relative = displayPathOf(root, filePath);
+    if (relative === filePath.replace(/\\/g, "/"))
       continue;
-    }
-    if (name === "init" && initReturnsValue(fn)) {
-      statements.push(...emitInitMerge(fn, context, property));
+    const separator = relative.indexOf("/");
+    if (separator <= 0)
+      continue;
+    const key = relative.slice(0, separator);
+    const url = urlByKey.get(key);
+    if (url === undefined) {
+      stray.add(key);
       continue;
     }
-    const params = fn.parameters.filter((param) => !isThisParameter2(param) && ts2.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)) {
-    return false;
-  }
-  const clause = node.importClause;
-  if (clause === undefined || clause.name !== undefined) {
-    return false;
-  }
-  if (clause.isTypeOnly) {
-    return false;
+    const bucket = filesByKey.get(key);
+    if (bucket === undefined)
+      filesByKey.set(key, [filePath]);
+    else
+      bucket.push(filePath);
   }
-  const bindings = clause.namedBindings;
-  if (bindings === undefined || !ts2.isNamedImports(bindings)) {
-    return false;
+  const claimed = new Map;
+  for (const { key, url } of resolved) {
+    for (const hostPath of (filesByKey.get(key) ?? []).sort()) {
+      const displayPath = displayPathOf(root, hostPath).slice(key.length + 1);
+      if (displayPath === "")
+        continue;
+      const owner = claimed.get(displayPath);
+      if (owner !== undefined) {
+        unreadable.push(`${displayPath}: also declared by ${url}; ${owner}'s file is used`);
+        continue;
+      }
+      const text = host.readFile(hostPath);
+      if (text === undefined) {
+        unreadable.push(`${displayPath}: could not be read from ${url}`);
+        continue;
+      }
+      claimed.set(displayPath, url);
+      documents.push({ displayPath, hostPath, url, text });
+    }
   }
-  const runtime = bindings.elements.filter((element) => !element.isTypeOnly);
-  if (runtime.length === 0) {
-    return false;
+  for (const key of [...stray].sort()) {
+    unreadable.push(`${LIBRARY_DEPENDENCY_ROOT}/${key}: is materialized but no longer declared by game.project, so its scenes are left out`);
   }
-  return runtime.every((element) => FACTORY_NAMES.has((element.propertyName ?? element.name).text));
+  return { documents, unreadable };
 }
-var lifecycleErasurePlugin = {
-  visitors: {
-    [ts2.SyntaxKind.ExpressionStatement]: (node, context) => eraseFactoryCall(node.expression, context) ?? context.superTransformStatements(node),
-    [ts2.SyntaxKind.ExportAssignment]: (node, context) => {
-      if (!node.isExportEquals) {
-        const erased = eraseFactoryCall(node.expression, context);
-        if (erased !== undefined) {
-          return erased;
-        }
-      }
-      return context.superTransformStatements(node);
-    },
-    [ts2.SyntaxKind.ImportDeclaration]: (node, context) => isFactoryOnlyImport(node) ? [] : context.superTransformStatements(node)
-  }
-};
-
 // src/main-entry-factory-imports.ts
+import * as ts4 from "typescript";
 function findMainEntryFactoryImports(fileName, source) {
-  const sourceFile = ts3.createSourceFile(fileName, source, ts3.ScriptTarget.Latest, true);
+  const sourceFile = ts4.createSourceFile(fileName, source, ts4.ScriptTarget.Latest, true);
   const factories = [];
   for (const statement of sourceFile.statements) {
-    if (!ts3.isImportDeclaration(statement)) {
+    if (!ts4.isImportDeclaration(statement)) {
       continue;
     }
     const specifier = statement.moduleSpecifier;
-    if (!ts3.isStringLiteral(specifier) || specifier.text !== FACTORY_MODULE) {
+    if (!ts4.isStringLiteral(specifier) || specifier.text !== FACTORY_MODULE) {
       continue;
     }
     const bindings = statement.importClause?.namedBindings;
-    if (bindings === undefined || !ts3.isNamedImports(bindings)) {
+    if (bindings === undefined || !ts4.isNamedImports(bindings)) {
       continue;
     }
     for (const element of bindings.elements) {
@@ -1381,6 +2002,15 @@ function relUnderOutDir(rel, config) {
   const relUnderBase = rel.slice(includeBase.length);
   return path.posix.join(outDir, relUnderBase);
 }
+function requirePathForRel(rel) {
+  const segments = rel.split("/").filter((segment) => segment !== "" && segment !== "." && segment !== "..");
+  const last = segments.length - 1;
+  const lastSegment = segments[last];
+  if (lastSegment !== undefined) {
+    segments[last] = lastSegment.replace(/\.[^.]*$/, "");
+  }
+  return segments.map((segment) => segment.replace(/\./g, "_")).join(".");
+}
 function computeOutputRel(rel, config, kind) {
   const baseRel = relUnderOutDir(rel, config);
   if (kind === "module") {
@@ -1389,16 +2019,16 @@ function computeOutputRel(rel, config, kind) {
   return baseRel.replace(/\.ts$/, SCRIPT_SUFFIX_BY_KIND[kind]);
 }
 // src/program-diagnostics.ts
-import * as ts7 from "typescript";
+import * as ts8 from "typescript";
 import * as tstl from "typescript-to-lua";
 
 // src/message-guard-lowering.ts
-import * as ts4 from "typescript";
+import * as ts5 from "typescript";
 import {
   createBinaryExpression as createBinaryExpression3,
   createCallExpression as createCallExpression3,
   createIdentifier as createIdentifier3,
-  SyntaxKind as SyntaxKind6
+  SyntaxKind as SyntaxKind7
 } from "typescript-to-lua";
 var GUARD_MODULE = "@defold-typescript/types";
 var GUARD_NAME = "isMessage";
@@ -1407,7 +2037,7 @@ function resolvesToGuardExport(callee, checker) {
   if (symbol === undefined) {
     return false;
   }
-  if (symbol.flags & ts4.SymbolFlags.Alias) {
+  if (symbol.flags & ts5.SymbolFlags.Alias) {
     symbol = checker.getAliasedSymbol(symbol);
   }
   if (symbol.getName() !== GUARD_NAME) {
@@ -1421,12 +2051,12 @@ function resolvesToGuardExport(callee, checker) {
 }
 var messageGuardLoweringPlugin = {
   visitors: {
-    [ts4.SyntaxKind.CallExpression]: (node, context) => {
+    [ts5.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]), SyntaxKind6.EqualityOperator, node);
+        return createBinaryExpression3(messageId, createCallExpression3(createIdentifier3("hash"), [expected]), SyntaxKind7.EqualityOperator, node);
       }
       return context.superTransformExpression(node);
     }
@@ -1434,77 +2064,34 @@ var messageGuardLoweringPlugin = {
 };
 
 // src/timers-lowering.ts
-import * as ts5 from "typescript";
-
-// src/timers-runtime.ts
-var TIMERS_MODULE_SPECIFIER = "@defold-typescript/types/timers";
-var TIMERS_REQUIRE_NAME = "defold_typescript_timers";
-var TIMERS_RUNTIME = `local ____lualib = require("lualib_bundle")
-local __TS__Promise = ____lualib.__TS__Promise
-local __TS__New = ____lualib.__TS__New
-
-local function setTimeout(callback, delayMs)
-    return timer.delay(delayMs / 1000, false, function()
-        callback()
-    end)
-end
-
-local function setInterval(callback, delayMs)
-    return timer.delay(delayMs / 1000, true, function()
-        callback()
-    end)
-end
-
-local function clearTimeout(handle)
-    timer.cancel(handle)
-end
-
-local function clearInterval(handle)
-    timer.cancel(handle)
-end
-
-local function wait(seconds)
-    return __TS__New(__TS__Promise, function(_, resolve)
-        timer.delay(seconds, false, function()
-            resolve()
-        end)
-    end)
-end
-
-return {
-    setTimeout = setTimeout,
-    setInterval = setInterval,
-    clearTimeout = clearTimeout,
-    clearInterval = clearInterval,
-    wait = wait,
-}
-`;
-
-// src/timers-lowering.ts
+import * as ts6 from "typescript";
+import { LuaLibFeature } from "typescript-to-lua";
 function isTimersSpecifier(node) {
-  return ts5.isStringLiteral(node) && node.text === TIMERS_MODULE_SPECIFIER;
+  return ts6.isStringLiteral(node) && node.text === TIMERS_MODULE_SPECIFIER;
 }
 function importsTimersModule(sourceFile) {
-  return sourceFile.statements.some((statement) => ts5.isImportDeclaration(statement) && isTimersSpecifier(statement.moduleSpecifier));
+  return sourceFile.statements.some((statement) => ts6.isImportDeclaration(statement) && isTimersSpecifier(statement.moduleSpecifier));
 }
 var TIMERS_REQUIRE_PATH = `@NoResolution:${TIMERS_REQUIRE_NAME}`;
 var timersLoweringPlugin = {
   visitors: {
-    [ts5.SyntaxKind.ImportDeclaration]: (node, context) => {
+    [ts6.SyntaxKind.ImportDeclaration]: (node, context) => {
       if (!isTimersSpecifier(node.moduleSpecifier)) {
         return context.superTransformStatements(node);
       }
-      const rewritten = ts5.factory.updateImportDeclaration(node, node.modifiers, node.importClause, ts5.factory.createStringLiteral(TIMERS_REQUIRE_PATH), node.attributes);
+      context.usedLuaLibFeatures.add(LuaLibFeature.Promise);
+      context.usedLuaLibFeatures.add(LuaLibFeature.New);
+      const rewritten = ts6.factory.updateImportDeclaration(node, node.modifiers, node.importClause, ts6.factory.createStringLiteral(TIMERS_REQUIRE_PATH), node.attributes);
       return context.superTransformStatements(rewritten);
     }
   }
 };
 
 // src/window-event-guard-lowering.ts
-import * as ts6 from "typescript";
+import * as ts7 from "typescript";
 import {
   createBinaryExpression as createBinaryExpression4,
-  SyntaxKind as SyntaxKind9
+  SyntaxKind as SyntaxKind10
 } from "typescript-to-lua";
 var GUARD_MODULE2 = "@defold-typescript/types";
 var GUARD_NAME2 = "isWindowEvent";
@@ -1513,7 +2100,7 @@ function resolvesToGuardExport2(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_NAME2) {
@@ -1527,12 +2114,12 @@ function resolvesToGuardExport2(callee, checker) {
 }
 var windowEventGuardLoweringPlugin = {
   visitors: {
-    [ts6.SyntaxKind.CallExpression]: (node, context) => {
+    [ts7.SyntaxKind.CallExpression]: (node, context) => {
       const [eventArg, , expectedArg] = node.arguments;
       if (node.arguments.length === 3 && eventArg !== undefined && expectedArg !== undefined && resolvesToGuardExport2(node.expression, context.checker)) {
         const event = context.transformExpression(eventArg);
         const expected = context.transformExpression(expectedArg);
-        return createBinaryExpression4(event, expected, SyntaxKind9.EqualityOperator, node);
+        return createBinaryExpression4(event, expected, SyntaxKind10.EqualityOperator, node);
       }
       return context.superTransformExpression(node);
     }
@@ -1552,13 +2139,33 @@ function isAmbient(fileName) {
   return /[\\/]node_modules[\\/]/.test(fileName) || /(^|[\\/])lib\.[^\\/]*\.d\.ts$/.test(fileName);
 }
 function getProgramDiagnostics(program, sourceFile) {
-  const { diagnostics } = tstl.getProgramTranspileResult(ts7.sys, noopWriteFile, {
+  const { diagnostics } = tstl.getProgramTranspileResult(ts8.sys, noopWriteFile, {
     program,
     plugins: LUA_PLUGINS,
     ...sourceFile ? { sourceFiles: [sourceFile] } : {}
   });
   return diagnostics.filter((d) => d.file !== undefined && !isAmbient(d.file.fileName));
 }
+// src/require-rewrite.ts
+function quote(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+}
+function rewriteEmittedRequires(lua, rewrites) {
+  if (rewrites.size === 0) {
+    return lua;
+  }
+  let out = "";
+  let cursor = 0;
+  for (const { path, start, end } of scanEmittedRequires(lua)) {
+    const mapped = rewrites.get(path);
+    if (mapped === undefined) {
+      continue;
+    }
+    out += lua.slice(cursor, start) + quote(mapped);
+    cursor = end;
+  }
+  return cursor === 0 ? lua : out + lua.slice(cursor);
+}
 // src/scene-component-index.ts
 var COMPONENT_BLOCKS = new Set(["components", "embedded_components"]);
 var EMBEDDING_BLOCKS = new Set(["embedded_instances", "embedded_components"]);
@@ -2052,13 +2659,441 @@ function relativeAddressesFrom(index, context) {
 import { readFileSync as readFileSync2 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 import * as path3 from "node:path";
-import * as ts10 from "typescript";
+import * as ts12 from "typescript";
 import * as tstl3 from "typescript-to-lua";
 
+// src/companion-emit.ts
+import * as ts9 from "typescript";
+import {
+  createAssignmentStatement as createAssignmentStatement2,
+  createCallExpression as createCallExpression4,
+  createFile,
+  createIdentifier as createIdentifier4,
+  createReturnStatement as createReturnStatement2,
+  createStringLiteral as createStringLiteral3,
+  createTableExpression,
+  createTableFieldExpression,
+  createTableIndexExpression as createTableIndexExpression2,
+  createVariableDeclarationStatement as createVariableDeclarationStatement3,
+  isBlock as isBlock3,
+  isCallExpression as isCallExpression4,
+  isDoStatement,
+  isForInStatement as isForInStatement2,
+  isForStatement,
+  isFunctionDefinition,
+  isFunctionExpression as isFunctionExpression4,
+  isIdentifier as isIdentifier4,
+  isMethodCallExpression,
+  isRepeatStatement,
+  isReturnStatement as isReturnStatement2,
+  isStringLiteral as isStringLiteral6,
+  isTableExpression,
+  isVariableDeclarationStatement,
+  LuaPrinter
+} from "typescript-to-lua";
+var EXPORTS_NAME = "____exports";
+function exportsIdentifier() {
+  return createIdentifier4(EXPORTS_NAME);
+}
+function isRuntimeScriptSource(sourceFile, checker) {
+  return sourceFile.statements.some((statement) => {
+    const expression = ts9.isExpressionStatement(statement) ? statement.expression : ts9.isExportAssignment(statement) && !statement.isExportEquals ? statement.expression : undefined;
+    return expression !== undefined && ts9.isCallExpression(expression) && resolvesToFactoryExport(expression.expression, checker);
+  });
+}
+function planFor(sourceFile, checker) {
+  if (sourceFile.isDeclarationFile || !isRuntimeScriptSource(sourceFile, checker)) {
+    return;
+  }
+  const closure = computeCompanionClosure(sourceFile, checker);
+  if (closure.statements.length === 0 || closure.violations.length > 0) {
+    return;
+  }
+  return {
+    closureStarts: new Set(closure.statements.map((statement) => statement.pos)),
+    internals: closure.internals,
+    importBindings: closure.importBindings,
+    requirePath: requirePathForRel(sourceFile.fileName)
+  };
+}
+function isLuaNode(value) {
+  return typeof value === "object" && value !== null && typeof value.kind === "number";
+}
+function forEachLuaNode(root, visit) {
+  visit(root);
+  for (const value of Object.values(root)) {
+    if (Array.isArray(value)) {
+      for (const element of value) {
+        if (isLuaNode(element)) {
+          forEachLuaNode(element, visit);
+        }
+      }
+    } else if (isLuaNode(value)) {
+      forEachLuaNode(value, visit);
+    }
+  }
+}
+function declaredNames(statement) {
+  return isVariableDeclarationStatement(statement) ? statement.left.map((name) => name.text) : [];
+}
+function freeNames(statements) {
+  const free = new Set;
+  const scopes = [new Set];
+  function declare(name) {
+    scopes[scopes.length - 1]?.add(name);
+  }
+  function isBound(name) {
+    return scopes.some((scope) => scope.has(name));
+  }
+  function inScope(run) {
+    scopes.push(new Set);
+    run();
+    scopes.pop();
+  }
+  function visitEach(nodes) {
+    for (const node of nodes ?? []) {
+      visit(node);
+    }
+  }
+  function visit(node) {
+    if (node === undefined) {
+      return;
+    }
+    if (isIdentifier4(node)) {
+      if (!isBound(node.text)) {
+        free.add(node.text);
+      }
+      return;
+    }
+    if (isVariableDeclarationStatement(node)) {
+      if (isFunctionDefinition(node)) {
+        const [name] = node.left;
+        if (name !== undefined) {
+          declare(name.text);
+        }
+        visit(node.right[0]);
+        return;
+      }
+      visitEach(node.right);
+      for (const name of node.left) {
+        declare(name.text);
+      }
+      return;
+    }
+    if (isFunctionExpression4(node)) {
+      inScope(() => {
+        for (const param of node.params ?? []) {
+          declare(param.text);
+        }
+        visit(node.body);
+      });
+      return;
+    }
+    if (isForStatement(node)) {
+      visit(node.controlVariableInitializer);
+      visit(node.limitExpression);
+      visit(node.stepExpression);
+      inScope(() => {
+        declare(node.controlVariable.text);
+        visit(node.body);
+      });
+      return;
+    }
+    if (isForInStatement2(node)) {
+      visitEach(node.expressions);
+      inScope(() => {
+        for (const name of node.names) {
+          declare(name.text);
+        }
+        visit(node.body);
+      });
+      return;
+    }
+    if (isRepeatStatement(node)) {
+      inScope(() => {
+        visitEach(node.body.statements);
+        visit(node.condition);
+      });
+      return;
+    }
+    if (isBlock3(node) || isDoStatement(node)) {
+      inScope(() => visitEach(node.statements));
+      return;
+    }
+    if (isMethodCallExpression(node)) {
+      visit(node.prefixExpression);
+      visitEach(node.params);
+      return;
+    }
+    for (const value of Object.values(node)) {
+      if (Array.isArray(value)) {
+        for (const element of value) {
+          if (isLuaNode(element)) {
+            visit(element);
+          }
+        }
+      } else if (isLuaNode(value)) {
+        visit(value);
+      }
+    }
+  }
+  for (const statement of statements) {
+    for (const name of declaredNames(statement)) {
+      declare(name);
+    }
+  }
+  for (const statement of statements) {
+    visit(statement);
+  }
+  return free;
+}
+function resolvedRequirePaths(sourceFile, checker) {
+  const paths = new Map;
+  for (const statement of sourceFile.statements) {
+    const specifier = ts9.isImportDeclaration(statement) || ts9.isExportDeclaration(statement) ? statement.moduleSpecifier : undefined;
+    if (specifier === undefined || !ts9.isStringLiteral(specifier)) {
+      continue;
+    }
+    const target = checker.getSymbolAtLocation(specifier)?.declarations?.find((declaration) => ts9.isSourceFile(declaration));
+    if (target === undefined || target.isDeclarationFile) {
+      continue;
+    }
+    paths.set(specifier.text, requirePathForRel(target.fileName));
+  }
+  return paths;
+}
+function resolveMovedRequires(statements, paths) {
+  for (const statement of statements) {
+    forEachLuaNode(statement, (node) => {
+      if (!isCallExpression4(node) || !isIdentifier4(node.expression)) {
+        return;
+      }
+      if (node.expression.text !== "require" || node.params.length !== 1) {
+        return;
+      }
+      const [argument] = node.params;
+      if (argument === undefined || !isStringLiteral6(argument)) {
+        return;
+      }
+      const resolved = paths.get(argument.value);
+      if (resolved !== undefined) {
+        argument.value = resolved;
+      }
+    });
+  }
+}
+function withResolvedRequire(statement, paths) {
+  if (!isVariableDeclarationStatement(statement) || statement.left.length !== 1) {
+    return statement;
+  }
+  const name = statement.left[0];
+  const [value] = statement.right ?? [];
+  if (name === undefined || value === undefined || !isCallExpression4(value)) {
+    return statement;
+  }
+  if (!isIdentifier4(value.expression) || value.expression.text !== "require") {
+    return statement;
+  }
+  const [argument] = value.params;
+  if (argument === undefined || !isStringLiteral6(argument)) {
+    return statement;
+  }
+  const resolved = paths.get(argument.value);
+  if (resolved === undefined) {
+    return statement;
+  }
+  return createVariableDeclarationStatement3(createIdentifier4(name.text), createCallExpression4(createIdentifier4("require"), [createStringLiteral3(resolved)]));
+}
+function copiedPrelude(halves, importBindings) {
+  const needed = new Set(importBindings);
+  for (const name of freeNames(halves.companion)) {
+    needed.add(name);
+  }
+  const alreadyCarried = new Set(halves.companion);
+  const candidates = halves.script.filter((statement) => isVariableDeclarationStatement(statement) && !alreadyCarried.has(statement));
+  const copied = new Set;
+  let grew = true;
+  while (grew) {
+    grew = false;
+    for (const statement of candidates) {
+      if (copied.has(statement) || !declaredNames(statement).some((name) => needed.has(name))) {
+        continue;
+      }
+      copied.add(statement);
+      for (const name of freeNames([statement])) {
+        needed.add(name);
+      }
+      grew = true;
+    }
+  }
+  return halves.script.filter((statement) => copied.has(statement));
+}
+function namesIdentifier(statement, names) {
+  let found = false;
+  forEachLuaNode(statement, (node) => {
+    if (isIdentifier4(node) && names.has(node.text)) {
+      found = true;
+    }
+  });
+  return found;
+}
+function isExportsTableInit(statement) {
+  if (!isVariableDeclarationStatement(statement) || statement.left.length !== 1) {
+    return false;
+  }
+  const [single] = statement.right ?? [];
+  return statement.left[0]?.text === EXPORTS_NAME && single !== undefined && isTableExpression(single);
+}
+function isExportsReturn(statement) {
+  if (!isReturnStatement2(statement) || statement.expressions.length !== 1) {
+    return false;
+  }
+  const [single] = statement.expressions;
+  return single !== undefined && isIdentifier4(single) && single.text === EXPORTS_NAME;
+}
+function isHoistedNameDeclaration(statement) {
+  return isVariableDeclarationStatement(statement) && statement.right === undefined;
+}
+function internalsField(name) {
+  return createTableIndexExpression2(createTableIndexExpression2(exportsIdentifier(), createStringLiteral3(COMPANION_INTERNAL_FIELD)), createStringLiteral3(name));
+}
+function requireInsertionPoint(script, reads) {
+  let index = 0;
+  while (index < script.length) {
+    const statement = script[index];
+    if (statement === undefined || !isVariableDeclarationStatement(statement)) {
+      break;
+    }
+    if (namesIdentifier(statement, reads)) {
+      break;
+    }
+    index++;
+  }
+  return index;
+}
+function split(statements, owned) {
+  const script = [];
+  const companion = [];
+  for (const statement of statements) {
+    if (isExportsTableInit(statement) || isExportsReturn(statement)) {
+      continue;
+    }
+    if (owned.has(statement)) {
+      companion.push(statement);
+      continue;
+    }
+    if (isHoistedNameDeclaration(statement)) {
+      companion.push(statement);
+    }
+    script.push(statement);
+  }
+  return { script, companion };
+}
+function createCompanionEmitPlugin() {
+  const plans = new Map;
+  const owned = new Map;
+  const companions = new Map;
+  function planOf(sourceFile, checker) {
+    const key = sourceFile.fileName;
+    if (!plans.has(key)) {
+      plans.set(key, planFor(sourceFile, checker));
+    }
+    return plans.get(key);
+  }
+  function capture(node, context) {
+    const statements = context.superTransformStatements(node);
+    const sourceFile = context.sourceFile;
+    const plan = planOf(sourceFile, context.checker);
+    if (plan === undefined || !plan.closureStarts.has(node.pos)) {
+      return statements;
+    }
+    let bucket = owned.get(sourceFile.fileName);
+    if (bucket === undefined) {
+      bucket = new Set;
+      owned.set(sourceFile.fileName, bucket);
+    }
+    for (const statement of statements) {
+      bucket.add(statement);
+    }
+    return statements;
+  }
+  const visitors = {
+    [ts9.SyntaxKind.VariableStatement]: capture,
+    [ts9.SyntaxKind.FunctionDeclaration]: capture,
+    [ts9.SyntaxKind.ClassDeclaration]: capture,
+    [ts9.SyntaxKind.EnumDeclaration]: capture,
+    [ts9.SyntaxKind.ExportDeclaration]: capture
+  };
+  let configuredNoResolvePaths = [];
+  const plugin = {
+    visitors,
+    beforeTransform(_program, options) {
+      configuredNoResolvePaths = options.noResolvePaths ?? [];
+    },
+    afterPrint(program, options, emitHost, result) {
+      const emitted = [];
+      for (const file of result) {
+        const sourceFile = file.sourceFiles?.[0];
+        if (sourceFile === undefined || file.luaAst === undefined) {
+          continue;
+        }
+        const plan = plans.get(sourceFile.fileName);
+        const bucket = owned.get(sourceFile.fileName);
+        if (plan === undefined || bucket === undefined || bucket.size === 0) {
+          continue;
+        }
+        emitCompanion(program, emitHost, file, sourceFile, plan, bucket, companions);
+        emitted.push(plan.requirePath);
+      }
+      if (emitted.length > 0) {
+        options.noResolvePaths = [...configuredNoResolvePaths, ...emitted];
+      }
+    }
+  };
+  return { plugin, companions };
+}
+function emitCompanion(program, emitHost, file, sourceFile, plan, owned, companions) {
+  const luaAst = file.luaAst;
+  if (luaAst === undefined) {
+    return;
+  }
+  const halves = split(luaAst.statements, owned);
+  const requirePaths = resolvedRequirePaths(sourceFile, program.getTypeChecker());
+  resolveMovedRequires(halves.companion, requirePaths);
+  const closureTable = createTableExpression(plan.internals.map((name) => createTableFieldExpression(createIdentifier4(name), createStringLiteral3(name))));
+  const companionStatements = [
+    createVariableDeclarationStatement3(exportsIdentifier(), createTableExpression()),
+    ...copiedPrelude(halves, plan.importBindings).map((statement) => withResolvedRequire(statement, requirePaths)),
+    ...halves.companion,
+    ...plan.internals.length > 0 ? [
+      createAssignmentStatement2(createTableIndexExpression2(exportsIdentifier(), createStringLiteral3(COMPANION_INTERNAL_FIELD)), closureTable)
+    ] : [],
+    createReturnStatement2([exportsIdentifier()])
+  ];
+  const reads = new Set([EXPORTS_NAME, ...plan.internals]);
+  const insertAt = requireInsertionPoint(halves.script, reads);
+  const scriptStatements = [
+    ...halves.script.slice(0, insertAt),
+    createVariableDeclarationStatement3(exportsIdentifier(), createCallExpression4(createIdentifier4("require"), [createStringLiteral3(plan.requirePath)])),
+    ...plan.internals.map((name) => createVariableDeclarationStatement3(createIdentifier4(name), internalsField(name))),
+    ...halves.script.slice(insertAt),
+    createReturnStatement2([exportsIdentifier()])
+  ];
+  const features = new Set(luaAst.luaLibFeatures);
+  const printer = new LuaPrinter(emitHost, program, sourceFile.fileName);
+  companions.set(sourceFile.fileName, printer.print(createFile(companionStatements, new Set(features), luaAst.trivia, sourceFile)).code);
+  const scriptFile = createFile(scriptStatements, features, luaAst.trivia, sourceFile);
+  const printed = new LuaPrinter(emitHost, program, sourceFile.fileName).print(scriptFile);
+  file.luaAst = scriptFile;
+  file.code = printed.code;
+  file.sourceMap = printed.sourceMap;
+  file.sourceMapNode = printed.sourceMapNode;
+}
+
 // src/editor-script-erasure.ts
-import * as ts8 from "typescript";
+import * as ts10 from "typescript";
 import {
-  createReturnStatement as createReturnStatement2
+  createReturnStatement as createReturnStatement3
 } from "typescript-to-lua";
 var EDITOR_FACTORY_MODULE = "@defold-typescript/types";
 var EDITOR_SCRIPT_FACTORY_NAME = "defineEditorScript";
@@ -2076,7 +3111,7 @@ function resolveEditorFactoryExport(callee, checker) {
   if (symbol === undefined) {
     return;
   }
-  if (symbol.flags & ts8.SymbolFlags.Alias) {
+  if (symbol.flags & ts10.SymbolFlags.Alias) {
     symbol = checker.getAliasedSymbol(symbol);
   }
   const name = symbol.getName();
@@ -2090,7 +3125,7 @@ function resolveEditorFactoryExport(callee, checker) {
   return declaration.getSourceFile().fileName.includes(EDITOR_FACTORY_MODULE) ? name : undefined;
 }
 function lowerEditorFactoryCall(expression, context) {
-  if (!ts8.isCallExpression(expression)) {
+  if (!ts10.isCallExpression(expression)) {
     return;
   }
   if (resolveEditorFactoryExport(expression.expression, context.checker) !== EDITOR_SCRIPT_FACTORY_NAME) {
@@ -2100,10 +3135,10 @@ function lowerEditorFactoryCall(expression, context) {
   if (module === undefined) {
     return;
   }
-  return [createReturnStatement2([context.transformExpression(module)])];
+  return [createReturnStatement3([context.transformExpression(module)])];
 }
 function isEditorFactoryOnlyImport(node) {
-  if (!ts8.isStringLiteral(node.moduleSpecifier) || !EDITOR_FACTORY_SPECIFIERS.has(node.moduleSpecifier.text)) {
+  if (!ts10.isStringLiteral(node.moduleSpecifier) || !EDITOR_FACTORY_SPECIFIERS.has(node.moduleSpecifier.text)) {
     return false;
   }
   const clause = node.importClause;
@@ -2114,7 +3149,7 @@ function isEditorFactoryOnlyImport(node) {
     return false;
   }
   const bindings = clause.namedBindings;
-  if (bindings === undefined || !ts8.isNamedImports(bindings)) {
+  if (bindings === undefined || !ts10.isNamedImports(bindings)) {
     return false;
   }
   const runtime = bindings.elements.filter((element) => !element.isTypeOnly);
@@ -2125,7 +3160,7 @@ function isEditorFactoryOnlyImport(node) {
 }
 var editorScriptErasurePlugin = {
   visitors: {
-    [ts8.SyntaxKind.ExportAssignment]: (node, context) => {
+    [ts10.SyntaxKind.ExportAssignment]: (node, context) => {
       if (!node.isExportEquals) {
         const lowered = lowerEditorFactoryCall(node.expression, context);
         if (lowered !== undefined) {
@@ -2134,14 +3169,14 @@ var editorScriptErasurePlugin = {
       }
       return context.superTransformStatements(node);
     },
-    [ts8.SyntaxKind.CallExpression]: (node, context) => {
+    [ts10.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);
     },
-    [ts8.SyntaxKind.ImportDeclaration]: (node, context) => isEditorFactoryOnlyImport(node) ? [] : context.superTransformStatements(node)
+    [ts10.SyntaxKind.ImportDeclaration]: (node, context) => isEditorFactoryOnlyImport(node) ? [] : context.superTransformStatements(node)
   }
 };
 
@@ -2152,17 +3187,17 @@ import * as path2 from "node:path";
 import * as tstl2 from "typescript-to-lua";
 
 // src/go-property-direct-call.ts
-import * as ts9 from "typescript";
+import * as ts11 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 (ts9.isCallExpression(node) && ts9.isPropertyAccessExpression(node.expression) && node.expression.name.text === "property" && ts9.isIdentifier(node.expression.expression) && node.expression.expression.text === "go") {
+    if (ts11.isCallExpression(node) && ts11.isPropertyAccessExpression(node.expression) && node.expression.name.text === "property" && ts11.isIdentifier(node.expression.expression) && node.expression.expression.text === "go") {
       calls.push(node);
     }
-    ts9.forEachChild(node, visit);
+    ts11.forEachChild(node, visit);
   };
-  ts9.forEachChild(sourceFile, visit);
+  ts11.forEachChild(sourceFile, visit);
   return calls;
 }
 
@@ -2261,9 +3296,10 @@ var LUALIB_BUNDLE_NAME = "lualib_bundle.lua";
 function isLualibBundle(file) {
   return file.sourceFiles.length === 0 && file.outPath.endsWith(LUALIB_BUNDLE_NAME);
 }
-function collectOutputs(transpiledFiles, diagnostics, userKeys) {
+function collectOutputs(transpiledFiles, diagnostics, userKeys, emittedCompanions = new Map) {
   const lua = {};
   const sourceMaps = {};
+  const companions = {};
   let lualib;
   for (const file of transpiledFiles) {
     if (isLualibBundle(file) && typeof file.lua === "string") {
@@ -2278,6 +3314,10 @@ function collectOutputs(transpiledFiles, diagnostics, userKeys) {
     if (typeof file.luaSourceMap === "string") {
       sourceMaps[userSource.fileName] = file.luaSourceMap;
     }
+    const companion = emittedCompanions.get(userSource.fileName);
+    if (companion !== undefined) {
+      companions[userSource.fileName] = companion;
+    }
   }
   const collectedDiagnostics = diagnostics.map((d) => {
     const fileName = d.file?.fileName;
@@ -2315,6 +3355,7 @@ function collectOutputs(transpiledFiles, diagnostics, userKeys) {
     lua,
     sourceMaps,
     diagnostics: collectedDiagnostics,
+    ...Object.keys(companions).length > 0 ? { companions } : {},
     ...lualib !== undefined ? { lualib } : {},
     ...timersImported ? { timersRuntime: TIMERS_RUNTIME } : {}
   };
@@ -2322,6 +3363,7 @@ function collectOutputs(transpiledFiles, diagnostics, userKeys) {
 function transpileProject(input) {
   const userKeys = new Set(Object.keys(input.files));
   const merged = { ...AMBIENT_FILES, ...input.files };
+  const companionEmit = createCompanionEmitPlugin();
   const result = tstl2.transpileVirtualProject(merged, {
     luaTarget: tstl2.LuaTarget.Lua51,
     sourceMap: true,
@@ -2334,10 +3376,11 @@ function transpileProject(input) {
       { plugin: messageGuardLoweringPlugin },
       { plugin: windowEventGuardLoweringPlugin },
       { plugin: messageDispatchLoweringPlugin },
-      { plugin: timersLoweringPlugin }
+      { plugin: timersLoweringPlugin },
+      { plugin: companionEmit.plugin }
     ]
   });
-  return collectOutputs(result.transpiledFiles, result.diagnostics, userKeys);
+  return collectOutputs(result.transpiledFiles, result.diagnostics, userKeys, companionEmit.companions);
 }
 function transpile(source) {
   const project = transpileProject({ files: { "main.ts": source } });
@@ -2350,21 +3393,24 @@ function transpile(source) {
 
 // src/session.ts
 var requireFromHere2 = createRequire2(import.meta.url);
-var COMPILER_OPTIONS = {
-  luaTarget: tstl3.LuaTarget.Lua51,
-  sourceMap: true,
-  lib: ["lib.es2022.d.ts"],
-  skipLibCheck: true,
-  noImplicitSelf: true,
-  luaPlugins: [
-    { plugin: lifecycleErasurePlugin },
-    { plugin: editorScriptErasurePlugin },
-    { plugin: messageGuardLoweringPlugin },
-    { plugin: windowEventGuardLoweringPlugin },
-    { plugin: messageDispatchLoweringPlugin },
-    { plugin: timersLoweringPlugin }
-  ]
-};
+function compilerOptions(companionEmit) {
+  return {
+    luaTarget: tstl3.LuaTarget.Lua51,
+    sourceMap: true,
+    lib: ["lib.es2022.d.ts"],
+    skipLibCheck: true,
+    noImplicitSelf: true,
+    luaPlugins: [
+      { plugin: lifecycleErasurePlugin },
+      { plugin: editorScriptErasurePlugin },
+      { plugin: messageGuardLoweringPlugin },
+      { plugin: windowEventGuardLoweringPlugin },
+      { plugin: messageDispatchLoweringPlugin },
+      { plugin: timersLoweringPlugin },
+      { plugin: companionEmit.plugin }
+    ]
+  };
+}
 function normalizeSlashes(p) {
   return p.replace(/\\/g, "/");
 }
@@ -2403,7 +3449,7 @@ function createTranspileSession() {
       if (cached) {
         return cached;
       }
-      const created = ts10.createSourceFile(fileName, content, ts10.ScriptTarget.Latest, false);
+      const created = ts12.createSourceFile(fileName, content, ts12.ScriptTarget.Latest, false);
       sourceFileCache.set(normalized, created);
       return created;
     }
@@ -2422,7 +3468,7 @@ function createTranspileSession() {
         return cached;
       }
       const fileContent = readFileSync2(filePath, "utf8");
-      const created = ts10.createSourceFile(filePath, fileContent, ts10.ScriptTarget.Latest, false);
+      const created = ts12.createSourceFile(filePath, fileContent, ts12.ScriptTarget.Latest, false);
       libCache.set(fileName, created);
       return created;
     }
@@ -2435,10 +3481,10 @@ function createTranspileSession() {
     return AMBIENT_FILES[normalized];
   }
   const host = {
-    fileExists: (fileName) => mergedContent(normalizeSlashes(fileName)) !== undefined || ts10.sys.fileExists(fileName),
+    fileExists: (fileName) => mergedContent(normalizeSlashes(fileName)) !== undefined || ts12.sys.fileExists(fileName),
     getCanonicalFileName: (fileName) => fileName,
     getCurrentDirectory: () => "",
-    getDefaultLibFileName: ts10.getDefaultLibFileName,
+    getDefaultLibFileName: ts12.getDefaultLibFileName,
     readFile: () => "",
     getNewLine: () => `
 `,
@@ -2459,17 +3505,18 @@ function createTranspileSession() {
     }
     const userKeys = new Set(userFiles.keys());
     const rootNames = [...Object.keys(AMBIENT_FILES).map(normalizeSlashes), ...userKeys];
-    program = ts10.createProgram(rootNames, COMPILER_OPTIONS, host, program);
-    const preEmitDiagnostics = ts10.getPreEmitDiagnostics(program);
+    const companionEmit = createCompanionEmitPlugin();
+    program = ts12.createProgram(rootNames, compilerOptions(companionEmit), host, program);
+    const preEmitDiagnostics = ts12.getPreEmitDiagnostics(program);
     const collector = createOutputCollector();
     const { diagnostics: transpileDiagnostics } = new tstl3.Transpiler().emit({
       program,
       writeFile: collector.writeFile
     });
     const diagnostics = [
-      ...ts10.sortAndDeduplicateDiagnostics([...preEmitDiagnostics, ...transpileDiagnostics])
+      ...ts12.sortAndDeduplicateDiagnostics([...preEmitDiagnostics, ...transpileDiagnostics])
     ];
-    return collectOutputs(collector.files, diagnostics, userKeys);
+    return collectOutputs(collector.files, diagnostics, userKeys, companionEmit.companions);
   }
   return {
     update,
@@ -2477,7 +3524,7 @@ function createTranspileSession() {
   };
 }
 // src/url-address-slots.ts
-import * as ts11 from "typescript";
+import * as ts13 from "typescript";
 var ADDRESS_CLASSES = {
   "game-object": true,
   component: true,
@@ -2496,7 +3543,7 @@ function isFragmentCaret(slot, position) {
   return slot.fragmentStart !== -1 && position >= slot.fragmentStart;
 }
 function tableKey(checker, callee) {
-  const symbol = checker.getSymbolAtLocation(ts11.isIdentifier(callee) ? callee : callee.name);
+  const symbol = checker.getSymbolAtLocation(ts13.isIdentifier(callee) ? callee : callee.name);
   if (!symbol)
     return;
   const fqn = checker.getFullyQualifiedName(symbol);
@@ -2504,43 +3551,43 @@ function tableKey(checker, callee) {
 }
 function parameterName(checker, call, index) {
   const declaration = checker.getResolvedSignature(call)?.declaration;
-  if (!declaration || !ts11.isFunctionLike(declaration))
+  if (!declaration || !ts13.isFunctionLike(declaration))
     return;
   const parameter = declaration.parameters[index];
-  if (!parameter || parameter.dotDotDotToken || !ts11.isIdentifier(parameter.name))
+  if (!parameter || parameter.dotDotDotToken || !ts13.isIdentifier(parameter.name))
     return;
   return parameter.name.text;
 }
 var EQUALITY_OPERATORS = new Set([
-  ts11.SyntaxKind.EqualsEqualsEqualsToken,
-  ts11.SyntaxKind.ExclamationEqualsEqualsToken,
-  ts11.SyntaxKind.EqualsEqualsToken,
-  ts11.SyntaxKind.ExclamationEqualsToken
+  ts13.SyntaxKind.EqualsEqualsEqualsToken,
+  ts13.SyntaxKind.ExclamationEqualsEqualsToken,
+  ts13.SyntaxKind.EqualsEqualsToken,
+  ts13.SyntaxKind.ExclamationEqualsToken
 ]);
 function comparisonSatisfied(checker, entry, call) {
   if (entry.comparedParameter === undefined)
     return true;
   let node = call;
-  while (ts11.isParenthesizedExpression(node.parent))
+  while (ts13.isParenthesizedExpression(node.parent))
     node = node.parent;
   const comparison = node.parent;
-  if (!ts11.isBinaryExpression(comparison))
+  if (!ts13.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) => ts11.isParameter(declaration) && ts11.isIdentifier(declaration.name) && declaration.name.text === entry.comparedParameter);
+  return (symbol?.declarations ?? []).some((declaration) => ts13.isParameter(declaration) && ts13.isIdentifier(declaration.name) && declaration.name.text === entry.comparedParameter);
 }
 function classifiedEntryOfArgument(checker, table, argument) {
   const call = argument.parent;
-  if (!ts11.isCallExpression(call))
+  if (!ts13.isCallExpression(call))
     return;
   const argumentIndex = call.arguments.indexOf(argument);
   if (argumentIndex === -1)
     return;
   const callee = call.expression;
-  if (!ts11.isPropertyAccessExpression(callee) && !ts11.isIdentifier(callee))
+  if (!ts13.isPropertyAccessExpression(callee) && !ts13.isIdentifier(callee))
     return;
   const fqn = tableKey(checker, callee);
   if (fqn === undefined)
@@ -2557,10 +3604,10 @@ function classifiedEntryOfArgument(checker, table, argument) {
 }
 function slotThroughHashedCall(checker, table, literal) {
   const call = literal.parent;
-  if (!ts11.isCallExpression(call))
+  if (!ts13.isCallExpression(call))
     return;
   const callee = call.expression;
-  if (!ts11.isPropertyAccessExpression(callee) && !ts11.isIdentifier(callee))
+  if (!ts13.isPropertyAccessExpression(callee) && !ts13.isIdentifier(callee))
     return;
   if (tableKey(checker, callee) !== "hash")
     return;
@@ -2578,24 +3625,24 @@ function addressTextOf(checker, entry, call) {
   if (entry.addressParameter === undefined)
     return;
   const declaration = checker.getResolvedSignature(call)?.declaration;
-  if (!declaration || !ts11.isFunctionLike(declaration))
+  if (!declaration || !ts13.isFunctionLike(declaration))
     return;
-  const index = declaration.parameters.findIndex((parameter) => !parameter.dotDotDotToken && ts11.isIdentifier(parameter.name) && parameter.name.text === entry.addressParameter);
+  const index = declaration.parameters.findIndex((parameter) => !parameter.dotDotDotToken && ts13.isIdentifier(parameter.name) && parameter.name.text === entry.addressParameter);
   if (index === -1)
     return;
   const argument = call.arguments[index];
-  return argument && ts11.isStringLiteralLike(argument) ? argument.text : undefined;
+  return argument && ts13.isStringLiteralLike(argument) ? argument.text : undefined;
 }
 function innermostLiteralAt(sourceFile, position) {
   let found;
   const visit = (node) => {
     if (position < node.getStart(sourceFile) || position > node.getEnd())
       return;
-    if (ts11.isStringLiteralLike(node))
+    if (ts13.isStringLiteralLike(node))
       found = node;
-    ts11.forEachChild(node, visit);
+    ts13.forEachChild(node, visit);
   };
-  ts11.forEachChild(sourceFile, visit);
+  ts13.forEachChild(sourceFile, visit);
   return found;
 }
 function resolveClassifiedSlotAtPosition(input) {
@@ -2629,23 +3676,23 @@ function resolveClassifiedSlotAtPosition(input) {
   };
 }
 // src/url-cross-world-address.ts
-import * as ts13 from "typescript";
+import * as ts15 from "typescript";
 
 // src/url-address-literals.ts
-import * as ts12 from "typescript";
+import * as ts14 from "typescript";
 function isAmbient2(fileName) {
   return /[\\/]node_modules[\\/]/.test(fileName) || /(^|[\\/])lib\.[^\\/]*\.d\.ts$/.test(fileName);
 }
 function referenceTargetSymbol(type) {
-  if ((type.flags & ts12.TypeFlags.Object) === 0)
+  if ((type.flags & ts14.TypeFlags.Object) === 0)
     return;
-  if ((type.objectFlags & ts12.ObjectFlags.Reference) === 0)
+  if ((type.objectFlags & ts14.ObjectFlags.Reference) === 0)
     return;
   return type.target.symbol;
 }
 function ambientHashAliasTargets(checker, anchor) {
   const targets = new Set;
-  for (const symbol of checker.getSymbolsInScope(anchor, ts12.SymbolFlags.Type)) {
+  for (const symbol of checker.getSymbolsInScope(anchor, ts14.SymbolFlags.Type)) {
     if (symbol.name !== "Hash")
       continue;
     const target = referenceTargetSymbol(checker.getDeclaredTypeOfSymbol(symbol));
@@ -2661,7 +3708,7 @@ function canonicalHashSymbols(checker, program) {
   if (!anchor)
     return canonical;
   const aliased = ambientHashAliasTargets(checker, anchor);
-  for (const symbol of checker.getSymbolsInScope(anchor, ts12.SymbolFlags.Function)) {
+  for (const symbol of checker.getSymbolsInScope(anchor, ts14.SymbolFlags.Function)) {
     if (symbol.name !== "hash")
       continue;
     const declaration = symbol.declarations?.[0];
@@ -2683,7 +3730,7 @@ function hashedSourceOfType(checker, type, canonical) {
   return source?.isStringLiteral() ? source.value : undefined;
 }
 function staticAddressTextOf(checker, node, canonical) {
-  return ts12.isStringLiteralLike(node) ? node.text : hashedSourceOfType(checker, checker.getTypeAtLocation(node), canonical);
+  return ts14.isStringLiteralLike(node) ? node.text : hashedSourceOfType(checker, checker.getTypeAtLocation(node), canonical);
 }
 
 // src/url-cross-world-address.ts
@@ -2707,7 +3754,7 @@ function checkCrossWorldAddresses(input) {
     if (worlds.length === 0)
       continue;
     const visit = (node) => {
-      if (ts13.isExpression(node)) {
+      if (ts15.isExpression(node)) {
         const entry = addressEntryOfArgument(checker, table, node);
         if (entry !== undefined && slotRejectsForeignSocket(entry)) {
           const address = staticAddressTextOf(checker, node, canonical);
@@ -2724,14 +3771,14 @@ function checkCrossWorldAddresses(input) {
           }
         }
       }
-      ts13.forEachChild(node, visit);
+      ts15.forEachChild(node, visit);
     };
-    ts13.forEachChild(sourceFile, visit);
+    ts15.forEachChild(sourceFile, visit);
   }
   return findings;
 }
 // src/url-fragment-reachability.ts
-import * as ts14 from "typescript";
+import * as ts16 from "typescript";
 function pathOfKey(key) {
   const socket = socketOfAddress(key);
   return socket === undefined ? key : key.slice(socket.length + 1);
@@ -2776,7 +3823,7 @@ function checkUrlFragmentReachability(input) {
     if (isAmbient2(sourceFile.fileName))
       continue;
     const visit = (node) => {
-      if (ts14.isExpression(node) && isAddressClass(addressClassOfArgument(checker, table, node))) {
+      if (ts16.isExpression(node) && isAddressClass(addressClassOfArgument(checker, table, node))) {
         const text = staticAddressTextOf(checker, node, canonical);
         if (text !== undefined) {
           const hash = text.indexOf("#");
@@ -2795,26 +3842,29 @@ function checkUrlFragmentReachability(input) {
           }
         }
       }
-      ts14.forEachChild(node, visit);
+      ts16.forEachChild(node, visit);
     };
-    ts14.forEachChild(sourceFile, visit);
+    ts16.forEachChild(sourceFile, visit);
   }
   return { kind: "checked", findings };
 }
 export {
   ANIMATION_ASSET_EXTENSIONS,
   COLLECTION_REFERENCE_EXTENSIONS,
+  COMPANION_INTERNAL_FIELD,
   DEFAULT_INCLUDE,
   GAME_PROJECT_DOCUMENT,
   GUI_EXTENSIONS,
   INPUT_BINDING_EXTENSIONS,
   LIBRARY_DEPENDENCY_ROOT,
   LIBRARY_SCENE_EXTENSIONS,
+  LUALIB_REQUIRE_NAME,
   PROJECT_EXTENSIONS,
   SCAFFOLDED_DEFIGNORE_LINES,
   SCENE_EXTENSIONS,
   SCRIPT_SUFFIX_BY_KIND,
   SceneTextFormatError,
+  TIMERS_REQUIRE_NAME,
   addressClassOfArgument,
   addressEntryOfArgument,
   archiveWrapperOf,
@@ -2833,9 +3883,11 @@ export {
   collectComponentDeclarations,
   collectComponentIds,
   componentIdOfSameObjectAddress,
+  computeCompanionClosure,
   computeOutputRel,
   createTranspileSession,
   displayPathOf,
+  findEmittedRequires,
   findMainEntryFactoryImports,
   getProgramDiagnostics,
   guiScriptResourceOf,
@@ -2854,7 +3906,9 @@ export {
   readLibrarySceneDocuments,
   readSceneDocuments,
   relativeAddressesFrom,
+  requirePathForRel,
   resolveClassifiedSlotAtPosition,
+  rewriteEmittedRequires,
   slotRejectsForeignSocket,
   socketOfAddress,
   stripIncludeBase,