@jarenjs/json 0.9.2 → 0.34.0

package/src/jslt/dispatch.js

@@ -14,6 +14,7 @@ import {
 import {
   CARD_MANY,
   normalizeQuery,
+  hostFailureText,
 } from '../query/normalize.js';
 import {
   compileNode,
@@ -33,6 +34,7 @@ import {
   JsltCompileError,
   JsltRuntimeError,
 } from './errors.js';
+import { setObjectMember } from '@jarenjs/core/object';
 
 const hasOwn = Object.hasOwn;
 const NO_RULE = Symbol('Jslt.NoRule');
@@ -46,15 +48,15 @@ function composeDocPath(base, inner) {
   return inner.length === 0 ? base : base + inner;
 }
 
-function errorText(error) {
-  return error instanceof Error ? error.message : String(error);
-}
+// the one total host-failure projection of the package (see
+// query/normalize.js): no raw .message read, no user coercion, no
+// proxy-observable reflection
 
 // One compiled query per distinct match-path source string: rules across
 // modes matching the same path share the object, so the per-call
 // `.paths(root)` enumeration is computed once per transform (see
 // getQueryPaths), not once per mode.
-function compileMatchPath(rule, pathQueryCache) {
+function compileMatchPath(rule, pathQueryCache, pathOptions) {
   const match = rule.match;
   if (match === null || match.path === null)
     return null;
@@ -62,7 +64,8 @@ function compileMatchPath(rule, pathQueryCache) {
   if (cached !== undefined)
     return cached;
   try {
-    const query = compileJSONPath(match.path);
+    const query = compileJSONPath(match.path,
+      pathOptions === undefined ? undefined : { pathFunctions: pathOptions.pathFunctions });
     pathQueryCache.set(match.path, query);
     return query;
   }
@@ -89,7 +92,7 @@ function compileMatchSchema(rule, compileTypeTest) {
   }
   catch (error) {
     throw new JsltCompileError('JT0005',
-      `invalid match schema: ${errorText(error)}`, match.schemaDocPath, error);
+      `invalid match schema: ${hostFailureText(error)}`, match.schemaDocPath, error);
   }
   if (typeof test !== 'function') {
     const cause = new TypeError('the type-test compiler did not return a predicate function');
@@ -112,7 +115,6 @@ function appendDispatched(acc, selected, targetMode, depth, tctx, dispatch) {
 
 function createApplyEntry(ruleBox, tableBox, targetModes) {
   return {
-    result: () => CARD_MANY,
     normalize(arg, docPath, opPath, scope, ctx, helpers) {
       let selector;
       let targetMode = ruleBox.mode;
@@ -130,6 +132,7 @@ function createApplyEntry(ruleBox, tableBox, targetModes) {
         }
       }
       targetModes.add(targetMode);
+      ruleBox.targets.add(targetMode);
       const args = [selector];
       if (Array.isArray(arg) && arg.length === 2) // the explicit-mode form
         args.push(helpers.makeRaw(targetMode, opPath + '/1'));
@@ -186,12 +189,13 @@ function wrapBodyCompileError(rule, error) {
     composeDocPath(rule.bodyDocPath, error.docPath), error);
 }
 
-function compileBody(rule, compileTypeTest, tableBox, targetModes) {
+function compileBody(rule, compileTypeTest, tableBox, targetModes, pathOptions) {
   const ruleBox = {
     mode: rule.mode,
     locSlot: -1,
     depthSlot: -1,
     tctxSlot: -1,
+    targets: new Set(), // the modes this body's $apply calls dispatch into
   };
   const applyEntry = createApplyEntry(ruleBox, tableBox, targetModes);
   let normalized;
@@ -199,7 +203,13 @@ function compileBody(rule, compileTypeTest, tableBox, targetModes) {
   try {
     normalized = normalizeQuery(rule.body, {
       compileTypeTest,
-      extensions: { '$apply': applyEntry },
+      // the host's registered operators merge in, but $apply ALWAYS wins
+      // (a pack cannot shadow the dispatch operator)
+      extensions: pathOptions === undefined || pathOptions.extensions === undefined
+        ? { '$apply': applyEntry }
+        : { ...pathOptions.extensions, '$apply': applyEntry },
+      functions: pathOptions === undefined ? undefined : pathOptions.functions,
+      pathFunctions: pathOptions === undefined ? undefined : pathOptions.pathFunctions,
     });
     ruleBox.locSlot = normalized.frameSize;
     ruleBox.depthSlot = normalized.frameSize + 1;
@@ -241,9 +251,130 @@ function compileBody(rule, compileTypeTest, tableBox, targetModes) {
     pathSlot,
     readsPath,
     userExternals,
+    targets: ruleBox.targets,
   };
 }
 
+//#region body memoization (the `memo` option)
+
+// Ref-keyed body memoization: for an eligible rule, the same (location,
+// value reference) pair MUST produce the same output, so the previous
+// output can be returned by reference. Combined with copy-on-write state
+// updates upstream and a reference-equality fast path downstream (the
+// @jarenjs/view patcher), unchanged subtrees render in O(1) frame over
+// frame. Eligibility is decided entirely at compile time:
+//
+//  - the body reads neither $root, $path nor user externals (those make
+//    output depend on more than the matched value), and
+//  - every mode reachable through the body's $apply calls is STABLE: all
+//    of its rules are themselves body-clean, and their match paths do
+//    not reference the root inside a filter (a second '$' in the path
+//    source) - selection there depends only on (location, value), so
+//    the child dispatches frozen inside a cached output stay correct.
+//
+// The cache is generational (two maps, swapped per transform call):
+// entries unused for one full transform are dropped, bounding retention
+// to the size of the live output.
+
+function computeMemoEligibility(temporary) {
+  const modeRules = new Map();
+  for (let i = 0; i < temporary.length; i++) {
+    const mode = temporary[i].rule.mode;
+    const list = modeRules.get(mode);
+    if (list === undefined)
+      modeRules.set(mode, [i]);
+    else
+      list.push(i);
+  }
+
+  const bodyClean = new Array(temporary.length);
+  const selectionStable = new Array(temporary.length);
+  for (let i = 0; i < temporary.length; i++) {
+    const body = temporary[i].body;
+    bodyClean[i] = body.rootSlot < 0 && !body.readsPath && body.userExternals.length === 0;
+    const match = temporary[i].rule.match;
+    const path = match === null ? null : match.path;
+    selectionStable[i] = path === null || path.indexOf('$', 1) === -1;
+  }
+
+  // modes with no rules fall to the built-in dispositions, which depend
+  // only on (location, value): vacuously stable
+  const modeOk = new Map();
+  for (const name of modeRules.keys())
+    modeOk.set(name, true);
+  const ok = (name) => modeOk.get(name) !== false;
+
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const [name, indexes] of modeRules) {
+      if (modeOk.get(name) === false)
+        continue;
+      let good = true;
+      for (let j = 0; j < indexes.length && good; j++) {
+        const i = indexes[j];
+        if (!bodyClean[i] || !selectionStable[i]) {
+          good = false;
+          break;
+        }
+        for (const target of temporary[i].body.targets) {
+          if (!ok(target)) {
+            good = false;
+            break;
+          }
+        }
+      }
+      if (!good) {
+        modeOk.set(name, false);
+        changed = true;
+      }
+    }
+  }
+
+  const eligible = new Array(temporary.length);
+  for (let i = 0; i < temporary.length; i++) {
+    let good = bodyClean[i];
+    if (good) {
+      for (const target of temporary[i].body.targets) {
+        if (!ok(target)) {
+          good = false;
+          break;
+        }
+      }
+    }
+    eligible[i] = good;
+  }
+  return eligible;
+}
+
+function memoizeBodyEvaluator(evaluate, memoCaches) {
+  const box = { current: new Map(), previous: new Map() };
+  memoCaches.push(box);
+  return (value, loc, depth, tctx) => {
+    if (loc === null)
+      return evaluate(value, loc, depth, tctx);
+    let entry = box.current.get(loc);
+    if (entry === undefined) {
+      entry = box.previous.get(loc);
+      if (entry !== undefined)
+        box.current.set(loc, entry);
+    }
+    if (entry !== undefined && entry.value === value)
+      return entry.output;
+    const output = evaluate(value, loc, depth, tctx);
+    if (entry !== undefined) {
+      entry.value = value;
+      entry.output = output;
+    }
+    else {
+      box.current.set(loc, { value, output });
+    }
+    return output;
+  };
+}
+
+//#endregion
+
 function makeBodyEvaluator(rule, body, userSlots) {
   const {
     bodyGet,
@@ -290,7 +421,7 @@ function makeBodyEvaluator(rule, body, userSlots) {
   };
 }
 
-function compileRules(model, compileTypeTest, tableBox, targetModes) {
+function compileRules(model, compileTypeTest, tableBox, targetModes, memoEnabled, pathOptions) {
   const rules = model.rules;
   const temporary = new Array(rules.length);
   const externalNames = [];
@@ -301,11 +432,11 @@ function compileRules(model, compileTypeTest, tableBox, targetModes) {
   let pathRuleCount = 0;
   for (let i = 0; i < rules.length; i++) {
     const rule = rules[i];
-    const pathQuery = compileMatchPath(rule, pathQueryCache);
+    const pathQuery = compileMatchPath(rule, pathQueryCache, pathOptions);
     if (pathQuery !== null)
       pathRuleCount++;
     const test = compileMatchSchema(rule, compileTypeTest);
-    const body = compileBody(rule, compileTypeTest, tableBox, targetModes);
+    const body = compileBody(rule, compileTypeTest, tableBox, targetModes, pathOptions);
     readsPath = readsPath || body.readsPath;
     const userExternals = body.userExternals;
     for (let j = 0; j < userExternals.length; j++) {
@@ -322,6 +453,9 @@ function compileRules(model, compileTypeTest, tableBox, targetModes) {
   for (let i = 0; i < externalNames.length; i++)
     externalIndexes.set(externalNames[i], i);
 
+  const memoEligible = memoEnabled ? computeMemoEligibility(temporary) : null;
+  const memoCaches = [];
+
   const compiled = new Array(rules.length);
   for (let i = 0; i < temporary.length; i++) {
     const item = temporary[i];
@@ -334,11 +468,14 @@ function compileRules(model, compileTypeTest, tableBox, targetModes) {
     }
     const frozenSlots = Object.freeze(userSlots);
     const frozenIndexes = Object.freeze(userIndexes);
+    let bodyEval = makeBodyEvaluator(item.rule, item.body, frozenSlots);
+    if (memoEligible !== null && memoEligible[i])
+      bodyEval = memoizeBodyEvaluator(bodyEval, memoCaches);
     compiled[i] = Object.freeze({
       index: item.rule.index,
       pathQuery: item.pathQuery,
       test: item.test,
-      bodyEval: makeBodyEvaluator(item.rule, item.body, frozenSlots),
+      bodyEval,
       userSlots: frozenSlots,
       userIndexes: frozenIndexes,
     });
@@ -348,6 +485,7 @@ function compileRules(model, compileTypeTest, tableBox, targetModes) {
     rules: Object.freeze(compiled),
     externals: Object.freeze(externalNames),
     readsPath,
+    memoCaches,
     // rules sharing one match path (across modes, the TOC/render idiom)
     // enumerate it once per transform call through tctx.queryPaths
     sharedQueries: pathRuleCount > pathQueryCache.size,
@@ -588,20 +726,6 @@ function scanSetRules(mode, value, loc, depth, tctx, matched) {
   return NO_RULE;
 }
 
-function setObjectMember(out, name, value) {
-  if (name === '__proto__') {
-    Object.defineProperty(out, name, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true,
-    });
-  }
-  else {
-    out[name] = value;
-  }
-}
-
 function describeLocation(loc) {
   return loc === null ? 'a location-less value' : loc;
 }
@@ -813,13 +937,30 @@ export function compileJsltDispatch(model, options = {}) {
   const maxDepth = options.maxDepth === undefined ? 1024 : options.maxDepth;
   if (!Number.isInteger(maxDepth) || maxDepth < 0)
     throw new TypeError('options.maxDepth must be a non-negative integer');
+  const memoEnabled = options.memo === true;
+  // JSONPath function extensions reach both places a stylesheet embeds
+  // a path: the rules' match paths, and the path strings inside rule
+  // bodies (through the query normalizer).
+  // options carried into each rule body's normalizeQuery: the RFC 9535
+  // path-function registry, plus the host's registered operators
+  // (options.extensions) and $call functions (options.functions) — the
+  // JSLT operator registry (registry.js) flows in exactly here. Built
+  // whenever ANY of the three is present.
+  const bodyOptions = (options.pathFunctions == null
+    && options.extensions == null && options.functions == null)
+    ? undefined
+    : {
+      pathFunctions: options.pathFunctions ?? undefined,
+      extensions: options.extensions ?? undefined,
+      functions: options.functions ?? undefined,
+    };
 
   const tableBox = {
     dispatch: null,
     needsLoc: false,
   };
   const targetModes = new Set();
-  const compiled = compileRules(model, compileTypeTest, tableBox, targetModes);
+  const compiled = compileRules(model, compileTypeTest, tableBox, targetModes, memoEnabled, bodyOptions);
   tableBox.needsLoc = model.anyPathRule || compiled.readsPath;
   const built = buildModes(model, compiled.rules, targetModes);
   const modes = built.modes;
@@ -896,12 +1037,21 @@ export function compileJsltDispatch(model, options = {}) {
   const externalNames = compiled.externals;
   const compiledRules = compiled.rules;
   const sharedQueries = compiled.sharedQueries;
+  const memoCaches = compiled.memoCaches;
   const rootLoc = tableBox.needsLoc ? '$' : null;
   // the all-unbound resolution is a compile-time constant; calls without
   // user bindings (the common case) share it instead of re-resolving
   const unboundRuleValues = resolveExternalValues(externalNames, compiledRules, null);
   return Object.freeze({
     evaluate(data, ext) {
+      // generation swap: entries unused for one full transform retire
+      for (let i = 0; i < memoCaches.length; i++) {
+        const box = memoCaches[i];
+        const retired = box.previous;
+        box.previous = box.current;
+        retired.clear();
+        box.current = retired;
+      }
       const tctx = {
         root: data,
         ruleExternalValues: ext == null || externalNames.length === 0

package/src/jslt/errors.js

@@ -3,17 +3,26 @@
 // `code` and a `docPath`, an RFC 6901 JSON Pointer into the stylesheet
 // document. Wrapped parser/query/hook errors are exposed through `cause`.
 
+import { CodedError } from '@jarenjs/core/errors';
+import { CodedDocPathError } from '../errors.js';
+
 /**
  * Error thrown when a JSLT stylesheet is rejected at compile time
  * (`JT0xxx` codes).
  */
-export class JsltCompileError extends Error {
-  constructor(code, message, docPath, cause = undefined) {
-    super(`${code}: ${message} at ${docPath}`,
-      cause === undefined ? undefined : { cause });
-    this.name = 'JsltCompileError';
-    this.code = code;
-    this.docPath = docPath;
+export class JsltCompileError extends CodedError {
+  /**
+   * @param {string} code
+   * @param {string} reason
+   * @param {string} docPath
+   * @param {...unknown} cause - When a fourth argument is passed AT
+   *   ALL, it is retained as an own `cause` — even `undefined`, so a
+   *   host hook that threw `undefined` stays distinguishable from "no
+   *   cause".
+   */
+  constructor(code, reason, docPath, ...cause) {
+    super('JsltCompileError', code, reason, docPath,
+      cause.length > 0 ? { cause: cause[0] } : undefined);
   }
 }
 
@@ -21,13 +30,9 @@ export class JsltCompileError extends Error {
  * Error thrown when evaluating a compiled JSLT stylesheet fails
  * (`JT2xxx` codes).
  */
-export class JsltRuntimeError extends Error {
-  constructor(code, message, docPath, cause = undefined) {
-    super(`${code}: ${message} at ${docPath}`,
-      cause === undefined ? undefined : { cause });
-    this.name = 'JsltRuntimeError';
-    this.code = code;
-    this.docPath = docPath;
+export class JsltRuntimeError extends CodedDocPathError {
+  constructor(code, reason, docPath, cause = undefined) {
+    super('JsltRuntimeError', code, reason, docPath, cause);
   }
 }
 

package/src/jslt/index.js

@@ -5,10 +5,13 @@
 
 import { deepFreezeCopy } from '../query/normalize.js';
 import { EMPTY, Seq } from '../query/runtime.js';
+import { createOptionVariantCache, identityOf } from '../option-variants.js';
 import { normalizeJsltStylesheet } from './stylesheet.js';
 import { compileJsltDispatch } from './dispatch.js';
 
 export { JsltCompileError, JsltRuntimeError } from './errors.js';
+export { createJsltRegistry } from './registry.js';
+export { mathPack, financePack, statsPack, allPacks } from './packs/index.js';
 
 /**
  * Compile a Jaren JSLT 0.1 stylesheet into a reusable transformation.
@@ -28,6 +31,20 @@ export { JsltCompileError, JsltRuntimeError } from './errors.js';
  *   [options.compileTypeTest] - validator-agnostic hook compiling schema
  *   match conditions and schema literals inside query bodies
  * @param {number} [options.maxDepth=1024] - maximum dispatch nesting depth
+ * @param {boolean} [options.memo=false] - memoize rule outputs by
+ *   (location, value reference): across repeated transforms of
+ *   copy-on-write-updated documents, unchanged subtrees return the
+ *   PREVIOUS output by reference — the fuel for reference-equality
+ *   fast paths downstream (the @jarenjs/view patcher). Only rules whose
+ *   output provably depends on nothing but the matched value are cached
+ *   (no $root/$path/user externals, transitively through $apply, and no
+ *   root references inside match-path filters); everything else runs
+ *   normally. Memoized outputs MUST be treated as immutable, and the
+ *   cache retains the previous transform's outputs (two generations).
+ * @param {Record<string, import('../path.js').JSONPathFunction>}
+ *   [options.pathFunctions] - custom JSONPath function extensions (RFC
+ *   9535 section 2.4), available in rule match paths and in the path
+ *   strings inside rule bodies
  * @returns {function} reusable `transform(data, externals?)` function
  * @throws {import('./errors.js').JsltCompileError} when compilation fails
  * @example
@@ -53,41 +70,29 @@ export function compileJsltStylesheet(doc, options = {}) {
   return transform;
 }
 
-const STYLESHEET_CACHE = new WeakMap();
+const STYLESHEET_CACHE = createOptionVariantCache();
 
 function cachedTransform(stylesheet, options) {
-  let record = STYLESHEET_CACHE.get(stylesheet);
-  if (record === undefined) {
-    record = {
-      defaultTransform: null,
-      variants: null,
-    };
-    STYLESHEET_CACHE.set(stylesheet, record);
-  }
-
+  // Every option that changes what compiles is part of the derived key,
+  // or a second call with different options silently reuses the first
+  // compilation. Hooks and registries compare by identity, so they are
+  // interned to per-process ids.
   const compileTypeTest = typeof options?.compileTypeTest === 'function'
     ? options.compileTypeTest
     : null;
   const maxDepth = options?.maxDepth === undefined ? 1024 : options.maxDepth;
-  if (compileTypeTest === null && maxDepth === 1024) {
-    if (record.defaultTransform === null)
-      record.defaultTransform = compileJsltStylesheet(stylesheet);
-    return record.defaultTransform;
-  }
-
-  let variants = record.variants;
-  if (variants === null) {
-    variants = [];
-    record.variants = variants;
-  }
-  for (let i = 0; i < variants.length; i++) {
-    const variant = variants[i];
-    if (variant.compileTypeTest === compileTypeTest && variant.maxDepth === maxDepth)
-      return variant.transform;
-  }
-  const transform = compileJsltStylesheet(stylesheet, options);
-  variants.push({ compileTypeTest, maxDepth, transform });
-  return transform;
+  const memo = options?.memo === true;
+  const pathFunctions = options?.pathFunctions == null ? null : options.pathFunctions;
+  // registered operators/functions (the JSLT operator registry) change
+  // what compiles, so they join the key by identity — a registry hands a
+  // STABLE extensions/functions object per instance (registry.js), so
+  // two transforms with the same registry still hit the cache.
+  const extensions = options?.extensions == null ? null : options.extensions;
+  const functions = options?.functions == null ? null : options.functions;
+  const key = `${identityOf(compileTypeTest)}|${maxDepth}|${memo ? 1 : 0}`
+    + `|${identityOf(pathFunctions)}|${identityOf(extensions)}|${identityOf(functions)}`;
+  return STYLESHEET_CACHE.getOrCompile(stylesheet, key,
+    () => compileJsltStylesheet(stylesheet, options));
 }
 
 /**
@@ -101,6 +106,9 @@ function cachedTransform(stylesheet, options) {
  * @param {(schemaJson: any, docPath: string) => ((value: any) => boolean)}
  *   [options.compileTypeTest] - schema type-test compiler
  * @param {number} [options.maxDepth=1024] - maximum dispatch nesting depth
+ * @param {boolean} [options.memo=false] - memoize rule outputs
+ * @param {Record<string, import('../path.js').JSONPathFunction>}
+ *   [options.pathFunctions] - custom JSONPath function extensions
  * @returns {any} `undefined`, one JSON item, or an array of result items
  * @throws {import('./errors.js').JsltCompileError} when compilation fails
  * @throws {import('./errors.js').JsltRuntimeError} when dispatch fails

package/src/jslt/packs/finance.js

@@ -0,0 +1,49 @@
+//@ts-check
+/**
+ * @file The finance pack — parameterized aggregators over a sequence of
+ * numbers, wrapping the pure functions of `@jarenjs/core/finance`. Each
+ * `agg` entry declares which operands are folded sequences (`seq`) and
+ * which are scalars; the registry gathers the `seq` operands into arrays
+ * before the call (the fold contract). Whole-series functions (`irr`,
+ * `npv`, moving averages) are `pushable: false` — they run in the engine
+ * or the db residual, never as an index-eligible SQLite scalar UDF.
+ */
+
+import {
+  npv, irr, mirr, fv, pv, pmt, cagr,
+  sma, ema, wma, rsi, roc,
+  volatility, sharpe, maxDrawdown,
+} from '@jarenjs/core/finance';
+
+const aggNum = (signature, fn) => ({ kind: 'agg', signature, result: 'number', fn, pushable: false });
+const aggSeq = (signature, fn) => ({ kind: 'agg', signature, result: 'seq<number>', fn, pushable: false });
+const opNum = (n, fn) => ({ kind: 'op', signature: new Array(n).fill('number'), result: 'number', fn, pushable: false });
+
+export const financePack = {
+  name: 'finance',
+  entries: {
+    // present value of a cashflow series at a rate
+    $npv: aggNum(['number', 'seq<number>'], (rate, cashflows) => npv(rate, cashflows)),
+    // internal rate of return of a cashflow series
+    $irr: aggNum(['seq<number>'], (cashflows) => irr(cashflows)),
+    // modified IRR: series, finance rate, reinvest rate
+    $mirr: aggNum(['seq<number>', 'number', 'number'],
+      (cashflows, financeRate, reinvestRate) => mirr(cashflows, financeRate, reinvestRate)),
+    // time value of money (scalar operands; pv/type default)
+    $fv: opNum(3, (rate, nper, pmtv) => fv(rate, nper, pmtv)),
+    $pv: opNum(3, (rate, nper, pmtv) => pv(rate, nper, pmtv)),
+    $pmt: opNum(3, (rate, nper, pval) => pmt(rate, nper, pval)),
+    // compound annual growth rate
+    $cagr: opNum(3, (begin, end, years) => cagr(begin, end, years)),
+    // moving averages / indicators — return a series (null during warm-up)
+    $sma: aggSeq(['seq<number>', 'number'], (values, period) => sma(values, period)),
+    $ema: aggSeq(['seq<number>', 'number'], (values, period) => ema(values, period)),
+    $wma: aggSeq(['seq<number>', 'number'], (values, period) => wma(values, period)),
+    $rsi: aggSeq(['seq<number>', 'number'], (values, period) => rsi(values, period)),
+    $roc: aggSeq(['seq<number>', 'number'], (values, period) => roc(values, period)),
+    // risk / return summaries over a returns series
+    $volatility: aggNum(['seq<number>'], (returns) => volatility(returns)),
+    $sharpe: aggNum(['seq<number>'], (returns) => sharpe(returns)),
+    $maxDrawdown: aggNum(['seq<number>'], (values) => maxDrawdown(values)),
+  },
+};

package/src/jslt/packs/index.js

@@ -0,0 +1,18 @@
+//@ts-check
+/**
+ * @file The built-in operator packs, plain data wrapping `@jarenjs/core`.
+ * A caller composes them into a registry: `createJsltRegistry().use(
+ * mathPack).use(financePack)`. `allPacks` is the convenience array for
+ * "register everything".
+ */
+
+export { mathPack } from './math.js';
+export { financePack } from './finance.js';
+export { statsPack } from './stats.js';
+
+import { mathPack } from './math.js';
+import { financePack } from './finance.js';
+import { statsPack } from './stats.js';
+
+/** Every built-in pack, in a stable order. */
+export const allPacks = Object.freeze([mathPack, financePack, statsPack]);

package/src/jslt/packs/math.js

@@ -0,0 +1,46 @@
+//@ts-check
+/**
+ * @file The math pack — scalar `$`-operators the core query vocabulary
+ * lacks, wrapping the pure f64 functions of `@jarenjs/core/math`. Every
+ * entry is `kind: 'op'` (scalar operands, scalar result). `pushable:
+ * 'scalar'` marks the ones Ring 3 MAY register as a SQLite UDF; it is
+ * ignored in Rings 1–2.
+ */
+
+import {
+  mathf64_sqrt, mathf64_cbrt, mathf64_pow, mathf64_hypot, mathf64_sign,
+  mathf64_abs, mathf64_sin, mathf64_cos, mathf64_tan,
+  mathf64_asin, mathf64_acos, mathf64_atan, mathf64_atan2,
+  mathf64_sinh, mathf64_cosh, mathf64_tanh,
+  mathf64_log, mathf64_log2, mathf64_log10, mathf64_exp, mathf64_expm1,
+} from '@jarenjs/core/math';
+
+const op1 = (fn) => ({ kind: 'op', signature: ['number'], result: 'number', fn, pushable: 'scalar' });
+const op2 = (fn) => ({ kind: 'op', signature: ['number', 'number'], result: 'number', fn, pushable: 'scalar' });
+
+export const mathPack = {
+  name: 'math',
+  entries: {
+    $abs: op1(mathf64_abs),
+    $sign: op1(mathf64_sign),
+    $sqrt: op1(mathf64_sqrt),
+    $cbrt: op1(mathf64_cbrt),
+    $pow: op2(mathf64_pow),
+    $hypot: op2(mathf64_hypot),
+    $exp: op1(mathf64_exp),
+    $expm1: op1(mathf64_expm1),
+    $log: op1(mathf64_log),
+    $log2: op1(mathf64_log2),
+    $log10: op1(mathf64_log10),
+    $sin: op1(mathf64_sin),
+    $cos: op1(mathf64_cos),
+    $tan: op1(mathf64_tan),
+    $asin: op1(mathf64_asin),
+    $acos: op1(mathf64_acos),
+    $atan: op1(mathf64_atan),
+    $atan2: op2(mathf64_atan2),
+    $sinh: op1(mathf64_sinh),
+    $cosh: op1(mathf64_cosh),
+    $tanh: op1(mathf64_tanh),
+  },
+};