nola-lang 0.1.7 → 0.1.8

package/dist/build.d.ts

@@ -1,6 +1,8 @@
 export interface BuildResult {
     written: string[];
     errors: string[];
+    /** non-fatal: same-basename .ts + .tsi pairs (spec decision 5) */
+    warnings: string[];
 }
 export declare function cmdBuild(dirArg?: string, outArg?: string): Promise<BuildResult>;
 //# sourceMappingURL=build.d.ts.map

package/dist/build.js

@@ -2,13 +2,13 @@ import { existsSync } from "node:fs";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import remappingImport from "@ampproject/remapping";
-import { Codes } from "@nola-lang/ast";
-import { companionSourceCandidates, companionSpecifierFor, compileCompanion, compileNola } from "@nola-lang/compiler";
 import { bundleSelfConfiguringConfig, findProjectRoot, loadBuildOptions, loadCompilerOptions, } from "@nola-lang/node-loader";
 import { transformSync } from "esbuild";
+import { createProjectDeriver } from "./derive.js";
 import { printDiagnostics } from "./diag.js";
 import { emitDeclarationTexts } from "./tshost-declarations.js";
-import { walkProject } from "./walk.js";
+import { danglingViewErrors } from "./views.js";
+import { siblingWarning, walkProject } from "./walk.js";
 const remapping = remappingImport;
 /** First line of the emitted config bundle; the overwrite guard keys on it. */
 const CONFIG_BUNDLE_MARKER = "// generated by nola build — self-configuring Nola config bundle";
@@ -23,20 +23,15 @@ export async function cmdBuild(dirArg = ".", outArg = "dist") {
     const written = [];
     const errors = [];
     const lowered = [];
-    const metas = [];
-    const { tsi, reserved } = await walkProject(dir);
-    for (const file of reserved) {
-        errors.push(`${file} ${Codes.ReservedCompanionPath}: the *.nola.* filename namespace is reserved for generated companion modules — rename this file`);
-    }
-    if (errors.length > 0)
-        return { written, errors };
+    const { tsi, siblings } = await walkProject(dir);
+    const warnings = siblings.map(siblingWarning);
     // App builds ship the config: bundle nola.config.ts (relative imports
     // inlined, packages external) with a self-configuring wrapper, emitted
     // first so a bad config fails the build before any compilation.
     if (wireConfig) {
         if (existsSync(configOutPath) && !(await readFile(configOutPath, "utf8")).startsWith(CONFIG_BUNDLE_MARKER)) {
             errors.push(`${configOutPath}: exists and was not generated by nola build — refusing to overwrite. Is another toolchain compiling nola.config.ts into --out?`);
-            return { written, errors };
+            return { written, errors, warnings };
         }
         try {
             const bundled = await bundleSelfConfiguringConfig(configPath);
@@ -46,81 +41,82 @@ export async function cmdBuild(dirArg = ".", outArg = "dist") {
         }
         catch (err) {
             errors.push(err instanceof Error ? err.message : String(err));
-            return { written, errors };
+            return { written, errors, warnings };
         }
     }
-    for (const file of tsi) {
-        const source = await readFile(file, "utf8");
-        const result = compileNola(source, file, { sourceRoot, underivableContextType });
-        if (result.diagnostics.length > 0) {
-            errors.push(printDiagnostics(result.diagnostics, () => source));
-            continue;
-        }
-        lowered.push({ file, loweredCode: result.code });
-        metas.push(result.meta.companions);
-        // The wiring import is appended to the TRANSFORM INPUT only — the
-        // declarations pass reuses result.code and must never see it. EOF keeps
-        // positions intact; the appended line has no counterpart in result.map,
-        // so it stays unmapped after the merge.
-        const outPath = `${join(out, relative(dir, file))}.js`;
-        let emitCode = result.code;
-        if (wireConfig) {
-            const rel = relative(dirname(outPath), configOutPath).replace(/\\/g, "/");
-            emitCode = `${result.code}\nimport ${JSON.stringify(rel.startsWith(".") ? rel : `./${rel}`)};\n`;
-        }
-        const js = transformSync(emitCode, { loader: "ts", format: "esm", sourcemap: "external", sourcefile: file });
-        let consumed = false;
-        const merged = remapping(js.map, () => {
-            if (consumed)
-                return null;
-            consumed = true;
-            return result.map;
-        });
-        await mkdir(dirname(outPath), { recursive: true });
-        await writeFile(outPath, `${js.code}\n//# sourceMappingURL=${basename(outPath)}.map\n`);
-        await writeFile(`${outPath}.map`, merged.toString());
-        written.push(outPath, `${outPath}.map`);
+    const deriver = createProjectDeriver(dir, sourceRoot, underivableContextType);
+    try {
+        return await buildWith(deriver);
     }
-    // Companion worklist: every reachable type source gets one real module in
-    // dist, named by the same forward transform the lowered imports use — so
-    // production output needs no loader at all.
-    const emittedCompanions = new Set();
-    const companionQueue = lowered.flatMap((entry, i) => (metas[i] ?? []).map((specifier) => ({ importer: entry.file, specifier })));
-    while (companionQueue.length > 0) {
-        const { importer, specifier } = companionQueue.shift();
-        const src = companionSourceCandidates(specifier)
-            .map((c) => resolve(dirname(importer), c))
-            .find((p) => existsSync(p));
-        if (!src) {
-            errors.push(`${importer} ${Codes.CompanionUnavailable}: cannot locate the type source for "${specifier}"`);
-            continue;
+    finally {
+        deriver.dispose();
+    }
+    async function buildWith(deriver) {
+        for (const file of tsi) {
+            const source = await readFile(file, "utf8");
+            // phase 1 + the checker pass (emit 15): the appendix accessors carry real bodies from here on
+            const result = deriver.lower(file, source);
+            if (result.diagnostics.length > 0) {
+                errors.push(printDiagnostics(result.diagnostics, () => source));
+                continue;
+            }
+            lowered.push({ file, loweredCode: result.code });
+            errors.push(...danglingViewErrors(file, result.meta.views));
+            // The wiring import is appended to the TRANSFORM INPUT only — the
+            // declarations pass reuses result.code and must never see it. EOF keeps
+            // positions intact; the appended line has no counterpart in result.map,
+            // so it stays unmapped after the merge.
+            const outPath = `${join(out, relative(dir, file))}.js`;
+            let emitCode = result.code;
+            if (wireConfig) {
+                const rel = relative(dirname(outPath), configOutPath).replace(/\\/g, "/");
+                emitCode = `${result.code}\nimport ${JSON.stringify(rel.startsWith(".") ? rel : `./${rel}`)};\n`;
+            }
+            const js = transformSync(emitCode, { loader: "ts", format: "esm", sourcemap: "external", sourcefile: file });
+            let consumed = false;
+            const merged = remapping(js.map, () => {
+                if (consumed)
+                    return null;
+                consumed = true;
+                return result.map;
+            });
+            await mkdir(dirname(outPath), { recursive: true });
+            await writeFile(outPath, `${js.code}\n//# sourceMappingURL=${basename(outPath)}.map\n`);
+            await writeFile(`${outPath}.map`, merged.toString());
+            written.push(outPath, `${outPath}.map`);
         }
-        if (emittedCompanions.has(src))
-            continue;
-        emittedCompanions.add(src);
-        const companion = compileCompanion(await readFile(src, "utf8"), src, { sourceRoot });
-        if (companion.code === "" || companion.diagnostics.length > 0) {
-            errors.push(printDiagnostics(companion.diagnostics, () => ""));
-            continue;
+        const decl = await emitDeclarationTexts(lowered, sourceRoot, dir, { deriveView: deriver.viewCode });
+        for (const [file, declarationText] of decl.tsi) {
+            // Next to the built .js in --out (report.tsi.js + report.tsi.d.ts pair
+            // under NodeNext), NEVER adjacent to the source: the editor serves
+            // .tsi virtually, and an on-disk declaration would only shadow it.
+            const dtsPath = `${join(out, relative(dir, file))}.d.ts`;
+            await mkdir(dirname(dtsPath), { recursive: true });
+            await writeFile(dtsPath, declarationText);
+            written.push(dtsPath);
         }
-        const js = transformSync(companion.code, { loader: "ts", format: "esm" });
-        const outName = companionSpecifierFor(basename(src));
-        const outPath = join(out, relative(dir, join(dirname(src), outName)));
-        await mkdir(dirname(outPath), { recursive: true });
-        await writeFile(outPath, js.code);
-        written.push(outPath);
-        companionQueue.push(...companion.companions.map((c) => ({ importer: src, specifier: c })));
-    }
-    const texts = await emitDeclarationTexts(lowered, metas, sourceRoot, dir);
-    for (const [file, declarationText] of texts) {
-        // Next to the built .js in --out (report.tsi.js + report.tsi.d.ts pair
-        // under NodeNext), NEVER adjacent to the source: the editor serves
-        // .tsi virtually, and an on-disk declaration would only shadow it.
-        const dtsPath = `${join(out, relative(dir, file))}.d.ts`;
-        await mkdir(dirname(dtsPath), { recursive: true });
-        await writeFile(dtsPath, declarationText);
-        written.push(dtsPath);
+        // Every VIEW the program reached becomes a real `<base>.tsi.js` +
+        // `<base>.tsi.d.ts` pair beside the lowered output — the NodeNext pair real
+        // .tsi files get — so production output needs no loader at all. The view
+        // re-exports `./<base>.js`, so the plain module compiles into the same tree.
+        for (const [viewSource, declarationText] of decl.views) {
+            const src = resolve(viewSource); // tshost keys views by posix path; `written` stays platform-native
+            const base = basename(src).replace(/\.d\.ts$|\.ts$/, "");
+            const outDir = join(out, relative(dir, dirname(src)));
+            const viewCode = deriver.viewCode(src);
+            if (viewCode === undefined) {
+                errors.push(`${src}: the view of this module could not be derived (see the diagnostics above)`);
+                continue;
+            }
+            const js = transformSync(viewCode, { loader: "ts", format: "esm" });
+            await mkdir(outDir, { recursive: true });
+            const jsPath = join(outDir, `${base}.tsi.js`);
+            const dtsPath = join(outDir, `${base}.tsi.d.ts`);
+            await writeFile(jsPath, js.code);
+            await writeFile(dtsPath, declarationText);
+            written.push(jsPath, dtsPath);
+        }
+        return { written, errors, warnings };
     }
-    return { written, errors };
 }
 //# sourceMappingURL=build.js.map

package/dist/check.d.ts

@@ -1,4 +1,5 @@
 export declare function cmdCheck(dirArg?: string): Promise<{
     errors: string[];
+    warnings: string[];
 }>;
 //# sourceMappingURL=check.d.ts.map

package/dist/check.js

@@ -1,71 +1,72 @@
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import { originalPositionFor, TraceMap } from "@jridgewell/trace-mapping";
-import { Codes } from "@nola-lang/ast";
-import { compileNola } from "@nola-lang/compiler";
 import { findProjectRoot, loadCompilerOptions } from "@nola-lang/node-loader";
 import ts from "typescript";
-import { collectCompanionEntries } from "./companions.js";
+import { createProjectDeriver } from "./derive.js";
 import { printDiagnostics } from "./diag.js";
 import { createLoweredProgram } from "./tshost.js";
-import { walkProject } from "./walk.js";
+import { danglingViewErrors } from "./views.js";
+import { siblingWarning, walkProject } from "./walk.js";
 export async function cmdCheck(dirArg = ".") {
     const dir = resolve(dirArg);
     // Check the same text `nola build` emits, so the two can't drift.
     const sourceRoot = findProjectRoot(dir);
     const { underivableContextType } = await loadCompilerOptions(dir);
     const errors = [];
-    const { tsi, reserved } = await walkProject(dir);
-    for (const file of reserved) {
-        errors.push(`${file} ${Codes.ReservedCompanionPath}: the *.nola.* filename namespace is reserved for generated companion modules — rename this file`);
-    }
-    if (errors.length > 0)
-        return { errors };
+    const { tsi, siblings } = await walkProject(dir);
+    const warnings = siblings.map(siblingWarning);
     const entries = [];
     const maps = new Map();
-    const seeds = [];
-    for (const file of tsi) {
-        const source = await readFile(file, "utf8");
-        const result = compileNola(source, file, { sourceRoot, underivableContextType });
-        if (result.diagnostics.length > 0) {
-            errors.push(printDiagnostics(result.diagnostics, () => source));
-            continue;
-        }
-        entries.push({ file, loweredCode: result.code });
-        maps.set(file, result.map);
-        seeds.push({ file, companions: result.meta.companions });
-    }
-    if (entries.length === 0)
-        return { errors };
-    const companionEntries = await collectCompanionEntries(seeds, sourceRoot);
-    errors.push(...companionEntries.errors);
-    const { program, virtualName } = createLoweredProgram(entries, dir, "check", companionEntries.virtual);
-    const virtualToFile = new Map(entries.map((e) => [virtualName(e.file).replace(/\\/g, "/"), e.file]));
-    for (const d of ts.getPreEmitDiagnostics(program)) {
-        if (!d.file || d.start === undefined)
-            continue;
-        const fileName = d.file.fileName.replace(/\\/g, "/");
-        const message = ts.flattenDiagnosticMessageText(d.messageText, " ");
-        const companionSource = companionEntries.sources.get(fileName);
-        if (companionSource) {
-            // Diagnostics policy: never report into a file the user cannot open.
-            errors.push(`${companionSource}:1:1 TS${d.code}: in derived type module: ${message}`);
-            continue;
+    const deriver = createProjectDeriver(dir, sourceRoot, underivableContextType);
+    try {
+        for (const file of tsi) {
+            const source = await readFile(file, "utf8");
+            // phase 1 + the checker pass: NOLA2002 / NOLA2008 arrive with the lowering diagnostics
+            const result = deriver.lower(file, source);
+            if (result.diagnostics.length > 0) {
+                errors.push(printDiagnostics(result.diagnostics, () => source));
+                continue;
+            }
+            entries.push({ file, loweredCode: result.code });
+            maps.set(file, result.map);
+            errors.push(...danglingViewErrors(file, result.meta.views));
         }
-        const original = virtualToFile.get(fileName);
-        if (!original) {
-            // A real on-disk file (a plain .ts project root): position it directly.
-            const pos = d.file.getLineAndCharacterOfPosition(d.start);
-            errors.push(`${d.file.fileName}:${pos.line + 1}:${pos.character + 1} TS${d.code}: ${message}`);
-            continue;
+        if (entries.length === 0)
+            return { errors, warnings };
+        const { program, virtualName, views } = createLoweredProgram(entries, dir, "check", sourceRoot, {
+            deriveView: deriver.viewCode,
+        });
+        const virtualToFile = new Map(entries.map((e) => [virtualName(e.file).replace(/\\/g, "/"), e.file]));
+        for (const d of ts.getPreEmitDiagnostics(program)) {
+            if (!d.file || d.start === undefined)
+                continue;
+            const fileName = d.file.fileName.replace(/\\/g, "/");
+            const message = ts.flattenDiagnosticMessageText(d.messageText, " ");
+            const viewSource = views.get(fileName);
+            if (viewSource) {
+                // Diagnostics policy: never report into a file the user cannot open.
+                errors.push(`${viewSource}:1:1 TS${d.code}: in derived type module: ${message}`);
+                continue;
+            }
+            const original = virtualToFile.get(fileName);
+            if (!original) {
+                // A real on-disk file (a plain .ts project root): position it directly.
+                const pos = d.file.getLineAndCharacterOfPosition(d.start);
+                errors.push(`${d.file.fileName}:${pos.line + 1}:${pos.character + 1} TS${d.code}: ${message}`);
+                continue;
+            }
+            const generated = d.file.getLineAndCharacterOfPosition(d.start);
+            const tracer = new TraceMap(maps.get(original));
+            const pos = originalPositionFor(tracer, { line: generated.line + 1, column: generated.character });
+            const line = pos.line ?? generated.line + 1;
+            const column = (pos.column ?? generated.character) + 1;
+            errors.push(`${original}:${line}:${column} TS${d.code}: ${message}`);
         }
-        const generated = d.file.getLineAndCharacterOfPosition(d.start);
-        const tracer = new TraceMap(maps.get(original));
-        const pos = originalPositionFor(tracer, { line: generated.line + 1, column: generated.character });
-        const line = pos.line ?? generated.line + 1;
-        const column = (pos.column ?? generated.character) + 1;
-        errors.push(`${original}:${line}:${column} TS${d.code}: ${message}`);
+        return { errors, warnings };
+    }
+    finally {
+        deriver.dispose();
     }
-    return { errors };
 }
 //# sourceMappingURL=check.js.map

package/dist/commands.d.ts

@@ -6,6 +6,7 @@ import { type CliIo, type CommandSpec, type Palette } from "create-nola-lang";
 export declare function report(label: string, result: {
     written?: string[];
     errors: string[];
+    warnings?: string[];
 }, separator: string, io?: CliIo, p?: Palette): number;
 export declare const COMMANDS: readonly CommandSpec[];
 //# sourceMappingURL=commands.d.ts.map

package/dist/commands.js

@@ -18,6 +18,9 @@ const consoleIo = { log: (m) => console.log(m), error: (m) => console.error(m) }
  * summary (exit 0): the file count when it writes, "no errors" otherwise.
  */
 export function report(label, result, separator, io = consoleIo, p = ansi) {
+    // Non-fatal (a same-basename .ts + .tsi pair): stderr, no exit-code change.
+    for (const warning of result.warnings ?? [])
+        io.error(`warning: ${warning}`);
     if (result.errors.length > 0) {
         io.error(styleDiagnostics(result.errors.join(separator), p));
         return 1;
@@ -53,10 +56,10 @@ export const COMMANDS = [
     }),
     defineCommand({
         name: "skill",
-        summary: "write agent skill files (Claude Code, Cursor, Copilot, AGENTS.md) into the project",
+        summary: "write the Nola agent skill (.claude/skills, .agents/skills) and/or AGENTS.md into the project",
         args: "install",
         options: {
-            agents: { type: "string", description: "claude,cursor,copilot,agents-md | all | none" },
+            agents: { type: "string", description: "claude,universal,agents-md | all | none" },
             force: { type: "boolean", description: "replace files stamped by another Nola version" },
         },
         run: ({ positionals: [sub], values }) => cmdSkill(sub, { agents: values.agents, force: values.force }),

package/dist/declarations.d.ts

@@ -1,13 +1,16 @@
 /** report.tsi → report.d.tsi.ts, adjacent — TS allowArbitraryExtensions resolves it. */
 export declare function adjacentDeclarationPath(tsiFile: string): string;
+/** models.ts / api.d.ts → models.d.tsi.ts / api.d.tsi.ts: the declaration of the module's VIEW. */
+export declare function adjacentViewDeclarationPath(viewSourceFile: string): string;
 /**
- * Emit <base>.d.tsi.ts next to each .tsi so PLAIN tsc (and framework builds
- * like `next build`) resolve .tsi imports via allowArbitraryExtensions.
- * The editor hides these when the sibling .tsi exists; `nola check` excludes
- * them from roots.
+ * Emit <base>.d.tsi.ts next to each .tsi — and next to each plain module
+ * reached as a VIEW — so PLAIN tsc (and framework builds like `next build`)
+ * resolve `.tsi` imports via allowArbitraryExtensions. The editor hides these
+ * when the sibling .tsi exists; `nola check` excludes them from roots.
  */
 export declare function emitAdjacentDeclarations(dirArg?: string): Promise<{
     written: string[];
     errors: string[];
+    warnings: string[];
 }>;
 //# sourceMappingURL=declarations.d.ts.map

package/dist/declarations.js

@@ -1,20 +1,24 @@
 import { readFile, writeFile } from "node:fs/promises";
 import { resolve } from "node:path";
-import { Codes } from "@nola-lang/ast";
-import { compileNola } from "@nola-lang/compiler";
 import { findProjectRoot, loadCompilerOptions } from "@nola-lang/node-loader";
+import { createProjectDeriver } from "./derive.js";
 import { printDiagnostics } from "./diag.js";
 import { emitDeclarationTexts } from "./tshost-declarations.js";
-import { walkProject } from "./walk.js";
+import { danglingViewErrors } from "./views.js";
+import { siblingWarning, walkProject } from "./walk.js";
 /** report.tsi → report.d.tsi.ts, adjacent — TS allowArbitraryExtensions resolves it. */
 export function adjacentDeclarationPath(tsiFile) {
     return `${tsiFile.slice(0, -".tsi".length)}.d.tsi.ts`;
 }
+/** models.ts / api.d.ts → models.d.tsi.ts / api.d.tsi.ts: the declaration of the module's VIEW. */
+export function adjacentViewDeclarationPath(viewSourceFile) {
+    return `${viewSourceFile.replace(/\.d\.ts$|\.ts$/, "")}.d.tsi.ts`;
+}
 /**
- * Emit <base>.d.tsi.ts next to each .tsi so PLAIN tsc (and framework builds
- * like `next build`) resolve .tsi imports via allowArbitraryExtensions.
- * The editor hides these when the sibling .tsi exists; `nola check` excludes
- * them from roots.
+ * Emit <base>.d.tsi.ts next to each .tsi — and next to each plain module
+ * reached as a VIEW — so PLAIN tsc (and framework builds like `next build`)
+ * resolve `.tsi` imports via allowArbitraryExtensions. The editor hides these
+ * when the sibling .tsi exists; `nola check` excludes them from roots.
  */
 export async function emitAdjacentDeclarations(dirArg = ".") {
     const dir = resolve(dirArg);
@@ -22,30 +26,38 @@ export async function emitAdjacentDeclarations(dirArg = ".") {
     const { underivableContextType } = await loadCompilerOptions(dir);
     const written = [];
     const errors = [];
-    const { tsi, reserved } = await walkProject(dir);
-    for (const file of reserved) {
-        errors.push(`${file} ${Codes.ReservedCompanionPath}: the *.nola.* filename namespace is reserved for generated companion modules — rename this file`);
-    }
-    if (errors.length > 0)
-        return { written, errors };
+    const { tsi, siblings } = await walkProject(dir);
+    const warnings = siblings.map(siblingWarning);
     const lowered = [];
-    const metas = [];
-    for (const file of tsi) {
-        const source = await readFile(file, "utf8");
-        const result = compileNola(source, file, { sourceRoot, underivableContextType });
-        if (result.diagnostics.length > 0) {
-            errors.push(printDiagnostics(result.diagnostics, () => source));
-            continue;
+    const deriver = createProjectDeriver(dir, sourceRoot, underivableContextType);
+    let decl;
+    try {
+        for (const file of tsi) {
+            const source = await readFile(file, "utf8");
+            const result = deriver.lower(file, source);
+            if (result.diagnostics.length > 0) {
+                errors.push(printDiagnostics(result.diagnostics, () => source));
+                continue;
+            }
+            lowered.push({ file, loweredCode: result.code });
+            errors.push(...danglingViewErrors(file, result.meta.views));
         }
-        lowered.push({ file, loweredCode: result.code });
-        metas.push(result.meta.companions);
+        decl = await emitDeclarationTexts(lowered, sourceRoot, dir, { deriveView: deriver.viewCode });
+    }
+    finally {
+        deriver.dispose();
     }
-    const texts = await emitDeclarationTexts(lowered, metas, sourceRoot, dir);
-    for (const [file, text] of texts) {
+    for (const [file, text] of decl.tsi) {
         const dtsPath = adjacentDeclarationPath(file);
         await writeFile(dtsPath, text);
         written.push(dtsPath);
     }
-    return { written, errors };
+    for (const [src, text] of decl.views) {
+        // tshost keys views by posix path; `resolve` restores the platform form for `written`
+        const dtsPath = adjacentViewDeclarationPath(resolve(src));
+        await writeFile(dtsPath, text);
+        written.push(dtsPath);
+    }
+    return { written, errors, warnings };
 }
 //# sourceMappingURL=declarations.js.map

package/dist/derive.d.ts

@@ -0,0 +1,21 @@
+import { type CompileResult } from "@nola-lang/compiler";
+import type { UnderivableContextTypeMode } from "@nola-lang/core";
+import { type DerivationService } from "@nola-lang/derive";
+/**
+ * The checker-backed derivation seam of `nola build` / `nola check` /
+ * `nola declarations` (emit 15): one DerivationService per command, phase 1
+ * → answers → finalize for every `.tsi`, and the finalized view of every plain
+ * module the lowered program reaches (fed to tshost through its `deriveView`
+ * hook, so the program type-checks the REAL bodies — the UnsupportedType
+ * elaboration included — and the emitted `.tsi.js` of a view is complete).
+ */
+export interface ProjectDeriver {
+    readonly service: DerivationService;
+    /** phase 1 + derive + finalize; `diagnostics` carries NOLA2002 / NOLA2008 next to the parse/lower ones */
+    lower(file: string, source: string): CompileResult;
+    /** finalized code of the view of `source` (x.ts / x.d.ts), memoized; undefined when the source does not parse */
+    viewCode(source: string): string | undefined;
+    dispose(): void;
+}
+export declare function createProjectDeriver(projectDir: string, sourceRoot: string, underivableContextType: UnderivableContextTypeMode): ProjectDeriver;
+//# sourceMappingURL=derive.d.ts.map

package/dist/derive.js

@@ -0,0 +1,27 @@
+import { compileNola, finalizeDerivations } from "@nola-lang/compiler";
+import { createDerivationService } from "@nola-lang/derive";
+export function createProjectDeriver(projectDir, sourceRoot, underivableContextType) {
+    const service = createDerivationService({ projectRoot: projectDir, sourceRoot, underivableContextType });
+    const views = new Map();
+    return {
+        service,
+        lower(file, source) {
+            const phase1 = compileNola(source, file, { sourceRoot, underivableContextType });
+            if (phase1.diagnostics.length > 0)
+                return phase1;
+            return finalizeDerivations(phase1, service.derive(file, phase1).answers, file);
+        },
+        viewCode(source) {
+            const key = source.replace(/\\/g, "/");
+            if (!views.has(key)) {
+                const view = service.deriveView(source);
+                views.set(key, view.code === "" || view.diagnostics.length > 0 ? undefined : view.code);
+            }
+            return views.get(key);
+        },
+        dispose() {
+            service.dispose();
+        },
+    };
+}
+//# sourceMappingURL=derive.js.map

package/dist/skill.d.ts

@@ -1,4 +1,4 @@
-/** `nola skill install` — write agent skill adapters into the current project. */
+/** `nola skill install` — write the agent skill (.claude/skills, .agents/skills) and/or AGENTS.md into the current project. */
 export declare function cmdSkill(sub: string | undefined, opts: {
     agents?: string;
     force?: boolean;

package/dist/skill.js

@@ -1,6 +1,6 @@
 import { runSkillInstall } from "create-nola-lang";
-const USAGE = "nola skill install [--agents claude,cursor,copilot,agents-md | all | none] [--force]";
-/** `nola skill install` — write agent skill adapters into the current project. */
+const USAGE = "nola skill install [--agents claude,universal,agents-md | all | none] [--force]";
+/** `nola skill install` — write the agent skill (.claude/skills, .agents/skills) and/or AGENTS.md into the current project. */
 export async function cmdSkill(sub, opts) {
     if (sub !== "install") {
         console.log(USAGE);

package/dist/style.js

@@ -1,5 +1,5 @@
 // `path:line:col CODE: message` (build/check/declarations), or `path CODE: message`
-// for the position-less reserved-companion refusal. The path is everything
+// for a position-less refusal such as a dangling view import (NOLA2007). The path is everything
 // before the last `:line:col` — a Windows drive letter carries its own colon.
 const HEAD = /^(.+?)(:\d+:\d+)? ((?:NOLA|TS)\d+): /;
 const GUTTER = /^(\d+ \|)( .*)?$/;

package/dist/tshost-declarations.d.ts

@@ -1,8 +1,14 @@
-import { type LoweredEntry } from "./tshost.js";
+import { type LoweredEntry, type LoweredProgramHooks } from "./tshost.js";
+export interface DeclarationTexts {
+    /** .tsi source path -> its declaration text */
+    tsi: Map<string, string>;
+    /** viewed plain-module source path (x.ts / x.d.ts) -> the view's declaration text */
+    views: Map<string, string>;
+}
 /**
- * Declaration text per lowered .tsi, from one shared lowered program —
- * extracted from cmdBuild so `nola build` (--out pair) and
- * `nola declarations` (adjacent d.tsi.ts) cannot drift.
+ * Declaration text per lowered .tsi — and per VIEW the program reached —
+ * from one shared lowered program, extracted from cmdBuild so `nola build`
+ * (--out pairs) and `nola declarations` (adjacent d.tsi.ts) cannot drift.
  */
-export declare function emitDeclarationTexts(lowered: LoweredEntry[], metas: string[][], sourceRoot: string, projectDir: string): Promise<Map<string, string>>;
+export declare function emitDeclarationTexts(lowered: LoweredEntry[], sourceRoot: string, projectDir: string, hooks?: LoweredProgramHooks): Promise<DeclarationTexts>;
 //# sourceMappingURL=tshost-declarations.d.ts.map