@defold-typescript/transpiler 0.51.0 → 0.53.0

package/dist/lifecycle-erasure.d.ts

@@ -3,6 +3,7 @@ import { type Plugin } from "typescript-to-lua";
 export declare const FACTORY_MODULE = "@defold-typescript/types";
 export declare const FACTORY_NAMES: Set<string>;
 export declare function resolvesToFactoryExport(callee: ts.Expression, checker: ts.TypeChecker): boolean;
+export declare const RESOURCE_PROPERTY_MARKERS: ReadonlySet<string>;
 export interface PropertyMember {
     readonly name: string;
     readonly initializer: ts.Expression;

package/dist/transpile.d.ts

@@ -22,6 +22,7 @@ export interface TranspileProjectResult {
     readonly lualib?: string;
     readonly timersRuntime?: string;
     readonly hsmModules?: Readonly<Record<string, string>>;
+    readonly hsmSourceMaps?: Readonly<Record<string, string>>;
 }
 export declare const AMBIENT_FILES: Readonly<Record<string, string>>;
 interface CollectableFile {
@@ -42,5 +43,7 @@ export declare function transpileProject(input: TranspileProjectInput): Transpil
  * lualib bundle.
  */
 export declare function compileHsmModules(): Readonly<Record<string, string>>;
+/** The source map of every module `compileHsmModules` returns, under the same keys. */
+export declare function compileHsmSourceMaps(): Readonly<Record<string, string>>;
 export declare function transpile(source: string): TranspileResult;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defold-typescript/transpiler",
-  "version": "0.51.0",
+  "version": "0.53.0",
   "description": "TypeScript-to-Lua build pipeline tuned for Defold's runtime.",
   "license": "MIT",
   "repository": {
@@ -35,9 +35,12 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@defold-typescript/types": "0.51.0",
+    "@defold-typescript/types": "0.53.0",
     "@typescript-to-lua/language-extensions": "1.19.0",
     "typescript": "6.0.2",
     "typescript-to-lua": "^1.36.0"
+  },
+  "devDependencies": {
+    "lua-wasm-bindings": "0.5.3"
   }
 }

package/src/companion-closure.ts

@@ -1,4 +1,5 @@
 import * as ts from "typescript";
+import { findManagedBootstrap } from "./debug-bootstrap";
 import { resolvesToFactoryExport } from "./lifecycle-erasure";
 
 /**
@@ -49,6 +50,13 @@ export interface CompanionClosure {
    * companion takes its own `require` of the same module instead.
    */
   readonly importBindings: readonly string[];
+  /**
+   * The unedited `setup-debug` managed block's statements, in source order, or
+   * empty. They are exempt from the order rule because the emit runs them ahead
+   * of the companion's `require`, so the debugger starts before anything the
+   * companion loads.
+   */
+  readonly bootstrap: readonly ts.Statement[];
   /** Shapes a split cannot preserve. Empty means the source is splittable. */
   readonly violations: readonly ClosureViolation[];
 }
@@ -717,11 +725,20 @@ export function computeCompanionClosure(
     });
   }
 
+  const managed = findManagedBootstrap(sourceFile);
+  const bootstrap = managed?.canonical === true ? managed.statements : [];
+  const editedBlock = new Set(managed?.canonical === false ? managed.statements : []);
+  const exempt = new Set(bootstrap);
+
   // The companion loads as a unit, so the constraint is pairwise: any effectful
   // script statement with any closure declaration below it is reordered by the
   // split, whatever the first member's position.
   for (const statement of sourceFile.statements) {
-    if (closureStatements.has(statement) || isEffectFreeStatement(statement, checker)) {
+    if (
+      closureStatements.has(statement) ||
+      exempt.has(statement) ||
+      isEffectFreeStatement(statement, checker)
+    ) {
       continue;
     }
     const start = statement.getStart(sourceFile);
@@ -735,14 +752,18 @@ export function computeCompanionClosure(
       siteOf(statement, "runs in the script"),
       siteOf(hoisted.declaration.node, "moves into the companion"),
     ];
+    const name = hoisted.declaration.name;
     violations.push({
       kind: "initialization-order",
-      member: hoisted.declaration.name,
+      member: name,
       sites,
-      message:
-        `top-level work precedes "${hoisted.declaration.name}", which the companion would run first, ` +
-        `reversing their order (${formatSites(sites)}). ` +
-        "Move that work below the companion's declarations, or into a lifecycle hook.",
+      message: editedBlock.has(statement)
+        ? `the setup-debug managed block was edited and now runs top-level work before "${name}", ` +
+          `which the companion would run first (${formatSites(sites)}). ` +
+          "Run `defold-typescript setup-debug` to restore the block."
+        : `top-level work precedes "${name}", which the companion would run first, ` +
+          `reversing their order (${formatSites(sites)}). ` +
+          "Move that work below the companion's declarations, or into a lifecycle hook.",
     });
   }
 
@@ -756,6 +777,7 @@ export function computeCompanionClosure(
     internals: ordered
       .filter(({ symbol }) => !exportSet.has(symbol) && scriptReferences.has(symbol))
       .map(({ declaration }) => declaration.name),
+    bootstrap,
     violations,
   };
 }

package/src/companion-emit.ts

@@ -66,6 +66,8 @@ function isRuntimeScriptSource(sourceFile: ts.SourceFile, checker: ts.TypeChecke
 interface CompanionPlan {
   /** Full start of each top-level statement the companion takes over. */
   readonly closureStarts: ReadonlySet<number>;
+  /** Full start of each unedited `setup-debug` block statement. */
+  readonly bootstrapStarts: ReadonlySet<number>;
   /** Members the script reaches by bare name, which the companion must expose. */
   readonly internals: readonly string[];
   /** Import bindings the companion needs its own `require` of. */
@@ -86,6 +88,7 @@ function planFor(sourceFile: ts.SourceFile, checker: ts.TypeChecker): CompanionP
   }
   return {
     closureStarts: new Set(closure.statements.map((statement) => statement.pos)),
+    bootstrapStarts: new Set(closure.bootstrap.map((statement) => statement.pos)),
     internals: closure.internals,
     importBindings: closure.importBindings,
     requirePath: requirePathForRel(sourceFile.fileName),
@@ -466,6 +469,10 @@ interface SplitHalves {
  * first. The run stops at the first statement that reads the companion, and at
  * the first non-declaration — a lifecycle hook closes over the internals it
  * reads, so its declaration must precede the hook's.
+ *
+ * The `setup-debug` block's gate is taken out of `script` before this runs and
+ * placed immediately ahead of the `require`, so the debugger starts before any
+ * companion code does while `lldebugger` itself is still required above it.
  */
 function requireInsertionPoint(script: readonly Statement[], reads: ReadonlySet<string>): number {
   let index = 0;
@@ -524,6 +531,7 @@ export interface CompanionEmitter {
 export function createCompanionEmitPlugin(): CompanionEmitter {
   const plans = new Map<string, CompanionPlan | undefined>();
   const owned = new Map<string, Set<Statement>>();
+  const bootstraps = new Map<string, Set<Statement>>();
   const companions = new Map<string, string>();
 
   function planOf(sourceFile: ts.SourceFile, checker: ts.TypeChecker): CompanionPlan | undefined {
@@ -552,6 +560,24 @@ export function createCompanionEmitPlugin(): CompanionEmitter {
     return statements;
   }
 
+  function captureBootstrap(node: ts.IfStatement, context: TransformationContext): Statement[] {
+    const statements = context.superTransformStatements(node);
+    const sourceFile = context.sourceFile;
+    const plan = planOf(sourceFile, context.checker);
+    if (plan === undefined || !plan.bootstrapStarts.has(node.pos)) {
+      return statements;
+    }
+    let bucket = bootstraps.get(sourceFile.fileName);
+    if (bucket === undefined) {
+      bucket = new Set();
+      bootstraps.set(sourceFile.fileName, bucket);
+    }
+    for (const statement of statements) {
+      bucket.add(statement);
+    }
+    return statements;
+  }
+
   const visitors: Plugin["visitors"] = {
     [ts.SyntaxKind.VariableStatement]: capture,
     [ts.SyntaxKind.FunctionDeclaration]: capture,
@@ -561,6 +587,7 @@ export function createCompanionEmitPlugin(): CompanionEmitter {
     // because TSTL emits its `require` bindings through its own hoisting. The
     // companion takes a copy of that prelude instead — see `copiedPrelude`.
     [ts.SyntaxKind.ExportDeclaration]: capture,
+    [ts.SyntaxKind.IfStatement]: captureBootstrap,
   };
 
   let configuredNoResolvePaths: readonly string[] = [];
@@ -582,7 +609,8 @@ export function createCompanionEmitPlugin(): CompanionEmitter {
         if (plan === undefined || bucket === undefined || bucket.size === 0) {
           continue;
         }
-        emitCompanion(program, emitHost, file, sourceFile, plan, bucket, companions);
+        const bootstrap = bootstraps.get(sourceFile.fileName) ?? new Set();
+        emitCompanion(program, emitHost, file, sourceFile, plan, bucket, bootstrap, companions);
         emitted.push(plan.requirePath);
       }
       // The companion is written by the CLI, not by TSTL's emit plan, so TSTL's
@@ -606,6 +634,7 @@ function emitCompanion(
   sourceFile: ts.SourceFile,
   plan: CompanionPlan,
   owned: ReadonlySet<Statement>,
+  bootstrap: ReadonlySet<Statement>,
   companions: Map<string, string>,
 ): void {
   const luaAst = file.luaAst;
@@ -644,9 +673,11 @@ function emitCompanion(
   ];
 
   const reads = new Set([EXPORTS_NAME, ...plan.internals]);
-  const insertAt = requireInsertionPoint(halves.script, reads);
+  const rest = halves.script.filter((statement) => !bootstrap.has(statement));
+  const insertAt = requireInsertionPoint(rest, reads);
   const scriptStatements: Statement[] = [
-    ...halves.script.slice(0, insertAt),
+    ...rest.slice(0, insertAt),
+    ...halves.script.filter((statement) => bootstrap.has(statement)),
     createVariableDeclarationStatement(
       exportsIdentifier(),
       createCallExpression(createIdentifier("require"), [createStringLiteral(plan.requirePath)]),
@@ -654,7 +685,7 @@ function emitCompanion(
     ...plan.internals.map((name) =>
       createVariableDeclarationStatement(createIdentifier(name), internalsField(name)),
     ),
-    ...halves.script.slice(insertAt),
+    ...rest.slice(insertAt),
     createReturnStatement([exportsIdentifier()]),
   ];
 

package/src/debug-bootstrap.ts

@@ -0,0 +1,88 @@
+import * as ts from "typescript";
+
+// Managed-block sentinels. A re-run locates the single BEGIN…END pair and
+// refreshes the enclosed text if it drifted, so wording changes self-heal.
+// They are `//` line comments, stripped by TSTL, so they never reach the
+// emitted `.ts.script`.
+export const DEBUG_BLOCK_BEGIN =
+  "// defold-typescript:setup-debug BEGIN — managed block, do not edit";
+export const DEBUG_BLOCK_END = "// defold-typescript:setup-debug END";
+
+// The canonical managed block: import + gated start, marker-free, no
+// `declare module` (that lives in the ambient `.d.ts`). Mirrors the snippet in
+// `packages/docs/guide/debugging.md` exactly; a guide-comparison test locks the two.
+// The blank line before END keeps Biome's organizeImports assist from gluing
+// the END comment onto a following import as its leading comment (which would
+// then demand a blank line before the whole group). With blank lines on both
+// sides of END, an import injected above the user's own imports stays clean.
+export const DEBUG_MANAGED_BLOCK = `${DEBUG_BLOCK_BEGIN}
+import * as lldebugger from "lldebugger.debug";
+
+if (sys.get_engine_info().is_debug) {
+  lldebugger.start();
+}
+
+${DEBUG_BLOCK_END}`;
+
+export interface ManagedBootstrap {
+  /** The top-level statements wholly between the sentinels, in source order. */
+  readonly statements: readonly ts.Statement[];
+  /**
+   * Whether the text between the sentinels is the canonical body token for
+   * token, so line endings, quote style, comments and optional semicolons never
+   * decide it.
+   */
+  readonly canonical: boolean;
+}
+
+function occurrences(haystack: string, needle: string): number {
+  return haystack.split(needle).length - 1;
+}
+
+function bodyTokens(text: string): string[] {
+  const scanner = ts.createScanner(ts.ScriptTarget.Latest, true, ts.LanguageVariant.Standard, text);
+  const tokens: string[] = [];
+  for (let kind = scanner.scan(); kind !== ts.SyntaxKind.EndOfFileToken; kind = scanner.scan()) {
+    if (kind === ts.SyntaxKind.SemicolonToken) {
+      continue;
+    }
+    const spelling =
+      kind === ts.SyntaxKind.StringLiteral ? scanner.getTokenValue() : scanner.getTokenText();
+    tokens.push(`${kind}:${spelling}`);
+  }
+  return tokens;
+}
+
+const CANONICAL_BODY_TOKENS = bodyTokens(
+  DEBUG_MANAGED_BLOCK.slice(
+    DEBUG_BLOCK_BEGIN.length,
+    DEBUG_MANAGED_BLOCK.length - DEBUG_BLOCK_END.length,
+  ),
+);
+
+/**
+ * The `setup-debug` managed block in a source, located the way
+ * `upsertManagedBlock` locates it: exactly one BEGIN and one END, BEGIN first.
+ * Any other sentinel shape is one `setup-debug` itself refuses to edit, so it
+ * is not a managed block at all.
+ */
+export function findManagedBootstrap(sourceFile: ts.SourceFile): ManagedBootstrap | undefined {
+  const text = sourceFile.text;
+  if (occurrences(text, DEBUG_BLOCK_BEGIN) !== 1 || occurrences(text, DEBUG_BLOCK_END) !== 1) {
+    return undefined;
+  }
+  const beginAt = text.indexOf(DEBUG_BLOCK_BEGIN);
+  const endAt = text.indexOf(DEBUG_BLOCK_END);
+  if (endAt < beginAt) {
+    return undefined;
+  }
+  const bodyStart = beginAt + DEBUG_BLOCK_BEGIN.length;
+  const statements = sourceFile.statements.filter(
+    (statement) => statement.getStart(sourceFile) >= bodyStart && statement.end <= endAt,
+  );
+  const tokens = bodyTokens(text.slice(bodyStart, endAt));
+  const canonical =
+    tokens.length === CANONICAL_BODY_TOKENS.length &&
+    tokens.every((token, index) => token === CANONICAL_BODY_TOKENS[index]);
+  return { statements, canonical };
+}

package/src/hsm-builtin.ts

@@ -7,8 +7,8 @@ import { scanEmittedRequires } from "./lua-require-scan";
 
 // `@defold-typescript/types/hsm` is the `index` module; every other module is a
 // subpath of it. Each lowers to a require of `defold_typescript_hsm.<module>`,
-// which the CLI writes under the output root the way it writes the timers
-// runtime.
+// which the CLI respells to the module's place in its runtime folder, the way it
+// handles the timers runtime.
 export const HSM_MODULE_SPECIFIER = "@defold-typescript/types/hsm";
 export const HSM_REQUIRE_ROOT = "defold_typescript_hsm";
 

package/src/index.ts

@@ -11,6 +11,13 @@ export {
   componentIdOfSameObjectAddress,
 } from "./component-animation-index";
 export { buildConfigKeyIndex, readGameProjectSetting } from "./config-key-index";
+export type { ManagedBootstrap } from "./debug-bootstrap";
+export {
+  DEBUG_BLOCK_BEGIN,
+  DEBUG_BLOCK_END,
+  DEBUG_MANAGED_BLOCK,
+  findManagedBootstrap,
+} from "./debug-bootstrap";
 export { findEmittedRequires, LUALIB_REQUIRE_NAME } from "./emitted-requires";
 export type { GuiFlipbookIndex } from "./gui-flipbook-index";
 export { buildGuiFlipbookIndex } from "./gui-flipbook-index";
@@ -46,6 +53,7 @@ export {
   readGameProjectDependencies,
   readLibrarySceneDocuments,
 } from "./library-dependencies";
+export { scanEmittedRequires } from "./lua-require-scan";
 export { findMainEntryFactoryImports } from "./main-entry-factory-imports";
 export type { BuildConfig, ScriptKind, SourceOutputKind } from "./output-paths";
 export {

package/src/lifecycle-erasure.ts

@@ -35,22 +35,29 @@ const FACTORY_SPECIFIERS = new Set([
   `${FACTORY_MODULE}/render-script`,
 ]);
 
-export function resolvesToFactoryExport(callee: ts.Expression, checker: ts.TypeChecker): boolean {
+// The lifecycle factory a callee resolves to, aliases followed, or `undefined`
+// when it is not one of this package's factory exports.
+function factoryExportName(callee: ts.Expression, checker: ts.TypeChecker): string | undefined {
   let symbol = checker.getSymbolAtLocation(callee);
   if (symbol === undefined) {
-    return false;
+    return undefined;
   }
   if (symbol.flags & ts.SymbolFlags.Alias) {
     symbol = checker.getAliasedSymbol(symbol);
   }
-  if (!FACTORY_NAMES.has(symbol.getName())) {
-    return false;
+  const name = symbol.getName();
+  if (!FACTORY_NAMES.has(name)) {
+    return undefined;
   }
   const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
   if (declaration === undefined) {
-    return false;
+    return undefined;
   }
-  return declaration.getSourceFile().fileName.includes(FACTORY_MODULE);
+  return declaration.getSourceFile().fileName.includes(FACTORY_MODULE) ? name : undefined;
+}
+
+export function resolvesToFactoryExport(callee: ts.Expression, checker: ts.TypeChecker): boolean {
+  return factoryExportName(callee, checker) !== undefined;
 }
 
 function isThisParameter(param: ts.ParameterDeclaration): boolean {
@@ -208,6 +215,20 @@ function emitInitMerge(
   return [builderDecl, createAssignmentStatement(createIdentifier("init"), initFn, property)];
 }
 
+// Build-time markers, never engine functions: bob reads `resource.<kind>("path")`
+// only as a `go.property` default (`LuaScanner.java:923-933` at defold
+// `a81dbb04`), and the engine's `resource` table registers none of them
+// (`script_resource.cpp:3447-3463` in 1.14.0). Called anywhere else, each is nil.
+export const RESOURCE_PROPERTY_MARKERS: ReadonlySet<string> = new Set([
+  "resource.atlas",
+  "resource.buffer",
+  "resource.font",
+  "resource.material",
+  "resource.render_target",
+  "resource.texture",
+  "resource.tile_source",
+]);
+
 export interface PropertyMember {
   readonly name: string;
   readonly initializer: ts.Expression;
@@ -275,14 +296,171 @@ function emitPropertyRegistrations(
   );
 }
 
+// Defold builds `go.property` only in `.script` files, so a GUI or render
+// script's `properties` block has nothing it could lower to.
+function scriptOnlyProperties(
+  property: ts.ObjectLiteralElementLike,
+  factory: string,
+): ts.Diagnostic {
+  const file = property.getSourceFile();
+  const start = property.getStart(file);
+  return {
+    file,
+    start,
+    length: property.getEnd() - start,
+    category: ts.DiagnosticCategory.Error,
+    code: 0,
+    messageText: `\`${factory}\` cannot declare \`properties\`: Defold builds \`go.property\` only in \`.script\` files. Declare the property in a \`defineScript\` and send its value with \`msg.post\`.`,
+  };
+}
+
+// The outermost expression that only wraps `node` in parentheses or a type-only
+// form, so `(resource.atlas("/a.atlas") as Hash)` sits where the bare call would.
+function outermostWrapper(node: ts.Expression): ts.Expression {
+  let current = node;
+  while (
+    ts.isParenthesizedExpression(current.parent) ||
+    ts.isAsExpression(current.parent) ||
+    ts.isSatisfiesExpression(current.parent) ||
+    ts.isNonNullExpression(current.parent) ||
+    ts.isTypeAssertionExpression(current.parent)
+  ) {
+    current = current.parent;
+  }
+  return current;
+}
+
+// The inverse of `outermostWrapper`: the expression a run of parentheses and
+// type-only forms wraps, which TSTL emits in place of the whole run.
+function innermostExpression(node: ts.Expression): ts.Expression {
+  let current = node;
+  while (
+    ts.isParenthesizedExpression(current) ||
+    ts.isAsExpression(current) ||
+    ts.isSatisfiesExpression(current) ||
+    ts.isNonNullExpression(current) ||
+    ts.isTypeAssertionExpression(current)
+  ) {
+    current = current.expression;
+  }
+  return current;
+}
+
+// Keyed by the declaration's fully qualified name: only a symbol declared in an
+// ambient `declare global` block carries the `global.` prefix, so a project's
+// own `resource` never matches.
+function globalName(symbol: ts.Symbol | undefined, checker: ts.TypeChecker): string | undefined {
+  if (symbol === undefined) {
+    return undefined;
+  }
+  const fqn = checker.getFullyQualifiedName(symbol);
+  return fqn.startsWith("global.") ? fqn.slice("global.".length) : undefined;
+}
+
+function calledGlobal(call: ts.CallExpression, checker: ts.TypeChecker): string | undefined {
+  const declaration = checker.getResolvedSignature(call)?.declaration;
+  if (
+    declaration === undefined ||
+    !ts.isFunctionDeclaration(declaration) ||
+    declaration.name === undefined
+  ) {
+    return undefined;
+  }
+  return globalName(checker.getSymbolAtLocation(declaration.name), checker);
+}
+
+// A `properties` default of a factory call, or the default argument of a
+// direct `go.property` call: the two places bob reads a marker.
+function isPropertyDefault(call: ts.CallExpression, checker: ts.TypeChecker): boolean {
+  const value = outermostWrapper(call);
+  const parent = value.parent;
+  if (ts.isCallExpression(parent)) {
+    return parent.arguments[1] === value && calledGlobal(parent, checker) === "go.property";
+  }
+  const properties = parent?.parent?.parent;
+  if (
+    properties === undefined ||
+    !ts.isPropertyAssignment(properties) ||
+    !isPropertiesHook(properties)
+  ) {
+    return false;
+  }
+  const hooks = properties.parent;
+  return (
+    ts.isObjectLiteralExpression(hooks) &&
+    factoryHooks(hooks.parent as ts.Expression, checker) === hooks &&
+    propertyMembers(properties).some((member) => member.initializer === value)
+  );
+}
+
+function misplacedMarker(node: ts.Expression, marker: string): ts.Diagnostic {
+  const file = node.getSourceFile();
+  const start = node.getStart(file);
+  return {
+    file,
+    start,
+    length: node.getEnd() - start,
+    category: ts.DiagnosticCategory.Error,
+    code: 0,
+    messageText: `\`${marker}\` is a build-time marker: Defold's build reads it only in a \`go.property\` default, and the engine binds no such function. Use it as a \`defineScript\` \`properties\` default.`,
+  };
+}
+
+// Bob reads a default as a marker only when the emitted text is
+// `resource.<kind>("<path>")` or `resource.<kind>()`: the object token must be
+// `resource` with a dot `NAME` key, and the first argument a string literal or
+// absent (`LuaScanner.java:801-822`, `:923-933` and `:493-510` at defold
+// `a81dbb04`). The receiver test is textual like bob's; the marker resolution
+// has already excluded a project's own `resource`.
+function readsAsMarker(call: ts.CallExpression): boolean {
+  const callee = innermostExpression(call.expression);
+  if (ts.isOptionalChain(call) || ts.isOptionalChain(callee)) {
+    return false;
+  }
+  if (
+    !ts.isPropertyAccessExpression(callee) &&
+    !(
+      ts.isElementAccessExpression(callee) &&
+      ts.isStringLiteralLike(innermostExpression(callee.argumentExpression))
+    )
+  ) {
+    return false;
+  }
+  const receiver = innermostExpression(callee.expression);
+  if (!ts.isIdentifier(receiver) || receiver.text !== "resource") {
+    return false;
+  }
+  const [path] = call.arguments;
+  return path === undefined || ts.isStringLiteralLike(innermostExpression(path));
+}
+
+function unreadableMarker(node: ts.CallExpression, marker: string): ts.Diagnostic {
+  const file = node.getSourceFile();
+  const start = node.getStart(file);
+  return {
+    file,
+    start,
+    length: node.getEnd() - start,
+    category: ts.DiagnosticCategory.Error,
+    code: 0,
+    messageText: `\`${marker}\` in a property default must be written \`${marker}("<path>")\`, with a string literal path: Defold's build reads no other form.`,
+  };
+}
+
+function isCallee(node: ts.Expression): boolean {
+  const callee = outermostWrapper(node);
+  return ts.isCallExpression(callee.parent) && callee.parent.expression === callee;
+}
+
 function eraseFactoryCall(
   expression: ts.Expression,
   context: TransformationContext,
 ): Statement[] | undefined {
   const hooks = factoryHooks(expression, context.checker);
-  if (hooks === undefined) {
+  if (hooks === undefined || !ts.isCallExpression(expression)) {
     return undefined;
   }
+  const factory = factoryExportName(expression.expression, context.checker);
   const registrations: Statement[] = [];
   const statements: Statement[] = [];
   for (const property of hooks.properties) {
@@ -291,7 +469,11 @@ function eraseFactoryCall(
       continue;
     }
     if (name === "properties") {
-      registrations.push(...emitPropertyRegistrations(property, context));
+      if (factory === "defineScript") {
+        registrations.push(...emitPropertyRegistrations(property, context));
+      } else if (factory !== undefined && propertyMembers(property).length > 0) {
+        context.diagnostics.push(scriptOnlyProperties(property, factory));
+      }
       continue;
     }
     const fn = hookFunction(property);
@@ -374,5 +556,48 @@ export const lifecycleErasurePlugin: Plugin = {
     },
     [ts.SyntaxKind.ImportDeclaration]: (node, context) =>
       isFactoryOnlyImport(node) ? [] : context.superTransformStatements(node),
+    // TSTL's optional-chain lowering also visits nodes it synthesizes, which have
+    // no parent and no source span; only parsed nodes are checked.
+    [ts.SyntaxKind.CallExpression]: (node, context) => {
+      const marker = node.parent === undefined ? undefined : calledGlobal(node, context.checker);
+      if (marker !== undefined && RESOURCE_PROPERTY_MARKERS.has(marker)) {
+        if (!isPropertyDefault(node, context.checker)) {
+          context.diagnostics.push(misplacedMarker(node, marker));
+        } else if (!readsAsMarker(node)) {
+          context.diagnostics.push(unreadableMarker(node, marker));
+        }
+      }
+      return context.superTransformExpression(node);
+    },
+    [ts.SyntaxKind.PropertyAccessExpression]: (node, context) => {
+      if (node.parent !== undefined && !isCallee(node)) {
+        const marker = globalName(context.checker.getSymbolAtLocation(node.name), context.checker);
+        if (marker !== undefined && RESOURCE_PROPERTY_MARKERS.has(marker)) {
+          context.diagnostics.push(misplacedMarker(node, marker));
+        }
+      }
+      return context.superTransformExpression(node);
+    },
+    [ts.SyntaxKind.ElementAccessExpression]: (node, context) => {
+      if (node.parent !== undefined && !isCallee(node)) {
+        // The checker resolves a string key only when it is the direct argument,
+        // so a wrapped key is looked up by name on the receiver's type, as the
+        // checker does for a direct one.
+        const key = innermostExpression(node.argumentExpression);
+        const marker = ts.isStringLiteralLike(key)
+          ? globalName(
+              context.checker.getPropertyOfType(
+                context.checker.getTypeAtLocation(node.expression),
+                key.text,
+              ),
+              context.checker,
+            )
+          : undefined;
+        if (marker !== undefined && RESOURCE_PROPERTY_MARKERS.has(marker)) {
+          context.diagnostics.push(misplacedMarker(node, marker));
+        }
+      }
+      return context.superTransformExpression(node);
+    },
   },
 };

package/src/timers-runtime.ts

@@ -1,7 +1,7 @@
 // The importable polyfill specifier (matched by the type checker and the
 // lowering pass) and the flat Lua require name the import is rewritten to. The
-// CLI writes the runtime to `<require name>.lua` at the output root, mirroring
-// `lualib_bundle`, so `require("defold_typescript_timers")` resolves in Defold.
+// CLI writes the runtime into its runtime folder beside `lualib_bundle` and
+// respells every `require("defold_typescript_timers")` to that path.
 export const TIMERS_MODULE_SPECIFIER = "@defold-typescript/types/timers";
 export const TIMERS_REQUIRE_NAME = "defold_typescript_timers";