aontu 0.52.0 → 0.53.0

package/dist/mod.d.ts

@@ -0,0 +1,31 @@
+export type ModuleRef = {
+    path: string;
+    major: number;
+    hash?: string;
+};
+export type ModuleFs = {
+    existsSync: (p: string) => boolean;
+    readFileSync: (p: string, enc: string) => string;
+};
+export declare function parseModuleRef(spec: string): ModuleRef | undefined;
+export declare function moduleDir(store: string, ref: ModuleRef): string;
+export declare function projectRoots(from: string, fs: ModuleFs): string[];
+export declare function lockJson(text: string): string;
+export declare function modCacheDir(): string | undefined;
+export declare function modCacheDirFor(platform: string, env: Record<string, string | undefined>): string | undefined;
+export declare function lockHash(root: string, ref: ModuleRef, fs: ModuleFs): string | undefined;
+export type ModuleEval = (src: string, path: string) => {
+    gen: any;
+    hash: string;
+};
+export declare const MODULE_MAX_DEPTH = 16;
+export type ModuleOptions = {
+    cache?: string;
+    eval: ModuleEval;
+    depth?: number;
+};
+export type ModuleFound = {
+    full: string;
+    src: string;
+};
+export declare function resolveModule(ref: ModuleRef, fromDir: string, fs: ModuleFs, options: ModuleOptions): ModuleFound;

package/dist/mod.js

@@ -0,0 +1,250 @@
+"use strict";
+/* Copyright (c) 2025 Richard Rodger, MIT License */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODULE_MAX_DEPTH = void 0;
+exports.parseModuleRef = parseModuleRef;
+exports.moduleDir = moduleDir;
+exports.projectRoots = projectRoots;
+exports.lockJson = lockJson;
+exports.modCacheDir = modCacheDir;
+exports.modCacheDirFor = modCacheDirFor;
+exports.lockHash = lockHash;
+exports.resolveModule = resolveModule;
+// MODULE IDENTITY AND LOCAL RESOLUTION (G6 phase 2,
+// docs/capability-review/g6-distribution.md).
+//
+// An import is still just `@"…"`; the string's SHAPE routes it, so the
+// grammar is untouched and every existing include keeps its exact
+// behaviour:
+//
+//   service: @"corp.example/schemas/service@1"
+//   frozen:  @"corp.example/schemas/service@1#aon1-4vJemVYtWFR2mQeN…"
+//   local:   @"./fragment.aon"        <- unchanged, not a module
+//
+// EVALUATION NEVER TOUCHES THE NETWORK. Resolution reads local stores
+// only: `aon_vendor/` beside the project's `mod.aon`, then a
+// content-addressed user cache keyed by canon-hash. Fetching is a
+// separate, explicit tool step, and a module that is in neither store
+// is an evaluation error that says so.
+//
+// TWO PINS, TWO ROLES. The lockfile's `oci` digest certifies that these
+// are the bytes the registry served; the `canon` hash certifies that
+// this is the MEANING that was reviewed. Only the second can be checked
+// locally without the registry, and it is the one this file checks: the
+// module is unified standalone and its canon-hash compared with the
+// pin. An inline `#aon1-…` fragment is the same check without a
+// lockfile — the degenerate mode for single-file and agent-sandbox use.
+const node_path_1 = require("node:path");
+// A module path is DOMAIN-SHAPED — the first segment carries a dot,
+// which is what tells it apart from `./local.aon`, `pkg-name` and every
+// other spelling already in use — and carries the major version in the
+// path, CUE/Go-style, so two majors are two modules.
+//
+// The pattern is deliberately narrow: anything it does not match falls
+// through to the existing resolver chain unchanged, so no document that
+// worked before this phase can be routed somewhere new by it.
+const MODULE_RE = /^([a-z0-9][a-z0-9-]*(?:\.[a-z0-9][a-z0-9-]*)+(?:\/[A-Za-z0-9._-]+)*)@(\d+)(?:#(aon1-[A-Za-z0-9_-]+))?$/;
+function parseModuleRef(spec) {
+    const m = MODULE_RE.exec(spec);
+    if (null == m) {
+        return undefined;
+    }
+    return {
+        path: m[1],
+        major: +m[2],
+        ...(null == m[3] ? {} : { hash: m[3] }),
+    };
+}
+// The directory a module's files live in, under a store root.
+function moduleDir(store, ref) {
+    return (0, node_path_1.join)(store, ...ref.path.split('/')) + '@' + ref.major;
+}
+// EVERY project root at or above `from`, innermost first — a project
+// root being a directory holding a `mod.aon`. This used to answer with
+// the NEAREST one alone, and the plural is the fix, because a
+// VENDORED MODULE IS A PROJECT INSIDE A PROJECT. A module in
+// `aon_vendor/` carries its own `mod.aon`, which stopped the upward
+// walk there, so a nested import resolved against the vendored
+// module's own directory: a tree with no `aon_vendor/` of its own, and
+// therefore a `module not fetched` for a dependency sitting flat
+// beside it in the CONSUMER's vendor tree — the only layout `mod
+// vendor` produces (use-cases/BUGS.md §31).
+//
+// The consumer's stores are searched after the module's own, so a
+// module that vendors its dependencies nested still wins for its own
+// tree, and one that does not falls through to the consumer that
+// vendored it. The last element is `from` itself when nothing above it
+// declares a module, which is the single-file inline-pin mode.
+function projectRoots(from, fs) {
+    const roots = [];
+    let dir = from;
+    for (;;) {
+        if (fs.existsSync((0, node_path_1.join)(dir, 'mod.aon'))) {
+            roots.push(dir);
+        }
+        const up = (0, node_path_1.dirname)(dir);
+        if (up === dir) {
+            return 0 < roots.length ? roots : [from];
+        }
+        dir = up;
+    }
+}
+// The lockfile's pin for one import, or undefined.
+//
+// `mod-lock.aon` is machine-written CANONICAL Aontu, and canonical
+// Aontu whose leaves are scalars IS JSON — which is why reading it here
+// needs no evaluator, and why a hand-edited lockfile that is no longer
+// canonical simply does not parse. It is generated; the file says so.
+// The lockfile's JSON: its canonical line, with the generated-file
+// header stripped. The file is AONTU, so it may carry `#` comments —
+// and the header `aontu mod tidy` writes says not to edit it, which is
+// worth more than the two lines it costs to skip. Everything below the
+// comments is the canonical map, and canonical Aontu whose leaves are
+// scalars is JSON.
+function lockJson(text) {
+    return text
+        .split('\n')
+        .filter((line) => !line.trimStart().startsWith('#'))
+        .join('\n');
+}
+// The user cache: `$XDG_CACHE_HOME/aontu/mod` unless the host names
+// another, else the platform's own cache location. A host with nowhere
+// to put one has no cache, which is a miss rather than a failure. One
+// rule, in one place: the resolver reads this cache during evaluation
+// and `aontu mod` writes into it, and two spellings of "where the cache
+// is" is one bug.
+function modCacheDir() {
+    return modCacheDirFor(process.platform, process.env);
+}
+// That rule with the platform and the environment PASSED IN, so the
+// Windows arm can be exercised off Windows — the only way a rule about
+// a platform nobody here runs gets tested at all. The Go port splits
+// the same way (modCacheDirFor, go/aontu.go).
+//
+// THE ORDER IS EXPLICIT BEFORE IMPLICIT, and LOCALAPPDATA is LAST.
+// XDG_CACHE_HOME is the override and wins everywhere, Windows included:
+// a caller who names a cache directory means it. HOME comes next and is
+// also honoured on Windows, where it is not standard but IS set by Git
+// Bash and by most development shells — a user who has one expects
+// their tools to agree about where home is.
+//
+// LOCALAPPDATA is the PLATFORM DEFAULT beneath both, which is the whole
+// addition: Windows sets neither XDG_CACHE_HOME nor HOME by default —
+// it supplies USERPROFILE and LOCALAPPDATA, and LOCALAPPDATA is what a
+// cache directory means there — so a rule that knew only the first two
+// left every Windows user with NO cache. Putting it ABOVE HOME was the
+// first attempt and was wrong: it made an explicitly set HOME
+// unreachable on Windows, which broke the existing fallback test the
+// moment CI ran it. A platform default that overrides what the
+// environment was told is not a default.
+function modCacheDirFor(platform, env) {
+    const xdg = env.XDG_CACHE_HOME;
+    if ('string' === typeof xdg && '' !== xdg) {
+        return (0, node_path_1.join)(xdg, 'aontu', 'mod');
+    }
+    const home = env.HOME;
+    if ('string' === typeof home && '' !== home) {
+        return (0, node_path_1.join)(home, '.cache', 'aontu', 'mod');
+    }
+    if ('win32' === platform) {
+        const local = env.LOCALAPPDATA;
+        if ('string' === typeof local && '' !== local) {
+            return (0, node_path_1.join)(local, 'aontu', 'mod');
+        }
+    }
+    return undefined;
+}
+function lockHash(root, ref, fs) {
+    const file = (0, node_path_1.join)(root, 'mod-lock.aon');
+    if (!fs.existsSync(file)) {
+        return undefined;
+    }
+    let lock;
+    try {
+        lock = JSON.parse(lockJson(fs.readFileSync(file, 'utf8')));
+    }
+    catch {
+        return undefined;
+    }
+    const entry = lock?.lock?.[ref.path + '@' + ref.major];
+    return 'string' === typeof entry?.canon ? entry.canon : undefined;
+}
+// How deep module verification may nest before it is refused. A module
+// is verified by EVALUATING it, and that evaluation resolves the
+// module's own imports -- so a vendor tree that leads back to itself
+// (a symlink is enough) would recurse until the host's stack gave out,
+// and a verdict that depends on the host's stack size is exactly what
+// the determinism clause forbids (docs/trust.md, and the same argument
+// unify_cycle rests on). Sixteen is far above any real vendor nesting.
+exports.MODULE_MAX_DEPTH = 16;
+// A refusal that carries its code to the parse layer, exactly as a
+// denied include does (makeModelResolver's `deny`): the resolver
+// THROWS, so a bare-member module import cannot vanish in the merge and
+// leave a plausible, silently-partial document.
+function refuse(code, message) {
+    const err = new Error(message);
+    err.code = code;
+    throw err;
+}
+// Resolve one module import against the local stores.
+function resolveModule(ref, fromDir, fs, options) {
+    if (exports.MODULE_MAX_DEPTH <= (options.depth ?? 0)) {
+        refuse('module_depth', 'module depth: ' + ref.path + '@' + ref.major +
+            ' (verification nested past ' + exports.MODULE_MAX_DEPTH + ')');
+    }
+    // EVERY enclosing project, innermost first (see projectRoots): a
+    // vendored module is a project inside a project, and its nested
+    // imports have to reach the tree the consumer vendored them into.
+    const roots = projectRoots(fromDir, fs);
+    // The PIN comes from the first lockfile that names this import. A
+    // vendored module usually ships none, so that is the consumer's --
+    // which is right: the consumer's lock is what its build is pinned to.
+    const expect = ref.hash ??
+        roots.map((r) => lockHash(r, ref, fs)).find((h) => null != h);
+    const stores = roots.map((r) => moduleDir((0, node_path_1.join)(r, 'aon_vendor'), ref));
+    if (null != options.cache && null != expect) {
+        // Content-addressed: the cache is keyed by the hash, so a cache hit
+        // is already the right MEANING before anything is read from it.
+        stores.push((0, node_path_1.join)(options.cache, expect));
+    }
+    const dir = stores.find((d) => fs.existsSync((0, node_path_1.join)(d, 'mod.aon')));
+    if (undefined === dir) {
+        // The wording is the contract (docs/capability-review/
+        // g6-distribution.md): it names the module AND the step that fixes
+        // it, because an agent reading this error is the audience.
+        refuse('module_missing', 'module not fetched: ' + ref.path + '@' + ref.major +
+            ' (run: aontu mod get)');
+    }
+    // The module's own `mod.aon` names its entry file. Read with the
+    // evaluator rather than a regexp: a module file is ordinary Aontu,
+    // and the language reading its own metadata is the point.
+    const main = moduleMain((0, node_path_1.join)(dir, 'mod.aon'), fs, options);
+    const full = (0, node_path_1.join)(dir, main);
+    if (!fs.existsSync(full)) {
+        refuse('module_missing', 'module not fetched: ' + ref.path + '@' + ref.major +
+            ' (run: aontu mod get)');
+    }
+    const src = fs.readFileSync(full, 'utf8');
+    if (null != expect) {
+        // VERIFICATION IS ALWAYS LOCAL. The registry's annotation is
+        // advisory; what decides is the hash of the module as it is on this
+        // machine, recomputed now.
+        const got = options.eval(src, full).hash;
+        if (got !== expect) {
+            refuse('module_integrity', 'module integrity: ' + ref.path + '@' + ref.major +
+                ' expected ' + expect + ' got ' + got);
+        }
+    }
+    return { full, src };
+}
+// The `mod.main` a module file declares, or the default entry name.
+// The module file is ORDINARY AONTU, read by the language itself — the
+// toolchain dogfooding its own evaluator rather than pattern-matching
+// its own syntax with a regexp.
+function moduleMain(file, fs, options) {
+    const gen = options.eval(fs.readFileSync(file, 'utf8'), file).gen;
+    const main = gen?.mod?.main;
+    return 'string' === typeof main && '' !== main ? main : DEFAULT_MAIN;
+}
+const DEFAULT_MAIN = 'main.aon';
+//# sourceMappingURL=mod.js.map

package/dist/mod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.js","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"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"}

package/dist/patch.d.ts

@@ -0,0 +1,44 @@
+import type { TrustOptions } from './type';
+import type { VetFinding, VetVerdict } from './vet';
+export type PatchOptions = {
+    entryPath?: string;
+    overlayPath?: string;
+    inPlace?: boolean;
+    trust?: TrustOptions;
+};
+export type PatchReplacement = {
+    col: number;
+    file: string;
+    from: string;
+    path: string;
+    row: number;
+    to: string;
+};
+export type PatchReport = {
+    overlay: string;
+    appended: string[];
+    replaced: PatchReplacement[];
+    verdict: VetVerdict;
+    findings: VetFinding[];
+};
+export declare function parseAssignment(text: string): {
+    path: string;
+    value: string;
+} | undefined;
+export declare function overlayLine(path: string, value: string): string;
+export declare function offsetAt(src: string, row: number, col: number): number;
+export declare function spanAt(src: string, site: {
+    row: number;
+    col: number;
+    len: number;
+}): string | undefined;
+export declare function spanHolds(src: string, site: {
+    row: number;
+    col: number;
+    len: number;
+}, expect: string): boolean;
+export declare function spanValue(src: string): {
+    canon: string;
+    concrete: boolean;
+} | undefined;
+export declare function patch(entrySrc: string, overlaySrc: string, assignments: string[], opts?: PatchOptions): PatchReport;