@velarscript/compiler 0.10.1

package/dist/collection-lowering-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection-lowering-runtime.js","sourceRoot":"","sources":["../src/collection-lowering-runtime.ts"],"names":[],"mappings":"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"}

package/dist/collection-runtime.d.ts

@@ -0,0 +1,16 @@
+/** Canonical generated runtime for collection identity and runtime-Type traversal. */
+export declare const VELAR_COLLECTION_IDENTITY_RUNTIME: string;
+/** Additional host traversal used only when a module emits runtime collection Types. */
+export declare const VELAR_COLLECTION_TYPE_RUNTIME: string;
+/** Host operations required by ordinary List validation and receiver methods. */
+export declare const VELAR_COLLECTION_LIST_RUNTIME: string;
+/** Host operations required by ordinary Set and Map construction and receiver methods. */
+export declare const VELAR_COLLECTION_SET_MAP_RUNTIME: string;
+/** Host operations required by ordinary Record validation and receiver methods. */
+export declare const VELAR_COLLECTION_RECORD_RUNTIME: string;
+export declare const VELAR_COLLECTION_HOST_MODULE = "velar/compiler-runtime-collections-v1";
+/** Names consumed by module-local collection algorithms from the shared host ABI. */
+export declare const VELAR_COLLECTION_HOST_EXPORTS: readonly ["__velarCollectionNativeArray", "__velarCollectionNativeMap", "__velarCollectionNativeSet", "__velarCollectionNativeObject", "__velarCollectionNativeTypeError", "__velarCollectionGetPrototypeOf", "__velarCollectionObjectPrototype", "__velarCollectionHostCall", "__velarIsMap", "__velarIsSet", "__velarIsRecord", "__velarCollectionListNativeRangeError", "__velarCollectionListIsArray", "__velarCollectionListGetOwnPropertyDescriptor", "__velarCollectionListOwnNames", "__velarCollectionListOwnSymbols", "__velarCollectionListDefineProperty", "__velarCollectionListObjectIs", "__velarCollectionListIsInteger", "__velarCollectionListIsNaN", "__velarCollectionListIsFinite", "__velarCollectionListMaximum", "__velarCollectionListMinimum", "__velarCollectionListHostJoin", "__velarCollectionListHostSort", "__velarCollectionListHostReverse", "__velarCollectionSetMapNativeRangeError", "__velarCollectionSetMapFreeze", "__velarCollectionSetMapSetSize", "__velarCollectionSetMapMapSize", "__velarCollectionSetMapSetAdd", "__velarCollectionSetMapSetHas", "__velarCollectionSetMapSetDelete", "__velarCollectionSetMapSetClear", "__velarCollectionSetMapSetValues", "__velarCollectionSetMapSetNext", "__velarCollectionSetMapMapGet", "__velarCollectionSetMapMapSet", "__velarCollectionSetMapMapHas", "__velarCollectionSetMapMapDelete", "__velarCollectionSetMapMapClear", "__velarCollectionSetMapMapKeys", "__velarCollectionSetMapMapValues", "__velarCollectionSetMapMapEntries", "__velarCollectionSetMapMapNext", "__velarCollectionRecordNativeRangeError", "__velarCollectionRecordGetOwnPropertyDescriptor", "__velarCollectionRecordOwnNames", "__velarCollectionRecordOwnSymbols", "__velarCollectionRecordDefineProperty", "__velarCollectionRecordObjectIs", "__velarCollectionRecordDeleteProperty", "__velarCollectionRecordFreeze"];
+/** Project-shared immutable host operations for module-local collection algorithms. */
+export declare const VELAR_COLLECTION_HOST_MODULE_SOURCE: string;
+//# sourceMappingURL=collection-runtime.d.ts.map

package/dist/collection-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection-runtime.d.ts","sourceRoot":"","sources":["../src/collection-runtime.ts"],"names":[],"mappings":"AAAA,sFAAsF;AACtF,eAAO,MAAM,iCAAiC,QAuDjC,CAAC;AAEd,wFAAwF;AACxF,eAAO,MAAM,6BAA6B,QAc7B,CAAC;AAEd,iFAAiF;AACjF,eAAO,MAAM,6BAA6B,QA+B7B,CAAC;AAEd,0FAA0F;AAC1F,eAAO,MAAM,gCAAgC,QAsChC,CAAC;AAEd,mFAAmF;AACnF,eAAO,MAAM,+BAA+B,QAe/B,CAAC;AAEd,eAAO,MAAM,4BAA4B,0CAA0C,CAAC;AAEpF,qFAAqF;AACrF,eAAO,MAAM,6BAA6B,YACxC,8BAA8B,EAC9B,4BAA4B,EAC5B,4BAA4B,EAC5B,+BAA+B,EAC/B,kCAAkC,EAClC,iCAAiC,EACjC,kCAAkC,EAClC,2BAA2B,EAC3B,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,uCAAuC,EACvC,8BAA8B,EAC9B,+CAA+C,EAC/C,+BAA+B,EAC/B,iCAAiC,EACjC,qCAAqC,EACrC,+BAA+B,EAC/B,gCAAgC,EAChC,4BAA4B,EAC5B,+BAA+B,EAC/B,8BAA8B,EAC9B,8BAA8B,EAC9B,+BAA+B,EAC/B,+BAA+B,EAC/B,kCAAkC,EAClC,yCAAyC,EACzC,+BAA+B,EAC/B,gCAAgC,EAChC,gCAAgC,EAChC,+BAA+B,EAC/B,+BAA+B,EAC/B,kCAAkC,EAClC,iCAAiC,EACjC,kCAAkC,EAClC,gCAAgC,EAChC,+BAA+B,EAC/B,+BAA+B,EAC/B,+BAA+B,EAC/B,kCAAkC,EAClC,iCAAiC,EACjC,gCAAgC,EAChC,kCAAkC,EAClC,mCAAmC,EACnC,gCAAgC,EAChC,yCAAyC,EACzC,iDAAiD,EACjD,iCAAiC,EACjC,mCAAmC,EACnC,uCAAuC,EACvC,iCAAiC,EACjC,uCAAuC,EACvC,+BAA+B,CACvB,CAAC;AAEX,uFAAuF;AACvF,eAAO,MAAM,mCAAmC,QAQnC,CAAC"}

package/dist/collection-runtime.js

@@ -0,0 +1,231 @@
+/** Canonical generated runtime for collection identity and runtime-Type traversal. */
+export const VELAR_COLLECTION_IDENTITY_RUNTIME = String.raw `
+const __velarCollectionNativeArray = globalThis.Array;
+const __velarCollectionNativeMap = globalThis.Map;
+const __velarCollectionNativeSet = globalThis.Set;
+const __velarCollectionNativeObject = globalThis.Object;
+const __velarCollectionNativeReflect = globalThis.Reflect;
+const __velarCollectionNativeWeakMap = globalThis.WeakMap;
+const __velarCollectionNativeTypeError = globalThis.TypeError;
+const __velarCollectionGetOwnPropertyDescriptor = __velarCollectionNativeObject.getOwnPropertyDescriptor;
+const __velarCollectionReflectApply = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionNativeReflect, "apply")?.value;
+const __velarCollectionArrayIsArray = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionNativeArray, "isArray")?.value;
+const __velarCollectionGetPrototypeOf = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionNativeObject, "getPrototypeOf")?.value;
+const __velarCollectionObjectPrototype = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionNativeObject, "prototype")?.value;
+const __velarCollectionMapPrototype = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionNativeMap, "prototype")?.value;
+const __velarCollectionSetPrototype = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionNativeSet, "prototype")?.value;
+const __velarCollectionMapSize = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionMapPrototype, "size")?.get;
+const __velarCollectionSetSize = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionSetPrototype, "size")?.get;
+function __velarCollectionHostCall(operation, receiver, arguments_) {
+  if (typeof operation !== "function" || typeof __velarCollectionReflectApply !== "function") throw new __velarCollectionNativeTypeError("The JavaScript collection runtime is unavailable");
+  return __velarCollectionReflectApply(operation, receiver, arguments_);
+}
+const __velarCollectionWeakMapPrototype = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionNativeWeakMap, "prototype")?.value;
+const __velarCollectionWeakMapGetOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionWeakMapPrototype, "get")?.value;
+const __velarCollectionWeakMapSetOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionWeakMapPrototype, "set")?.value;
+const __velarCollectionBrands = new __velarCollectionNativeWeakMap();
+// The only unforgeable, cross-realm Map/Set test JavaScript offers is invoking
+// the prototype 'size' getter and observing whether it throws, and a thrown and
+// caught exception costs roughly 1.8us -- paid by every Set membership test,
+// which probes Map first. Internal slots are fixed at construction, so the
+// verdict can never change for a given object: probe once, then answer from a
+// WeakMap. 0 = neither, 1 = Map, 2 = Set.
+function __velarCollectionBrand(value) {
+  if (value === null || (typeof value !== "object" && typeof value !== "function")) return 0;
+  const known = __velarCollectionHostCall(__velarCollectionWeakMapGetOperation, __velarCollectionBrands, [value]);
+  if (known !== undefined) return known;
+  let brand = 0;
+  try { __velarCollectionHostCall(__velarCollectionMapSize, value, []); brand = 1; }
+  catch {
+    try { __velarCollectionHostCall(__velarCollectionSetSize, value, []); brand = 2; }
+    catch { brand = 0; }
+  }
+  __velarCollectionHostCall(__velarCollectionWeakMapSetOperation, __velarCollectionBrands, [value, brand]);
+  return brand;
+}
+function __velarIsMap(value) {
+  return __velarCollectionBrand(value) === 1;
+}
+function __velarIsSet(value) {
+  return __velarCollectionBrand(value) === 2;
+}
+function __velarIsRecord(value) {
+  if (value === null || typeof value !== "object" || __velarCollectionHostCall(__velarCollectionArrayIsArray, __velarCollectionNativeArray, [value])) return false;
+  const prototype = __velarCollectionHostCall(__velarCollectionGetPrototypeOf, __velarCollectionNativeObject, [value]);
+  return prototype === __velarCollectionObjectPrototype || prototype === null;
+}
+`.trimStart();
+/** Additional host traversal used only when a module emits runtime collection Types. */
+export const VELAR_COLLECTION_TYPE_RUNTIME = String.raw `
+const __velarCollectionOwnNames = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionNativeObject, "getOwnPropertyNames")?.value;
+const __velarCollectionOwnSymbols = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionNativeObject, "getOwnPropertySymbols")?.value;
+const __velarCollectionOwnKeys = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionNativeReflect, "ownKeys")?.value;
+const __velarCollectionMapEntries = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionMapPrototype, "entries")?.value;
+const __velarCollectionSetValues = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionSetPrototype, "values")?.value;
+const __velarCollectionMapIteratorPrototype = __velarCollectionHostCall(__velarCollectionGetPrototypeOf, __velarCollectionNativeObject, [__velarCollectionHostCall(__velarCollectionMapEntries, new __velarCollectionNativeMap(), [])]);
+const __velarCollectionSetIteratorPrototype = __velarCollectionHostCall(__velarCollectionGetPrototypeOf, __velarCollectionNativeObject, [__velarCollectionHostCall(__velarCollectionSetValues, new __velarCollectionNativeSet(), [])]);
+const __velarCollectionMapIteratorNext = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionMapIteratorPrototype, "next")?.value;
+const __velarCollectionSetIteratorNext = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionSetIteratorPrototype, "next")?.value;
+function __velarCollectionMapTypeIterator(value) { return __velarCollectionHostCall(__velarCollectionMapEntries, value, []); }
+function __velarCollectionSetTypeIterator(value) { return __velarCollectionHostCall(__velarCollectionSetValues, value, []); }
+function __velarCollectionMapTypeNext(iterator) { return __velarCollectionHostCall(__velarCollectionMapIteratorNext, iterator, []); }
+function __velarCollectionSetTypeNext(iterator) { return __velarCollectionHostCall(__velarCollectionSetIteratorNext, iterator, []); }
+`.trimStart();
+/** Host operations required by ordinary List validation and receiver methods. */
+export const VELAR_COLLECTION_LIST_RUNTIME = String.raw `
+const __velarCollectionListNativeNumber = globalThis.Number;
+const __velarCollectionListNativeMath = globalThis.Math;
+const __velarCollectionListNativeRangeError = globalThis.RangeError;
+const __velarCollectionListArrayPrototype = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionNativeArray, "prototype")?.value;
+const __velarCollectionListOwnNamesOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionNativeObject, "getOwnPropertyNames")?.value;
+const __velarCollectionListOwnSymbolsOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionNativeObject, "getOwnPropertySymbols")?.value;
+const __velarCollectionListDefinePropertyOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionNativeObject, "defineProperty")?.value;
+const __velarCollectionListObjectIsOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionNativeObject, "is")?.value;
+const __velarCollectionListIntegerOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionListNativeNumber, "isInteger")?.value;
+const __velarCollectionListNaNOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionListNativeNumber, "isNaN")?.value;
+const __velarCollectionListFiniteOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionListNativeNumber, "isFinite")?.value;
+const __velarCollectionListMaximumOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionListNativeMath, "max")?.value;
+const __velarCollectionListMinimumOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionListNativeMath, "min")?.value;
+const __velarCollectionListJoinOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionListArrayPrototype, "join")?.value;
+const __velarCollectionListSortOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionListArrayPrototype, "sort")?.value;
+const __velarCollectionListReverseOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionListArrayPrototype, "reverse")?.value;
+function __velarCollectionListIsArray(value) { return __velarCollectionHostCall(__velarCollectionArrayIsArray, __velarCollectionNativeArray, [value]); }
+function __velarCollectionListGetOwnPropertyDescriptor(value, key) { return __velarCollectionHostCall(__velarCollectionGetOwnPropertyDescriptor, __velarCollectionNativeObject, [value, key]); }
+function __velarCollectionListOwnNames(value) { return __velarCollectionHostCall(__velarCollectionListOwnNamesOperation, __velarCollectionNativeObject, [value]); }
+function __velarCollectionListOwnSymbols(value) { return __velarCollectionHostCall(__velarCollectionListOwnSymbolsOperation, __velarCollectionNativeObject, [value]); }
+function __velarCollectionListDefineProperty(value, key, descriptor) { return __velarCollectionHostCall(__velarCollectionListDefinePropertyOperation, __velarCollectionNativeObject, [value, key, descriptor]); }
+function __velarCollectionListObjectIs(left, right) { return __velarCollectionHostCall(__velarCollectionListObjectIsOperation, __velarCollectionNativeObject, [left, right]); }
+function __velarCollectionListIsInteger(value) { return __velarCollectionHostCall(__velarCollectionListIntegerOperation, __velarCollectionListNativeNumber, [value]); }
+function __velarCollectionListIsNaN(value) { return __velarCollectionHostCall(__velarCollectionListNaNOperation, __velarCollectionListNativeNumber, [value]); }
+function __velarCollectionListIsFinite(value) { return __velarCollectionHostCall(__velarCollectionListFiniteOperation, __velarCollectionListNativeNumber, [value]); }
+function __velarCollectionListMaximum(...values) { return __velarCollectionHostCall(__velarCollectionListMaximumOperation, __velarCollectionListNativeMath, values); }
+function __velarCollectionListMinimum(...values) { return __velarCollectionHostCall(__velarCollectionListMinimumOperation, __velarCollectionListNativeMath, values); }
+function __velarCollectionListHostJoin(value, separator) { return __velarCollectionHostCall(__velarCollectionListJoinOperation, value, [separator]); }
+function __velarCollectionListHostSort(value, compare) { return __velarCollectionHostCall(__velarCollectionListSortOperation, value, [compare]); }
+function __velarCollectionListHostReverse(value) { return __velarCollectionHostCall(__velarCollectionListReverseOperation, value, []); }
+`.trimStart();
+/** Host operations required by ordinary Set and Map construction and receiver methods. */
+export const VELAR_COLLECTION_SET_MAP_RUNTIME = String.raw `
+const __velarCollectionSetMapNativeRangeError = globalThis.RangeError;
+const __velarCollectionSetMapFreezeOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionNativeObject, "freeze")?.value;
+const __velarCollectionSetAddOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionSetPrototype, "add")?.value;
+const __velarCollectionSetHasOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionSetPrototype, "has")?.value;
+const __velarCollectionSetDeleteOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionSetPrototype, "delete")?.value;
+const __velarCollectionSetClearOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionSetPrototype, "clear")?.value;
+const __velarCollectionSetValuesOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionSetPrototype, "values")?.value;
+const __velarCollectionMapGetOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionMapPrototype, "get")?.value;
+const __velarCollectionMapSetOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionMapPrototype, "set")?.value;
+const __velarCollectionMapHasOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionMapPrototype, "has")?.value;
+const __velarCollectionMapDeleteOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionMapPrototype, "delete")?.value;
+const __velarCollectionMapClearOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionMapPrototype, "clear")?.value;
+const __velarCollectionMapKeysOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionMapPrototype, "keys")?.value;
+const __velarCollectionMapValuesOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionMapPrototype, "values")?.value;
+const __velarCollectionMapEntriesOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionMapPrototype, "entries")?.value;
+const __velarCollectionSetMapMapIteratorPrototype = __velarCollectionHostCall(__velarCollectionGetPrototypeOf, __velarCollectionNativeObject, [__velarCollectionHostCall(__velarCollectionMapEntriesOperation, new __velarCollectionNativeMap(), [])]);
+const __velarCollectionSetMapSetIteratorPrototype = __velarCollectionHostCall(__velarCollectionGetPrototypeOf, __velarCollectionNativeObject, [__velarCollectionHostCall(__velarCollectionSetValuesOperation, new __velarCollectionNativeSet(), [])]);
+const __velarCollectionSetMapMapIteratorNext = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionSetMapMapIteratorPrototype, "next")?.value;
+const __velarCollectionSetMapSetIteratorNext = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionSetMapSetIteratorPrototype, "next")?.value;
+function __velarCollectionSetMapFreeze(value) { return __velarCollectionHostCall(__velarCollectionSetMapFreezeOperation, __velarCollectionNativeObject, [value]); }
+function __velarCollectionSetMapSetSize(value) { return __velarCollectionHostCall(__velarCollectionSetSize, value, []); }
+function __velarCollectionSetMapMapSize(value) { return __velarCollectionHostCall(__velarCollectionMapSize, value, []); }
+function __velarCollectionSetMapSetAdd(value, item) { return __velarCollectionHostCall(__velarCollectionSetAddOperation, value, [item]); }
+function __velarCollectionSetMapSetHas(value, item) { return __velarCollectionHostCall(__velarCollectionSetHasOperation, value, [item]); }
+function __velarCollectionSetMapSetDelete(value, item) { return __velarCollectionHostCall(__velarCollectionSetDeleteOperation, value, [item]); }
+function __velarCollectionSetMapSetClear(value) { return __velarCollectionHostCall(__velarCollectionSetClearOperation, value, []); }
+function __velarCollectionSetMapSetValues(value) { return __velarCollectionHostCall(__velarCollectionSetValuesOperation, value, []); }
+function __velarCollectionSetMapSetNext(iterator) { return __velarCollectionHostCall(__velarCollectionSetMapSetIteratorNext, iterator, []); }
+function __velarCollectionSetMapMapGet(value, key) { return __velarCollectionHostCall(__velarCollectionMapGetOperation, value, [key]); }
+function __velarCollectionSetMapMapSet(value, key, item) { return __velarCollectionHostCall(__velarCollectionMapSetOperation, value, [key, item]); }
+function __velarCollectionSetMapMapHas(value, key) { return __velarCollectionHostCall(__velarCollectionMapHasOperation, value, [key]); }
+function __velarCollectionSetMapMapDelete(value, key) { return __velarCollectionHostCall(__velarCollectionMapDeleteOperation, value, [key]); }
+function __velarCollectionSetMapMapClear(value) { return __velarCollectionHostCall(__velarCollectionMapClearOperation, value, []); }
+function __velarCollectionSetMapMapKeys(value) { return __velarCollectionHostCall(__velarCollectionMapKeysOperation, value, []); }
+function __velarCollectionSetMapMapValues(value) { return __velarCollectionHostCall(__velarCollectionMapValuesOperation, value, []); }
+function __velarCollectionSetMapMapEntries(value) { return __velarCollectionHostCall(__velarCollectionMapEntriesOperation, value, []); }
+function __velarCollectionSetMapMapNext(iterator) { return __velarCollectionHostCall(__velarCollectionSetMapMapIteratorNext, iterator, []); }
+`.trimStart();
+/** Host operations required by ordinary Record validation and receiver methods. */
+export const VELAR_COLLECTION_RECORD_RUNTIME = String.raw `
+const __velarCollectionRecordNativeRangeError = globalThis.RangeError;
+const __velarCollectionRecordOwnNamesOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionNativeObject, "getOwnPropertyNames")?.value;
+const __velarCollectionRecordOwnSymbolsOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionNativeObject, "getOwnPropertySymbols")?.value;
+const __velarCollectionRecordDefinePropertyOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionNativeObject, "defineProperty")?.value;
+const __velarCollectionRecordObjectIsOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionNativeObject, "is")?.value;
+const __velarCollectionRecordDeletePropertyOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionNativeReflect, "deleteProperty")?.value;
+const __velarCollectionRecordFreezeOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionNativeObject, "freeze")?.value;
+function __velarCollectionRecordGetOwnPropertyDescriptor(value, key) { return __velarCollectionHostCall(__velarCollectionGetOwnPropertyDescriptor, __velarCollectionNativeObject, [value, key]); }
+function __velarCollectionRecordOwnNames(value) { return __velarCollectionHostCall(__velarCollectionRecordOwnNamesOperation, __velarCollectionNativeObject, [value]); }
+function __velarCollectionRecordOwnSymbols(value) { return __velarCollectionHostCall(__velarCollectionRecordOwnSymbolsOperation, __velarCollectionNativeObject, [value]); }
+function __velarCollectionRecordDefineProperty(value, key, descriptor) { return __velarCollectionHostCall(__velarCollectionRecordDefinePropertyOperation, __velarCollectionNativeObject, [value, key, descriptor]); }
+function __velarCollectionRecordObjectIs(left, right) { return __velarCollectionHostCall(__velarCollectionRecordObjectIsOperation, __velarCollectionNativeObject, [left, right]); }
+function __velarCollectionRecordDeleteProperty(value, key) { return __velarCollectionHostCall(__velarCollectionRecordDeletePropertyOperation, __velarCollectionNativeReflect, [value, key]); }
+function __velarCollectionRecordFreeze(value) { return __velarCollectionHostCall(__velarCollectionRecordFreezeOperation, __velarCollectionNativeObject, [value]); }
+`.trimStart();
+export const VELAR_COLLECTION_HOST_MODULE = "velar/compiler-runtime-collections-v1";
+/** Names consumed by module-local collection algorithms from the shared host ABI. */
+export const VELAR_COLLECTION_HOST_EXPORTS = [
+    "__velarCollectionNativeArray",
+    "__velarCollectionNativeMap",
+    "__velarCollectionNativeSet",
+    "__velarCollectionNativeObject",
+    "__velarCollectionNativeTypeError",
+    "__velarCollectionGetPrototypeOf",
+    "__velarCollectionObjectPrototype",
+    "__velarCollectionHostCall",
+    "__velarIsMap",
+    "__velarIsSet",
+    "__velarIsRecord",
+    "__velarCollectionListNativeRangeError",
+    "__velarCollectionListIsArray",
+    "__velarCollectionListGetOwnPropertyDescriptor",
+    "__velarCollectionListOwnNames",
+    "__velarCollectionListOwnSymbols",
+    "__velarCollectionListDefineProperty",
+    "__velarCollectionListObjectIs",
+    "__velarCollectionListIsInteger",
+    "__velarCollectionListIsNaN",
+    "__velarCollectionListIsFinite",
+    "__velarCollectionListMaximum",
+    "__velarCollectionListMinimum",
+    "__velarCollectionListHostJoin",
+    "__velarCollectionListHostSort",
+    "__velarCollectionListHostReverse",
+    "__velarCollectionSetMapNativeRangeError",
+    "__velarCollectionSetMapFreeze",
+    "__velarCollectionSetMapSetSize",
+    "__velarCollectionSetMapMapSize",
+    "__velarCollectionSetMapSetAdd",
+    "__velarCollectionSetMapSetHas",
+    "__velarCollectionSetMapSetDelete",
+    "__velarCollectionSetMapSetClear",
+    "__velarCollectionSetMapSetValues",
+    "__velarCollectionSetMapSetNext",
+    "__velarCollectionSetMapMapGet",
+    "__velarCollectionSetMapMapSet",
+    "__velarCollectionSetMapMapHas",
+    "__velarCollectionSetMapMapDelete",
+    "__velarCollectionSetMapMapClear",
+    "__velarCollectionSetMapMapKeys",
+    "__velarCollectionSetMapMapValues",
+    "__velarCollectionSetMapMapEntries",
+    "__velarCollectionSetMapMapNext",
+    "__velarCollectionRecordNativeRangeError",
+    "__velarCollectionRecordGetOwnPropertyDescriptor",
+    "__velarCollectionRecordOwnNames",
+    "__velarCollectionRecordOwnSymbols",
+    "__velarCollectionRecordDefineProperty",
+    "__velarCollectionRecordObjectIs",
+    "__velarCollectionRecordDeleteProperty",
+    "__velarCollectionRecordFreeze",
+];
+/** Project-shared immutable host operations for module-local collection algorithms. */
+export const VELAR_COLLECTION_HOST_MODULE_SOURCE = String.raw `
+${VELAR_COLLECTION_IDENTITY_RUNTIME}
+${VELAR_COLLECTION_LIST_RUNTIME}
+${VELAR_COLLECTION_SET_MAP_RUNTIME}
+${VELAR_COLLECTION_RECORD_RUNTIME}
+export {
+${VELAR_COLLECTION_HOST_EXPORTS.map((name) => `  ${name},`).join("\n")}
+};
+`.trimStart();
+//# sourceMappingURL=collection-runtime.js.map

package/dist/collection-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection-runtime.js","sourceRoot":"","sources":["../src/collection-runtime.ts"],"names":[],"mappings":"AAAA,sFAAsF;AACtF,MAAM,CAAC,MAAM,iCAAiC,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuD1D,CAAC,SAAS,EAAE,CAAC;AAEd,wFAAwF;AACxF,MAAM,CAAC,MAAM,6BAA6B,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;CActD,CAAC,SAAS,EAAE,CAAC;AAEd,iFAAiF;AACjF,MAAM,CAAC,MAAM,6BAA6B,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BtD,CAAC,SAAS,EAAE,CAAC;AAEd,0FAA0F;AAC1F,MAAM,CAAC,MAAM,gCAAgC,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsCzD,CAAC,SAAS,EAAE,CAAC;AAEd,mFAAmF;AACnF,MAAM,CAAC,MAAM,+BAA+B,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;CAexD,CAAC,SAAS,EAAE,CAAC;AAEd,MAAM,CAAC,MAAM,4BAA4B,GAAG,uCAAuC,CAAC;AAEpF,qFAAqF;AACrF,MAAM,CAAC,MAAM,6BAA6B,GAAG;IAC3C,8BAA8B;IAC9B,4BAA4B;IAC5B,4BAA4B;IAC5B,+BAA+B;IAC/B,kCAAkC;IAClC,iCAAiC;IACjC,kCAAkC;IAClC,2BAA2B;IAC3B,cAAc;IACd,cAAc;IACd,iBAAiB;IACjB,uCAAuC;IACvC,8BAA8B;IAC9B,+CAA+C;IAC/C,+BAA+B;IAC/B,iCAAiC;IACjC,qCAAqC;IACrC,+BAA+B;IAC/B,gCAAgC;IAChC,4BAA4B;IAC5B,+BAA+B;IAC/B,8BAA8B;IAC9B,8BAA8B;IAC9B,+BAA+B;IAC/B,+BAA+B;IAC/B,kCAAkC;IAClC,yCAAyC;IACzC,+BAA+B;IAC/B,gCAAgC;IAChC,gCAAgC;IAChC,+BAA+B;IAC/B,+BAA+B;IAC/B,kCAAkC;IAClC,iCAAiC;IACjC,kCAAkC;IAClC,gCAAgC;IAChC,+BAA+B;IAC/B,+BAA+B;IAC/B,+BAA+B;IAC/B,kCAAkC;IAClC,iCAAiC;IACjC,gCAAgC;IAChC,kCAAkC;IAClC,mCAAmC;IACnC,gCAAgC;IAChC,yCAAyC;IACzC,iDAAiD;IACjD,iCAAiC;IACjC,mCAAmC;IACnC,uCAAuC;IACvC,iCAAiC;IACjC,uCAAuC;IACvC,+BAA+B;CACvB,CAAC;AAEX,uFAAuF;AACvF,MAAM,CAAC,MAAM,mCAAmC,GAAG,MAAM,CAAC,GAAG,CAAA;EAC3D,iCAAiC;EACjC,6BAA6B;EAC7B,gCAAgC;EAChC,+BAA+B;;EAE/B,6BAA6B,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;;CAErE,CAAC,SAAS,EAAE,CAAC"}

package/dist/core-vocabulary.d.ts

@@ -0,0 +1,141 @@
+/**
+ * D57 rules 134/135 and D62 rules 157/158: the one roster of Core's own
+ * vocabulary — the permanent (resident) namespaces, the prelude names that
+ * need no import, the contextual keywords, and the numeric suffixes.
+ *
+ * Every place that has to know the whole vocabulary derives it from here: the
+ * analyzer's builtin table is keyed by these names, and `source-names.ts`
+ * refuses them as binding spellings by reading this roster rather than by
+ * restating it. Before that, the refusal list was a hand-kept copy of the
+ * JavaScript globals, so `Math` was protected only because it happens to be a
+ * JavaScript global too, while `Json`, `Promise`, `Text`, `equals`, and
+ * `range` were not protected at all. Adding a namespace or a prelude name
+ * here is now the whole change; nothing downstream can stay behind.
+ *
+ * The contextual keywords arrived the same way and worse: D62 rule 157 found
+ * four partial copies (`parser.ts` knew one word by table and the rest as
+ * inline literals, `formatter.ts` knew two, `language-server.ts` knew six) and
+ * **no original at all**, so charter §3's cross-cutting claim — that each of
+ * these words is an ordinary name in seven positions — named a set nothing
+ * could enumerate. It is enumerable here now.
+ *
+ * This module deliberately holds names and plain data — no imports — so the
+ * lexer-facing `source-names.ts`, the lexer, the parser, the formatter and the
+ * analyzer can all read it without a cycle between them.
+ */
+/** The namespaces that are always in scope and are not values (D51 rule 106). */
+export declare const PERMANENT_NAMESPACE_NAMES: readonly ["Json", "Promise", "Text", "Math"];
+/** The prelude functions that need no import (D47 rule 81, D50 rule 90). */
+export declare const CORE_PRELUDE_NAMES: readonly ["number", "str", "print", "equals", "range"];
+export type PermanentNamespaceName = (typeof PERMANENT_NAMESPACE_NAMES)[number];
+export type CorePreludeName = (typeof CORE_PRELUDE_NAMES)[number];
+export type CoreVocabularyName = PermanentNamespaceName | CorePreludeName;
+/** The full Core vocabulary: no binding may spell one of these (D57 rule 135). */
+export declare const CORE_VOCABULARY_NAMES: readonly CoreVocabularyName[];
+export declare function isPermanentNamespaceName(name: string): name is PermanentNamespaceName;
+/**
+ * D62 rule 157: one entry per word the lexer emits as an ordinary identifier
+ * and the Core parser claims as syntax in one shape and nowhere else.
+ *
+ * Membership is decided by *live* syntax. A word the parser recognizes only in
+ * order to reject it is not here: `init` (the removed `init:` block), `set`
+ * (VelarScript has no setters), `default` (no default export), and `invert`
+ * (the removed toggle statement) are spellings the language does not have, and
+ * requiring a tour or an editor to offer them would resurrect them. `dispose`
+ * is not here either — it is only ever read after `@`, which is the separate
+ * closed `@name` vocabulary of D43 item 67.
+ */
+export interface CoreContextualKeyword {
+    /** The spelling, as the lexer emits it. */
+    readonly word: string;
+    /** The one shape the parser claims it in, for the reader of this file. */
+    readonly shape: string;
+    /**
+     * Whether, at the head of a statement line, what follows the word opens a
+     * fresh expression rather than being applied to it. This is the question the
+     * formatter's spacing and the arrow-brace statement scan both ask, and the
+     * answer is not "is it a keyword": `constructor(name: string):` occupies a
+     * declaration's *name* slot, so its `(` binds tight exactly as `def f(`
+     * does, while `match (value):` and `case -1:` keep the separating space.
+     */
+    readonly statementSubjectFollows: boolean;
+}
+export declare const CORE_CONTEXTUAL_KEYWORDS: readonly [{
+    readonly word: "as";
+    readonly shape: "an import alias and a match binding: 'import {a as b}', 'case Shape.circle as c:'";
+    readonly statementSubjectFollows: false;
+}, {
+    readonly word: "case";
+    readonly shape: "a match branch: 'case Status.done:'";
+    readonly statementSubjectFollows: true;
+}, {
+    readonly word: "constructor";
+    readonly shape: "a class's construction member: 'constructor(name: string):'";
+    readonly statementSubjectFollows: false;
+}, {
+    readonly word: "from";
+    readonly shape: "the module an import or a re-export reads: 'import {a} from \"./m.vel\"'";
+    readonly statementSubjectFollows: false;
+}, {
+    readonly word: "get";
+    readonly shape: "a class getter: 'get empty() -> bool:'";
+    readonly statementSubjectFollows: false;
+}, {
+    readonly word: "match";
+    readonly shape: "a match statement: 'match value:'";
+    readonly statementSubjectFollows: true;
+}, {
+    readonly word: "readonly";
+    readonly shape: "a read-only record field or type: 'readonly tags: List<string>'";
+    readonly statementSubjectFollows: false;
+}, {
+    readonly word: "test";
+    readonly shape: "a test declaration: 'test \"a name\":'";
+    readonly statementSubjectFollows: false;
+}, {
+    readonly word: "type";
+    readonly shape: "a record type or a type alias: 'type User:', 'type Id = string'";
+    readonly statementSubjectFollows: false;
+}, {
+    readonly word: "using";
+    readonly shape: "a scoped resource binding: 'using file = open(path)'";
+    readonly statementSubjectFollows: false;
+}];
+export type CoreContextualKeywordWord = (typeof CORE_CONTEXTUAL_KEYWORDS)[number]["word"];
+/**
+ * The roster keyed by its own spellings, so a consumer names a word instead of
+ * restating it: `CORE_WORDS.type` stops compiling the moment `type` leaves the
+ * roster, which is what makes the derivation hold in both directions.
+ */
+export declare const CORE_WORDS: {
+    readonly [Word in CoreContextualKeywordWord]: Word;
+};
+/** The roster as bare spellings, for the consumers that need only the set. */
+export declare const CORE_CONTEXTUAL_KEYWORD_WORDS: readonly CoreContextualKeywordWord[];
+/**
+ * The words that stand where a keyword stands at the head of a statement line.
+ * The formatter's spacing and the parser's arrow-brace scan both read this,
+ * rather than each keeping the two-word copy D62 rule 157 found in them.
+ */
+export declare const CORE_STATEMENT_HEAD_KEYWORDS: readonly CoreContextualKeywordWord[];
+/**
+ * D39-52 and D62 rule 158: the numeric suffixes Core owns on its own. Both are
+ * Duration literals — `250ms`, `3s`. Extensions add visual units on top, and
+ * the Web extension happens to republish these two through `LOOK_UNIT_TYPES`,
+ * which is the only reason the coverage gate could see them at all before this
+ * roster existed; a Core-only checkout checked neither.
+ */
+export declare const CORE_NUMERIC_SUFFIXES: readonly ["ms", "s"];
+export type CoreNumericSuffix = (typeof CORE_NUMERIC_SUFFIXES)[number];
+/**
+ * D55 rule 120: the declaration forms that take `<T>`, as one roster. Every
+ * refusal aimed at a form that does not take one names this list rather than
+ * spelling its own copy — the copies are what made "only 'def' functions take
+ * '<T>'" outlive the ruling that stopped being true. The tour-coverage gate
+ * reads the same roster, so a form added here without an example goes red.
+ */
+export declare const TYPE_PARAMETER_DECLARATION_FORMS: readonly ["def", "type"];
+export type TypeParameterDeclarationForm = (typeof TYPE_PARAMETER_DECLARATION_FORMS)[number];
+/** "'def' functions and 'type' records" — the one phrasing of the roster above. */
+export declare function typeParameterDeclarationFormsPhrase(): string;
+//# sourceMappingURL=core-vocabulary.d.ts.map

package/dist/core-vocabulary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-vocabulary.d.ts","sourceRoot":"","sources":["../src/core-vocabulary.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,iFAAiF;AACjF,eAAO,MAAM,yBAAyB,YAAI,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAU,CAAC;AAEtF,4EAA4E;AAC5E,eAAO,MAAM,kBAAkB,YAAI,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAU,CAAC;AAEzF,MAAM,MAAM,sBAAsB,GAAG,CAAC,OAAO,yBAAyB,CAAC,CAAC,MAAM,CAAC,CAAC;AAChF,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAC;AAClE,MAAM,MAAM,kBAAkB,GAAG,sBAAsB,GAAG,eAAe,CAAC;AAE1E,kFAAkF;AAClF,eAAO,MAAM,qBAAqB,EAAE,SAAS,kBAAkB,EAG9D,CAAC;AAEF,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,IAAI,sBAAsB,CAErF;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,qBAAqB;IACpC,2CAA2C;IAC3C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,0EAA0E;IAC1E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;;;;;;;OAOG;IACH,QAAQ,CAAC,uBAAuB,EAAE,OAAO,CAAC;CAC3C;AAED,eAAO,MAAM,wBAAwB;mBAC3B,IAAI;oBAAS,mFAAmF;;;mBAChG,MAAM;oBAAS,qCAAqC;;;mBACpD,aAAa;oBAAS,6DAA6D;;;mBACnF,MAAM;oBAAS,0EAA0E;;;mBACzF,KAAK;oBAAS,wCAAwC;;;mBACtD,OAAO;oBAAS,mCAAmC;;;mBACnD,UAAU;oBAAS,iEAAiE;;;mBACpF,MAAM;oBAAS,wCAAwC;;;mBACvD,MAAM;oBAAS,iEAAiE;;;mBAChF,OAAO;oBAAS,sDAAsD;;EAC3B,CAAC;AAEtD,MAAM,MAAM,yBAAyB,GAAG,CAAC,OAAO,wBAAwB,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC;AAE1F;;;;GAIG;AACH,eAAO,MAAM,UAAU,EAAE;IAAE,QAAQ,EAAE,IAAI,IAAI,yBAAyB,GAAG,IAAI;CAElB,CAAC;AAE5D,8EAA8E;AAC9E,eAAO,MAAM,6BAA6B,EAAE,SAAS,yBAAyB,EACzB,CAAC;AAEtD;;;;GAIG;AACH,eAAO,MAAM,4BAA4B,EAAE,SAAS,yBAAyB,EAEhD,CAAC;AAE9B;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,YAAI,IAAI,EAAE,GAAG,CAAU,CAAC;AAC1D,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEvE;;;;;;GAMG;AACH,eAAO,MAAM,gCAAgC,YAAI,KAAK,EAAE,MAAM,CAAU,CAAC;AACzE,MAAM,MAAM,4BAA4B,GAAG,CAAC,OAAO,gCAAgC,CAAC,CAAC,MAAM,CAAC,CAAC;AAE7F,mFAAmF;AACnF,wBAAgB,mCAAmC,IAAI,MAAM,CAI5D"}

package/dist/core-vocabulary.js

@@ -0,0 +1,88 @@
+/**
+ * D57 rules 134/135 and D62 rules 157/158: the one roster of Core's own
+ * vocabulary — the permanent (resident) namespaces, the prelude names that
+ * need no import, the contextual keywords, and the numeric suffixes.
+ *
+ * Every place that has to know the whole vocabulary derives it from here: the
+ * analyzer's builtin table is keyed by these names, and `source-names.ts`
+ * refuses them as binding spellings by reading this roster rather than by
+ * restating it. Before that, the refusal list was a hand-kept copy of the
+ * JavaScript globals, so `Math` was protected only because it happens to be a
+ * JavaScript global too, while `Json`, `Promise`, `Text`, `equals`, and
+ * `range` were not protected at all. Adding a namespace or a prelude name
+ * here is now the whole change; nothing downstream can stay behind.
+ *
+ * The contextual keywords arrived the same way and worse: D62 rule 157 found
+ * four partial copies (`parser.ts` knew one word by table and the rest as
+ * inline literals, `formatter.ts` knew two, `language-server.ts` knew six) and
+ * **no original at all**, so charter §3's cross-cutting claim — that each of
+ * these words is an ordinary name in seven positions — named a set nothing
+ * could enumerate. It is enumerable here now.
+ *
+ * This module deliberately holds names and plain data — no imports — so the
+ * lexer-facing `source-names.ts`, the lexer, the parser, the formatter and the
+ * analyzer can all read it without a cycle between them.
+ */
+/** The namespaces that are always in scope and are not values (D51 rule 106). */
+export const PERMANENT_NAMESPACE_NAMES = ["Json", "Promise", "Text", "Math"];
+/** The prelude functions that need no import (D47 rule 81, D50 rule 90). */
+export const CORE_PRELUDE_NAMES = ["number", "str", "print", "equals", "range"];
+/** The full Core vocabulary: no binding may spell one of these (D57 rule 135). */
+export const CORE_VOCABULARY_NAMES = [
+    ...PERMANENT_NAMESPACE_NAMES,
+    ...CORE_PRELUDE_NAMES,
+];
+export function isPermanentNamespaceName(name) {
+    return PERMANENT_NAMESPACE_NAMES.includes(name);
+}
+export const CORE_CONTEXTUAL_KEYWORDS = [
+    { word: "as", shape: "an import alias and a match binding: 'import {a as b}', 'case Shape.circle as c:'", statementSubjectFollows: false },
+    { word: "case", shape: "a match branch: 'case Status.done:'", statementSubjectFollows: true },
+    { word: "constructor", shape: "a class's construction member: 'constructor(name: string):'", statementSubjectFollows: false },
+    { word: "from", shape: "the module an import or a re-export reads: 'import {a} from \"./m.vel\"'", statementSubjectFollows: false },
+    { word: "get", shape: "a class getter: 'get empty() -> bool:'", statementSubjectFollows: false },
+    { word: "match", shape: "a match statement: 'match value:'", statementSubjectFollows: true },
+    { word: "readonly", shape: "a read-only record field or type: 'readonly tags: List<string>'", statementSubjectFollows: false },
+    { word: "test", shape: "a test declaration: 'test \"a name\":'", statementSubjectFollows: false },
+    { word: "type", shape: "a record type or a type alias: 'type User:', 'type Id = string'", statementSubjectFollows: false },
+    { word: "using", shape: "a scoped resource binding: 'using file = open(path)'", statementSubjectFollows: false },
+];
+/**
+ * The roster keyed by its own spellings, so a consumer names a word instead of
+ * restating it: `CORE_WORDS.type` stops compiling the moment `type` leaves the
+ * roster, which is what makes the derivation hold in both directions.
+ */
+export const CORE_WORDS = Object.freeze(Object.fromEntries(CORE_CONTEXTUAL_KEYWORDS.map((entry) => [entry.word, entry.word])));
+/** The roster as bare spellings, for the consumers that need only the set. */
+export const CORE_CONTEXTUAL_KEYWORD_WORDS = CORE_CONTEXTUAL_KEYWORDS.map((entry) => entry.word);
+/**
+ * The words that stand where a keyword stands at the head of a statement line.
+ * The formatter's spacing and the parser's arrow-brace scan both read this,
+ * rather than each keeping the two-word copy D62 rule 157 found in them.
+ */
+export const CORE_STATEMENT_HEAD_KEYWORDS = CORE_CONTEXTUAL_KEYWORDS
+    .filter((entry) => entry.statementSubjectFollows)
+    .map((entry) => entry.word);
+/**
+ * D39-52 and D62 rule 158: the numeric suffixes Core owns on its own. Both are
+ * Duration literals — `250ms`, `3s`. Extensions add visual units on top, and
+ * the Web extension happens to republish these two through `LOOK_UNIT_TYPES`,
+ * which is the only reason the coverage gate could see them at all before this
+ * roster existed; a Core-only checkout checked neither.
+ */
+export const CORE_NUMERIC_SUFFIXES = ["ms", "s"];
+/**
+ * D55 rule 120: the declaration forms that take `<T>`, as one roster. Every
+ * refusal aimed at a form that does not take one names this list rather than
+ * spelling its own copy — the copies are what made "only 'def' functions take
+ * '<T>'" outlive the ruling that stopped being true. The tour-coverage gate
+ * reads the same roster, so a form added here without an example goes red.
+ */
+export const TYPE_PARAMETER_DECLARATION_FORMS = ["def", "type"];
+/** "'def' functions and 'type' records" — the one phrasing of the roster above. */
+export function typeParameterDeclarationFormsPhrase() {
+    const described = { def: "'def' functions", type: "'type' records" };
+    const forms = TYPE_PARAMETER_DECLARATION_FORMS.map((form) => described[form]);
+    return forms.length <= 1 ? forms.join("") : `${forms.slice(0, -1).join(", ")} and ${forms.at(-1)}`;
+}
+//# sourceMappingURL=core-vocabulary.js.map

package/dist/core-vocabulary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-vocabulary.js","sourceRoot":"","sources":["../src/core-vocabulary.ts"],"names":[],"mappings":"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"}

package/dist/diagnostic.d.ts

@@ -0,0 +1,42 @@
+import type { SourceText, Span } from "./source.ts";
+/**
+ * D38 §48: the mechanical rewrite a diagnostic already knows. A fix is
+ * registered only where the diagnostic names one correct replacement and no
+ * judgment is involved, so applying it is a spelling change and never a guess
+ * about intent. `velar fix` applies these, and an editor offers each one as a
+ * quick fix; every other diagnostic stays advice the author acts on.
+ */
+export interface DiagnosticEdit {
+    /** The replaced range. It may be wider than the diagnostic span (surrounding whitespace a deletion should take with it), and empty to insert. */
+    readonly span: Span;
+    /** The exact replacement text; the empty string deletes the range. */
+    readonly text: string;
+}
+export interface DiagnosticFix {
+    /** The edits of one rewrite; they never overlap and are applied together or not at all. */
+    readonly edits: readonly DiagnosticEdit[];
+    /** Imperative editor title, e.g. "Use VelarScript strict equality '=='". */
+    readonly title: string;
+}
+export interface Diagnostic {
+    readonly code: string;
+    readonly message: string;
+    readonly span: Span;
+    /**
+     * Marks a guidance diagnostic whose compile stage internally recovered as
+     * the guided spelling, so later stages still run and can report their own
+     * guidance in the same compile. Compilation still fails: recovered
+     * diagnostics count toward the zero-diagnostics gate for code generation.
+     */
+    readonly recovered?: boolean;
+    /** The mechanical rewrite this diagnostic names, when it names exactly one. */
+    readonly fix?: DiagnosticFix;
+}
+export declare function diagnostic(code: string, message: string, span: Span, fix?: DiagnosticFix): Diagnostic;
+export declare function recoveredDiagnostic(code: string, message: string, span: Span, fix?: DiagnosticFix): Diagnostic;
+/** Builds the one-edit mechanical rewrite of `span` to `text`. */
+export declare function mechanicalFix(span: Span, text: string, title: string): DiagnosticFix;
+/** Builds a mechanical rewrite whose one spelling change needs more than one edit. */
+export declare function mechanicalEdits(edits: readonly DiagnosticEdit[], title: string): DiagnosticFix;
+export declare function formatDiagnostic(source: SourceText, item: Diagnostic): string;
+//# sourceMappingURL=diagnostic.d.ts.map

package/dist/diagnostic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostic.d.ts","sourceRoot":"","sources":["../src/diagnostic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAEpD;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B,iJAAiJ;IACjJ,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB,sEAAsE;IACtE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,aAAa;IAC5B,2FAA2F;IAC3F,QAAQ,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,CAAC;IAC1C,4EAA4E;IAC5E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAC7B,+EAA+E;IAC/E,QAAQ,CAAC,GAAG,CAAC,EAAE,aAAa,CAAC;CAC9B;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,CAAC,EAAE,aAAa,GAAG,UAAU,CAErG;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,CAAC,EAAE,aAAa,GAAG,UAAU,CAE9G;AAED,kEAAkE;AAClE,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,aAAa,CAEpF;AAED,sFAAsF;AACtF,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,aAAa,CAE9F;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CAqB7E"}