aontu 0.52.1 → 0.54.0

package/src/val/ContainerKindVal.ts

@@ -0,0 +1,158 @@
+/* Copyright (c) 2025 Richard Rodger, MIT License */
+
+// CONTAINER KINDS (docs/design/PATHS.0.md). `{}` and `[]` are the
+// container UNITS: they admit any map (or list) AND generate empty
+// when nothing arrives. `map()` and `list()` are the container KINDS
+// proper: they admit exactly the same values and default to NOTHING,
+// as `string` does -- the spelling of "this must be a map, and it
+// must be supplied", which the unit cannot say because an unmet unit
+// silently manufactures its empty value.
+//
+// The vacuous call is the kind; the literal is the unit. That is the
+// whole convention, and it is why neither function takes arguments:
+// element constraints already belong to the spreads (`{&: V}`,
+// `[&: V]`), and a second spelling of them here would drift.
+//
+// No null/top/nil arms, as RelVal records: unite's dispatch ladder
+// absorbs those peers before any Val's own unify is consulted, and
+// FuncBaseVal returns a done resolution directly against a top peer.
+
+import type {
+  Val,
+  ValSpec,
+} from '../type'
+
+import {
+  DONE,
+} from '../type'
+
+import {
+  AontuContext,
+} from '../ctx'
+
+import { makeNilErr } from '../err'
+
+import { FeatureVal } from './FeatureVal'
+import { FuncBaseVal } from './FuncBaseVal'
+
+
+class MapKindVal extends FeatureVal {
+  isContainerKind = true
+  isMapKind = true
+
+  constructor(spec: ValSpec, ctx?: AontuContext) {
+    super(spec, ctx)
+    this.dc = DONE
+  }
+
+  unify(peer: Val, ctx: AontuContext): Val {
+    const p: any = peer
+    if (true === p.isMap) {
+      return peer
+    }
+    if (true === p.isMapKind) {
+      return this
+    }
+    // The unit's own refusal code: a kind mismatch here is the same
+    // fact `{} & 1` reports, and two codes for one fact would drift.
+    return makeNilErr(ctx, 'map', this, peer)
+  }
+
+  get canon() {
+    return 'map()'
+  }
+
+  same(peer: any): boolean {
+    return true === peer?.isMapKind
+  }
+
+} /* node:coverage ignore next 4 */
+
+
+class ListKindVal extends FeatureVal {
+  isContainerKind = true
+  isListKind = true
+
+  constructor(spec: ValSpec, ctx?: AontuContext) {
+    super(spec, ctx)
+    this.dc = DONE
+  }
+
+  unify(peer: Val, ctx: AontuContext): Val {
+    const p: any = peer
+    if (true === p.isList) {
+      return peer
+    }
+    if (true === p.isListKind) {
+      return this
+    }
+    return makeNilErr(ctx, 'list', this, peer)
+  }
+
+  get canon() {
+    return 'list()'
+  }
+
+  same(peer: any): boolean {
+    return true === peer?.isListKind
+  }
+
+} /* node:coverage ignore next 4 */
+
+
+class MapFuncVal extends FuncBaseVal {
+  isMapFunc = true
+
+  constructor(spec: ValSpec, ctx?: AontuContext) {
+    super(spec, ctx)
+  }
+
+  make(_ctx: AontuContext, spec: ValSpec): Val {
+    return new MapFuncVal(spec)
+  }
+
+  funcname() {
+    return 'map'
+  }
+
+  resolve(ctx: AontuContext, _args: Val[]) {
+    const out = new MapKindVal({}, ctx)
+    out.site = this.site
+    out.path = this.path
+    return out
+  }
+
+} /* node:coverage ignore next 4 */
+
+
+class ListFuncVal extends FuncBaseVal {
+  isListFunc = true
+
+  constructor(spec: ValSpec, ctx?: AontuContext) {
+    super(spec, ctx)
+  }
+
+  make(_ctx: AontuContext, spec: ValSpec): Val {
+    return new ListFuncVal(spec)
+  }
+
+  funcname() {
+    return 'list'
+  }
+
+  resolve(ctx: AontuContext, _args: Val[]) {
+    const out = new ListKindVal({}, ctx)
+    out.site = this.site
+    out.path = this.path
+    return out
+  }
+
+} /* node:coverage ignore next 8 */
+
+
+export {
+  MapKindVal,
+  ListKindVal,
+  MapFuncVal,
+  ListFuncVal,
+}

package/src/val/CopyFuncVal.ts

@@ -13,7 +13,6 @@ import {
 
 import { makeNilErr } from '../err'
 
-import { NilVal } from '../val/NilVal'
 
 
 import {

package/src/val/Decimal.ts

@@ -176,6 +176,21 @@ class Decimal {
   }
 
 
+  // D6 -- EXACT MULTIPLICATION. Multiply the coefficients, ADD the
+  // scales: (a/10^s)(b/10^t) is ab/10^(s+t), with no alignment step and
+  // no rounding mode, exactly as add() has none.
+  //
+  // The result leaves the budget far more readily than a sum does --
+  // scales add rather than taking the maximum, and coefficient digits
+  // add too -- so squaring a value at half the budget is already over
+  // it. Every caller must test with decimalOverBudget() and report
+  // `decimal_budget`, for the same reason add()'s callers must: at the
+  // limit, refusing is the only answer that is not a rounded one.
+  multiply(peer: Decimal): Decimal {
+    return new Decimal(this.unscaled * peer.unscaled, this.scale + peer.scale)
+  }
+
+
   // Exact ceiling and floor, for `upper()`/`lower()`. Coefficient
   // arithmetic only -- Math.ceil of this value would mean rounding it to
   // binary64 first, which for a leaf that exists to escape binary64 is

package/src/val/DeprecateFuncVal.ts

@@ -0,0 +1,84 @@
+/* Copyright (c) 2025 Richard Rodger, MIT License */
+
+// The deprecation mark (G3 phase 4,
+// docs/capability-review/g3-subsumption-evolution.md): a function-form
+// builtin, `deprecate(x, m)`, that unifies EXACTLY as `x` while the
+// record `m` rides the result through meets. The record's keys are
+// msg, use and since — all optional, all strings; `use` is a path
+// spelled as a STRING, because a live reference would resolve and
+// unify, which is not wanted. Boolean ValMarks cannot hold a record,
+// so the Val carries one optional field (Val.deprecation), propagated
+// by the same channel as the marks (propagateMarks) and rendered back
+// reparseably by canon (canonRiders).
+
+import type {
+  Val,
+  ValSpec,
+} from '../type'
+
+import {
+  AontuContext,
+} from '../ctx'
+
+import { makeNilErr } from '../err'
+
+import { FuncBaseVal } from './FuncBaseVal'
+
+
+// The record's whole vocabulary. Other keys are DROPPED, not carried:
+// the record is a contract the tooling reads (vet, the LSP tag, the
+// breaking downgrade), and a bag of free-form keys would be a second,
+// unspecified metadata channel.
+const DEPRECATION_KEYS = ['msg', 'use', 'since']
+
+
+class DeprecateFuncVal extends FuncBaseVal {
+  isDeprecateFunc = true
+
+  constructor(
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    super(spec, ctx)
+  }
+
+  make(_ctx: AontuContext, spec: ValSpec): Val {
+    return new DeprecateFuncVal(spec)
+  }
+
+  funcname() {
+    return 'deprecate'
+  }
+
+  resolve(ctx: AontuContext, args: Val[]) {
+    let out = args[0] ?? makeNilErr(ctx, 'arg', this)
+
+    // A nil ARGUMENT is returned unchanged, never marked: marking it
+    // makes the bag's marked-child skip drop it (the type()/hide()
+    // lesson — refusal over corruption, D7).
+    if (out.isNil) {
+      return out
+    }
+
+    out = out.clone(ctx)
+
+    const record: Record<string, string> = {}
+    const m: any = args[1]
+    if (true === m?.isMap && null != m.peg) {
+      for (const key of DEPRECATION_KEYS) {
+        const v = m.peg[key]
+        if (true === v?.isScalar && 'string' === typeof v.peg) {
+          record[key] = v.peg
+        }
+      }
+    }
+    out.deprecation = record
+
+    return out
+  }
+} /* node:coverage ignore next 6 */
+
+
+export {
+  DeprecateFuncVal,
+}