@velarscript/compiler 0.10.1

package/dist/json-runtime.js

@@ -0,0 +1,193 @@
+import { VELAR_RUNTIME_REGISTRY_KEY, VELAR_RUNTIME_SCHEMA_VERSION } from "./runtime-abi.js";
+export const VELAR_STRICT_JSON_RUNTIME = String.raw `
+const __velarMaxJsonCodeUnits = 16 * 1024 * 1024;
+const __velarMaxJsonNodes = 1000000;
+const __velarMaxJsonDepth = 128;
+const __velarJsonNativeArray = globalThis.Array;
+const __velarJsonNativeSet = globalThis.Set;
+const __velarJsonNativeObject = globalThis.Object;
+const __velarJsonNativeNumber = globalThis.Number;
+const __velarJsonNativeString = globalThis.String;
+const __velarJsonNativeMath = globalThis.Math;
+const __velarJsonNativeTypeError = globalThis.TypeError;
+const __velarJsonNativeRangeError = globalThis.RangeError;
+const __velarJsonGetOwnPropertyDescriptor = __velarJsonNativeObject.getOwnPropertyDescriptor;
+const __velarJsonGetOwnPropertyNames = __velarJsonNativeObject.getOwnPropertyNames;
+const __velarJsonGetOwnPropertySymbols = __velarJsonNativeObject.getOwnPropertySymbols;
+const __velarJsonGetPrototypeOf = __velarJsonNativeObject.getPrototypeOf;
+const __velarJsonObjectPrototype = __velarJsonGetOwnPropertyDescriptor(__velarJsonNativeObject, "prototype")?.value;
+const __velarJsonCreate = __velarJsonNativeObject.create;
+const __velarJsonDefineProperty = __velarJsonNativeObject.defineProperty;
+const __velarJsonArrayIsArray = __velarJsonNativeArray.isArray;
+const __velarJsonArrayPrototype = __velarJsonGetOwnPropertyDescriptor(__velarJsonNativeArray, "prototype")?.value;
+const __velarJsonArraySort = __velarJsonGetOwnPropertyDescriptor(__velarJsonArrayPrototype, "sort")?.value;
+const __velarJsonNumberIsFinite = __velarJsonNativeNumber.isFinite;
+const __velarJsonNumberIsInteger = __velarJsonNativeNumber.isInteger;
+const __velarJsonMathMax = __velarJsonNativeMath.max;
+const __velarJsonSymbolFor = globalThis.Symbol.for;
+const __velarJsonReflectOwnKeys = globalThis.Reflect.ownKeys;
+const __velarNativeReflectApply = __velarJsonGetOwnPropertyDescriptor(globalThis.Reflect, "apply")?.value;
+const __velarJsonSetPrototype = __velarJsonGetOwnPropertyDescriptor(__velarJsonNativeSet, "prototype")?.value;
+const __velarJsonSetHas = __velarJsonGetOwnPropertyDescriptor(__velarJsonSetPrototype, "has")?.value;
+const __velarJsonSetAdd = __velarJsonGetOwnPropertyDescriptor(__velarJsonSetPrototype, "add")?.value;
+const __velarJsonSetDelete = __velarJsonGetOwnPropertyDescriptor(__velarJsonSetPrototype, "delete")?.value;
+const __velarJsonStringPrototype = __velarJsonGetOwnPropertyDescriptor(__velarJsonNativeString, "prototype")?.value;
+const __velarJsonCharCodeAt = __velarJsonGetOwnPropertyDescriptor(__velarJsonStringPrototype, "charCodeAt")?.value;
+const __velarJsonPathPattern = /^[A-Za-z_][A-Za-z0-9_]*$/u;
+const __velarJsonRegExpPrototype = __velarJsonGetPrototypeOf(__velarJsonPathPattern);
+const __velarJsonRegExpTest = __velarJsonGetOwnPropertyDescriptor(__velarJsonRegExpPrototype, "test")?.value;
+function __velarJsonApply(operation, receiver, arguments_, label) {
+  if (typeof operation !== "function" || typeof __velarNativeReflectApply !== "function") throw new __velarJsonNativeTypeError("The JavaScript " + label + " JSON API is unavailable");
+  return __velarNativeReflectApply(operation, receiver, arguments_);
+}
+const __velarJsonHostDescriptor = __velarJsonGetOwnPropertyDescriptor(globalThis, "JSON");
+const __velarJsonHost = __velarJsonHostDescriptor && "value" in __velarJsonHostDescriptor ? __velarJsonHostDescriptor.value : null;
+const __velarNativeJsonParse = __velarJsonHost && __velarJsonGetOwnPropertyDescriptor(__velarJsonHost, "parse")?.value;
+const __velarNativeJsonStringify = __velarJsonHost && __velarJsonGetOwnPropertyDescriptor(__velarJsonHost, "stringify")?.value;
+function __velarJsonRaw(value) {
+  const descriptor = __velarJsonGetOwnPropertyDescriptor(globalThis, __velarJsonApply(__velarJsonSymbolFor, undefined, [${JSON.stringify(VELAR_RUNTIME_REGISTRY_KEY)}], "Symbol.for"));
+  const runtime = descriptor && "value" in descriptor ? descriptor.value : null;
+  if (!runtime || runtime.version !== ${JSON.stringify(VELAR_RUNTIME_SCHEMA_VERSION)} || typeof runtime.toRaw !== "function") return value;
+  if (typeof runtime.trackDeep === "function") runtime.trackDeep(value);
+  return runtime.toRaw(value);
+}
+function __velarJsonFailure(path, message) {
+  throw new __velarJsonNativeTypeError("Invalid JSON value at " + path + ": " + message);
+}
+function __velarJsonPath(parent, key) {
+  return __velarJsonApply(__velarJsonRegExpTest, __velarJsonPathPattern, [key], "RegExp.test") ? parent + "." + key : parent + "[field]";
+}
+function __velarJsonStringUnits(value) {
+  let units = 2;
+  for (let index = 0; index < value.length; index += 1) {
+    const code = __velarJsonApply(__velarJsonCharCodeAt, value, [index], "String.charCodeAt");
+    if (code === 34 || code === 92 || code === 8 || code === 9 || code === 10 || code === 12 || code === 13) units += 2;
+    else if (code <= 31 || (code >= 0xD800 && code <= 0xDFFF && !(code <= 0xDBFF && index + 1 < value.length && __velarJsonApply(__velarJsonCharCodeAt, value, [index + 1], "String.charCodeAt") >= 0xDC00 && __velarJsonApply(__velarJsonCharCodeAt, value, [index + 1], "String.charCodeAt") <= 0xDFFF))) units += 6;
+    else { units += 1; if (code >= 0xD800 && code <= 0xDBFF) { units += 1; index += 1; } }
+    if (units > __velarMaxJsonCodeUnits) return units;
+  }
+  return units;
+}
+function __velarJsonBudget(state, path) {
+  if (state.nodes > __velarMaxJsonNodes) __velarJsonFailure(path, "data cannot exceed " + __velarMaxJsonNodes + " values");
+  if (state.compactUnits > __velarMaxJsonCodeUnits) __velarJsonFailure(path, "encoded JSON cannot exceed 16 MiB");
+}
+function __velarJsonState() { return { active: new __velarJsonNativeSet(), nodes: 0, depth: 0, compactUnits: 0, prettyLines: 0, prettyIndentWeight: 0, prettyColonSpaces: 0 }; }
+function __velarInspectJson(value, path, state, copy) {
+  value = __velarJsonRaw(value);
+  state.nodes += 1;
+  if (value === null) { state.compactUnits += 4; __velarJsonBudget(state, path); return value; }
+  if (typeof value === "string") { state.compactUnits += __velarJsonStringUnits(value); __velarJsonBudget(state, path); return value; }
+  if (typeof value === "boolean") { state.compactUnits += value ? 4 : 5; __velarJsonBudget(state, path); return value; }
+  if (typeof value === "number") {
+    if (!__velarJsonApply(__velarJsonNumberIsFinite, __velarJsonNativeNumber, [value], "Number.isFinite")) __velarJsonFailure(path, "numbers must be finite");
+    state.compactUnits += __velarJsonApply(__velarJsonNativeString, undefined, [value], "String").length;
+    __velarJsonBudget(state, path);
+    return value;
+  }
+  if (typeof value !== "object") __velarJsonFailure(path, typeof value + " is not supported");
+  if (state.depth >= __velarMaxJsonDepth) __velarJsonFailure(path, "data cannot exceed " + __velarMaxJsonDepth + " nested collections");
+  if (__velarJsonApply(__velarJsonSetHas, state.active, [value], "Set.has")) __velarJsonFailure(path, "cyclic data is not supported");
+  __velarJsonApply(__velarJsonSetAdd, state.active, [value], "Set.add");
+  try {
+    if (__velarJsonApply(__velarJsonArrayIsArray, __velarJsonNativeArray, [value], "Array.isArray")) {
+      if (value.length > 1000000) __velarJsonFailure(path, "Lists cannot exceed 1000000 items");
+      if (__velarJsonGetOwnPropertySymbols(value).length > 0) __velarJsonFailure(path, "List symbol fields are not supported");
+      const names = __velarJsonGetOwnPropertyNames(value);
+      if (names.length !== value.length + 1 || names[names.length - 1] !== "length") {
+        __velarJsonFailure(path, "Lists must be dense and cannot have extra fields");
+      }
+      state.compactUnits += 2 + __velarJsonApply(__velarJsonMathMax, __velarJsonNativeMath, [0, value.length - 1], "Math.max");
+      if (value.length > 0) {
+        state.prettyLines += value.length + 1;
+        state.prettyIndentWeight += value.length * (state.depth + 1) + state.depth;
+      }
+      __velarJsonBudget(state, path);
+      const output = copy ? new __velarJsonNativeArray(value.length) : value;
+      state.depth += 1;
+      for (let index = 0; index < value.length; index += 1) {
+        const descriptor = __velarJsonGetOwnPropertyDescriptor(value, index);
+        if (!descriptor?.enumerable || !("value" in descriptor)) __velarJsonFailure(path + "[" + index + "]", "List entries must be enumerable data values");
+        const child = __velarInspectJson(descriptor.value, path + "[" + index + "]", state, copy);
+        if (copy) output[index] = child;
+      }
+      state.depth -= 1;
+      return output;
+    }
+    const prototype = __velarJsonGetPrototypeOf(value);
+    if (prototype !== __velarJsonObjectPrototype && prototype !== null) {
+      __velarJsonFailure(path, "only records and Lists are supported");
+    }
+    const keys = __velarJsonApply(__velarJsonReflectOwnKeys, globalThis.Reflect, [value], "Reflect.ownKeys");
+    if (keys.length > 1000000) __velarJsonFailure(path, "records cannot exceed 1000000 fields");
+    state.compactUnits += 2 + __velarJsonApply(__velarJsonMathMax, __velarJsonNativeMath, [0, keys.length - 1], "Math.max");
+    if (keys.length > 0) {
+      state.prettyLines += keys.length + 1;
+      state.prettyIndentWeight += keys.length * (state.depth + 1) + state.depth;
+      state.prettyColonSpaces += keys.length;
+    }
+    __velarJsonBudget(state, path);
+    const output = copy ? __velarJsonApply(__velarJsonCreate, __velarJsonNativeObject, [null], "Object.create") : value;
+    state.depth += 1;
+    for (let index = 0; index < keys.length; index += 1) {
+      const key = keys[index];
+      if (typeof key !== "string") __velarJsonFailure(path, "record symbol fields are not supported");
+      state.compactUnits += __velarJsonStringUnits(key) + 1;
+      __velarJsonBudget(state, path);
+      const childPath = __velarJsonPath(path, key);
+      const descriptor = __velarJsonGetOwnPropertyDescriptor(value, key);
+      if (!descriptor?.enumerable || !("value" in descriptor)) {
+        __velarJsonFailure(childPath, "record fields must be enumerable data values");
+      }
+      const child = __velarInspectJson(descriptor.value, childPath, state, copy);
+      if (copy) __velarJsonApply(__velarJsonDefineProperty, __velarJsonNativeObject, [output, key, { value: child, enumerable: true, configurable: true, writable: true }], "Object.defineProperty");
+    }
+    state.depth -= 1;
+    return output;
+  } finally {
+    __velarJsonApply(__velarJsonSetDelete, state.active, [value], "Set.delete");
+  }
+}
+function __velarAssertJson(value, path = "$", state = null) {
+  state ??= __velarJsonState();
+  __velarInspectJson(value, path, state, false);
+  return state;
+}
+function __velarJsonSnapshot(value) {
+  const state = __velarJsonState();
+  return { value: __velarInspectJson(value, "$", state, true), state };
+}
+function __velarJsonIndent(pretty) {
+  if (pretty === false) return 0;
+  if (pretty === true) return 2;
+  if (!__velarJsonApply(__velarJsonNumberIsInteger, __velarJsonNativeNumber, [pretty], "Number.isInteger") || pretty < 0 || pretty > 10) {
+    throw new __velarJsonNativeRangeError("JSON indentation must be false, true, or an integer from 0 to 10");
+  }
+  return pretty;
+}
+function __velarJsonParse(text, name = "JSON text") {
+  if (typeof text !== "string") throw new __velarJsonNativeTypeError(name + " must be a string");
+  if (text.length > __velarMaxJsonCodeUnits) throw new __velarJsonNativeRangeError(name + " cannot exceed 16 MiB");
+  if (typeof __velarNativeJsonParse !== "function" || typeof __velarNativeReflectApply !== "function") {
+    throw new __velarJsonNativeTypeError("The host JSON parser is unavailable");
+  }
+  const value = __velarNativeReflectApply(__velarNativeJsonParse, __velarJsonHost, [text]);
+  return __velarJsonSnapshot(value).value;
+}
+function __velarJsonStringify(value, pretty = false) {
+  const snapshot = __velarJsonSnapshot(value);
+  const state = snapshot.state;
+  const indentation = __velarJsonIndent(pretty);
+  const estimated = state.compactUnits + (indentation ? state.prettyLines + state.prettyColonSpaces + state.prettyIndentWeight * indentation : 0);
+  if (estimated > __velarMaxJsonCodeUnits) throw new __velarJsonNativeRangeError("Encoded JSON cannot exceed 16 MiB");
+  if (typeof __velarNativeJsonStringify !== "function" || typeof __velarNativeReflectApply !== "function") {
+    throw new __velarJsonNativeTypeError("The host JSON serializer is unavailable");
+  }
+  const output = __velarNativeReflectApply(__velarNativeJsonStringify, __velarJsonHost, [snapshot.value, null, indentation]);
+  if (typeof output !== "string") throw new __velarJsonNativeTypeError("The host JSON serializer must return a string");
+  if (output.length > __velarMaxJsonCodeUnits) throw new __velarJsonNativeRangeError("Encoded JSON cannot exceed 16 MiB");
+  return output;
+}
+function __velarJsonClone(value) { return __velarJsonParse(__velarJsonStringify(value)); }
+`.trimStart();
+//# sourceMappingURL=json-runtime.js.map

package/dist/json-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-runtime.js","sourceRoot":"","sources":["../src/json-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0BAA0B,EAAE,4BAA4B,EAAE,MAAM,kBAAkB,CAAC;AAE5F,MAAM,CAAC,MAAM,yBAAyB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0HA8CuE,IAAI,CAAC,SAAS,CAAC,0BAA0B,CAAC;;wCAE5H,IAAI,CAAC,SAAS,CAAC,4BAA4B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8InF,CAAC,SAAS,EAAE,CAAC"}

package/dist/language-guidance.d.ts

@@ -0,0 +1,31 @@
+export interface SourceTypeGuidance {
+    readonly message: string;
+    readonly replacement: string | null;
+    readonly title: string | null;
+}
+export type CollectionKind = "List" | "Set" | "Map";
+export interface CollectionMemberGuidance {
+    readonly message: string;
+    readonly replacement: string | null;
+    readonly title: string | null;
+}
+export interface DeclarationKeywordGuidance {
+    readonly message: string;
+    readonly keyword: "def" | "type";
+}
+export declare function webNumericUnitOwner(suffix: string): string | null;
+export declare function declarationKeywordGuidance(name: string): DeclarationKeywordGuidance | null;
+export declare function stringMemberGuidance(name: string): string | null;
+export declare function removedStandardFunctionGuidance(source: string, name: string): string | null;
+export declare function removedGlobalFunctionGuidance(name: string): string | null;
+/**
+ * D65 rule 170: one sentence, two stages. A rest parameter without an element
+ * type is refused by the parser in every declaration, and by the analyzer in
+ * an arrow, where the contextual function type gets its chance to supply one
+ * first — exactly as a fixed parameter's type already arrives. Both stages say
+ * the same thing because it is the same refusal.
+ */
+export declare const REST_PARAMETER_ELEMENT_TYPE_MESSAGE = "A rest parameter requires an element type";
+export declare function sourceTypeNameGuidance(name: string): SourceTypeGuidance | null;
+export declare function collectionMemberGuidance(kind: CollectionKind, member: string): CollectionMemberGuidance | null;
+//# sourceMappingURL=language-guidance.d.ts.map

package/dist/language-guidance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-guidance.d.ts","sourceRoot":"","sources":["../src/language-guidance.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,CAAC;AAEpD,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAiED,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,KAAK,GAAG,MAAM,CAAC;CAClC;AAsFD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAEjE;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,GAAG,0BAA0B,GAAG,IAAI,CAE1F;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAEhE;AAED,wBAAgB,+BAA+B,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAE3F;AAED,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAMzE;AAED;;;;;;GAMG;AACH,eAAO,MAAM,mCAAmC,8CAA8C,CAAC;AAE/F,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI,CAE9E;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,GAAG,wBAAwB,GAAG,IAAI,CAE9G"}

package/dist/language-guidance.js

@@ -0,0 +1,187 @@
+const sourceTypeGuidance = new Map([
+    ["Array", typeReplacement("Use 'List<T>' for ordered collections; VelarScript exposes one source-level List type", "List", "Use the VelarScript List type")],
+    ["array", typeReplacement("Use 'List<T>' for ordered collections; VelarScript exposes one source-level List type", "List", "Use the VelarScript List type")],
+    ["list", typeReplacement("Use 'List<T>' for ordered collections", "List", "Use the VelarScript List type")],
+    ["dict", typeReplacement("Use 'Map<K, V>' for keyed collections", "Map", "Use the VelarScript Map type")],
+    ["set", typeReplacement("Use 'Set<T>' for unique collections", "Set", "Use the VelarScript Set type")],
+    ["str", typeReplacement("Use 'string' for text values; str(value) is only the explicit text conversion function", "string", "Use the VelarScript string type")],
+    ["String", typeReplacement("Use 'string' for text values; JavaScript wrapper-object types are not exposed", "string", "Use the VelarScript string type")],
+    ["Number", typeReplacement("Use 'number'; JavaScript wrapper-object types are not exposed", "number", "Use the VelarScript number type")],
+    ["boolean", typeReplacement("Use 'bool' for boolean values", "bool", "Use the VelarScript bool type")],
+    ["Boolean", typeReplacement("Use 'bool'; JavaScript wrapper-object types are not exposed", "bool", "Use the VelarScript bool type")],
+    ["void", typeReplacement("Use 'null' for an explicit no-result type; omitted body-backed results are inferred", "null", "Use the VelarScript null type")],
+    ["object", typeGuidance("Declare a named 'type' for an object shape, or use 'unknown' at an unchecked boundary")],
+    ["Object", typeGuidance("Declare a named 'type' for an object shape, or use 'unknown' at an unchecked boundary")],
+    ["Callable", typeGuidance("Write an explicit function type such as '(value: string) -> bool'")],
+]);
+const collectionGuidance = new Map([
+    ["List", new Map([
+            ["length", memberReplacement("Use 'size'", "size", "Use List size")],
+            ["at", memberReplacement("Use 'get(index)'", "get", "Use List.get")],
+            ["includes", memberReplacement("Use 'has(value)'", "has", "Use List.has")],
+            ["contains", memberReplacement("Use 'has(value)'", "has", "Use List.has")],
+            ["add", memberReplacement("Use 'append(value)'", "append", "Use List.append")],
+            ["addAll", memberReplacement("Use 'extend(values)'", "extend", "Use List.extend")],
+            ["push", memberReplacement("Use 'append(value)'", "append", "Use List.append")],
+            ["unshift", memberGuidance("Use 'insert(0, value)'")],
+            ["shift", memberGuidance("Use 'pop(0)'")],
+            ["set", memberGuidance("Use indexed assignment such as 'values[index] = value'")],
+            ["delete", memberGuidance("Use 'remove(value)' to remove by value, or 'pop(index)' to remove by index")],
+            ["deleteAt", memberReplacement("Use 'pop(index)'", "pop", "Use List.pop")],
+            ["first", memberGuidance("Use 'get(0)'")],
+            ["last", memberGuidance("Use 'get(-1)'")],
+            ["findIndex", memberGuidance("Use 'find(test)' when you need the matching value, or 'index(value)' when locating a known value")],
+            ["forEach", memberGuidance("Use a structured loop for side effects — 'for value in values:' followed by the effect in its indented body")],
+            ["indexOf", memberReplacement("Use 'index(value)'", "index", "Use List.index")],
+            ["any", memberReplacement("Use 'some(test)'", "some", "Use List.some")],
+            ["all", memberReplacement("Use 'every(test)'", "every", "Use List.every")],
+            ["sort", memberGuidance("Use non-mutating 'sorted(compare)' and keep its returned List")],
+            ["reverse", memberGuidance("Use non-mutating 'reversed()' and keep its returned List")],
+            ["splice", memberGuidance("Use 'insert', 'remove', 'pop', or 'slice' for one explicit operation")],
+        ])],
+    ["Set", new Map([
+            ["length", memberReplacement("Use 'size'", "size", "Use Set size")],
+            ["addAll", memberReplacement("Use 'update(values)'", "update", "Use Set.update")],
+            ["append", memberReplacement("Use 'add(value)'", "add", "Use Set.add")],
+            ["push", memberReplacement("Use 'add(value)'", "add", "Use Set.add")],
+            ["includes", memberReplacement("Use 'has(value)'", "has", "Use Set.has")],
+            ["contains", memberReplacement("Use 'has(value)'", "has", "Use Set.has")],
+            ["delete", memberReplacement("Use 'remove(value)'", "remove", "Use Set.remove")],
+        ])],
+    ["Map", new Map([
+            ["length", memberReplacement("Use 'size'", "size", "Use Map size")],
+            ["setAll", memberReplacement("Use 'update(other)'", "update", "Use Map.update")],
+            ["put", memberReplacement("Use 'set(key, value)'", "set", "Use Map.set")],
+            ["includes", memberReplacement("Use 'has(key)'", "has", "Use Map.has")],
+            ["includesKey", memberReplacement("Use 'has(key)'", "has", "Use Map.has")],
+            ["contains", memberReplacement("Use 'has(key)'", "has", "Use Map.has")],
+            ["containsKey", memberReplacement("Use 'has(key)'", "has", "Use Map.has")],
+            ["delete", memberReplacement("Use 'remove(key)'", "remove", "Use Map.remove")],
+        ])],
+]);
+const functionKeywordGuidance = { message: "Use 'def'; VelarScript declares functions with 'def name(...)'", keyword: "def" };
+const typeKeywordGuidance = { message: "Use 'type'; VelarScript declares record shapes with 'type Name:'", keyword: "type" };
+const declarationKeywordGuidanceEntries = new Map([
+    ["fn", functionKeywordGuidance],
+    ["func", functionKeywordGuidance],
+    ["function", functionKeywordGuidance],
+    ["record", typeKeywordGuidance],
+    ["struct", typeKeywordGuidance],
+    ["interface", typeKeywordGuidance],
+    ["schema", typeKeywordGuidance],
+]);
+const stringMemberGuidanceEntries = new Map([
+    ["length", "Use '.size'; strings count Unicode code points like List.size"],
+    ["substring", "Use '.slice(start, end)'; VelarScript has one string slicing method"],
+    ["substr", "Use '.slice(start, end)'; VelarScript has one string slicing method"],
+    ["charAt", "Use '.char(index)'; string positions count Unicode code points"],
+    ["at", "Use '.char(index)'; string positions count Unicode code points"],
+    ["indexOf", "Use '.index(text, start)'; missing text returns null and string positions count Unicode code points"],
+    ["lastIndexOf", "Use '.index(text, start)' to search forward; VelarScript has no reverse string search member"],
+    // D51 item "two-round retirement": the destination is the spelling that
+    // survives. Naming 'velar/text' here sent the author to an import the
+    // project driver retires on the next run, so the guidance taught a loop.
+    ["trimStart", "Use Text.trimStart(value); string operations beyond the core members live in the Text namespace, which needs no import"],
+    ["trimEnd", "Use Text.trimEnd(value); string operations beyond the core members live in the Text namespace, which needs no import"],
+    ["toUpperCase", "Use '.upper()'; VelarScript exposes one string uppercase spelling"],
+    ["toLowerCase", "Use '.lower()'; VelarScript exposes one string lowercase spelling"],
+    ["includes", "Use '.has(text)'; strings and collections share one membership method"],
+    ["toString", "Use 'str(value)' or an f-string; VelarScript has one explicit text conversion spelling"],
+    // TXT-I1: the Python spellings, each pointed at the member or the `Text.`
+    // namespace function that exists.
+    ["strip", "Use '.trim()'; VelarScript trims whitespace with the trim member"],
+    ["lstrip", "Use Text.trimStart(value); string operations beyond the core members live in the Text namespace, which needs no import"],
+    ["rstrip", "Use Text.trimEnd(value); string operations beyond the core members live in the Text namespace, which needs no import"],
+    ["startswith", "Use '.startsWith(text)'; VelarScript member names are camelCase"],
+    ["endswith", "Use '.endsWith(text)'; VelarScript member names are camelCase"],
+    ["find", "Use '.index(text, start)'; missing text returns null instead of -1"],
+    ["splitlines", "Use Text.lines(value); it splits on line boundaries, and the Text namespace needs no import"],
+    ["casefold", "Use '.lower()'; VelarScript exposes simple case mapping, not locale case folding"],
+    ["format", "Use an f-string — f\"Hello {name}\" — VelarScript interpolates values instead of format()"],
+    ["title", "Use Text.title(value); string operations beyond the core members live in the Text namespace, which needs no import"],
+    ["capitalize", "Use Text.capitalize(value); string operations beyond the core members live in the Text namespace, which needs no import"],
+]);
+const removedStandardFunctionGuidanceEntries = new Map([
+    ["velar/text", new Map([
+            ["length", "Use 'value.size'; string measurement is a checked member"],
+            ["char", "Use 'value.char(index)'; string access is a checked member"],
+            ["slice", "Use 'value.slice(start, end)'; string slicing is a checked member"],
+            ["trim", "Use 'value.trim()'; string trimming is a checked member"],
+            ["lower", "Use 'value.lower()'; string lowercasing is a checked member"],
+            ["upper", "Use 'value.upper()'; string uppercasing is a checked member"],
+            ["startsWith", "Use 'value.startsWith(text)'; string prefix checks are checked members"],
+            ["endsWith", "Use 'value.endsWith(text)'; string suffix checks are checked members"],
+            ["includes", "Use 'value.has(text)'; strings and collections share one membership method"],
+            ["indexOf", "Use 'value.index(text, start)'; missing text returns null and string positions count Unicode code points"],
+            ["split", "Use 'value.split(separator)'; string splitting is a checked member"],
+            ["replace", "Use 'value.replace(from, to)'; string replacement is a checked member"],
+            ["replaceAll", "Use 'value.replaceAll(from, to)'; string replacement is a checked member"],
+            ["repeat", "Use 'value.repeat(count)'; string repetition is a checked member"],
+            ["padStart", "Use 'value.padStart(size, fill)'; string padding is a checked member"],
+            ["padEnd", "Use 'value.padEnd(size, fill)'; string padding is a checked member"],
+        ])],
+    ["velar/math", new Map([
+            ["abs", "Use 'value.abs()'; absolute value is a checked number member"],
+            ["round", "Use 'value.round()'; number rounding is a checked member"],
+            ["floor", "Use 'value.floor()'; number flooring is a checked member"],
+            ["ceil", "Use 'value.ceil()'; number ceiling is a checked member"],
+            ["isFinite", "Use 'value.isFinite()'; finite-number checks are checked members"],
+            ["isInteger", "Use 'value.isInteger()'; integer checks are checked members"],
+        ])],
+]);
+/**
+ * LOK-I5: the visual unit vocabulary belongs to `@velarscript/web`, which adds
+ * these suffixes to the lexer. Core keeps the list only to recognize the
+ * spelling and name the extension that owns it — the same cross-extension
+ * guidance D37 rule 45 established for Web statement shapes — instead of
+ * reporting a unit the author spelled perfectly well as unknown. Core's own
+ * duration suffixes (`ms`, `s`) are not in this list; they are Core's.
+ */
+const webNumericUnits = new Set(["px", "rem", "em", "vw", "vh", "vmin", "vmax", "%", "fr", "deg", "turn"]);
+export function webNumericUnitOwner(suffix) {
+    return webNumericUnits.has(suffix) ? "@velarscript/web" : null;
+}
+export function declarationKeywordGuidance(name) {
+    return declarationKeywordGuidanceEntries.get(name) ?? null;
+}
+export function stringMemberGuidance(name) {
+    return stringMemberGuidanceEntries.get(name) ?? null;
+}
+export function removedStandardFunctionGuidance(source, name) {
+    return removedStandardFunctionGuidanceEntries.get(source)?.get(name) ?? null;
+}
+export function removedGlobalFunctionGuidance(name) {
+    for (const entries of removedStandardFunctionGuidanceEntries.values()) {
+        const guidance = entries.get(name);
+        if (guidance)
+            return guidance;
+    }
+    return null;
+}
+/**
+ * D65 rule 170: one sentence, two stages. A rest parameter without an element
+ * type is refused by the parser in every declaration, and by the analyzer in
+ * an arrow, where the contextual function type gets its chance to supply one
+ * first — exactly as a fixed parameter's type already arrives. Both stages say
+ * the same thing because it is the same refusal.
+ */
+export const REST_PARAMETER_ELEMENT_TYPE_MESSAGE = "A rest parameter requires an element type";
+export function sourceTypeNameGuidance(name) {
+    return sourceTypeGuidance.get(name) ?? null;
+}
+export function collectionMemberGuidance(kind, member) {
+    return collectionGuidance.get(kind)?.get(member) ?? null;
+}
+function typeGuidance(message) {
+    return { message, replacement: null, title: null };
+}
+function typeReplacement(message, value, title) {
+    return { message, replacement: value, title };
+}
+function memberGuidance(message) {
+    return { message, replacement: null, title: null };
+}
+function memberReplacement(message, value, title) {
+    return { message, replacement: value, title };
+}
+//# sourceMappingURL=language-guidance.js.map

package/dist/language-guidance.js.map

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

package/dist/lexer.d.ts

@@ -0,0 +1,85 @@
+import { type Diagnostic } from "./diagnostic.ts";
+import type { CompilerLexicalExtension } from "./extension.ts";
+import { type Token } from "./token.ts";
+export interface LexResult {
+    readonly tokens: readonly Token[];
+    readonly diagnostics: readonly Diagnostic[];
+}
+export declare class Lexer {
+    private readonly text;
+    private readonly extensionForbiddenIdentifiers;
+    private readonly extensionScanners;
+    private readonly numericSuffixes;
+    private readonly tokens;
+    private readonly diagnostics;
+    private readonly diagnosedBidirectionalOffsets;
+    private readonly indentStack;
+    private index;
+    private atLineStart;
+    private nesting;
+    private readonly bracketFragment;
+    private readonly scanSourceHygiene;
+    constructor(text: string, extensions?: readonly CompilerLexicalExtension[], options?: {
+        readonly bracketFragment?: boolean;
+        readonly scanSourceHygiene?: boolean;
+    });
+    lex(): LexResult;
+    private readIndentation;
+    private isChainContinuation;
+    private readNewline;
+    private readComment;
+    private readBlockComment;
+    private blockCommentOwnsLine;
+    private readIdentifier;
+    private readNumber;
+    private readRadixNumber;
+    private isRadixDigit;
+    /**
+     * LOK-I5: `%` right after a number is the percentage unit only where a
+     * remainder operator could not stand — the operator always takes a right
+     * operand, so a `%` followed by a line end, a closing bracket, or a
+     * separator is a unit spelling and nothing else.
+     */
+    private isPercentUnitPosition;
+    private readLeadingDotNumber;
+    private readDigitsWithSeparators;
+    private readString;
+    private readEmbeddedJavaScript;
+    private diagnoseStringContents;
+    private decodeStringText;
+    private legacyTripleQuotePrefix;
+    private readLegacyTripleQuote;
+    private readExtensionToken;
+    private operator;
+    /**
+     * The rewrite of a symbol operator to its word spelling. A word needs air on
+     * either side that a symbol did not: 'a&&b' becomes 'a and b', while
+     * 'a && b' keeps the spacing it already had.
+     */
+    private wordOperatorFix;
+    private skipHorizontalWhitespace;
+    /**
+     * The deletion of a line-ending semicolon, including the blank space it would
+     * leave behind. A semicolon followed by anything except further semicolons,
+     * spaces, or a comment separates two statements: putting those on their own
+     * lines is a change of layout rather than of spelling, so it carries no fix.
+     */
+    private trailingSemicolonFix;
+    private simple;
+    private readHexColor;
+    private readJavaScriptPrivateIdentifier;
+    private readHashComment;
+    private diagnoseForbiddenSourceCharacters;
+    private isBidirectionalControl;
+    private isForbiddenLiteralControl;
+    private lineStart;
+    private lineEnd;
+    private invalidCharacter;
+    private isAtEnd;
+    private peek;
+    private advance;
+    private isIdentifierStart;
+    private isIdentifierPart;
+    private isDigit;
+}
+//# sourceMappingURL=lexer.d.ts.map

package/dist/lexer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lexer.d.ts","sourceRoot":"","sources":["../src/lexer.ts"],"names":[],"mappings":"AACA,OAAO,EAAkD,KAAK,UAAU,EAAsB,MAAM,iBAAiB,CAAC;AAEtH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAK/D,OAAO,EAAgB,KAAK,KAAK,EAAkB,MAAM,YAAY,CAAC;AA0BtE,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,CAAC;IAClC,QAAQ,CAAC,WAAW,EAAE,SAAS,UAAU,EAAE,CAAC;CAC7C;AAED,qBAAa,KAAK;IAChB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAC,6BAA6B,CAA6B;IAC3E,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAuD;IAMzF,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA0C;IAC1E,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IACtC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAoB;IAChD,OAAO,CAAC,QAAQ,CAAC,6BAA6B,CAAqB;IACnE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAO;IACnC,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,OAAO,CAAK;IAKpB,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAU;IAC1C,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAU;IAE5C,YACE,IAAI,EAAE,MAAM,EACZ,UAAU,GAAE,SAAS,wBAAwB,EAAO,EACpD,OAAO,GAAE;QAAE,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAA;KAAO,EAY3F;IAED,GAAG,IAAI,SAAS,CAwQf;IAED,OAAO,CAAC,eAAe;IA0DvB,OAAO,CAAC,mBAAmB;IAU3B,OAAO,CAAC,WAAW;IAcnB,OAAO,CAAC,WAAW;IAMnB,OAAO,CAAC,gBAAgB;IAyCxB,OAAO,CAAC,oBAAoB;IAmB5B,OAAO,CAAC,cAAc;IAiDtB,OAAO,CAAC,UAAU;IA0ElB,OAAO,CAAC,eAAe;IAqCvB,OAAO,CAAC,YAAY;IAOpB;;;;;OAKG;IACH,OAAO,CAAC,qBAAqB;IAK7B,OAAO,CAAC,oBAAoB;IAoB5B,OAAO,CAAC,wBAAwB;IAqBhC,OAAO,CAAC,UAAU;IAqDlB,OAAO,CAAC,sBAAsB;IA+B9B,OAAO,CAAC,sBAAsB;IA2C9B,OAAO,CAAC,gBAAgB;IAmBxB,OAAO,CAAC,uBAAuB;IAY/B,OAAO,CAAC,qBAAqB;IAyB7B,OAAO,CAAC,kBAAkB;IAqB1B,OAAO,CAAC,QAAQ;IAIhB;;;;OAIG;IACH,OAAO,CAAC,eAAe;IAQvB,OAAO,CAAC,wBAAwB;IAMhC;;;;;OAKG;IACH,OAAO,CAAC,oBAAoB;IAW5B,OAAO,CAAC,MAAM;IAQd,OAAO,CAAC,YAAY;IAmBpB,OAAO,CAAC,+BAA+B;IAuBvC,OAAO,CAAC,eAAe;IAYvB,OAAO,CAAC,iCAAiC;IAiBzC,OAAO,CAAC,sBAAsB;IAI9B,OAAO,CAAC,yBAAyB;IAOjC,OAAO,CAAC,SAAS;IAKjB,OAAO,CAAC,OAAO;IAKf,OAAO,CAAC,gBAAgB;IAYxB,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,IAAI;IAIZ,OAAO,CAAC,OAAO;IAMf,OAAO,CAAC,iBAAiB;IAIzB,OAAO,CAAC,gBAAgB;IAIxB,OAAO,CAAC,OAAO;CAGhB"}