rip-lang 3.14.1 → 3.14.3

package/src/compiler.js

@@ -198,6 +198,12 @@ export class CodeEmitter {
     'optcall': 'emitOptCall',
     'regex-index': 'emitRegexIndex',
 
+    // Pick operator — obj.{a, b: c, d = default}
+    // Heads are non-identifier shapes so they can't collide with a user
+    // function named `pick` (e.g. `pick = (x) -> ...; pick(false)`).
+    '.{}':  'emitPick',
+    '?.{}': 'emitOptPick',
+
     // Functions
     'def': 'emitDef',
     '->': 'emitThinArrow',
@@ -463,6 +469,12 @@ export class CodeEmitter {
       return;
     }
 
+    if (head === 'for-in' || head === 'for-of' || head === 'for-as') {
+      this.collectVarsFromLoopHead(rest[0], this.programVars);
+      rest.slice(1).forEach(item => this.collectProgramVariables(item));
+      return;
+    }
+
     if (head === 'def' || head === '->' || head === '=>' || head === 'effect') return;
 
     if (head === 'if') {
@@ -515,6 +527,11 @@ export class CodeEmitter {
         collect(value);
         return;
       }
+      if (head === 'for-in' || head === 'for-of' || head === 'for-as') {
+        this.collectVarsFromLoopHead(rest[0], vars);
+        rest.slice(1).forEach(collect);
+        return;
+      }
       if (head === 'def' || head === '->' || head === '=>' || head === 'effect') return;
       if (head === 'try') {
         collect(rest[0]);
@@ -1023,7 +1040,7 @@ export class CodeEmitter {
     this._componentName = prevComponentName;
     this._componentTypeParams = prevComponentTypeParams;
     this._schemaName = prevSchemaName;
-    let isObjLit = this.is(value, 'object');
+    let isObjLit = this.is(value, 'object') || this.is(value, '.{}') || this.is(value, '?.{}');
     if (!isObjLit) valueCode = this.unwrap(valueCode);
 
     let needsParensVal = context === 'value';
@@ -1058,6 +1075,81 @@ export class CodeEmitter {
     return `${this.emit(obj, 'value')}?.${prop}`;
   }
 
+  // Pick operator: obj.{a, b: c, d = default}
+  //
+  // Semantics:
+  //   - missing key → `undefined` (source.key just reads as undefined)
+  //   - default fires on nullish (`??`), deliberately broader than JS
+  //     destructure's undefined-only defaults, to match DB NULL reality.
+  //   - rename `a: b` emits `b: source.a` (inverse of destructure pattern)
+  //
+  // Codegen strategy:
+  //   - Simple source (bare identifier, `this`) → inline, no function alloc
+  //   - Complex source (call, member, indexed, etc.) → arrow IIFE binds
+  //     a single-letter temp to ensure single evaluation and avoid
+  //     repeating getter reads.
+  //
+  // AST: [".{}", source, [srcKey, dstKey, defaultOrNull], ...]
+  emitPick(head, rest, context, sexpr) {
+    let [source, ...items] = rest;
+    let sourceCode = this.emit(source, 'value');
+    let simple = this._isSimplePickSource(source);
+    let ref = simple ? sourceCode : '_';
+
+    let body = items.map(([srcKey, dstKey, def]) => {
+      let access = `${ref}.${str(srcKey)}`;
+      if (def !== null && def !== undefined) {
+        access = `(${access} ?? ${this.emit(def, 'value')})`;
+      }
+      return `${str(dstKey)}: ${access}`;
+    }).join(', ');
+
+    // Always parenthesize the object literal so at statement position it
+    // parses as an expression, not a block. `x = ({a:...})` is harmless;
+    // bare `{a:...}` at statement-top would parse as a block in JS.
+    if (simple) return `({${body}})`;
+    return `((_) => ({${body}}))(${sourceCode})`;
+  }
+
+  // Optional-chain pick: obj?.{a, b}
+  //   - If source is null/undefined, result is `undefined` (not `{}`)
+  //   - Otherwise identical to pick semantics above
+  emitOptPick(head, rest, context, sexpr) {
+    let [source, ...items] = rest;
+    let sourceCode = this.emit(source, 'value');
+    let simple = this._isSimplePickSource(source);
+    let ref = simple ? sourceCode : '_';
+
+    let body = items.map(([srcKey, dstKey, def]) => {
+      let access = `${ref}.${str(srcKey)}`;
+      if (def !== null && def !== undefined) {
+        access = `(${access} ?? ${this.emit(def, 'value')})`;
+      }
+      return `${str(dstKey)}: ${access}`;
+    }).join(', ');
+
+    if (simple) return `(${sourceCode} == null ? undefined : {${body}})`;
+    return `((_) => _ == null ? undefined : ({${body}}))(${sourceCode})`;
+  }
+
+  // A pick source is "simple" only when it's safe to reference multiple
+  // times with no observable difference from a single-evaluation form.
+  // Restricted to AST shapes that are atomically identifier-like:
+  //   - bare identifier  (AST is a plain string like "whom")
+  //   - `this`           (AST is the literal string "this")
+  //   - `@`              (AST is the literal string "@")
+  // Member access like `this.x` or `obj.y` is NOT simple: getters and
+  // reactive tracking can observe each read, so we force an IIFE to
+  // evaluate the source exactly once.
+  _isSimplePickSource(node) {
+    if (typeof node !== 'string') return false;
+    // Identifier-shape or `@`/`this` only. Rejects string-typed AST nodes
+    // that happen to carry non-identifier content (defensive; current AST
+    // doesn't produce such strings but future shape changes are bounded).
+    return node === 'this' || node === '@' ||
+      /^[A-Za-z_$][\w$]*$/.test(node);
+  }
+
   emitRegexIndex(head, rest) {
     let [value, regex, captureIndex] = rest;
     this.helpers.add('toMatchable');
@@ -1380,7 +1472,7 @@ export class CodeEmitter {
         let stmts = body.slice(1);
         this.indentLevel++;
         let lines = [];
-        if (!noVar) lines.push(`const ${itemVarPattern} = ${iterCode}[${idxName}];`);
+        if (!noVar) lines.push(`${itemVarPattern} = ${iterCode}[${idxName}];`);
         if (guard) {
           lines.push(`if (${this.emit(guard, 'value')}) {`);
           this.indentLevel++;
@@ -1400,8 +1492,8 @@ export class CodeEmitter {
           : loopHeader + `{ ${this.emit(body, 'statement')}; }`;
       }
       return guard
-        ? loopHeader + `{ const ${itemVarPattern} = ${iterCode}[${idxName}]; if (${this.emit(guard, 'value')}) ${this.emit(body, 'statement')}; }`
-        : loopHeader + `{ const ${itemVarPattern} = ${iterCode}[${idxName}]; ${this.emit(body, 'statement')}; }`;
+        ? loopHeader + `{ ${itemVarPattern} = ${iterCode}[${idxName}]; if (${this.emit(guard, 'value')}) ${this.emit(body, 'statement')}; }`
+        : loopHeader + `{ ${itemVarPattern} = ${iterCode}[${idxName}]; ${this.emit(body, 'statement')}; }`;
     }
 
     // Index variable → traditional for loop
@@ -1411,7 +1503,7 @@ export class CodeEmitter {
       if (this.is(body, 'block')) {
         code += '{\n';
         this.indentLevel++;
-        code += this.indent() + `const ${itemVarPattern} = ${iterCode}[${indexVar}];\n`;
+        code += this.indent() + `${itemVarPattern} = ${iterCode}[${indexVar}];\n`;
         if (guard) {
           code += this.indent() + `if (${this.unwrap(this.emit(guard, 'value'))}) {\n`;
           this.indentLevel++;
@@ -1425,8 +1517,8 @@ export class CodeEmitter {
         code += this.indent() + '}';
       } else {
         code += guard
-          ? `{ const ${itemVarPattern} = ${iterCode}[${indexVar}]; if (${this.unwrap(this.emit(guard, 'value'))}) ${this.emit(body, 'statement')}; }`
-          : `{ const ${itemVarPattern} = ${iterCode}[${indexVar}]; ${this.emit(body, 'statement')}; }`;
+          ? `{ ${itemVarPattern} = ${iterCode}[${indexVar}]; if (${this.unwrap(this.emit(guard, 'value'))}) ${this.emit(body, 'statement')}; }`
+          : `{ ${itemVarPattern} = ${iterCode}[${indexVar}]; ${this.emit(body, 'statement')}; }`;
       }
       return code;
     }
@@ -1450,7 +1542,8 @@ export class CodeEmitter {
     }
 
     // Default: for-of
-    let code = `for (const ${itemVarPattern} of ${this.emit(iterable, 'value')}) `;
+    let bind = noVar ? 'let ' : '';
+    let code = `for (${bind}${itemVarPattern} of ${this.emit(iterable, 'value')}) `;
     code += guard ? this.emitLoopBodyWithGuard(body, guard) : this.emitLoopBody(body);
     return code;
   }
@@ -1465,7 +1558,7 @@ export class CodeEmitter {
 
     let [keyVar, valueVar] = Array.isArray(vars) ? vars : [vars];
     let objCode = this.emit(obj, 'value');
-    let code = `for (const ${keyVar} in ${objCode}) `;
+    let code = `for (${keyVar} in ${objCode}) `;
 
     if (own && !valueVar && !guard) {
       if (this.is(body, 'block')) {
@@ -1483,7 +1576,7 @@ export class CodeEmitter {
         this.indentLevel++;
         let lines = [];
         if (own) lines.push(`if (!Object.hasOwn(${objCode}, ${keyVar})) continue;`);
-        lines.push(`const ${valueVar} = ${objCode}[${keyVar}];`);
+        lines.push(`${valueVar} = ${objCode}[${keyVar}];`);
         if (guard) {
           lines.push(`if (${this.emit(guard, 'value')}) {`);
           this.indentLevel++;
@@ -1498,7 +1591,7 @@ export class CodeEmitter {
       }
       let inline = '';
       if (own) inline += `if (!Object.hasOwn(${objCode}, ${keyVar})) continue; `;
-      inline += `const ${valueVar} = ${objCode}[${keyVar}]; `;
+      inline += `${valueVar} = ${objCode}[${keyVar}]; `;
       if (guard) inline += `if (${this.emit(guard, 'value')}) `;
       inline += `${this.emit(body, 'statement')};`;
       return code + `{ ${inline} }`;
@@ -1545,7 +1638,7 @@ export class CodeEmitter {
       itemVarPattern = this.emitDestructuringPattern(firstVar);
     else itemVarPattern = firstVar;
 
-    let code = `for ${awaitKw}(const ${itemVarPattern} of ${iterCode}) `;
+    let code = `for ${awaitKw}(${itemVarPattern} of ${iterCode}) `;
 
     if (needsTempVar && destructStmts.length > 0) {
       let stmts = this.unwrapBlock(body);
@@ -1919,16 +2012,17 @@ export class CodeEmitter {
       let header = isNeg
         ? `for (let ${idxN} = ${ic}.length - 1; ${idxN} >= 0; ${update})`
         : `for (let ${idxN} = 0; ${idxN} < ${ic}.length; ${update})`;
-      return { header, setup: noVar ? null : `const ${ivp} = ${ic}[${idxN}];` };
+      return { header, setup: noVar ? null : `${ivp} = ${ic}[${idxN}];` };
     }
     if (indexVar) {
       let ic = this.emit(iterable, 'value');
       return {
         header: `for (let ${indexVar} = 0; ${indexVar} < ${ic}.length; ${indexVar}++)`,
-        setup: `const ${ivp} = ${ic}[${indexVar}];`,
+        setup: `${ivp} = ${ic}[${indexVar}];`,
       };
     }
-    return { header: `for (const ${ivp} of ${this.emit(iterable, 'value')})`, setup: null };
+    let bind = noVar ? 'let ' : '';
+    return { header: `for (${bind}${ivp} of ${this.emit(iterable, 'value')})`, setup: null };
   }
 
   // Shared: parse a for-of (object) iterator and return { header, own, vv, oc, kvp }.
@@ -1938,7 +2032,7 @@ export class CodeEmitter {
     let kvp = (this.is(kv, 'array') || this.is(kv, 'object'))
       ? this.emitDestructuringPattern(kv) : kv;
     let oc = this.emit(iterable, 'value');
-    return { header: `for (const ${kvp} in ${oc})`, own, vv, oc, kvp };
+    return { header: `for (${kvp} in ${oc})`, own, vv, oc, kvp };
   }
 
   // Shared: parse a for-as (iterator) spec and return { header }.
@@ -1947,7 +2041,7 @@ export class CodeEmitter {
     let [fv] = va;
     let ivp = (this.is(fv, 'array') || this.is(fv, 'object'))
       ? this.emitDestructuringPattern(fv) : fv;
-    return { header: `for ${isAwait ? 'await ' : ''}(const ${ivp} of ${this.emit(iterable, 'value')})` };
+    return { header: `for ${isAwait ? 'await ' : ''}(${ivp} of ${this.emit(iterable, 'value')})` };
   }
 
   emitComprehension(head, rest, context) {
@@ -1974,7 +2068,7 @@ export class CodeEmitter {
         code += this.indent() + header + ' {\n';
         this.indentLevel++;
         if (own) code += this.indent() + `if (!Object.hasOwn(${oc}, ${kvp})) continue;\n`;
-        if (vv) code += this.indent() + `const ${vv} = ${oc}[${kvp}];\n`;
+        if (vv) code += this.indent() + `${vv} = ${oc}[${kvp}];\n`;
       } else if (iterType === 'for-as') {
         let { header } = this._forAsHeader(vars, iterable, iter[3]);
         code += this.indent() + header + ' {\n';
@@ -2038,10 +2132,10 @@ export class CodeEmitter {
       if (iterType === 'for-of') {
         let [kv, vv] = vars;
         let oc = this.emit(iterable, 'value');
-        code += this.indent() + `for (const ${kv} in ${oc}) {\n`;
+        code += this.indent() + `for (${kv} in ${oc}) {\n`;
         this.indentLevel++;
         if (own) code += this.indent() + `if (!Object.hasOwn(${oc}, ${kv})) continue;\n`;
-        if (vv) code += this.indent() + `const ${vv} = ${oc}[${kv}];\n`;
+        if (vv) code += this.indent() + `${vv} = ${oc}[${kv}];\n`;
       }
     }
     for (let guard of guards) { code += this.indent() + `if (${this.emit(guard, 'value')}) {\n`; this.indentLevel++; }
@@ -2385,7 +2479,14 @@ export class CodeEmitter {
     if (typeof param === 'string') return param;
     if (param instanceof String) return param.valueOf();
     if (this.is(param, 'rest')) return `...${param[1]}`;
-    if (this.is(param, 'default')) return `${param[1]} = ${this.emit(param[2], 'value')}`;
+    if (this.is(param, 'default')) {
+      // `param[1]` is either a plain identifier string (e.g. `x = 5`) or a
+      // destructuring pattern AST node (e.g. `{a, b} = {}`). Recurse via
+      // `formatParam` so patterns emit as `{a, b}` / `[x, y]` instead of
+      // being coerced to a string via `Array.prototype.toString`, which
+      // produced the famous `(object,,a,a,,b,b = {})` mis-rendering.
+      return `${this.formatParam(param[1])} = ${this.emit(param[2], 'value')}`;
+    }
     if (this.is(param, '.') && param[1] === 'this') return param[2];
     if (this.is(param, 'array')) {
       let els = param.slice(1).map(el => {
@@ -2695,7 +2796,7 @@ export class CodeEmitter {
         code += header + ' {\n';
         this.indentLevel++;
         if (own) code += this.indent() + `if (!Object.hasOwn(${oc}, ${kvp})) continue;\n`;
-        if (vv) code += this.indent() + `const ${vv} = ${oc}[${kvp}];\n`;
+        if (vv) code += this.indent() + `${vv} = ${oc}[${kvp}];\n`;
         emitBody();
         this.indentLevel--;
         code += this.indent() + '}';
@@ -3059,12 +3160,29 @@ export class CodeEmitter {
       if (typeof item === 'string') { varSet.add(item); return; }
       if (Array.isArray(item)) {
         if (item[0] === '...' && typeof item[1] === 'string') varSet.add(item[1]);
+        else if (item[0] === '=' && typeof item[1] === 'string') varSet.add(item[1]);
         else if (item[0] === 'array') this.collectVarsFromArray(item, varSet);
         else if (item[0] === 'object') this.collectVarsFromObject(item, varSet);
       }
     });
   }
 
+  // Collect names bound by a for-in / for-of / for-as head. `vars` is the
+  // second slot of the loop s-expression and always arrives as an array of
+  // entries — e.g. ['x'], ['x', 'i'], ['k', 'v'], [['array', 'a', 'b']],
+  // or [undefined] for no-var range loops.
+  collectVarsFromLoopHead(vars, varSet) {
+    if (!Array.isArray(vars)) return;
+    vars.forEach(v => {
+      if (v == null) return;
+      if (typeof v === 'string') { varSet.add(v); return; }
+      if (Array.isArray(v)) {
+        if (v[0] === 'array') this.collectVarsFromArray(v, varSet);
+        else if (v[0] === 'object') this.collectVarsFromObject(v, varSet);
+      }
+    });
+  }
+
   collectVarsFromObject(obj, varSet) {
     obj.slice(1).forEach(pair => {
       if (!Array.isArray(pair)) return;

package/src/grammar/grammar.rip

@@ -243,6 +243,13 @@ grammar =
     o 'Value INDEX_START INDENT Expression OUTDENT INDEX_END'                   , '["[]", 1, 4]'
     o 'Value INDEX_START Slice INDEX_END'                                       , '["[]", 1, 3]'
     o 'Value INDEX_START INDENT Slice OUTDENT INDEX_END'                        , '["[]", 1, 4]'
+    # Pick operator: obj.{a, b: c, d = default} → { a: obj.a, c: obj.b, d: obj.d ?? default }
+    # Heads `.{}` and `?.{}` are syntax-shape strings that can't collide with
+    # a user function named `pick` (Rip encodes calls as [name, ...args]).
+    o 'Value PICK_START    PickList OptComma PICK_END'               , '[".{}",  1, ...3]'
+    o 'Value OPTPICK_START PickList OptComma PICK_END'               , '["?.{}", 1, ...3]'
+    o 'Value PICK_START    INDENT PickList OptComma OUTDENT PICK_END', '[".{}",  1, ...4]'
+    o 'Value OPTPICK_START INDENT PickList OptComma OUTDENT PICK_END', '["?.{}", 1, ...4]'
     # Regex indexing with capture group
     o 'Value INDEX_START RegexWithIndex INDEX_END'                              , '[$3[0], $1, ...$3.slice(1)]'
     # ES6 optional indexing (?.[ )
@@ -323,6 +330,11 @@ grammar =
     # Indexing
     o 'ObjSpreadExpr INDEX_START Expression INDEX_END'                , '["[]", 1, 3]'
     o 'ObjSpreadExpr INDEX_START INDENT Expression OUTDENT INDEX_END', '["[]", 1, 4]'
+    # Pick — {...obj.{a, b}} inside object literal spread
+    o 'ObjSpreadExpr PICK_START    PickList OptComma PICK_END'               , '[".{}",  1, ...3]'
+    o 'ObjSpreadExpr OPTPICK_START PickList OptComma PICK_END'               , '["?.{}", 1, ...3]'
+    o 'ObjSpreadExpr PICK_START    INDENT PickList OptComma OUTDENT PICK_END', '[".{}",  1, ...4]'
+    o 'ObjSpreadExpr OPTPICK_START INDENT PickList OptComma OUTDENT PICK_END', '["?.{}", 1, ...4]'
   ]
 
   # ============================================================================
@@ -348,6 +360,35 @@ grammar =
     o '... Expression'                            , '["...", 2]'
   ]
 
+  # ============================================================================
+  # Pick Expressions — obj.{a, b: newB, c = 'default', d: newD = 'x'}
+  #
+  # Each item compiles to a 3-tuple [srcKey, dstKey, defaultOrNull] that
+  # the codegen emits as `dstKey: (source.srcKey ?? default)` — nullish,
+  # intentionally different from JS destructure defaults (undefined-only).
+  #
+  # PickKey is restricted to Identifier/Property so we don't admit strings,
+  # numbers, or computed keys in v1.
+  # ============================================================================
+
+  PickList: [
+    o 'PickItem'                             , '[1]'
+    o 'PickList , PickItem'                  , '[...1, 3]'
+    o 'PickList OptComma TERMINATOR PickItem', '[...1, 4]'
+  ]
+
+  PickItem: [
+    o 'PickKey'                                 , '[1, 1, null]'   # shorthand {a}        → ["a", "a", null]
+    o 'PickKey : PickKey'                       , '[1, 3, null]'   # rename   {a: b}      → ["a", "b", null]
+    o 'PickKey = Expression'                    , '[1, 1, 3]'      # default  {a = 5}     → ["a", "a", 5]
+    o 'PickKey : PickKey = Expression'          , '[1, 3, 5]'      # both     {a: b = 5}  → ["a", "b", 5]
+  ]
+
+  PickKey: [
+    o 'Identifier'
+    o 'Property'
+  ]
+
   MapAssignable: [
     o 'Identifier'
     o 'Property'

package/src/lexer.js

@@ -140,8 +140,8 @@ let IMPLICIT_COMMA_BEFORE_ARROW = new Set([
 ]);
 
 // Tokens that start/end balanced pairs
-let EXPRESSION_START = new Set(['(', '[', '{', 'MAP_START', 'INDENT', 'CALL_START', 'PARAM_START', 'INDEX_START', 'STRING_START', 'INTERPOLATION_START', 'REGEX_START']);
-let EXPRESSION_END   = new Set([')', ']', '}', 'MAP_END', 'OUTDENT', 'CALL_END', 'PARAM_END', 'INDEX_END', 'STRING_END', 'INTERPOLATION_END', 'REGEX_END']);
+let EXPRESSION_START = new Set(['(', '[', '{', 'MAP_START', 'PICK_START', 'OPTPICK_START', 'INDENT', 'CALL_START', 'PARAM_START', 'INDEX_START', 'STRING_START', 'INTERPOLATION_START', 'REGEX_START']);
+let EXPRESSION_END   = new Set([')', ']', '}', 'MAP_END', 'PICK_END', 'OUTDENT', 'CALL_END', 'PARAM_END', 'INDEX_END', 'STRING_END', 'INTERPOLATION_END', 'REGEX_END']);
 
 // Balanced pair inverses
 let INVERSES = {
@@ -156,6 +156,8 @@ let INVERSES = {
   'INTERPOLATION_START': 'INTERPOLATION_END', 'INTERPOLATION_END': 'INTERPOLATION_START',
   'REGEX_START': 'REGEX_END', 'REGEX_END': 'REGEX_START',
   'MAP_START': 'MAP_END', 'MAP_END': 'MAP_START',
+  'PICK_START': 'PICK_END', 'PICK_END': 'PICK_START',
+  'OPTPICK_START': 'PICK_END',
 };
 
 // Tokens that close a clause (for normalizeLines)
@@ -181,6 +183,25 @@ let SINGLE_CLOSERS = new Set(['TERMINATOR', 'CATCH', 'FINALLY', 'ELSE', 'OUTDENT
 // Tokens that indicate end-of-line
 let LINE_BREAK = new Set(['INDENT', 'OUTDENT', 'TERMINATOR']);
 
+// Compound-key recognition shared by three lexer sites:
+//   - the implicit-call guard (blocks `IDENT -IDENT :` from wrapping as `IDENT(-IDENT)`)
+//   - the `:` handler (collapses the chain into a single STRING token)
+//   - `looksObjectish` (tells the implicit-object tracker an indented chain is still a key)
+//
+// A compound key is an IDENTIFIER followed by `[ (. | -) (IDENTIFIER|PROPERTY) ]+` and then `:`.
+// `.` accepts any spacing (pre-existing behavior). `-` requires no whitespace *or*
+// newline on either side, so legitimate subtraction (`a - b: 1`) and line-broken
+// expressions (`foo-\n  bar:`) remain unaffected.
+let isIdentOrProp = t => t?.[0] === 'IDENTIFIER' || t?.[0] === 'PROPERTY';
+let isCompoundSep = (sep, rhs) => {
+  if (sep?.[0] === '.') return true;
+  if (sep?.[0] === '-') {
+    return sep.spaced === false && !sep.newLine &&
+           rhs?.spaced === false && !rhs?.newLine;
+  }
+  return false;
+};
+
 // Tokens that close implicit calls when following a newline
 let CALL_CLOSERS = new Set(['.', '?.']);
 
@@ -426,6 +447,47 @@ export class Lexer {
     return p ? p[1] : undefined;
   }
 
+  // True when the next identifier/keyword-shaped token would sit in a
+  // pick-key position of a `.{` or `?.{` body. Used by identifierToken()
+  // to tag reserved-word keys (`default`, `class`, `delete`, …) as
+  // PROPERTY so they don't later become keyword/UNARY tokens (which
+  // would suppress a following TERMINATOR in multi-line bodies).
+  //
+  // Pick-key position means prev is one of: `{` (first key), `,`
+  // (subsequent key), `:` (rename dest), TERMINATOR/INDENT/OUTDENT
+  // (newline-separated key), AND we're inside a `{` that was
+  // preceded by a tight `.` or `?.`.
+  inPickKeyPos() {
+    let prev = this.prev();
+    if (!prev) return false;
+    let p = prev[0];
+    if (p !== '{' && p !== ',' && p !== ':' &&
+        p !== 'TERMINATOR' && p !== 'INDENT' && p !== 'OUTDENT') return false;
+    // Walk back to find the enclosing `{`. Bail out on a few structural
+    // tokens that mean we've left any pick body.
+    let depth = 0;
+    let toks = this.tokens;
+    for (let k = toks.length - 1; k >= 0; k--) {
+      let t = toks[k];
+      let tt = t[0];
+      if (tt === '}' || tt === 'PICK_END') { depth++; continue; }
+      if (tt === '{' || tt === 'PICK_START' || tt === 'OPTPICK_START') {
+        if (depth === 0) {
+          let before = toks[k - 1];
+          return !!(before && (before[0] === '.' || before[0] === '?.') &&
+                    !before.spaced && !t.spaced);
+        }
+        depth--;
+        continue;
+      }
+      // Cheap early-outs — if we escape the local block context, we
+      // clearly aren't inside any pick body.
+      if (depth === 0 && (tt === '(' || tt === 'CALL_START' ||
+          tt === '[' || tt === 'INDEX_START')) return false;
+    }
+    return false;
+  }
+
   // --------------------------------------------------------------------------
   // 1. Identifier Token
   // --------------------------------------------------------------------------
@@ -514,7 +576,7 @@ export class Lexer {
     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] === '@')))) {
+    if (colon || (prev && (prev[0] === '.' || prev[0] === '?.' || (!prev.spaced && prev[0] === '@'))) || this.inPickKeyPos()) {
       tag = 'PROPERTY';
 
       // In render blocks, consume hyphenated CSS class names: .counter-display → PROPERTY "counter-display"
@@ -1414,6 +1476,8 @@ export class Lexer {
   rewrite(tokens) {
     this.tokens = tokens;
     this.removeLeadingNewlines();
+    this.rewriteDottedPicks();  // .{ and ?.{ — must run before map literals so
+                                // pick bodies see raw { } for depth counting
     this.rewriteMapLiterals();
     this.closeMergeAssignments();
     this.closeOpenCalls();
@@ -1457,6 +1521,52 @@ export class Lexer {
     }
   }
 
+  // Pick operator: `obj.{a, b}` → { a: obj.a, b: obj.b }
+  //                `obj?.{a, b}` → obj == null ? undefined : { a: obj.a, b: obj.b }
+  //
+  // Recognize `.` or `?.` followed immediately by `{` at postfix position
+  // (preceded by an INDEXABLE value). Retag the `.` away and mark the braces
+  // as PICK_START/PICK_END (or OPTPICK_START/PICK_END for optional chain),
+  // leaving the body tokens to parse via the Pick grammar.
+  //
+  // Runs before rewriteMapLiterals() so pick bodies see raw `{`/`}` for
+  // depth tracking; map literals inside defaults are handled on the next
+  // pass after pick braces have been distinguished.
+  rewriteDottedPicks() {
+    let tokens = this.tokens;
+    for (let i = 0; i < tokens.length; i++) {
+      let tag = tokens[i][0];
+      if (tag !== '.' && tag !== '?.') continue;
+      let next = tokens[i + 1];
+      if (!next || next[0] !== '{') continue;
+      // `.` must sit tight to the next `{`: no whitespace between them.
+      // In Rip, token.spaced means "followed by whitespace", so checking
+      // tokens[i].spaced (the `.`) catches `. {` cases. We DON'T check
+      // next.spaced — that would mean "whitespace after `{`" which is
+      // perfectly fine (`obj.{ a, b }` should work like `obj.{a, b}`).
+      // Similarly, next.newLine is OK — it allows multiline bodies like
+      // `obj.{\n  a\n  b\n}`.
+      if (tokens[i].spaced || tokens[i].newLine) continue;
+      let prev = tokens[i - 1];
+      if (!prev || !INDEXABLE.has(prev[0])) continue;
+      let optional = (tag === '?.');
+      tokens.splice(i, 1);
+      tokens[i][0] = optional ? 'OPTPICK_START' : 'PICK_START';
+      // Find the matching close brace, retagging as PICK_END. Reserved-word
+      // keys inside the body are already handled upstream by inPickKeyPos()
+      // during initial tokenization — no second pass needed here.
+      let depth = 1;
+      for (let j = i + 1; j < tokens.length && depth > 0; j++) {
+        let tt = tokens[j][0];
+        if (tt === '{' || tt === 'PICK_START' || tt === 'OPTPICK_START') depth++;
+        else if (tt === '}') {
+          depth--;
+          if (depth === 0) { tokens[j][0] = 'PICK_END'; break; }
+        }
+      }
+    }
+  }
+
   closeOpenCalls() {
     this.scanTokens((token, i) => {
       if (token[0] === 'CALL_START') {
@@ -1708,7 +1818,20 @@ export class Lexer {
       }
 
       // Detect implicit function calls
-      if (IMPLICIT_FUNC.has(tag) && token.spaced &&
+      //
+      // Before firing on `IDENT -IDENT`, check if the real pattern is a
+      // compound-key chain (`data-src:`). If so, let the `:` handler
+      // collapse it to a STRING — don't wrap it as `data(-src)`.
+      let looksLikeCompoundKey = false;
+      if (nextTag === '-' && !nextToken.spaced && !nextToken.newLine && isIdentOrProp(token)) {
+        for (let k = i; k < tokens.length - 2; k += 2) {
+          if (!isCompoundSep(tokens[k + 1], tokens[k + 2])) break;
+          if (!isIdentOrProp(tokens[k + 2])) break;
+          if (tokens[k + 3]?.[0] === ':') { looksLikeCompoundKey = true; break; }
+        }
+      }
+
+      if (!looksLikeCompoundKey && IMPLICIT_FUNC.has(tag) && token.spaced &&
           (IMPLICIT_CALL.has(nextTag) || (nextTag === '...' && IMPLICIT_CALL.has(tokens[i + 2]?.[0])) ||
            (IMPLICIT_UNSPACED_CALL.has(nextTag) && !nextToken.spaced && !nextToken.newLine)) &&
           !((tag === ']' || tag === '}') && (nextTag === '->' || nextTag === '=>'))) {
@@ -1735,17 +1858,21 @@ export class Lexer {
           return forward(1);
         }
 
-        // Dotted keys: collapse `IDENTIFIER . PROPERTY . PROPERTY` into a STRING
-        if (tokens[i - 1]?.[0] === 'PROPERTY' && tokens[i - 2]?.[0] === '.') {
+        // Compound keys: collapse `IDENTIFIER [ (. | -) (IDENTIFIER|PROPERTY) ]+` into a STRING.
+        // Walks backwards from `:` through a chain, then rebuilds the string by concatenating
+        // each token's raw value (identifiers carry safe characters; separators contribute
+        // a literal `.` or `-`). See `isCompoundSep` for spacing rules.
+        // Examples: `www.amazon.com:`, `data-src:`, `beta-site.amazon.com:`.
+        if (isIdentOrProp(tokens[i - 1]) && isCompoundSep(tokens[i - 2], tokens[i - 1])) {
           let j = i - 2;
-          while (j >= 2 && tokens[j]?.[0] === '.' && (tokens[j - 1]?.[0] === 'PROPERTY' || tokens[j - 1]?.[0] === 'IDENTIFIER')) {
+          while (j >= 2 && isCompoundSep(tokens[j], tokens[j + 1]) && isIdentOrProp(tokens[j - 1])) {
             j -= 2;
           }
           j += 1;
-          if (tokens[j]?.[0] === 'IDENTIFIER' || tokens[j]?.[0] === 'PROPERTY') {
-            let parts = [];
-            for (let k = j; k < i; k += 2) parts.push(tokens[k][1]);
-            let str = gen('STRING', `"${parts.join('.')}"`, tokens[j]);
+          if (isIdentOrProp(tokens[j])) {
+            let buf = '';
+            for (let k = j; k < i; k++) buf += tokens[k][1];
+            let str = gen('STRING', `"${buf}"`, tokens[j]);
             str.pre = tokens[j].pre;
             str.spaced = tokens[j].spaced;
             str.newLine = tokens[j].newLine;
@@ -1765,7 +1892,7 @@ export class Lexer {
         if (stackTop()) {
           let [stackTag, stackIdx] = stackTop();
           let stackNext = stack[stack.length - 2];
-          let isBrace = (t) => t === '{' || t === 'MAP_START';
+          let isBrace = (t) => t === '{' || t === 'MAP_START' || t === 'PICK_START' || t === 'OPTPICK_START';
           if ((isBrace(stackTag) || (stackTag === 'INDENT' && isBrace(stackNext?.[0]) && !isImplicit(stackNext))) &&
               (startsLine || this.tokens[s - 1]?.[0] === ',' || isBrace(this.tokens[s - 1]?.[0]) || isBrace(this.tokens[s]?.[0]))) {
             return forward(1);
@@ -1943,11 +2070,13 @@ export class Lexer {
     if (!this.tokens[j]) return false;
     if (this.tokens[j]?.[0] === '@' && this.tokens[j + 2]?.[0] === ':') return true;
     if (this.tokens[j + 1]?.[0] === ':') return true;
-    // Dotted keys: IDENTIFIER . PROPERTY ... :
-    if ((this.tokens[j]?.[0] === 'IDENTIFIER' || this.tokens[j]?.[0] === 'PROPERTY') && this.tokens[j + 1]?.[0] === '.') {
-      let k = j + 2;
-      while (this.tokens[k]?.[0] === 'PROPERTY' && this.tokens[k + 1]?.[0] === '.') k += 2;
-      if (this.tokens[k]?.[0] === 'PROPERTY' && this.tokens[k + 1]?.[0] === ':') return true;
+    // Compound keys: IDENTIFIER [ (. | -) (IDENTIFIER|PROPERTY) ]+ :
+    if (isIdentOrProp(this.tokens[j])) {
+      for (let k = j + 1; k < this.tokens.length; k += 2) {
+        if (!isCompoundSep(this.tokens[k], this.tokens[k + 1])) break;
+        if (!isIdentOrProp(this.tokens[k + 1])) break;
+        if (this.tokens[k + 2]?.[0] === ':') return true;
+      }
     }
     if (EXPRESSION_START.has(this.tokens[j]?.[0])) {
       let end = null;