kopscript 0.7.2 → 0.9.0

package/dist/cli.js

@@ -66,7 +66,14 @@ function build(filePath, jsonMode = false) {
         return { outPath: null, watchFiles: allWatchFiles(result) };
     }
     for (const absPath of result.order) {
-        writeFileSync(outputPathFor(absPath), result.outputs.get(absPath), "utf-8");
+        const outPath = outputPathFor(absPath);
+        writeFileSync(outPath, result.outputs.get(absPath), "utf-8");
+        const map = result.sourceMaps.get(absPath);
+        // Only a file with real code got a `sourceMappingURL` comment appended
+        // (see codegen.ts) — skip writing an orphaned .map for one that didn't.
+        if (result.outputs.get(absPath).includes("//# sourceMappingURL=")) {
+            writeFileSync(`${outPath}.map`, map, "utf-8");
+        }
     }
     if (jsonMode)
         printJson(result, result.order.map(outputPathFor));
@@ -102,7 +109,10 @@ function run(filePath) {
     const { outPath } = build(filePath);
     if (!outPath)
         return;
-    const result = spawnSync(process.execPath, [outPath], { stdio: "inherit" });
+    // Node has resolved `//# sourceMappingURL` comments natively since v12.12
+    // — this is what makes an uncaught exception during `ks run` show the
+    // real .ks file/line instead of the generated .js, with no extra setup.
+    const result = spawnSync(process.execPath, ["--enable-source-maps", outPath], { stdio: "inherit" });
     process.exitCode = result.status ?? 0;
 }
 // Rebuilds on every save of any file in the graph (not just the entry —

package/dist/codegen.js

@@ -1,3 +1,11 @@
+import { SourceMapBuilder } from "./sourcemap.js";
+function countNewlines(text) {
+    let n = 0;
+    for (let i = 0; i < text.length; i++)
+        if (text[i] === "\n")
+            n++;
+    return n;
+}
 // KopScript's PascalCase stdlib member names, mapped to their real JS names — a
 // blind syntactic rename (codegen has no type information, so this fires on
 // any member access with a matching name, string/array/user-class alike;
@@ -55,19 +63,45 @@ export class CodeGenerator {
         this.matchCounter = 0;
         this.interfaceNames = new Set();
         this.usesState = false;
+        // The current 1-indexed *generated* output line — kept in sync with the
+        // text being built by every method that can introduce a literal `\n`
+        // (genBlock, genClass, genConstructor, genMatch, genInterpolatedString,
+        // and this method's own top-level loop). Nothing else needs to touch it:
+        // a "simple" single-line gen* case just leaves it untouched, and by the
+        // time control returns to whichever loop called it, `outputLine` already
+        // correctly reflects how many lines that call's output actually took —
+        // including a lambda/match-expression buried inside it, since those
+        // recurse back into the same bookkeeping. See sourcemap.ts for the actual
+        // encoder; see README.md's "Source maps" section for the v1 scope this
+        // is deliberately limited to (statement-level, not per-expression/column).
+        this.outputLine = 1;
+    }
+    mark(node, generatedColumn) {
+        this.sourceMap.addMapping(this.outputLine, generatedColumn, node.line, node.col);
     }
     // `usingExports` maps each `using "<path>"` path (as written in source) to
     // the list of names that module exports — resolved by the caller from that
     // module's own checked Program, since a bare `using` brings everything
-    // `public` into scope without naming it explicitly.
-    generate(program, usingExports = new Map(), rawContents = new Map()) {
+    // `public` into scope without naming it explicitly. `sourceFileName`/
+    // `sourceText` are for the emitted source map only (both optional so every
+    // existing test call site keeps compiling unchanged).
+    generate(program, usingExports = new Map(), rawContents = new Map(), sourceFileName = "source.ks", sourceText = "") {
         this.interfaceNames = new Set(program.statements.filter((s) => s.kind === "InterfaceDecl").map((s) => s.name));
+        this.outputLine = 1;
+        const outFileName = sourceFileName.replace(/\.ks$/, ".js");
+        this.sourceMap = new SourceMapBuilder(outFileName, sourceFileName, sourceText);
         const importLines = program.usings
             .map((u) => {
             const names = usingExports.get(u.path) ?? [];
             return names.length > 0 ? `import { ${names.join(", ")} } from "${u.path}.js";` : null;
         })
             .filter((line) => line !== null);
+        // Body statements are generated (and marked) starting from *relative*
+        // line 1 — whether the import/prelude sections actually precede them in
+        // the final output depends on `this.usesState`, which genExpr only
+        // finishes deciding partway through this very loop (StateExpr flips it
+        // lazily). Every mark recorded below gets shifted by the real prefix's
+        // line count right after, once that's known for certain.
         const lines = [];
         for (const stmt of program.statements) {
             if (stmt.kind === "InterfaceDecl")
@@ -78,24 +112,41 @@ export class CodeGenerator {
                 // whatever the class's own binding resolves to at runtime; only the
                 // binding itself (import / ambient alias / re-export) needs emitting.
                 const binding = this.genExternBinding(stmt.name, stmt.jsName, stmt.modulePath, stmt.isExported);
-                if (binding)
+                if (binding) {
+                    this.mark(stmt, 0);
                     lines.push(binding);
+                    this.outputLine += countNewlines(binding) + 1;
+                }
                 continue;
             }
             if (stmt.kind === "RawStringDecl") {
                 const content = rawContents.get(stmt.name) ?? "";
-                lines.push(`${stmt.isExported ? "export const" : "const"} ${stmt.name} = ${JSON.stringify(content)};`);
+                const code = `${stmt.isExported ? "export const" : "const"} ${stmt.name} = ${JSON.stringify(content)};`;
+                this.mark(stmt, 0);
+                lines.push(code);
+                this.outputLine += countNewlines(code) + 1;
                 continue;
             }
+            this.mark(stmt, 0);
             let code = this.genStatement(stmt, 0);
             if ((stmt.kind === "ClassDecl" || stmt.kind === "EnumDecl" || stmt.kind === "FunctionDecl") && stmt.isExported) {
                 code = `export ${code}`;
             }
             lines.push(code);
+            this.outputLine += 1; // move past this statement's own last line, to the "\n" join separator
         }
         const body = lines.join("\n") + "\n";
         const sections = [importLines.join("\n"), this.usesState ? STATE_PRELUDE : "", body].filter((s) => s.length > 0);
-        return sections.join("\n\n");
+        const prefixSections = sections.slice(0, -1); // body is always last (see filter above) and always non-empty
+        const prefixText = prefixSections.length > 0 ? prefixSections.join("\n\n") + "\n\n" : "";
+        this.sourceMap.shiftLines(countNewlines(prefixText));
+        const rawCode = sections.join("\n\n");
+        // A file whose only statements were private/unexported/ambient-with-no-
+        // rename externs (nothing else) legitimately generates zero real code —
+        // leave it exactly empty rather than tacking on a comment pointing at a
+        // map with nothing worth mapping.
+        const code = rawCode.trim().length > 0 ? rawCode + `\n//# sourceMappingURL=${outFileName.split("/").pop()}.map\n` : rawCode;
+        return { code, map: this.sourceMap.toJSON() };
     }
     // Builds the code (if any) that creates the local `name` binding for an
     // extern declaration, wiring in `export` when needed:
@@ -179,11 +230,30 @@ export class CodeGenerator {
         }
         return code;
     }
+    // Entry: `outputLine` is the line the caller's own `{` is being appended
+    // to (a block never starts its own fresh line — see e.g. genIf's ` else `
+    // continuing straight on from the previous block's own closing `}`).
+    // Exit: `outputLine` is left AT this block's own closing-`}` line (not one
+    // past it), so a caller that continues on the same line (`} else {`,
+    // `} catch (e) {`) doesn't need to undo anything, and one that doesn't
+    // (the statement/member loops below) just adds one more line itself.
     genBlock(block, indent) {
         const pad = this.indentStr(indent);
-        if (block.statements.length === 0)
+        if (block.statements.length === 0) {
+            this.outputLine += 1; // the "\n" between "{" and the closing pad}
             return `{\n${pad}}`;
-        const body = block.statements.map((s) => this.genStatement(s, indent + 1)).join("\n");
+        }
+        const memberCol = this.indentStr(indent + 1).length;
+        this.outputLine += 1; // "\n" after "{", moving to the first statement's line
+        const pieces = block.statements.map((s, i) => {
+            this.mark(s, memberCol);
+            const text = this.genStatement(s, indent + 1);
+            if (i < block.statements.length - 1)
+                this.outputLine += 1; // "\n" before the next statement
+            return text;
+        });
+        this.outputLine += 1; // "\n" before the closing pad}
+        const body = pieces.join("\n");
         return `{\n${body}\n${pad}}`;
     }
     genIf(stmt, indent) {
@@ -205,26 +275,48 @@ export class CodeGenerator {
         const prefix = decl.isAsync ? "async function" : "function";
         return `${pad}${prefix} ${decl.name}(${params}) ${this.genBlock(decl.body, indent).trimStart()}`;
     }
+    // Same entry/exit `outputLine` convention as genBlock. The one difference:
+    // members are separated by a full blank line (`.join("\n\n")`), so each
+    // non-last member advances by 2, not 1. Marking has to happen immediately
+    // before each member's *own* generation call (a constructor/method body
+    // can itself contain nested blocks that advance `outputLine` further), so
+    // member sources are built as `{ node, build }` pairs and only invoked
+    // inside the loop below, not gathered as plain strings up front.
     genClass(decl, indent) {
         const pad = this.indentStr(indent);
         // The base list mixes an optional superclass with interface names (checker-validated);
         // only the non-interface entry, if any, becomes a JS `extends` clause.
         const superclass = decl.baseList.find((n) => !this.interfaceNames.has(n)) ?? null;
         const header = superclass ? `class ${decl.name} extends ${superclass} {` : `class ${decl.name} {`;
-        const parts = [];
         const memberPad = this.indentStr(indent + 1);
+        const memberCol = memberPad.length;
+        const sources = [];
         for (const field of decl.fields) {
             if (field.isStatic)
-                parts.push(`${memberPad}static ${field.name} = ${this.genExpr(field.initializer)};`);
+                sources.push({ node: field, build: () => `${memberPad}static ${field.name} = ${this.genExpr(field.initializer)};` });
         }
         if (decl.constructor) {
-            parts.push(this.genConstructor(decl.constructor, indent + 1));
+            const ctor = decl.constructor;
+            sources.push({ node: ctor, build: () => this.genConstructor(ctor, indent + 1) });
         }
         for (const method of decl.methods) {
             const params = method.params.map((p) => p.name).join(", ");
             const prefix = `${method.isStatic ? "static " : ""}${method.isAsync ? "async " : ""}`;
-            parts.push(`${memberPad}${prefix}${method.name}(${params}) ${this.genBlock(method.body, indent + 1).trimStart()}`);
+            sources.push({ node: method, build: () => `${memberPad}${prefix}${method.name}(${params}) ${this.genBlock(method.body, indent + 1).trimStart()}` });
+        }
+        if (sources.length === 0) {
+            this.outputLine += 2; // "\n" after header, "\n" before the closing pad}
+            return `${pad}${header}\n\n${pad}}`;
         }
+        this.outputLine += 1; // "\n" after header, moving to the first member's line
+        const parts = sources.map((m, i) => {
+            this.mark(m.node, memberCol);
+            const text = m.build();
+            if (i < sources.length - 1)
+                this.outputLine += 2; // blank line before the next member
+            return text;
+        });
+        this.outputLine += 1; // "\n" before the closing pad}
         const body = parts.join("\n\n");
         return `${pad}${header}\n${body}\n${pad}}`;
     }
@@ -235,14 +327,36 @@ export class CodeGenerator {
     genConstructor(ctor, indent) {
         const pad = this.indentStr(indent);
         const bodyPad = this.indentStr(indent + 1);
+        const bodyCol = bodyPad.length;
         const params = ctor.params.map((p) => p.name).join(", ");
+        // `super(...)` (if any) has no AST statement node of its own to mark —
+        // it's synthesized from `ctor.baseArgs`, a plain expression list, not a
+        // Statement — so it's the one line in a constructor body that goes
+        // unmapped; every real statement after it still gets its own mark.
+        const hasSuper = ctor.baseArgs !== null;
+        const totalLines = (hasSuper ? 1 : 0) + ctor.body.statements.length;
+        if (totalLines === 0) {
+            this.outputLine += 1; // "\n" before the closing pad}
+            return `${pad}constructor(${params}) {\n${pad}}`;
+        }
+        this.outputLine += 1; // "\n" after "{", moving to the first line
         const lines = [];
-        if (ctor.baseArgs) {
+        let emitted = 0;
+        if (hasSuper) {
             lines.push(`${bodyPad}super(${ctor.baseArgs.map((a) => this.genExpr(a)).join(", ")});`);
+            emitted++;
+            if (emitted < totalLines)
+                this.outputLine += 1;
+        }
+        for (const s of ctor.body.statements) {
+            this.mark(s, bodyCol);
+            lines.push(this.genStatement(s, indent + 1));
+            emitted++;
+            if (emitted < totalLines)
+                this.outputLine += 1;
         }
-        lines.push(...ctor.body.statements.map((s) => this.genStatement(s, indent + 1)));
-        const bodyStr = lines.length > 0 ? `{\n${lines.join("\n")}\n${pad}}` : `{\n${pad}}`;
-        return `${pad}constructor(${params}) ${bodyStr}`;
+        this.outputLine += 1; // "\n" before the closing pad}
+        return `${pad}constructor(${params}) {\n${lines.join("\n")}\n${pad}}`;
     }
     // ---------- expressions ----------
     // genExpr wraps an assignment in parens unconditionally (`(x = y)`), since
@@ -316,7 +430,19 @@ export class CodeGenerator {
     genInterpolatedString(expr) {
         const escapeText = (text) => text.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
         const body = expr.parts
-            .map((part) => (part.kind === "Text" ? escapeText(part.text) : `\${${this.genExpr(part.expression)}}`))
+            .map((part) => {
+            if (part.kind === "Text") {
+                // A `\n` escape in the source literal is already a real newline
+                // character in `part.text` by the time it reaches codegen (the
+                // lexer resolves it) — it lands verbatim in the JS template
+                // literal too (backticks support real embedded newlines), so
+                // `outputLine` has to account for it or every mark recorded after
+                // this point in the file would be off.
+                this.outputLine += countNewlines(part.text);
+                return escapeText(part.text);
+            }
+            return `\${${this.genExpr(part.expression)}}`;
+        })
             .join("");
         return `\`${body}\``;
     }
@@ -348,15 +474,31 @@ export class CodeGenerator {
         const jsProperty = expr.property === "Length" ? "length" : MEMBER_METHOD_MAP[expr.property] ?? expr.property;
         return `${this.genExpr(expr.object)}.${jsProperty}`;
     }
+    // Each arm gets its own mark, at the line its own `if`/`else` opens on —
+    // MatchArm carries `line`/`col` even though its pattern variants don't
+    // (see ast.ts). One known v1 imprecision, same spirit as the rest of this
+    // file's statement-level (not full-expression) granularity: if an arm's
+    // *result* expression itself contains a nested multi-line construct (a
+    // lambda with a block body, or another `match`), the fixed "+1 line" this
+    // method advances by per template line undercounts, and marks recorded
+    // after that arm land one or more lines early. Rare in practice (a match
+    // arm's result is usually a short expression), not attempted here.
     genMatch(expr) {
         const subjectVar = `__subject${this.matchCounter++}`;
-        const lines = [`(() => {`, `  const ${subjectVar} = ${this.genExpr(expr.subject)};`];
+        this.outputLine += 1; // "\n" after "(() => {", moving to the "const subjectN = ..." line
+        const subjectText = this.genExpr(expr.subject);
+        const lines = [`(() => {`, `  const ${subjectVar} = ${subjectText};`];
+        this.outputLine += 1; // "\n" before the first arm's own line
         let emittedIf = false;
         expr.arms.forEach((arm) => {
+            this.mark(arm, 2);
             if (arm.pattern.kind === "WildcardPattern") {
                 lines.push(emittedIf ? `  else {` : `  if (true) {`);
+                this.outputLine += 1;
                 lines.push(`    return ${this.genExpr(arm.result)};`);
+                this.outputLine += 1;
                 lines.push(`  }`);
+                this.outputLine += 1;
                 emittedIf = true;
                 return;
             }
@@ -364,8 +506,11 @@ export class CodeGenerator {
                 ? `new RegExp(${JSON.stringify(arm.pattern.source)}).test(${subjectVar})`
                 : arm.pattern.values.map((v) => `${subjectVar} === ${this.genExpr(v)}`).join(" || ");
             lines.push(`  ${emittedIf ? "else if" : "if"} (${condition}) {`);
+            this.outputLine += 1;
             lines.push(`    return ${this.genExpr(arm.result)};`);
+            this.outputLine += 1;
             lines.push(`  }`);
+            this.outputLine += 1;
             emittedIf = true;
         });
         lines.push(`})()`);

package/dist/diagnostics.js

@@ -2,11 +2,11 @@ export class DiagnosticBag {
     constructor() {
         this.diagnostics = [];
     }
-    error(message, line, col) {
-        this.diagnostics.push({ severity: "error", message, line, col });
+    error(code, message, line, col) {
+        this.diagnostics.push({ code, severity: "error", message, line, col });
     }
-    warning(message, line, col) {
-        this.diagnostics.push({ severity: "warning", message, line, col });
+    warning(code, message, line, col) {
+        this.diagnostics.push({ code, severity: "warning", message, line, col });
     }
     get hasErrors() {
         return this.diagnostics.some((d) => d.severity === "error");
@@ -17,7 +17,7 @@ export class DiagnosticBag {
             .map((d) => {
             const sourceLine = lines[d.line - 1] ?? "";
             const pointer = " ".repeat(Math.max(0, d.col - 1)) + "^";
-            return (`${fileName}:${d.line}:${d.col} - ${d.severity}: ${d.message}\n` +
+            return (`${fileName}:${d.line}:${d.col} - ${d.severity} ${d.code}: ${d.message}\n` +
                 `  ${sourceLine}\n` +
                 `  ${pointer}`);
         })

package/dist/lexer.js

@@ -107,7 +107,7 @@ export class Lexer {
             value += this.readStringChar();
         }
         if (this.isAtEnd()) {
-            this.diagnostics.error("Unterminated string literal", line, col);
+            this.diagnostics.error("KS1001", "Unterminated string literal", line, col);
         }
         else {
             this.advance(); // closing quote
@@ -127,7 +127,7 @@ export class Lexer {
             raw += this.advance();
         }
         if (this.isAtEnd()) {
-            this.diagnostics.error("Unterminated interpolated string literal", line, col);
+            this.diagnostics.error("KS1002", "Unterminated interpolated string literal", line, col);
         }
         else {
             this.advance(); // closing quote
@@ -157,7 +157,7 @@ export class Lexer {
             }
         }
         if (this.isAtEnd()) {
-            this.diagnostics.error("Unterminated regex literal", line, col);
+            this.diagnostics.error("KS1003", "Unterminated regex literal", line, col);
         }
         else {
             this.advance(); // closing quote
@@ -284,7 +284,7 @@ export class Lexer {
                 }
                 break;
         }
-        this.diagnostics.error(`Unexpected character '${c}'`, line, col);
+        this.diagnostics.error("KS1004", `Unexpected character '${c}'`, line, col);
         return this.next();
     }
     make(kind, lexeme, line, col) {

package/dist/modules.js

@@ -1,5 +1,5 @@
 import { existsSync, readFileSync } from "node:fs";
-import { dirname, relative, resolve } from "node:path";
+import { basename, dirname, relative, resolve } from "node:path";
 import { Lexer } from "./lexer.js";
 import { Parser } from "./parser.js";
 import { Checker, emptyModuleExports } from "./checker.js";
@@ -25,21 +25,21 @@ function expandTemplates(program, absPath, diagnostics, fileOverrides) {
             continue;
         const templateRef = stmt.template;
         if (stmt.methods.some((m) => m.name === "Render" && !m.isStatic)) {
-            diagnostics.error(`Class '${stmt.name}' has both a 'template' declaration and a hand-written 'Render()' method — remove one`, templateRef.line, templateRef.col);
+            diagnostics.error("KS3001", `Class '${stmt.name}' has both a 'template' declaration and a hand-written 'Render()' method — remove one`, templateRef.line, templateRef.col);
             continue;
         }
         const templatePath = resolve(dirname(absPath), templateRef.path);
         watchFiles.push(templatePath);
         const exists = fileOverrides?.has(templatePath) || existsSync(templatePath);
         if (!exists) {
-            diagnostics.error(`Cannot find template file '${templateRef.path}' (looked for '${displayPath(templatePath)}')`, templateRef.line, templateRef.col);
+            diagnostics.error("KS3002", `Cannot find template file '${templateRef.path}' (looked for '${displayPath(templatePath)}')`, templateRef.line, templateRef.col);
             continue;
         }
         const templateSource = fileOverrides?.get(templatePath) ?? readFileSync(templatePath, "utf-8");
         const templateDiagnostics = new DiagnosticBag();
         const root = new TemplateParser(templateSource, templateDiagnostics).parseDocument();
         for (const d of templateDiagnostics.diagnostics) {
-            diagnostics.error(`[${templateRef.path}:${d.line}:${d.col}] ${d.message}`, templateRef.line, templateRef.col);
+            diagnostics.error("KS3003", `[${templateRef.path}:${d.line}:${d.col}] ${d.message}`, templateRef.line, templateRef.col);
         }
         if (!root)
             continue;
@@ -48,12 +48,12 @@ function expandTemplates(program, absPath, diagnostics, fileOverrides) {
         const compileDiagnostics = new DiagnosticBag();
         const { renderMethod, autoSubscribeFields } = new TemplateCompiler(memberNames, stateFieldNames, compileDiagnostics).compile(root, templateRef);
         for (const d of compileDiagnostics.diagnostics) {
-            diagnostics.error(`[${templateRef.path}:${d.line}:${d.col}] ${d.message}`, templateRef.line, templateRef.col);
+            diagnostics.error("KS3004", `[${templateRef.path}:${d.line}:${d.col}] ${d.message}`, templateRef.line, templateRef.col);
         }
         stmt.methods.push(renderMethod);
         if (autoSubscribeFields.length > 0) {
             if (!stmt.constructor) {
-                diagnostics.error(`Class '${stmt.name}' has a template referencing state<T> field(s) (${autoSubscribeFields.join(", ")}) but no constructor to subscribe from`, templateRef.line, templateRef.col);
+                diagnostics.error("KS3005", `Class '${stmt.name}' has a template referencing state<T> field(s) (${autoSubscribeFields.join(", ")}) but no constructor to subscribe from`, templateRef.line, templateRef.col);
                 continue;
             }
             for (const fieldName of autoSubscribeFields) {
@@ -128,16 +128,16 @@ export function loadModuleGraph(entryAbsPath, fileOverrides) {
         stack.push(absPath);
         for (const u of program.usings) {
             if (!u.path.startsWith("./") && !u.path.startsWith("../")) {
-                diagnostics.error(`'using' path '${u.path}' must be relative (start with './' or '../')`, u.line, u.col);
+                diagnostics.error("KS3006", `'using' path '${u.path}' must be relative (start with './' or '../')`, u.line, u.col);
                 continue;
             }
             const depPath = resolve(dirname(absPath), u.path) + ".ks";
             if (!exists(depPath)) {
-                diagnostics.error(`Cannot find module '${u.path}' (looked for '${displayPath(depPath)}')`, u.line, u.col);
+                diagnostics.error("KS3007", `Cannot find module '${u.path}' (looked for '${displayPath(depPath)}')`, u.line, u.col);
                 continue;
             }
             if (stack.includes(depPath)) {
-                diagnostics.error(`Circular 'using' dependency: ${[...stack, depPath].map(displayPath).join(" -> ")}`, u.line, u.col);
+                diagnostics.error("KS3008", `Circular 'using' dependency: ${[...stack, depPath].map(displayPath).join(" -> ")}`, u.line, u.col);
                 continue;
             }
             record.dependencies.push(depPath);
@@ -157,7 +157,7 @@ export function loadModuleGraph(entryAbsPath, fileOverrides) {
 export function compileGraph(entryAbsPath, fileOverrides) {
     const { modules, order, entryMissing } = loadModuleGraph(entryAbsPath, fileOverrides);
     if (entryMissing) {
-        return { success: false, entryMissing: true, modules, order, outputs: new Map() };
+        return { success: false, entryMissing: true, modules, order, outputs: new Map(), sourceMaps: new Map() };
     }
     const exportsByModule = new Map();
     const rawContentsByModule = new Map();
@@ -180,7 +180,7 @@ export function compileGraph(entryAbsPath, fileOverrides) {
             const mergeOne = (name, apply) => {
                 const existingFrom = importedFrom.get(name);
                 if (existingFrom && existingFrom !== depPath) {
-                    mod.diagnostics.error(`'${name}' is exported by both '${displayPath(existingFrom)}' and '${displayPath(depPath)}' — ambiguous 'using'`, u.line, u.col);
+                    mod.diagnostics.error("KS3009", `'${name}' is exported by both '${displayPath(existingFrom)}' and '${displayPath(depPath)}' — ambiguous 'using'`, u.line, u.col);
                     return;
                 }
                 importedFrom.set(name, depPath);
@@ -219,9 +219,10 @@ export function compileGraph(entryAbsPath, fileOverrides) {
         rawContentsByModule.set(absPath, checker.getRawContents());
     }
     if (hasErrors) {
-        return { success: false, entryMissing: false, modules, order, outputs: new Map() };
+        return { success: false, entryMissing: false, modules, order, outputs: new Map(), sourceMaps: new Map() };
     }
     const outputs = new Map();
+    const sourceMaps = new Map();
     for (const absPath of order) {
         const mod = modules.get(absPath);
         const usingExports = new Map();
@@ -235,7 +236,13 @@ export function compileGraph(entryAbsPath, fileOverrides) {
                 usingExports.set(u.path, [...importableTypeNames, ...depExports.functions.keys(), ...depExports.externValues.keys()]);
             }
         }
-        outputs.set(absPath, new CodeGenerator().generate(mod.program, usingExports, rawContentsByModule.get(absPath) ?? new Map()));
+        // Just the basename, not a cwd-relative path — the .js.map file always
+        // lands right next to its .ks/.js siblings (ks build writes output in
+        // place), so "sources" has to resolve relative to *that* directory, not
+        // wherever the compiler happened to be invoked from.
+        const { code, map } = new CodeGenerator().generate(mod.program, usingExports, rawContentsByModule.get(absPath) ?? new Map(), basename(absPath), mod.source);
+        outputs.set(absPath, code);
+        sourceMaps.set(absPath, map);
     }
-    return { success: true, entryMissing: false, modules, order, outputs };
+    return { success: true, entryMissing: false, modules, order, outputs, sourceMaps };
 }