aontu 0.52.1 → 0.54.0

package/dist/val/AggFuncVal.js

@@ -0,0 +1,364 @@
+"use strict";
+/* Copyright (c) 2025 Richard Rodger, MIT License */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GreatestFuncVal = exports.LeastFuncVal = exports.SumFuncVal = exports.PickFuncVal = exports.JoinFuncVal = exports.AggFuncVal = void 0;
+const err_1 = require("../err");
+const IntegerVal_1 = require("./IntegerVal");
+const ListVal_1 = require("./ListVal");
+const StringVal_1 = require("./StringVal");
+const FuncBaseVal_1 = require("./FuncBaseVal");
+const arith_1 = require("./arith");
+const numcmp_1 = require("./numcmp");
+const keyorder_1 = require("../keyorder");
+const PlusOpVal_1 = require("./PlusOpVal");
+// The children of a bag, in the order the aggregate sees them: source
+// order for a list, sorted-key order for a map -- `each`'s order, and
+// for the same reason (a map has no order of its own, so the language
+// picks one and states it).
+function bagChildren(data) {
+    if (true === data?.isList) {
+        return data.peg;
+    }
+    if (true === data?.isMap) {
+        // THE ONE MAP-KEY ORDER (../keyorder.ts), not a bare `.sort()`:
+        // JavaScript compares by UTF-16 code unit, so an astral key's
+        // leading surrogate sorts BELOW U+E000-U+FFFF and `pick` answered
+        // in a different order from `each`, from canon, and from Go --
+        // which sorts UTF-8 bytes, i.e. code points. `pick` is the
+        // order-preserving projection, so that was one model producing two
+        // different generated files (BUGS.md 62).
+        return Object.keys(data.peg).sort(keyorder_1.cmpCodePoint).map((k) => data.peg[k]);
+    }
+    return undefined;
+}
+class AggFuncVal extends FuncBaseVal_1.FuncBaseVal {
+    constructor(spec, ctx, op) {
+        super(spec, ctx);
+        this.isAggFunc = true;
+        // THE STAGING RULE (G8 phase 0). A total over a bag that is still
+        // being merged into is a total of the wrong bag -- the same reason
+        // `filter` and `each` wait.
+        this.staged = true;
+        this.op = op;
+    }
+    // NO `make` OVERRIDE, matching the other STAGED funcs (pack, each,
+    // filter, match): a staged call returns `residuate` before `unify`
+    // ever reaches the rebuild branch, so an override there would be
+    // unreachable code pretending to be a contract. The base's `make`
+    // raises `func:<name>` if that ever stops being true, which is the
+    // loud answer rather than a value that silently lost its operation.
+    funcname() {
+        return this.op;
+    }
+    // The base does not drive the argument: `unify` drives it by hand,
+    // because a staged func must advance what it is waiting on every
+    // pass rather than only on the pass it fires.
+    prepare(_ctx, _args) {
+        return null;
+    }
+    unify(peer, ctx) {
+        const ready = this.driveStagedArgs(ctx, 1);
+        if (!ready || !ctx.settle) {
+            return this.residuate(peer, ctx);
+        }
+        return super.unify(peer, ctx);
+    }
+    resolve(ctx, args) {
+        const children = bagChildren(args?.[0]);
+        if (undefined === children) {
+            return this.place((0, err_1.makeNilErr)(ctx, 'aggregate_data', this, undefined, this.op));
+        }
+        if ('sum' === this.op) {
+            // Zero is addition's identity, so an empty bag has an answer and
+            // it is an integer -- the narrowest kind, which the first real
+            // operand then widens under R5 exactly as `add(0, x)` would.
+            let total = new IntegerVal_1.IntegerVal({ peg: 0 });
+            for (const child of children) {
+                total = (0, arith_1.arith)(ctx, 'add', this, total, child, this.op);
+                // A refusal inside the fold IS the answer: adding on past a
+                // non-numeric child or an overflow would report the wrong
+                // reason, or none.
+                if (true === total.isNil) {
+                    return this.place(total);
+                }
+            }
+            return this.place(total);
+        }
+        if (0 === children.length) {
+            return this.place((0, err_1.makeNilErr)(ctx, 'aggregate_empty', this, undefined, this.op));
+        }
+        const want = 'least' === this.op ? -1 : 1;
+        let best = undefined;
+        for (const child of children) {
+            const c = unpref(child);
+            if (!(c?.isVal && c.isScalar && 'string' !== typeof c.peg &&
+                'boolean' !== typeof c.peg && !c.isNull)) {
+                return this.place((0, err_1.makeNilErr)(ctx, 'invalid-arg', this, undefined, this.op));
+            }
+            // The EXACT comparator (numcmp), never binary64: a bigdecimal and
+            // an integer in one bag must order by their values and not by
+            // whatever their float images happen to be.
+            if (undefined === best || want === (0, numcmp_1.cmpNumeric)(c, best)) {
+                best = c;
+            }
+        }
+        // The winner is returned as itself, so it keeps its own kind: the
+        // least of a bag of bigdecimals is a bigdecimal.
+        return this.place(best.clone(ctx));
+    }
+}
+exports.AggFuncVal = AggFuncVal;
+// A pref child contributes its preferred value, and therefore that
+// value's kind too -- the rule `+` and the arithmetic family apply to
+// operands, applied here to bag members.
+function unpref(v) {
+    while (v?.isPref) {
+        v = v.peg;
+    }
+    return v;
+}
+// PROJECTION: `pick(d, k)` -- one element per child of `d`, being that
+// child's `k`.
+//
+// The other half of the review's finding I: "`_.field` is unspellable,
+// `filter` cannot see into lists, `unique()`-by-field is reserved but
+// absent -- so 'no two services share a port' and 'unique event ids'
+// cannot be said." Without it the aggregates above cannot reach the
+// case that motivated them, because `sum` needs a bag of NUMBERS and a
+// model holds a bag of RECORDS:
+//
+//   total: sum(pick($.lines, amountCents))
+//
+// IT IS NOT `each` WITH A CLEVER TEMPLATE. `each(d, t)` MEETS each
+// child with `t`, and a meet cannot select: `each($.lines, _.amount)`
+// asks for a child that is simultaneously the whole record and one of
+// its fields, which is why every spelling of it answers `no_path`.
+// Selection is a different operation and gets its own verb.
+//
+// A CHILD MISSING THE KEY IS AN ERROR, not a silently shorter list.
+// Skipping would make `sum(pick(...))` quietly total the wrong set of
+// records -- the failure mode an aggregate exists to prevent -- so the
+// refusal names the child (`pick_key`).
+class PickFuncVal extends FuncBaseVal_1.FuncBaseVal {
+    constructor(spec, ctx) {
+        super(spec, ctx);
+        this.isPickFunc = true;
+        // The bag must settle before it is projected, exactly as it must
+        // before it is folded.
+        this.staged = true;
+    }
+    funcname() {
+        return 'pick';
+    }
+    // The base drives neither argument: the DATA is driven by hand below
+    // (a staged func must advance what it waits on every pass), and the
+    // KEY is a bare word, which the parser has already made a string.
+    prepare(_ctx, _args) {
+        return null;
+    }
+    unify(peer, ctx) {
+        const ready = this.driveStagedArgs(ctx, 1);
+        if (!ready || !ctx.settle) {
+            return this.residuate(peer, ctx);
+        }
+        return super.unify(peer, ctx);
+    }
+    resolve(ctx, args) {
+        const children = bagChildren(args?.[0]);
+        const key = args?.[1];
+        if (undefined === children) {
+            return this.place((0, err_1.makeNilErr)(ctx, 'aggregate_data', this, undefined, 'pick'));
+        }
+        // The key is a STRING for a map child and the decimal spelling of an
+        // index for a list child -- the same rule a reference segment
+        // follows, so `pick(d, 0)` and `$.d.0.x` agree about what `0` names.
+        const name = null == key?.peg ? undefined :
+            'string' === typeof key.peg ? key.peg :
+                'number' === typeof key.peg && key.isInteger ? String(key.peg) :
+                    undefined;
+        if (undefined === name) {
+            return this.place((0, err_1.makeNilErr)(ctx, 'invalid-arg', this, undefined, 'pick'));
+        }
+        const peg = [];
+        for (const child of children) {
+            const c = child;
+            const got = true === c?.isMap ? c.peg[name] :
+                true === c?.isList ? c.peg[Number(name)] :
+                    undefined;
+            if (null == got) {
+                return this.place((0, err_1.makeNilErr)(ctx, 'pick_key', this, undefined, 'pick', { key: name }));
+            }
+            peg.push(got.clone(ctx.descend(String(peg.length))));
+        }
+        return this.place(new ListVal_1.ListVal({ peg }, ctx));
+    }
+}
+exports.PickFuncVal = PickFuncVal;
+// Which of the three a value is.
+//
+// `text` -- `+` would take it, so the fold can.
+//
+// `never` -- a SETTLED value that will never become text: a map, a
+// list, a null. This is `join_member`, class `conflict`, and it names
+// the member rather than the call, because "one of these is not a
+// string" is only actionable if you are told which.
+//
+// `notyet` -- an unresolved kind, a top, a stable residue. NOT a join
+// failure at all: the call stays residual and generation reports
+// `mapval_no_gen`, class `incomplete`, exactly as docs/trust.md
+// requires ("a stable residue ... is ordinary incompleteness"). Getting
+// this split wrong in either direction is the defect that matters here:
+// refusing a residue makes `join` unusable inside a schema, and
+// deferring on a map makes a real error arrive as a shrug.
+function memberVerdict(v) {
+    const u = unpref(v);
+    if (undefined !== (0, PlusOpVal_1.plusText)(u)) {
+        return 'text';
+    }
+    if (true === u?.isMap || true === u?.isList || true === u?.isNull) {
+        return 'never';
+    }
+    return 'notyet';
+}
+// The separator is a STRING or it is nothing.
+//
+// A number would render perfectly well through `+`, and is still
+// refused: the separator is not a member of the fold, it is the
+// parameter naming the text between members, and `join(x, 5)` is far
+// likelier a mistake than an intent to separate with "5". `pick`'s key
+// argument draws the same line for the same reason. This is the
+// direction that can be loosened later without breaking a document;
+// the other direction cannot.
+function sepVerdict(v) {
+    const u = unpref(v);
+    if (u?.isVal && u.isScalar) {
+        return 'string' === typeof u.peg ? 'text' : 'never';
+    }
+    if (true === u?.isMap || true === u?.isList || true === u?.isNull) {
+        return 'never';
+    }
+    return 'notyet';
+}
+class JoinFuncVal extends FuncBaseVal_1.FuncBaseVal {
+    constructor(spec, ctx) {
+        super(spec, ctx);
+        this.isJoinFunc = true;
+        // The bag must settle before it is folded, exactly as it must before
+        // it is summed or projected.
+        this.staged = true;
+    }
+    // A `make` OVERRIDE, WHERE ITS AggFuncVal SIBLINGS HAVE NONE, and the
+    // difference is worth stating because it is not arbitrary. `sum`,
+    // `pick` and the rest are staged and nothing more: they residuate
+    // before `unify` reaches the rebuild branch, so a `make` there would
+    // be unreachable code pretending to be a contract, and the base's
+    // `func:<name>` refusal is the loud answer if that ever changes.
+    //
+    // `join` is the first builtin that is BOTH staged AND defers its
+    // resolution (see `deferResolve`). A deferred call has settled
+    // arguments, so it does reach the rebuild branch, and without this it
+    // raised `func:join` on the first document with an unresolved member
+    // — where the Go port residuated and reported `mapval_no_gen`.
+    // Opposite answers on `join($.m, ",")` with `m: [string]`, caught by
+    // running both engines rather than by either test suite. `super` and
+    // bare `id`, the two other deferring calls, each carry the same
+    // override for the same reason.
+    make(_ctx, spec) {
+        return new JoinFuncVal(spec);
+    }
+    funcname() {
+        return 'join';
+    }
+    // The base does not drive: `unify` drives by hand, because a staged
+    // func must advance what it is waiting on every pass rather than only
+    // on the pass it fires.
+    prepare(_ctx, _args) {
+        return null;
+    }
+    unify(peer, ctx) {
+        // BOTH arguments, unlike `pick`, which drives only its bag: `pick`'s
+        // key is a bare word the parser has already made a string, while a
+        // separator is an ordinary expression and `join($.rows, $.sep)` has
+        // to wait for it.
+        const ready = this.driveStagedArgs(ctx, 2);
+        if (!ready || !ctx.settle) {
+            return this.residuate(peer, ctx);
+        }
+        return super.unify(peer, ctx);
+    }
+    // The `notyet` half of the verdict, taken before `resolve` runs: with
+    // arguments settled but a member still a kind, the call rides the
+    // ordinary args-not-done path and residuates, which is what makes an
+    // unresolved member ordinary incompleteness rather than a refusal.
+    deferResolve(_ctx, args) {
+        const children = bagChildren(args?.[0]);
+        if (undefined === children) {
+            // Not a bag at all: let `resolve` say so rather than waiting for
+            // a settling that has already happened.
+            return false;
+        }
+        const sep = args?.[1];
+        if (undefined !== sep && 'notyet' === sepVerdict(sep)) {
+            return true;
+        }
+        return children.some((c) => 'notyet' === memberVerdict(c));
+    }
+    resolve(ctx, args) {
+        const children = bagChildren(args?.[0]);
+        if (undefined === children) {
+            return this.place((0, err_1.makeNilErr)(ctx, 'aggregate_data', this, undefined, 'join'));
+        }
+        // Arity is [1,2], so a second argument is present or the separator
+        // is the empty string -- which makes `join(coll)` concatenation.
+        // The separator's SHAPE is settled before resolve runs: the
+        // signature gate refuses every concrete non-string
+        // (docs/design/SIGNATURES.0.md; join(d: map|list, sep?: string)),
+        // and deferResolve holds the call while sepVerdict answers notyet
+        // -- so a present separator here is text.
+        let sep = '';
+        if (1 < args.length) {
+            sep = unpref(args[1]).peg;
+        }
+        // NO NIL-MEMBER GUARD, WHERE `sum` HAS ONE, and the difference is
+        // the fold's shape rather than an oversight. `sum` folds with
+        // `arith`, which MINTS a nil part-way through — a non-numeric child
+        // or an overflow — so it has to stop and return it. `join` folds
+        // already-unified values, and a nil among a list's elements
+        // collapses the list before this call resolves: `join([least([])],
+        // ",")` reports `aggregate_empty` at the member's own path,
+        // `$.o.0`, and never reaches here. A guard was written, the
+        // ADR-002 gate found it unexecuted, and probing confirmed no
+        // spelling reaches it, so it is removed rather than excused.
+        const parts = [];
+        for (const child of children) {
+            const u = unpref(child);
+            const text = (0, PlusOpVal_1.plusText)(u);
+            if (undefined === text) {
+                return this.place((0, err_1.makeNilErr)(ctx, 'join_member', this, undefined, 'join', { member: String(u?.canon) }));
+            }
+            parts.push(text);
+        }
+        // Every part is already a string, so this IS the `+` fold seeded
+        // with `""` -- written as one concatenation because a loop of `+`
+        // over settled strings cannot differ from it, and because the Go
+        // twin's strings.Join must produce the same bytes.
+        return this.place(new StringVal_1.StringVal({ peg: parts.join(sep) }));
+    }
+}
+exports.JoinFuncVal = JoinFuncVal;
+// The three the registry names. Each is its operation and nothing else.
+class SumFuncVal extends AggFuncVal {
+    constructor(spec, ctx) { super(spec, ctx, 'sum'); }
+}
+exports.SumFuncVal = SumFuncVal;
+class LeastFuncVal extends AggFuncVal {
+    constructor(spec, ctx) { super(spec, ctx, 'least'); }
+}
+exports.LeastFuncVal = LeastFuncVal;
+class GreatestFuncVal extends AggFuncVal {
+    constructor(spec, ctx) {
+        super(spec, ctx, 'greatest');
+    }
+} /* node:coverage ignore next 10 */
+exports.GreatestFuncVal = GreatestFuncVal;
+//# sourceMappingURL=AggFuncVal.js.map

package/dist/val/AggFuncVal.js.map

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

package/dist/val/ArithFuncVal.d.ts

@@ -0,0 +1,31 @@
+import type { Val, ValSpec } from '../type';
+import { AontuContext } from '../ctx';
+import { FuncBaseVal } from './FuncBaseVal';
+import type { ArithOp } from './arith';
+declare class ArithFuncVal extends FuncBaseVal {
+    isArithFunc: boolean;
+    op: ArithOp;
+    constructor(spec: ValSpec, ctx: AontuContext | undefined, op: ArithOp);
+    make(_ctx: AontuContext, spec: ValSpec): Val;
+    funcname(): ArithOp;
+    resolve(ctx: AontuContext | undefined, args: Val[]): Val;
+}
+declare class AddFuncVal extends ArithFuncVal {
+    constructor(spec: ValSpec, ctx?: AontuContext);
+}
+declare class SubFuncVal extends ArithFuncVal {
+    constructor(spec: ValSpec, ctx?: AontuContext);
+}
+declare class MulFuncVal extends ArithFuncVal {
+    constructor(spec: ValSpec, ctx?: AontuContext);
+}
+declare class DivFuncVal extends ArithFuncVal {
+    constructor(spec: ValSpec, ctx?: AontuContext);
+}
+declare class ModFuncVal extends ArithFuncVal {
+    constructor(spec: ValSpec, ctx?: AontuContext);
+}
+declare class RemFuncVal extends ArithFuncVal {
+    constructor(spec: ValSpec, ctx?: AontuContext);
+}
+export { ArithFuncVal, AddFuncVal, SubFuncVal, MulFuncVal, DivFuncVal, ModFuncVal, RemFuncVal, };

package/dist/val/ArithFuncVal.js

@@ -0,0 +1,62 @@
+"use strict";
+/* Copyright (c) 2025 Richard Rodger, MIT License */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemFuncVal = exports.ModFuncVal = exports.DivFuncVal = exports.MulFuncVal = exports.SubFuncVal = exports.AddFuncVal = exports.ArithFuncVal = void 0;
+const FuncBaseVal_1 = require("./FuncBaseVal");
+const arith_1 = require("./arith");
+// ONE CLASS FOR SIX FUNCTIONS, because every rule they obey is a rule
+// about arithmetic rather than about any one operation (see arith.ts).
+// Six near-identical classes would be six places for the exact ladder,
+// the zero divisor and the storage contract to drift apart, and the
+// number tower's whole point is that they cannot.
+//
+// The op is carried on the instance and answered by `funcname()`, which
+// is what canon renders and what an error names. The six one-line
+// subclasses below exist only because the parser's registry constructs
+// with `new funcval({peg: args})` and has nowhere to put a name; every
+// line of behaviour is here.
+class ArithFuncVal extends FuncBaseVal_1.FuncBaseVal {
+    constructor(spec, ctx, op) {
+        super(spec, ctx);
+        this.isArithFunc = true;
+        this.op = op;
+    }
+    // Rebuilt as its own class, carrying its own op: residuation must not
+    // turn a `sub` into a bare arithmetic call with no operation.
+    make(_ctx, spec) {
+        return new this.constructor(spec, undefined, this.op);
+    }
+    funcname() {
+        return this.op;
+    }
+    resolve(ctx, args) {
+        return this.place((0, arith_1.arith)(ctx, this.op, this, args?.[0], args?.[1]));
+    }
+}
+exports.ArithFuncVal = ArithFuncVal;
+// The six the registry names. Each is its operation and nothing else.
+class AddFuncVal extends ArithFuncVal {
+    constructor(spec, ctx) { super(spec, ctx, 'add'); }
+}
+exports.AddFuncVal = AddFuncVal;
+class SubFuncVal extends ArithFuncVal {
+    constructor(spec, ctx) { super(spec, ctx, 'sub'); }
+}
+exports.SubFuncVal = SubFuncVal;
+class MulFuncVal extends ArithFuncVal {
+    constructor(spec, ctx) { super(spec, ctx, 'mul'); }
+}
+exports.MulFuncVal = MulFuncVal;
+class DivFuncVal extends ArithFuncVal {
+    constructor(spec, ctx) { super(spec, ctx, 'div'); }
+}
+exports.DivFuncVal = DivFuncVal;
+class ModFuncVal extends ArithFuncVal {
+    constructor(spec, ctx) { super(spec, ctx, 'mod'); }
+}
+exports.ModFuncVal = ModFuncVal;
+class RemFuncVal extends ArithFuncVal {
+    constructor(spec, ctx) { super(spec, ctx, 'rem'); }
+} /* node:coverage ignore next 11 */
+exports.RemFuncVal = RemFuncVal;
+//# sourceMappingURL=ArithFuncVal.js.map

package/dist/val/ArithFuncVal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArithFuncVal.js","sourceRoot":"","sources":["../../src/val/ArithFuncVal.ts"],"names":[],"mappings":";AAAA,oDAAoD;;;AAYpD,+CAA2C;AAC3C,mCAA+B;AAI/B,sEAAsE;AACtE,uEAAuE;AACvE,uEAAuE;AACvE,oEAAoE;AACpE,kDAAkD;AAClD,EAAE;AACF,wEAAwE;AACxE,kEAAkE;AAClE,uEAAuE;AACvE,uEAAuE;AACvE,6BAA6B;AAC7B,MAAM,YAAa,SAAQ,yBAAW;IAQpC,YACE,IAAa,EACb,GAA6B,EAC7B,EAAW;QAEX,KAAK,CAAC,IAAI,EAAE,GAAG,CAAC,CAAA;QAZlB,gBAAW,GAAG,IAAI,CAAA;QAahB,IAAI,CAAC,EAAE,GAAG,EAAE,CAAA;IACd,CAAC;IAGD,sEAAsE;IACtE,8DAA8D;IAC9D,IAAI,CAAC,IAAkB,EAAE,IAAa;QACpC,OAAO,IAAK,IAAI,CAAC,WAAmB,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,CAAC,EAAE,CAAC,CAAA;IAChE,CAAC;IAED,QAAQ;QACN,OAAO,IAAI,CAAC,EAAE,CAAA;IAChB,CAAC;IAGD,OAAO,CAAC,GAA6B,EAAE,IAAW;QAChD,OAAO,IAAI,CAAC,KAAK,CAAC,IAAA,aAAK,EAAC,GAAG,EAAE,IAAI,CAAC,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IACpE,CAAC;CAWF;QA8BC,YAAY;AA3Bd,sEAAsE;AACtE,MAAM,UAAW,SAAQ,YAAY;IACnC,YAAY,IAAa,EAAE,GAAkB,IAAI,KAAK,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAA,CAAC,CAAC;CAC3E;QAyBC,UAAU;AAvBZ,MAAM,UAAW,SAAQ,YAAY;IACnC,YAAY,IAAa,EAAE,GAAkB,IAAI,KAAK,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAA,CAAC,CAAC;CAC3E;QAsBC,UAAU;AApBZ,MAAM,UAAW,SAAQ,YAAY;IACnC,YAAY,IAAa,EAAE,GAAkB,IAAI,KAAK,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAA,CAAC,CAAC;CAC3E;QAmBC,UAAU;AAjBZ,MAAM,UAAW,SAAQ,YAAY;IACnC,YAAY,IAAa,EAAE,GAAkB,IAAI,KAAK,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAA,CAAC,CAAC;CAC3E;QAgBC,UAAU;AAdZ,MAAM,UAAW,SAAQ,YAAY;IACnC,YAAY,IAAa,EAAE,GAAkB,IAAI,KAAK,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAA,CAAC,CAAC;CAC3E;QAaC,UAAU;AAXZ,MAAM,UAAW,SAAQ,YAAY;IACnC,YAAY,IAAa,EAAE,GAAkB,IAAI,KAAK,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAA,CAAC,CAAC;CAC3E,CAAC,kCAAkC;QAUlC,UAAU"}

package/dist/val/BagVal.d.ts

@@ -7,12 +7,19 @@ declare abstract class BagVal extends FeatureVal {
     isGenable: boolean;
     closed: boolean;
     optionalKeys: string[];
+    aliasKeys: string[];
     spread: {
         cj: Val | undefined;
     };
     constructor(spec: ValSpec, ctx?: AontuContext);
     clone(ctx: AontuContext, spec?: ValSpec): Val;
     handleExpectedVal(key: string, val: Val, parent: Val, ctx: AontuContext): Val;
+    same(peer: any): boolean;
     gen(ctx: AontuContext): any;
 }
 export { BagVal, };
+export declare function sizingResidue(v: any): {
+    con: any;
+    bag: any;
+} | undefined;
+export declare function bagGenable(child: any): boolean;