@velarscript/compiler 0.12.0 → 0.13.0

package/dist/text-runtime.js

@@ -6,6 +6,7 @@ const __velarTextNativeString = globalThis.String;
 const __velarTextNativeNumber = globalThis.Number;
 const __velarTextNativeMath = globalThis.Math;
 const __velarTextNativeObject = globalThis.Object;
+const __velarTextNativeMap = globalThis.Map;
 const __velarTextNativeTypeError = globalThis.TypeError;
 const __velarTextNativeRangeError = globalThis.RangeError;
 const __velarTextGetOwnPropertyDescriptor = __velarTextNativeObject.getOwnPropertyDescriptor;
@@ -25,9 +26,12 @@ const __velarNativeStringTrim = __velarTextGetOwnPropertyDescriptor(__velarTextS
 const __velarNativeStringUpper = __velarTextGetOwnPropertyDescriptor(__velarTextStringPrototype, "toUpperCase")?.value;
 const __velarNativeStringLower = __velarTextGetOwnPropertyDescriptor(__velarTextStringPrototype, "toLowerCase")?.value;
 const __velarNativeStringSplit = __velarTextGetOwnPropertyDescriptor(__velarTextStringPrototype, "split")?.value;
-const __velarNativeStringReplace = __velarTextGetOwnPropertyDescriptor(__velarTextStringPrototype, "replace")?.value;
 const __velarNativeStringReplaceAll = __velarTextGetOwnPropertyDescriptor(__velarTextStringPrototype, "replaceAll")?.value;
 const __velarNativeStringRepeat = __velarTextGetOwnPropertyDescriptor(__velarTextStringPrototype, "repeat")?.value;
+const __velarTextMapPrototype = typeof __velarTextNativeMap === "function" ? __velarTextGetOwnPropertyDescriptor(__velarTextNativeMap, "prototype")?.value : null;
+const __velarTextMapGet = __velarTextMapPrototype ? __velarTextGetOwnPropertyDescriptor(__velarTextMapPrototype, "get")?.value : null;
+const __velarTextMapSet = __velarTextMapPrototype ? __velarTextGetOwnPropertyDescriptor(__velarTextMapPrototype, "set")?.value : null;
+const __velarTextMapClear = __velarTextMapPrototype ? __velarTextGetOwnPropertyDescriptor(__velarTextMapPrototype, "clear")?.value : null;
 const __velarTextSurrogatePattern = /[\u{10000}-\u{10FFFF}\uD800-\uDFFF]/u;
 const __velarTextRegExpPrototype = typeof __velarTextRuntimeGetPrototypeOf === "function" ? __velarTextRuntimeGetPrototypeOf(__velarTextSurrogatePattern) : null;
 const __velarTextSurrogateExec = __velarTextRegExpPrototype ? __velarTextGetOwnPropertyDescriptor(__velarTextRegExpPrototype, "exec")?.value : null;
@@ -66,48 +70,146 @@ function __velarTextNextCodePointOffset(value, offset) {
   const second = __velarTextCall(__velarNativeStringCharCodeAt, value, [offset + 1]);
   return second >= 0xDC00 && second <= 0xDFFF ? offset + 2 : offset + 1;
 }
-function __velarTextCodePointLength(value) {
-  if (__velarTextCall(__velarTextSurrogateExec, __velarTextSurrogatePattern, [value]) === null) return value.length;
+// D90 R7, performance half. Measuring a string used to be a whole-string job
+// every single time: the surrogate probe ran per call, and one astral character
+// anywhere forced every offset conversion to walk code points from zero, which
+// made a loop of char/slice calls quadratic: 20,000 char/slice calls over a
+// 200 KiB string with one leading astral character took 17.1 s, and 34 ms
+// once measurement was memoised. A measurement is a pure function of an
+// immutable value, so it is memoised: a dense string answers offset conversions in
+// O(1) when no surrogate pair splits it, and otherwise the checkpoint list
+// records the code-unit offset of every stride-th code point so a conversion
+// starts from the nearest checkpoint instead of from the start of the string.
+// The cache may only change the cost of an answer, never the answer.
+const __velarTextCheckpointStride = 64;
+const __velarTextMeasureMinimumUnits = 64;
+// The cache holds its keys strongly, so its budget is memory the program has
+// stopped using but cannot reclaim. Eight MiB buys the loops that matter and
+// bounds what a document-processing program leaves behind; a single string
+// larger than the budget still measures once and stays, because evicting the
+// string a loop is walking would put the cliff back. The entry count only
+// bounds the cache's own bookkeeping, so it is set well above the number of
+// strings a loop cycles through: a tighter count made a walk over 65 short
+// strings 15x slower than the same walk over 64.
+const __velarTextMeasureCacheEntries = 512;
+const __velarTextMeasureCacheUnits = 8 * 1024 * 1024;
+const __velarTextMeasureCache = typeof __velarTextNativeMap === "function"
+  && typeof __velarTextMapGet === "function" && typeof __velarTextMapSet === "function" && typeof __velarTextMapClear === "function"
+  ? new __velarTextNativeMap() : null;
+let __velarTextMeasureCacheCount = 0;
+let __velarTextMeasureCacheHeld = 0;
+function __velarTextMeasureText(value) {
+  if (__velarTextCall(__velarTextSurrogateExec, __velarTextSurrogatePattern, [value]) === null) {
+    return { length: value.length, dense: true, checkpoints: null };
+  }
+  const checkpoints = new __velarTextNativeArray();
   let length = 0, offset = 0;
-  while (offset < value.length) { offset = __velarTextNextCodePointOffset(value, offset); length += 1; }
-  return length;
+  while (offset < value.length) {
+    if (length % __velarTextCheckpointStride === 0) checkpoints[length / __velarTextCheckpointStride] = offset;
+    offset = __velarTextNextCodePointOffset(value, offset);
+    length += 1;
+  }
+  // A string that carries only unpaired surrogates still has one unit per code
+  // point, so it keeps the O(1) path even though the probe matched.
+  return { length: length, dense: length === value.length, checkpoints: checkpoints };
 }
-function __velarTextCodePointPrefix(value, count) { return __velarTextCall(__velarNativeStringSlice, value, [0, __velarTextCodeUnitOffset(value, count)]); }
-// A string whose code-point count equals its code-unit count carries no
-// surrogate pair, so a code-point position is already a code-unit offset.
-// The codePointLength argument lets a caller that has already measured the string reuse
-// that measurement; without it the surrogate probe answers the same question
-// in one native scan. Walking code points from zero instead made every offset
-// conversion O(corpus + position), which is what turned slice-based document
-// scanning quadratic.
-function __velarTextOneUnitPerCodePoint(value, codePointLength) {
-  if (codePointLength >= 0) return codePointLength === value.length;
-  return __velarTextCall(__velarTextSurrogateExec, __velarTextSurrogatePattern, [value]) === null;
+function __velarTextMeasure(value) {
+  if (__velarTextMeasureCache === null || value.length < __velarTextMeasureMinimumUnits) return __velarTextMeasureText(value);
+  const cached = __velarTextCall(__velarTextMapGet, __velarTextMeasureCache, [value]);
+  if (cached !== undefined) return cached;
+  const measured = __velarTextMeasureText(value);
+  if (__velarTextMeasureCacheCount >= __velarTextMeasureCacheEntries
+    || (__velarTextMeasureCacheCount > 0 && __velarTextMeasureCacheHeld + value.length > __velarTextMeasureCacheUnits)) {
+    __velarTextCall(__velarTextMapClear, __velarTextMeasureCache, []);
+    __velarTextMeasureCacheCount = 0;
+    __velarTextMeasureCacheHeld = 0;
+  }
+  __velarTextCall(__velarTextMapSet, __velarTextMeasureCache, [value, measured]);
+  __velarTextMeasureCacheCount += 1;
+  __velarTextMeasureCacheHeld += value.length;
+  return measured;
+}
+function __velarTextCodePointLength(value) {
+  return __velarTextMeasure(value).length;
 }
-function __velarTextCodeUnitOffset(value, position, codePointLength = -1) {
-  if (__velarTextOneUnitPerCodePoint(value, codePointLength)) return position < value.length ? position : value.length;
-  let offset = 0, current = 0;
+function __velarTextCodePointPrefix(value, count) { return __velarTextCall(__velarNativeStringSlice, value, [0, __velarTextCodeUnitOffset(value, count)]); }
+function __velarTextCodeUnitOffset(value, position) {
+  const measured = __velarTextMeasure(value);
+  if (measured.dense) return position < value.length ? position : value.length;
+  if (position <= 0) return 0;
+  const checkpoints = measured.checkpoints;
+  let block = __velarTextCall(__velarTextMathFloor, __velarTextNativeMath, [position / __velarTextCheckpointStride]);
+  if (block >= checkpoints.length) block = checkpoints.length - 1;
+  let offset = checkpoints[block], current = block * __velarTextCheckpointStride;
   while (offset < value.length && current < position) { offset = __velarTextNextCodePointOffset(value, offset); current += 1; }
   return offset;
 }
-function __velarTextCodePointIndex(value, unitOffset, codePointLength = -1) {
-  if (__velarTextOneUnitPerCodePoint(value, codePointLength)) return unitOffset <= value.length ? unitOffset : null;
-  let offset = 0, position = 0;
+function __velarTextCodePointIndex(value, unitOffset) {
+  const measured = __velarTextMeasure(value);
+  if (measured.dense) return unitOffset <= value.length ? unitOffset : null;
+  if (unitOffset < 0 || unitOffset > value.length) return null;
+  const checkpoints = measured.checkpoints;
+  let low = 0, high = checkpoints.length - 1;
+  while (low < high) {
+    const middle = low + __velarTextCall(__velarTextMathFloor, __velarTextNativeMath, [(high - low + 1) / 2]);
+    if (checkpoints[middle] <= unitOffset) low = middle; else high = middle - 1;
+  }
+  let offset = checkpoints[low], position = low * __velarTextCheckpointStride;
   while (offset < unitOffset && offset < value.length) { offset = __velarTextNextCodePointOffset(value, offset); position += 1; }
   return offset === unitOffset ? position : null;
 }
 function __velarTextCodePointDistance(value, start, end) {
+  if (__velarTextMeasure(value).dense) return end >= start ? end - start : null;
   let offset = start, distance = 0;
   while (offset < end) { offset = __velarTextNextCodePointOffset(value, offset); distance += 1; }
   return offset === end ? distance : null;
 }
+// D90 R7: a code-unit offset sits between two code points unless it splits a
+// surrogate pair, and only an adjacent lead/trail pair can be split. The test
+// is O(1), so every search below can reject a mid-pair hit without measuring
+// the string.
+function __velarTextIsBoundary(value, offset) {
+  if (offset <= 0 || offset >= value.length) return true;
+  const lead = __velarTextCall(__velarNativeStringCharCodeAt, value, [offset - 1]);
+  if (lead < 0xD800 || lead > 0xDBFF) return true;
+  const trail = __velarTextCall(__velarNativeStringCharCodeAt, value, [offset]);
+  return trail < 0xDC00 || trail > 0xDFFF;
+}
+// D90 R7, performance half. A match can only start inside a pair when the
+// needle starts with a trail surrogate, and can only end inside one when the
+// needle ends with a lead surrogate: the unit the gate reads at each end of a
+// match is the needle's own edge unit. Both are properties of the needle
+// alone, so one O(1) look says whether the native scan already answers what
+// the bounded scan answers, and an ordinary needle keeps native speed on any
+// haystack. The needle must not be empty; each caller handles that case.
+function __velarTextNeedsBoundaryCheck(search) {
+  const first = __velarTextCall(__velarNativeStringCharCodeAt, search, [0]);
+  if (first >= 0xDC00 && first <= 0xDFFF) return true;
+  const last = __velarTextCall(__velarNativeStringCharCodeAt, search, [search.length - 1]);
+  return last >= 0xD800 && last <= 0xDBFF;
+}
+// Every search operation goes through here so that a match is accepted only
+// when it starts and ends on a code-point boundary. A needle that begins or
+// ends with an unpaired surrogate therefore never matches inside a pair, which
+// is what keeps split/replace/replaceAll from manufacturing lone surrogates.
+// The needle must not be empty; each caller handles that case in its own voice.
+function __velarTextBoundedIndexOf(value, search, cursor) {
+  if (!__velarTextNeedsBoundaryCheck(search)) return __velarTextCall(__velarNativeStringIndexOf, value, [search, cursor]);
+  while (cursor <= value.length) {
+    const found = __velarTextCall(__velarNativeStringIndexOf, value, [search, cursor]);
+    if (found < 0) return -1;
+    if (__velarTextIsBoundary(value, found) && __velarTextIsBoundary(value, found + search.length)) return found;
+    cursor = found + 1;
+  }
+  return -1;
+}
 function __velarTextReplacementOutputUnits(value, search, replacement, all) {
   let matches = 0;
   if (search === "") matches = all ? __velarTextCodePointLength(value) + 1 : 1;
   else {
     let cursor = 0;
     while (true) {
-      const index = __velarTextCall(__velarNativeStringIndexOf, value, [search, cursor]);
+      const index = __velarTextBoundedIndexOf(value, search, cursor);
       if (index < 0) break;
       matches += 1;
       if (!all) break;
@@ -157,8 +259,14 @@ function __velarStringCompare(left, right) {
 // which one is known only at runtime. A string pair keeps code-point order
 // (TXT-D1); everything else uses the plain relational order, exactly as a
 // monomorphic comparison of that category would.
+// D90 R6: one NaN policy. A NaN may be held and tested with .isNaN(), but an
+// operation that orders it raises instead of answering. Without this the
+// "neither less nor greater" arm returned 0, which made NaN compare both <=
+// and >= as true at a generic site while the same source on a plain number
+// answered false, and produced genuinely mis-sorted output.
 function __velarOrderCompare(left, right) {
   if (typeof left === "string" && typeof right === "string") return __velarStringCompare(left, right);
+  if (left !== left || right !== right) throw new __velarTextNativeTypeError("ordered comparison found NaN, which has no ordering; drop it with filter(x => not x.isNaN()) or fix the upstream computation");
   return left < right ? -1 : left > right ? 1 : 0;
 }
 function __velarStringSize(value) { return __velarTextCodePointLength(__velarTextValue(value)); }
@@ -173,7 +281,7 @@ function __velarStringSlice(value, start = 0, end = null) {
   if (!__velarTextCall(__velarTextNumberIsInteger, __velarTextNativeNumber, [start]) || !__velarTextCall(__velarTextNumberIsInteger, __velarTextNativeNumber, [end])) throw new __velarTextNativeTypeError("String.slice positions must be integers");
   const first = start < 0 ? __velarTextCall(__velarTextMathMax, __velarTextNativeMath, [total + start, 0]) : __velarTextCall(__velarTextMathMin, __velarTextNativeMath, [start, total]);
   const last = end < 0 ? __velarTextCall(__velarTextMathMax, __velarTextNativeMath, [total + end, 0]) : __velarTextCall(__velarTextMathMin, __velarTextNativeMath, [end, total]);
-  return __velarTextCall(__velarNativeStringSlice, value, [__velarTextCodeUnitOffset(value, first, total), __velarTextCodeUnitOffset(value, last, total)]);
+  return __velarTextCall(__velarNativeStringSlice, value, [__velarTextCodeUnitOffset(value, first), __velarTextCodeUnitOffset(value, last)]);
 }
 function __velarStringChar(value, index) {
   value = __velarTextValue(value);
@@ -182,25 +290,23 @@ function __velarStringChar(value, index) {
   if (index < 0) index += total;
   if (index < 0) return null;
   if (index >= total) return null;
-  const start = __velarTextCodeUnitOffset(value, index, total);
+  const start = __velarTextCodeUnitOffset(value, index);
   return __velarTextCall(__velarNativeStringSlice, value, [start, __velarTextNextCodePointOffset(value, start)]);
 }
-function __velarStringHas(value, text) { return __velarTextCall(__velarNativeStringIndexOf, __velarTextValue(value), [__velarTextArgument(text, "String.has text")]) >= 0; }
+function __velarStringHas(value, text) {
+  value = __velarTextValue(value); text = __velarTextArgument(text, "String.has text");
+  return text === "" || __velarTextBoundedIndexOf(value, text, 0) >= 0;
+}
 function __velarStringIndex(value, text, start = 0) {
   value = __velarTextValue(value); text = __velarTextArgument(text, "String.index text");
   if (!__velarTextCall(__velarTextNumberIsInteger, __velarTextNativeNumber, [start])) throw new __velarTextNativeTypeError("String.index start must be an integer");
   const total = __velarTextCodePointLength(value);
   const first = start < 0 ? __velarTextCall(__velarTextMathMax, __velarTextNativeMath, [total + start, 0]) : __velarTextCall(__velarTextMathMin, __velarTextNativeMath, [start, total]);
-  let cursor = __velarTextCodeUnitOffset(value, first, total);
+  const cursor = __velarTextCodeUnitOffset(value, first);
   if (text === "") return first;
-  while (cursor <= value.length) {
-    const found = __velarTextCall(__velarNativeStringIndexOf, value, [text, cursor]);
-    if (found < 0) return null;
-    const position = __velarTextCodePointIndex(value, found, total);
-    if (position !== null && __velarTextCodePointIndex(value, found + text.length, total) !== null) return position;
-    cursor = found + 1;
-  }
-  return null;
+  const found = __velarTextBoundedIndexOf(value, text, cursor);
+  if (found < 0) return null;
+  return __velarTextCodePointIndex(value, found);
 }
 function __velarStringCount(value, text) {
   value = __velarTextValue(value); text = __velarTextArgument(text, "String.count text");
@@ -208,7 +314,7 @@ function __velarStringCount(value, text) {
   let count = 0;
   let cursor = 0;
   while (true) {
-    const index = __velarTextCall(__velarNativeStringIndexOf, value, [text, cursor]);
+    const index = __velarTextBoundedIndexOf(value, text, cursor);
     if (index < 0) return count;
     count += 1;
     cursor = index + text.length;
@@ -216,12 +322,12 @@ function __velarStringCount(value, text) {
 }
 function __velarStringStartsWith(value, text) {
   value = __velarTextValue(value); text = __velarTextArgument(text, "String.startsWith text");
-  return __velarTextCall(__velarNativeStringIndexOf, value, [text, 0]) === 0;
+  return __velarTextCall(__velarNativeStringIndexOf, value, [text, 0]) === 0 && __velarTextIsBoundary(value, text.length);
 }
 function __velarStringEndsWith(value, text) {
   value = __velarTextValue(value); text = __velarTextArgument(text, "String.endsWith text");
   const start = value.length - text.length;
-  return start >= 0 && __velarTextCall(__velarNativeStringIndexOf, value, [text, start]) === start;
+  return start >= 0 && __velarTextIsBoundary(value, start) && __velarTextCall(__velarNativeStringIndexOf, value, [text, start]) === start;
 }
 function __velarStringSplit(value, separator) {
   value = __velarTextValue(value); separator = __velarTextArgument(separator, "String.split separator");
@@ -237,12 +343,35 @@ function __velarStringSplit(value, separator) {
     }
     return output;
   }
-  return __velarTextList(__velarTextCall(__velarNativeStringSplit, value, [separator, __velarMaxTextItems + 1]), "String.split");
+  // The native split matches UTF-16 code units, so it would cut a surrogate
+  // pair in half on a separator that begins or ends with an unpaired
+  // surrogate. Every other separator makes the two scans agree match for
+  // match, and the native one is the faster: its limit argument also stops it
+  // before it can build an oversize array.
+  if (!__velarTextNeedsBoundaryCheck(separator)) {
+    return __velarTextList(__velarTextCall(__velarNativeStringSplit, value, [separator, __velarMaxTextItems + 1]), "String.split");
+  }
+  // Searching on code-point boundaries keeps every piece well formed; the
+  // pieces themselves are still plain slices of the input.
+  const parts = new __velarTextNativeArray();
+  let cursor = 0;
+  while (true) {
+    const found = __velarTextBoundedIndexOf(value, separator, cursor);
+    if (found < 0) break;
+    parts[parts.length] = __velarTextCall(__velarNativeStringSlice, value, [cursor, found]);
+    if (parts.length > __velarMaxTextItems) return __velarTextList(parts, "String.split");
+    cursor = found + separator.length;
+  }
+  parts[parts.length] = __velarTextCall(__velarNativeStringSlice, value, [cursor]);
+  return __velarTextList(parts, "String.split");
 }
 function __velarStringReplace(value, from, to) {
   value = __velarTextValue(value); from = __velarTextArgument(from, "String.replace from"); to = __velarTextArgument(to, "String.replace to");
   if (__velarTextReplacementOutputUnits(value, from, to, false) > __velarMaxTextCodeUnits) throw new __velarTextNativeRangeError("String.replace output cannot exceed 16 MiB");
-  return __velarTextCall(__velarNativeStringReplace, value, [from, () => to]);
+  if (from === "") return to + value;
+  const found = __velarTextBoundedIndexOf(value, from, 0);
+  if (found < 0) return value;
+  return __velarTextCall(__velarNativeStringSlice, value, [0, found]) + to + __velarTextCall(__velarNativeStringSlice, value, [found + from.length]);
 }
 function __velarStringReplaceAll(value, from, to) {
   value = __velarTextValue(value); from = __velarTextArgument(from, "String.replaceAll from"); to = __velarTextArgument(to, "String.replaceAll to");
@@ -253,7 +382,19 @@ function __velarStringReplaceAll(value, from, to) {
     while (offset < value.length) { const next = __velarTextNextCodePointOffset(value, offset); output += __velarTextCall(__velarNativeStringSlice, value, [offset, next]) + to; offset = next; }
     return output;
   }
-  return __velarTextCall(__velarNativeStringReplaceAll, value, [from, () => to]);
+  // A separator that cannot split a pair leaves nothing for the bounded walk
+  // to reject, so the native rewrite answers the same string faster. The
+  // replacement is passed as a function so that a '$' in it stays literal.
+  if (!__velarTextNeedsBoundaryCheck(from)) return __velarTextCall(__velarNativeStringReplaceAll, value, [from, () => to]);
+  let output = "";
+  let cursor = 0;
+  while (true) {
+    const found = __velarTextBoundedIndexOf(value, from, cursor);
+    if (found < 0) break;
+    output += __velarTextCall(__velarNativeStringSlice, value, [cursor, found]) + to;
+    cursor = found + from.length;
+  }
+  return output + __velarTextCall(__velarNativeStringSlice, value, [cursor]);
 }
 function __velarStringPad(value, size, fill, start) {
   const name = start ? "String.padStart" : "String.padEnd";

package/dist/text-runtime.js.map

@@ -1 +1 @@
-{"version":3,"file":"text-runtime.js","sourceRoot":"","sources":["../src/text-runtime.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,yBAAyB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2RlD,CAAC,SAAS,EAAE,CAAC"}
+{"version":3,"file":"text-runtime.js","sourceRoot":"","sources":["../src/text-runtime.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,yBAAyB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwalD,CAAC,SAAS,EAAE,CAAC"}

package/dist/token.d.ts

@@ -14,6 +14,17 @@ export interface Token {
     readonly span: Span;
     readonly payload?: unknown;
 }
+/**
+ * A number token's payload, carried only when the author's own spelling differs
+ * from the value the token holds — digit separators (`1_000_000_1`) and an
+ * uppercase radix prefix (`0X20`) are the two differences the lexer makes.
+ * D90 R6's representability report quotes the literal back at the author, and
+ * quoting the normalized spelling would show them text that appears nowhere in
+ * their source.
+ */
+export interface NumberTokenPayload {
+    readonly written: string;
+}
 /**
  * Hard reserved words: spellings the lexer always turns into a keyword token,
  * so they can never name a binding. D30 item 16 softened the statement-head

package/dist/token.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"token.d.ts","sourceRoot":"","sources":["../src/token.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAExC,MAAM,MAAM,SAAS,GACjB,YAAY,GACZ,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,gBAAgB,GAChB,YAAY,GACZ,OAAO,GACP,KAAK,GACL,KAAK,GACL,OAAO,GACP,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,IAAI,GACJ,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,MAAM,GACN,UAAU,GACV,OAAO,GACP,SAAS,GACT,UAAU,GACV,SAAS,GACT,QAAQ,GACR,OAAO,GACP,QAAQ,GACR,OAAO,GACP,QAAQ,GACR,IAAI,GACJ,MAAM,GACN,KAAK,GACL,IAAI,GACJ,OAAO,GACP,OAAO,GACP,UAAU,GACV,KAAK,GACL,OAAO,GACP,SAAS,GACT,MAAM,GACN,IAAI,GACJ,MAAM,GACN,OAAO,GACP,MAAM,GACN,KAAK,GACL,IAAI,GACJ,KAAK,GACL,SAAS,GACT,QAAQ,GACR,QAAQ,GACR,WAAW,GACX,YAAY,GACZ,aAAa,GACb,cAAc,GACd,WAAW,GACX,YAAY,GACZ,OAAO,GACP,OAAO;AACT,mGAAmG,IAAI,IAAI,GACzG,KAAK,GACL,UAAU,GACV,UAAU;AACZ;;;;;GAKG;GACD,MAAM,GACN,aAAa,GACb,SAAS,GACT,OAAO,GACP,UAAU,GACV,MAAM,GACN,KAAK,GACL,OAAO,GACP,OAAO,GACP,WAAW,GACX,YAAY,GACZ,oBAAoB,GACpB,QAAQ,GACR,YAAY,GACZ,aAAa,GACb,YAAY,GACZ,aAAa,GACb,eAAe,GACf,aAAa,GACb,cAAc,GACd,cAAc,GACd,iBAAiB,GACjB,kBAAkB,GAClB,0BAA0B,GAC1B,OAAO,GACP,UAAU,GACV,MAAM,GACN,WAAW,GACX,SAAS,GACT,cAAc,GACd,MAAM,GACN,OAAO,GACP,MAAM,GACN,UAAU,GACV,OAAO,GACP,SAAS,GACT,KAAK,CAAC;AAEV,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAyC5D,CAAC"}
+{"version":3,"file":"token.d.ts","sourceRoot":"","sources":["../src/token.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAExC,MAAM,MAAM,SAAS,GACjB,YAAY,GACZ,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,gBAAgB,GAChB,YAAY,GACZ,OAAO,GACP,KAAK,GACL,KAAK,GACL,OAAO,GACP,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,IAAI,GACJ,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,MAAM,GACN,UAAU,GACV,OAAO,GACP,SAAS,GACT,UAAU,GACV,SAAS,GACT,QAAQ,GACR,OAAO,GACP,QAAQ,GACR,OAAO,GACP,QAAQ,GACR,IAAI,GACJ,MAAM,GACN,KAAK,GACL,IAAI,GACJ,OAAO,GACP,OAAO,GACP,UAAU,GACV,KAAK,GACL,OAAO,GACP,SAAS,GACT,MAAM,GACN,IAAI,GACJ,MAAM,GACN,OAAO,GACP,MAAM,GACN,KAAK,GACL,IAAI,GACJ,KAAK,GACL,SAAS,GACT,QAAQ,GACR,QAAQ,GACR,WAAW,GACX,YAAY,GACZ,aAAa,GACb,cAAc,GACd,WAAW,GACX,YAAY,GACZ,OAAO,GACP,OAAO;AACT,mGAAmG,IAAI,IAAI,GACzG,KAAK,GACL,UAAU,GACV,UAAU;AACZ;;;;;GAKG;GACD,MAAM,GACN,aAAa,GACb,SAAS,GACT,OAAO,GACP,UAAU,GACV,MAAM,GACN,KAAK,GACL,OAAO,GACP,OAAO,GACP,WAAW,GACX,YAAY,GACZ,oBAAoB,GACpB,QAAQ,GACR,YAAY,GACZ,aAAa,GACb,YAAY,GACZ,aAAa,GACb,eAAe,GACf,aAAa,GACb,cAAc,GACd,cAAc,GACd,iBAAiB,GACjB,kBAAkB,GAClB,0BAA0B,GAC1B,OAAO,GACP,UAAU,GACV,MAAM,GACN,WAAW,GACX,SAAS,GACT,cAAc,GACd,MAAM,GACN,OAAO,GACP,MAAM,GACN,UAAU,GACV,OAAO,GACP,SAAS,GACT,KAAK,CAAC;AAEV,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAyC5D,CAAC"}

package/dist/token.js.map

@@ -1 +1 @@
-{"version":3,"file":"token.js","sourceRoot":"","sources":["../src/token.ts"],"names":[],"mappings":"AAmHA;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,YAAY,GAAwC;IAC/D,KAAK,EAAE,OAAO;IACd,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,EAAE,EAAE,IAAI;IACR,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,IAAI,EAAE,MAAM;IACZ,QAAQ,EAAE,UAAU;IACpB,KAAK,EAAE,OAAO;IACd,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,UAAU;IACpB,OAAO,EAAE,SAAS;IAClB,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,QAAQ;IAChB,EAAE,EAAE,IAAI;IACR,IAAI,EAAE,MAAM;IACZ,GAAG,EAAE,KAAK;IACV,EAAE,EAAE,IAAI;IACR,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,QAAQ,EAAE,UAAU;IACpB,GAAG,EAAE,KAAK;IACV,KAAK,EAAE,OAAO;IACd,OAAO,EAAE,SAAS;IAClB,IAAI,EAAE,MAAM;IACZ,EAAE,EAAE,IAAI;IACR,IAAI,EAAE,MAAM;IACZ,KAAK,EAAE,OAAO;IACd,IAAI,EAAE,MAAM;IACZ,GAAG,EAAE,KAAK;IACV,EAAE,EAAE,IAAI;IACR,GAAG,EAAE,KAAK;CACX,CAAC"}
+{"version":3,"file":"token.js","sourceRoot":"","sources":["../src/token.ts"],"names":[],"mappings":"AA+HA;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,YAAY,GAAwC;IAC/D,KAAK,EAAE,OAAO;IACd,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,EAAE,EAAE,IAAI;IACR,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,IAAI,EAAE,MAAM;IACZ,QAAQ,EAAE,UAAU;IACpB,KAAK,EAAE,OAAO;IACd,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,UAAU;IACpB,OAAO,EAAE,SAAS;IAClB,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,QAAQ;IAChB,EAAE,EAAE,IAAI;IACR,IAAI,EAAE,MAAM;IACZ,GAAG,EAAE,KAAK;IACV,EAAE,EAAE,IAAI;IACR,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,QAAQ,EAAE,UAAU;IACpB,GAAG,EAAE,KAAK;IACV,KAAK,EAAE,OAAO;IACd,OAAO,EAAE,SAAS;IAClB,IAAI,EAAE,MAAM;IACZ,EAAE,EAAE,IAAI;IACR,IAAI,EAAE,MAAM;IACZ,KAAK,EAAE,OAAO;IACd,IAAI,EAAE,MAAM;IACZ,GAAG,EAAE,KAAK;IACV,EAAE,EAAE,IAAI;IACR,GAAG,EAAE,KAAK;CACX,CAAC"}

package/dist/type-registry-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"type-registry-runtime.d.ts","sourceRoot":"","sources":["../src/type-registry-runtime.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,QA2C3B,CAAC"}
+{"version":3,"file":"type-registry-runtime.d.ts","sourceRoot":"","sources":["../src/type-registry-runtime.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,QAkD3B,CAAC"}

package/dist/type-registry-runtime.js

@@ -42,7 +42,14 @@ function __velarRegisterRuntimeType(value) {
 }
 function __velarRequireRuntimeType(value, name, optional = false) {
   if (optional && value == null) return null;
-  if (!value || typeof value !== "object" || !__velarTypeCall(__velarTypeWeakSetHas, __velarRuntimeTypeRegistry, [value])) {
+  // Registry membership proves the value was registered somewhere in this
+  // realm; it does not prove it still presents the Type surface. A module built
+  // by another generation registers into the same WeakSet whenever both
+  // generations share the registry key, so the surface itself is asserted here:
+  // 'is' and 'parse' are the two operations every caller of this helper goes on
+  // to invoke.
+  if (!value || typeof value !== "object" || !__velarTypeCall(__velarTypeWeakSetHas, __velarRuntimeTypeRegistry, [value])
+    || typeof value.is !== "function" || typeof value.parse !== "function") {
     throw new __velarTypeNativeTypeError(name + " requires a compiler-known VelarScript runtime type");
   }
   return value;

package/dist/type-registry-runtime.js.map

@@ -1 +1 @@
-{"version":3,"file":"type-registry-runtime.js","sourceRoot":"","sources":["../src/type-registry-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAE3D;;;;GAIG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;kGAY6C,IAAI,CAAC,SAAS,CAAC,uBAAuB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BxI,CAAC,SAAS,EAAE,CAAC"}
+{"version":3,"file":"type-registry-runtime.js","sourceRoot":"","sources":["../src/type-registry-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAE3D;;;;GAIG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;kGAY6C,IAAI,CAAC,SAAS,CAAC,uBAAuB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsCxI,CAAC,SAAS,EAAE,CAAC"}

package/dist/type-validation-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"type-validation-runtime.d.ts","sourceRoot":"","sources":["../src/type-validation-runtime.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,QAgD7B,CAAC;AAEd,+DAA+D;AAC/D,eAAO,MAAM,qCAAqC,QAsCrC,CAAC;AAEd,eAAO,MAAM,8BAA8B,QAc9B,CAAC;AAEd,eAAO,MAAM,4BAA4B,oCAAoC,CAAC;AAE9E;;;;GAIG;AACH,eAAO,MAAM,mCAAmC,QA+BnC,CAAC"}
+{"version":3,"file":"type-validation-runtime.d.ts","sourceRoot":"","sources":["../src/type-validation-runtime.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,QAgL7B,CAAC;AAEd,+DAA+D;AAC/D,eAAO,MAAM,qCAAqC,QAsCrC,CAAC;AAEd,eAAO,MAAM,8BAA8B,QAc9B,CAAC;AAEd,eAAO,MAAM,4BAA4B,oCAAoC,CAAC;AAE9E;;;;GAIG;AACH,eAAO,MAAM,mCAAmC,QA+BnC,CAAC"}

package/dist/type-validation-runtime.js

@@ -24,11 +24,19 @@ const __velarValidationSetDeleteOperation = __velarCollectionGetOwnPropertyDescr
 const __velarValidationSetSizeOperation = __velarCollectionGetOwnPropertyDescriptor(__velarValidationSetPrototype, "size")?.get;
 const __velarValidationFunctionHasInstanceOperation = __velarCollectionGetOwnPropertyDescriptor(__velarValidationFunctionPrototype, __velarValidationHasInstanceSymbol)?.value;
 const __velarValidationFreezeOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionNativeObject, "freeze")?.value;
-function __velarValidationState() { return { active: new __velarValidationNativeWeakMap(), depth: 0 }; }
+const __velarValidationDefinePropertyOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionNativeObject, "defineProperty")?.value;
+const __velarValidationMapSetOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionMapPrototype, "set")?.value;
+const __velarValidationMapGetOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionMapPrototype, "get")?.value;
+// D90 rule R5: the per-call graph state carries both the validator's cycle
+// guard and the copy memo, because parse runs one then the other over the same
+// object graph. 'copies' stays null until something is actually copied.
+function __velarValidationState() { return { active: new __velarValidationNativeWeakMap(), depth: 0, copies: null, copy: __velarValidationCopy }; }
 function __velarValidationSet() { return new __velarValidationNativeSet(); }
 function __velarValidationWeakMapGet(value, key) { return __velarCollectionHostCall(__velarValidationWeakMapGetOperation, value, [key]); }
 function __velarValidationWeakMapSet(value, key, item) { return __velarCollectionHostCall(__velarValidationWeakMapSetOperation, value, [key, item]); }
 function __velarValidationWeakMapDelete(value, key) { return __velarCollectionHostCall(__velarValidationWeakMapDeleteOperation, value, [key]); }
+function __velarValidationMapGet(value, key) { return __velarCollectionHostCall(__velarValidationMapGetOperation, value, [key]); }
+function __velarValidationMapSet(value, key, item) { return __velarCollectionHostCall(__velarValidationMapSetOperation, value, [key, item]); }
 function __velarValidationSetHas(value, item) { return __velarCollectionHostCall(__velarValidationSetHasOperation, value, [item]); }
 function __velarValidationSetAdd(value, item) { return __velarCollectionHostCall(__velarValidationSetAddOperation, value, [item]); }
 function __velarValidationSetDelete(value, item) { return __velarCollectionHostCall(__velarValidationSetDeleteOperation, value, [item]); }
@@ -48,6 +56,126 @@ function __velarValidationIsPlainObject(value) {
   if (prototype === null) return true;
   return __velarCollectionHostCall(__velarCollectionGetPrototypeOf, __velarCollectionNativeObject, [prototype]) === null;
 }
+// D90 rule R5: parse returns a copy, so "validated" means "and it stays
+// valid" rather than "it was correct at the instant of the check". The copy
+// follows the declared shape — the generated validators supply one callback
+// per element position — and the memo answers per source object *and* copy
+// plan, so a shared or cyclic subgraph is copied once per declared shape and
+// the copy preserves the sharing the source had. Keying on the source alone
+// would hand the second projection of one object the first projection's copy:
+// a value the caller never wrote and no declared type ever accepted. The four
+// container members are spelled with an "Of" suffix because this runtime
+// reaches every host collection through a captured operation: no member call
+// inside it may read as a get, set, has, add, or delete call, which is the
+// boundary gate's rule for this file.
+const __velarValidationCopy = {
+  seen(state, value, plan) {
+    if (state.copies === null) return undefined;
+    const plans = __velarValidationWeakMapGet(state.copies, value);
+    return plans === undefined ? undefined : __velarValidationMapGet(plans, plan);
+  },
+  remember(state, value, copy, plan) {
+    if (state.copies === null) state.copies = new __velarValidationNativeWeakMap();
+    let plans = __velarValidationWeakMapGet(state.copies, value);
+    if (plans === undefined) {
+      plans = new __velarCollectionNativeMap();
+      __velarValidationWeakMapSet(state.copies, value, plans);
+    }
+    __velarValidationMapSet(plans, plan, copy);
+    return copy;
+  },
+  object(state, value, plan) {
+    return __velarValidationCopy.remember(state, value, {}, plan);
+  },
+  // Fields are written through defineProperty so a field literally named
+  // '__proto__' lands as an own data property instead of retargeting the
+  // copy's prototype, and so every copied field is an ordinary mutable
+  // enumerable data property whatever the source's descriptor said.
+  field(target, name, value) {
+    __velarCollectionHostCall(__velarValidationDefinePropertyOperation, __velarCollectionNativeObject, [target, name, { value: value, writable: true, enumerable: true, configurable: true }]);
+  },
+  // A null element callback means the element position has nothing to copy —
+  // a primitive, an enum member, a class instance, or an opaque 'unknown'.
+  // 'plan' is the container position's own stable identity: the emitter hoists
+  // one function per distinct copy plan and hands it in as both the element
+  // callback and the key this memo files the copy under.
+  listOf(value, state, item, plan) {
+    const found = __velarValidationCopy.seen(state, value, plan);
+    if (found !== undefined) return found;
+    const result = __velarValidationCopy.remember(state, value, [], plan);
+    const length = __velarValidationOwnDescriptor(value, "length")?.value ?? 0;
+    for (let index = 0; index < length; index += 1) {
+      const descriptor = __velarValidationOwnDescriptor(value, index);
+      result[index] = item === null ? descriptor?.value : item(descriptor?.value, state);
+    }
+    return result;
+  },
+  setOf(value, state, item, plan) {
+    const found = __velarValidationCopy.seen(state, value, plan);
+    if (found !== undefined) return found;
+    const result = __velarValidationCopy.remember(state, value, __velarValidationSet(), plan);
+    const iterator = __velarCollectionSetTypeIterator(value);
+    while (true) {
+      const step = __velarCollectionSetTypeNext(iterator);
+      if (step.done) break;
+      __velarValidationSetAdd(result, item === null ? step.value : item(step.value, state));
+    }
+    return result;
+  },
+  mapOf(value, state, key, item, plan) {
+    const found = __velarValidationCopy.seen(state, value, plan);
+    if (found !== undefined) return found;
+    const result = __velarValidationCopy.remember(state, value, new __velarCollectionNativeMap(), plan);
+    const iterator = __velarCollectionMapTypeIterator(value);
+    while (true) {
+      const step = __velarCollectionMapTypeNext(iterator);
+      if (step.done) break;
+      const entry = step.value;
+      __velarValidationMapSet(result, key === null ? entry[0] : key(entry[0], state), item === null ? entry[1] : item(entry[1], state));
+    }
+    return result;
+  },
+  recordOf(value, state, item, plan) {
+    const found = __velarValidationCopy.seen(state, value, plan);
+    if (found !== undefined) return found;
+    const result = __velarValidationCopy.remember(state, value, {}, plan);
+    const keys = __velarCollectionHostCall(__velarCollectionOwnKeys, __velarCollectionNativeReflect, [value]);
+    for (let index = 0; index < keys.length; index += 1) {
+      const name = keys[index];
+      if (typeof name !== "string") continue;
+      const descriptor = __velarValidationOwnDescriptor(value, name);
+      if (!descriptor?.enumerable || !("value" in descriptor)) continue;
+      __velarValidationCopy.field(result, name, item === null ? descriptor.value : item(descriptor.value, state));
+    }
+    return result;
+  },
+  // A generic instantiation supplies a predicate per type argument but no copy
+  // plan, and a structural or union position is validated as a shape the
+  // predicate did not fully decide. Both copy the plain data they can see:
+  // arrays, Maps, Sets, and plain objects recurse; anything else — a class
+  // instance, a promise, a function, a binary buffer — is not plain data and
+  // passes through by reference.
+  plain(value, state) {
+    if (value === null || typeof value !== "object") return value;
+    const found = __velarValidationCopy.seen(state, value, __velarValidationCopy.plain);
+    if (found !== undefined) return found;
+    if (__velarValidationIsArray(value)) return __velarValidationCopy.listOf(value, state, __velarValidationCopy.plain, __velarValidationCopy.plain);
+    if (__velarIsMap(value)) return __velarValidationCopy.mapOf(value, state, __velarValidationCopy.plain, __velarValidationCopy.plain, __velarValidationCopy.plain);
+    if (__velarIsSet(value)) return __velarValidationCopy.setOf(value, state, __velarValidationCopy.plain, __velarValidationCopy.plain);
+    if (!__velarValidationIsPlainObject(value)) return value;
+    return __velarValidationCopy.recordOf(value, state, __velarValidationCopy.plain, __velarValidationCopy.plain);
+  },
+  // A Type object from a target extension, or one emitted by an older build,
+  // may carry no copy plan; the structural copy is what is left to fall back on.
+  // A Type that does answer 'copy' owns its own plan identity — a declared
+  // record files under its copy function, an instantiation under its arguments
+  // — so nothing is threaded in from here.
+  through(type, value, state) {
+    const operation = type === null || type === undefined ? undefined : type.copy;
+    if (typeof operation !== "function") return __velarValidationCopy.plain(value, state);
+    return __velarCollectionHostCall(operation, type, [value, state]);
+  },
+};
 // Teaching suffix for record parse failures caused by the plain-object rule.
 function __velarValidationRejectionHint(value) {
   if (value === null || typeof value !== "object" || __velarValidationIsArray(value) || __velarValidationIsPlainObject(value)) return "";

package/dist/type-validation-runtime.js.map

@@ -1 +1 @@
-{"version":3,"file":"type-validation-runtime.js","sourceRoot":"","sources":["../src/type-validation-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iCAAiC,EAAE,6BAA6B,EAAE,MAAM,yBAAyB,CAAC;AAC3G,OAAO,EAAE,2BAA2B,EAAE,MAAM,4BAA4B,CAAC;AAEzE;;;;GAIG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDtD,CAAC,SAAS,EAAE,CAAC;AAEd,+DAA+D;AAC/D,MAAM,CAAC,MAAM,qCAAqC,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsC9D,CAAC,SAAS,EAAE,CAAC;AAEd,MAAM,CAAC,MAAM,8BAA8B,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;CAcvD,CAAC,SAAS,EAAE,CAAC;AAEd,MAAM,CAAC,MAAM,4BAA4B,GAAG,iCAAiC,CAAC;AAE9E;;;;GAIG;AACH,MAAM,CAAC,MAAM,mCAAmC,GAAG,MAAM,CAAC,GAAG,CAAA;EAC3D,iCAAiC;EACjC,6BAA6B;EAC7B,2BAA2B;EAC3B,6BAA6B;EAC7B,qCAAqC;EACrC,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;CAyB/B,CAAC,SAAS,EAAE,CAAC"}
+{"version":3,"file":"type-validation-runtime.js","sourceRoot":"","sources":["../src/type-validation-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iCAAiC,EAAE,6BAA6B,EAAE,MAAM,yBAAyB,CAAC;AAC3G,OAAO,EAAE,2BAA2B,EAAE,MAAM,4BAA4B,CAAC;AAEzE;;;;GAIG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgLtD,CAAC,SAAS,EAAE,CAAC;AAEd,+DAA+D;AAC/D,MAAM,CAAC,MAAM,qCAAqC,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsC9D,CAAC,SAAS,EAAE,CAAC;AAEd,MAAM,CAAC,MAAM,8BAA8B,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;CAcvD,CAAC,SAAS,EAAE,CAAC;AAEd,MAAM,CAAC,MAAM,4BAA4B,GAAG,iCAAiC,CAAC;AAE9E;;;;GAIG;AACH,MAAM,CAAC,MAAM,mCAAmC,GAAG,MAAM,CAAC,GAAG,CAAA;EAC3D,iCAAiC;EACjC,6BAA6B;EAC7B,2BAA2B;EAC3B,6BAA6B;EAC7B,qCAAqC;EACrC,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;CAyB/B,CAAC,SAAS,EAAE,CAAC"}

package/dist/types.d.ts

@@ -69,9 +69,16 @@ export interface GenericApplication {
     readonly name: string;
     readonly arguments: readonly ValueType[];
 }
-export type ValueType = {
+export type ValueType = 
+/**
+ * `restricted` is the recursion placeholder and `boundary` is the `unknown`
+ * a program wrote down — the type of data nobody has checked yet. Neither
+ * may be absorbed by a merge; see `mergeTypes`.
+ */
+{
     readonly kind: "unknown";
     readonly restricted?: boolean;
+    readonly boundary?: true;
 }
 /**
  * `textConvertible` marks the compiler-owned text-conversion domain (charter
@@ -212,6 +219,14 @@ export type BinaryStorageKind = "bytes" | "uint8" | "uint16" | "uint32" | "float
  */
 export declare function binaryStorageKind(type: ValueType): BinaryStorageKind | null;
 export declare const unknownType: ValueType;
+/**
+ * The `unknown` a program wrote in an annotation, and the type every boundary
+ * that hands back unchecked data should carry. It differs from the inference
+ * seed above in exactly one rule — a merge may not absorb it — so `unknown`
+ * arriving from outside stays unassignable until the value is validated,
+ * instead of being retyped as whatever the other branch produced.
+ */
+export declare const boundaryUnknownType: ValueType;
 export declare const invalidType: ValueType;
 export declare const anyType: ValueType;
 /** The declared parameter domain of the built-in `str`; see `isTextConvertibleType`. */
@@ -320,6 +335,7 @@ export declare function typeContainsParameter(type: ValueType, matches?: (parame
     kind: "parameter";
 }>) => boolean): boolean;
 export declare function typeContainsRuntimeTypeCheck(type: ValueType): boolean;
+export declare function typeContainsAnyOutput(type: ValueType): boolean;
 export declare function substituteTypeParameters(type: ValueType, bindings: readonly (ValueType | null)[]): ValueType;
 export declare function bindNamedTypeParameters(type: ValueType, parameters: ReadonlyMap<string, ValueType>): ValueType;
 /**