rip-lang 3.13.136 → 3.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rip-lang",
-  "version": "3.13.136",
+  "version": "3.14.0",
   "description": "A modern language that compiles to JavaScript",
   "type": "module",
   "main": "src/compiler.js",
@@ -27,8 +27,7 @@
     "scripts/serve.js",
     "rip-loader.js",
     "README.md",
-    "LICENSE",
-    "CHANGELOG.md"
+    "LICENSE"
   ],
   "scripts": {
     "build": "bun scripts/build.js",
@@ -36,9 +35,16 @@
     "gen:dom": "bun scripts/gen-dom.js",
     "gallery": "bun scripts/gallery.js",
     "parser": "bun src/grammar/solar.rip -o src/parser.js src/grammar/grammar.rip",
+    "postinstall": "bun scripts/link-local.js --quiet && bun scripts/link-check.js --quiet",
+    "link-local": "bun scripts/link-local.js",
+    "link-global": "bun scripts/link-global.js",
+    "link-check": "bun scripts/link-check.js",
     "serve": "bun scripts/serve.js",
     "test": "bun test/runner.js",
-    "test:types": "cd test/types && ../../bin/rip check && bunx tsc",
+    "test:types": "bun test/types/runner.js",
+    "test:server": "./bin/rip packages/server/tests/runner.rip",
+    "test:time": "bun run --cwd packages/time test",
+    "test:all": "bun run test && bun run test:types && bun run test:server && bun run test:time",
     "test:ui": "bun run --cwd packages/ui test:e2e",
     "test:ui:chromium": "bun run --cwd packages/ui test:e2e:chromium",
     "test:ui:axe": "bun run --cwd packages/ui test:e2e:axe",

package/src/AGENTS.md

@@ -300,6 +300,12 @@ div.card.active
 .card.primary.("flex", x)
 ```
 
+Tag and component name resolution:
+
+- **Lowercase names** that match the template tag set are **DOM elements** (`div`, `span`, `button`)
+- **PascalCase names** are **child components** — must start with uppercase, contain at least one lowercase letter, and have no underscores (`App`, `AuthScreen`, `HomeSection`)
+- **ALL_CAPS names** are treated as regular variables, not components (`DEFAULT_SCREEN`, `SECTIONS`, `A`, `IO`)
+
 Key mechanisms:
 
 - `startsWithTag` — backward scan to decide whether a line starts a template tag
@@ -527,6 +533,130 @@ Types are processed at the token layer before parsing.
 
 `rip --shadow file.rip` dumps the virtual TypeScript file that `rip check` and the VS Code extension feed into the TypeScript language service.
 
+---
+
+## Schema System
+
+Inline schemas are a third compiler sidecar — `schema.js` — that parallels
+`types.js` and `components.js`.
+
+### Lexer path
+
+- `installSchemaSupport(Lexer, CodeEmitter)` adds `rewriteSchema()` to the
+  Lexer prototype. It runs between `rewriteRender()` and `rewriteTypes()` in
+  the rewriter pipeline.
+- `rewriteSchema()` detects a contextual `schema` identifier at expression-
+  start positions followed by either a `:kind` SYMBOL or a direct INDENT.
+  The matching INDENT...OUTDENT range is parsed by a schema-specific
+  sub-parser and collapsed into a single `SCHEMA_BODY` token whose `.data`
+  carries a structured descriptor (kind, entries, per-entry `.loc`).
+- The main grammar has one tiny production, `Schema: SCHEMA SCHEMA_BODY`,
+  under `Expression`. Schema body syntax — field declarations (with
+  optional type, `min..max` range, `[default]`, `/regex/`, `{attrs}`,
+  terminal `-> transform` with whole-raw-input `it`), directives
+  (`@name`), methods (`name: -> body`), computed getters
+  (`name: ~> body`), eager-derived fields (`name: !> body`), and
+  `@ensure "msg", (x) -> predicate` refinements — never reaches the
+  main parser, so the state table stays lean.
+- Bodies of methods, computed getters, and hooks are captured as token
+  slices. At codegen time those slices run through the tail rewriter
+  passes (implicit braces, tagged templates, etc.) and feed into
+  `parser.parse()` via a temporary lex adapter. The parsed body is wrapped
+  as a thin-arrow `['->', [], body]` AST and emitted through the existing
+  codegen path — Rip `->` is already a `function()` (not a JS arrow), so
+  `this` binds to the instance.
+
+### Layered runtime
+
+The descriptor passed to `__schema({...})` is Layer 1. Layer 2 normalization
+(fields, methods, computed, hooks, relations, expanded mixins, collision
+checks) runs once per schema on first downstream use. Layer 3 (validator
+plan) builds on the first `.parse/.safe/.ok`; Layer 4a (ORM) on the first
+`.find/.create/.save`; Layer 4b (DDL) on the first `.toSQL()`. The four
+caches are independent — a DDL-emitting script that only calls `.toSQL()`
+never builds the ORM plan.
+
+### Registry
+
+`__SchemaRegistry` (process-global) holds every named `:model` and `:mixin`.
+Relations look up `:model` targets by name; `@mixin Name` looks up `:mixin`
+targets. Registration happens in the `__SchemaDef` constructor so just
+importing a file that defines named schemas activates them. Tests can call
+`__SchemaRegistry.reset()` between runs.
+
+### Algebra invariant
+
+`.pick/.omit/.partial/.required/.extend` always return `kind: 'shape'`.
+**Field semantics survive** — type (including literal unions), modifiers,
+constraints, and **inline transforms** — because they describe how a
+field's value is obtained from raw input, not what the instance does.
+**Instance behavior drops** — methods, computed getters (`~>`),
+eager-derived fields (`!>`), hooks, ORM methods, and `@ensure`
+refinements. Calling `.find()` or `.toSQL()` on a derived shape throws
+a dedicated error pointing the user at query projection on the source
+model. Refinements drop because they're schema-level invariants that
+reference field names by identifier — the algebra operation has no
+static way to know which names survive the derivation, so the safe
+rule is "never carry them through." Runtime tests and the shadow TS
+signatures both enforce this.
+
+### Parser invariants (don't break these)
+
+- **Field-line classification**: `IDENTIFIER` start → field; `PROPERTY`
+  start (trailing `:` absorbed into the identifier's tag) → callable.
+  Don't merge the two paths.
+- **Type slot is optional** and defaults to `string` — the parser only
+  consumes a type when `typeFirst[0] === 'IDENTIFIER'` or `'STRING'`
+  (the literal-union case). Anything else triggers the default.
+- **Transform is terminal**: once `->` appears as a field-line part,
+  no further comma-separated parts are allowed. Reject with a diagnostic
+  that says "move everything else before the arrow".
+- **Comma before `->` is required** whenever anything precedes it
+  (type, range, regex, default, attrs). Only the bare form `name! -> fn`
+  parses comma-less. There are two enforcement points: after type
+  consumption (if `rest[0]` is `->`), and inside the parts loop (via
+  `findTopLevelArrowIdx` scanning depth-zero arrows within a part).
+- **Transforms run on `.parse()` only, never `_hydrate`.** Hydrate
+  bypasses the whole parse pipeline (`_applyTransforms` → defaults →
+  validation → assign) and goes directly from column row to instance.
+- **Eager-derived (`!>`) runs on both parse AND hydrate** — in
+  declaration order, on the partially-constructed instance. It is
+  NOT re-run on field mutation (materialized once, stored as own
+  enumerable property).
+- **`@ensure` is a special directive** — parsed into its own
+  `tag: 'ensure'` entry (distinct from generic `tag: 'directive'`)
+  because it carries a compiled fn + message, not just args. Both
+  inline (`@ensure "msg", (x) -> body`) and array
+  (`@ensure [ "msg", fn, "msg", fn ]`) forms compile to one entry
+  per refinement; downstream runtime can't tell them apart. The
+  array-form splitter treats both `,` and TERMINATOR as element
+  separators at depth 0 to match Rip's array-literal convention.
+- **@ensure runs AFTER field validation and BEFORE eager-derived.**
+  `.parse/.safe/.ok` short-circuit `@ensure` when per-field errors
+  fire (predicates assume field types are correct). `_hydrate` skips
+  `@ensure` entirely (trusted data). Runtime method name
+  `_applyEnsures` mirrors the directive (parallel to
+  `_applyTransforms` for `-> transform` and `_applyEagerDerived` for
+  `!> derived`). See `src/schema.js`.
+
+### Shadow TS
+
+`emitSchemaTypes(sexpr, lines)` walks the parsed s-expression for named
+schema declarations, emits mixins first so intersections resolve, then
+emits type aliases and `declare const` per kind:
+
+- `:input` → `Schema<ValueType, ValueType>`
+- `:shape` → `Schema<ShapeInstance, ShapeData>` (or `Schema<Data, Data>` when
+  fields-only)
+- `:model` → `ModelSchema<Instance, Data>` with ORM methods and relation
+  accessors (same-file targets typed, cross-file degrades to `unknown`)
+- `:mixin` → field-only `type Foo = { ... }` alias, no runtime value
+- `:enum` → discriminated-union alias + const with `ok(data): data is
+  Role` type predicate
+
+`hasSchemas(source)` is the cheap probe that gates intrinsic preamble
+injection and file-level type checking (parallels `hasTypeAnnotations`).
+
 Typical debugging sequence:
 
 ```bash

package/src/compiler.js

@@ -12,6 +12,7 @@ import { Lexer } from './lexer.js';
 import { parser } from './parser.js';
 import { installComponentSupport } from './components.js';
 import { emitTypes, emitEnum } from './types.js';
+import { installSchemaSupport } from './schema.js';
 import { SourceMapGenerator } from './sourcemaps.js';
 import { RipError, toRipError } from './error.js';
 
@@ -251,6 +252,9 @@ export class CodeEmitter {
     // Types
     'enum': 'emitEnum',
 
+    // Schema
+    'schema': 'emitSchema',
+
     // Modules
     'import': 'emitImport',
     'export': 'emitExport',
@@ -263,6 +267,9 @@ export class CodeEmitter {
     'regex': 'emitRegex',
     'tagged-template': 'emitTaggedTemplate',
     'str': 'emitString',
+
+    // Symbol literals
+    'symbol': 'emitSymbol',
   };
 
   constructor(options = {}) {
@@ -318,12 +325,30 @@ export class CodeEmitter {
     }
   }
 
+  // Check whether a column position falls inside a string literal on a line of
+  // generated JavaScript/TypeScript.  Used by recordSubMappings to skip false
+  // matches (e.g. identifiers appearing as values inside union type strings).
+  static _isColInsideString(line, col) {
+    let inStr = false, quote = '';
+    for (let i = 0; i < line.length && i < col; i++) {
+      let ch = line[i];
+      if (inStr) {
+        if (ch === '\\') { i++; continue; }
+        if (ch === quote) inStr = false;
+      } else if (ch === '"' || ch === "'" || ch === '`') {
+        inStr = true; quote = ch;
+      }
+    }
+    return inStr;
+  }
+
   // Walk the s-expression tree and record source map entries for
   // sub-expressions that carry .loc, giving column-level precision.
   recordSubMappings(code, sexpr, lineOffset) {
     let stmtOrigLine = sexpr.loc ? sexpr.loc.r : 0;
     let subs = [];
     this.collectSubExprs(sexpr, subs);
+    let codeLines = code.split('\n');
     for (let { name, origLine, origCol } of subs) {
       let escaped = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
       let re = new RegExp('\\b' + escaped + '\\b', 'g');
@@ -332,11 +357,15 @@ export class CodeEmitter {
       while ((m = re.exec(code)) !== null) {
         let before = code.substring(0, m.index);
         let nl = before.split('\n');
-        let genLine = lineOffset + nl.length - 1;
+        let genLineInStmt = nl.length - 1;
         let genCol = nl[nl.length - 1].length;
+        // Skip matches inside string literals — prevents false mappings when
+        // an identifier also appears as a string value (e.g. union type member)
+        let lineText = codeLines[genLineInStmt];
+        if (lineText && CodeEmitter._isColInsideString(lineText, genCol)) continue;
+        let genLine = lineOffset + genLineInStmt;
         // Prefer matches on the same relative line within the statement,
         // falling back to column distance as tiebreaker.
-        let genLineInStmt = nl.length - 1;
         let dist = Math.abs(genLineInStmt - origLineInStmt) * 10000 + Math.abs(genCol - origCol);
         if (dist < bestDist) { bestDist = dist; bestMatch = { genLine, genCol }; }
       }
@@ -770,6 +799,17 @@ export class CodeEmitter {
       needsBlank = true;
     }
 
+    if (this.usesSchemas && !skip) {
+      if (skipRT) {
+        code += 'var { __schema, SchemaError, __SchemaRegistry, __schemaSetAdapter } = globalThis.__ripSchema;\n';
+      } else if (typeof globalThis !== 'undefined' && globalThis.__ripSchema) {
+        code += 'const { __schema, SchemaError, __SchemaRegistry, __schemaSetAdapter } = globalThis.__ripSchema;\n';
+      } else {
+        code += this.getSchemaRuntime();
+      }
+      needsBlank = true;
+    }
+
     if (this.dataSection !== null && this.dataSection !== undefined && !skip) {
       code += 'var DATA;\n_setDataSection();\n';
       needsBlank = true;
@@ -971,13 +1011,18 @@ export class CodeEmitter {
 
     const prevComponentName = this._componentName;
     const prevComponentTypeParams = this._componentTypeParams;
+    const prevSchemaName = this._schemaName;
     if (this.is(value, 'component') && (typeof target === 'string' || target instanceof String)) {
       this._componentName = str(target);
       this._componentTypeParams = target.typeParams || '';
     }
+    if (this.is(value, 'schema') && (typeof target === 'string' || target instanceof String)) {
+      this._schemaName = str(target);
+    }
     let valueCode = this.emit(value, 'value');
     this._componentName = prevComponentName;
     this._componentTypeParams = prevComponentTypeParams;
+    this._schemaName = prevSchemaName;
     let isObjLit = this.is(value, 'object');
     if (!isObjLit) valueCode = this.unwrap(valueCode);
 
@@ -1630,6 +1675,12 @@ export class CodeEmitter {
     return `(${ops.map(o => this.emit(o, 'value')).join(' || ')})`;
   }
 
+  // ---------------------------------------------------------------------------
+  // Symbol literals
+  // ---------------------------------------------------------------------------
+
+  emitSymbol(head, rest) { return `Symbol.for(${JSON.stringify(rest[0])})`; }
+
   // ---------------------------------------------------------------------------
   // Data structures
   // ---------------------------------------------------------------------------
@@ -2162,13 +2213,16 @@ export class CodeEmitter {
       if (this.is(decl, '=')) {
         const prev = this._componentName;
         const prevTP = this._componentTypeParams;
+        const prevSchema = this._schemaName;
         if (this.is(decl[2], 'component')) {
           this._componentName = str(decl[1]);
           this._componentTypeParams = decl[1]?.typeParams || '';
         }
+        if (this.is(decl[2], 'schema')) this._schemaName = str(decl[1]);
         const result = `const ${decl[1]} = ${this.emit(decl[2], 'value')}`;
         this._componentName = prev;
         this._componentTypeParams = prevTP;
+        this._schemaName = prevSchema;
         return result;
       }
       if (Array.isArray(decl) && decl.every(i => typeof i === 'string')) return '';
@@ -2177,13 +2231,16 @@ export class CodeEmitter {
     if (this.is(decl, '=')) {
       const prev = this._componentName;
       const prevTP = this._componentTypeParams;
+      const prevSchema = this._schemaName;
       if (this.is(decl[2], 'component')) {
         this._componentName = str(decl[1]);
         this._componentTypeParams = decl[1]?.typeParams || '';
       }
+      if (this.is(decl[2], 'schema')) this._schemaName = str(decl[1]);
       const result = `export const ${decl[1]} = ${this.emit(decl[2], 'value')}`;
       this._componentName = prev;
       this._componentTypeParams = prevTP;
+      this._schemaName = prevSchema;
       return result;
     }
     if (Array.isArray(decl) && decl.every(i => typeof i === 'string')) return `export { ${decl.join(', ')} }`;
@@ -3555,6 +3612,12 @@ installComponentSupport(CodeEmitter, Lexer);
 
 CodeEmitter.prototype.emitEnum = emitEnum;
 
+// =============================================================================
+// Schema Support (prototype installation)
+// =============================================================================
+
+installSchemaSupport(null, CodeEmitter);
+
 // =============================================================================
 // Convenience Functions
 // =============================================================================

package/src/components.js

@@ -145,7 +145,7 @@ export function installComponentSupport(CodeEmitter, Lexer) {
 
     let isComponent = (name) => {
       if (!name || typeof name !== 'string') return false;
-      return /^[A-Z]/.test(name);
+      return /^[A-Z][A-Za-z0-9]*[a-z][A-Za-z0-9]*$/.test(name);
     };
 
     let isTemplateTag = (name) => {
@@ -538,7 +538,7 @@ export function installComponentSupport(CodeEmitter, Lexer) {
    */
   proto.isComponent = function(name) {
     if (!name || typeof name !== 'string') return false;
-    return /^[A-Z]/.test(name);
+    return /^[A-Z][A-Za-z0-9]*[a-z][A-Za-z0-9]*$/.test(name);
   };
 
   /**
@@ -1132,7 +1132,9 @@ export function installComponentSupport(CodeEmitter, Lexer) {
               return; // Don't walk children again below
             }
           } else if (head === '__text__') {
-            // = expr — text expression: emit the expression for type-checking
+            // = expr — text expression: emit the expression for type-checking.
+            // Return early — the expression is fully handled; walking children
+            // would mis-interpret the call target as an element tag name.
             const textExpr = node[1];
             if (textExpr != null) {
               const exprCode = this.emitInComponent(textExpr, 'value');
@@ -1140,6 +1142,18 @@ export function installComponentSupport(CodeEmitter, Lexer) {
               const srcMarker = srcLine != null ? ` // @rip-src:${srcLine}` : '';
               constructions.push(`    ${exprCode};${srcMarker}`);
             }
+            return;
+          } else if (head === 'str') {
+            // Interpolated string — emit the full expression so TS sees
+            // references to variables/functions inside the interpolation
+            // (e.g. "#{format(x)}" must count as a read of `format`).
+            try {
+              const exprCode = this.emitInComponent(node, 'value');
+              const srcLine = node.loc?.r;
+              const srcMarker = srcLine != null ? ` // @rip-src:${srcLine}` : '';
+              constructions.push(`    ${exprCode};${srcMarker}`);
+            } catch {}
+            return;
           }
 
           // Emit a bare lowercase identifier as either a property access
@@ -1534,7 +1548,7 @@ export function installComponentSupport(CodeEmitter, Lexer) {
     const statements = this.is(body, 'block') ? body.slice(1) : [body];
 
     let rootVar;
-    if (statements.length === 0) {
+    if (statements.length === 0 || (statements.length === 1 && statements[0] === 'null')) {
       rootVar = 'null';
     } else if (statements.length === 1) {
       this._pendingAutoWire = !!this._autoEventHandlers;
@@ -2895,7 +2909,7 @@ class __Component {
     this._target = target;
     try {
       this._root = this._create();
-      target.appendChild(this._root);
+      if (this._root) target.appendChild(this._root);
       if (this._setup) this._setup();
       if (this.mounted) this.mounted();
     } catch (error) {

package/src/grammar/grammar.rip

@@ -86,6 +86,7 @@ grammar =
     o 'Yield'
     o 'Def'
     o 'Enum'
+    o 'Schema'
   ]
 
   # Single-line expressions (for postfix forms and inline arrows).
@@ -122,6 +123,7 @@ grammar =
     o 'BOOL'      # true/false
     o 'INFINITY'  # Infinity
     o 'NAN'       # NaN
+    o 'SYMBOL'    , '["symbol", 1]'
   ]
 
   AlphaNumeric: [
@@ -360,6 +362,7 @@ grammar =
     o 'Array'
     o 'Object'
     o 'Parenthetical'
+    o 'SYMBOL'     , '["symbol", 1]'
   ]
 
   # ============================================================================
@@ -760,6 +763,21 @@ grammar =
     o 'ENUM Identifier Block', '["enum", 2, 3]'
   ]
 
+  # ============================================================================
+  # Schema
+  # ============================================================================
+  # `schema [:kind] INDENT ... OUTDENT` is parsed entirely by the schema
+  # sub-parser at lexer-rewrite time (src/schema.js). The rewriter emits
+  # a synthetic SCHEMA_BODY token whose .data carries the full descriptor
+  # (kind, entries, per-entry loc). The main grammar only sees these two
+  # terminals, which keeps schema body syntax (`name! type`, `@directive`,
+  # `name: -> body`, `name: ~> body`) fully localized and prevents
+  # state-table growth.
+
+  Schema: [
+    o 'SCHEMA SCHEMA_BODY', '["schema", 2]'
+  ]
+
   # ============================================================================
   # Components
   # ============================================================================
@@ -793,7 +811,8 @@ grammar =
   #          div.card
   #            h1 "Hello"
   Render: [
-    o 'RENDER Block', '["render", 2]'
+    o 'RENDER Block'      , '["render", 2]'
+    o 'RENDER Expression' , '["render", 2]'
   ]
 
   # ============================================================================

package/src/lexer.js

@@ -40,6 +40,7 @@
 // ==========================================================================
 
 import { installTypeSupport } from './types.js';
+import { installSchemaSupport } from './schema.js';
 
 // ==========================================================================
 // Token Category Sets
@@ -107,6 +108,7 @@ let INDEXABLE = new Set([
   ...CALLABLE,
   'NUMBER', 'INFINITY', 'NAN', 'STRING', 'STRING_END',
   'REGEX', 'REGEX_END', 'BOOL', 'NULL', 'UNDEFINED', '}', 'MAP_END',
+  'SYMBOL',
 ]);
 
 // Tokens that can follow IMPLICIT_FUNC to start an implicit call
@@ -118,6 +120,7 @@ let IMPLICIT_CALL = new Set([
   'UNDEFINED', 'NULL', 'BOOL', 'UNARY', 'DO', 'DO_IIFE',
   'YIELD', 'AWAIT', 'UNARY_MATH', 'SUPER', 'THROW',
   '@', '->', '=>', '[', '(', '{', 'MAP_START', '--', '++',
+  'SYMBOL',
 ]);
 
 // Tokens that can start an implicit call (unspaced, like +/-)
@@ -133,6 +136,7 @@ let IMPLICIT_END = new Set([
 let IMPLICIT_COMMA_BEFORE_ARROW = new Set([
   'STRING', 'STRING_END', 'REGEX', 'REGEX_END', 'NUMBER',
   'BOOL', 'NULL', 'UNDEFINED', 'INFINITY', 'NAN', ']', '}', 'MAP_END',
+  'SYMBOL',
 ]);
 
 // Tokens that start/end balanced pairs
@@ -506,6 +510,9 @@ export class Lexer {
     // Don't treat colon as property when in ternary context
     if (colon && prev && prev[0] === 'TERNARY') colon = null;
 
+    // Don't capture spaced colon when followed by identifier start (symbol literal)
+    if (colon && colon.length > 1 && /[a-zA-Z_$]/.test(this.chunk[idLen + colon.length])) colon = null;
+
     // Property vs identifier
     if (colon || (prev && (prev[0] === '.' || prev[0] === '?.' || (!prev.spaced && prev[0] === '@')))) {
       tag = 'PROPERTY';
@@ -649,6 +656,18 @@ export class Lexer {
       }
       if (/^\s+#[a-zA-Z_]/.test(this.chunk)) return 0;  // let lineToken handle indentation first
     }
+    // Schema field modifier: `#` adjacent (unspaced) to an identifier acts
+    // as the unique-marker inside schema bodies (e.g. `email!# email`).
+    // Return 0 so literalToken emits a standalone `#` token; rewriteSchema
+    // absorbs it. Outside schema bodies the `#` token is harmless because
+    // nothing else in the grammar accepts `IDENTIFIER #` without a space.
+    if (this.chunk[0] === '#') {
+      let prev = this.prev();
+      if (prev && !prev.spaced && !prev.newLine &&
+          (prev[0] === 'IDENTIFIER' || prev[0] === 'PROPERTY')) {
+        return 0;
+      }
+    }
     let match = COMMENT_RE.exec(this.chunk);
     if (!match) return 0;
     return match[0].length;
@@ -1162,6 +1181,23 @@ export class Lexer {
     return total;
   }
 
+  // --------------------------------------------------------------------------
+  // Symbol Literal: :name → Symbol.for('name')
+  // --------------------------------------------------------------------------
+
+  symbolToken() {
+    if (this.chunk[0] !== ':') return 0;
+    let next = this.chunk[1];
+    if (!next || next === '=' || next === ':' || /\s/.test(next)) return 0;
+    if (!/[a-zA-Z_$]/.test(next)) return 0;
+    let match = /^((?:(?!\s)[$\w\x7f-\uffff])+)/.exec(this.chunk.slice(1));
+    if (!match) return 0;
+    let name = match[1];
+    let total = name.length + 1;
+    this.emit('SYMBOL', name, {len: total});
+    return total;
+  }
+
   // --------------------------------------------------------------------------
   // 9. Literal Token (operators, punctuation, everything else)
   // --------------------------------------------------------------------------
@@ -1171,6 +1207,10 @@ export class Lexer {
     let wl = this.wordLiteral();
     if (wl) return wl;
 
+    // :name symbol literal: :redo → Symbol.for("redo")
+    let sl = this.symbolToken();
+    if (sl) return sl;
+
     let match = OPERATOR_RE.exec(this.chunk);
     let val = match ? match[0] : this.chunk.charAt(0);
     let tag = val;
@@ -1380,6 +1420,7 @@ export class Lexer {
     this.closeOpenIndexes();
     this.normalizeLines();
     this.rewriteRender?.();
+    this.rewriteSchema?.();
     this.rewriteTypes();
     this.tagPostfixConditionals();
     this.rewriteTaggedTemplates();
@@ -1951,6 +1992,7 @@ export class Lexer {
 // ==========================================================================
 
 installTypeSupport(Lexer);
+installSchemaSupport(Lexer);
 
 // ==========================================================================
 // Convenience export