aontu 0.52.1 → 0.53.0

package/dist/site.d.ts

@@ -3,11 +3,15 @@ type SiteSpec = {
     row?: number;
     col?: number;
     url?: string;
+    len?: number;
+    src?: string;
 };
 declare class Site {
     row: number;
     col: number;
     url: string;
+    len: number;
+    src: string;
     constructor(val?: Val | SiteSpec);
 }
 export { Site, };

package/dist/site.js

@@ -2,12 +2,43 @@
 /* Copyright (c) 2021-2025 Richard Rodger, MIT License */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Site = void 0;
+// Site locates a value in the text that produced it: where it starts
+// (row, col), HOW FAR IT RUNS (len), and the source text itself (src).
+//
+// THE EXTENT IS NOT OPTIONAL DETAIL — it is what makes a site safe to
+// edit. Without it the only length available is the CANON, and canon is
+// not source text: `port: 0x1F` has canon `31`, so replacing
+// `(col, canon.length)` writes `port: 5x1F` and corrupts the document.
+// The parser knew the extent all along — the token carries `len` and
+// `src` beside the `rI`/`cI` this already read — and dropping it was
+// the whole defect (status report 2026-08-21, §5).
+//
+// WHAT THE EXTENT COVERS is the TOKEN THE SITE POINTS AT, which is the
+// same thing row and col have always pointed at:
+//
+//   0x1F         a scalar literal   len 4   the whole literal
+//   "hi there"   a string           len 10  quotes included
+//   {x:1}        a map              len 1   the opening brace
+//   min(3)       a constraint       len 3   the name, not the call
+//
+// So for a SCALAR — which is what a repair edits, and what `set` and
+// the manual fallback rewrite — `(col, len)` is exactly the span to
+// replace. For a container it under-reaches to the opening delimiter,
+// which is safe in the direction that matters: a highlight that is too
+// short is a cosmetic flaw, while canon.length on a map over-reaches
+// across lines into text the value never occupied.
+//
+// -1 and '' mean UNKNOWN, the same convention row and col already use:
+// a value minted by unification rather than written by a document has
+// no site, and must not be edited as though it had one.
 class Site {
     constructor(val) {
         const site = (val?.site ?? val);
         this.row = site?.row ?? -1;
         this.col = site?.col ?? -1;
         this.url = site?.url ?? '';
+        this.len = site?.len ?? -1;
+        this.src = site?.src ?? '';
     }
 } /* node:coverage ignore next 6 */
 exports.Site = Site;

package/dist/site.js.map

@@ -1 +1 @@
-{"version":3,"file":"site.js","sourceRoot":"","sources":["../src/site.ts"],"names":[],"mappings":";AAAA,yDAAyD;;;AAUzD,MAAM,IAAI;IAKR,YAAY,GAAoB;QAC9B,MAAM,IAAI,GAAG,CAAE,GAAW,EAAE,IAAI,IAAI,GAAG,CAAa,CAAA;QAEpD,IAAI,CAAC,GAAG,GAAG,IAAI,EAAE,GAAG,IAAI,CAAC,CAAC,CAAA;QAC1B,IAAI,CAAC,GAAG,GAAG,IAAI,EAAE,GAAG,IAAI,CAAC,CAAC,CAAA;QAC1B,IAAI,CAAC,GAAG,GAAG,IAAI,EAAE,GAAG,IAAI,EAAE,CAAA;IAC5B,CAAC;CACF,CAAC,iCAAiC;QAIjC,IAAI"}
+{"version":3,"file":"site.js","sourceRoot":"","sources":["../src/site.ts"],"names":[],"mappings":";AAAA,yDAAyD;;;AAYzD,qEAAqE;AACrE,uEAAuE;AACvE,EAAE;AACF,sEAAsE;AACtE,wEAAwE;AACxE,6DAA6D;AAC7D,uEAAuE;AACvE,qEAAqE;AACrE,qEAAqE;AACrE,mDAAmD;AACnD,EAAE;AACF,uEAAuE;AACvE,iDAAiD;AACjD,EAAE;AACF,8DAA8D;AAC9D,4DAA4D;AAC5D,8DAA8D;AAC9D,mEAAmE;AACnE,EAAE;AACF,qEAAqE;AACrE,oEAAoE;AACpE,sEAAsE;AACtE,uEAAuE;AACvE,qEAAqE;AACrE,mDAAmD;AACnD,EAAE;AACF,uEAAuE;AACvE,sEAAsE;AACtE,wDAAwD;AACxD,MAAM,IAAI;IAOR,YAAY,GAAoB;QAC9B,MAAM,IAAI,GAAG,CAAE,GAAW,EAAE,IAAI,IAAI,GAAG,CAAa,CAAA;QAEpD,IAAI,CAAC,GAAG,GAAG,IAAI,EAAE,GAAG,IAAI,CAAC,CAAC,CAAA;QAC1B,IAAI,CAAC,GAAG,GAAG,IAAI,EAAE,GAAG,IAAI,CAAC,CAAC,CAAA;QAC1B,IAAI,CAAC,GAAG,GAAG,IAAI,EAAE,GAAG,IAAI,EAAE,CAAA;QAC1B,IAAI,CAAC,GAAG,GAAG,IAAI,EAAE,GAAG,IAAI,CAAC,CAAC,CAAA;QAC1B,IAAI,CAAC,GAAG,GAAG,IAAI,EAAE,GAAG,IAAI,EAAE,CAAA;IAC5B,CAAC;CACF,CAAC,iCAAiC;QAIjC,IAAI"}

package/dist/std.d.ts

@@ -0,0 +1 @@
+export declare const STD_SOURCES: Record<string, string>;

package/dist/std.js

@@ -0,0 +1,73 @@
+"use strict";
+/* Copyright (c) 2025 Richard Rodger, MIT License */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STD_SOURCES = void 0;
+// THE BUNDLED VOCABULARY (G4 phase 4,
+// docs/capability-review/g4-identity-relations.md): `@"std/system"` is
+// served from the engine itself — no filesystem, no package resolution
+// — so a document may use it under every include capability except
+// `none`, and the hermeticity posture is not widened by a source that
+// never leaves the process.
+//
+// The TEXT is the shared artifact: go/std.go carries the same bytes,
+// and test/spec/std-system.tsv pins its canon and its canon-hash in
+// both engines, so the two copies cannot drift without a red suite.
+// It carries no backtick for that reason: one string literal per port,
+// and Go's raw string has no escape.
+const STD_SYSTEM = `# std/system --- the SYSTEM VOCABULARY (G4 phase 4). Ports, components
+# and relations need no syntax: they are schemas. Everything here is
+# ordinary unification --- conjunction, spreads, marks, defaults ---
+# so the vocabulary costs the language nothing, and an author who wants
+# a different one writes it the same way.
+#
+# EXPERIMENTAL until the distribution layer can version it by
+# canon-hash. Entity ids deliberately do NOT embed versions: fusing
+# identity and version makes "v1 and v2 describe the same entity"
+# inexpressible.
+
+std: {
+
+  # One end of a connection.
+  Port: type({
+    direction: *in | out | inout
+    protocol?: string
+  })
+
+  # A node with ports. A Component that is not itself an entity is a
+  # component OF its nearest identified ancestor, which is the
+  # entity/component distinction and needs no mark of its own.
+  Component: type({
+    ports?: {&: $.std.Port}
+  })
+
+  # A component that is a service. Written out rather than as
+  # $.std.Component & {kind: service}: a reference from one member of
+  # this file to another does not survive being INCLUDED into a
+  # document (the marks the include carries make the referring member
+  # unusable), so the vocabulary states each schema on its own.
+  Service: type({
+    kind: service
+    ports?: {&: $.std.Port}
+  })
+
+  # A DECLARED RELATION. "target" is what the far end must satisfy,
+  # "inverse" names the relation that must mirror it, and "acyclic"
+  # asks that the edge set have no cycle. The last two are checked
+  # AFTER unification, not by it: they are global and non-monotone ---
+  # an acyclic graph becomes cyclic when one more edge unifies in ---
+  # and no lattice citizen may be falsified by more information.
+  Relation: type({
+    target?: top
+    inverse?: string
+    acyclic?: *false | boolean
+  })
+}
+`;
+// The bundled sources, by the name a document writes. Both the bare
+// name and the `.aon` spelling resolve, because both are what an
+// author reaches for.
+exports.STD_SOURCES = {
+    'std/system': STD_SYSTEM,
+    'std/system.aon': STD_SYSTEM,
+};
+//# sourceMappingURL=std.js.map

package/dist/std.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"std.js","sourceRoot":"","sources":["../src/std.ts"],"names":[],"mappings":";AAAA,oDAAoD;;;AAEpD,sCAAsC;AACtC,uEAAuE;AACvE,uEAAuE;AACvE,mEAAmE;AACnE,sEAAsE;AACtE,4BAA4B;AAC5B,EAAE;AACF,qEAAqE;AACrE,oEAAoE;AACpE,oEAAoE;AACpE,uEAAuE;AACvE,qCAAqC;AAErC,MAAM,UAAU,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDlB,CAAA;AAGD,oEAAoE;AACpE,iEAAiE;AACjE,sBAAsB;AACT,QAAA,WAAW,GAA2B;IACjD,YAAY,EAAE,UAAU;IACxB,gBAAgB,EAAE,UAAU;CAC7B,CAAA"}

package/dist/subsume.d.ts

@@ -0,0 +1,39 @@
+import type { TrustOptions } from './type';
+import type { VetFinding } from './vet';
+export type SubsumeVerdict = 'subsumes' | 'does_not_subsume' | 'undecided' | 'error';
+export type SubsumeProfile = 'values' | 'defaults' | 'gen';
+export type SubsumeOptions = {
+    profile?: SubsumeProfile;
+    at?: string;
+    generalUrl?: string;
+    specificUrl?: string;
+    generalPath?: string;
+    specificPath?: string;
+    trust?: TrustOptions;
+};
+export type SubsumeReport = {
+    verdict: SubsumeVerdict;
+    findings: VetFinding[];
+};
+type SubState = {
+    profile: SubsumeProfile;
+    distributing?: boolean;
+    findings: VetFinding[];
+    generalUrl: string;
+    specificUrl: string;
+};
+type Tri = 'yes' | 'no' | 'undecided';
+export declare function effectiveDefault(v: any): any;
+export declare function subsumeNode(state: SubState, path: string[], g0: any, s0: any): Tri;
+/**
+ * Does `generalSrc` subsume `specificSrc` — is every instance the
+ * specific admits admitted by the general too?
+ *
+ * Both sources are evaluated fresh (single-use trees make this
+ * mandatory), and the recursion runs on the finished values. The
+ * verdict is three-valued plus `error` (a source that does not stand up
+ * on its own, mirroring vet's schema-error verdict); findings reuse
+ * G2's object with class `compat`.
+ */
+export declare function subsume(generalSrc: string, specificSrc: string, opts?: SubsumeOptions): SubsumeReport;
+export {};