functionalscript 0.46.1 → 0.47.0

package/fjs/edag/module.f.d.mts

@@ -0,0 +1,410 @@
+/**
+ * @module
+ *
+ * @import { Assert } from '../asserts/types.ts'
+ * @import { Check, Check3 } from '../types/rtti/ts/types.ts'
+ * @import {
+ *  Array,
+ *  Exp,
+ *  Primitive,
+ *  Property,
+ *  NumberCast,
+ *  Object,
+ *  PropertyLambda,
+ *  OptionLambda,
+ *  OptionPropertyLambda,
+ *  Call,
+ *  Dot,
+ *  OptionDot,
+ *  OptionCall,
+ *  Comma,
+ *  Op2Id,
+ *  Op2,
+ *  Op1Id,
+ *  Op1,
+ *  Op0Id,
+ *  Op0,
+ *  Spread,
+ *  Items,
+ *  Properties,
+ *  Exps,
+ * } from './types.ts'
+ * @import { Phantom } from '../types/phantom/types.ts'
+ */
+import type { Assert } from '../asserts/types.ts';
+import type { Check, Check3 } from '../types/rtti/ts/types.ts';
+import type { Array, Exp, Primitive, Property, NumberCast, Object, PropertyLambda, OptionLambda, OptionPropertyLambda, Call, Dot, OptionDot, OptionCall, Comma, Op2Id, Op2, Op1Id, Op1, Op0Id, Op0, Spread, Items, Properties, Exps } from './types.ts';
+import type { Phantom } from '../types/phantom/types.ts';
+/**
+ * Every tuple here is closed — the members it declares and nothing else, which
+ * is what a bare `Tuple` says ("Structs and tuples are closed" in
+ * `../types/rtti/README.md`). That is load-bearing rather than incidental: the
+ * chain grammar below claims each JS chain has exactly one spelling, and an
+ * `open` tuple would let any node carry a trailing element nothing reads,
+ * splitting one function into unboundedly many graphs. So do **not** wrap any
+ * of these in `open`. No operand of any node is optional either: a chain step
+ * that does no further work carries an explicit `null` continuation, never a
+ * missing position.
+ *
+ * Do not call `parse(exp)` or rely on `validate(exp)` rejecting cycles
+ * without reading `../types/rtti/todo/identity-aware-parse.md` first —
+ * neither is identity-aware, and that TODO covers why and what's missing.
+ */
+/**
+ * Written out explicitly, not `@type {const}`: that can't apply to the
+ * arrow function itself (TS1355, literals only), and applied to just the
+ * returned array it still can't resolve the cycle back through `array`/
+ * `object`/`op0`/... to `exp` — declaration emit elides it to `any`.
+ *
+ * @type {() => readonly['or',
+ *  typeof primitive,
+ *  typeof array,
+ *  typeof object,
+ *  typeof dot,
+ *  typeof call,
+ *  typeof optionDot,
+ *  typeof optionCall,
+ *  typeof comma,
+ *  typeof op2,
+ *  typeof op1,
+ *  typeof op0,
+ * ]}
+ */
+declare const _exp: () => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0];
+/** @type {Phantom<typeof _exp, Exp>} */
+export declare const exp: Phantom<typeof _exp, Exp>;
+export type _ExpAssert = Assert<Check3<Exp, typeof _exp, typeof exp>>;
+/** @typedef {Assert<Check3<Exp, typeof _exp, typeof exp>>} _ExpAssert */
+/**
+ * Bare constant values — no tag, no operands, not an operation node at all.
+ * `undefined` is deliberately not among them: its EDAG representation,
+ * `['undefined']`, *is* a tagged operation node (so a bare `undefined` stays
+ * distinguishable from a missing tuple position), which puts it in the
+ * `op0`/`op1`/`op2` grouping below by the same arity rule as every other
+ * operation, not here.
+ */
+export declare const primitive: import("../types/rtti/types.ts").Or<readonly [null, import("../types/rtti/types.ts")._Type0<"boolean">, import("../types/rtti/types.ts")._Type0<"number">, import("../types/rtti/types.ts")._Type0<"string">, import("../types/rtti/types.ts").Bigint]>;
+export type _Primitive = Assert<Check<Primitive, typeof primitive>>;
+/** @typedef {Assert<Check<Primitive, typeof primitive>>} _Primitive */
+export declare const exps: import("../types/rtti/types.ts").Type1<"array", Phantom<() => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0], Exp>>;
+export type _Exps = Assert<Check<Exps, typeof exps>>;
+/** @typedef {Assert<Check<Exps, typeof exps>>} _Exps */
+/**
+ * ```js
+ * [...exp]  // as an array item, through `items` — see `array`
+ * {...exp}  // as an object property, through `properties` — see `object`
+ * ```
+ *
+ * Not a top-level `Exp`: `spread` only appears as an `items`/`properties`
+ * alternative, never as an operand an operation node can hold directly.
+ */
+export declare const spread: readonly ['...', Phantom<() => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0], Exp>];
+export type _Spread = Assert<Check<Spread, typeof spread>>;
+/** @typedef {Assert<Check<Spread, typeof spread>>} _Spread */
+/** An array element: a plain `exp`, or a `spread` splicing another array in. */
+export declare const items: import("../types/rtti/types.ts").Or<readonly [Phantom<() => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0], Exp>, readonly ["...", Phantom<() => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0], Exp>]]>;
+export type _Items = Assert<Check<Items, typeof items>>;
+/** @typedef {Assert<Check<Items, typeof items>>} _Items */
+/**
+ * ```js
+ * [exp0, exp1]
+ * [exp0, ...exp1]
+ * ```
+ */
+export declare const array: readonly ['[]', import("../types/rtti/types.ts").Type1<"array", import("../types/rtti/types.ts").Or<readonly [Phantom<() => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0], Exp>, readonly ["...", Phantom<() => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0], Exp>]]>>];
+export type _Array = Assert<Check<Array, typeof array>>;
+/** @typedef {Assert<Check<Array, typeof array>>} _Array */
+/**
+ * A structural operand of `object`, not an independently evaluated EDAG
+ * node: nothing ever evaluates a descriptor as a value, so whether one is
+ * shared by reference or written twice with equal content is unobservable,
+ * and conforming VMs may legally differ on it. Only the `key` and `value`
+ * operands are real nodes, their identities shared normally.
+ *
+ * The key stays `exp`, not narrowed to a string constant, and its evaluated
+ * value is coerced via JS `ToPropertyKey` when the property is defined —
+ * see `../../todo/edag-stage1-discussion.md` subject 4.
+ */
+export declare const property: readonly [':', Phantom<() => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0], Exp>, Phantom<() => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0], Exp>];
+export type _Property = Assert<Check<Property, typeof property>>;
+/** @typedef {Assert<Check<Property, typeof property>>} _Property */
+/** An object entry: a plain `property`, or a `spread` splicing another object in. */
+export declare const properties: import("../types/rtti/types.ts").Or<readonly [readonly [":", Phantom<() => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0], Exp>, Phantom<() => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0], Exp>], readonly ["...", Phantom<() => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0], Exp>]]>;
+export type _Properties = Assert<Check<Properties, typeof properties>>;
+/** @typedef {Assert<Check<Properties, typeof properties>>} _Properties */
+/**
+ * ```js
+ * {
+ *     a: exp0,
+ *     "a": exp1,
+ *     [exp2]: exp3,
+ *     ...exp4,
+ * }
+ * ```
+ *
+ * The entries are an ordered sequence, applied as if in written order —
+ * never sorted or deduplicated: order is observable (enumeration,
+ * overwrites), and duplicate keys are allowed with the later entry winning,
+ * which is also required once computed keys are admitted, since key
+ * equality may not be decidable at validation time.
+ *
+ * `__proto__` is a data key, never a prototype assignment: an entry whose
+ * key evaluates to `__proto__` defines an ordinary own property, and a
+ * printer must spell it computed — `{ ["__proto__"]: value }`, the only
+ * object-literal form that reproduces it; the identifier and string
+ * spellings assign a prototype instead and lose the property. See "the
+ * `__proto__` key" in `../../spec/README.md`.
+ */
+export declare const object: readonly ['{}', import("../types/rtti/types.ts").Type1<"array", import("../types/rtti/types.ts").Or<readonly [readonly [":", Phantom<() => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0], Exp>, Phantom<() => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0], Exp>], readonly ["...", Phantom<() => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0], Exp>]]>>];
+export type _Object = Assert<Check<Object, typeof object>>;
+/** @typedef {Assert<Check<Object, typeof object>>} _Object */
+/**
+ * ```js
+ * Number(exp)
+ * ```
+ */
+export declare const numberCast: readonly ['Number', Phantom<() => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0], Exp>];
+export type _NumberCast = Assert<Check<NumberCast, typeof numberCast>>;
+/**
+ * @typedef {Assert<Check<NumberCast, typeof numberCast>>} _NumberCast
+ */
+/**
+ * A property/index operand: a plain `string` or `number` key, or a `Number`
+ * cast around a computed `exp` (`arr[i]`, where `i` is itself an expression).
+ *
+ * Every naming position in the chain nodes below uses this rather than a bare
+ * `exp` — `.`, `?.`, and the `|.` step. Widening them to `exp` was weighed and
+ * rejected: `exp` and `index` overlap (`['Number', e]` is both a `numberCast`
+ * and an `op1`), so the wider spelling would buy a second reading of every
+ * computed key without buying any expression a `Number` cast cannot already
+ * name.
+ *
+ * Does not exclude `'constructor'`/`'__proto__'` — TODO, see
+ * `../types/rtti/todo/excluded-string-values.md`.
+ */
+export declare const index: import("../types/rtti/types.ts").Or<readonly [readonly ["Number", Phantom<() => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0], Exp>], import("../types/rtti/types.ts")._Type0<"string">, import("../types/rtti/types.ts")._Type0<"number">]>;
+/**
+ * The continuation of a step that produced a plain value **inside** an open
+ * region — what `?.()` owns, and what a call step hands on.
+ *
+ * `|()` stays in the region because the region has to cover the call:
+ * `a?.(...b)(...c)` skips the second call too. `|.` stays for the same
+ * reason, and hands on a receiver. Neither `|?.()` nor `|!()` is here: with P
+ * dead there is nothing for a guard or a close to protect that a nested node
+ * would not protect equally, so admitting them would only add a second
+ * spelling.
+ *
+ * @type {() => readonly['or',
+ *  null,
+ *  readonly['|()', typeof exp, typeof optionLambda],
+ *  readonly['|.', typeof index, typeof optionPropertyLambda],
+ * ]}
+ */
+declare const _optionLambda: () => readonly ['or', null, readonly ['|()', typeof exp, typeof optionLambda], readonly ['|.', typeof index, typeof optionPropertyLambda]];
+/** @type {Phantom<typeof _optionLambda, OptionLambda>} */
+export declare const optionLambda: Phantom<typeof _optionLambda, OptionLambda>;
+export type _OptionLambda = Assert<Check3<OptionLambda, typeof _optionLambda, typeof optionLambda>>;
+/**
+ * @typedef {Assert<Check3<OptionLambda, typeof _optionLambda, typeof optionLambda>>} _OptionLambda
+ */
+/**
+ * The continuation of a property step **inside** an open region — both bits
+ * live, so this is the state with every production.
+ *
+ * Its three call forms are a complete taxonomy of how a call can relate to
+ * the region around it, and there is no fourth:
+ *
+ * ```js
+ * a?.b(...c)     // ['?.', a, 'b', ['|()',   c, null]]  inherits the guard
+ * a?.b?.(...c)   // ['?.', a, 'b', ['|?.()', c, null]]  adds its own
+ * (a?.b)(...c)   // ['?.', a, 'b', ['|!()',  c, null]]  escapes it
+ * ```
+ *
+ * `|!()` is the one step a short-circuit does not skip: the parentheses ended
+ * the region, so the `undefined` it produced is what gets called. `|!` pairs
+ * only with `()` because only a call consumes a receiver — a close-then-access
+ * `|!.` would just be a `dot` over the whole node, which nesting already
+ * spells.
+ *
+ * @type {() => readonly['or',
+ *  null,
+ *  readonly['|()', typeof exp, typeof optionLambda],
+ *  readonly['|.', typeof index, typeof optionPropertyLambda],
+ *  readonly['|?.()', typeof exp, typeof optionLambda],
+ *  readonly['|!()', typeof exp, null],
+ * ]}
+ */
+declare const _optionPropertyLambda: () => readonly ['or', null, readonly ['|()', typeof exp, typeof optionLambda], readonly ['|.', typeof index, typeof optionPropertyLambda], readonly ['|?.()', typeof exp, typeof optionLambda], readonly ['|!()', typeof exp, null]];
+/** @type {Phantom<typeof _optionPropertyLambda, OptionPropertyLambda>} */
+export declare const optionPropertyLambda: Phantom<typeof _optionPropertyLambda, OptionPropertyLambda>;
+export type _OptionPropertyLambda = Assert<Check3<OptionPropertyLambda, typeof _optionPropertyLambda, typeof optionPropertyLambda>>;
+/**
+ * @typedef {Assert<Check3<OptionPropertyLambda, typeof _optionPropertyLambda, typeof optionPropertyLambda>>} _OptionPropertyLambda
+ */
+/**
+ * The continuation of a `dot` — a receiver is live and no region is open.
+ *
+ * Only the two call steps are here, because only a call can use a receiver.
+ * `|()` is terminal: with the receiver spent and no region to be inside, what
+ * follows an `a.b(...c)` is an ordinary expression over an ordinary value, so
+ * it nests. `|?.()` continues, since it opens a region that then owns the
+ * rest of the chain. There is no `|.` production, which is what gives a plain
+ * property path exactly one spelling: `a.b.c` is nested `dot`s and nothing
+ * else.
+ *
+ * The terminal's third operand is a literal `null`, not the absence of one.
+ * Uniform arity is what keeps closedness able to tell it from `['|()', c, k]`:
+ * were the terminal two elements long, a continuation handed to a
+ * `propertyLambda` slot would be read as the terminal with the rest silently
+ * dropped.
+ */
+export declare const propertyLambda: import("../types/rtti/types.ts").Or<readonly [null, readonly ["|()", Phantom<() => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0], Exp>, null], readonly ["|?.()", Phantom<() => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0], Exp>, Phantom<() => readonly ['or', null, readonly ['|()', typeof exp, typeof optionLambda], readonly ['|.', typeof index, typeof optionPropertyLambda]], OptionLambda>]]>;
+export type _PropertyLambda = Assert<Check<PropertyLambda, typeof propertyLambda>>;
+/**
+ * @typedef {Assert<Check<PropertyLambda, typeof propertyLambda>>} _PropertyLambda
+ */
+/**
+ * ```js
+ * exp0(...exp1)
+ * ```
+ *
+ * A call with **no** receiver and no region: the callee is an ordinary
+ * expression, so a chain never reaches this node — `a.b(...c)` is a `dot`
+ * whose continuation is the call, and `(0, a.b)(...c)` is this node over a
+ * complete `dot`. The two differ, which is why the distinction is structural.
+ *
+ * The last operand is one node evaluating to the complete argument array,
+ * not a literal operand list: `f(a, b)` is `['()', f, ['[]', [a, b]]]`,
+ * while spread `f(...xs)` is `['()', f, xs]`.
+ */
+export declare const call: readonly ['()', Phantom<() => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0], Exp>, Phantom<() => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0], Exp>];
+export type _Call = Assert<Check<Call, typeof call>>;
+/** @typedef {Assert<Check<Call, typeof call>>} _Call */
+/**
+ * ```js
+ * exp0.k                     // ['.', exp0, 'k', null]
+ * exp0[exp1]                 // ['.', exp0, ['Number', exp1], null]
+ * exp0.k(...exp2)            // ['.', exp0, 'k', ['|()', exp2, null]]
+ * exp0.k?.(...exp2)          // ['.', exp0, 'k', ['|?.()', exp2, null]]
+ * ```
+ *
+ * The naming operand is an `index`, not an `exp`, so a computed key is spelled
+ * `['Number', exp]`: `['.', a, ['args'], null]` does not validate.
+ *
+ * Property access, owning whatever the receiver it produces is used for. The
+ * `null` continuation is the plain read — the receiver is dropped, as JS
+ * drops it — and the two call continuations are the only things that can use
+ * it.
+ */
+export declare const dot: readonly ['.', Phantom<() => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0], Exp>, import("../types/rtti/types.ts").Or<readonly [readonly ["Number", Phantom<() => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0], Exp>], import("../types/rtti/types.ts")._Type0<"string">, import("../types/rtti/types.ts")._Type0<"number">]>, import("../types/rtti/types.ts").Or<readonly [null, readonly ["|()", Phantom<() => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0], Exp>, null], readonly ["|?.()", Phantom<() => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0], Exp>, Phantom<() => readonly ['or', null, readonly ['|()', typeof exp, typeof optionLambda], readonly ['|.', typeof index, typeof optionPropertyLambda]], OptionLambda>]]>];
+export type _Dot = Assert<Check<Dot, typeof dot>>;
+/** @typedef {Assert<Check<Dot, typeof dot>>} _Dot */
+/**
+ * ```js
+ * exp0?.k                    // ['?.', exp0, 'k', null]
+ * exp0?.[exp1]               // ['?.', exp0, ['Number', exp1], null]
+ * exp0?.k.m                  // ['?.', exp0, 'k', ['|.', 'm', null]]
+ * (exp0?.k)(...exp2)         // ['?.', exp0, 'k', ['|!()', exp2, null]]
+ * ```
+ *
+ * Optional property access, owning the rest of its optional region. If `exp0`
+ * is nullish the region short-circuits: neither the `index` nor any step of
+ * the continuation is evaluated — in particular `a?.[k]` does not evaluate
+ * `k` — and the node's value is `undefined`, unless the continuation reaches
+ * a `|!()`, which the parentheses put *outside* the region and which
+ * therefore calls that `undefined`.
+ *
+ * Where the region ends is the grouping: `a?.b.c` is one node,
+ * `['?.', a, 'b', ['|.', 'c', null]]`, while `(a?.b).c` is a `dot` over a
+ * complete `['?.', a, 'b', null]` — and throws when `a` is nullish, as JS
+ * does.
+ */
+export declare const optionDot: readonly ['?.', Phantom<() => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0], Exp>, import("../types/rtti/types.ts").Or<readonly [readonly ["Number", Phantom<() => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0], Exp>], import("../types/rtti/types.ts")._Type0<"string">, import("../types/rtti/types.ts")._Type0<"number">]>, Phantom<() => readonly ['or', null, readonly ['|()', typeof exp, typeof optionLambda], readonly ['|.', typeof index, typeof optionPropertyLambda], readonly ['|?.()', typeof exp, typeof optionLambda], readonly ['|!()', typeof exp, null]], OptionPropertyLambda>];
+export type _OptionDot = Assert<Check<OptionDot, typeof optionDot>>;
+/** @typedef {Assert<Check<OptionDot, typeof optionDot>>} _OptionDot */
+/**
+ * ```js
+ * exp0?.(...exp1)            // ['?.()', exp0, exp1, null]
+ * exp0?.(...exp1).k          // ['?.()', exp0, exp1, ['|.', 'k', null]]
+ * ```
+ *
+ * Optional call, owning the rest of its optional region the way `?.` does.
+ * The callee is an ordinary expression, so this node never carries a receiver
+ * — `a.b?.(...c)` is a `dot` with a `|?.()` continuation, not this. If `exp0`
+ * is nullish the arguments are not evaluated and the region short-circuits.
+ */
+export declare const optionCall: readonly ['?.()', Phantom<() => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0], Exp>, Phantom<() => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0], Exp>, Phantom<() => readonly ['or', null, readonly ['|()', typeof exp, typeof optionLambda], readonly ['|.', typeof index, typeof optionPropertyLambda]], OptionLambda>];
+export type _OptionCall = Assert<Check<OptionCall, typeof optionCall>>;
+/** @typedef {Assert<Check<OptionCall, typeof optionCall>>} _OptionCall */
+/**
+ * ```js
+ * (exp0, exp1, exp2)
+ * ```
+ *
+ * Establishes all of its operands and takes the value of the last one; the
+ * earlier operands exist for their throw-potential only. The shape is a
+ * known-incomplete placeholder — it cannot yet say "at least two operands,
+ * last is the result, each pre-result operand a true root (not reachable
+ * from another operand of the same `,`)". A single-operand `,` is the
+ * identity and a reachable operand a redundant anchor — both non-canonical,
+ * each splitting one function into two hashes. See the header of
+ * `./proof.f.mjs`.
+ */
+export declare const comma: readonly [',', import("../types/rtti/types.ts").Type1<"array", Phantom<() => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0], Exp>>];
+export type _Comma = Assert<Check<Comma, typeof comma>>;
+/**
+ * @typedef {Assert<Check<Comma, typeof comma>>} _Comma
+ */
+/**
+ * `op0`/`op1`/`op2` group operation nodes by their `exp`-operand count —
+ * zero, one, or two — not by any semantic category. `undefined`/`args`/
+ * `frame` all take zero `exp` operands after the tag, so all three are
+ * `op0`, regardless of what each individually means: the `undefined` value,
+ * the arguments array, and the captured-consts frame — the way `args` is
+ * for the arguments.
+ */
+export declare const op0Id: import("../types/rtti/types.ts").Or<readonly ["undefined", "args", "frame"]>;
+export type _Op0Id = Assert<Check<Op0Id, typeof op0Id>>;
+/** @typedef {Assert<Check<Op0Id, typeof op0Id>>} _Op0Id */
+export declare const op0: readonly [import("../types/rtti/types.ts").Or<readonly ["undefined", "args", "frame"]>];
+export type _Op0 = Assert<Check<Op0, typeof op0>>;
+/** @typedef {Assert<Check<Op0, typeof op0>>} _Op0 */
+/**
+ * `String`/`Number` are casts, `neg` is arithmetic negation (a word tag —
+ * `-` is binary subtraction), `!` is logical and `~` bitwise not.
+ */
+export declare const op1Id: import("../types/rtti/types.ts").Or<readonly ["String", "Number", "neg", "!", "~"]>;
+export type _Op1Id = Assert<Check<Op1Id, typeof op1Id>>;
+/** @typedef {Assert<Check<Op1Id, typeof op1Id>>} _Op1Id */
+export declare const op1: readonly [import("../types/rtti/types.ts").Or<readonly ["String", "Number", "neg", "!", "~"]>, Phantom<() => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0], Exp>];
+export type _Op1 = Assert<Check<Op1, typeof op1>>;
+/** @typedef {Assert<Check<Op1, typeof op1>>} _Op1 */
+/**
+ * `=>` builds a function from a frame and a body: the frame operand is one
+ * node evaluated in the enclosing scope, while the body is the inner
+ * function's graph — deferred, never established when the closure is built,
+ * only on each call, against that function's own `args`/`frame`. Calling one
+ * is not here: `()` is `['()', exp, exp]` and so *is* binary in operand
+ * count, but it is a chain node rather than an operation — the whole point of
+ * the chain vocabulary is that a call's receiver comes from the node holding
+ * it, which no `op2` id has anywhere to put. `own` is exactly
+ * `Object.getOwnPropertyDescriptor(object, key)?.value` — no
+ * getter invocation, no prototype chain — where the key operand must
+ * evaluate to a string: a runtime-value constraint the shape-only schema
+ * cannot express — a computed key's value is only known at execution, so
+ * upholding it falls to the executor (`ownJs` in `./proof.f.mjs`; the
+ * Operations table in `../../todo/edag-stage1-discussion.md`). The rest
+ * are the JS comparison,
+ * arithmetic, bitwise, and logical operators they name — with `&&`/`||`/`??`
+ * short-circuiting exactly as in JS: their right operand is conditional,
+ * never established eagerly. All this laziness is positional, not nodal —
+ * the same node referenced from an eager position elsewhere is still
+ * evaluated there.
+ */
+export declare const op2Id: import("../types/rtti/types.ts").Or<readonly ["=>", "own", "===", "!==", ">", ">=", "<", "<=", "+", "-", "*", "/", "%", "**", "&", "|", "^", "<<", ">>", ">>>", "&&", "||", "??"]>;
+export type _Op2Id = Assert<Check<Op2Id, typeof op2Id>>;
+/** @typedef {Assert<Check<Op2Id, typeof op2Id>>} _Op2Id */
+export declare const op2: readonly [import("../types/rtti/types.ts").Or<readonly ["=>", "own", "===", "!==", ">", ">=", "<", "<=", "+", "-", "*", "/", "%", "**", "&", "|", "^", "<<", ">>", ">>>", "&&", "||", "??"]>, Phantom<() => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0], Exp>, Phantom<() => readonly ['or', typeof primitive, typeof array, typeof object, typeof dot, typeof call, typeof optionDot, typeof optionCall, typeof comma, typeof op2, typeof op1, typeof op0], Exp>];
+export type _Op2 = Assert<Check<Op2, typeof op2>>;
+export {};
+/** @typedef {Assert<Check<Op2, typeof op2>>} _Op2 */