@lango-project/lango-js 0.1.7 → 0.1.10

package/README.md

@@ -36,6 +36,24 @@ private `.lango/runtime.mjs` beside the output. Run the current checks with:
 npm test
 ```
 
+Relative Lango imports are compiled under the entry output directory. The build
+preserves their paths relative to the common source directory, and emitted
+imports use the relative path to each actual output. Parent-directory imports
+therefore stay inside the output tree. A shared dependency is emitted once;
+cycles refer back to the configured entry filename. If that filename collides
+with a dependency, dependencies are placed under `.lango/modules/`. Each output
+folder receives its private runtime. Changing the source import graph may change
+its common root and dependency paths; rebuild the complete entry graph rather
+than relying on generated dependency filenames.
+
+For a Node command-line entry, use `lango build input.lango --out cli.mjs
+--executable`. It requires `export main(args)`, configures console output and
+invokes main with the command-line arguments, waiting for a returned Promise.
+The generated entry starts with `#!/usr/bin/env node`, so it can be an npm
+`bin` target. npm sets its executable permission during installation; when
+running the file directly outside npm, use `node cli.mjs` or set that permission
+yourself. Ordinary library builds do not invoke main.
+
 Create a new application project with:
 
 ```sh
@@ -232,8 +250,8 @@ Faz 30 permits a function to return a closure directly. See
 
 ## Faz 31
 
-Faz 31 makes an explicit `capture @property` retain the original class
-instance in a returned closure. See `examples/031-property-capture`.
+Faz 31 retains the original class instance for property access in a returned
+closure. Member capture is now automatic (D-063). See `examples/031-property-capture`.
 
 ## Faz 32
 
@@ -252,7 +270,7 @@ capture declarations. See `examples/034-static-capture`.
 
 ## Faz 35
 
-Faz 35 extends explicit closure capture to protected properties. See
+Faz 35 retains protected properties in closures; capture is now automatic. See
 `examples/035-protected-capture`.
 
 ## Faz 36
@@ -837,6 +855,11 @@ Faz 174 adds `Array#remove_all(value)` for removing every matching value. See
 Faz 175 preserves null-safe optional access for array mutation helpers. See
 `examples/175-optional-array-mutations`.
 
+On non-array receivers, these helpers delegate to the receiver's own method,
+preserving every supplied argument and the method receiver. This includes
+`remove`, `remove_all`, `clear`, `remove_at` and `insert_at`; an undefined method
+result becomes null. Array mutation semantics remain as described above.
+
 ## Faz 176
 
 Faz 176 requires `to_js_number()` before a Decimal enters a direct host method
@@ -901,3 +924,34 @@ are native finite numbers.
 ## Faz 209
 
 Faz 209 rejects dynamic non-numeric range bounds.
+
+## Implicit method receivers
+
+Inside a class method, call another method as `prepare()`; instance and static
+methods resolve within their respective scopes. Use the readonly `@this` only
+when the receiver itself is needed. Callbacks automatically retain the receiver
+for method calls and member access; outer locals and captured context bindings
+still require `capture`. The former `this` and `this.method()` spellings produce migration
+diagnostics. See [the class guide](design/guide.md#public),
+[D-063](design/decisions.md#d-063-method-calls-have-an-implicit-receiver), and
+`examples/261-implicit-receiver` and `examples/262-automatic-receiver` for
+executable examples.
+
+## Inheritance across modules
+
+A Lango class can extend an imported Lango class, including an aliased import.
+Builds resolve inherited public members, constructor defaults and `super` method
+signatures across module boundaries. Bare inherited method calls and `@property`
+access use the inherited receiver; public fields are not redeclared in the
+subclass. An omitted subclass constructor forwards its arguments. Private method
+access/overrides remain rejected. This supports browser control subclasses in
+separate Lango modules without JavaScript wrappers.
+
+Method visibility and implicit-receiver lookup apply to the current Lango
+receiver. Calls to a JavaScript namespace or another object keep their own method
+and boundary normalization, even when the current class declares a private or
+public method with the same name.
+
+The CLI test runner waits for a Promise returned by a Lango test before
+reporting its result and resetting state for the next test. Async rejections
+are reported as test failures and remaining tests continue.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lango-project/lango-js",
-  "version": "0.1.7",
+  "version": "0.1.10",
   "license": "Apache-2.0",
   "publishConfig": {
     "access": "public"

package/src/cli.mjs

@@ -154,7 +154,7 @@ if (command === "init" && inputPath && rest.length === 0) {
             try {
                 program.__langoResetTests?.();
                 runtime.configure({ output: (value) => console.log(value), catalog, database_adapter: database });
-                test.run();
+                await test.run();
                 console.log(`PASS ${test.name}`);
             } catch (error) {
                 failures += 1;

package/src/compiler.mjs

@@ -30,20 +30,24 @@ export function formatDiagnostics(error) {
   }).join("\n");
 }
 
-export async function buildFile(inputPath, outputPath, seen = new Set(), includeTests = false, profile = {}) {
+export async function buildFile(inputPath, outputPath, seen = new Set(), includeTests = false, profile = {}, layout = null) {
+  inputPath = path.resolve(inputPath);
+  outputPath = path.resolve(outputPath);
   const decimalProfile = validateDecimalProfile(profile);
   if (decimalProfile.target === "browser" && profile.executable)
     throw new LangoError("LNG1266", 1, "browser builds cannot use --executable", inputPath);
   const isEntryPoint = seen.size === 0;
-  if (isEntryPoint)
-    await validateModuleInitializerCycles(inputPath, outputPath);
+  if (layout === null) {
+    const modules = await validateModuleInitializerCycles(inputPath, outputPath);
+    layout = moduleOutputLayout(inputPath, outputPath, modules);
+  }
   if (seen.has(inputPath)) return;
   seen.add(inputPath);
 
   const source = await readFile(inputPath, "utf8");
-  const imports = collectImports(source, inputPath, outputPath);
+  const imports = collectImports(source, inputPath, outputPath, layout);
   for (const item of imports)
-    await buildFile(item.sourcePath, item.outputPath, seen, includeTests, decimalProfile);
+    await buildFile(item.sourcePath, item.outputPath, seen, includeTests, decimalProfile, layout);
   for (const item of imports) {
     const importedProgram = new Parser(
       await readFile(item.sourcePath, "utf8"),
@@ -77,14 +81,16 @@ export async function buildFile(inputPath, outputPath, seen = new Set(), include
           1,
           `${inputPath}: import signature for ${selection.sourceName} does not match ${item.sourcePath}`,
         );
-      if (selection.kind === "class")
+      if (selection.kind === "class") {
+        selection.classMetadata = await importedClassMetadata(item.sourcePath, selection.sourceName);
         validateImportedClassInterface(
           selection,
-          target,
-          importedProgram,
+          selection.classMetadata,
+          { classes: [selection.classMetadata] },
           inputPath,
           item.sourcePath,
         );
+      }
     }
   }
 
@@ -103,6 +109,7 @@ export async function buildFile(inputPath, outputPath, seen = new Set(), include
       `//# sourceMappingURL=${path.basename(outputPath)}.map`,
       `const { configure } = await import("./.lango/runtime.mjs");\nconfigure({ output: (value) => console.log(value) });\nawait main(process.argv.slice(2));\n//# sourceMappingURL=${path.basename(outputPath)}.map`,
     );
+    output = `#!/usr/bin/env node\n${output}`;
   }
   const directory = path.dirname(outputPath);
 
@@ -283,6 +290,17 @@ class Parser {
         this.blank();
         continue;
       }
+      const hostImport = /^import js global ([A-Za-z_]\w*(?:\/[A-Za-z_]\w*)*)(?: as ([A-Za-z_]\w*))?$/.exec(line.text);
+      if (hostImport) {
+        if (declarationSeen)
+          this.fail(line, "LNG1121", "imports must precede class and function declarations");
+        const name = hostImport[2] ?? hostImport[1].split("/").at(-1);
+        if (jsImports.some((item) => item.name === name))
+          this.fail(line, "LNG1122", `duplicate JavaScript import name ${name}`);
+        jsImports.push({ name, globalPath: hostImport[1].split("/").map(kebabName) });
+        this.blank();
+        continue;
+      }
       const jsImport = /^import js "([^"]+)" as ([A-Za-z_]\w*)$/.exec(line.text);
       if (jsImport) {
         if (declarationSeen)
@@ -1074,8 +1092,12 @@ class Parser {
   }
   captures() {
     if (!(this.peek() ?? "").trimStart().startsWith("capture ")) return [];
-    const line = this.line();
-    const names = splitTopLevel(line.text.trim().slice(8));
+    const line = { text: this.peek(), number: this.i + 1 };
+    const indent = spaces(line.text);
+    const names = [];
+    while (spaces(this.peek() ?? "") === indent && (this.peek() ?? "").trimStart().startsWith("capture ")) {
+      names.push(...splitTopLevel(this.line().text.trim().slice(8)));
+    }
     if (
       names.some(
         (name) =>
@@ -1116,7 +1138,7 @@ class Parser {
         value:
           match[2] === "{"
             ? this.object(indent + 4)
-            : expr(match[2], line, this),
+            : expr(this.continuedStatement(match[2], line, indent + 4), line, this),
       });
     }
     return { type: "object", fields };
@@ -1550,6 +1572,8 @@ function expr(source, line, parser) {
         : [],
       line: line.number,
     };
+  if (methodCall?.[1] === "this")
+    parser.fail(line, "LNG1270", `use ${methodCall[3]}(...) without this.`);
   if (methodCall)
     return {
       type: "methodCall",
@@ -1587,6 +1611,8 @@ function expr(source, line, parser) {
     return { type: "raw", value: text };
   }
   if (/^(true|false|null)$/.test(text)) return { type: "raw", value: text };
+  if (/^this(?:$|[.\[?])/.test(text))
+    parser.fail(line, "LNG1270", "use @this for the current receiver and method(...) for its methods");
   if (/^@{0,2}\$?[A-Za-z_]\w*(?:(?:\.|\?\.)[A-Za-z_]\w*)*(?:\.|\?\.)_[A-Za-z_]\w*$/.test(text))
     parser.fail(
       line,
@@ -1803,6 +1829,8 @@ function validate(program, imports = []) {
     ),
   );
   const jsImportNames = new Set(program.jsImports.map((item) => item.name));
+  const jsModuleNames = new Set(program.jsImports.filter((item) => !item.globalPath).map((item) => item.name));
+  const hostImportNames = new Set(program.jsImports.filter((item) => item.globalPath).map((item) => item.name));
   const importedFunctions = new Map(
     imports.flatMap((item) =>
       (item.selections ?? [])
@@ -1836,7 +1864,7 @@ function validate(program, imports = []) {
     ["xml2obj", 1],
     ["start_trans", 0], ["commit_trans", 0], ["rollback_trans", 0], ["trans_state", 0],
   ]);
-  const hostFunctions = new Set(["fetch"]);
+  const hostFunctions = new Set(["fetch", ...hostImportNames]);
   const isDecimalValue = (value) =>
     value &&
     (value.type === "decimal" ||
@@ -1988,7 +2016,12 @@ function validate(program, imports = []) {
         1,
         `imported local name ${name} conflicts with a Lango declaration`,
       ));
-  const classes = new Map(program.classes.map((item) => [item.name, item]));
+  const classes = new Map([
+    ...imports.flatMap((item) => (item.selections ?? [])
+      .filter((selection) => selection.classMetadata && program.classes.some((node) => node.ancestor === selection.localName))
+      .map((selection) => [selection.localName, { ...selection.classMetadata, name: selection.localName }])),
+    ...program.classes.map((item) => [item.name, item]),
+  ]);
   duplicateDiagnostics(program.classes, "LNG1205", "class name");
   if (nameDiagnostics.length) {
     const [primary] = nameDiagnostics;
@@ -2112,6 +2145,8 @@ function validate(program, imports = []) {
       if (node.type === "assign" && !node.name.startsWith("@"))
         result.add(node.name);
       if (node.type === "closureAssign") result.add(node.name);
+      if (node.type === "closureAssign" || node.type === "closure") continue;
+      if (["contextDeclare", "contextSet", "globalDeclare"].includes(node.type)) result.add(node.name);
       if (node.type === "for") result.add(node.item);
       if (node.type === "forObject") {
         result.add(node.key);
@@ -2260,6 +2295,24 @@ function validate(program, imports = []) {
     findMethod(classNode, "constructor", false);
   const walk = (value, localCallables, classNode = null, staticMethod = false) => {
     if (!value || typeof value !== "object") return;
+    if (value.parameters && value.body)
+      localCallables = new Set([...localCallables, ...value.parameters.map((parameter) => parameter.name), ...dynamicBindingNames(value.body)]);
+    const bindings = [
+      ...(["assign", "closureAssign", "increment", "contextSet", "contextDeclare", "globalDeclare"].includes(value.type) ? [value.name] : []),
+      ...(value.parameters ?? []).map((parameter) => parameter.name),
+      ...(value.type === "for" ? [value.item] : []),
+      ...(value.type === "forObject" ? [value.key, value.value] : []),
+      ...(value.catchName ? [value.catchName] : []),
+    ];
+    const readonly = bindings.find((name) => hostImportNames.has(name));
+    if (readonly)
+      throw new LangoError("LNG1268", value.line ?? 1, `${readonly} is a readonly host import and cannot be rebound or shadowed`);
+    if (bindings.includes("this") || bindings.includes("@this"))
+      throw new LangoError("LNG1270", value.line ?? 1, "the current receiver cannot be rebound or shadowed");
+    if (value.type === "methodCall" && value.receiver === "this" && !value.implicitReceiver)
+      throw new LangoError("LNG1270", value.line ?? 1, `use ${value.name}(...) without this.`);
+    if (typeof value.receiver === "string" && /^@this(?:$|[.\[?])/.test(value.receiver) && !classNode)
+      throw new LangoError("LNG1270", value.line ?? 1, "@this is only valid in a class method");
     if (value.type === "binary" && ["+", "-", "*", "/", "%", "**", ">", "<", ">=", "<="].includes(value.operator)) {
       const string = (item) => item.type === "string";
       const number = (item) => item.type === "raw" && /^\d/.test(item.value);
@@ -2273,6 +2326,21 @@ function validate(program, imports = []) {
            (leftKind === "string" && value.operator !== "+")))
         throw new LangoError("LNG1254", value.line ?? 1, "primitive values do not coerce in operators");
     }
+    if (value.type === "call") {
+      const member = classNode && findMethodWithOwner(classNode, value.name, staticMethod);
+      if (member) {
+        const competing = names.has(value.name) || imported.has(value.name) || globals.has(value.name) ||
+          standardFunctions.has(value.name) || hostFunctions.has(value.name) ||
+          localCallables.has(value.name);
+        if (competing)
+          throw new LangoError("LNG1269", value.line, `ambiguous call ${value.name}: a method and another binding have the same name`);
+        value.type = "methodCall";
+        value.receiver = "this";
+        value.implicitReceiver = true;
+      }
+    }
+    if (value.type === "raw" && /^@this(?:$|[.\[?])/.test(value.value) && !classNode)
+      throw new LangoError("LNG1270", value.line ?? 1, "@this is only valid in a class method");
     if (value.type === "call") {
       const target = names.get(value.name) ?? importedFunctions.get(value.name);
       if (
@@ -2336,7 +2404,7 @@ function validate(program, imports = []) {
           value.line,
           `use / between JavaScript namespace segments in new ${value.name}(...)`,
         );
-      if (value.name.includes("/")) validateJavaScriptArguments(value, value.name);
+      if (value.name.includes("/") || hostImportNames.has(value.name)) validateJavaScriptArguments(value, value.name);
       const target = classes.get(value.name);
       const constructor = target && findConstructor(target);
       if (constructor) validateRequiredArguments(constructor, value, value.name);
@@ -2344,15 +2412,16 @@ function validate(program, imports = []) {
     if (value.type === "methodCall" && typeof value.receiver === "string") {
       if (
         value.receiver.includes(".") &&
-        jsImportNames.has(value.receiver.split(".")[0])
+        jsModuleNames.has(value.receiver.split(".")[0])
       )
         throw new LangoError(
           "LNG1232",
           value.line,
           `use / between JavaScript namespace segments in ${value.receiver}.${value.name}(...)`,
         );
+      const currentReceiver = value.receiver === "this" || value.receiver === "@this";
       const targetClass =
-        value.receiver === "this"
+        currentReceiver
           ? classNode
           : classes.get(value.receiver) ?? null;
       const importedStaticMethod =
@@ -2379,13 +2448,13 @@ function validate(program, imports = []) {
         findMethodWithOwner(
           targetClass,
           value.name,
-          value.receiver === "this" ? staticMethod : true,
+          currentReceiver ? staticMethod : true,
         );
       if (targetClass && !target)
         throw new LangoError(
           "LNG1241",
           value.line,
-          `${targetClass.name}: unknown ${value.receiver === "this" ? "instance" : "static"} method ${value.name}`,
+          `${targetClass.name}: unknown ${currentReceiver && !staticMethod ? "instance" : "static"} method ${value.name}`,
         );
       if (
         target &&
@@ -2404,6 +2473,8 @@ function validate(program, imports = []) {
           `${targetClass.name}${target.method.static ? "::" : ":"}${value.name}`,
         );
     }
+    if (value.type === "methodCall" && hostImportNames.has(receiverRoot(value.receiver)))
+      validateJavaScriptArguments(value, `${receiverRoot(value.receiver)}.${value.name}`);
     if (value.type === "methodCall" && receiverRoot(value.receiver) === "args")
       validateJavaScriptArguments(value, `args.${value.name}`);
     if (value.type === "namespaceMethodCall") {
@@ -2445,12 +2516,16 @@ function validate(program, imports = []) {
         );
       validateRequiredArguments(target, value, `super.${value.name}`);
     }
-    Object.values(value).forEach((item) =>
+    Object.entries(value).forEach(([key, item]) =>
       Array.isArray(item)
-        ? item.forEach((child) => walk(child, localCallables, classNode, staticMethod))
+        ? item.forEach((child) => walk(child, key === "catchBody" && value.catchName ? new Set([...localCallables, value.catchName]) : localCallables, classNode, staticMethod))
         : walk(item, localCallables, classNode, staticMethod),
     );
   };
+  program.globals.forEach((global) => walk(global, new Set()));
+  program.classes.forEach((classNode) =>
+    [...classNode.staticValues, ...classNode.enumValues].forEach((value) => walk(value, new Set())),
+  );
   [...program.functions, ...program.tests].forEach((fn) =>
     walk(
       fn,
@@ -2496,6 +2571,7 @@ function validate(program, imports = []) {
       return;
     }
     if (node.type === "methodCall" || node.type === "namespaceMethodCall") {
+      if (node.implicitReceiver) references.add("@this");
       if (typeof node.receiver === "string" && node.receiver !== "this")
         references.add(node.receiver.split(/[./]/)[0]);
       else if (typeof node.receiver !== "string")
@@ -2827,17 +2903,20 @@ function validate(program, imports = []) {
             !hostFunctions.has(name),
         );
         const captures = new Set(closure.captures);
+        const automaticCaptures = new Set(needed.filter((name) =>
+          classScope && (name.startsWith("@") || name.startsWith("_")),
+        ));
         const contextCaptures = new Set(
           closure.captures.filter((name) => availableContexts.has(name)),
         );
         for (const name of needed)
-          if (!captures.has(name))
+          if (!captures.has(name) && !automaticCaptures.has(name))
             throw new LangoError(
               "LNG1210",
               closure.line,
               `MissingCapture: ${name}; add capture ${name}`,
             );
-        for (const name of captures) {
+        for (const name of new Set([...captures, ...automaticCaptures])) {
           if (!needed.includes(name) && !contextCaptures.has(name))
             throw new LangoError(
               "LNG1211",
@@ -2853,6 +2932,11 @@ function validate(program, imports = []) {
               `capture ${name} is not assigned before this closure`,
             );
           if (propertyCapture) {
+            if (name === "@this") {
+              if (!classScope)
+                throw new LangoError("LNG1213", closure.line, "@this is only valid in a class method");
+              continue;
+            }
             const staticMember = name.startsWith("@@");
             const property = name.startsWith("@")
               ? name.slice(staticMember ? 2 : 1)
@@ -3088,6 +3172,8 @@ function validate(program, imports = []) {
   program.functions.forEach((fn) => validateLoopLevels(fn.body));
   program.tests.forEach((test) => validateLoopLevels(test.body));
   for (const classNode of program.classes) {
+    if (classNode.publicProperties.includes("this"))
+      throw new LangoError("LNG1270", classNode.line, "this is reserved for the current receiver");
     if (classNode.ancestor && !classes.has(classNode.ancestor))
       throw new LangoError(
         "LNG1206",
@@ -3282,6 +3368,7 @@ function validate(program, imports = []) {
           );
       }
       if (name && /^@[A-Za-z_]\w*$/.test(name)) {
+        if (name === "@this") return;
         if (!classScope.instanceMembers.has(name.slice(1)))
           throw new LangoError(
             "LNG1222",
@@ -3312,7 +3399,7 @@ function validate(program, imports = []) {
             : null;
       if (
         name &&
-        (/^@[A-Za-z_]\w*$/.test(name) || /^_[A-Za-z_]\w*$/.test(name))
+        ((/^@[A-Za-z_]\w*$/.test(name) && name !== "@this") || /^_[A-Za-z_]\w*$/.test(name))
       )
         throw new LangoError(
           "LNG1231",
@@ -3389,6 +3476,12 @@ function validate(program, imports = []) {
 
 function emit(program, moduleImports = [], includeTests = false) {
   const flags = {
+    classes: new Map([
+      ...moduleImports.flatMap((item) => (item.selections ?? [])
+        .filter((selection) => selection.classMetadata)
+        .map((selection) => [selection.localName, selection.classMetadata])),
+      ...program.classes.map((item) => [item.name, item]),
+    ]),
     print: false,
     translate: false,
     context: false,
@@ -3401,6 +3494,7 @@ function emit(program, moduleImports = [], includeTests = false) {
         item.names.map((name) => name.split(" as ").at(-1)),
       ),
     ),
+    hostGlobals: new Map(program.jsImports.filter((item) => item.globalPath).map((item) => [item.name, item.globalPath])),
   };
   const classes = program.classes
     .map((item) => emitClass(item, flags))
@@ -3424,7 +3518,18 @@ function emit(program, moduleImports = [], includeTests = false) {
         .concat("...__langoOwnTests")
         .join(", ")}];\n`
     : "";
+  const globals = program.globals
+    .map((item) => {
+      const value = emitExpr(item.value, flags);
+      const prefix = item.exported ? "export let" : "let";
+      if (!item.name.startsWith("$")) return `${prefix} ${item.name} = ${value};\n`;
+      flags.decimal = true;
+      return `${prefix} ${item.name} = __decimal(${item.value.type === "raw" ? JSON.stringify(item.value.value) : value});\n`;
+    })
+    .join("");
   const helpers = [
+    flags.hostGlobal && "hostGlobal as __hostGlobal",
+    flags.hostGlobalCall && "hostGlobalCall as __hostGlobalCall",
     flags.decimal && "decimal as __decimal",
     flags.print && "println as __println",
     flags.translate && "translate as __translate",
@@ -3482,20 +3587,12 @@ function emit(program, moduleImports = [], includeTests = false) {
     )
     .join("");
   const jsModules = program.jsImports
+    .filter((item) => !item.globalPath)
     .map(
       (item) =>
         `import * as ${item.name} from ${JSON.stringify(item.specifier)};\n`,
     )
     .join("");
-  const globals = program.globals
-    .map((item) => {
-      const value = emitExpr(item.value, flags);
-      const prefix = item.exported ? "export let" : "let";
-      if (!item.name.startsWith("$")) return `${prefix} ${item.name} = ${value};\n`;
-      flags.decimal = true;
-      return `${prefix} ${item.name} = __decimal(${item.value.type === "raw" ? JSON.stringify(item.value.value) : value});\n`;
-    })
-    .join("");
   const testReset = includeTests
     ? `export function __langoResetTests() {\n${program.globals
         .map((item) => `    ${item.name} = ${emitExpr(item.value, flags)};\n`)
@@ -3575,6 +3672,13 @@ function emitClass(item, flags) {
       method.public,
     ]),
   );
+  for (let ancestor = flags.classes.get(item.ancestor); ancestor; ancestor = flags.classes.get(ancestor.ancestor)) {
+    ancestor.publicProperties.forEach((name) => flags.publicProperties.add(name));
+    for (const method of ancestor.methods) {
+      const key = `${method.static ? "static" : "instance"}:${method.name}`;
+      if (method.public && !flags.methods.has(key)) flags.methods.set(key, true);
+    }
+  }
   const fields = [
     ...new Set(
       item.methods
@@ -3585,7 +3689,7 @@ function emitClass(item, flags) {
         .filter((name) => !name.startsWith("@@"))
         .map((name) => name.slice(1)),
     ),
-  ].filter((field) => !flags.publicProperties.has(field));
+  ].filter((field) => field !== "this" && !flags.publicProperties.has(field));
   const implicitConstructor =
     item.ancestor &&
     !item.methods.some((method) => method.name === "constructor")
@@ -3665,7 +3769,8 @@ function emitFunction(fn, flags) {
       .map((node) => node.name),
   );
   const hoisted = new Set(
-    [...collectEmitLocals(fn.body)].filter((name) => !topLevelAssigned.has(name)),
+    [...collectEmitLocals(fn.body)].filter((name) =>
+      !topLevelAssigned.has(name) && !fn.parameters.some((parameter) => parameter.name === name)),
   );
   const declared = new Set([...fn.parameters.map((p) => p.name), ...hoisted]);
   const priorArrayBindings = flags.arrayBindings;
@@ -3984,6 +4089,12 @@ function emitBoundaryChecks(parameters, depth, flags) {
     .join("");
 }
 function emitReceiverName(name, flags) {
+  if (/^@this(?:$|[.\[?])/.test(name)) return `this${name.slice(5)}`;
+  const host = /^([A-Za-z_]\w*)(.*)$/.exec(name);
+  if (host && flags.hostGlobals?.has(host[1])) {
+    flags.hostGlobal = true;
+    return `__hostGlobal(${JSON.stringify(flags.hostGlobals.get(host[1]))})${emitKebabPath(host[2])}`;
+  }
   const member = /^(@{1,2})(\$?[A-Za-z_]\w*)(.*)$/.exec(name);
   if (member) {
     const [, scope, property, suffix] = member;
@@ -4002,6 +4113,7 @@ function emitReceiverName(name, flags) {
 }
 
 function emitExpr(node, flags) {
+  if (node.type === "raw" && node.value === "@this") return "this";
   const decimalRaw = (value) =>
     value?.type === "raw" &&
     (value.value.startsWith("$") || value.value.includes(".$"));
@@ -4014,6 +4126,13 @@ function emitExpr(node, flags) {
     flags.normalize = true;
     return `__normalize(${value})`;
   };
+  if (node.type === "raw" && flags.hostGlobals.has(node.value.split(/[.\[?]/)[0]))
+    return normalize(emitReceiverName(node.value, flags));
+  if (node.type === "call" && flags.hostGlobals.has(node.name)) {
+    flags.hostGlobalCall = true;
+    const arguments_ = node.arguments.map((item) => item.type === "closure" ? emitClosure(item, 0, flags) : emitExpr(item, flags)).join(", ");
+    return `__hostGlobalCall(${JSON.stringify(flags.hostGlobals.get(node.name))}${arguments_ ? `, ${arguments_}` : ""})`;
+  }
   if (node.type === "raw")
     if (/^@{1,2}\$?[A-Za-z_]\w*[.\[?]/.test(node.value))
       return normalize(emitReceiverName(node.value, flags));
@@ -4076,7 +4195,7 @@ function emitExpr(node, flags) {
     return `__finite(-${numericLiteral ? emitExpr(node.value, flags) : `__requireNumber(${emitExpr(node.value, flags)})`})`;
   }
   if (node.type === "new")
-    return `new ${node.name.replaceAll("/", ".")}(${node.arguments.map((item) =>
+    return `new ${flags.hostGlobals.has(node.name.split("/")[0]) ? `(${emitReceiverName(node.name.replaceAll("/", "."), flags)})` : node.name.replaceAll("/", ".")}(${node.arguments.map((item) =>
       item.type === "closure" ? emitClosure(item, 0, flags) : emitExpr(item, flags),
     ).join(", ")})`;
   if (node.type === "superMethodCall")
@@ -4092,7 +4211,7 @@ function emitExpr(node, flags) {
   if (node.type === "methodCall" || node.type === "namespaceMethodCall") {
     const namespace = node.type === "namespaceMethodCall";
     const sourceReceiver = namespace
-      ? node.receiver.replaceAll("/", ".")
+      ? emitReceiverName(node.receiver.replaceAll("/", "."), flags)
       : typeof node.receiver === "string"
         ? emitReceiverName(node.receiver, flags)
         : emitExpr(node.receiver, flags);
@@ -4101,7 +4220,8 @@ function emitExpr(node, flags) {
       (sourceReceiver === "this" && flags.staticMethod)
         ? "static"
         : "instance";
-    const visibility = flags.methods?.get(`${type}:${node.name}`);
+    const ownReceiver = !namespace && (sourceReceiver === "this" || sourceReceiver === flags.className);
+    const visibility = ownReceiver ? flags.methods?.get(`${type}:${node.name}`) : undefined;
     const receiver =
       sourceReceiver === "this" && flags.staticMethod && visibility === false
         ? flags.className
@@ -4329,7 +4449,7 @@ function emitString(parts, flags) {
 function spaces(line) {
   return line.length - line.trimStart().length;
 }
-function collectImports(source, inputPath, outputPath) {
+function collectImports(source, inputPath, outputPath, layout = null) {
   const lines = source.split(/\r?\n/);
   const items = [];
   for (let index = 0; index < lines.length; index += 1) {
@@ -4378,7 +4498,7 @@ function collectImports(source, inputPath, outputPath) {
       path.dirname(inputPath),
       `${match[1]}.lango`,
     );
-    const outputPathForImport = path.resolve(
+    const outputPathForImport = layout?.get(sourcePath) ?? path.resolve(
       path.dirname(outputPath),
       `${match[1]}.mjs`,
     );
@@ -4387,12 +4507,38 @@ function collectImports(source, inputPath, outputPath) {
       selections,
       sourcePath,
       outputPath: outputPathForImport,
-      specifier: `./${path.basename(outputPathForImport)}`,
+      specifier: relativeModuleSpecifier(outputPath, outputPathForImport),
     });
   }
   return items;
 }
 
+function relativeModuleSpecifier(from, to) {
+  const relative = path.relative(path.dirname(from), to).split(path.sep).join("/");
+  return relative.startsWith("../") ? relative : `./${relative}`;
+}
+
+function moduleOutputLayout(entryPath, entryOutputPath, modules) {
+  let sourceRoot = path.dirname(entryPath);
+  for (const sourcePath of modules.keys()) {
+    while (true) {
+      const relative = path.relative(sourceRoot, sourcePath);
+      if (relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative)) break;
+      sourceRoot = path.dirname(sourceRoot);
+    }
+  }
+  const outputRoot = path.dirname(entryOutputPath);
+  const dependencyPath = (sourcePath, root) =>
+    path.join(root, path.relative(sourceRoot, sourcePath).replace(/\.lango$/, ".mjs"));
+  const collision = [...modules.keys()].some((sourcePath) =>
+    sourcePath !== entryPath && dependencyPath(sourcePath, outputRoot) === entryOutputPath);
+  const dependencyRoot = collision ? path.join(outputRoot, ".lango/modules") : outputRoot;
+  return new Map([...modules.keys()].map((sourcePath) => [
+    sourcePath,
+    sourcePath === entryPath ? entryOutputPath : dependencyPath(sourcePath, dependencyRoot),
+  ]));
+}
+
 async function validateModuleInitializerCycles(entryPath, entryOutputPath) {
   const modules = new Map();
   const visit = async (modulePath, outputPath) => {
@@ -4450,6 +4596,7 @@ async function validateModuleInitializerCycles(entryPath, entryOutputPath) {
               `${modulePath}: cyclic module initializer reads imported ${selection.kind} ${selection.localName}`,
             );
     }
+  return modules;
 }
 function collectClassImportInterface(lines, getIndex, setIndex) {
   const api = {
@@ -4494,6 +4641,46 @@ function collectClassImportInterface(lines, getIndex, setIndex) {
   setIndex(index);
   return api;
 }
+async function importedClassMetadata(sourcePath, name, visiting = new Set()) {
+  const key = `${sourcePath}:${name}`;
+  if (visiting.has(key))
+    throw new LangoError("LNG1207", 1, `cyclic class inheritance involving ${name}`, sourcePath);
+  const chain = new Set(visiting).add(key);
+  const source = await readFile(sourcePath, "utf8");
+  const program = new Parser(source, sourcePath).parse();
+  const target = program.classes.find((item) => item.name === name);
+  if (!target) throw new LangoError("LNG1206", 1, `unknown ancestor ${name}`, sourcePath);
+  let ancestor = null;
+  if (target.ancestor) {
+    if (program.classes.some((item) => item.name === target.ancestor))
+      ancestor = await importedClassMetadata(sourcePath, target.ancestor, chain);
+    else {
+      for (const item of collectImports(source, sourcePath, sourcePath)) {
+        const selection = item.selections.find((entry) => entry.kind === "class" && entry.localName === target.ancestor);
+        if (selection) {
+          ancestor = await importedClassMetadata(item.sourcePath, selection.sourceName, chain);
+          break;
+        }
+      }
+      if (!ancestor) throw new LangoError("LNG1206", target.line, `unknown ancestor ${target.ancestor}`, sourcePath);
+    }
+  }
+  const nearest = (own, inherited, keyOf) => [...new Map([
+    ...inherited.map((item) => [keyOf(item), item]),
+    ...own.map((item) => [keyOf(item), item]),
+  ]).values()];
+  const methodKey = (method) => `${method.static ? "static" : "instance"}:${method.name}`;
+  return {
+    ...target,
+    ancestor: null,
+    publicProperties: [...new Set([...(ancestor?.publicProperties ?? []), ...target.publicProperties])],
+    methods: nearest(target.methods, ancestor?.methods ?? [], methodKey),
+    publicMethods: nearest(target.publicMethods, ancestor?.publicMethods ?? [], methodKey),
+    staticValues: nearest(target.staticValues, ancestor?.staticValues ?? [], (item) => item.name),
+    enumValues: nearest(target.enumValues, ancestor?.enumValues ?? [], (item) => item.name),
+  };
+}
+
 function validateImportedClassInterface(
   selection,
   target,

package/src/runtime.mjs

@@ -427,7 +427,8 @@ export function add(value, ...items) {
     throw new Error("NotAddable");
 }
 
-export function remove(value, item) {
+export function remove(value, ...items) {
+    const [item] = items;
     if (Array.isArray(value)) {
         const index = value.indexOf(item);
         if (index < 0) return false;
@@ -435,12 +436,13 @@ export function remove(value, item) {
         return true;
     }
     if (value !== null && typeof value?.remove === "function") {
-        return normalize(value.remove(item));
+        return normalize(value.remove(...items));
     }
     throw new Error("NotRemovable");
 }
 
-export function remove_all(value, item) {
+export function remove_all(value, ...items) {
+    const [item] = items;
     if (Array.isArray(value)) {
         let removed = 0;
         for (let index = value.length - 1; index >= 0; index -= 1) {
@@ -451,23 +453,24 @@ export function remove_all(value, item) {
         return removed;
     }
     if (value !== null && typeof value?.remove_all === "function") {
-        return normalize(value.remove_all(item));
+        return normalize(value.remove_all(...items));
     }
     throw new Error("NotRemovable");
 }
 
-export function clear(value) {
+export function clear(value, ...items) {
     if (Array.isArray(value)) {
         value.length = 0;
         return null;
     }
     if (value !== null && typeof value?.clear === "function") {
-        return normalize(value.clear());
+        return normalize(value.clear(...items));
     }
     throw new Error("NotClearable");
 }
 
-export function remove_at(value, index) {
+export function remove_at(value, ...items) {
+    const [index] = items;
     if (Array.isArray(value)) {
         if (!Number.isSafeInteger(index) || index < 0 || index >= value.length)
             return false;
@@ -475,12 +478,13 @@ export function remove_at(value, index) {
         return true;
     }
     if (value !== null && typeof value?.remove_at === "function") {
-        return normalize(value.remove_at(index));
+        return normalize(value.remove_at(...items));
     }
     throw new Error("NotRemovable");
 }
 
-export function insert_at(value, index, item) {
+export function insert_at(value, ...items) {
+    const [index, item] = items;
     if (Array.isArray(value)) {
         if (!Number.isSafeInteger(index) || index < 0 || index > value.length)
             return false;
@@ -488,7 +492,7 @@ export function insert_at(value, index, item) {
         return true;
     }
     if (value !== null && typeof value?.insert_at === "function") {
-        return normalize(value.insert_at(index, item));
+        return normalize(value.insert_at(...items));
     }
     throw new Error("NotInsertable");
 }
@@ -548,6 +552,36 @@ export function call(value, ...arguments_) {
     return normalize(value(...arguments_));
 }
 
+export class HostGlobalUnavailable extends Error {
+    constructor(path) {
+        super("HostGlobalUnavailable: " + path.join("/"));
+        this.name = "HostGlobalUnavailable";
+    }
+}
+
+function resolveHostGlobal(path) {
+    let owner = globalThis;
+    let value = owner;
+    for (const segment of path) {
+        owner = value;
+        if (owner === null || owner === undefined || !(segment in Object(owner)))
+            throw new HostGlobalUnavailable(path);
+        value = owner[segment];
+    }
+    if (value === undefined) throw new HostGlobalUnavailable(path);
+    return { owner, value };
+}
+
+export function hostGlobal(path) {
+    return resolveHostGlobal(path).value;
+}
+
+export function hostGlobalCall(path, ...arguments_) {
+    const { owner, value } = resolveHostGlobal(path);
+    if (typeof value !== "function") throw new Error("NotCallable");
+    return normalize(Reflect.apply(value, owner, arguments_));
+}
+
 export function callMethod(receiver, name, ...arguments_) {
     const value = receiver?.[name];
     if (typeof value !== "function") throw new Error("NotCallable");