@greenpandastudios/aug-cli 0.19.0

package/src/policies.js

@@ -0,0 +1,130 @@
+import { basename, dirname, join, relative } from 'node:path';
+import { orderGraph } from "./di.js";
+import { javadocBefore } from "./javadoc.js";
+import { callableDocumentation } from "./documentation.js";
+export function projectPolicies(project) {
+    const diagnostics = [];
+    const enabled = (name) => project.config.lint.includes(name);
+    const report = (span, message, code, warning = false) => diagnostics.push({
+        file: span.file, line: span.line, column: span.column, message, code, severity: warning ? 'warning' : 'error'
+    });
+    const modules = new Map();
+    const module = (path) => relative(project.sourceRoot, dirname(path)).replaceAll('\\', '/') || '.';
+    const rules = project.config.module_dependencies.map(rule => {
+        const [owner, targets] = rule.split(':');
+        return { owner: owner.trim(), targets: targets.split(',').map(target => target.trim()).filter(Boolean) };
+    });
+    const matches = (pattern, value) => pattern === '*' || pattern.endsWith('/*') ?
+        pattern === '*' || value === pattern.slice(0, -2) || value.startsWith(pattern.slice(0, -1)) : pattern === value;
+    for (const file of project.files.values()) {
+        if (file.builtin || basename(file.path) === 'export.aug')
+            continue;
+        const edges = new Set();
+        for (const item of file.items)
+            if (item.kind === 'import') {
+                const imports = project.imports.get(item) ?? [];
+                for (const def of imports) {
+                    if (def.file !== file.path && !project.files.get(def.file)?.builtin)
+                        edges.add(def.file);
+                    const from = module(file.path), to = project.files.get(def.file)?.package ? item.from.join('/') : module(def.file);
+                    const rule = rules.find(rule => matches(rule.owner, from));
+                    if (!file.package && rule && from !== to && !project.files.get(def.file)?.builtin && !rule.targets.some(target => matches(target, to)))
+                        report(item.span, `${from} may not depend on ${to}; allowed: ${rule.targets.join(', ') || 'none'}`, 'MODULE');
+                    if (!file.package && project.config.strict_modules && dirname(def.file) === dirname(file.path)) {
+                        const surface = project.files.get(join(dirname(def.file), 'export.aug'));
+                        if (!surface?.items.some(entry => entry.kind === 'export' && entry.name === def.name && entry.from === basename(def.file, '.aug')))
+                            report(item.span, `Strict modules require ${def.name} from ${basename(def.file)} to appear in this folder's export.aug`, 'MODULE');
+                    }
+                }
+                if (!file.package && item.everything && enabled('wildcard_imports'))
+                    report(item.span, 'Expand everything to explicit named imports to keep dependencies visible', 'LINT', true);
+            }
+        modules.set(file.path, { key: file.path, dependencies: [...edges], span: file.items[0]?.span ?? { file: file.path, start: 0, end: 0, line: 1, column: 1 } });
+        if (file.package)
+            continue;
+        const publicNodes = file.items.filter(item => ['class', 'interface', 'interceptor', 'function', 'composition'].includes(item.kind) && 'name' in item && !item.name.startsWith('_'));
+        if (enabled('architecture') && edges.size > project.config.max_dependencies)
+            report(modules.get(file.path).span, `${basename(file.path)} depends on ${edges.size} files; consider a smaller module contract`, 'LINT', true);
+        const publicMembers = publicNodes.reduce((count, node) => count + 1 + ('methods' in node ? node.methods.filter(method => !method.name.startsWith('_')).length : 0) +
+            ('fields' in node ? node.fields.filter(field => !field.name.startsWith('_')).length : 0), 0);
+        if (enabled('public_helpers') && publicMembers > project.config.max_public_symbols)
+            report(modules.get(file.path).span, `${publicMembers} public declarations and members; prefix implementation helpers with _ or expose a smaller folder surface`, 'LINT', true);
+        if (enabled('public_helpers'))
+            for (const node of publicNodes)
+                if (node.kind === 'function') {
+                    const def = project.scopes.get(file.path)?.get(node.name);
+                    const imported = [...project.imports.values()].some(imports => imports.some(imported => imported.id === def?.id));
+                    const exported = project.files.get(join(dirname(file.path), 'export.aug'))?.items.some(item => item.kind === 'export' && item.name === node.name && item.from === basename(file.path, '.aug'));
+                    const others = file.items.filter(item => item !== node);
+                    const called = (value) => !!value && typeof value === 'object' && (Array.isArray(value) ? value.some(called) :
+                        value.kind === 'name' && value.name === node.name ||
+                            Object.entries(value).some(([key, child]) => key !== 'span' && called(child)));
+                    if (!imported && !exported && called(others))
+                        report(node.span, `${node.name} is only used within this file; prefix an implementation helper with _`, 'LINT', true);
+                }
+    }
+    orderGraph([...modules.values()], (node, path) => report(node.span, `Import cycle: ${path.map(path => relative(project.root, path)).join(' -> ')}`, 'MODULE'));
+    for (const def of project.definitions.values()) {
+        if (project.files.get(def.file)?.builtin)
+            continue;
+        const source = project.files.get(def.file).source;
+        const declarations = [def.node, ...('methods' in def.node ? def.node.methods : [])];
+        for (const node of declarations) {
+            const doc = javadocBefore(source, 'annotations' in node && node.annotations?.length ? node.annotations[0].span.start : node.span.start);
+            const effectiveDoc = node.kind === 'function' ? callableDocumentation(project, node, def) : doc;
+            const own = !project.files.get(def.file)?.package;
+            const publicNode = !def.name.startsWith('_') && !node.name.startsWith('_');
+            const required = own && (project.config.spec.require_comments === 'all' || project.config.spec.require_comments === 'public' && publicNode);
+            if (required && !effectiveDoc)
+                report(node.span, `Document ${node.name} with Javadoc; main.yaml spec.require_comments is ${project.config.spec.require_comments}`, 'DOC');
+            else if (own && publicNode && enabled('public_docs') && !effectiveDoc)
+                report(node.span, `Document public ${node.name}'s contract with Javadoc`, 'DOC', true);
+            if (doc) {
+                const params = 'params' in node ? node.params : 'fields' in node ? node.fields : [];
+                for (const label of doc.parameters.keys())
+                    if (!params.some(param => (param.label ?? param.name) === label))
+                        report(node.span, `@param ${label} does not name a public input of ${node.name}`, 'DOC');
+                for (const tag of doc.tags ?? []) {
+                    if (['return', 'returns'].includes(tag.name) && !('returns' in node && node.returns.name !== 'void'))
+                        report(node.span, `@${tag.name} requires a value-returning callable`, 'DOC');
+                    if (['throws', 'exception'].includes(tag.name)) {
+                        const name = tag.value.split(/\s/)[0];
+                        const errors = 'throws' in node ? node.throws : 'validationErrors' in node ? node.validationErrors ?? [] : [];
+                        if (!('annotations' in node && node.annotations?.length) && !errors.some(error => error.name === name))
+                            report(node.span, `@${tag.name} ${name} is absent from ${node.name}'s unless contract`, 'DOC');
+                    }
+                    if (!['param', 'return', 'returns', 'throws', 'exception', 'deprecated', 'see'].includes(tag.name))
+                        report(node.span, `Unknown documentation tag @${tag.name}`, 'DOC');
+                }
+            }
+            if (!project.files.get(def.file)?.package && 'throws' in node && enabled('broad_errors') && node.throws.some(error => error.name === 'Error'))
+                report(node.span, `Prefer specific public errors on ${node.name}; unless Error hides recoverable cases`, 'LINT', true);
+            const visit = (body) => {
+                for (const stmt of body) {
+                    if (stmt.kind === 'try')
+                        for (const clause of stmt.catches) {
+                            const mentions = (value) => !!value && typeof value === 'object' && (Array.isArray(value) ? value.some(mentions) :
+                                value.kind === 'name' && value.name === clause.name ||
+                                    Object.entries(value).some(([key, child]) => key !== 'span' && mentions(child)));
+                            if (enabled('discarded_errors') && !mentions(clause.body))
+                                report(clause.span, `Caught ${clause.name} is discarded; record or deliberately recover from the failure`, 'LINT', true);
+                            visit(clause.body);
+                        }
+                    if ('body' in stmt)
+                        visit(stmt.body);
+                    if (stmt.kind === 'if') {
+                        visit(stmt.then);
+                        visit(stmt.otherwise);
+                    }
+                    if (stmt.kind === 'match')
+                        stmt.cases.forEach(clause => visit(clause.body));
+                }
+            };
+            if ('body' in node)
+                visit(node.body ?? []);
+            if ('constructorBody' in node)
+                visit(node.constructorBody ?? []);
+        }
+    }
+    return diagnostics;
+}

package/src/project-init.js

@@ -0,0 +1,19 @@
+import { existsSync, mkdirSync, readdirSync, writeFileSync } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
+/** Create a small, runnable application without replacing existing files. */
+export function initProject(destination) {
+    const root = resolve(destination);
+    if (existsSync(root) && readdirSync(root).length)
+        throw new Error(`Directory is not empty: ${root}`);
+    const name = basename(root);
+    mkdirSync(root, { recursive: true });
+    const files = {
+        'main.aug': `import Greeter and SimpleGreeter from greeting\n\nimplement Greeter with SimpleGreeter\nresolve Greeter to greeter\nprint(value=greeter.greet(name="August"))\n`,
+        'greeting.aug': `/** Build a greeting for a named person. */\ninterface Greeter:\n    /** Return a greeting for the named person. */\n    greet(string name) returns string\n\n/** A plain-language greeting. */\nSimpleGreeter() implements Greeter:\n    greet(string name) returns string:\n        return "Hello, " + name + "!"\n\ntest SimpleGreeter greeter:\n    when greetings:\n        greeter = SimpleGreeter()\n        it greets_a_person:\n            assert(greeter.greet(name="August") == "Hello, August!")\n`,
+        '.gitignore': '.aug-build/\n.aug-spec/\n*.aug.md\n',
+        'README.md': `# ${name}\n\nThis is an August application. Start in \`main.aug\`; its dependencies and startup are visible there.\n\n\`greeting.aug\` contains a public interface, its implementation, and a same-file test.\n\n\`\`\`sh\naug check .\naug test .\naug spec .\naug run .\n\`\`\`\n\nFor the language guide, see https://GreenPandaStudios.github.io/augscript/getting-started.\n`,
+    };
+    for (const [file, contents] of Object.entries(files))
+        writeFileSync(join(root, file), contents, { flag: 'wx' });
+    return root;
+}

package/src/project.js

@@ -0,0 +1,292 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { basename, dirname, join, relative, resolve } from 'node:path';
+import { parse } from "./parser.js";
+import { loadConfig } from "./config.js";
+import { projectPolicies } from "./policies.js";
+import { builtinFunctions, builtinTypes } from "./builtins.js";
+import { libraryChild, libraryRelative, standardLibraries } from "./libraries.js";
+import { projectPackages, readPackage, sourcePaths } from "./package-manager.js";
+export function isPrivateName(name) { return name.startsWith('_'); }
+function diagnostic(file, line, column, message, code) {
+    return { file, line, column, message, code };
+}
+function sourceFiles(root) {
+    const output = [];
+    function walk(dir) {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            if (entry.name.startsWith('.') || entry.name === 'node_modules' || entry.name === 'dist')
+                continue;
+            const path = join(dir, entry.name);
+            if (entry.isDirectory())
+                walk(path);
+            else if (entry.isFile() && entry.name.endsWith('.aug'))
+                output.push(path);
+        }
+    }
+    walk(root);
+    return output.sort();
+}
+export function loadProject(projectRoot, overrides = new Map(), cache) {
+    const root = resolve(projectRoot);
+    const files = new Map();
+    const definitions = new Map();
+    const scopes = new Map();
+    const imports = new Map();
+    const { config, diagnostics } = loadConfig(root);
+    let library;
+    let sourceRoot = root;
+    if (existsSync(join(root, 'aug-package.json'))) {
+        try {
+            const loaded = readPackage(root);
+            library = loaded.manifest;
+            sourceRoot = loaded.sourceRoot;
+        }
+        catch (error) {
+            diagnostics.push(diagnostic(join(root, 'aug-package.json'), 1, 1, error.message, 'PACKAGE'));
+        }
+    }
+    const packages = projectPackages(root, library?.dependencies ?? config.packages, sourceRoot);
+    diagnostics.push(...packages.diagnostics);
+    const read = (path) => {
+        const source = overrides.get(path) ?? readFileSync(path, 'utf8');
+        const cached = cache?.get(path);
+        if (cached?.file.source === source)
+            return cached;
+        const parsed = parse(path, source);
+        cache?.set(path, parsed);
+        return parsed;
+    };
+    for (const path of new Set([...sourceFiles(sourceRoot), ...overrides.keys()].filter(path => path.endsWith('.aug')))) {
+        const parsed = read(path);
+        files.set(path, parsed.file);
+        diagnostics.push(...parsed.diagnostics);
+    }
+    for (const scope of new Set(packages.scopes.values()))
+        for (const path of sourcePaths(scope.sourceRoot)) {
+            const parsed = read(path);
+            // Cached parse objects can be shared across project revisions.
+            files.set(path, { ...parsed.file, package: scope.path });
+            diagnostics.push(...parsed.diagnostics);
+        }
+    const libraries = standardLibraries();
+    const stdlibRoot = libraries.root;
+    const libraryFiles = new Set([stdlibRoot, ...libraries.modules.values()].flatMap(sourceFiles));
+    for (const path of libraryFiles) {
+        const parsed = read(path);
+        parsed.file.builtin = true;
+        files.set(path, parsed.file);
+        diagnostics.push(...parsed.diagnostics);
+    }
+    const main = files.get(join(root, 'main.aug'));
+    if (!main && !library)
+        diagnostics.push(diagnostic(join(root, 'main.aug'), 1, 1, 'Project requires main.aug at its root', 'PROJECT'));
+    for (const file of files.values()) {
+        const local = new Map();
+        const isExport = basename(file.path) === 'export.aug';
+        for (const item of file.items) {
+            if (isExport && item.kind !== 'export') {
+                diagnostics.push(diagnostic(file.path, item.span.line, item.span.column, 'export.aug may contain only export declarations', 'EXPORT'));
+            }
+            if (!isExport && item.kind === 'export') {
+                diagnostics.push(diagnostic(file.path, item.span.line, item.span.column, 'export declarations belong in export.aug', 'EXPORT'));
+            }
+            if (file === main && ['class', 'interface', 'function', 'interceptor', 'test', 'composition'].includes(item.kind)) {
+                diagnostics.push(diagnostic(file.path, item.span.line, item.span.column, 'Define classes, interfaces, functions, and interceptors outside main.aug', 'MAIN'));
+            }
+            if (file !== main && ['bind', 'include', 'expr', 'assign', 'return', 'throw', 'if', 'while', 'for', 'destructure', 'match', 'scope', 'freeze', 'serve', 'lock',
+                'try', 'unsafe', 'borrow'].includes(item.kind)) {
+                diagnostics.push(diagnostic(file.path, item.span.line, item.span.column, 'Executable statements and bindings belong in main.aug', 'MAIN'));
+            }
+            if (item.kind === 'class' || item.kind === 'interface' || item.kind === 'function' || item.kind === 'interceptor' || item.kind === 'composition') {
+                if (item.name in builtinTypes || builtinFunctions.some(operation => operation.name === item.name) || item.name === 'next') {
+                    diagnostics.push(diagnostic(file.path, item.span.line, item.span.column, `${item.name} is a reserved built-in name`, 'NAME'));
+                    continue;
+                }
+                if (local.has(item.name)) {
+                    diagnostics.push(diagnostic(file.path, item.span.line, item.span.column, `Duplicate declaration ${item.name}`, 'NAME'));
+                    continue;
+                }
+                const packageScope = file.package ? packages.scopes.get(file.package) : undefined;
+                const identity = packageScope ? `package/${packageScope.name}@${packageScope.version}/${relative(packageScope.sourceRoot, file.path)}` :
+                    library && !file.builtin ? `package/${library.name}@${library.version}/${relative(sourceRoot, file.path)}` : relative(root, file.path);
+                const def = { id: `${file.builtin ? 'august/' + libraryRelative(libraries, file.path) : identity}:${item.name}`,
+                    name: item.name, file: file.path, node: item };
+                local.set(item.name, def);
+                definitions.set(def.id, def);
+            }
+        }
+        scopes.set(file.path, local);
+    }
+    // Importing a sibling exposes its declarations, never its imported dependencies.
+    const declaredScopes = new Map([...scopes].map(([file, scope]) => [file, new Map(scope)]));
+    const exportCache = new Map();
+    function folderExports(folder, visiting = new Set()) {
+        if (exportCache.has(folder))
+            return exportCache.get(folder);
+        const result = new Map();
+        const exportFile = files.get(join(folder, 'export.aug'));
+        if (!exportFile)
+            return result;
+        if (visiting.has(folder))
+            return result;
+        visiting.add(folder);
+        for (const item of exportFile.items) {
+            if (item.kind !== 'export' || item.folder)
+                continue;
+            if (isPrivateName(item.name)) {
+                diagnostics.push(diagnostic(exportFile.path, item.span.line, item.span.column, `Cannot export private name ${item.name}`, 'PRIVATE'));
+                continue;
+            }
+            if (item.from && isPrivateName(item.from)) {
+                diagnostics.push(diagnostic(exportFile.path, item.span.line, item.span.column, `Cannot export from private module ${item.from}`, 'PRIVATE'));
+                continue;
+            }
+            const sibling = files.get(join(folder, `${item.from}.aug`));
+            if (!sibling || basename(sibling.path) === 'export.aug') {
+                diagnostics.push(diagnostic(exportFile.path, item.span.line, item.span.column, `Cannot export ${item.name}: sibling file ${item.from}.aug was not found`, 'EXPORT'));
+                continue;
+            }
+            const def = declaredScopes.get(sibling.path)?.get(item.name);
+            if (!def) {
+                diagnostics.push(diagnostic(exportFile.path, item.span.line, item.span.column, `Cannot export ${item.name}: ${item.from}.aug does not define it`, 'EXPORT'));
+            }
+            else if (result.has(item.name)) {
+                diagnostics.push(diagnostic(exportFile.path, item.span.line, item.span.column, `Duplicate export ${item.name}`, 'EXPORT'));
+            }
+            else
+                result.set(item.name, def);
+        }
+        exportCache.set(folder, result);
+        visiting.delete(folder);
+        return result;
+    }
+    function exposedChild(folder, child) {
+        const file = files.get(join(folder, 'export.aug'));
+        return !!file?.items.some((item) => item.kind === 'export' && item.folder && item.name === child);
+    }
+    for (const file of files.values()) {
+        if (basename(file.path) !== 'export.aug')
+            continue;
+        for (const item of file.items) {
+            if (item.kind !== 'export' || !item.folder)
+                continue;
+            if (isPrivateName(item.name)) {
+                diagnostics.push(diagnostic(file.path, item.span.line, item.span.column, `Cannot export private folder ${item.name}`, 'PRIVATE'));
+                continue;
+            }
+            const path = file.builtin ? libraryChild(libraries, dirname(file.path), item.name) : join(dirname(file.path), item.name);
+            if (!statExistsDirectory(path))
+                diagnostics.push(diagnostic(file.path, item.span.line, item.span.column, `Cannot export folder ${item.name}: it does not exist`, 'EXPORT'));
+            else if (!files.has(join(path, 'export.aug')))
+                diagnostics.push(diagnostic(file.path, item.span.line, item.span.column, `Cannot export folder ${item.name}: it has no export.aug`, 'EXPORT'));
+        }
+        folderExports(dirname(file.path));
+    }
+    for (const file of files.values()) {
+        if (basename(file.path) === 'export.aug')
+            continue;
+        const scope = scopes.get(file.path);
+        for (const item of file.items) {
+            if (item.kind !== 'import')
+                continue;
+            const resolved = resolveImports(item, file.path);
+            imports.set(item, [...resolved.values()]);
+            for (const [name, def] of resolved) {
+                if (scope.has(name))
+                    diagnostics.push(diagnostic(file.path, item.span.line, item.span.column, `Imported name ${name} conflicts with another name`, 'IMPORT'));
+                else
+                    scope.set(name, def);
+            }
+        }
+    }
+    function resolveImports(item, importer) {
+        const source = item.from.join('.');
+        const result = new Map();
+        const select = (available, missing) => {
+            const names = item.everything ? [...available.keys()].filter(name => !isPrivateName(name)) : item.names;
+            for (const name of names) {
+                if (isPrivateName(name))
+                    diagnostics.push(diagnostic(importer, item.span.line, item.span.column, `Cannot import private name ${name}`, 'PRIVATE'));
+                else if (result.has(name))
+                    diagnostics.push(diagnostic(importer, item.span.line, item.span.column, `Duplicate imported name ${name}`, 'IMPORT'));
+                else if (available.has(name))
+                    result.set(name, available.get(name));
+                else
+                    diagnostics.push(diagnostic(importer, item.span.line, item.span.column, `${source} ${missing} ${name}`, 'IMPORT'));
+            }
+            return result;
+        };
+        const privateModule = item.from.find(isPrivateName);
+        if (privateModule) {
+            diagnostics.push(diagnostic(importer, item.span.line, item.span.column, `Cannot import from private module ${privateModule}`, 'PRIVATE'));
+            return result;
+        }
+        if (item.from[0] === 'august') {
+            let folder = stdlibRoot;
+            for (const child of item.from.slice(1)) {
+                if (!exposedChild(folder, child)) {
+                    diagnostics.push(diagnostic(importer, item.span.line, item.span.column, `Standard module august does not export ${child}`, 'IMPORT'));
+                    return result;
+                }
+                folder = libraryChild(libraries, folder, child);
+            }
+            return select(folderExports(folder), 'does not export');
+        }
+        const owner = files.get(importer)?.package;
+        const ownerScope = owner ? packages.scopes.get(owner) : undefined;
+        const dependency = ownerScope ? packages.scopes.get(ownerScope.dependencies[item.from[0]]) : packages.roots.get(item.from[0]);
+        if (dependency) {
+            let folder = dependency.sourceRoot;
+            for (const child of item.from.slice(1)) {
+                if (!exposedChild(folder, child)) {
+                    diagnostics.push(diagnostic(importer, item.span.line, item.span.column, `Package ${item.from[0]} does not export folder ${child}`, 'IMPORT'));
+                    return result;
+                }
+                folder = join(folder, child);
+            }
+            return select(folderExports(folder), 'does not export');
+        }
+        if (item.from.length === 1) {
+            const sibling = join(dirname(importer), `${item.from[0]}.aug`);
+            if (files.has(sibling) && basename(sibling) !== 'export.aug') {
+                return select(declaredScopes.get(sibling) ?? new Map(), 'does not define');
+            }
+        }
+        let folder;
+        if (item.from.length === 1 && statExistsDirectory(join(dirname(importer), item.from[0]))) {
+            folder = join(dirname(importer), item.from[0]);
+        }
+        else {
+            folder = join(ownerScope?.sourceRoot ?? sourceRoot, item.from[0]);
+            if (!statExistsDirectory(folder)) {
+                diagnostics.push(diagnostic(importer, item.span.line, item.span.column, `Import folder ${source} does not exist`, 'IMPORT'));
+                return result;
+            }
+            for (const child of item.from.slice(1)) {
+                if (!exposedChild(folder, child)) {
+                    diagnostics.push(diagnostic(importer, item.span.line, item.span.column, `Folder ${relative(root, folder)} does not export child folder ${child}`, 'IMPORT'));
+                    return result;
+                }
+                folder = join(folder, child);
+            }
+        }
+        return select(folderExports(folder), 'does not export');
+    }
+    const project = { root, sourceRoot, library, packages, files, definitions, scopes, imports, diagnostics, main, stdlibRoot, libraries, config };
+    diagnostics.push(...projectPolicies(project));
+    return project;
+}
+function statExistsDirectory(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+export function declarations(file) {
+    return file.items.filter((item) => item.kind === 'class' || item.kind === 'interface' || item.kind === 'function' || item.kind === 'interceptor' || item.kind === 'composition');
+}
+export function statements(file) {
+    return file.items.filter(item => !['import', 'export', 'class', 'interface', 'function', 'interceptor', 'composition', 'test'].includes(item.kind));
+}

package/src/schemas.js

@@ -0,0 +1,62 @@
+export function schemaType(project, ref, file, parameters = new Map()) {
+    const param = parameters.get(ref.name);
+    if (param)
+        return { ...param, nullable: param.nullable || ref.nullable, optional: ref.optional || param.optional };
+    const def = project.scopes.get(file)?.get(ref.name);
+    return { id: def?.id ?? 'builtin:' + ref.name, name: ref.name,
+        kind: def?.node.kind === 'class' ? 'class' : def ? 'interface' : 'builtin', def,
+        nullable: ref.nullable, optional: ref.optional, args: ref.args.map(arg => schemaType(project, arg, file, parameters)) };
+}
+export function jsonDataType(project, type, seen = new Set()) {
+    if (['int', 'c_int', 'float', 'bool', 'string', 'Json'].includes(type.name) && type.kind === 'builtin')
+        return true;
+    if (type.kind === 'builtin' && ['List', 'Set', 'Tuple', 'Map'].includes(type.name))
+        return (type.name !== 'Map' || type.args[0]?.name === 'string') && type.args.every(arg => jsonDataType(project, arg, seen));
+    const node = type.def?.node;
+    if (node?.kind !== 'class' || !node.record || node.fields.some(field => field.name.startsWith('_')))
+        return false;
+    if (seen.has(type.id))
+        return true;
+    seen.add(type.id);
+    const params = new Map(node.typeParams.map((name, i) => [name, type.args[i]]));
+    return node.fields.every(field => jsonDataType(project, schemaType(project, field.type, type.def.file, params), seen));
+}
+/** One shared native schema per concrete type, used by HTTP and explicit JSON decoding. */
+export class NativeSchemas {
+    names = new Map();
+    output = [];
+    forwards = [];
+    project;
+    constructorName;
+    constructor(project, constructorName) {
+        this.project = project;
+        this.constructorName = constructorName;
+    }
+    request(type) {
+        const key = JSON.stringify(this.identity(type));
+        const previous = this.names.get(key);
+        if (previous)
+            return previous;
+        const name = 'aug_schema_' + this.names.size;
+        this.names.set(key, name);
+        this.forwards.push(`static const AugSchema ${name};`);
+        let kind = 'AUG_SCHEMA_' + type.name.toUpperCase(), fields = [], labels = [], maker = 'NULL';
+        if (type.def?.node.kind === 'class' && type.def.node.record) {
+            kind = 'AUG_SCHEMA_RECORD';
+            const node = type.def.node, params = new Map(node.typeParams.map((param, i) => [param, type.args[i]]));
+            fields = node.fields.map(field => '&' + this.request(schemaType(this.project, field.type, type.def.file, params)));
+            labels = node.fields.map(field => JSON.stringify(field.name));
+            maker = this.constructorName(type.def);
+        }
+        else
+            fields = type.args.map(arg => '&' + this.request(arg));
+        if (fields.length)
+            this.output.push(`static const AugSchema *const ${name}_fields[] = {${fields.join(', ')}};`);
+        if (labels.length)
+            this.output.push(`static const char *const ${name}_names[] = {${labels.join(', ')}};`);
+        this.output.push(`static const AugSchema ${name} = {${kind}, ${type.nullable ? 'true' : 'false'}, ${type.optional ? 'true' : 'false'}, ${fields.length}, ${fields.length ? name + '_fields' : 'NULL'}, ${labels.length ? name + '_names' : 'NULL'}, ${maker}};`);
+        return name;
+    }
+    identity(type) { return [type.id, type.nullable, !!type.optional, type.args.map(arg => this.identity(arg))]; }
+    declarations() { return [...this.forwards, ...this.output].join('\n'); }
+}