@lango-project/lango-js 0.1.8 → 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.8",
+  "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);
 
@@ -1565,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",
@@ -1602,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,
@@ -2005,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;
@@ -2129,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);
@@ -2277,7 +2295,7 @@ function validate(program, imports = []) {
     findMethod(classNode, "constructor", false);
   const walk = (value, localCallables, classNode = null, staticMethod = false) => {
     if (!value || typeof value !== "object") return;
-    if (value.type === "closure" || value.type === "closureAssign")
+    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] : []),
@@ -2289,6 +2307,12 @@ function validate(program, imports = []) {
     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);
@@ -2302,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 (
@@ -2380,8 +2419,9 @@ function validate(program, imports = []) {
           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 =
@@ -2408,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 &&
@@ -2476,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,
@@ -2527,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")
@@ -2858,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",
@@ -2884,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)
@@ -3119,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",
@@ -3313,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",
@@ -3343,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",
@@ -3420,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,
@@ -3610,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
@@ -3620,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")
@@ -3700,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;
@@ -4019,6 +4089,7 @@ 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;
@@ -4042,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(".$"));
@@ -4148,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
@@ -4376,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) {
@@ -4425,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`,
     );
@@ -4434,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) => {
@@ -4497,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 = {
@@ -4541,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");
 }