solve-engine 2.14.1 → 2.15.0

package/dist/chunk-5SDSIRPL.js

@@ -0,0 +1,2 @@
+import {a,d as d$1}from'./chunk-Q3PSTNSY.js';import {a as a$1}from'./chunk-TVE2DNPU.js';import {c}from'./chunk-IJMNVBIS.js';import {c as c$1}from'./chunk-YAZ4DUJJ.js';var A=class{constructor(){this.category="Symbolic";}parse(o,r,e){o.consume("LPAREN"),o.parseExpression(a.Lowest,e),o.consume("RPAREN"),e.emitOpcode(51),e.emitIndex(67),e.emitIndex(1);}};var O=class{constructor(){this.category="Symbolic";}parse(o,r,e){o.consume("LPAREN"),o.parseExpression(a.Lowest,e),o.consume("RPAREN"),e.emitOpcode(51),e.emitIndex(68),e.emitIndex(1);}};function L(t,o){let r=t.peek();if(!r||r.type!=="IDENT"&&r.type!=="UNIT")throw c$1.parsing("SYMBOLIC_REQUIRES_VARIABLE_NAME",`${o} needs the name of an unknown here, as in ${o}(x^2, x).`,{found:r?.type??"end of input"});return t.consume(),r.value}function x(t,o){t.emitOpcode(13),t.emitString(o);}function N(t,o,r){let e=new d$1(o.pluginIndexMap);t.parseExpression(a.Lowest,e),t.setBuilder(o);let n=e.build();if(n.hasAsync)throw c$1.parsing("SYMBOLIC_ARGUMENT_MUST_BE_SYNCHRONOUS",`${r}'s expression must be synchronous (no weather/stocks/currency calls).`);return n}function I(t,o,r){let e=t.emitAnonymousBody([r],o);t.emitOpcode(159),t.emitIndex(e);}var R=class{constructor(){this.category="Symbolic";}parse(o,r,e){o.consume("LPAREN");let n=N(o,e,"solve"),m=o.match("EQUALS")?N(o,e,"solve"):null;o.consume("COMMA");let l=o.peek();if(!l||l.type!=="IDENT"&&l.type!=="UNIT")throw c$1.parsing("SOLVE_REQUIRES_VARIABLE_NAME","solve's second argument must be the name of the unknown to solve for, as in solve(x^2-4=0, x).",{found:l?.type??"end of input"});o.consume(),I(e,n,l.value),m?I(e,m,l.value):(e.emitOpcode(10),e.emitNumber(0)),x(e,l.value),o.consume("RPAREN"),e.emitOpcode(51),e.emitIndex(69),e.emitIndex(3);}};var g=class{constructor(){this.category="Symbolic";}parse(o,r,e){o.consume("LPAREN");let n=N(o,e,"der");o.consume("COMMA");let m=L(o,"der");I(e,n,m),x(e,m),o.match("COMMA")?o.parseExpression(a.Lowest,e):(e.emitOpcode(10),e.emitNumber(1)),o.consume("RPAREN"),e.emitOpcode(51),e.emitIndex(70),e.emitIndex(3);}};var C=class{constructor(){this.category="Symbolic";}parse(o,r,e){o.consume("LPAREN");let n=N(o,e,"integral");o.consume("COMMA");let m=L(o,"integral");I(e,n,m),x(e,m),o.consume("RPAREN"),e.emitOpcode(51),e.emitIndex(71),e.emitIndex(2);}};var M=class{constructor(){this.category="Symbolic";}parse(o,r,e){o.consume("LPAREN");let n=N(o,e,"taylor");o.consume("COMMA");let m=L(o,"taylor");I(e,n,m),x(e,m),o.consume("EQUALS"),o.parseExpression(a.Lowest,e),o.consume("COMMA"),o.parseExpression(a.Lowest,e),o.consume("RPAREN"),e.emitOpcode(51),e.emitIndex(72),e.emitIndex(4);}};var S=class{constructor(){this.category="Symbolic";}parse(o,r,e){o.consume("LPAREN");let n=0;do o.parseExpression(a.Lowest,e),n++;while(o.match("COMMA"));o.consume("RPAREN"),e.emitOpcode(51),e.emitIndex(73),e.emitIndex(n);}};var k=class{constructor(){this.category="Symbolic";}parse(o,r,e){e.emitOpcode(10),e.emitNumber(Number(r.value)),e.emitOpcode(51),e.emitIndex(74),e.emitIndex(1);}};var w=class{constructor(){this.category="Symbolic";}parse(o,r,e){o.consume("LPAREN"),o.parseExpression(a.Lowest,e),o.consume("RPAREN"),e.emitOpcode(51),e.emitIndex(75),e.emitIndex(1);}};var v=class{constructor(){this.category="Symbolic";}parse(o,r,e){o.consume("LPAREN"),o.parseExpression(a.Lowest,e),o.consume("RPAREN"),e.emitOpcode(51),e.emitIndex(76),e.emitIndex(1);}};var U=class{constructor(){this.category="Symbolic";}parse(o,r,e){o.consume("LPAREN"),o.parseExpression(a.Lowest,e),o.consume("RPAREN"),e.emitOpcode(51),e.emitIndex(77),e.emitIndex(1);}};var F=class{constructor(){this.category="Symbolic";}parse(o,r,e){o.consume("LPAREN"),o.parseExpression(a.Lowest,e),o.consume("RPAREN"),e.emitOpcode(51),e.emitIndex(78),e.emitIndex(1);}};var h=class{constructor(){this.category="Symbolic";}parse(o,r,e){o.consume("LPAREN"),o.parseExpression(a.Lowest,e),o.consume("RPAREN"),e.emitOpcode(51),e.emitIndex(79),e.emitIndex(1);}};function V(t=75){return {name:"symbolic:imaginary-literal",priority:t,match(o,r){let e=o[r];if(!e||e.type!=="NUMBER")return null;let n=o[r+1];return !n||n.type!=="IDENT"||n.value!=="i"||n.offset!==e.offset+e.value.length||o[r+2]?.type==="LPAREN"?null:{consumed:2,replacement:[new a$1("IMAGINARY",c("IMAGINARY"),e.value,e.value,e.offset,0,e.line,e.col)],ruleName:"symbolic:imaginary-literal"}}}}var ie={expand:"EXPAND_FN",factor:"FACTOR_FN",solve:"SOLVE_FN",der:"DER_FN",derivative:"DER_FN",integral:"INTEGRAL_FN",taylor:"TAYLOR_FN",jacobian:"JACOBIAN_FN",conj:"CONJ_FN",re:"RE_FN",im:"IM_FN",cancel:"CANCEL_FN",apart:"APART_FN"};function $(t=80){return {name:"symbolic:call",priority:t,startTokenTypes:["IDENT"],match(o,r){let e=o[r];if(!e||e.type!=="IDENT")return null;let n=ie[e.value.toLowerCase()];return !n||o[r+1]?.type!=="LPAREN"?null:{consumed:1,replacement:[new a$1(n,c(n),e.value,e.value,e.offset,0,e.line,e.col)],ruleName:"symbolic:call"}}}}var j=[{word:"expand",tokenType:"EXPAND_FN",builtinIndex:67,example:"expand((x+1)*(x+2))",expected:"x^2+3x+2",docPage:"algebra.md"},{word:"factor",tokenType:"FACTOR_FN",builtinIndex:68,example:"factor(x^2-4)",expected:"(x-2)*(x+2)",docPage:"algebra.md"},{word:"solve",tokenType:"SOLVE_FN",builtinIndex:69,example:"solve(x^2-4=0, x)",expected:"= [-2, 2]",docPage:"algebra.md"},{word:"der",tokenType:"DER_FN",builtinIndex:70,example:"der(x^3, x)",expected:"3x^2",docPage:"calculus.md"},{word:"integral",tokenType:"INTEGRAL_FN",builtinIndex:71,example:"integral(x^2, x)",expected:"1/3x^3",docPage:"calculus.md"},{word:"taylor",tokenType:"TAYLOR_FN",builtinIndex:72,example:"taylor(exp(x), x=0, 3)",expected:"1/6x^3+0.5x^2+x+1",docPage:"calculus.md"},{word:"jacobian",tokenType:"JACOBIAN_FN",builtinIndex:73,example:"jacobian(x*y, x+y)",expected:"= [y, x; 1, 1]",docPage:"calculus.md"},{word:"conj",tokenType:"CONJ_FN",builtinIndex:75,example:"conj(2+3i)",expected:"2-3i",docPage:"complex.md"},{word:"re",tokenType:"RE_FN",builtinIndex:76,example:"re(2+3i)",expected:"= 2",docPage:"complex.md"},{word:"im",tokenType:"IM_FN",builtinIndex:77,example:"im(2+3i)",expected:"= 3",docPage:"complex.md"},{word:"cancel",tokenType:"CANCEL_FN",builtinIndex:78,example:"cancel((x^2-1)/(x-1))",expected:"x+1",docPage:"algebra.md"},{word:"apart",tokenType:"APART_FN",builtinIndex:79,example:"apart((3x+5)/(x^2-1))",expected:"4/(x-1)-1/(x+1)",docPage:"algebra.md"}],le={name:"solve-symbolic",normalizerRules:[$(),V()],prefixParselets:{EXPAND_FN:new A,FACTOR_FN:new O,SOLVE_FN:new R,DER_FN:new g,INTEGRAL_FN:new C,TAYLOR_FN:new M,JACOBIAN_FN:new S,IMAGINARY:new k,CONJ_FN:new w,RE_FN:new v,IM_FN:new U,CANCEL_FN:new F,APART_FN:new h},tokenCategories:{EXPAND_FN:"keyword",FACTOR_FN:"keyword",SOLVE_FN:"keyword",DER_FN:"keyword",INTEGRAL_FN:"keyword",TAYLOR_FN:"keyword",JACOBIAN_FN:"keyword",IMAGINARY:"number",CONJ_FN:"keyword",RE_FN:"keyword",IM_FN:"keyword",CANCEL_FN:"keyword",APART_FN:"keyword"}},ae=new Set(j.map(t=>t.tokenType));function se(t){return t.some(o=>ae.has(o.type))}var ce=/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:?\d{2})?)?$/;function H(t){let o=t.trim();if(o.length>=2&&o.startsWith('"')&&o.endsWith('"')&&(o=o.slice(1,-1)),!ce.test(o))return null;let r=new Date(o).getTime();return Number.isNaN(r)?null:r}function Eo(t){let o=new Date(t),r=E=>String(E).padStart(2,"0"),e=o.getFullYear(),n=r(o.getMonth()+1),m=r(o.getDate()),l=r(o.getHours()),s=r(o.getMinutes()),c=r(o.getSeconds()),p=-o.getTimezoneOffset(),y=p>=0?"+":"-",a=Math.abs(p),f=r(Math.floor(a/60)),u=r(a%60);return `${e}-${n}-${m}T${l}:${s}:${c}${y}${f}:${u}`}var pe=1e12;function Ao(t){return Math.abs(t)>=pe?t:t*1e3}var D="DATETIME_LITERAL",J=c(D),Y=/^\d+$/,ue=/^\d{1,2}\.\d{1,2}$/,de=/^\.(\d{2}|\d{4})$/,d=/^\d{1,2}$/;function fe(t){for(let o=0;o<t.length-1;o++){let r=t[o];if((r.sourceEnd??r.offset+r.text.length)!==t[o+1].offset)return  false}return  true}function b(t){if(t.length===4)return Number(t);if(t.length===2){let o=Number(t);return o<=68?2e3+o:1900+o}return null}function P(t,o,r,e,n){if(o<1||o>12||t<1||t>31)return null;let m=new Date(r,o-1,t);if(m.getFullYear()!==r||m.getMonth()!==o-1||m.getDate()!==t)return null;let l=e[0],s=e.map(p=>p.value).join(""),c=new a$1(D,J,String(m.getTime()),s,l.offset,0,l.line,l.col);return {consumed:e.length,replacement:[c],ruleName:n}}var Ne=/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:?\d{2})?/,Ie=new Set(["NUMBER","MINUS","PLUS","COLON","IDENT"]),xe=16;function ye(t,o,r){let e=t[o];if(e.sourceEnd!==void 0)return null;let n=e.text,m=e.offset+e.text.length,l=[e];for(let f=o+1;f<t.length&&l.length<xe;f++){let u=t[f];if(u.sourceEnd!==void 0||u.offset!==m||!Ie.has(u.type))break;n+=u.text,m=u.offset+u.text.length,l.push(u);}let s=Ne.exec(n);if(s===null)return null;let c=0,p=0;for(let f of l)if(p+=f.text.length,c++,p>=s[0].length)break;if(p!==s[0].length)return null;let y=H(s[0]);if(y===null)return null;let a=new a$1(D,J,String(y),s[0],e.offset,0,e.line,e.col,e.offset+s[0].length);return {consumed:c,replacement:[a],ruleName:r}}function Te(t,o,r,e){if(e==="YMD")return t.length!==4||!d.test(o)||!d.test(r)?null:{year:Number(t),month:Number(o),day:Number(r)};if(!d.test(t)||!d.test(o))return null;let n=b(r);return n===null?null:e==="DMY"?{day:Number(t),month:Number(o),year:n}:{day:Number(o),month:Number(t),year:n}}function Mo(t=()=>"auto"){return {name:"datetime:date-literal",priority:70,match(o,r){let e=o[r];if(e.type!=="NUMBER")return null;if(ue.test(e.value)){let a=o[r+1];if(a&&a.type==="NUMBER"&&de.test(a.value)){let[f,u]=e.value.split("."),E=b(a.value.slice(1));if(E!==null){let z=P(Number(f),Number(u),E,[e,a],"datetime:date-literal:dot");if(z)return z}}return null}if(e.value.length===4&&Y.test(e.value)){let a=ye(o,r,"datetime:date-literal:iso-timestamp");if(a)return a}if(!Y.test(e.value))return null;let n=o[r+1];if(!n||n.type!=="SLASH"&&n.type!=="MINUS")return null;let m=o[r+2],l=o[r+3],s=o[r+4];if(!m||m.type!=="NUMBER"||!Y.test(m.value)||!l||l.type!==n.type||!s||s.type!=="NUMBER"||!Y.test(s.value))return null;let c=[e,n,m,l,s];if(!fe(c))return null;let p=t();if(p!=="auto"){let a=Te(e.value,m.value,s.value,p);return a===null?null:P(a.day,a.month,a.year,c,`datetime:date-literal:${p.toLowerCase()}`)}if(n.type==="SLASH"){if(!d.test(e.value)||!d.test(m.value))return null;let a=b(s.value);return a===null?null:P(Number(e.value),Number(m.value),a,c,"datetime:date-literal:european")}if(e.value.length===4)return !d.test(m.value)||!d.test(s.value)?null:P(Number(s.value),Number(m.value),Number(e.value),c,"datetime:date-literal:iso");if(!d.test(e.value)||!d.test(m.value))return null;let y=b(s.value);return y===null?null:P(Number(m.value),Number(e.value),y,c,"datetime:date-literal:us")}}}export{le as a,se as b,H as c,Eo as d,Ao as e,D as f,P as g,Mo as h};//# sourceMappingURL=chunk-5SDSIRPL.js.map
+//# sourceMappingURL=chunk-5SDSIRPL.js.map

package/dist/chunk-5SDSIRPL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/packages/symbolic/parselets/ExpandParselet.ts","../src/packages/symbolic/parselets/FactorParselet.ts","../src/packages/symbolic/parselets/VariableArgument.ts","../src/packages/symbolic/parselets/SolveParselet.ts","../src/packages/symbolic/parselets/DerParselet.ts","../src/packages/symbolic/parselets/IntegralParselet.ts","../src/packages/symbolic/parselets/TaylorParselet.ts","../src/packages/symbolic/parselets/JacobianParselet.ts","../src/packages/symbolic/parselets/ImaginaryParselet.ts","../src/packages/symbolic/parselets/ConjParselet.ts","../src/packages/symbolic/parselets/ReParselet.ts","../src/packages/symbolic/parselets/ImParselet.ts","../src/packages/symbolic/parselets/CancelParselet.ts","../src/packages/symbolic/parselets/ApartParselet.ts","../src/packages/symbolic/normalizer/ImaginaryLiteralNormalizerRule.ts","../src/packages/symbolic/normalizer/SymbolicCallNormalizerRule.ts","../src/packages/symbolic/SymbolicPackage.ts","../src/packages/datetime/Iso8601.ts","../src/packages/datetime/normalizer/DateLiteralNormalizerRule.ts"],"names":["ExpandParselet","parser","_token","builder","BindingPower","FactorParselet","readVariableName","verb","token","ErrorFactory","emitVariableName","name","parseBoundExpression","inner","BytecodeBuilder","program","emitBoundExpression","index","SolveParselet","left","right","variable","DerParselet","expression","IntegralParselet","TaylorParselet","JacobianParselet","count","ImaginaryParselet","_parser","ConjParselet","ReParselet","ImParselet","CancelParselet","ApartParselet","imaginaryLiteralNormalizerRule","priority","tokens","pos","number","suffix","LexerToken","tokenTypeId","SYMBOLIC_WORD_TO_TOKEN_TYPE","symbolicCallNormalizerRule","tokenType","SYMBOLIC_FUNCTIONS","SYMBOLIC_PACKAGE","SYMBOLIC_TOKEN_TYPES","fn","containsSymbolicCall","ISO8601_PATTERN","parseIso8601","s","trimmed","ms","formatIso8601Local","epochMs","d","pad","n","year","month","day","hours","minutes","seconds","offsetMinutesTotal","sign","absOffset","offsetHours","offsetMinutes","MS_TIMESTAMP_THRESHOLD","unixTimestampToEpochMs","DATETIME_LITERAL_TYPE","DATETIME_LITERAL_TYPE_ID","PLAIN_INTEGER","DOT_DAY_MONTH","DOT_LEADING_YEAR","DAY_OR_MONTH","writtenAsOneRun","i","resolveYear","digits","yy","buildDateToken","sourceTokens","ruleName","date","first","text","t","fusedToken","ISO_TIMESTAMP","ISO_TOKEN_TYPES","ISO_MAX_TOKENS","fuseIsoTimestamp","runEnd","window","next","matched","consumed","covered","resolveOrderedGroups","g0","g1","g2","order","dateLiteralNormalizerRule","getInputOrder","t0","t1","dayText","monthText","match","timestamp","sep1","sep2","t2","resolved"],"mappings":"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","file":"chunk-5SDSIRPL.js","sourcesContent":["import { PrefixParselet } from \"@solve-js/parser/Parselet\";\nimport { Parser } from \"@solve-js/parser/Parser\";\nimport { Token } from \"@solve-js/lexer/Token\";\nimport { BytecodeBuilder } from \"@solve-js/parser/BytecodeBuilder\";\nimport { OpCode } from \"@solve-js/parser/OpCode\";\nimport { BindingPower } from \"@solve-js/parser/BindingPower\";\nimport { SYMBOLIC_BUILTIN_EXPAND } from \"@solve-js/packages/symbolic/SymbolicBuiltinIndex\";\n\n/**\n * `expand(expr)`, multiplying out every product and power.\n *\n * A dedicated parselet rather than a `builtinNameToIndex` entry reached through\n * the ordinary `FunctionCallParselet`, because that route needs the lexer to\n * emit `FUNC` for the word, which means a `keywordMap` entry, which would stop\n * `expand` working as an ordinary variable name. See\n * `normalizer/SymbolicCallNormalizerRule.ts`.\n *\n * The emitted bytecode is an ordinary `CALL_BUILTIN`, so no new opcode and no\n * new VM dispatch arm is involved.\n */\nexport class ExpandParselet implements PrefixParselet {\n\treadonly category = \"Symbolic\";\n\n\tparse(parser: Parser, _token: Token, builder: BytecodeBuilder): void {\n\t\tparser.consume(\"LPAREN\");\n\t\tparser.parseExpression(BindingPower.Lowest, builder);\n\t\tparser.consume(\"RPAREN\");\n\n\t\tbuilder.emitOpcode(OpCode.CALL_BUILTIN);\n\t\tbuilder.emitIndex(SYMBOLIC_BUILTIN_EXPAND);\n\t\tbuilder.emitIndex(1);\n\t}\n}\n","import { PrefixParselet } from \"@solve-js/parser/Parselet\";\nimport { Parser } from \"@solve-js/parser/Parser\";\nimport { Token } from \"@solve-js/lexer/Token\";\nimport { BytecodeBuilder } from \"@solve-js/parser/BytecodeBuilder\";\nimport { OpCode } from \"@solve-js/parser/OpCode\";\nimport { BindingPower } from \"@solve-js/parser/BindingPower\";\nimport { SYMBOLIC_BUILTIN_FACTOR } from \"@solve-js/packages/symbolic/SymbolicBuiltinIndex\";\n\n/**\n * `factor(expr)`, writing a polynomial as a product of irreducible factors over the rationals.\n *\n * A dedicated parselet rather than a `builtinNameToIndex` entry reached through\n * the ordinary `FunctionCallParselet`, because that route needs the lexer to\n * emit `FUNC` for the word, which means a `keywordMap` entry, which would stop\n * `expand` working as an ordinary variable name. See\n * `normalizer/SymbolicCallNormalizerRule.ts`.\n *\n * The emitted bytecode is an ordinary `CALL_BUILTIN`, so no new opcode and no\n * new VM dispatch arm is involved.\n */\nexport class FactorParselet implements PrefixParselet {\n\treadonly category = \"Symbolic\";\n\n\tparse(parser: Parser, _token: Token, builder: BytecodeBuilder): void {\n\t\tparser.consume(\"LPAREN\");\n\t\tparser.parseExpression(BindingPower.Lowest, builder);\n\t\tparser.consume(\"RPAREN\");\n\n\t\tbuilder.emitOpcode(OpCode.CALL_BUILTIN);\n\t\tbuilder.emitIndex(SYMBOLIC_BUILTIN_FACTOR);\n\t\tbuilder.emitIndex(1);\n\t}\n}\n","import { Parser } from \"@solve-js/parser/Parser\";\nimport { BytecodeBuilder, type BytecodeProgram } from \"@solve-js/parser/BytecodeBuilder\";\nimport { OpCode } from \"@solve-js/parser/OpCode\";\nimport { BindingPower } from \"@solve-js/parser/BindingPower\";\nimport { ErrorFactory } from \"@solve-js/errors/UnifiedErrorFramework\";\n\n/**\n * Reads a bare variable name argument and returns it, consuming the token.\n *\n * Shared by every algebra verb that takes \"which unknown\" as an argument.\n * Compiling the name as an ordinary variable read would require it to already\n * have a value, which is precisely what differentiating or solving with respect\n * to it says it does not.\n *\n * Requiring `IDENT` or `UNIT` here gives the same reserved-word protection\n * `VariableParselet` relies on: a keyword always lexes as its own token type,\n * so it can never reach this position and be taken for a variable name.\n *\n * @param parser - The parser, positioned at the name.\n * @param verb - The calling verb's name, for the error message.\n * @returns The name as written.\n * @throws {EngineError} `SYMBOLIC_REQUIRES_VARIABLE_NAME` when the next token is\n * not a bare name.\n */\nexport function readVariableName(parser: Parser, verb: string): string {\n\tconst token = parser.peek();\n\tif (!token || (token.type !== \"IDENT\" && token.type !== \"UNIT\")) {\n\t\tthrow ErrorFactory.parsing(\n\t\t\t\"SYMBOLIC_REQUIRES_VARIABLE_NAME\",\n\t\t\t`${verb} needs the name of an unknown here, as in ${verb}(x^2, x).`,\n\t\t\t{ found: token?.type ?? \"end of input\" },\n\t\t);\n\t}\n\tparser.consume();\n\treturn token.value;\n}\n\n/** Emits an already-read unknown's name as the String argument the algebra builtins read it as. */\nexport function emitVariableName(builder: BytecodeBuilder, name: string): void {\n\tbuilder.emitOpcode(OpCode.PUSH_STRING);\n\tbuilder.emitString(name);\n}\n\n/**\n * Parses an algebra verb's expression argument into its own independent\n * program, rather than emitting it inline.\n *\n * The verb names its unknown AFTER the expression (`der(x^2, x)`), so the\n * expression has to be held rather than emitted: only once the name is known\n * can it be paired with {@link emitBoundExpression}, which is what makes the\n * name shadow any document value it happens to share. Compiled into an\n * isolated builder exactly like a user-defined function body or a map/reduce\n * transform, and `parseExpression` leaves `parser.builder` pointing at the\n * isolated one with no automatic restore, so the caller's builder is put back\n * before returning.\n *\n * @param parser - The parser, positioned at the start of the expression.\n * @param builder - The builder to restore afterwards.\n * @param verb - The calling verb's name, for the error message.\n * @returns The compiled expression, to be handed to {@link emitBoundExpression}.\n */\nexport function parseBoundExpression(parser: Parser, builder: BytecodeBuilder, verb: string): BytecodeProgram {\n\tconst inner = new BytecodeBuilder(builder.pluginIndexMap);\n\tparser.parseExpression(BindingPower.Lowest, inner);\n\tparser.setBuilder(builder);\n\tconst program = inner.build();\n\tif (program.hasAsync) {\n\t\t// Same v1 restriction every other deferred body carries (user-defined\n\t\t// functions, map/reduce transforms): a reentrant execution cannot\n\t\t// suspend and resume the outer expression around an async result.\n\t\tthrow ErrorFactory.parsing(\n\t\t\t\"SYMBOLIC_ARGUMENT_MUST_BE_SYNCHRONOUS\",\n\t\t\t`${verb}'s expression must be synchronous (no weather/stocks/currency calls).`,\n\t\t);\n\t}\n\treturn program;\n}\n\n/**\n * Emits a held expression so that it evaluates with `name` bound to itself.\n *\n * This is what makes `der(x^2, x)` mean the derivative of a square rather than\n * the derivative of a constant on a page that also says `:x = 5`. Naming `x` as\n * the verb's argument declares it bound, so within the expression it is an\n * unknown and nothing else, exactly the way a function's parameter shadows a\n * document variable of the same name inside its body. Before this, the\n * expression was compiled inline and its `x` was an ordinary variable read, so\n * the verb received 25 and answered 0 with no indication that it had not been\n * asked the question the user wrote.\n *\n * @param builder - The builder to emit into.\n * @param program - The expression, from {@link parseBoundExpression}.\n * @param name - The unknown the verb named, bound for the expression's evaluation.\n */\nexport function emitBoundExpression(builder: BytecodeBuilder, program: BytecodeProgram, name: string): void {\n\tconst index = builder.emitAnonymousBody([name], program);\n\tbuilder.emitOpcode(OpCode.BIND_UNKNOWN);\n\tbuilder.emitIndex(index);\n}\n","import { PrefixParselet } from \"@solve-js/parser/Parselet\";\nimport { Parser } from \"@solve-js/parser/Parser\";\nimport { Token } from \"@solve-js/lexer/Token\";\nimport { BytecodeBuilder } from \"@solve-js/parser/BytecodeBuilder\";\nimport { OpCode } from \"@solve-js/parser/OpCode\";\nimport { ErrorFactory } from \"@solve-js/errors/UnifiedErrorFramework\";\nimport { SYMBOLIC_BUILTIN_SOLVE } from \"@solve-js/packages/symbolic/SymbolicBuiltinIndex\";\nimport { emitVariableName, parseBoundExpression, emitBoundExpression } from \"@solve-js/packages/symbolic/parselets/VariableArgument\";\n\n/**\n * `solve(equation, variable)`, for example `solve(x^2-4=0, x)`.\n *\n * Two things here cannot go through the ordinary function-call grammar, which\n * is why this is a hand-written parselet.\n *\n * The first argument contains a bare `=`, which no infix parselet consumes, so\n * an ordinary argument list would fail to parse it. This reads the two sides\n * separately and lets a missing right-hand side default to zero, so\n * `solve(x^2-4, x)` means the same as `solve(x^2-4=0, x)`.\n *\n * The second argument is a *name*, not a value. Compiling it as a `LOAD_VAR`\n * would demand that the variable already exist, which is exactly what solving\n * for it says it does not. Emitting it as a `PUSH_STRING` instead means the\n * builtin receives a plain String value and the VM needs no change at all.\n *\n * Both sides of the equation are held until that name has been read, so each\n * evaluates with the unknown bound to itself rather than to whatever value the\n * document may already have given it. See {@link emitBoundExpression}: with\n * `:x = 5` above it, `solve(x^2-4=0, x)` was solving `21 = 0` and reporting,\n * accurately for the question it was asked and uselessly for the one written,\n * that there is no solution.\n */\nexport class SolveParselet implements PrefixParselet {\n\treadonly category = \"Symbolic\";\n\n\tparse(parser: Parser, _token: Token, builder: BytecodeBuilder): void {\n\t\tparser.consume(\"LPAREN\");\n\t\tconst left = parseBoundExpression(parser, builder, \"solve\");\n\t\tconst right = parser.match(\"EQUALS\") ? parseBoundExpression(parser, builder, \"solve\") : null;\n\n\t\tparser.consume(\"COMMA\");\n\t\t// Requiring IDENT or UNIT here is the same protection VariableParselet\n\t\t// relies on: a reserved word always lexes as its own token type, so it\n\t\t// can never reach this position and be mistaken for a variable name.\n\t\tconst variable = parser.peek();\n\t\tif (!variable || (variable.type !== \"IDENT\" && variable.type !== \"UNIT\")) {\n\t\t\tthrow ErrorFactory.parsing(\n\t\t\t\t\"SOLVE_REQUIRES_VARIABLE_NAME\",\n\t\t\t\t`solve's second argument must be the name of the unknown to solve for, as in solve(x^2-4=0, x).`,\n\t\t\t\t{ found: variable?.type ?? \"end of input\" },\n\t\t\t);\n\t\t}\n\t\tparser.consume();\n\n\t\temitBoundExpression(builder, left, variable.value);\n\t\tif (right) {\n\t\t\temitBoundExpression(builder, right, variable.value);\n\t\t} else {\n\t\t\t// No `=` written, so the equation is \"this expression equals zero\".\n\t\t\tbuilder.emitOpcode(OpCode.PUSH_NUMBER);\n\t\t\tbuilder.emitNumber(0);\n\t\t}\n\t\temitVariableName(builder, variable.value);\n\n\t\tparser.consume(\"RPAREN\");\n\n\t\tbuilder.emitOpcode(OpCode.CALL_BUILTIN);\n\t\tbuilder.emitIndex(SYMBOLIC_BUILTIN_SOLVE);\n\t\tbuilder.emitIndex(3);\n\t}\n}\n","import { PrefixParselet } from \"@solve-js/parser/Parselet\";\nimport { Parser } from \"@solve-js/parser/Parser\";\nimport { Token } from \"@solve-js/lexer/Token\";\nimport { BytecodeBuilder } from \"@solve-js/parser/BytecodeBuilder\";\nimport { OpCode } from \"@solve-js/parser/OpCode\";\nimport { BindingPower } from \"@solve-js/parser/BindingPower\";\nimport { SYMBOLIC_BUILTIN_DER } from \"@solve-js/packages/symbolic/SymbolicBuiltinIndex\";\nimport { readVariableName, emitVariableName, parseBoundExpression, emitBoundExpression } from \"@solve-js/packages/symbolic/parselets/VariableArgument\";\n\n/**\n * `der(expr, variable)` and `der(expr, variable, order)`, the symbolic\n * derivative. `derivative` is accepted as the same thing.\n *\n * The variable is emitted as a string rather than compiled as a variable read,\n * for the reason given in {@link readVariableName}, and `expr` is held until\n * that name is known so it can be evaluated with the name bound. See\n * {@link emitBoundExpression}.\n */\nexport class DerParselet implements PrefixParselet {\n\treadonly category = \"Symbolic\";\n\n\tparse(parser: Parser, _token: Token, builder: BytecodeBuilder): void {\n\t\tparser.consume(\"LPAREN\");\n\t\tconst expression = parseBoundExpression(parser, builder, \"der\");\n\t\tparser.consume(\"COMMA\");\n\t\tconst variable = readVariableName(parser, \"der\");\n\t\temitBoundExpression(builder, expression, variable);\n\t\temitVariableName(builder, variable);\n\n\t\t// The order is optional and defaults to a first derivative.\n\t\tif (parser.match(\"COMMA\")) {\n\t\t\tparser.parseExpression(BindingPower.Lowest, builder);\n\t\t} else {\n\t\t\tbuilder.emitOpcode(OpCode.PUSH_NUMBER);\n\t\t\tbuilder.emitNumber(1);\n\t\t}\n\t\tparser.consume(\"RPAREN\");\n\n\t\tbuilder.emitOpcode(OpCode.CALL_BUILTIN);\n\t\tbuilder.emitIndex(SYMBOLIC_BUILTIN_DER);\n\t\tbuilder.emitIndex(3);\n\t}\n}\n","import { PrefixParselet } from \"@solve-js/parser/Parselet\";\nimport { Parser } from \"@solve-js/parser/Parser\";\nimport { Token } from \"@solve-js/lexer/Token\";\nimport { BytecodeBuilder } from \"@solve-js/parser/BytecodeBuilder\";\nimport { OpCode } from \"@solve-js/parser/OpCode\";\nimport { SYMBOLIC_BUILTIN_INTEGRAL } from \"@solve-js/packages/symbolic/SymbolicBuiltinIndex\";\nimport { readVariableName, emitVariableName, parseBoundExpression, emitBoundExpression } from \"@solve-js/packages/symbolic/parselets/VariableArgument\";\n\n/**\n * `integral(expr, variable)`, the indefinite integral, without a constant of\n * integration. `expr` is held until the variable is read so that the named\n * unknown shadows any document value of the same name, see\n * {@link emitBoundExpression}.\n */\nexport class IntegralParselet implements PrefixParselet {\n\treadonly category = \"Symbolic\";\n\n\tparse(parser: Parser, _token: Token, builder: BytecodeBuilder): void {\n\t\tparser.consume(\"LPAREN\");\n\t\tconst expression = parseBoundExpression(parser, builder, \"integral\");\n\t\tparser.consume(\"COMMA\");\n\t\tconst variable = readVariableName(parser, \"integral\");\n\t\temitBoundExpression(builder, expression, variable);\n\t\temitVariableName(builder, variable);\n\t\tparser.consume(\"RPAREN\");\n\n\t\tbuilder.emitOpcode(OpCode.CALL_BUILTIN);\n\t\tbuilder.emitIndex(SYMBOLIC_BUILTIN_INTEGRAL);\n\t\tbuilder.emitIndex(2);\n\t}\n}\n","import { PrefixParselet } from \"@solve-js/parser/Parselet\";\nimport { Parser } from \"@solve-js/parser/Parser\";\nimport { Token } from \"@solve-js/lexer/Token\";\nimport { BytecodeBuilder } from \"@solve-js/parser/BytecodeBuilder\";\nimport { OpCode } from \"@solve-js/parser/OpCode\";\nimport { BindingPower } from \"@solve-js/parser/BindingPower\";\nimport { SYMBOLIC_BUILTIN_TAYLOR } from \"@solve-js/packages/symbolic/SymbolicBuiltinIndex\";\nimport { readVariableName, emitVariableName, parseBoundExpression, emitBoundExpression } from \"@solve-js/packages/symbolic/parselets/VariableArgument\";\n\n/**\n * `taylor(expr, variable = point, degree)`, matching Calca's own spelling.\n *\n * The `variable = point` argument is why this needs a hand-written parselet:\n * `EQUALS` has no infix parselet, so an ordinary argument list cannot parse it.\n * Reading the name and the point separately also means the name never has to\n * exist as a variable, and `expr` is held until the name is known so that the\n * name shadows any document value it shares (see {@link emitBoundExpression}).\n * The expansion point is an ordinary value expression and is not shadowed: it\n * is a number, not the unknown.\n */\nexport class TaylorParselet implements PrefixParselet {\n\treadonly category = \"Symbolic\";\n\n\tparse(parser: Parser, _token: Token, builder: BytecodeBuilder): void {\n\t\tparser.consume(\"LPAREN\");\n\t\tconst expression = parseBoundExpression(parser, builder, \"taylor\");\n\t\tparser.consume(\"COMMA\");\n\t\tconst variable = readVariableName(parser, \"taylor\");\n\t\temitBoundExpression(builder, expression, variable);\n\t\temitVariableName(builder, variable);\n\t\tparser.consume(\"EQUALS\");\n\t\tparser.parseExpression(BindingPower.Lowest, builder);\n\t\tparser.consume(\"COMMA\");\n\t\tparser.parseExpression(BindingPower.Lowest, builder);\n\t\tparser.consume(\"RPAREN\");\n\n\t\tbuilder.emitOpcode(OpCode.CALL_BUILTIN);\n\t\tbuilder.emitIndex(SYMBOLIC_BUILTIN_TAYLOR);\n\t\tbuilder.emitIndex(4);\n\t}\n}\n","import { PrefixParselet } from \"@solve-js/parser/Parselet\";\nimport { Parser } from \"@solve-js/parser/Parser\";\nimport { Token } from \"@solve-js/lexer/Token\";\nimport { BytecodeBuilder } from \"@solve-js/parser/BytecodeBuilder\";\nimport { OpCode } from \"@solve-js/parser/OpCode\";\nimport { BindingPower } from \"@solve-js/parser/BindingPower\";\nimport { SYMBOLIC_BUILTIN_JACOBIAN } from \"@solve-js/packages/symbolic/SymbolicBuiltinIndex\";\n\n/**\n * `jacobian(f1, f2, ...)`, the matrix of partial derivatives.\n *\n * Variadic, and the variables are not named: they are taken from the union of\n * the functions' own unknowns, sorted, which is what Calca does. Row `i` is the\n * gradient of the `i`-th function.\n */\nexport class JacobianParselet implements PrefixParselet {\n\treadonly category = \"Symbolic\";\n\n\tparse(parser: Parser, _token: Token, builder: BytecodeBuilder): void {\n\t\tparser.consume(\"LPAREN\");\n\t\tlet count = 0;\n\t\tdo {\n\t\t\tparser.parseExpression(BindingPower.Lowest, builder);\n\t\t\tcount++;\n\t\t} while (parser.match(\"COMMA\"));\n\t\tparser.consume(\"RPAREN\");\n\n\t\tbuilder.emitOpcode(OpCode.CALL_BUILTIN);\n\t\tbuilder.emitIndex(SYMBOLIC_BUILTIN_JACOBIAN);\n\t\tbuilder.emitIndex(count);\n\t}\n}\n","import { PrefixParselet } from \"@solve-js/parser/Parselet\";\nimport { Parser } from \"@solve-js/parser/Parser\";\nimport { Token } from \"@solve-js/lexer/Token\";\nimport { BytecodeBuilder } from \"@solve-js/parser/BytecodeBuilder\";\nimport { OpCode } from \"@solve-js/parser/OpCode\";\nimport { SYMBOLIC_BUILTIN_IMAGINARY } from \"@solve-js/packages/symbolic/SymbolicBuiltinIndex\";\n\n/**\n * An imaginary literal, `3i`, fused by\n * `normalizer/ImaginaryLiteralNormalizerRule.ts`.\n *\n * The token carries the numeric part as its value; this pushes that number and\n * lets the builtin turn it into an exact imaginary value. Going through a\n * builtin rather than a dedicated opcode keeps the VM dispatch table untouched,\n * the same choice every other algebra verb made.\n */\nexport class ImaginaryParselet implements PrefixParselet {\n\treadonly category = \"Symbolic\";\n\n\tparse(_parser: Parser, token: Token, builder: BytecodeBuilder): void {\n\t\tbuilder.emitOpcode(OpCode.PUSH_NUMBER);\n\t\tbuilder.emitNumber(Number(token.value));\n\t\tbuilder.emitOpcode(OpCode.CALL_BUILTIN);\n\t\tbuilder.emitIndex(SYMBOLIC_BUILTIN_IMAGINARY);\n\t\tbuilder.emitIndex(1);\n\t}\n}\n","import { PrefixParselet } from \"@solve-js/parser/Parselet\";\nimport { Parser } from \"@solve-js/parser/Parser\";\nimport { Token } from \"@solve-js/lexer/Token\";\nimport { BytecodeBuilder } from \"@solve-js/parser/BytecodeBuilder\";\nimport { OpCode } from \"@solve-js/parser/OpCode\";\nimport { BindingPower } from \"@solve-js/parser/BindingPower\";\nimport { SYMBOLIC_BUILTIN_CONJ } from \"@solve-js/packages/symbolic/SymbolicBuiltinIndex\";\n\n/**\n * `conj(z)`, the complex conjugate.\n *\n * A dedicated parselet rather than a keywordMap entry, for the reason given in\n * `normalizer/SymbolicCallNormalizerRule.ts`: `re` and `im` are short words a\n * person may well use as variable names.\n */\nexport class ConjParselet implements PrefixParselet {\n\treadonly category = \"Symbolic\";\n\n\tparse(parser: Parser, _token: Token, builder: BytecodeBuilder): void {\n\t\tparser.consume(\"LPAREN\");\n\t\tparser.parseExpression(BindingPower.Lowest, builder);\n\t\tparser.consume(\"RPAREN\");\n\n\t\tbuilder.emitOpcode(OpCode.CALL_BUILTIN);\n\t\tbuilder.emitIndex(SYMBOLIC_BUILTIN_CONJ);\n\t\tbuilder.emitIndex(1);\n\t}\n}\n","import { PrefixParselet } from \"@solve-js/parser/Parselet\";\nimport { Parser } from \"@solve-js/parser/Parser\";\nimport { Token } from \"@solve-js/lexer/Token\";\nimport { BytecodeBuilder } from \"@solve-js/parser/BytecodeBuilder\";\nimport { OpCode } from \"@solve-js/parser/OpCode\";\nimport { BindingPower } from \"@solve-js/parser/BindingPower\";\nimport { SYMBOLIC_BUILTIN_RE } from \"@solve-js/packages/symbolic/SymbolicBuiltinIndex\";\n\n/**\n * `re(z)`, the real part of a complex value.\n *\n * A dedicated parselet rather than a keywordMap entry, for the reason given in\n * `normalizer/SymbolicCallNormalizerRule.ts`: `re` and `im` are short words a\n * person may well use as variable names.\n */\nexport class ReParselet implements PrefixParselet {\n\treadonly category = \"Symbolic\";\n\n\tparse(parser: Parser, _token: Token, builder: BytecodeBuilder): void {\n\t\tparser.consume(\"LPAREN\");\n\t\tparser.parseExpression(BindingPower.Lowest, builder);\n\t\tparser.consume(\"RPAREN\");\n\n\t\tbuilder.emitOpcode(OpCode.CALL_BUILTIN);\n\t\tbuilder.emitIndex(SYMBOLIC_BUILTIN_RE);\n\t\tbuilder.emitIndex(1);\n\t}\n}\n","import { PrefixParselet } from \"@solve-js/parser/Parselet\";\nimport { Parser } from \"@solve-js/parser/Parser\";\nimport { Token } from \"@solve-js/lexer/Token\";\nimport { BytecodeBuilder } from \"@solve-js/parser/BytecodeBuilder\";\nimport { OpCode } from \"@solve-js/parser/OpCode\";\nimport { BindingPower } from \"@solve-js/parser/BindingPower\";\nimport { SYMBOLIC_BUILTIN_IM } from \"@solve-js/packages/symbolic/SymbolicBuiltinIndex\";\n\n/**\n * `im(z)`, the imaginary part of a complex value.\n *\n * A dedicated parselet rather than a keywordMap entry, for the reason given in\n * `normalizer/SymbolicCallNormalizerRule.ts`: `re` and `im` are short words a\n * person may well use as variable names.\n */\nexport class ImParselet implements PrefixParselet {\n\treadonly category = \"Symbolic\";\n\n\tparse(parser: Parser, _token: Token, builder: BytecodeBuilder): void {\n\t\tparser.consume(\"LPAREN\");\n\t\tparser.parseExpression(BindingPower.Lowest, builder);\n\t\tparser.consume(\"RPAREN\");\n\n\t\tbuilder.emitOpcode(OpCode.CALL_BUILTIN);\n\t\tbuilder.emitIndex(SYMBOLIC_BUILTIN_IM);\n\t\tbuilder.emitIndex(1);\n\t}\n}\n","import { PrefixParselet } from \"@solve-js/parser/Parselet\";\nimport { Parser } from \"@solve-js/parser/Parser\";\nimport { Token } from \"@solve-js/lexer/Token\";\nimport { BytecodeBuilder } from \"@solve-js/parser/BytecodeBuilder\";\nimport { OpCode } from \"@solve-js/parser/OpCode\";\nimport { BindingPower } from \"@solve-js/parser/BindingPower\";\nimport { SYMBOLIC_BUILTIN_CANCEL } from \"@solve-js/packages/symbolic/SymbolicBuiltinIndex\";\n\n/**\n * `cancel(expr)`, reducing a quotient of polynomials to lowest terms.\n *\n * The simplifier already cancels a common factor automatically; this is the\n * explicit form, for when the intent is to reduce a fraction rather than to\n * evaluate something that happens to contain one.\n */\nexport class CancelParselet implements PrefixParselet {\n\treadonly category = \"Symbolic\";\n\n\tparse(parser: Parser, _token: Token, builder: BytecodeBuilder): void {\n\t\tparser.consume(\"LPAREN\");\n\t\tparser.parseExpression(BindingPower.Lowest, builder);\n\t\tparser.consume(\"RPAREN\");\n\n\t\tbuilder.emitOpcode(OpCode.CALL_BUILTIN);\n\t\tbuilder.emitIndex(SYMBOLIC_BUILTIN_CANCEL);\n\t\tbuilder.emitIndex(1);\n\t}\n}\n","import { PrefixParselet } from \"@solve-js/parser/Parselet\";\nimport { Parser } from \"@solve-js/parser/Parser\";\nimport { Token } from \"@solve-js/lexer/Token\";\nimport { BytecodeBuilder } from \"@solve-js/parser/BytecodeBuilder\";\nimport { OpCode } from \"@solve-js/parser/OpCode\";\nimport { BindingPower } from \"@solve-js/parser/BindingPower\";\nimport { SYMBOLIC_BUILTIN_APART } from \"@solve-js/packages/symbolic/SymbolicBuiltinIndex\";\n\n/**\n * `apart(expr)`, splitting a rational function into partial fractions.\n *\n * The inverse of putting a sum of fractions over a common denominator, and the\n * step that makes a rational function integrable.\n */\nexport class ApartParselet implements PrefixParselet {\n\treadonly category = \"Symbolic\";\n\n\tparse(parser: Parser, _token: Token, builder: BytecodeBuilder): void {\n\t\tparser.consume(\"LPAREN\");\n\t\tparser.parseExpression(BindingPower.Lowest, builder);\n\t\tparser.consume(\"RPAREN\");\n\n\t\tbuilder.emitOpcode(OpCode.CALL_BUILTIN);\n\t\tbuilder.emitIndex(SYMBOLIC_BUILTIN_APART);\n\t\tbuilder.emitIndex(1);\n\t}\n}\n","import type { Token } from \"@solve-js/lexer/Token\";\nimport { tokenTypeId } from \"@solve-js/lexer/Token\";\nimport { LexerToken } from \"@solve-js/lexer/ExpressionLexer\";\nimport type { NormalizerRule, NormalizerMatch } from \"@solve-js/normalizer/NormalizerRule\";\n\n/**\n * Fuses `3i` into a single imaginary literal, but only when the `i` is written\n * flush against the number.\n *\n * `i` is not claimed as a keyword, and deliberately so. It is one of the most\n * common variable names there is, and this engine's whole trigger-word policy\n * exists to avoid taking words a person would reasonably assign to. `:i = 5`\n * has to keep working, and after this rule it does: the rule only fires on a\n * number immediately followed by the letter, which is the same shape the\n * magnitude suffixes use, and `2.5k` set that precedent.\n *\n * Adjacency is checked by source offset rather than by token order, so `3i` is\n * an imaginary literal while `3 i` and `3 * i` are a number multiplied by a\n * variable named `i`. That is the distinction that keeps both readings\n * available, and it is the reason a bare `i` on its own is still a variable.\n * Write `1i` for the imaginary unit alone.\n */\nexport function imaginaryLiteralNormalizerRule(priority = 75): NormalizerRule {\n\treturn {\n\t\tname: \"symbolic:imaginary-literal\",\n\t\tpriority,\n\t\tmatch(tokens: Token[], pos: number): NormalizerMatch | null {\n\t\t\tconst number = tokens[pos];\n\t\t\tif (!number || number.type !== \"NUMBER\") return null;\n\n\t\t\tconst suffix = tokens[pos + 1];\n\t\t\tif (!suffix || suffix.type !== \"IDENT\" || suffix.value !== \"i\") return null;\n\n\t\t\t// Flush against the number, with no space between them.\n\t\t\tif (suffix.offset !== number.offset + number.value.length) return null;\n\n\t\t\t// A following `(` would make this a call, as in `3i(x)`, which is not a\n\t\t\t// shape this claims.\n\t\t\tif (tokens[pos + 2]?.type === \"LPAREN\") return null;\n\n\t\t\treturn {\n\t\t\t\tconsumed: 2,\n\t\t\t\treplacement: [\n\t\t\t\t\tnew LexerToken(\n\t\t\t\t\t\t\"IMAGINARY\",\n\t\t\t\t\t\ttokenTypeId(\"IMAGINARY\"),\n\t\t\t\t\t\tnumber.value,\n\t\t\t\t\t\tnumber.value,\n\t\t\t\t\t\tnumber.offset,\n\t\t\t\t\t\t0,\n\t\t\t\t\t\tnumber.line,\n\t\t\t\t\t\tnumber.col,\n\t\t\t\t\t),\n\t\t\t\t],\n\t\t\t\truleName: \"symbolic:imaginary-literal\",\n\t\t\t};\n\t\t},\n\t};\n}\n","import type { Token } from \"@solve-js/lexer/Token\";\nimport { tokenTypeId } from \"@solve-js/lexer/Token\";\nimport { LexerToken } from \"@solve-js/lexer/ExpressionLexer\";\nimport type { NormalizerRule, NormalizerMatch } from \"@solve-js/normalizer/NormalizerRule\";\n\n/**\n * The algebra verbs, mapped to the token type each becomes when it is being\n * called.\n *\n * Kept in one place so {@link SYMBOLIC_FUNCTIONS} in `SymbolicPackage.ts` and\n * this rule cannot disagree about which words the package claims.\n */\nexport const SYMBOLIC_WORD_TO_TOKEN_TYPE: Readonly<Record<string, string>> = {\n\texpand: \"EXPAND_FN\",\n\tfactor: \"FACTOR_FN\",\n\tsolve: \"SOLVE_FN\",\n\tder: \"DER_FN\",\n\tderivative: \"DER_FN\",\n\tintegral: \"INTEGRAL_FN\",\n\ttaylor: \"TAYLOR_FN\",\n\tjacobian: \"JACOBIAN_FN\",\n\tconj: \"CONJ_FN\",\n\tre: \"RE_FN\",\n\tim: \"IM_FN\",\n\tcancel: \"CANCEL_FN\",\n\tapart: \"APART_FN\",\n};\n\n/**\n * Fuses an algebra verb into its own token type, but only when the bare word is\n * immediately followed by `(`.\n *\n * None of these words may be a plain `keywordMap` entry, and the reason is\n * concrete rather than stylistic. A `keywordMap` entry makes the lexer emit a\n * reserved token type everywhere the word appears, which would break\n * `:factor = 1.5` and `:solve = 2` as ordinary variable names. `solve` is also\n * the product's own name and `factor` is an everyday English noun, so both are\n * words a user will reasonably assign to.\n *\n * Mirrors `packages/mapreduce/normalizer/MapReduceCallNormalizerRule.ts`, which\n * exists for exactly this reason for `map`/`reduce`/`sum`/`prod`.\n *\n * @param priority - Rule ordering within the normalizer, defaulting to the same\n * band the map/reduce call rule uses.\n * @returns The normalizer rule.\n */\nexport function symbolicCallNormalizerRule(priority = 80): NormalizerRule {\n\treturn {\n\t\tname: \"symbolic:call\",\n\t\tpriority,\n\t\tstartTokenTypes: [\"IDENT\"],\n\t\tmatch(tokens: Token[], pos: number): NormalizerMatch | null {\n\t\t\tconst token = tokens[pos];\n\t\t\tif (!token || token.type !== \"IDENT\") return null;\n\t\t\tconst tokenType = SYMBOLIC_WORD_TO_TOKEN_TYPE[token.value.toLowerCase()];\n\t\t\tif (!tokenType) return null;\n\t\t\tif (tokens[pos + 1]?.type !== \"LPAREN\") return null;\n\n\t\t\treturn {\n\t\t\t\tconsumed: 1,\n\t\t\t\treplacement: [\n\t\t\t\t\tnew LexerToken(tokenType, tokenTypeId(tokenType), token.value, token.value, token.offset, 0, token.line, token.col),\n\t\t\t\t],\n\t\t\t\truleName: \"symbolic:call\",\n\t\t\t};\n\t\t},\n\t};\n}\n","import type { IEnginePackage } from \"@solve-js/api/PackageRegistry\";\nimport { ExpandParselet } from \"./parselets/ExpandParselet\";\nimport { FactorParselet } from \"./parselets/FactorParselet\";\nimport { SolveParselet } from \"./parselets/SolveParselet\";\nimport { DerParselet } from \"./parselets/DerParselet\";\nimport { IntegralParselet } from \"./parselets/IntegralParselet\";\nimport { TaylorParselet } from \"./parselets/TaylorParselet\";\nimport { JacobianParselet } from \"./parselets/JacobianParselet\";\nimport { ImaginaryParselet } from \"./parselets/ImaginaryParselet\";\nimport { ConjParselet } from \"./parselets/ConjParselet\";\nimport { ReParselet } from \"./parselets/ReParselet\";\nimport { ImParselet } from \"./parselets/ImParselet\";\nimport { CancelParselet } from \"./parselets/CancelParselet\";\nimport { ApartParselet } from \"./parselets/ApartParselet\";\nimport { imaginaryLiteralNormalizerRule } from \"./normalizer/ImaginaryLiteralNormalizerRule\";\nimport { symbolicCallNormalizerRule } from \"./normalizer/SymbolicCallNormalizerRule\";\nimport {\n\tSYMBOLIC_BUILTIN_EXPAND,\n\tSYMBOLIC_BUILTIN_FACTOR,\n\tSYMBOLIC_BUILTIN_SOLVE,\n\tSYMBOLIC_BUILTIN_DER,\n\tSYMBOLIC_BUILTIN_INTEGRAL,\n\tSYMBOLIC_BUILTIN_TAYLOR,\n\tSYMBOLIC_BUILTIN_JACOBIAN,\n\tSYMBOLIC_BUILTIN_CONJ,\n\tSYMBOLIC_BUILTIN_RE,\n\tSYMBOLIC_BUILTIN_IM,\n\tSYMBOLIC_BUILTIN_CANCEL,\n\tSYMBOLIC_BUILTIN_APART,\n} from \"./SymbolicBuiltinIndex\";\n\n/**\n * One algebra verb's whole surface, in a single row.\n *\n * Everything a verb needs in order to work is listed here rather than being\n * spread across the normalizer, the parselet registry, the builtin table and\n * the docs, so `__tests__/engine/SymbolicSurfaceParity.spec.ts` can check the\n * pieces actually agree. Shipping a verb whose index has no implementation, or\n * whose parselet is registered under a token type the normalizer never mints,\n * then becomes a failing test rather than a silent dead feature.\n */\nexport interface SymbolicFunctionSurface {\n\t/** The bare word a user types. */\n\treadonly word: string;\n\t/** The token type the normalizer fuses it into when it is followed by `(`. */\n\treadonly tokenType: string;\n\t/** The `CALL_BUILTIN` index its parselet emits. */\n\treadonly builtinIndex: number;\n\t/** A working example, executed by the parity spec through every public entry point. */\n\treadonly example: string;\n\t/** That example's expected formatted result. */\n\treadonly expected: string;\n\t/** The documentation page under `docs/src/content/docs/syntax/` that must show it. */\n\treadonly docPage: string;\n}\n\n/** Every algebra verb this package registers. */\nexport const SYMBOLIC_FUNCTIONS: readonly SymbolicFunctionSurface[] = [\n\t{\n\t\tword: \"expand\",\n\t\ttokenType: \"EXPAND_FN\",\n\t\tbuiltinIndex: SYMBOLIC_BUILTIN_EXPAND,\n\t\texample: \"expand((x+1)*(x+2))\",\n\t\texpected: \"x^2+3x+2\",\n\t\tdocPage: \"algebra.md\",\n\t},\n\t{\n\t\tword: \"factor\",\n\t\ttokenType: \"FACTOR_FN\",\n\t\tbuiltinIndex: SYMBOLIC_BUILTIN_FACTOR,\n\t\texample: \"factor(x^2-4)\",\n\t\texpected: \"(x-2)*(x+2)\",\n\t\tdocPage: \"algebra.md\",\n\t},\n\t{\n\t\tword: \"solve\",\n\t\ttokenType: \"SOLVE_FN\",\n\t\tbuiltinIndex: SYMBOLIC_BUILTIN_SOLVE,\n\t\texample: \"solve(x^2-4=0, x)\",\n\t\texpected: \"= [-2, 2]\",\n\t\tdocPage: \"algebra.md\",\n\t},\n\t{\n\t\tword: \"der\",\n\t\ttokenType: \"DER_FN\",\n\t\tbuiltinIndex: SYMBOLIC_BUILTIN_DER,\n\t\texample: \"der(x^3, x)\",\n\t\texpected: \"3x^2\",\n\t\tdocPage: \"calculus.md\",\n\t},\n\t{\n\t\tword: \"integral\",\n\t\ttokenType: \"INTEGRAL_FN\",\n\t\tbuiltinIndex: SYMBOLIC_BUILTIN_INTEGRAL,\n\t\texample: \"integral(x^2, x)\",\n\t\texpected: \"1/3x^3\",\n\t\tdocPage: \"calculus.md\",\n\t},\n\t{\n\t\tword: \"taylor\",\n\t\ttokenType: \"TAYLOR_FN\",\n\t\tbuiltinIndex: SYMBOLIC_BUILTIN_TAYLOR,\n\t\texample: \"taylor(exp(x), x=0, 3)\",\n\t\texpected: \"1/6x^3+0.5x^2+x+1\",\n\t\tdocPage: \"calculus.md\",\n\t},\n\t{\n\t\tword: \"jacobian\",\n\t\ttokenType: \"JACOBIAN_FN\",\n\t\tbuiltinIndex: SYMBOLIC_BUILTIN_JACOBIAN,\n\t\texample: \"jacobian(x*y, x+y)\",\n\t\texpected: \"= [y, x; 1, 1]\",\n\t\tdocPage: \"calculus.md\",\n\t},\n\t{\n\t\tword: \"conj\",\n\t\ttokenType: \"CONJ_FN\",\n\t\tbuiltinIndex: SYMBOLIC_BUILTIN_CONJ,\n\t\texample: \"conj(2+3i)\",\n\t\texpected: \"2-3i\",\n\t\tdocPage: \"complex.md\",\n\t},\n\t{\n\t\tword: \"re\",\n\t\ttokenType: \"RE_FN\",\n\t\tbuiltinIndex: SYMBOLIC_BUILTIN_RE,\n\t\texample: \"re(2+3i)\",\n\t\texpected: \"= 2\",\n\t\tdocPage: \"complex.md\",\n\t},\n\t{\n\t\tword: \"im\",\n\t\ttokenType: \"IM_FN\",\n\t\tbuiltinIndex: SYMBOLIC_BUILTIN_IM,\n\t\texample: \"im(2+3i)\",\n\t\texpected: \"= 3\",\n\t\tdocPage: \"complex.md\",\n\t},\n\t{\n\t\tword: \"cancel\",\n\t\ttokenType: \"CANCEL_FN\",\n\t\tbuiltinIndex: SYMBOLIC_BUILTIN_CANCEL,\n\t\texample: \"cancel((x^2-1)/(x-1))\",\n\t\texpected: \"x+1\",\n\t\tdocPage: \"algebra.md\",\n\t},\n\t{\n\t\tword: \"apart\",\n\t\ttokenType: \"APART_FN\",\n\t\tbuiltinIndex: SYMBOLIC_BUILTIN_APART,\n\t\texample: \"apart((3x+5)/(x^2-1))\",\n\t\texpected: \"4/(x-1)-1/(x+1)\",\n\t\tdocPage: \"algebra.md\",\n\t},\n];\n\n/**\n * Symbolic algebra verbs: multiplying out, and (in later phases) factoring,\n * solving and calculus.\n *\n * The algebra itself lives in `symbolic/`, which is pure mathematics over the\n * expression tree. This package is only the grammar surface: which words become\n * which tokens, and which parselet emits which builtin call.\n *\n * None of these words is a bare `keywordMap` entry. See\n * `normalizer/SymbolicCallNormalizerRule.ts` for why that matters.\n */\nexport const SYMBOLIC_PACKAGE: IEnginePackage = {\n\tname: \"solve-symbolic\",\n\tnormalizerRules: [symbolicCallNormalizerRule(), imaginaryLiteralNormalizerRule()],\n\tprefixParselets: {\n\t\tEXPAND_FN: new ExpandParselet(),\n\t\tFACTOR_FN: new FactorParselet(),\n\t\tSOLVE_FN: new SolveParselet(),\n\t\tDER_FN: new DerParselet(),\n\t\tINTEGRAL_FN: new IntegralParselet(),\n\t\tTAYLOR_FN: new TaylorParselet(),\n\t\tJACOBIAN_FN: new JacobianParselet(),\n\t\tIMAGINARY: new ImaginaryParselet(),\n\t\tCONJ_FN: new ConjParselet(),\n\t\tRE_FN: new ReParselet(),\n\t\tIM_FN: new ImParselet(),\n\t\tCANCEL_FN: new CancelParselet(),\n\t\tAPART_FN: new ApartParselet(),\n\t},\n\ttokenCategories: {\n\t\tEXPAND_FN: \"keyword\",\n\t\tFACTOR_FN: \"keyword\",\n\t\tSOLVE_FN: \"keyword\",\n\t\tDER_FN: \"keyword\",\n\t\tINTEGRAL_FN: \"keyword\",\n\t\tTAYLOR_FN: \"keyword\",\n\t\tJACOBIAN_FN: \"keyword\",\n\t\tIMAGINARY: \"number\",\n\t\tCONJ_FN: \"keyword\",\n\t\tRE_FN: \"keyword\",\n\t\tIM_FN: \"keyword\",\n\t\tCANCEL_FN: \"keyword\",\n\t\tAPART_FN: \"keyword\",\n\t},\n};\n\n/** The token types the algebra verbs fuse into, for the engine's own \"is this line symbolic\" check. */\nconst SYMBOLIC_TOKEN_TYPES: ReadonlySet<string> = new Set(SYMBOLIC_FUNCTIONS.map(fn => fn.tokenType));\n\n/**\n * Whether a normalized token list calls an algebra verb.\n *\n * `engine/ExpressionEngine.ts` uses this to evaluate such a line in\n * symbolic-tolerant mode without requiring a trailing `=>`, since asking to\n * expand or factor something is already a statement that its unknowns are meant\n * to stay unknown.\n *\n * @param tokens - The normalized tokens for one line.\n * @returns True when any token is an algebra verb.\n */\nexport function containsSymbolicCall(tokens: readonly { type: string }[]): boolean {\n\treturn tokens.some(token => SYMBOLIC_TOKEN_TYPES.has(token.type));\n}\n","/**\n * ISO8601 string <-> epoch-ms helpers backing the datetime package's\n * `<ISO8601 string> to date` and `<date/time> as iso8601` features.\n *\n * SCOPE, revised in 1.0.0: {@link parseIso8601} is now reached by BOTH input\n * shapes. A quoted string literal (`\"2019-04-01T15:30:00+11:00\" to date`)\n * always came here; the bare, unquoted form now does too, fused into one\n * DATETIME_LITERAL by `normalizer/DateLiteralNormalizerRule.ts` before the\n * parser sees it.\n *\n * This file used to record that the bare form was out of scope because it is\n * ambiguous with arithmetic (`2019 - 04 - 01` reads as two subtractions) and\n * would need a dedicated lexer change. The date half of that ambiguity was\n * already settled by the normalizer rule, and the differential run against\n * 1.0.0-beta.6 showed what leaving the other half cost: a bare\n * `2019-04-01T15:30:00+11:00` read its `+11:00` as a clock time being ADDED to\n * the date, and answered TODAY at 11:00. Not the instant, not an error, and\n * formatted as a date, which is the most convincing way to be wrong. The two\n * spellings now answer identically, which is the only defensible arrangement\n * when one of them was always right.\n */\n\n/**\n * Matches a (reasonably) well-formed ISO8601 date or date-time string:\n * `YYYY-MM-DD` optionally followed by `THH:MM[:SS[.fff]][Z|+HH:MM|-HH:MM]`.\n * Deliberately stricter than the native `Date` constructor's very lenient\n * parsing (which also accepts things like `\"April 1, 2019\"`), only a\n * string actually ISO8601-shaped is accepted here, so `\"not a date\" to\n * date` fails loudly instead of silently parsing as `Invalid Date` (or,\n * worse, something the native parser guesses at).\n */\nconst ISO8601_PATTERN =\n  /^\\d{4}-\\d{2}-\\d{2}(T\\d{2}:\\d{2}(:\\d{2}(\\.\\d+)?)?(Z|[+-]\\d{2}:?\\d{2})?)?$/;\n\n/**\n * Parse an ISO8601-shaped string into epoch milliseconds.\n *\n * Delegates the actual parsing to the native `Date` constructor, which\n * fully implements the ISO8601 extended format (including \"Z\"/\"+HH:MM\"\n * offsets and a fractional-seconds component) per the ECMA-262 Date Time\n * String Format spec, no custom parsing logic needed, just a stricter\n * shape gate in front of it (see {@link ISO8601_PATTERN}'s doc comment).\n *\n * A date-only string (`\"2019-04-01\"`) parses as UTC midnight; a date-time\n * with no offset and no \"Z\" (`\"2019-04-01T15:30:00\"`) parses in the HOST\n * SYSTEM's local timezone, both are the native `Date` constructor's own\n * spec-mandated behavior, not something this function adds.\n *\n * @returns epoch ms, or `null` if `s` isn't ISO8601-shaped or doesn't\n *   parse to a valid instant.\n */\nexport function parseIso8601(s: string): number | null {\n  // A `ValueType.String` Value's `.value` used to retain its original\n  // surrounding double-quotes, because `tokenizeString()` set the token's\n  // value to the raw source slice and `OpCode.PUSH_STRING` pushed that\n  // verbatim. It no longer does: the token's `value` is the payload and its\n  // `text` is the quoted slice. The strip below stays because this function\n  // is also reachable with text that came from somewhere other than a\n  // literal, and stripping a pair that is not there is a no-op.\n  let trimmed = s.trim();\n  if (trimmed.length >= 2 && trimmed.startsWith('\"') && trimmed.endsWith('\"')) {\n    trimmed = trimmed.slice(1, -1);\n  }\n  if (!ISO8601_PATTERN.test(trimmed)) return null;\n  const ms = new Date(trimmed).getTime();\n  return Number.isNaN(ms) ? null : ms;\n}\n\n/**\n * Format epoch milliseconds as an ISO8601 string with an explicit\n * `+HH:MM`/`-HH:MM` offset, e.g. `\"2019-04-01T15:30:00+11:00\"`.\n *\n * DESIGN NOTE: uses the HOST SYSTEM's local timezone offset for the\n * offset component. This engine's `Datetime` representation is a bare\n * epoch-ms number with no zone tag (see `packages/time/TimePackage.ts`'s\n * doc comment for the same limitation affecting timezone conversion), so\n * there is no per-expression timezone context to draw on otherwise, the\n * process's own local offset (`Date.getTimezoneOffset()`) is the only\n * notion of \"local\" available. No milliseconds component is emitted,\n * matching the precision of the task's own worked example.\n */\nexport function formatIso8601Local(epochMs: number): string {\n  const d = new Date(epochMs);\n  const pad = (n: number) => String(n).padStart(2, \"0\");\n\n  const year = d.getFullYear();\n  const month = pad(d.getMonth() + 1);\n  const day = pad(d.getDate());\n  const hours = pad(d.getHours());\n  const minutes = pad(d.getMinutes());\n  const seconds = pad(d.getSeconds());\n\n  // getTimezoneOffset() is (UTC - local) in minutes, i.e. the SIGN is\n  // inverted relative to a \"+HH:MM ahead of UTC\" display offset.\n  const offsetMinutesTotal = -d.getTimezoneOffset();\n  const sign = offsetMinutesTotal >= 0 ? \"+\" : \"-\";\n  const absOffset = Math.abs(offsetMinutesTotal);\n  const offsetHours = pad(Math.floor(absOffset / 60));\n  const offsetMinutes = pad(absOffset % 60);\n\n  return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}${sign}${offsetHours}:${offsetMinutes}`;\n}\n\n/**\n * Magnitude threshold distinguishing a millisecond Unix timestamp from a\n * second Unix timestamp: values at or above this are treated as\n * milliseconds, below it as seconds.\n *\n * Chosen so that \"now\" in EITHER unit sits comfortably on its own side:\n * seconds-since-epoch for the foreseeable future stays in the ~1.7-2.5\n * billion range (1e9-1e10-ish), nowhere near 1e12, while the SAME\n * instant in milliseconds is ~1000x larger, comfortably past 1e12\n * (e.g. \"2024-12-10\" is ~1.73e9 seconds or ~1.73e12 ms). 1e12 sits well\n * clear of both real-world ranges for at least the next few centuries of\n * second-timestamps, so this is a safe, simple magnitude gate rather than\n * a fragile exact boundary.\n */\nconst MS_TIMESTAMP_THRESHOLD = 1e12;\n\n/**\n * Interpret a bare numeric Unix timestamp as epoch milliseconds, applying\n * the magnitude-based seconds-vs-milliseconds disambiguation described by\n * {@link MS_TIMESTAMP_THRESHOLD}.\n */\nexport function unixTimestampToEpochMs(n: number): number {\n  return Math.abs(n) >= MS_TIMESTAMP_THRESHOLD ? n : n * 1000;\n}\n","import type { Token } from \"@solve-js/lexer/Token\";\nimport { tokenTypeId } from \"@solve-js/lexer/Token\";\nimport { LexerToken } from \"@solve-js/lexer/ExpressionLexer\";\nimport type { NormalizerRule, NormalizerMatch } from \"@solve-js/normalizer/NormalizerRule\";\nimport { parseIso8601 } from \"@solve-js/packages/datetime/Iso8601\";\nimport type { DateInputOrder } from \"@solve-js/constants/Configuration\";\n\n/**\n * Token type a fused date literal is rewritten to.\n *\n * One type covers every supported ordering, so the parselet handles the shape\n * rather than the locale.\n */\nexport const DATETIME_LITERAL_TYPE = \"DATETIME_LITERAL\";\nconst DATETIME_LITERAL_TYPE_ID = tokenTypeId(DATETIME_LITERAL_TYPE);\n\n/** A pure digit string, guards against fusing hex/scientific/bigint-suffixed NUMBER tokens. */\nconst PLAIN_INTEGER = /^\\d+$/;\n\n/** First NUMBER token of a dot-separated literal: the lexer's decimal scanner\n * merges \"DD.MM\" into one float-shaped token (see module doc below). */\nconst DOT_DAY_MONTH = /^\\d{1,2}\\.\\d{1,2}$/;\n\n/** Second NUMBER token of a dot-separated literal: the lexer re-enters\n * tokenizeNumber() AT the second dot, so the year keeps its leading dot. */\nconst DOT_LEADING_YEAR = /^\\.(\\d{2}|\\d{4})$/;\n\n/**\n * Day and month groups of a separator-separated literal, in any of the three\n * orderings below: one or two digits, padded or not.\n *\n * Deliberately NOT two digits exactly. Zero-padding is what ISO 8601 requires\n * of a serialized date, but it is not what people type: \"2024-5-3\" is an\n * ordinary way to write a date and has to keep working. The digit count is\n * still bounded because a group of three or more digits is not a date group at\n * all, and the calendar check in {@link buildDateToken} would not catch it on\n * its own (\"030\" reads back as day 30).\n *\n * What actually separates a date from the arithmetic it is spelled like is\n * adjacency, not padding. See {@link writtenAsOneRun}.\n */\nconst DAY_OR_MONTH = /^\\d{1,2}$/;\n\n/**\n * Whether every token in a run touches the next one in the source text, with\n * no whitespace anywhere between the first character and the last.\n *\n * This is the whole basis for telling a date literal apart from the\n * arithmetic it is spelled identically to. A date is written as one\n * uninterrupted run (\"2024-5-3\"); a subtraction chain is written with spaces\n * around its operators (\"2024 - 5 - 3\"). The lexer records that difference in\n * the token offsets and nowhere else, since the tokens themselves are the same\n * five either way:\n *\n *   2024-5-3        NUMBER@0 MINUS@4 NUMBER@5 MINUS@6 NUMBER@7\n *   2024 - 5 - 3    NUMBER@0 MINUS@5 NUMBER@7 MINUS@9 NUMBER@11\n *\n * The same technique, for the same reason, is what tells \"5k\" from \"5 k\" in\n * `arithmetic/normalizer/LargeNumberSuffixNormalizerRule.ts`.\n *\n * ## Why this replaced a zero-padding requirement on the ISO branch\n * The ISO branch briefly required its month and day groups to be padded to two\n * digits, which did stop \"2024 - 5 - 3\" being answered as \"Friday, May 3,\n * 2024\" but also stopped \"2024-5-3\" being a date at all. Padding was never the\n * real distinction, and the rule's own US branch is the proof: it has always\n * accepted unpadded groups, so \"1-1-2020\" and \"12-25-2023\" are both dates\n * today. Requiring padding on one branch of the two was therefore an\n * inconsistency between two spellings of one rule rather than a policy.\n *\n * The US branch's own guard is a 2-or-4-digit trailing year plus the calendar\n * check, and it is NOT safe against spaced arithmetic on its own: before this\n * check existed, \"12 - 25 - 2023\" answered Christmas 2023 instead of -2036,\n * and \"1 - 1 - 2020\" answered New Year's Day instead of -2020. Applying\n * adjacency to the whole run rather than to one branch fixes that at the same\n * time and leaves both branches resting on the same reason.\n *\n * ## Padded but spaced\n * \"2024 - 05 - 03\" is subtraction under this check, and that is the intended\n * reading. Nobody types the spaces when they mean the date, so the spacing is\n * the clearest signal available about which was meant, and the padding is not:\n * a person subtracting may well write \"05\" for the same reason they write\n * \"05\" anywhere else. Choosing the date there would mean no spelling of that\n * subtraction existed.\n *\n * `sourceEnd` is preferred over `text.length` where it is set, because a token\n * an earlier rule fused carries replacement text rather than source text and\n * only `sourceEnd` still describes the span it covers (see\n * `normalizer/TokenNormalizer.ts`'s `createFusedToken`).\n */\nfunction writtenAsOneRun(tokens: Token[]): boolean {\n  for (let i = 0; i < tokens.length - 1; i++) {\n    const token = tokens[i];\n    const end = token.sourceEnd ?? token.offset + token.text.length;\n    if (end !== tokens[i + 1].offset) return false;\n  }\n  return true;\n}\n\n/**\n * Resolves a year token's raw digit text to a 4-digit year.\n *\n * Accepts exactly 2 or 4 digits (matching the wiki's documented formats).\n * A 2-digit year is windowed using the common glibc `strptime(\"%y\")`\n * convention: 00-68 -> 2000-2068, 69-99 -> 1969-1999. Any other digit\n * count (1 or 3 digits) is not a valid year shape and returns null so the\n * caller can decline the match and fall back to ordinary arithmetic.\n */\nfunction resolveYear(digits: string): number | null {\n  if (digits.length === 4) return Number(digits);\n  if (digits.length === 2) {\n    const yy = Number(digits);\n    return yy <= 68 ? 2000 + yy : 1900 + yy;\n  }\n  return null;\n}\n\n/**\n * Converts a validated day/month/year triple into a fused DATETIME_LITERAL\n * token, or null if the triple isn't a real calendar date (e.g. \"30\" for\n * February), letting the caller fall back to treating the source tokens\n * as ordinary arithmetic instead of a date.\n */\nexport function buildDateToken(\n  day: number,\n  month: number,\n  year: number,\n  sourceTokens: Token[],\n  ruleName: string,\n): NormalizerMatch | null {\n  if (month < 1 || month > 12 || day < 1 || day > 31) return null;\n\n  // Local midnight, consistent with formatDatetime()'s toLocaleString()\n  // display and DATE_NOW's Date.now() epoch, both of which are local-time.\n  const date = new Date(year, month - 1, day);\n  // Reject calendar rollover (e.g. day=30 in February) rather than silently\n  // normalizing to March 2, a rollover almost always means the tokens were\n  // never a date to begin with (e.g. \"2-30-5\" as chained subtraction).\n  if (date.getFullYear() !== year || date.getMonth() !== month - 1 || date.getDate() !== day) {\n    return null;\n  }\n\n  const first = sourceTokens[0];\n  const text = sourceTokens.map((t) => t.value).join(\"\");\n  const fusedToken = new LexerToken(\n    DATETIME_LITERAL_TYPE,\n    DATETIME_LITERAL_TYPE_ID,\n    String(date.getTime()),\n    text,\n    first.offset,\n    0,\n    first.line,\n    first.col,\n  );\n\n  return { consumed: sourceTokens.length, replacement: [fusedToken], ruleName };\n}\n\n/**\n * A full ISO 8601 timestamp: an ISO date with a time of day, optionally\n * carrying a UTC offset or the `Z` that means one of zero.\n *\n * Anchored at the start and deliberately greedy about the offset, so\n * `...T15:30:00+11:00` matches through the offset rather than stopping at the\n * seconds and leaving `+11:00` behind as an addition. That is what the bare\n * form used to do: `2019-04-01T15:30:00+11:00` read the offset as a clock time\n * being ADDED to the date on its left, and answered today at 11:00. Both\n * halves of that were wrong and neither was visible, which is worse than the\n * bare form simply not being supported.\n *\n * The time of day is required. Without it this would match what the date-only\n * branches below already handle, and they carry the ambiguity rules\n * (adjacency, group shapes) that keep a subtraction chain a subtraction.\n *\n * Matched against reconstructed source text rather than token by token. The\n * lexer has no idea this is one literal, so it emits nine to fourteen tokens\n * for it with the shape depending on the spelling (`T15` arrives as an\n * identifier, `Z` as another, an offset as a PLUS or MINUS with two more\n * numbers), and enumerating those permutations in token patterns is how a\n * spelling gets missed.\n *\n * `T` and `Z` are uppercase only, matching `Iso8601.ts`'s own pattern, which is\n * what actually parses the match. Accepting a spelling here that the parser\n * then refuses would mean the bare form supported more shapes than the quoted\n * one, for no reason a reader could infer.\n */\nconst ISO_TIMESTAMP = /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}(:\\d{2}(\\.\\d+)?)?(Z|[+-]\\d{2}:?\\d{2})?/;\n\n/**\n * Token types a run of ISO 8601 timestamp text can lex into. Anything else\n * ends the run, so the reconstruction below can never reach across an operator\n * or a word that is not part of the literal.\n */\nconst ISO_TOKEN_TYPES = new Set([\"NUMBER\", \"MINUS\", \"PLUS\", \"COLON\", \"IDENT\"]);\n\n/**\n * How many tokens the longest supported spelling occupies. `2019-04-01T15:30:00.123+11:00`\n * is fourteen; the cap only bounds the walk, since the match itself decides\n * where the literal ends.\n */\nconst ISO_MAX_TOKENS = 16;\n\n/**\n * Fuses a bare (unquoted) ISO 8601 timestamp into one DATETIME_LITERAL.\n *\n * `Iso8601.ts` could always parse this shape, and still does the parsing here;\n * what it said could not be done without \"a much larger, dedicated lexer\n * change\" was recognising the bare form, on the grounds that it is ambiguous\n * with arithmetic. The date half of that ambiguity was settled by the rule this\n * helper sits inside (a date is written as one uninterrupted run, so\n * `2024 - 5 - 3` stays arithmetic), and the time half is not ambiguous at all:\n * no chain of subtractions contains a `T15:30`.\n *\n * Contiguity in the SOURCE is what makes that true, the same test\n * {@link writtenAsOneRun} applies to the date-only orderings. Every token has\n * to begin exactly where the previous one ended, so `2019-04-01 T15:30` with a\n * space in it, or `2019-04-01 + 11:00` with the offset written as an addition,\n * are left alone: the user who typed a space typed two things.\n *\n * A token an earlier normalizer rule already fused ends the run rather than\n * joining it. Its `text` is replacement text rather than source text (see\n * `normalizer/TokenNormalizer.ts`'s `createFusedToken`), so concatenating it\n * would reconstruct something the user never typed, and nothing that has\n * already been fused into a phrase is part of a timestamp anyway.\n *\n * @returns The fused match, or null when the tokens at `pos` are not a\n * timestamp, when the match would end mid-token, or when the shape is\n * ISO-like but names no real instant (`2019-04-01T25:00:00`).\n */\nfunction fuseIsoTimestamp(tokens: Token[], pos: number, ruleName: string): NormalizerMatch | null {\n  const first = tokens[pos];\n  if (first.sourceEnd !== undefined) return null;\n  let text = first.text;\n  let runEnd = first.offset + first.text.length;\n  const window: Token[] = [first];\n  for (let i = pos + 1; i < tokens.length && window.length < ISO_MAX_TOKENS; i++) {\n    const next = tokens[i];\n    if (next.sourceEnd !== undefined) break;\n    if (next.offset !== runEnd || !ISO_TOKEN_TYPES.has(next.type)) break;\n    text += next.text;\n    runEnd = next.offset + next.text.length;\n    window.push(next);\n  }\n\n  const matched = ISO_TIMESTAMP.exec(text);\n  if (matched === null) return null;\n\n  // The literal has to end where a token ends. A match that stopped halfway\n  // through one would leave the parser holding a token whose text has already\n  // been consumed, so decline and let the ordinary rules have it.\n  let consumed = 0;\n  let covered = 0;\n  for (const token of window) {\n    covered += token.text.length;\n    consumed++;\n    if (covered >= matched[0].length) break;\n  }\n  if (covered !== matched[0].length) return null;\n\n  // The instant comes from the same parser the quoted form uses, so the two\n  // spellings cannot drift apart: an offset means what it means there, and a\n  // timestamp with no offset is local time, exactly as a bare date literal is\n  // local midnight.\n  const epochMs = parseIso8601(matched[0]);\n  if (epochMs === null) return null;\n\n  const fusedToken = new LexerToken(\n    DATETIME_LITERAL_TYPE,\n    DATETIME_LITERAL_TYPE_ID,\n    String(epochMs),\n    matched[0],\n    first.offset,\n    0,\n    first.line,\n    first.col,\n    first.offset + matched[0].length,\n  );\n  return { consumed, replacement: [fusedToken], ruleName };\n}\n\n/**\n * Maps the three numeric groups of a slash- or hyphen-separated literal to a\n * (day, month, year) triple under an explicit {@link DateInputOrder}, or null\n * when a group is the wrong shape for its role (a non-4-digit year in `YMD`, a\n * year group that is neither two nor four digits in `DMY`/`MDY`).\n *\n * Only reached when the host has fixed an order; `'auto'` keeps the historic\n * per-separator reading in the rule below and never calls this.\n */\nfunction resolveOrderedGroups(\n  g0: string, g1: string, g2: string, order: Exclude<DateInputOrder, \"auto\">,\n): { day: number; month: number; year: number } | null {\n  if (order === \"YMD\") {\n    if (g0.length !== 4) return null;\n    if (!DAY_OR_MONTH.test(g1) || !DAY_OR_MONTH.test(g2)) return null;\n    return { year: Number(g0), month: Number(g1), day: Number(g2) };\n  }\n  // DMY and MDY: two 1-2 digit groups and a trailing 2- or 4-digit year.\n  if (!DAY_OR_MONTH.test(g0) || !DAY_OR_MONTH.test(g1)) return null;\n  const year = resolveYear(g2);\n  if (year === null) return null;\n  return order === \"DMY\"\n    ? { day: Number(g0), month: Number(g1), year }\n    : { day: Number(g1), month: Number(g0), year };\n}\n\n/**\n * NormalizerRule that fuses numeric date literals into a single\n * DATETIME_LITERAL token, per the documented \"Datetime Formats\":\n * - European: DD/MM/YYYY  (5 tokens: NUMBER SLASH NUMBER SLASH NUMBER)\n * - US:       MM-DD-YYYY  (5 tokens: NUMBER MINUS NUMBER MINUS NUMBER)\n * - ISO 8601: YYYY-MM-DD  (same 5-token shape as US, disambiguated by the\n *             first group being exactly 4 digits)\n * - Dot:      DD.MM.YYYY  (2 tokens. See below)\n *\n * ## Why the dot format is a 2-token window, not 5\n * ExpressionLexer's tokenizeNumber() treats \".\" adjacent to digits on both\n * sides as a decimal point, not a separator. For \"25.12.2023\" the lexer\n * itself emits only two NUMBER tokens: \"25.12\" (day+month merged into one\n * float-shaped literal) and \".2023\" (the lexer re-enters number scanning\n * AT the second dot, so the year keeps a leading dot). There is no 5-token\n * NUMBER-DOT-NUMBER-DOT-NUMBER shape to match against, the fusion has to\n * happen post-hoc from that 2-token shape instead. This only works for the\n * literal typed with no internal whitespace (e.g. \"25.12.2023\"); a spaced\n * variant (\"25 .12 .2023\") produces three separate leading-dot tokens and\n * is intentionally not supported, out of scope for the documented format.\n *\n * ## Ambiguity with existing arithmetic\n * A date-shaped SLASH or MINUS chain (e.g. \"25/12/2023\" or \"12-25-2023\")\n * previously parsed as chained division/subtraction. This rule\n * deliberately reinterprets any such chain that resolves to a real\n * calendar date as a date literal instead, matching the documented\n * behavior. Chains that aren't valid dates (out-of-range day/month, a\n * February 30, a non-2/4-digit year) fall through unchanged.\n *\n * That reinterpretation only ever claims a chain written as one\n * uninterrupted run of characters. \"25/12/2023\" and \"12-25-2023\" are dates;\n * \"25 / 12 / 2023\" and \"12 - 25 - 2023\", written with the spaces an operator\n * normally gets, stay division and subtraction. {@link writtenAsOneRun}\n * carries the full reasoning, including why this is checked instead of\n * requiring an ISO date's zero-padding.\n *\n * ## Relationship to Iso8601.ts / DatePhrase.ts\n * This is the general-purpose \"bare numeric date literal\" implementation\n * those two files' doc comments referenced as landing on a sibling branch\n * (`feat/safety-limits-datetime-literals`), now ported here. It's\n * intentionally independent of both: `Iso8601.ts` only parses QUOTED\n * STRING literals (`\"2019-04-01...\" to date`), and the Stocks package's\n * `DatePhrase.ts` is a narrower, deliberately-diverging grammar (US-style\n * bare SLASH dates, 4-digit-year-only) scoped to stock-history queries\n * neither of those needed to change for this to land.\n */\nexport function dateLiteralNormalizerRule(\n  getInputOrder: () => DateInputOrder = () => \"auto\",\n): NormalizerRule {\n  return {\n    name: \"datetime:date-literal\",\n    priority: 70,\n    match(tokens: Token[], pos: number): NormalizerMatch | null {\n      const t0 = tokens[pos];\n      if (t0.type !== \"NUMBER\") return null;\n\n      // ── Dot format: 2-token window (see module doc) ──────────────────\n      if (DOT_DAY_MONTH.test(t0.value)) {\n        const t1 = tokens[pos + 1];\n        if (t1 && t1.type === \"NUMBER\" && DOT_LEADING_YEAR.test(t1.value)) {\n          const [dayText, monthText] = t0.value.split(\".\");\n          const year = resolveYear(t1.value.slice(1));\n          if (year !== null) {\n            const match = buildDateToken(\n              Number(dayText), Number(monthText), year,\n              [t0, t1], \"datetime:date-literal:dot\",\n            );\n            if (match) return match;\n          }\n        }\n        return null;\n      }\n\n      // ── ISO 8601 timestamp: as many tokens as the spelling takes ─────\n      // Tried before the date-only windows below, which would otherwise fuse\n      // the date half of a timestamp and leave the time half to be read as\n      // arithmetic. See fuseIsoTimestamp().\n      if (t0.value.length === 4 && PLAIN_INTEGER.test(t0.value)) {\n        const timestamp = fuseIsoTimestamp(tokens, pos, \"datetime:date-literal:iso-timestamp\");\n        if (timestamp) return timestamp;\n      }\n\n      // ── Slash / minus format: 5-token window ─────────────────────────\n      if (!PLAIN_INTEGER.test(t0.value)) return null;\n      const sep1 = tokens[pos + 1];\n      if (!sep1 || (sep1.type !== \"SLASH\" && sep1.type !== \"MINUS\")) return null;\n      const t1 = tokens[pos + 2];\n      const sep2 = tokens[pos + 3];\n      const t2 = tokens[pos + 4];\n      if (!t1 || t1.type !== \"NUMBER\" || !PLAIN_INTEGER.test(t1.value)) return null;\n      if (!sep2 || sep2.type !== sep1.type) return null;\n      if (!t2 || t2.type !== \"NUMBER\" || !PLAIN_INTEGER.test(t2.value)) return null;\n\n      const sourceTokens = [t0, sep1, t1, sep2, t2];\n      // The one check that separates every ordering below from the arithmetic\n      // it is spelled identically to, and the only one that applies to all\n      // three equally. See writtenAsOneRun.\n      if (!writtenAsOneRun(sourceTokens)) return null;\n\n      // A host-fixed order (DMY/MDY/YMD) reads slash and hyphen dates the same\n      // way, so a US reader's `12/25/2023` and an ISO `2023/12/25` both parse.\n      // `'auto'` falls through to the historic per-separator reading below.\n      const order = getInputOrder();\n      if (order !== \"auto\") {\n        const resolved = resolveOrderedGroups(t0.value, t1.value, t2.value, order);\n        if (resolved === null) return null;\n        return buildDateToken(\n          resolved.day, resolved.month, resolved.year, sourceTokens,\n          `datetime:date-literal:${order.toLowerCase()}`,\n        );\n      }\n\n      if (sep1.type === \"SLASH\") {\n        // European: DD/MM/YYYY (always, no ISO-slash variant is documented)\n        if (!DAY_OR_MONTH.test(t0.value) || !DAY_OR_MONTH.test(t1.value)) return null;\n        const year = resolveYear(t2.value);\n        if (year === null) return null;\n        return buildDateToken(Number(t0.value), Number(t1.value), year, sourceTokens, \"datetime:date-literal:european\");\n      }\n\n      // MINUS: ISO (YYYY-MM-DD) if the first group is exactly 4 digits, else US (MM-DD-YYYY)\n      if (t0.value.length === 4) {\n        if (!DAY_OR_MONTH.test(t1.value) || !DAY_OR_MONTH.test(t2.value)) return null;\n        // year=t0, month=t1, day=t2, buildDateToken takes (day, month, year)\n        return buildDateToken(Number(t2.value), Number(t1.value), Number(t0.value), sourceTokens, \"datetime:date-literal:iso\");\n      }\n      if (!DAY_OR_MONTH.test(t0.value) || !DAY_OR_MONTH.test(t1.value)) return null;\n      const year = resolveYear(t2.value);\n      if (year === null) return null;\n      // month=t0, day=t1, year=t2, buildDateToken takes (day, month, year)\n      return buildDateToken(Number(t1.value), Number(t0.value), year, sourceTokens, \"datetime:date-literal:us\");\n    },\n  };\n}\n"]}

package/dist/{chunk-PNDQRCRQ.cjs → chunk-6U66HQKQ.cjs}

@@ -1,2 +1,2 @@
-'use strict';var chunkSOMGSIO4_cjs=require('./chunk-SOMGSIO4.cjs');var m=0,l=0,c=Number.POSITIVE_INFINITY,h=0,y=Number.POSITIVE_INFINITY;function b(e,t,r){return chunkSOMGSIO4_cjs.c.execution({code:"ALLOCATION_LIMIT_EXCEEDED",message:`Evaluating this expression would materialise ${e.toLocaleString("en-US")} ${t}, past the limit of ${c.toLocaleString("en-US")} elements for one evaluation`,expected:`at most ${c.toLocaleString("en-US")} elements materialised while evaluating one expression`,found:`a request for ${e.toLocaleString("en-US")} more ${t}, on top of ${r.toLocaleString("en-US")} already materialised`,suggestion:"use a smaller collection or matrix, or raise the engine's vm.maxAllocatedElements setting",context:{requested:e,what:t,used:r,limit:c}})}function M(e){m++===0&&(l=0,c=e.getMaxAllocatedElements(),h=0,y=e.getMaxFunctionCalls());}function _(){m>0&&m--;}function T(e,t){if(m!==0){if(!(e>=0))throw b(e,t,l);if(l+=e,l>c)throw b(e,t,l-e)}}function S(e,t){if(m!==0&&(!(e>=0)||l+e>c))throw b(e,t,l)}function R(e,t){return S(e,t),new Array(e)}function P(){if(m!==0&&++h>y)throw chunkSOMGSIO4_cjs.c.execution({code:"FUNCTION_CALL_LIMIT_EXCEEDED",message:`Evaluating this expression would make more than ${y.toLocaleString("en-US")} user-defined-function calls, which is the limit for one evaluation`,expected:`at most ${y.toLocaleString("en-US")} function calls while evaluating one expression`,found:"a call past that limit, from a chain of functions that each call others more than once",suggestion:"check for a function that calls itself (or a chain of them) more times than intended, or raise the engine's vm.maxFunctionCalls setting",context:{calls:h,callLimit:y}})}var N=(n=>(n[n.Number=0]="Number",n[n.Hex=1]="Hex",n[n.BigInt=2]="BigInt",n[n.String=3]="String",n[n.Datetime=4]="Datetime",n[n.Percentage=5]="Percentage",n[n.Uom=6]="Uom",n[n.Matrix=7]="Matrix",n[n.Range=8]="Range",n[n.Symbolic=9]="Symbolic",n[n.Boolean=10]="Boolean",n[n.Unit=11]="Unit",n[n.Pending=12]="Pending",n[n.Error=13]="Error",n[n.Colour=14]="Colour",n[n.Split=15]="Split",n[n.Chart=16]="Chart",n[n.IpCidr=17]="IpCidr",n))(N||{}),f=class f{constructor(t=512){this.arena=[];this.index=0;this.initialSize=t;for(let r=0;r<t;r++)this.arena.push(new a(0,0));}acquire(t,r,o){if(this.index<this.arena.length){let s=this.arena[this.index++];return s.recycle(t,r,o),s}let d=new a(t,r,o);return this.arena.push(d),this.index++,d}reset(){let t=this.index;this.index=0,!(this.arena.length<=this.initialSize)&&(this.arena.length<=t*f.SHRINK_WHEN_HOLDING_TIMES||(this.arena.length=Math.max(this.initialSize,t*f.KEEP_TIMES)));}get usage(){return this.index}get capacity(){return this.arena.length}};f.SHRINK_WHEN_HOLDING_TIMES=4,f.KEEP_TIMES=2;var g=f,i=null,u=false;function A(e){return i||(i=new g(e)),i.reset(),u=true,i}function O(){u=false;}function C(){return u}function $(e){let t=new a(e.type,e.value,e.unit);return e.exact!==void 0&&(t.exact=e.exact),e.rational!==void 0&&(t.rational=e.rational),e.uncertainty!==void 0&&(t.uncertainty=e.uncertainty),t}var E=process.env.NODE_ENV==="development";function q(e){return E&&!C()&&(e.toNumber(),Object.freeze(e)),e}var a=class{constructor(t,r,o){this.type=t,this.value=r,this.unit=o,typeof r=="number"&&(this._cachedNumber=r);}recycle(t,r,o){this.type=t,this.value=r,this.unit=o,this._cachedNumber=typeof r=="number"?r:void 0,this.timedOut=void 0,this.exact=void 0,this.rational=void 0,this.uncertainty=void 0,this.decimalPlaces=void 0;}isNumber(){return this.type===0}isHex(){return this.type===1}isBigInt(){return this.type===2}isString(){return this.type===3}isMatrix(){return this.type===7}isVectorShape(){if(this.type!==7)return  false;let t=this.value;return t.rows===1||t.cols===1}isRange(){return this.type===8}isColour(){return this.type===14}isChart(){return this.type===16}isIpCidr(){return this.type===17}isSymbolic(){return this.type===9}isError(){return this.type===13}isPending(){return this.type===12}isFault(){return this.type===13||this.type===12}get errorCode(){return this.type===13?this.value:void 0}get errorMessage(){return this.type===13?this.unit:void 0}toNumber(){if(this.type===12||this.type===13)return 0;if(this.type===7){let r=this.value;return r.rows===1&&r.cols===1&&typeof r.data[0]=="number"?r.data[0]:0}if(this.type===8||this.type===14||this.type===16)return 0;if(this.type===17)return this.value.addr??0;if(this.type===15)return this.value.shares[0].value;if(this.type===9)return 0;if(this.type===10)return this.value===true?1:0;if(this._cachedNumber!==void 0)return this._cachedNumber;if(typeof this.value=="bigint")return this._cachedNumber=Number(this.value),this._cachedNumber;let t=parseFloat(this.value);return this._cachedNumber=isNaN(t)?0:t,this._cachedNumber}isNaN(){if(this.type===12||this.type===13)return  false;if(this.type===7){let t=this.value;return t.rows===1&&t.cols===1&&typeof t.data[0]=="number"?isNaN(t.data[0]):false}return this.type===8||this.type===14||this.type===15||this.type===16||this.type===17||this.type===9||this.type===10?false:typeof this.value=="number"?isNaN(this.value):typeof this.value=="bigint"?false:isNaN(parseFloat(this.value))}};function x(e){return u&&i?i.acquire(0,e):new a(0,e)}function B(e,t){let r=x(e);return r.exact=t,r}function H(e,t){let r=x(e);return r.rational=t,r}function k(e,t){let r=x(e);return r.uncertainty=t,r}function j(e,t="hex"){let r=t==="hex"?void 0:t;return u&&i?i.acquire(1,e,r):new a(1,e,r)}function K(e){return u&&i?i.acquire(2,e):new a(2,e)}function z(e){return u&&i?i.acquire(3,e):new a(3,e)}function D(e,t){return u&&i?i.acquire(6,e,t):new a(6,e,t)}function Y(e,t,r){let o=D(e,t);return o.exact=r,o}function W(e,t,r){return D(e,`${t}/${r}`)}function X(e){return typeof e=="string"&&e.includes("/")}function G(e){let t=e.indexOf("/");if(t<0)throw chunkSOMGSIO4_cjs.c.internal("INVALID_RATE_UNIT",`splitRateUnit: "${e}" is not a rate unit (expected "numerator/denominator")`,{unit:e});return {numerator:e.slice(0,t),denominator:e.slice(t+1)}}var V="timecode@";function J(e){return `${V}${e}`}function v(e){return typeof e=="string"&&e.startsWith(V)}function Q(e){if(!v(e))throw chunkSOMGSIO4_cjs.c.internal("INVALID_TIMECODE_UNIT",`timecodeFps: "${e}" is not a timecode unit (expected "timecode@<fps>")`,{unit:e});return parseFloat(e.slice(V.length))}function I(e,t,r){T(r.length,"matrix cells");let o=r.some(s=>typeof s=="object"&&s!==null&&"kind"in s),d={rows:e,cols:t,data:r,hasSymbolic:o};return u&&i?i.acquire(7,d):new a(7,d)}function Z(e){return I(1,e.length,e)}function ee(e){return I(e.length,1,e)}function te(e,t){let r={min:e,max:t};return u&&i?i.acquire(8,r):new a(8,r)}function re(e){return u&&i?i.acquire(14,e):new a(14,e)}function ne(e){return u&&i?i.acquire(15,e):new a(15,e)}function ie(e){return u&&i?i.acquire(16,e):new a(16,e)}function ae(e){return u&&i?i.acquire(17,e):new a(17,e)}function ue(e){return u&&i?i.acquire(9,e):new a(9,e)}function oe(e){return u&&i?i.acquire(10,e):new a(10,e)}function le(e){return u&&i?i.acquire(4,e):new a(4,e)}function se(e){return u&&i?i.acquire(5,e):new a(5,e)}function pe(e){return new a(12,e)}function ce(e,t){return new a(13,e,t)}function me(e,t,r){return e.type===13||e.type===12?e:t!==void 0&&(t.type===13||t.type===12)?t:r!==void 0&&(r.type===13||r.type===12)?r:null}function fe(e){for(let t=0;t<e.length;t++){let r=e[t];if(r.type===13||r.type===12)return r}return null}exports.A=v;exports.B=Q;exports.C=I;exports.D=Z;exports.E=ee;exports.F=te;exports.G=re;exports.H=ne;exports.I=ie;exports.J=ae;exports.K=ue;exports.L=oe;exports.M=le;exports.N=se;exports.O=pe;exports.P=ce;exports.Q=me;exports.R=fe;exports.a=M;exports.b=_;exports.c=T;exports.d=S;exports.e=R;exports.f=P;exports.g=N;exports.h=A;exports.i=O;exports.j=C;exports.k=$;exports.l=q;exports.m=a;exports.n=x;exports.o=B;exports.p=H;exports.q=k;exports.r=j;exports.s=K;exports.t=z;exports.u=D;exports.v=Y;exports.w=W;exports.x=X;exports.y=G;exports.z=J;//# sourceMappingURL=chunk-PNDQRCRQ.cjs.map
-//# sourceMappingURL=chunk-PNDQRCRQ.cjs.map
+'use strict';var chunkNAZ6PGLS_cjs=require('./chunk-NAZ6PGLS.cjs');var m=0,l=0,c=Number.POSITIVE_INFINITY,h=0,y=Number.POSITIVE_INFINITY;function b(e,t,r){return chunkNAZ6PGLS_cjs.c.execution({code:"ALLOCATION_LIMIT_EXCEEDED",message:`Evaluating this expression would materialise ${e.toLocaleString("en-US")} ${t}, past the limit of ${c.toLocaleString("en-US")} elements for one evaluation`,expected:`at most ${c.toLocaleString("en-US")} elements materialised while evaluating one expression`,found:`a request for ${e.toLocaleString("en-US")} more ${t}, on top of ${r.toLocaleString("en-US")} already materialised`,suggestion:"use a smaller collection or matrix, or raise the engine's vm.maxAllocatedElements setting",context:{requested:e,what:t,used:r,limit:c}})}function M(e){m++===0&&(l=0,c=e.getMaxAllocatedElements(),h=0,y=e.getMaxFunctionCalls());}function _(){m>0&&m--;}function T(e,t){if(m!==0){if(!(e>=0))throw b(e,t,l);if(l+=e,l>c)throw b(e,t,l-e)}}function S(e,t){if(m!==0&&(!(e>=0)||l+e>c))throw b(e,t,l)}function R(e,t){return S(e,t),new Array(e)}function P(){if(m!==0&&++h>y)throw chunkNAZ6PGLS_cjs.c.execution({code:"FUNCTION_CALL_LIMIT_EXCEEDED",message:`Evaluating this expression would make more than ${y.toLocaleString("en-US")} user-defined-function calls, which is the limit for one evaluation`,expected:`at most ${y.toLocaleString("en-US")} function calls while evaluating one expression`,found:"a call past that limit, from a chain of functions that each call others more than once",suggestion:"check for a function that calls itself (or a chain of them) more times than intended, or raise the engine's vm.maxFunctionCalls setting",context:{calls:h,callLimit:y}})}var N=(n=>(n[n.Number=0]="Number",n[n.Hex=1]="Hex",n[n.BigInt=2]="BigInt",n[n.String=3]="String",n[n.Datetime=4]="Datetime",n[n.Percentage=5]="Percentage",n[n.Uom=6]="Uom",n[n.Matrix=7]="Matrix",n[n.Range=8]="Range",n[n.Symbolic=9]="Symbolic",n[n.Boolean=10]="Boolean",n[n.Unit=11]="Unit",n[n.Pending=12]="Pending",n[n.Error=13]="Error",n[n.Colour=14]="Colour",n[n.Split=15]="Split",n[n.Chart=16]="Chart",n[n.IpCidr=17]="IpCidr",n))(N||{}),d=class d{constructor(t=512){this.arena=[];this.index=0;this.initialSize=t;for(let r=0;r<t;r++)this.arena.push(new a(0,0));}acquire(t,r,o){if(this.index<this.arena.length){let s=this.arena[this.index++];return s.recycle(t,r,o),s}let f=new a(t,r,o);return this.arena.push(f),this.index++,f}reset(){let t=this.index;this.index=0,!(this.arena.length<=this.initialSize)&&(this.arena.length<=t*d.SHRINK_WHEN_HOLDING_TIMES||(this.arena.length=Math.max(this.initialSize,t*d.KEEP_TIMES)));}get usage(){return this.index}get capacity(){return this.arena.length}};d.SHRINK_WHEN_HOLDING_TIMES=4,d.KEEP_TIMES=2;var g=d,i=null,u=false;function A(e){return i||(i=new g(e)),i.reset(),u=true,i}function O(){u=false;}function C(){return u}function $(e){let t=new a(e.type,e.value,e.unit);return e.exact!==void 0&&(t.exact=e.exact),e.rational!==void 0&&(t.rational=e.rational),e.uncertainty!==void 0&&(t.uncertainty=e.uncertainty),t}var E=process.env.NODE_ENV==="development";function q(e){return E&&!C()&&(e.toNumber(),Object.freeze(e)),e}var a=class{constructor(t,r,o){this.type=t,this.value=r,this.unit=o,typeof r=="number"&&(this._cachedNumber=r);}recycle(t,r,o){this.type=t,this.value=r,this.unit=o,this._cachedNumber=typeof r=="number"?r:void 0,this.timedOut=void 0,this.exact=void 0,this.rational=void 0,this.uncertainty=void 0,this.decimalPlaces=void 0;}isNumber(){return this.type===0}isHex(){return this.type===1}isBigInt(){return this.type===2}isString(){return this.type===3}isMatrix(){return this.type===7}isVectorShape(){if(this.type!==7)return  false;let t=this.value;return t.rows===1||t.cols===1}isRange(){return this.type===8}isColour(){return this.type===14}isChart(){return this.type===16}isIpCidr(){return this.type===17}isSymbolic(){return this.type===9}isError(){return this.type===13}isPending(){return this.type===12}isFault(){return this.type===13||this.type===12}get errorCode(){return this.type===13?this.value:void 0}get errorMessage(){return this.type===13?this.unit:void 0}toNumber(){if(this.type===12||this.type===13)return 0;if(this.type===7){let r=this.value;return r.rows===1&&r.cols===1&&typeof r.data[0]=="number"?r.data[0]:0}if(this.type===8||this.type===14||this.type===16)return 0;if(this.type===17)return this.value.addr??0;if(this.type===15)return this.value.shares[0].value;if(this.type===9)return 0;if(this.type===10)return this.value===true?1:0;if(this._cachedNumber!==void 0)return this._cachedNumber;if(typeof this.value=="bigint")return this._cachedNumber=Number(this.value),this._cachedNumber;let t=parseFloat(this.value);return this._cachedNumber=isNaN(t)?0:t,this._cachedNumber}isNaN(){if(this.type===12||this.type===13)return  false;if(this.type===7){let t=this.value;return t.rows===1&&t.cols===1&&typeof t.data[0]=="number"?isNaN(t.data[0]):false}return this.type===8||this.type===14||this.type===15||this.type===16||this.type===17||this.type===9||this.type===10?false:typeof this.value=="number"?isNaN(this.value):typeof this.value=="bigint"?false:isNaN(parseFloat(this.value))}};function x(e){return u&&i?i.acquire(0,e):new a(0,e)}function B(e,t){let r=x(e);return r.exact=t,r}function H(e,t){let r=x(e);return r.rational=t,r}function k(e,t){let r=x(e);return r.uncertainty=t,r}function j(e,t="hex"){let r=t==="hex"?void 0:t;return u&&i?i.acquire(1,e,r):new a(1,e,r)}function K(e){return u&&i?i.acquire(2,e):new a(2,e)}function z(e){return u&&i?i.acquire(3,e):new a(3,e)}function D(e,t){return u&&i?i.acquire(6,e,t):new a(6,e,t)}function Y(e,t,r){let o=D(e,t);return o.exact=r,o}function W(e,t,r){return D(e,`${t}/${r}`)}function X(e){return typeof e=="string"&&e.includes("/")}function G(e){let t=e.indexOf("/");if(t<0)throw chunkNAZ6PGLS_cjs.c.internal("INVALID_RATE_UNIT",`splitRateUnit: "${e}" is not a rate unit (expected "numerator/denominator")`,{unit:e});return {numerator:e.slice(0,t),denominator:e.slice(t+1)}}var V="timecode@";function J(e){return `${V}${e}`}function v(e){return typeof e=="string"&&e.startsWith(V)}function Q(e){if(!v(e))throw chunkNAZ6PGLS_cjs.c.internal("INVALID_TIMECODE_UNIT",`timecodeFps: "${e}" is not a timecode unit (expected "timecode@<fps>")`,{unit:e});return parseFloat(e.slice(V.length))}function I(e,t,r){T(r.length,"matrix cells");let o=r.some(s=>typeof s=="object"&&s!==null&&"kind"in s),f={rows:e,cols:t,data:r,hasSymbolic:o};return u&&i?i.acquire(7,f):new a(7,f)}function Z(e){return I(1,e.length,e)}function ee(e){return I(e.length,1,e)}function te(e,t){let r={min:e,max:t};return u&&i?i.acquire(8,r):new a(8,r)}function re(e){return u&&i?i.acquire(14,e):new a(14,e)}function ne(e){return u&&i?i.acquire(15,e):new a(15,e)}function ie(e){return u&&i?i.acquire(16,e):new a(16,e)}function ae(e){return u&&i?i.acquire(17,e):new a(17,e)}function ue(e){return u&&i?i.acquire(9,e):new a(9,e)}function oe(e){return u&&i?i.acquire(10,e):new a(10,e)}function le(e){return u&&i?i.acquire(4,e):new a(4,e)}function se(e){return u&&i?i.acquire(5,e):new a(5,e)}function pe(e){return new a(12,e)}function ce(e,t){return new a(13,e,t)}function me(e,t,r){return e.type===13||e.type===12?e:t!==void 0&&(t.type===13||t.type===12)?t:r!==void 0&&(r.type===13||r.type===12)?r:null}function de(e){for(let t=0;t<e.length;t++){let r=e[t];if(r.type===13||r.type===12)return r}return null}exports.A=v;exports.B=Q;exports.C=I;exports.D=Z;exports.E=ee;exports.F=te;exports.G=re;exports.H=ne;exports.I=ie;exports.J=ae;exports.K=ue;exports.L=oe;exports.M=le;exports.N=se;exports.O=pe;exports.P=ce;exports.Q=me;exports.R=de;exports.a=M;exports.b=_;exports.c=T;exports.d=S;exports.e=R;exports.f=P;exports.g=N;exports.h=A;exports.i=O;exports.j=C;exports.k=$;exports.l=q;exports.m=a;exports.n=x;exports.o=B;exports.p=H;exports.q=k;exports.r=j;exports.s=K;exports.t=z;exports.u=D;exports.v=Y;exports.w=W;exports.x=X;exports.y=G;exports.z=J;//# sourceMappingURL=chunk-6U66HQKQ.cjs.map
+//# sourceMappingURL=chunk-6U66HQKQ.cjs.map

package/dist/chunk-6U66HQKQ.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/vm/AllocationBudget.ts","../src/vm/Value.ts"],"names":["depth","used","limit","calls","callLimit","exceeded","requested","what","alreadyUsed","ErrorFactory","beginEvaluation","vm","endEvaluation","chargeAllocation","count","checkAllocation","checkedArray","chargeFunctionCall","ValueType","_ValueArena","initialSize","i","Value","type","value","unit","v","usedLastCycle","ValueArena","_arena","_arenaActive","enableValueArena","size","disableValueArena","isArenaActive","persistentValue","p","isDevelopmentBuild","freezeIfDev","m","result","numberValue","n","numberValueExact","exact","numberValueRational","rational","numberValueUncertain","uncertainty","hexValue","base","tag","bigIntValue","stringValue","s","uomValue","uomValueExact","rateValue","magnitude","numeratorUnit","denominatorUnit","isRateUnit","splitRateUnit","idx","TIMECODE_UNIT_PREFIX","timecodeUnit","fps","isTimecodeUnit","timecodeFps","matrixValue","rows","cols","data","hasSymbolic","cell","rowVectorValue","colVectorValue","rangeValue","min","max","colourValue","c","splitValue","chartValue","ipCidrValue","symbolicValue","node","boolValue","b","datetimeValue","percentageValue","pendingValue","queryKey","errorValue","code","message","faultedOperand","a","faultedIn","values"],"mappings":"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","file":"chunk-6U66HQKQ.cjs","sourcesContent":["/**\n * The ceiling on how much memory one evaluation is allowed to ask for.\n *\n * The VM's other two counters bound how many opcodes run and how deep the value\n * stack gets, and both are checked BETWEEN opcodes. That leaves a hole the size\n * of a single opcode: whatever one opcode allocates in a loop of its own is\n * invisible to both, so twenty-four characters of input (`map(10*x,\n * 0:2000000000)`) could allocate until V8 aborted the process, which no\n * `try`/`catch` in the host can contain. Per-site caps close one hole each and\n * do not compose: two collections that are individually legal are legal\n * together, and an operation whose result is the PRODUCT of two legal inputs (a\n * matrix multiply) is bounded by neither of them.\n *\n * This is the counter that composes. Everything an evaluation materialises is\n * charged against one running tally, so the bound is on the total rather than\n * on any single step, and a new opcode inherits it by allocating through\n * {@link chargedArray} or by building a Value through a constructor that\n * already charges ({@link matrixValue}).\n *\n * The tally is module state rather than something threaded through every\n * signature. `executeBytecode()` opens an evaluation and every charge inside\n * that window lands on it, which is what lets a helper five call levels down\n * (`vm/MatrixOps.ts`'s `collectionToValues()`) charge without the four frames\n * in between passing a parameter along, and what keeps a charge down to an add\n * and a compare. This mirrors the value arena in `vm/Value.ts`, which is\n * ambient for the same reason and rests on the same fact: `executeBytecode()`\n * is synchronous, so exactly one evaluation is ever in flight in a realm.\n *\n * An \"element\" is one thing a user's input caused to exist: a `Value` in an\n * expanded collection, a cell in a matrix. They are counted rather than\n * measured in bytes, because a count is the quantity every call site already\n * has in hand before it allocates, and asking V8 how big something is costs\n * more than the allocation being guarded.\n *\n * A second tally lives here for the same structural reason and not because it\n * counts the same thing: {@link chargeFunctionCall} bounds how many\n * user-defined-function calls one evaluation may make in total. Surviving\n * reentry is the whole property both need, and this module is where reentry is\n * already tracked.\n *\n * @module AllocationBudget\n */\n\nimport { ErrorFactory } from \"@solve-js/errors/UnifiedErrorFramework\";\nimport type { VM } from \"@solve-js/vm/OpRegistry\";\n\n/**\n * How deep the evaluation is: 0 outside one, higher inside a reentrant call.\n *\n * `executeBytecode()` re-enters itself for a user-defined function call, a map\n * or reduce transform body, and an algebra verb's bound-unknown body. Only the\n * outermost entry clears the tally, so a runaway recursion cannot refresh its\n * own allowance the way it can refresh `maxInstructions` (each reentrant call\n * gets a fresh local instruction count, which is why function recursion needed\n * a separate guard of its own).\n */\nlet depth = 0;\n\n/** Elements charged so far in the evaluation currently in flight. */\nlet used = 0;\n\n/** The in-flight evaluation's ceiling, read from its VM when the evaluation opened. */\nlet limit = Number.POSITIVE_INFINITY;\n\n/** User-defined-function calls made so far in the evaluation currently in flight. */\nlet calls = 0;\n\n/** The in-flight evaluation's call ceiling, read from its VM when the evaluation opened. */\nlet callLimit = Number.POSITIVE_INFINITY;\n\n/**\n * The refusal itself, built in one place so the wording of the engine's most\n * likely \"this is too big\" message is not reinvented per site.\n */\nfunction exceeded(requested: number, what: string, alreadyUsed: number): Error {\n\treturn ErrorFactory.execution({\n\t\tcode: \"ALLOCATION_LIMIT_EXCEEDED\",\n\t\tmessage:\n\t\t\t`Evaluating this expression would materialise ${requested.toLocaleString(\"en-US\")} ${what}, ` +\n\t\t\t`past the limit of ${limit.toLocaleString(\"en-US\")} elements for one evaluation`,\n\t\texpected: `at most ${limit.toLocaleString(\"en-US\")} elements materialised while evaluating one expression`,\n\t\tfound: `a request for ${requested.toLocaleString(\"en-US\")} more ${what}, on top of ${alreadyUsed.toLocaleString(\"en-US\")} already materialised`,\n\t\tsuggestion: \"use a smaller collection or matrix, or raise the engine's vm.maxAllocatedElements setting\",\n\t\tcontext: { requested, what, used: alreadyUsed, limit },\n\t});\n}\n\n/**\n * Open an evaluation, taking its ceiling from the VM about to run it.\n *\n * @param vm - The VM running this program. Only consulted on the outermost\n * entry, so a reentrant call costs one increment.\n */\nexport function beginEvaluation(vm: VM): void {\n\tif (depth++ === 0) {\n\t\tused = 0;\n\t\tlimit = vm.getMaxAllocatedElements();\n\t\tcalls = 0;\n\t\tcallLimit = vm.getMaxFunctionCalls();\n\t}\n}\n\n/** Close the innermost evaluation. Always call from a `finally`, so a throw cannot leave one open. */\nexport function endEvaluation(): void {\n\tif (depth > 0) depth--;\n}\n\n/**\n * Record elements materialised by the evaluation in flight.\n *\n * Each thing is charged exactly once, where it comes into existence: a matrix\n * in `matrixValue()`, an expanded collection where it is expanded. A site that\n * knows a size in advance and whose result will be charged on birth uses\n * {@link checkAllocation} instead, so that refusing early does not mean\n * counting twice.\n *\n * Outside an evaluation this is a plain no-op rather than an error:\n * `matrixValue()` and the `vm/MatrixOps.ts` helpers are exported and get called\n * by tests, by the formatter and by hosts with no evaluation in flight, and\n * none of those is user input being executed.\n *\n * @param count - How many elements now exist.\n * @param what - What they are, in the plural and in a user's words (\"matrix\n * cells\", \"collection elements\"). Quoted verbatim in the error, so it should\n * name the thing rather than the code that makes it.\n * @throws `ALLOCATION_LIMIT_EXCEEDED` when this evaluation has had enough.\n * Recoverable: it describes this expression, not the engine.\n */\nexport function chargeAllocation(count: number, what: string): void {\n\tif (depth === 0) return;\n\t// Written as a negated `>=` so that NaN takes this branch. A NaN count would\n\t// otherwise be added to the tally and make every later `used > limit`\n\t// comparison false, silently switching the guard off for the rest of the\n\t// evaluation, which is the one failure mode a safety limit must not have.\n\tif (!(count >= 0)) throw exceeded(count, what, used);\n\tused += count;\n\tif (used > limit) throw exceeded(count, what, used - count);\n}\n\n/**\n * Refuse an allocation this evaluation cannot afford, without recording it.\n *\n * For the sites that know how big a result will be BEFORE building it and whose\n * result is charged later, when it is born. A matrix product is the case that\n * matters: its size is the product of two operands that are each affordable, so\n * it has to be refused from the shapes alone, before `matrixMultiply()` takes\n * the memory. Charging here as well as at birth would bill every matrix twice\n * and halve the ceiling the host asked for.\n *\n * @param count - How many elements the result would have.\n * @param what - What they are, in the plural. See {@link chargeAllocation}.\n * @throws `ALLOCATION_LIMIT_EXCEEDED` when the evaluation could not afford them.\n */\nexport function checkAllocation(count: number, what: string): void {\n\tif (depth === 0) return;\n\tif (!(count >= 0) || used + count > limit) throw exceeded(count, what, used);\n}\n\n/**\n * Check that an array is affordable, then allocate it.\n *\n * The intended way to build any user-sized array inside the VM whose contents\n * end up inside a Value that charges on birth, so that \"ask before you take\" is\n * a property of the allocator rather than something each new opcode has to be\n * told.\n *\n * @param count - Element count, checked before a single element exists.\n * @param what - What the elements are, in the plural. See {@link chargeAllocation}.\n * @returns An empty array of that length.\n * @throws `ALLOCATION_LIMIT_EXCEEDED` before allocating anything, when the\n * evaluation cannot afford it.\n */\nexport function checkedArray<T>(count: number, what: string): T[] {\n\tcheckAllocation(count, what);\n\treturn new Array<T>(count);\n}\n\n/**\n * Record one user-defined-function call, and refuse the one past the ceiling.\n *\n * Lives in this module rather than in the VM for the single reason the element\n * tally does: it has to survive `executeBytecode()` re-entering itself. A call\n * count kept per invocation would be reset by the very calls it is counting,\n * which is exactly what happens to `maxInstructions` and exactly why counting\n * instructions could never bound this.\n *\n * The thing being bounded is BREADTH, which no existing guard could see.\n * `maxFunctionRecursionDepth` bounds nesting, and a doubling chain\n * (`f22(v) = f21(v) + f21(v)`, twenty-two lines of it) nests only twenty-two\n * deep while making 2,097,152 calls, which was a fatal heap abort in under a\n * second. Depth 22 against a limit of 50 is comfortably legal, and it was.\n *\n * @throws `FUNCTION_CALL_LIMIT_EXCEEDED` when this evaluation has made\n * enough. Recoverable: the engine is fine, this line is not.\n */\nexport function chargeFunctionCall(): void {\n\tif (depth === 0) return;\n\tif (++calls > callLimit) {\n\t\tthrow ErrorFactory.execution({\n\t\t\tcode: \"FUNCTION_CALL_LIMIT_EXCEEDED\",\n\t\t\tmessage:\n\t\t\t\t`Evaluating this expression would make more than ${callLimit.toLocaleString(\"en-US\")} ` +\n\t\t\t\t`user-defined-function calls, which is the limit for one evaluation`,\n\t\t\texpected: `at most ${callLimit.toLocaleString(\"en-US\")} function calls while evaluating one expression`,\n\t\t\tfound: \"a call past that limit, from a chain of functions that each call others more than once\",\n\t\t\tsuggestion: \"check for a function that calls itself (or a chain of them) more times than intended, or raise the engine's vm.maxFunctionCalls setting\",\n\t\t\tcontext: { calls, callLimit },\n\t\t});\n\t}\n}\n\n/**\n * Elements charged so far in the evaluation in flight, or in the one that just\n * finished. For tests and for a host reporting on a refusal.\n *\n * @returns The running tally.\n */\nexport function allocationUsed(): number {\n\treturn used;\n}\n\n/**\n * Drop all in-flight evaluation state.\n *\n * For tests that need a known starting point, and as a repair for a host that\n * somehow lost an `endEvaluation()`. Ordinary execution never needs it:\n * `executeBytecode()` pairs its own begin and end in a `finally`, and the\n * outermost begin clears the tally regardless of what came before.\n */\nexport function resetAllocationTracking(): void {\n\tdepth = 0;\n\tused = 0;\n\tlimit = Number.POSITIVE_INFINITY;\n\tcalls = 0;\n\tcallLimit = Number.POSITIVE_INFINITY;\n}\n","import { ErrorFactory } from \"@solve-js/errors/UnifiedErrorFramework\";\nimport { chargeAllocation } from \"@solve-js/vm/AllocationBudget\";\nimport type { SymbolicNode, Rational } from \"@solve-js/symbolic\";\nimport type { DecimalData } from \"@solve-js/decimal\";\n\n/**\n * A single matrix cell. `boolean` covers element-wise comparison results\n * (`[1,6;3,8] < [5,2;7,4]` produces a Matrix of booleans, not numbers). A\n * `SymbolicNode` cell is a free-variable algebraic entry, e.g. `s =\n * [sx,0,0;0,sy,0;0,0,1]` where `sx`/`sy` are never assigned, so those\n * cells store a real `SymbolicNode` (a bare `var` node initially) rather\n * than degrading to `0`. See `MatrixOps.ts`'s `entryToSymbolic()`/\n * `symbolicToEntry()` for the two-way conversion every symbolic-aware\n * matrix op (multiply, inverse, determinant) uses.\n */\nexport type MatrixEntry = number | boolean | SymbolicNode;\n\n/**\n * A general rows×cols matrix, a vector is just a 1×N (row) or N×1 (column)\n * matrix. `data` is COLUMN-MAJOR (`data[row + col*rows]`), matching the\n * spec's own `a[index]` column-major indexing semantics directly (no\n * translation needed for single-index reads). `hasSymbolic` lets every\n * numeric matrix op fast-path the all-numeric case with one boolean check,\n * mirroring `binaryOp()`'s existing Number+Number fast path, computed by\n * `matrixValue()` itself (true the moment any cell is a `SymbolicNode`\n * object rather than a plain number/boolean), not something callers set\n * by hand.\n */\nexport interface MatrixData {\n\treadonly rows: number;\n\treadonly cols: number;\n\treadonly data: readonly MatrixEntry[];\n\treadonly hasSymbolic: boolean;\n}\n\n/** A first-class integer range `min:max`, both bounds inclusive. */\nexport interface RangeData {\n\treadonly min: number;\n\treadonly max: number;\n}\n\n/**\n * How a colour was authored, and therefore how it should display. It never\n * changes the channels: a colour is always stored as canonical sRGB (`r`,`g`,`b`\n * integers 0-255, `a` in 0-1), and `format` only decides whether `formatValue`\n * renders it as `#rrggbb`, `rgb(...)`, `hsl(...)` or a named keyword.\n */\nexport type ColourFormat = \"hex\" | \"rgb\" | \"rgba\" | \"hsl\" | \"hsla\" | \"named\";\n\n/**\n * A colour value. Canonical channels are sRGB (`r`,`g`,`b` are integers 0-255,\n * `a` is 0-1); HSL is never stored, it is derived on demand for display and for\n * hue/saturation/lightness operations, then re-quantised back to RGBA. A\n * `lighten` followed by an equal `darken` returns to within one rounding step of\n * the original (integer channels re-quantise each way), and does not drift on\n * repetition, rather than storing both HSL and RGB and letting them disagree.\n * `format`\n * records the authored/display form; `name` carries the CSS keyword only when\n * `format === \"named\"` (e.g. `\"rebeccapurple\"`). Lives in a {@link Value}'s\n * `value` slot exactly as {@link MatrixData}/{@link RangeData} do.\n */\nexport interface ColourData {\n\treadonly r: number;\n\treadonly g: number;\n\treadonly b: number;\n\treadonly a: number;\n\treadonly format: ColourFormat;\n\treadonly name?: string;\n}\n\n/**\n * One tier of a bill split: an amount and how many people pay it. An even\n * split is a single share; the odd-penny case is two shares (the base amount\n * most people pay, then the base plus a cent that the remaining `count` pay),\n * so the shares always add back to the exact total. `exact` carries the\n * base-ten cents of a currency share so display rounds from the decimal rather\n * than a drifted double, exactly as money does everywhere else.\n */\nexport interface SplitShare {\n\treadonly value: number;\n\treadonly exact?: DecimalData;\n\treadonly count: number;\n}\n\n/**\n * The result of a per-person bill split (`split $180 between 4`). `unit` is the\n * currency code when the amount was money, undefined for a bare number.\n * `shares` is ordered base-first: `shares[0]` is the \"each\" amount, and a\n * second share, when present, is the slightly larger amount the odd penny falls\n * on. Lives in a {@link Value}'s `value` slot exactly as {@link ColourData} and\n * {@link RangeData} do, a display-only payload the formatter renders.\n */\nexport interface SplitData {\n\treadonly unit?: string;\n\treadonly shares: readonly SplitShare[];\n}\n\n/**\n * What a {@link ChartData} draws, and therefore how a host renders it: a\n * `sparkline` is a tiny inline line with no axes, a `plot` a framed curve over a\n * domain. New kinds (a bar chart, a scatter) are added here, and every host that\n * switches on `kind` keeps working for the ones it already knows.\n */\nexport type ChartKind = \"sparkline\" | \"plot\";\n\n/**\n * A chart specification: the DATA to draw, never pixels. One shape holds every\n * visual the engine produces, `[1,2,3] as sparkline` and `plot sin(x) from 0 to\n * 2pi` alike, so a host reads `kind` to choose a renderer and draws `points`\n * scaled to `domain` × `range`. The engine brings the numbers; the developer\n * brings the charting library. `label` is the plain-text answer a reader without\n * a canvas still gets. A sparkline's points are `(index, value)`; a plot's are\n * `(x, y)`. Lives in a {@link Value}'s `value` slot exactly as\n * {@link MatrixData}/{@link ColourData} do (issues #186, #187).\n */\nexport interface ChartData {\n\treadonly kind: ChartKind;\n\t/** The points to draw, `(x, y)`. A sparkline indexes x from 0. */\n\treadonly points: readonly (readonly [number, number])[];\n\t/** The plain-text answer, e.g. `sin(x) over [0, 6.28]` or the series itself. */\n\treadonly label: string;\n\t/** The x-axis extent `[min, max]`. */\n\treadonly domain: readonly [number, number];\n\t/** The y-axis extent `[min, max]`, for scaling the drawn height. */\n\treadonly range: readonly [number, number];\n\t/** The source expression, for a plot; absent for a sparkline. */\n\treadonly expr?: string;\n}\n\n/**\n * An IPv4 address and/or subnet prefix (issue #189). `addr` is the 32-bit\n * address (`192.168.1.10` held as one number); `prefix` is the CIDR prefix\n * length in `/24`. A bare address has no `prefix`, a bare `/24` has no `addr`,\n * and a full block (`192.168.1.0/24`) has both. Lives in a {@link Value}'s\n * `value` slot as the other struct payloads do; the formatter renders it as the\n * dotted quad (plus `/prefix` when present).\n */\nexport interface IpCidrData {\n\treadonly addr?: number;\n\treadonly prefix?: number;\n}\n\n/**\n * Discriminated union tag for {@link Value} objects.\n *\n * Determines the runtime type of a Value and how its `value` field should\n * be interpreted. Used by the VM for type-aware dispatch in arithmetic,\n * comparison, and conversion operations.\n */\nexport enum ValueType {\n\t/** Plain 64-bit floating point number (IEEE 754 double) */\n\tNumber = 0,\n\tHex = 1,\n\tBigInt = 2,\n\tString = 3,\n\tDatetime = 4,\n\tPercentage = 5,\n\tUom = 6,\n\t/** General rows×cols matrix (a vector is a 1×N or N×1 matrix). Value is {@link MatrixData}. */\n\tMatrix = 7,\n\t/** A first-class integer range `min:max`, both inclusive. Value is {@link RangeData}. */\n\tRange = 8,\n\t/** A symbolic/algebraic expression tree (free-variable formula, not a concrete number). Value is a `SymbolicNode` (`@solve-js/symbolic`). */\n\tSymbolic = 9,\n\t/** Boolean true/false. Value is `boolean`. */\n\tBoolean = 10,\n\t/** Unit of measurement token (lexer only, not a runtime value). */\n\tUnit = 11,\n\t/** Async result pending resolution. Value stores the queryKey string. */\n\tPending = 12,\n\t/** Plugin-raised error propagated through the DAG. Value stores error code, unit stores message. */\n\tError = 13,\n\t/** A colour (hex/rgb/hsl/named). Value is {@link ColourData}. */\n\tColour = 14,\n\t/** A per-person bill split (`split $180 between 4`). Value is {@link SplitData}. */\n\tSplit = 15,\n\t/** A chart to draw (`[1,2,3] as sparkline`, `plot sin(x) from 0 to 2pi`). Value is {@link ChartData}. */\n\tChart = 16,\n\t/** An IPv4 address or subnet (`192.168.1.0/24`). Value is {@link IpCidrData}. */\n\tIpCidr = 17,\n}\n\n// ── ValueArena ────────────────────────────────────────────────────────────\n// Phase 5.3: Bump-allocator arena for zero-allocation Value reuse during scroll.\n// Instead of allocating new Value objects per instruction, we pre-allocate a\n// block and bump an index. A single arena.reset() per scroll frame recycles all\n// Values, no per-value release overhead, no GC pressure during 60fps scrolling.\n\n/**\n * Bump-allocator arena for zero-allocation Value reuse during scroll.\n *\n * Instead of allocating new Value objects per instruction, pre-allocates a\n * block and bumps an index. `arena.reset()` per scroll frame recycles all\n * Values, no per-value release overhead, no GC pressure during 60fps scrolling.\n *\n * Only active during Tier 2 scroll execution (ThreeTierEvaluator).\n */\nexport class ValueArena {\n\tprivate arena: Value[] = [];\n\tprivate index: number = 0;\n\t/** The block size to come back down to. Kept so {@link reset} can. */\n\tprivate readonly initialSize: number;\n\n\t/**\n\t * How much more than the last cycle needed the arena may go on holding\n\t * before it gives the difference back, and how much of it it keeps when it\n\t * does.\n\t *\n\t * A bump allocator that grows to serve one expensive line is working as\n\t * intended; one that never comes down is a leak wearing a cache's clothes.\n\t * `map(x*1, 1:100000)` is an ordinary line by every limit the engine has,\n\t * and it took the arena from 512 Values to 300,004, about 24MB that stayed\n\t * live through two forced full collections and through every later `1 + 1`,\n\t * because `acquire()` handles overflow with `push()` and `reset()` only\n\t * zeroed the bump index. The instance is module-level and survives\n\t * `disableValueArena()` on purpose, so that high-water mark was for the\n\t * life of the process.\n\t *\n\t * Keeping twice what the last cycle used, and only shrinking once holding\n\t * four times that, is what stops the release from becoming a different\n\t * performance bug: a steady scroll uses about the same number of Values\n\t * every frame, so it never meets the condition at all, and an alternating\n\t * heavy/light document degrades at worst to allocating the Values it would\n\t * have allocated with no arena in the first place.\n\t */\n\tprivate static readonly SHRINK_WHEN_HOLDING_TIMES = 4;\n\tprivate static readonly KEEP_TIMES = 2;\n\n\t/** Pre-allocate initial block. 512 Values covers ~30-line viewport comfortably. */\n\tconstructor(initialSize: number = 512) {\n\t\tthis.initialSize = initialSize;\n\t\tfor (let i = 0; i < initialSize; i++) {\n\t\t\tthis.arena.push(new Value(ValueType.Number, 0));\n\t\t}\n\t}\n\n\t/** Bump-allocate a recycled Value. Falls back to allocation only for overflow. */\n\tacquire(type: ValueType, value: number | bigint | string | boolean | MatrixData | RangeData | ColourData | SplitData | ChartData | IpCidrData | SymbolicNode, unit?: string): Value {\n\t\tif (this.index < this.arena.length) {\n\t\t\tconst v = this.arena[this.index++];\n\t\t\tv.recycle(type, value, unit);\n\t\t\treturn v;\n\t\t}\n\t\t// Arena overflow, allocate fresh (rare, only for very complex expressions)\n\t\tconst v = new Value(type, value, unit);\n\t\tthis.arena.push(v);\n\t\tthis.index++;\n\t\treturn v;\n\t}\n\n\t/**\n\t * Reset for the next scroll frame, releasing a block the last frame turned\n\t * out not to need.\n\t *\n\t * Still O(1) in the ordinary case: one comparison against what the cycle\n\t * that just ended used, and the truncation only on the frame after an\n\t * unusually expensive one. Reading the usage here rather than at\n\t * `disableValueArena()` is what makes the policy \"the first cycle that does\n\t * not need the block gives it back\", which is the first thing a host does\n\t * after the line that grew it.\n\t */\n\treset(): void {\n\t\tconst usedLastCycle = this.index;\n\t\tthis.index = 0;\n\t\tif (this.arena.length <= this.initialSize) return;\n\t\tif (this.arena.length <= usedLastCycle * ValueArena.SHRINK_WHEN_HOLDING_TIMES) return;\n\t\t// Never below the initial block, and never above what is already held,\n\t\t// so this only ever truncates.\n\t\tthis.arena.length = Math.max(this.initialSize, usedLastCycle * ValueArena.KEEP_TIMES);\n\t}\n\n\t/** Current arena utilization (for diagnostics). */\n\tget usage(): number { return this.index; }\n\tget capacity(): number { return this.arena.length; }\n}\n\n// Module-level arena toggle. Single-threaded JS, so global state is safe.\n// The arena is ONLY active during Tier 2 scroll execution, the ThreeTierEvaluator\n// enables it before evaluating visible lines and disables it after.\n//\n// The arena INSTANCE survives disable(): constructing a ValueArena allocates\n// its whole initial block (512 Values), so dropping it on every disable would\n// pay that allocation cost again on the next enable, more garbage than the\n// arena saves. Instead, an `_arenaActive` flag gates use of the long-lived\n// instance; enable() just resets the bump index.\nlet _arena: ValueArena | null = null;\nlet _arenaActive = false;\n\n/** Enable the Value arena for zero-allocation scroll execution. */\nexport function enableValueArena(size?: number): ValueArena {\n\tif (!_arena) _arena = new ValueArena(size);\n\t_arena.reset();\n\t_arenaActive = true;\n\treturn _arena;\n}\n\n/** Disable the arena (returns to normal GC-collected allocation). */\nexport function disableValueArena(): void {\n\t_arenaActive = false;\n}\n\n/** Check if arena is active (used by STORE_VAR / HALT to decide cloning). */\nexport function isArenaActive(): boolean {\n\treturn _arenaActive;\n}\n\n/**\n * Allocate a Value that persists beyond the current arena cycle.\n * Used for values stored in variables (STORE_VAR) and final expression results\n * (HALT return), these must survive arena.reset() in the next scroll frame.\n */\nexport function persistentValue(v: Value): Value {\n\tconst p = new Value(v.type, v.value, v.unit);\n\t// The exact sidecar has to survive being stored in a variable, or a\n\t// referenced money value would silently drop back to the double: \"a = $0.10,\n\t// b = $0.20, a + b\" must still be exact across the STORE_VAR round trip.\n\tif (v.exact !== undefined) p.exact = v.exact;\n\t// The rational sidecar survives the same round trip, so \"a = 1/3, a + a + a\"\n\t// is exactly 1 rather than the drifted double a stored fraction would carry.\n\tif (v.rational !== undefined) p.rational = v.rational;\n\t// The uncertainty sidecar survives too, so \"a = 12.3 +/- 0.5, a * 4\" still\n\t// propagates the tolerance across the STORE_VAR round trip.\n\tif (v.uncertainty !== undefined) p.uncertainty = v.uncertainty;\n\treturn p;\n}\n\n// ── Dev-mode immutability guard (Part II, L5, Value model hardening) ──\n//\n// Value is documented immutable by convention, not enforcement: the arena\n// mutates objects in place via recycle() (by design, for Tier-2 scroll\n// performance), so Value can never be unconditionally frozen. This guard\n// freezes a Value ONLY when it is safe to do so, i.e. NOT while the arena\n// is active, since an arena-active Value may still be recycled later in\n// the same scroll frame. It is a no-op outside development builds (matches\n// the existing `process.env.NODE_ENV === \"development\"` convention used by\n// the app-layer logger) so there is zero runtime cost in production.\nconst isDevelopmentBuild = process.env.NODE_ENV === \"development\";\n\n/**\n * Freeze a Value in development builds, catching accidental external\n * mutation of \"immutable\" results early. Safe to call unconditionally\n * it is a no-op in production and a no-op whenever the arena is active\n * (an arena-active Value may still be recycle()'d before this scroll\n * frame ends, and freezing it would make recycle() throw).\n *\n * Intended for values leaving a public evaluation boundary\n * (ExpressionEngine.evaluateLine* / evaluateExpression), not for values\n * still moving through internal VM/arena machinery.\n */\nexport function freezeIfDev<T extends Value>(value: T): T {\n\tif (isDevelopmentBuild && !isArenaActive()) {\n\t\t// toNumber() lazily memoizes _cachedNumber for bigint/string values\n\t\t// (Number/Hex are already eagerly cached by the constructor), warm\n\t\t// it now so a later toNumber() call on the frozen object doesn't\n\t\t// try to write to a frozen field.\n\t\tvalue.toNumber();\n\t\tObject.freeze(value);\n\t}\n\treturn value;\n}\n\n/**\n * Universal runtime value for the solve-js VM.\n *\n * Carries a {@link ValueType} discriminant, a polymorphic `value` payload,\n * and an optional `unit` string (for UoM values). Treated as immutable after\n * construction, the arena reuses objects internally via `recycle()`, but\n * external code should never mutate Value fields.\n *\n * A cached `_cachedNumber` avoids repeated `toNumber()` computation on\n * hot paths (ADD/SUB/MUL in the VM dispatch loop).\n */\nexport class Value {\n\t// Cached numeric representation, computed once on first toNumber() call.\n\t// Cleared on recycle() when the arena reuses this Value for a new value.\n\tprivate _cachedNumber: number | undefined;\n\n\t// Fields are NOT readonly, the arena reuses Value objects by calling\n\t// recycle() which overwrites all fields. External code should treat Values\n\t// as immutable after construction (arena handles mutation internally).\n\tpublic type: ValueType;\n\tpublic value: number | bigint | string | boolean | MatrixData | RangeData | ColourData | SplitData | ChartData | IpCidrData | SymbolicNode;\n\tpublic unit?: string;\n\t/** Set by async resolvers when a fetch timed out, the result is a fallback (typically 0). */\n\tpublic timedOut?: boolean;\n\t/**\n\t * The exact base-ten value this Value stands for, when it has one.\n\t *\n\t * A sidecar rather than a replacement for `value`: money and decimal-point\n\t * literals set it to a {@link DecimalData} so that same-currency arithmetic\n\t * and display can be exact (\"$0.10 + $0.20\" is \"$0.30\", not\n\t * \"$0.30000000000000004\"), while `value` stays the nearest double so every\n\t * existing consumer that reads `.value` or `toNumber()` is unchanged. The\n\t * plain Number-times-Number fast paths deliberately ignore it, which is why\n\t * a bare \"0.1 + 0.2\" still answers the double it always did: exactness is\n\t * carried only where a unit-bearing operand asks for it. Cleared by\n\t * {@link recycle} so a reused arena Value never inherits a stale exact.\n\t */\n\tpublic exact?: DecimalData;\n\t/**\n\t * The exact rational value this Value stands for, when it has one.\n\t *\n\t * The second sidecar, the same shape as {@link exact} and for the same\n\t * reason: a fraction has no exact base-ten form (`1/3` is not any decimal),\n\t * so exact fraction arithmetic needs a numerator/denominator pair rather\n\t * than a coefficient and a scale. Integer division seeds it (\"1/3\" carries\n\t * the {@link Rational} 1/3), and `+`, `-`, `*`, `/` between rational-bearing\n\t * numbers keep it reduced, so \"1/49 * 49\" is exactly 1 and \"5/6 - 1/6 - 1/6\n\t * - 1/6 - 1/6 - 1/6\" is exactly 0 rather than the 1.6e-16 the doubles drift\n\t * to. `value` still holds the nearest double, recomputed from the exact\n\t * rational so accumulation error never creeps in, which is why the default\n\t * display and every `.value`/`toNumber()` reader are unchanged. Only a\n\t * fraction written with \"/\" carries it, so a decimal literal (\"0.1\") and a\n\t * transcendental result (\"sqrt(2)\") stay the plain doubles they were.\n\t * Cleared by {@link recycle} alongside {@link exact}.\n\t */\n\tpublic rational?: Rational;\n\t/**\n\t * The one-sigma uncertainty (standard error) this value carries, when it\n\t * has one.\n\t *\n\t * The third sidecar, the same shape as {@link exact} and {@link rational}\n\t * and for the same reason: a measurement written `12.3 ± 0.5` is still the\n\t * number 12.3 everywhere it is read as one, so the type stays\n\t * {@link ValueType.Number} and `value` stays the center, while this non\n\t * negative field carries the tolerance. The `±` (or ASCII `+/-`) operator\n\t * seeds it, and `+`, `-`, `*`, `/` propagate it in quadrature for\n\t * independent errors (see `vm/VMConversion.ts`'s `uncertainOp`). Everything\n\t * else (a comparison, a transcendental function, a unit conversion) reads\n\t * the center through `toNumber()` and drops the tolerance, which is why a\n\t * value with no uncertainty behaves exactly as a plain number always did.\n\t * Cleared by {@link recycle} alongside the other two sidecars.\n\t */\n\tpublic uncertainty?: number;\n\t/**\n\t * The number of decimal places this value should DISPLAY at, when it has been\n\t * given an explicit precision.\n\t *\n\t * A display sidecar, not a value one: `value` is unchanged, so every\n\t * `.value`/`toNumber()` reader and all arithmetic behave exactly as before,\n\t * and a value with no `decimalPlaces` formats the way it always did (the\n\t * global two-place default with trailing zeros trimmed). It is set only by an\n\t * explicit precision request, `<x> to N dp` and `round(x, N)`, so that\n\t * `3.14159 to 4 dp` shows `3.1416` and `1.5 to 2 dp` shows `1.50` rather than\n\t * the value being rounded but then displayed at the default two places. It is\n\t * NOT propagated through arithmetic (a later `+ 1` re-decides precision),\n\t * which is why nothing that did not ask for a precision is affected. Cleared\n\t * by {@link recycle} alongside the other sidecars.\n\t */\n\tpublic decimalPlaces?: number;\n\n\tconstructor(\n\t\ttype: ValueType,\n\t\tvalue: number | bigint | string | boolean | MatrixData | RangeData | ColourData | SplitData | ChartData | IpCidrData | SymbolicNode,\n\t\tunit?: string\n\t) {\n\t\tthis.type = type;\n\t\tthis.value = value;\n\t\tthis.unit = unit;\n\t\t// Eagerly cache for Number and Hex types (the most common case).\n\t\t// This avoids a method call + type-check on first toNumber().\n\t\tif (typeof value === 'number') {\n\t\t\tthis._cachedNumber = value;\n\t\t}\n\t}\n\n\t/**\n\t * Phase 5.3: Reset all fields for arena reuse.\n\t * Called by ValueArena.acquire(), zero allocation, just field assignment.\n\t */\n\trecycle(type: ValueType, value: number | bigint | string | boolean | MatrixData | RangeData | ColourData | SplitData | ChartData | IpCidrData | SymbolicNode, unit?: string): void {\n\t\tthis.type = type;\n\t\tthis.value = value;\n\t\tthis.unit = unit;\n\t\t// Clear cache, value changed, cached number is stale.\n\t\t// Re-eager-cache for Number type (most common).\n\t\tthis._cachedNumber = typeof value === 'number' ? value : undefined;\n\t\t// Clear timeout flag, recycled Values shouldn't inherit stale metadata.\n\t\tthis.timedOut = undefined;\n\t\t// Clear the exact sidecar for the same reason: a reused Value that once\n\t\t// held money must not carry that money's decimal into a plain number.\n\t\tthis.exact = undefined;\n\t\t// The rational sidecar clears with it: a reused Value that once held a\n\t\t// fraction must not carry that fraction into a plain number.\n\t\tthis.rational = undefined;\n\t\t// The uncertainty sidecar clears the same way: a reused Value that once\n\t\t// carried a tolerance must not lend it to a plain number.\n\t\tthis.uncertainty = undefined;\n\t\t// The display-precision sidecar clears too: a reused Value that once had\n\t\t// an explicit `to N dp` must not display a plain number at that precision.\n\t\tthis.decimalPlaces = undefined;\n\t}\n\n\tisNumber(): this is Value & { value: number } {\n\t\treturn this.type === ValueType.Number;\n\t}\n\n\tisHex(): this is Value & { value: number } {\n\t\treturn this.type === ValueType.Hex;\n\t}\n\n\tisBigInt(): this is Value & { value: bigint } {\n\t\treturn this.type === ValueType.BigInt;\n\t}\n\n\tisString(): this is Value & { value: string } {\n\t\treturn this.type === ValueType.String;\n\t}\n\n\tisMatrix(): this is Value & { value: MatrixData } {\n\t\treturn this.type === ValueType.Matrix;\n\t}\n\n\t/** A Matrix shaped like a vector, 1×N (row) or N×1 (column). */\n\tisVectorShape(): boolean {\n\t\tif (this.type !== ValueType.Matrix) return false;\n\t\tconst m = this.value as MatrixData;\n\t\treturn m.rows === 1 || m.cols === 1;\n\t}\n\n\tisRange(): this is Value & { value: RangeData } {\n\t\treturn this.type === ValueType.Range;\n\t}\n\n\tisColour(): this is Value & { value: ColourData } {\n\t\treturn this.type === ValueType.Colour;\n\t}\n\n\tisChart(): this is Value & { value: ChartData } {\n\t\treturn this.type === ValueType.Chart;\n\t}\n\n\tisIpCidr(): this is Value & { value: IpCidrData } {\n\t\treturn this.type === ValueType.IpCidr;\n\t}\n\n\tisSymbolic(): this is Value & { value: SymbolicNode } {\n\t\treturn this.type === ValueType.Symbolic;\n\t}\n\n\t/**\n\t * An Error value: a fault carrying a code and message, propagated through the\n\t * DAG when a plugin or opcode cannot produce a quantity.\n\t *\n\t * An Error reads as the number 0 through {@link toNumber}, so a numeric\n\t * consumer that does not check this first cannot tell the fault apart from a\n\t * real zero: exactly the silently-wrong result the engine guards against\n\t * internally with {@link faultedOperand}. A host reading a live {@link Value}\n\t * off a result should branch on this (or {@link isFault}) before trusting the\n\t * number, and read {@link errorCode}/{@link errorMessage} for the detail.\n\t */\n\tisError(): boolean {\n\t\treturn this.type === ValueType.Error;\n\t}\n\n\t/**\n\t * A Pending value: an async result that has not yet resolved, holding the\n\t * query key it is waiting on. Reads as 0 through {@link toNumber}, the same\n\t * caveat as {@link isError}: a settled value arrives on a later evaluation.\n\t */\n\tisPending(): boolean {\n\t\treturn this.type === ValueType.Pending;\n\t}\n\n\t/**\n\t * Either fault, an Error or a Pending: the single predicate to check before\n\t * trusting {@link toNumber}. It mirrors the internal {@link faultedOperand}\n\t * rule that every opcode applies to its operands, so a host reading a result\n\t * makes the same distinction the engine does rather than computing with a\n\t * zero it cannot tell from a real one.\n\t */\n\tisFault(): boolean {\n\t\treturn this.type === ValueType.Error || this.type === ValueType.Pending;\n\t}\n\n\t/**\n\t * The stable {@link ErrorFactory} code of an Error value, else `undefined`.\n\t *\n\t * The code is the machine-branchable identifier (the message is the\n\t * human-facing text, {@link errorMessage}). It reads from the same slot\n\t * {@link errorValue} writes, so it is defined for exactly the values\n\t * {@link isError} accepts and `undefined` for every other type.\n\t */\n\tget errorCode(): string | undefined {\n\t\treturn this.type === ValueType.Error ? (this.value as string) : undefined;\n\t}\n\n\t/**\n\t * The human-facing message of an Error value, else `undefined`. Paired with\n\t * {@link errorCode}, which carries the branchable identifier.\n\t */\n\tget errorMessage(): string | undefined {\n\t\treturn this.type === ValueType.Error ? this.unit : undefined;\n\t}\n\n\ttoNumber(): number {\n\t\t// Pending/Error have no numeric representation at all, 0 (established\n\t\t// convention). A genuinely multi-cell Matrix has no single numeric\n\t\t// representation either (real callers branch on `.isMatrix()` BEFORE\n\t\t// reaching this fallback. See e.g. VM.ts's MUL/comparison dispatch)\n\t\t// but a 1x1 Matrix, the shape `float(x)`'s legacy sugar produces, see\n\t\t// packages/vector/parselets/FloatParselet.ts, IS a scalar in every\n\t\t// meaningful sense, so it degrades to that single cell's numeric value\n\t\t// rather than 0 (this exact case used to work \"by accident\" pre-Matrix,\n\t\t// since `parseFloat([2].toString())` happened to yield `2`).\n\t\tif (this.type === ValueType.Pending) return 0;\n\t\tif (this.type === ValueType.Error) return 0;\n\t\tif (this.type === ValueType.Matrix) {\n\t\t\tconst m = this.value as MatrixData;\n\t\t\tif (m.rows === 1 && m.cols === 1 && typeof m.data[0] === \"number\") return m.data[0];\n\t\t\treturn 0;\n\t\t}\n\t\tif (this.type === ValueType.Range) return 0;\n\t\t// A colour is a struct of channels, not a scalar; like Matrix/Range it has\n\t\t// no single numeric reading. Callers branch on `.isColour()` first.\n\t\tif (this.type === ValueType.Colour) return 0;\n\t\t// A chart is a set of points, not a scalar; callers branch on `.isChart()`.\n\t\tif (this.type === ValueType.Chart) return 0;\n\t\t// An IP/CIDR reads as its 32-bit address where a number is wanted (`as int`).\n\t\tif (this.type === ValueType.IpCidr) return (this.value as IpCidrData).addr ?? 0;\n\t\t// A split is a structured multi-share result; its scalar reading is the\n\t\t// \"each\" (base) share, so a numeric consumer or the worker DTO's number\n\t\t// field still gets a sensible value where a caller does not branch first.\n\t\tif (this.type === ValueType.Split) return (this.value as SplitData).shares[0].value;\n\t\t// A symbolic expression has no single concrete numeric value by\n\t\t// definition (it's a free-variable formula), 0, matching the\n\t\t// Pending/Error/Range convention. Real callers branch on\n\t\t// `.isSymbolic()` BEFORE reaching this fallback (see\n\t\t// `VMConversion.ts`'s `binaryOp()`).\n\t\tif (this.type === ValueType.Symbolic) return 0;\n\t\t// A boolean has an obvious numeric reading and no branch used to give it\n\t\t// one, so it fell through to `parseFloat(true)` -> NaN -> 0, and BOTH\n\t\t// booleans read as zero: `true == false` answered true, and every\n\t\t// arithmetic path that mixes a boolean with a number (\"true and 5\")\n\t\t// contributed nothing. 1/0 is the reading every language with a numeric\n\t\t// boolean coercion uses, and the one `if 1 then` already implies.\n\t\tif (this.type === ValueType.Boolean) return this.value === true ? 1 : 0;\n\n\t\tif (this._cachedNumber !== undefined) return this._cachedNumber;\n\n\t\tif (typeof this.value === 'bigint') {\n\t\t\tthis._cachedNumber = Number(this.value);\n\t\t\treturn this._cachedNumber;\n\t\t}\n\t\t// Prevent silent NaN propagation from non-numeric strings\n\t\tconst result = parseFloat(this.value as string);\n\t\tthis._cachedNumber = isNaN(result) ? 0 : result;\n\t\treturn this._cachedNumber;\n\t}\n\n\tisNaN(): boolean {\n\t\tif (this.type === ValueType.Pending) return false;\n\t\tif (this.type === ValueType.Error) return false;\n\t\tif (this.type === ValueType.Matrix) {\n\t\t\tconst m = this.value as MatrixData;\n\t\t\tif (m.rows === 1 && m.cols === 1 && typeof m.data[0] === \"number\") return isNaN(m.data[0]);\n\t\t\treturn false;\n\t\t}\n\t\tif (this.type === ValueType.Range) return false;\n\t\tif (this.type === ValueType.Colour) return false;\n\t\tif (this.type === ValueType.Split) return false;\n\t\tif (this.type === ValueType.Chart) return false;\n\t\tif (this.type === ValueType.IpCidr) return false;\n\t\tif (this.type === ValueType.Symbolic) return false;\n\t\t// Matches toNumber()'s boolean reading above. Without this a Boolean\n\t\t// reached the string branch at the bottom and `parseFloat(true)` made\n\t\t// every boolean report itself as NaN.\n\t\tif (this.type === ValueType.Boolean) return false;\n\t\tif (typeof this.value === 'number') return isNaN(this.value);\n\t\tif (typeof this.value === 'bigint') return false;\n\t\treturn isNaN(parseFloat(this.value as string));\n\t}\n}\n\n/**\n * Create a Number-typed Value. Uses the arena when active for zero-allocation.\n * This is the most common factory, over 90% of all Value creations.\n */\nexport function numberValue(n: number): Value {\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.Number, n);\n\treturn new Value(ValueType.Number, n);\n}\n\n/**\n * A Number that also carries the exact decimal it was written as.\n *\n * The type stays {@link ValueType.Number} and `value` stays the nearest double,\n * so this Value behaves exactly like any other number everywhere it is read as\n * one. The `exact` sidecar only matters when it later meets a currency: that is\n * what lets \"$0.70 * 1.10\" be exact while \"0.1 + 0.2\" stays the double it was.\n * Decimal-point literals are compiled to this (see the PUSH_DECIMAL opcode).\n */\nexport function numberValueExact(n: number, exact: DecimalData): Value {\n\tconst v = numberValue(n);\n\tv.exact = exact;\n\treturn v;\n}\n\n/**\n * A Number that also carries the exact rational it evaluates to.\n *\n * The rational counterpart of {@link numberValueExact}: the type stays\n * {@link ValueType.Number} and `value` stays the nearest double (recomputed\n * from the rational, so a chain of fraction operations never accumulates\n * float error), so this reads as an ordinary number everywhere. The `rational`\n * sidecar is what keeps the next fraction operation and any `as fraction`\n * exact. Integer division produces this (see the DIV opcode).\n */\nexport function numberValueRational(n: number, rational: Rational): Value {\n\tconst v = numberValue(n);\n\tv.rational = rational;\n\treturn v;\n}\n\n/**\n * A Number that also carries a one-sigma uncertainty (standard error).\n *\n * The uncertainty counterpart of {@link numberValueExact}: the type stays\n * {@link ValueType.Number} and `value` stays the center, so this reads as an\n * ordinary number everywhere. The `uncertainty` sidecar is what lets `+`, `-`,\n * `*`, `/` propagate the tolerance in quadrature. The `±` operator produces\n * this (see the MAKE_UNCERTAIN opcode), as does any of those four ops when an\n * operand already carries one. The magnitude is stored as given, callers pass a\n * non-negative value (`Math.abs` at the seam, quadrature results are already\n * non-negative).\n */\nexport function numberValueUncertain(n: number, uncertainty: number): Value {\n\tconst v = numberValue(n);\n\tv.uncertainty = uncertainty;\n\treturn v;\n}\n\n/** Which base a {@link ValueType.Hex} value is displayed in. */\nexport type DisplayBase = \"hex\" | \"bin\" | \"oct\";\n\n/**\n * Create a Hex-typed Value: a **number** that displays in another base.\n *\n * The type is numeric on purpose, and that is the whole point of it. A base is\n * a way of writing a quantity, not a different kind of quantity, so `0xFF + 1`\n * has to be 256. Returning a string instead makes it 1, because a string reads\n * as zero in arithmetic, and nothing about that failure is visible at the point\n * of use.\n *\n * @param n - The number itself, in full precision. A `bigint` is accepted for\n * the same reason the type is numeric at all: `12345678901234567890n as hex`\n * has an exact answer, and forcing it through a double first rendered\n * 0xAB54A98CEB1F0800 for a value ending 0AD2.\n * @param base - How to display it, defaulting to hexadecimal. Carried in the\n * `unit` slot, which is free for this type.\n */\nexport function hexValue(n: number | bigint, base: DisplayBase = \"hex\"): Value {\n\tconst tag = base === \"hex\" ? undefined : base;\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.Hex, n, tag);\n\treturn new Value(ValueType.Hex, n, tag);\n}\n\n/** Create a BigInt-typed Value (arbitrary-precision integer). */\nexport function bigIntValue(n: bigint): Value {\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.BigInt, n);\n\treturn new Value(ValueType.BigInt, n);\n}\n\n/** Create a String-typed Value. */\nexport function stringValue(s: string): Value {\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.String, s);\n\treturn new Value(ValueType.String, s);\n}\n\n/** Create a Unit-of-Measurement Value (typed number with unit annotation). */\nexport function uomValue(n: number, unit: string): Value {\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.Uom, n, unit);\n\treturn new Value(ValueType.Uom, n, unit);\n}\n\n/**\n * A unit-of-measurement Value that also carries an exact decimal magnitude.\n *\n * This is how money keeps its precision: `value` is the nearest double (so\n * `toNumber()` and every existing Uom path are unchanged), and `exact` is the\n * decimal the amount really is. Same-currency arithmetic reads `exact` to stay\n * exact, and the formatter reads it to round a half-cent the way a ledger does\n * rather than the way `toFixed` does on a double.\n */\nexport function uomValueExact(n: number, unit: string, exact: DecimalData): Value {\n\tconst v = uomValue(n, unit);\n\tv.exact = exact;\n\treturn v;\n}\n\n// ── Rate, \"quantity per unit of something\" (SoulverCore: `$99/week`\n// `3 hours/day`, `30 fps`). Represented as a `ValueType.Uom` (no new\n// ValueType, a rate IS a unit-of-measurement, just a compound one) whose\n// `unit` string is `\"<numerator>/<denominator>\"`. The numerator is an\n// opaque label (may be a real convertible unit like \"USD\"/\"km\", or a bare\n// tag like \"frames\" that the `convert` package doesn't know about, rate\n// arithmetic never needs to convert the numerator, only compare it for\n// equality when combining two rates). The denominator MUST be a unit\n// `convertUnit()`/`getMeasure()` (uom/UomConverter.ts) recognizes, since\n// that's the part rate arithmetic actually rescales. See `vm/VM.ts`'s\n// `RATE_CONVERT`/`RATE_MUL`/`RATE_DIV` opcodes for the operations built on\n// this representation.\n\n/** Create a Rate value: `magnitude` of `numeratorUnit` per one `denominatorUnit`. */\nexport function rateValue(magnitude: number, numeratorUnit: string, denominatorUnit: string): Value {\n\treturn uomValue(magnitude, `${numeratorUnit}/${denominatorUnit}`);\n}\n\n/** Whether `unit` is a compound rate unit (`\"X/Y\"`) rather than a plain unit. */\nexport function isRateUnit(unit: string | undefined): unit is string {\n\treturn typeof unit === \"string\" && unit.includes(\"/\");\n}\n\n/**\n * Split a rate unit string into its numerator/denominator halves.\n * @throws if `unit` isn't a rate unit, check with {@link isRateUnit} first.\n */\nexport function splitRateUnit(unit: string): { numerator: string; denominator: string } {\n\tconst idx = unit.indexOf(\"/\");\n\tif (idx < 0) {\n\t\tthrow ErrorFactory.internal(\n\t\t\t\"INVALID_RATE_UNIT\",\n\t\t\t`splitRateUnit: \"${unit}\" is not a rate unit (expected \"numerator/denominator\")`,\n\t\t\t{ unit },\n\t\t);\n\t}\n\treturn { numerator: unit.slice(0, idx), denominator: unit.slice(idx + 1) };\n}\n\n/** Join a numerator/denominator pair back into a rate unit string. */\nexport function joinRateUnit(numeratorUnit: string, denominatorUnit: string): string {\n\treturn `${numeratorUnit}/${denominatorUnit}`;\n}\n\n// ── Video timecode, \"HH:MM:SS:FF at a given fps\" (SoulverCore: video\n// editing timecode literals, e.g. `01:02:03:04 at 30fps`). Represented the\n// same way Rate is above: NOT a new ValueType, just a `ValueType.Uom` whose\n// `unit` string is `\"timecode@<fps>\"` and whose numeric `value` is the\n// TOTAL FRAME COUNT since 00:00:00:00 at that fps, e.g. \"00:00:01:00 at\n// 30fps\" is `Uom(30, \"timecode@30\")`.\n//\n// Storing the total frame count (rather than four separate H/M/S/F fields)\n// means ordinary integer addition/subtraction on the numeric value is\n// ALREADY correct carry/borrow-aware arithmetic with zero extra logic\n// e.g. \"frame 29 + 2 frames\" at 30fps is just `29 + 2 = 31`, and 31 total\n// frames at 30fps IS frame 1 of the next second, with no explicit carry\n// step required. Carry/borrow only needs to be reconstructed when\n// converting a total frame count back into HH:MM:SS:FF display notation\n// see `packages/time/timecode/TimecodeMath.ts`'s `framesToTimecodeString()`.\n// See `vm/VM.ts`'s ADD/SUB dispatch for the arithmetic built on this\n// representation (timecode + frames, + duration, + timecode, - timecode).\n\nconst TIMECODE_UNIT_PREFIX = \"timecode@\";\n\n/** Build a timecode Uom unit string embedding its frame rate, e.g. `timecodeUnit(30)` -> `\"timecode@30\"`. */\nexport function timecodeUnit(fps: number): string {\n\treturn `${TIMECODE_UNIT_PREFIX}${fps}`;\n}\n\n/** Whether `unit` is a compound video-timecode unit (`\"timecode@<fps>\"`). */\nexport function isTimecodeUnit(unit: string | undefined): unit is string {\n\treturn typeof unit === \"string\" && unit.startsWith(TIMECODE_UNIT_PREFIX);\n}\n\n/**\n * Extract the fps from a timecode unit string.\n * @throws if `unit` isn't a timecode unit, check with {@link isTimecodeUnit} first.\n */\nexport function timecodeFps(unit: string): number {\n\tif (!isTimecodeUnit(unit)) {\n\t\tthrow ErrorFactory.internal(\n\t\t\t\"INVALID_TIMECODE_UNIT\",\n\t\t\t`timecodeFps: \"${unit}\" is not a timecode unit (expected \"timecode@<fps>\")`,\n\t\t\t{ unit },\n\t\t);\n\t}\n\treturn parseFloat(unit.slice(TIMECODE_UNIT_PREFIX.length));\n}\n\n/**\n * Create a Matrix value from an explicit shape + column-major data array.\n * `data.length` must equal `rows*cols`, callers building a matrix from\n * row-major source syntax (e.g. the `[1,2;3,4]` literal) must transpose\n * into column-major order before calling this; see `MatrixOps.ts`'s\n * `rowMajorToColumnMajor()`.\n */\nexport function matrixValue(rows: number, cols: number, data: readonly MatrixEntry[]): Value {\n\t// Every matrix in the engine is born here, which makes this the one place\n\t// that can charge for one without each producer having to remember to. The\n\t// charge lands after `data` exists, so it is a backstop rather than a\n\t// refusal: it cannot stop a single allocation that is already fatal (the\n\t// sites whose size is knowable in advance charge before allocating, see\n\t// `vm/VM.ts`'s matrix cases), but it does stop the second one, and it means\n\t// an opcode added later inherits the bound without being told about it.\n\t// Free in relative terms: the hasSymbolic scan just below is already O(n)\n\t// over the same cells.\n\tchargeAllocation(data.length, \"matrix cells\");\n\t// A SymbolicNode cell is the only object-typed MatrixEntry variant\n\t// (number/boolean are primitives), a cheap, always-correct way to\n\t// derive hasSymbolic without asking every caller to track it by hand.\n\t// The `\"kind\" in cell` half is a tripwire, not redundancy. MatrixEntry is\n\t// `number | boolean | SymbolicNode`, so an object cell should always be a\n\t// node; requiring the discriminant means a Rational that escaped\n\t// MatrixOps.ts's symbolicToEntry() shows up as a wrong result rather than as\n\t// a matrix that silently believes it is symbolic.\n\tconst hasSymbolic = data.some(cell => typeof cell === \"object\" && cell !== null && \"kind\" in cell);\n\tconst m: MatrixData = { rows, cols, data, hasSymbolic };\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.Matrix, m);\n\treturn new Value(ValueType.Matrix, m);\n}\n\n/** A 1×N row-vector Matrix, row-major and column-major storage are identical for a single row. */\nexport function rowVectorValue(data: readonly number[]): Value {\n\treturn matrixValue(1, data.length, data);\n}\n\n/** An N×1 column-vector Matrix, row-major and column-major storage are identical for a single column. */\nexport function colVectorValue(data: readonly number[]): Value {\n\treturn matrixValue(data.length, 1, data);\n}\n\n/** Create a Range value, a first-class integer range `min:max`, both bounds inclusive. */\nexport function rangeValue(min: number, max: number): Value {\n\tconst r: RangeData = { min, max };\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.Range, r);\n\treturn new Value(ValueType.Range, r);\n}\n\n/**\n * Create a Colour value from canonical sRGB channels plus a display format.\n * Arena-backed like the other synchronous factories; the `ColourData` struct in\n * the `value` slot is immutable, so arena recycle is safe with no extra clearing\n * (matching {@link matrixValue}/{@link rangeValue}).\n */\nexport function colourValue(c: ColourData): Value {\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.Colour, c);\n\treturn new Value(ValueType.Colour, c);\n}\n\n/**\n * Create a Split value from its structured per-share payload. Arena-backed like\n * the other synchronous factories; the {@link SplitData} struct in the `value`\n * slot is immutable, so arena recycle is safe with no extra clearing (matching\n * {@link colourValue}/{@link rangeValue}).\n */\nexport function splitValue(data: SplitData): Value {\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.Split, data);\n\treturn new Value(ValueType.Split, data);\n}\n\n/** Create a Chart value from its specification. Arena-backed like the other\n * struct factories; the {@link ChartData} in the `value` slot is immutable, so\n * arena recycle is safe with no extra clearing. */\nexport function chartValue(data: ChartData): Value {\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.Chart, data);\n\treturn new Value(ValueType.Chart, data);\n}\n\n/** Create an IPv4 address/subnet Value. Arena-backed; the {@link IpCidrData} is immutable. */\nexport function ipCidrValue(data: IpCidrData): Value {\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.IpCidr, data);\n\treturn new Value(ValueType.IpCidr, data);\n}\n\n/** Create a Symbolic value, a free-variable algebraic expression tree (`symbolic/SymbolicNode.ts`'s `SymbolicNode`), not a concrete number. */\nexport function symbolicValue(node: SymbolicNode): Value {\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.Symbolic, node);\n\treturn new Value(ValueType.Symbolic, node);\n}\n\n\n\n/** Create a Boolean-typed Value. */\nexport function boolValue(b: boolean): Value {\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.Boolean, b);\n\treturn new Value(ValueType.Boolean, b);\n}\n\n/** Create a Datetime-typed Value (Unix timestamp in milliseconds). */\nexport function datetimeValue(n: number): Value {\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.Datetime, n);\n\treturn new Value(ValueType.Datetime, n);\n}\n\n/** Create a Percentage-typed Value (stored as fraction, e.g. 0.5 for 50%). */\nexport function percentageValue(n: number): Value {\n\tif (_arenaActive && _arena) return _arena.acquire(ValueType.Percentage, n);\n\treturn new Value(ValueType.Percentage, n);\n}\n\n/**\n * Create a Pending value, signals that an async result is not yet resolved.\n * The value field stores the queryKey string for deduplication and diagnostics.\n * Pending values should NEVER be stored in the arena (they persist across\n * scroll frames until resolution completes).\n */\nexport function pendingValue(queryKey: string): Value {\n\treturn new Value(ValueType.Pending, queryKey);\n}\n\n/**\n * Create an Error value, propagated through the DAG when a plugin raises an error.\n * The value field stores the EngineError code, unit stores the message.\n * Downstream consumers (lines that depend on errored data) bubble this up.\n * Should NEVER be stored in the arena.\n */\nexport function errorValue(code: string, message: string): Value {\n\treturn new Value(ValueType.Error, code, message);\n}\n\n/**\n * The first operand carrying a fault rather than a quantity, if any does.\n *\n * `Error` and `Pending` both read as the number 0 through {@link Value.toNumber},\n * by a convention that only holds up as long as nothing asks. Every opcode and\n * builtin that reaches for an operand's number without asking its type first\n * therefore computes with a zero it cannot tell apart from a real one, and\n * hands back an answer dressed in whatever type it was going to produce\n * anyway. That is how `(5 kg to m) to s` came to answer `0.00 s`: the failed\n * conversion is an Error, the second conversion read it as zero, and the unit\n * the reader asked for made the result look like a conversion that worked.\n *\n * Operands are checked left to right, matching evaluation order, and the\n * faulted Value is returned AS IT IS rather than replaced with a fresh one, so\n * the original code and message (or the pending query key) reach the caller\n * unchanged. `binaryOp` (vm/VMConversion.ts) and `OpCode.EXP` already did this\n * inline; this is the same rule for every other site, in one place so a site\n * added later can adopt it in a line.\n *\n * Three operands cover every call site in the VM (`MAT_INDEX2` and `MAT_SLICE`\n * are the widest). A variadic signature would allocate an arguments array on\n * paths that run per instruction; see {@link faultedIn} for the list case.\n *\n * @returns The faulted operand, or `null` when all of them carry a value.\n */\nexport function faultedOperand(a: Value, b?: Value, c?: Value): Value | null {\n\tif (a.type === ValueType.Error || a.type === ValueType.Pending) return a;\n\tif (b !== undefined && (b.type === ValueType.Error || b.type === ValueType.Pending)) return b;\n\tif (c !== undefined && (c.type === ValueType.Error || c.type === ValueType.Pending)) return c;\n\treturn null;\n}\n\n/**\n * {@link faultedOperand} over an already-built list, for the call sites that\n * have one (a builtin's arguments, a plugin function's).\n *\n * @returns The first faulted element, or `null` when every element carries a value.\n */\nexport function faultedIn(values: readonly Value[]): Value | null {\n\tfor (let i = 0; i < values.length; i++) {\n\t\tconst v = values[i];\n\t\tif (v.type === ValueType.Error || v.type === ValueType.Pending) return v;\n\t}\n\treturn null;\n}\n"]}

package/dist/{chunk-VBSMA7WJ.cjs → chunk-ABVDKMNF.cjs}

@@ -1,2 +1,2 @@
-'use strict';var A=(_=>(_[_.NOP=0]="NOP",_[_.HALT=1]="HALT",_[_.SWAP=2]="SWAP",_[_.DUP=3]="DUP",_[_.PUSH_NUMBER=10]="PUSH_NUMBER",_[_.PUSH_BIGINT=11]="PUSH_BIGINT",_[_.PUSH_HEX=12]="PUSH_HEX",_[_.PUSH_STRING=13]="PUSH_STRING",_[_.PUSH_BOOLEAN=14]="PUSH_BOOLEAN",_[_.PUSH_VARIABLE=15]="PUSH_VARIABLE",_[_.PUSH_DECIMAL=16]="PUSH_DECIMAL",_[_.ADD=20]="ADD",_[_.SUB=21]="SUB",_[_.MUL=22]="MUL",_[_.DIV=23]="DIV",_[_.MOD=24]="MOD",_[_.EXP=25]="EXP",_[_.NEG=26]="NEG",_[_.POS=27]="POS",_[_.MAKE_UNCERTAIN=28]="MAKE_UNCERTAIN",_[_.LSHIFT=30]="LSHIFT",_[_.RSHIFT=31]="RSHIFT",_[_.URSHIFT=32]="URSHIFT",_[_.BIT_AND=33]="BIT_AND",_[_.BIT_OR=34]="BIT_OR",_[_.BIT_XOR=35]="BIT_XOR",_[_.BIT_NOT=36]="BIT_NOT",_[_.EQ=40]="EQ",_[_.NEQ=41]="NEQ",_[_.LT=42]="LT",_[_.LTE=43]="LTE",_[_.GT=44]="GT",_[_.GTE=45]="GTE",_[_.CALL_PLUGIN=50]="CALL_PLUGIN",_[_.CALL_BUILTIN=51]="CALL_BUILTIN",_[_.RETURN=52]="RETURN",_[_.LOAD_VAR=60]="LOAD_VAR",_[_.STORE_VAR=61]="STORE_VAR",_[_.LOAD_GLOBAL_VAR=62]="LOAD_GLOBAL_VAR",_[_.STORE_GLOBAL_VAR=63]="STORE_GLOBAL_VAR",_[_.TO_NUMBER=70]="TO_NUMBER",_[_.TO_HEX=71]="TO_HEX",_[_.TO_PERCENTAGE=74]="TO_PERCENTAGE",_[_.UOM_CONVERT=80]="UOM_CONVERT",_[_.UOM_CONVERT_TO=81]="UOM_CONVERT_TO",_[_.UOM_GET_VALUE=82]="UOM_GET_VALUE",_[_.UOM_BEST=83]="UOM_BEST",_[_.UOM_CONVERT_IN=84]="UOM_CONVERT_IN",_[_.UOM_POSSIBILITIES=85]="UOM_POSSIBILITIES",_[_.DATE_NOW=90]="DATE_NOW",_[_.DATE_ADD=91]="DATE_ADD",_[_.DATE_SUB=92]="DATE_SUB",_[_.DATE_NEXT_WEEKDAY=93]="DATE_NEXT_WEEKDAY",_[_.DATE_LAST_WEEKDAY=94]="DATE_LAST_WEEKDAY",_[_.DATE_LITERAL=95]="DATE_LITERAL",_[_.DATE_WORKDAY_OFFSET=96]="DATE_WORKDAY_OFFSET",_[_.DATE_WORKDAYS_BETWEEN=97]="DATE_WORKDAYS_BETWEEN",_[_.RATE_DIV=110]="RATE_DIV",_[_.RATE_MUL=111]="RATE_MUL",_[_.RATE_CONVERT=112]="RATE_CONVERT",_[_.CLOCK_TIME_TODAY=120]="CLOCK_TIME_TODAY",_[_.LOGICAL_AND=130]="LOGICAL_AND",_[_.LOGICAL_OR=131]="LOGICAL_OR",_[_.SELECT=132]="SELECT",_[_.TO_FRACTION=140]="TO_FRACTION",_[_.TO_MULTIPLIER=141]="TO_MULTIPLIER",_[_.TO_SCI=142]="TO_SCI",_[_.TO_BINARY=143]="TO_BINARY",_[_.TO_OCTAL=144]="TO_OCTAL",_[_.CALL_AS_CONVERTER=145]="CALL_AS_CONVERTER",_[_.DEFINE_USER_FUNCTION=150]="DEFINE_USER_FUNCTION",_[_.CALL_USER_FUNCTION=151]="CALL_USER_FUNCTION",_[_.MAT_NEW=152]="MAT_NEW",_[_.MAT_INDEX1=153]="MAT_INDEX1",_[_.MAT_INDEX2=154]="MAT_INDEX2",_[_.MAT_SLICE=155]="MAT_SLICE",_[_.RANGE_NEW=156]="RANGE_NEW",_[_.MAP_INVOKE=157]="MAP_INVOKE",_[_.REDUCE_INVOKE=158]="REDUCE_INVOKE",_[_.BIND_UNKNOWN=159]="BIND_UNKNOWN",_[_.PLOT_INVOKE=160]="PLOT_INVOKE",_))(A||{}),I=(()=>{let E=new Map;for(let[N,T]of Object.entries(A))typeof T=="number"&&E.set(T,N);return E})();function L(E){return I.get(E)??`UNKNOWN_${E}`}exports.a=A;exports.b=L;//# sourceMappingURL=chunk-VBSMA7WJ.cjs.map
-//# sourceMappingURL=chunk-VBSMA7WJ.cjs.map
+'use strict';var A=(_=>(_[_.NOP=0]="NOP",_[_.HALT=1]="HALT",_[_.SWAP=2]="SWAP",_[_.DUP=3]="DUP",_[_.PUSH_NUMBER=10]="PUSH_NUMBER",_[_.PUSH_BIGINT=11]="PUSH_BIGINT",_[_.PUSH_HEX=12]="PUSH_HEX",_[_.PUSH_STRING=13]="PUSH_STRING",_[_.PUSH_BOOLEAN=14]="PUSH_BOOLEAN",_[_.PUSH_VARIABLE=15]="PUSH_VARIABLE",_[_.PUSH_DECIMAL=16]="PUSH_DECIMAL",_[_.ADD=20]="ADD",_[_.SUB=21]="SUB",_[_.MUL=22]="MUL",_[_.DIV=23]="DIV",_[_.MOD=24]="MOD",_[_.EXP=25]="EXP",_[_.NEG=26]="NEG",_[_.POS=27]="POS",_[_.MAKE_UNCERTAIN=28]="MAKE_UNCERTAIN",_[_.LSHIFT=30]="LSHIFT",_[_.RSHIFT=31]="RSHIFT",_[_.URSHIFT=32]="URSHIFT",_[_.BIT_AND=33]="BIT_AND",_[_.BIT_OR=34]="BIT_OR",_[_.BIT_XOR=35]="BIT_XOR",_[_.BIT_NOT=36]="BIT_NOT",_[_.EQ=40]="EQ",_[_.NEQ=41]="NEQ",_[_.LT=42]="LT",_[_.LTE=43]="LTE",_[_.GT=44]="GT",_[_.GTE=45]="GTE",_[_.CALL_PLUGIN=50]="CALL_PLUGIN",_[_.CALL_BUILTIN=51]="CALL_BUILTIN",_[_.RETURN=52]="RETURN",_[_.LOAD_VAR=60]="LOAD_VAR",_[_.STORE_VAR=61]="STORE_VAR",_[_.LOAD_GLOBAL_VAR=62]="LOAD_GLOBAL_VAR",_[_.STORE_GLOBAL_VAR=63]="STORE_GLOBAL_VAR",_[_.TO_NUMBER=70]="TO_NUMBER",_[_.TO_HEX=71]="TO_HEX",_[_.TO_PERCENTAGE=74]="TO_PERCENTAGE",_[_.UOM_CONVERT=80]="UOM_CONVERT",_[_.UOM_CONVERT_TO=81]="UOM_CONVERT_TO",_[_.UOM_GET_VALUE=82]="UOM_GET_VALUE",_[_.UOM_BEST=83]="UOM_BEST",_[_.UOM_CONVERT_IN=84]="UOM_CONVERT_IN",_[_.UOM_POSSIBILITIES=85]="UOM_POSSIBILITIES",_[_.DATE_NOW=90]="DATE_NOW",_[_.DATE_ADD=91]="DATE_ADD",_[_.DATE_SUB=92]="DATE_SUB",_[_.DATE_NEXT_WEEKDAY=93]="DATE_NEXT_WEEKDAY",_[_.DATE_LAST_WEEKDAY=94]="DATE_LAST_WEEKDAY",_[_.DATE_LITERAL=95]="DATE_LITERAL",_[_.DATE_WORKDAY_OFFSET=96]="DATE_WORKDAY_OFFSET",_[_.DATE_WORKDAYS_BETWEEN=97]="DATE_WORKDAYS_BETWEEN",_[_.RATE_DIV=110]="RATE_DIV",_[_.RATE_MUL=111]="RATE_MUL",_[_.RATE_CONVERT=112]="RATE_CONVERT",_[_.CLOCK_TIME_TODAY=120]="CLOCK_TIME_TODAY",_[_.LOGICAL_AND=130]="LOGICAL_AND",_[_.LOGICAL_OR=131]="LOGICAL_OR",_[_.SELECT=132]="SELECT",_[_.TO_FRACTION=140]="TO_FRACTION",_[_.TO_MULTIPLIER=141]="TO_MULTIPLIER",_[_.TO_SCI=142]="TO_SCI",_[_.TO_BINARY=143]="TO_BINARY",_[_.TO_OCTAL=144]="TO_OCTAL",_[_.CALL_AS_CONVERTER=145]="CALL_AS_CONVERTER",_[_.DEFINE_USER_FUNCTION=150]="DEFINE_USER_FUNCTION",_[_.CALL_USER_FUNCTION=151]="CALL_USER_FUNCTION",_[_.MAT_NEW=152]="MAT_NEW",_[_.MAT_INDEX1=153]="MAT_INDEX1",_[_.MAT_INDEX2=154]="MAT_INDEX2",_[_.MAT_SLICE=155]="MAT_SLICE",_[_.RANGE_NEW=156]="RANGE_NEW",_[_.MAP_INVOKE=157]="MAP_INVOKE",_[_.REDUCE_INVOKE=158]="REDUCE_INVOKE",_[_.BIND_UNKNOWN=159]="BIND_UNKNOWN",_[_.PLOT_INVOKE=160]="PLOT_INVOKE",_[_.CALL_PLUGIN_WIDE=161]="CALL_PLUGIN_WIDE",_))(A||{}),I=(()=>{let E=new Map;for(let[N,T]of Object.entries(A))typeof T=="number"&&E.set(T,N);return E})();function L(E){return I.get(E)??`UNKNOWN_${E}`}exports.a=A;exports.b=L;//# sourceMappingURL=chunk-ABVDKMNF.cjs.map
+//# sourceMappingURL=chunk-ABVDKMNF.cjs.map

package/dist/chunk-ABVDKMNF.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/parser/OpCode.ts"],"names":["OpCode","OP_CODE_NAMES","map","key","value","getOpCodeName","op"],"mappings":"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","file":"chunk-ABVDKMNF.cjs","sourcesContent":["/**\n * The VM's bytecode instruction set.\n *\n * Emitted by parselets (via {@link BytecodeBuilder}) during parsing and\n * consumed by the VM's dispatch loop during execution. Values are grouped\n * into numeric bands by category (0-9 stack ops, 10-19 push-literal, 20-29\n * arithmetic, ...) purely for readability, the VM dispatches on the exact\n * numeric value, not the band.\n *\n * Third-party packages emit `CALL_PLUGIN` (with a plugin-function index\n * from {@link allocatePluginFunctionIndex}) to invoke their own logic\n * see `IEnginePackage.pluginFunctions`. The other opcodes are used\n * internally by the built-in packages' parselets.\n */\nexport enum OpCode {\n\t// Stack operations\n\tNOP = 0,\n\tHALT = 1,\n\tSWAP = 2,\n\tDUP = 3,\n\n\t// Push literals\n\tPUSH_NUMBER = 10,\n\tPUSH_BIGINT = 11,\n\tPUSH_HEX = 12,\n\tPUSH_STRING = 13,\n\tPUSH_BOOLEAN = 14,\n\tPUSH_VARIABLE = 15,\n\t// A decimal-point literal, pushed with the exact base-ten value it was\n\t// written as alongside the nearest double. The operand is a string-pool\n\t// index holding the normalized \".\" decimal text (thousands grouping already\n\t// stripped), read back into a Number-typed Value whose `exact` sidecar makes\n\t// money that combines with it exact. See vm/Value.ts's numberValueExact().\n\tPUSH_DECIMAL = 16,\n\n\t// Arithmetic (BinaryOperator)\n\tADD = 20,\n\tSUB = 21,\n\tMUL = 22,\n\tDIV = 23,\n\tMOD = 24,\n\tEXP = 25,\n\tNEG = 26,\n\tPOS = 27,\n\t// `a ± b` (or the ASCII `a +/- b`): pops the spread then the center off the\n\t// stack and pushes a Number carrying a one-sigma uncertainty (`vm/Value.ts`'s\n\t// numberValueUncertain). Takes no operand byte, like the other arithmetic\n\t// ops. See packages/uncertainty/ for the parselet that emits it and\n\t// vm/VMConversion.ts's uncertainOp for how the four arithmetic ops propagate.\n\tMAKE_UNCERTAIN = 28,\n\n\t// Bitwise\n\tLSHIFT = 30,\n\tRSHIFT = 31,\n\tURSHIFT = 32,\n\tBIT_AND = 33,\n\tBIT_OR = 34,\n\tBIT_XOR = 35,\n\tBIT_NOT = 36,\n\n\t// Comparison\n\tEQ = 40,\n\tNEQ = 41,\n\tLT = 42,\n\tLTE = 43,\n\tGT = 44,\n\tGTE = 45,\n\n\t// Functions\n\tCALL_PLUGIN = 50,     // Plugin-registered functions (may be async — pre-resolved by orchestrator)\n\tCALL_BUILTIN = 51,    // Sync built-in functions (sqrt, sin, diceRoll, matmul)\n\tRETURN = 52,          // Reserved for future user-defined functions\n\n\t// Variables\n\tLOAD_VAR = 60,\n\tSTORE_VAR = 61,\n\tLOAD_GLOBAL_VAR = 62,   // Reads from the process-wide GlobalVariableStore, not the VM's local scope\n\tSTORE_GLOBAL_VAR = 63,  // Writes to the process-wide GlobalVariableStore, visible to every document\n\n\t// Type conversion\n\tTO_NUMBER = 70,\n\tTO_HEX = 71,\n\tTO_PERCENTAGE = 74,\n\n\t// UoM\n\tUOM_CONVERT = 80,\n\tUOM_CONVERT_TO = 81,\n\tUOM_GET_VALUE = 82,\n\tUOM_BEST = 83,\n\tUOM_CONVERT_IN = 84,\n\tUOM_POSSIBILITIES = 85,  // \"sourceUnit to ?\" — list units convertible from sourceUnit\n\n\t// Datetime\n\tDATE_NOW = 90,\n\tDATE_ADD = 91,\n\tDATE_SUB = 92,\n\tDATE_NEXT_WEEKDAY = 93,  // \"next <Weekday>\" — the next occurrence strictly after now\n\tDATE_LAST_WEEKDAY = 94,  // \"last <Weekday>\" — the previous occurrence strictly before now\n\tDATE_LITERAL = 95,       // Push a datetime literal whose epoch-ms was already resolved at parse time (see DateLiteralParselet)\n\tDATE_WORKDAY_OFFSET = 96,   // \"N working days after/before/from <date>\" — a business-day walk from the anchor date. One operand byte: 0 forward, 1 backward. Same walk as `<date> + N workdays` (vm/VM.ts's addBusinessDays). See WorkdayOffsetParselet.\n\tDATE_WORKDAYS_BETWEEN = 97, // \"working days between <date> and <date>\" — the count of working days in the inclusive span. See WorkdaysBetweenParselet and vm/BusinessDays.ts's countBusinessDaysBetween.\n\n\t// Rate, \"quantity per unit of something\" ($99/week, 30 fps). See\n\t// vm/Value.ts's rateValue()/isRateUnit()/splitRateUnit() for the\n\t// representation these opcodes operate on.\n\tRATE_DIV = 110,      // Uom ÷ Uom (different measures) -> Rate — the construction op\n\tRATE_MUL = 111,      // Rate × Uom (same measure as denominator) -> plain Uom (denominator cancels)\n\tRATE_CONVERT = 112,  // Rate -> Rate with a rescaled denominator unit (keeps the same real-world rate)\n\n\t// Time, clock-time-of-day, lap times, video timecode (distinct from\n\t// the Datetime band's calendar-date arithmetic).\n\tCLOCK_TIME_TODAY = 120,  // minutes-since-midnight -> Datetime anchored to today's calendar date\n\n\t// Conditionals, boolean logic and eager-evaluated ternary selection.\n\t// EQ/NEQ/LT/LTE/GT/GTE (40-45, above) already existed as dead opcodes\n\t// before this band was wired up; see vm/VM.ts for their handlers.\n\tLOGICAL_AND = 130,  // Boolean && Boolean -> Boolean\n\tLOGICAL_OR = 131,   // Boolean || Boolean -> Boolean\n\tSELECT = 132,       // (thenVal, elseVal, condition) -> thenVal if condition else elseVal — EAGER (both\n\t                    // branches already evaluated by the time this runs; no real branching/short-circuit,\n\t                    // a deliberate simplification for a side-effect-free expression language, see\n\t                    // packages/conditionals/parselets/IfThenElseParselet.ts)\n\n\t// Converters, the general \"as <type>\" mechanism. TO_NUMBER/TO_HEX/\n\t// TO_PERCENTAGE (70/71/74, above) cover the simplest cases; these cover\n\t// the ones with no existing opcode. CALL_AS_CONVERTER is the SDK\n\t// extension point. See IEnginePackage.asConverters and\n\t// vm/VMBuiltins.ts's asConverterRegistry.\n\tTO_FRACTION = 140,       // Number -> String, simplified fraction (\"0.5\" -> \"1/2\")\n\tTO_MULTIPLIER = 141,     // Number -> String, \"1 + n\" growth multiplier (\"0.5\" -> \"1.5x\")\n\tTO_SCI = 142,            // Number -> String, scientific notation (\"1500000\" -> \"1.5e+6\")\n\tTO_BINARY = 143,         // Number -> String, base-2 display (\"10\" -> \"0b1010\")\n\tTO_OCTAL = 144,          // Number -> String, base-8 display (\"10\" -> \"0o12\")\n\tCALL_AS_CONVERTER = 145, // (value, name) -> runtime asConverterRegistry lookup + call\n\n\t// User-defined, parameterized, reusable functions (f(x) = expr, then\n\t// f(5). See parser/PrecedenceParser.ts's IDENT_ID case\n\t// parser/BytecodeBuilder.ts's UserFunctionDef/emitUserFunctionBody, and\n\t// vm/VM.ts's VM.userFunctions/callFrames). Parameter references inside a\n\t// function body are ORDINARY LOAD_VAR opcodes, not a dedicated\n\t// parameter-load opcode, CALL_USER_FUNCTION binds arguments into a\n\t// name-keyed call frame at runtime, and LOAD_VAR checks the innermost\n\t// call frame before the flat variable store (see VM.getVar()).\n\tDEFINE_USER_FUNCTION = 150, // (operand = index into bytecode.userFunctionBodies) -> register name/params/program into vm.userFunctions. Registration happens at VM-EXECUTION time, not parse time, so a diagnostic/lookahead parse that compiles but never executes a definition line has no side effect on the shared registry.\n\tCALL_USER_FUNCTION = 151,   // (N arg values already on stack) -> pop N args, bind by NAME into a new call frame, execute the named function's stored body (reentrant executeBytecode), push its result\n\n\t// Matrix (Calca-parity, replaces the old ARR_* vector-only opcodes\n\t// which were never emitted by any registered parselet; see\n\t// vm/MatrixOps.ts for the shared column-major storage helpers this band\n\t// operates on, and vm/Value.ts's MatrixData for the representation).\n\tMAT_NEW = 152,      // (rows, cols operands; rows*cols values already on stack, ROW-MAJOR push order) -> pop rows*cols values, transpose to column-major, push a Matrix\n\tMAT_INDEX1 = 153,   // (matrix, index already on stack) -> column-major single-index read `a[i]`\n\tMAT_INDEX2 = 154,   // (matrix, row, col already on stack) -> `a[row, col]` read\n\tMAT_SLICE = 155,    // (matrix, rowRange, colRange already on stack) -> sub-matrix via two Range values\n\tRANGE_NEW = 156,    // (min, max already on stack) -> push a Range value `min:max`\n\tMAP_INVOKE = 157,   // map(...) — see parser/BytecodeBuilder.ts's `anonymousBodies` side-table\n\tREDUCE_INVOKE = 158, // reduce(...) — same anonymousBodies mechanism as MAP_INVOKE\n\t// An algebra verb's expression argument, evaluated with the verb's own\n\t// named unknown bound to itself (`der(x^2, x)` reads `x` as the unknown\n\t// even where the document also has a value for it). Operand = an index\n\t// into `anonymousBodies`, whose `params[0]` carries the name to bind, the\n\t// same side-table and the same call-frame shadowing MAP_INVOKE uses for a\n\t// transform body's parameters. See vm/VM.ts's handler.\n\tBIND_UNKNOWN = 159,\n\t// 159 was THEREFORE_SOLVE and STORE_EQUATION_OR_ASSIGNMENT, declared but never\n\t// emitted by any parselet nor handled in the VM switch. Both shapes have\n\t// effects (a stored equation, a direct vm.setVar()) that a cached bytecode\n\t// program cannot represent, so engine/ExpressionEngine.ts intercepts them\n\t// before compilation and always will. 159 has since been reused above.\n\t// `plot <expr> from <a> to <b>`: samples an inline body (binding `x`) across\n\t// [a, b], the same anonymousBodies side-table and call-frame shadowing\n\t// MAP_INVOKE uses. Operands: the body index, then the pooled source string.\n\tPLOT_INVOKE = 160,\n\t// Wide-index plugin call: identical to CALL_PLUGIN (opcode 50) but its\n\t// plugin-function index is TWO bytes (little-endian) rather than one, so a\n\t// process can register more than 256 plugin functions. Emitted only when an\n\t// index exceeds 255; anything at or below still uses the one-byte CALL_PLUGIN,\n\t// so existing bytecode and snapshots are unchanged. See BytecodeBuilder's\n\t// emitPluginCall and the VM's shared CALL_PLUGIN / CALL_PLUGIN_WIDE case.\n\tCALL_PLUGIN_WIDE = 161,\n}\n\n// Reverse lookup built once at module load, getOpCodeName() is called once\n// per VM instruction whenever a diagnostic collector is attached (VM.ts's\n// trace path), so a per-call linear scan of every enum entry (TS numeric\n// enums are bidirectional at runtime, so Object.entries(OpCode) yields both\n// \"NOP\" -> 0 and \"0\" -> \"NOP\" style entries) would otherwise redo the same\n// scan every single traced instruction. Only the numeric-valued entries are\n// kept, the string-valued reverse entries TS also generates aren't needed\n// here.\nconst OP_CODE_NAMES: ReadonlyMap<number, string> = (() => {\n\tconst map = new Map<number, string>();\n\tfor (const [key, value] of Object.entries(OpCode)) {\n\t\tif (typeof value === \"number\") map.set(value, key);\n\t}\n\treturn map;\n})();\n\n/**\n * Gets the name of an OpCode as a string.\n * @param op The OpCode value\n * @returns The enum name as a string, or \"UNKNOWN_<value>\" if not found\n */\nexport function getOpCodeName(op: number): string {\n\treturn OP_CODE_NAMES.get(op) ?? `UNKNOWN_${op}`;\n}\n"]}