@barefootjs/jsx 0.31.10 → 0.33.0

package/dist/index.js

@@ -523,7 +523,7 @@ function convertNode(node, raw) {
           }
           if (n === undefined || Number.isNaN(n)) {
             const parsedDepth = convertNode(depthNode, raw);
-            if (checkSupport(parsedDepth).supported) {
+            if (checkSupport(parsedDepth, "rendered").supported) {
               depthExpr = parsedDepth;
               flatDepth = 1;
             } else {
@@ -617,10 +617,12 @@ function convertNode(node, raw) {
         const k = objectLiteralKeyName(prop.name);
         if (k === null)
           return { kind: "unsupported", raw, reason: `Unsupported syntax: ${ts2.SyntaxKind[node.kind]}` };
-        properties.push({ key: k.key, keyKind: k.keyKind, shorthand: false, value: convertNode(prop.initializer, raw) });
+        properties.push({ kind: "prop", key: k.key, keyKind: k.keyKind, shorthand: false, value: convertNode(prop.initializer, raw) });
       } else if (ts2.isShorthandPropertyAssignment(prop)) {
         const key = prop.name.text;
-        properties.push({ key, keyKind: "identifier", shorthand: true, value: { kind: "identifier", name: key } });
+        properties.push({ kind: "prop", key, keyKind: "identifier", shorthand: true, value: { kind: "identifier", name: key } });
+      } else if (ts2.isSpreadAssignment(prop)) {
+        properties.push({ kind: "spread", expr: convertNode(prop.expression, raw) });
       } else {
         return { kind: "unsupported", raw, reason: `Unsupported syntax: ${ts2.SyntaxKind[node.kind]}` };
       }
@@ -1300,14 +1302,26 @@ function getUnaryOperatorString(op) {
   }
 }
 function isSupported(expr) {
-  return checkSupport(expr);
+  return checkSupport(expr, "rendered");
 }
-function checkSupport(expr) {
+function isSupportedValue(expr) {
+  return checkSupport(expr, "value");
+}
+function checkSupport(expr, pos) {
   switch (expr.kind) {
     case "unsupported":
       return { supported: false, reason: expr.reason };
-    case "object-literal":
-      return { supported: false, reason: "Unsupported syntax: ObjectLiteralExpression" };
+    case "object-literal": {
+      if (pos !== "value") {
+        return { supported: false, reason: "Unsupported syntax: ObjectLiteralExpression" };
+      }
+      for (const prop of expr.properties) {
+        const propSupport = checkSupport(prop.kind === "spread" ? prop.expr : prop.value, pos);
+        if (!propSupport.supported)
+          return propSupport;
+      }
+      return { supported: true, level: "L2" };
+    }
     case "identifier":
       return { supported: true, level: "L1" };
     case "literal":
@@ -1317,7 +1331,7 @@ function checkSupport(expr) {
       return { supported: false, reason: "Standalone arrow functions / regex literals are not supported" };
     case "array-literal": {
       for (const el of expr.elements) {
-        const elSupport = checkSupport(el);
+        const elSupport = checkSupport(el, pos);
         if (!elSupport.supported)
           return elSupport;
       }
@@ -1330,16 +1344,16 @@ function checkSupport(expr) {
           reason: `String.prototype.${expr.method} supports only a string pattern + string replacement (the regex form is deferred); use a string pattern or wrap the expression in /* @client */`
         };
       }
-      const objSupport = checkSupport(expr.object);
+      const objSupport = checkSupport(expr.object, pos);
       if (!objSupport.supported)
         return objSupport;
       for (const arg of expr.args) {
-        const argSupport = checkSupport(arg);
+        const argSupport = checkSupport(arg, pos);
         if (!argSupport.supported)
           return argSupport;
       }
       if (expr.method === "flat" && expr.depthExpr) {
-        const depthSupport = checkSupport(expr.depthExpr);
+        const depthSupport = checkSupport(expr.depthExpr, pos);
         if (!depthSupport.supported)
           return depthSupport;
       }
@@ -1348,10 +1362,10 @@ function checkSupport(expr) {
     case "call": {
       const cb = asCallbackMethodCall(expr);
       if (cb) {
-        const objSupport = checkSupport(cb.object);
+        const objSupport = checkSupport(cb.object, pos);
         if (!objSupport.supported)
           return objSupport;
-        const bodySupport = checkSupport(cb.arrow.body);
+        const bodySupport = checkSupport(cb.arrow.body, pos);
         if (!bodySupport.supported) {
           return {
             supported: false,
@@ -1360,13 +1374,13 @@ function checkSupport(expr) {
           };
         }
         for (const rest of cb.args) {
-          const restSupport = checkSupport(rest);
+          const restSupport = checkSupport(rest, pos);
           if (!restSupport.supported)
             return restSupport;
         }
         return { supported: true, level: "L5" };
       }
-      const calleeSupport = checkSupport(expr.callee);
+      const calleeSupport = checkSupport(expr.callee, pos);
       if (!calleeSupport.supported) {
         return calleeSupport;
       }
@@ -1385,7 +1399,7 @@ function checkSupport(expr) {
         return { supported: true, level: "L1" };
       }
       for (const arg of expr.args) {
-        const argSupport = checkSupport(arg);
+        const argSupport = checkSupport(arg, pos);
         if (!argSupport.supported) {
           return argSupport;
         }
@@ -1393,7 +1407,7 @@ function checkSupport(expr) {
       return { supported: true, level: "L2" };
     }
     case "member": {
-      const objSupport = checkSupport(expr.object);
+      const objSupport = checkSupport(expr.object, pos);
       if (!objSupport.supported) {
         return objSupport;
       }
@@ -1403,19 +1417,19 @@ function checkSupport(expr) {
       return { supported: true, level: "L2" };
     }
     case "index-access": {
-      const objSupport = checkSupport(expr.object);
+      const objSupport = checkSupport(expr.object, pos);
       if (!objSupport.supported)
         return objSupport;
-      const indexSupport = checkSupport(expr.index);
+      const indexSupport = checkSupport(expr.index, pos);
       if (!indexSupport.supported)
         return indexSupport;
       return { supported: true, level: "L2" };
     }
     case "binary": {
-      const leftSupport = checkSupport(expr.left);
+      const leftSupport = checkSupport(expr.left, pos);
       if (!leftSupport.supported)
         return leftSupport;
-      const rightSupport = checkSupport(expr.right);
+      const rightSupport = checkSupport(expr.right, pos);
       if (!rightSupport.supported)
         return rightSupport;
       if (["===", "==", "!==", "!=", ">", "<", ">=", "<="].includes(expr.op)) {
@@ -1427,7 +1441,7 @@ function checkSupport(expr) {
       return { supported: false, reason: `Unknown operator: ${expr.op}` };
     }
     case "unary": {
-      const argSupport = checkSupport(expr.argument);
+      const argSupport = checkSupport(expr.argument, pos);
       if (!argSupport.supported)
         return argSupport;
       if (expr.op === "!") {
@@ -1439,25 +1453,25 @@ function checkSupport(expr) {
       return { supported: false, reason: `Unsupported unary operator: ${expr.op}` };
     }
     case "logical": {
-      const leftSupport = checkSupport(expr.left);
+      const leftSupport = checkSupport(expr.left, pos);
       if (!leftSupport.supported)
         return leftSupport;
       if (expr.op === "??" && expr.right.kind === "object-literal" && expr.right.properties.length === 0) {
         return { supported: true, level: "L4" };
       }
-      const rightSupport = checkSupport(expr.right);
+      const rightSupport = checkSupport(expr.right, pos);
       if (!rightSupport.supported)
         return rightSupport;
       return { supported: true, level: "L4" };
     }
     case "conditional": {
-      const testSupport = checkSupport(expr.test);
+      const testSupport = checkSupport(expr.test, pos);
       if (!testSupport.supported)
         return testSupport;
-      const consSupport = checkSupport(expr.consequent);
+      const consSupport = checkSupport(expr.consequent, pos);
       if (!consSupport.supported)
         return consSupport;
-      const altSupport = checkSupport(expr.alternate);
+      const altSupport = checkSupport(expr.alternate, pos);
       if (!altSupport.supported)
         return altSupport;
       return { supported: true, level: "L4" };
@@ -1465,7 +1479,7 @@ function checkSupport(expr) {
     case "template-literal": {
       for (const part of expr.parts) {
         if (part.type === "expression") {
-          const partSupport = checkSupport(part.expr);
+          const partSupport = checkSupport(part.expr, pos);
           if (!partSupport.supported)
             return partSupport;
         }
@@ -1618,7 +1632,7 @@ function isPureInit(e, pureCallNames) {
     case "array-literal":
       return e.elements.every(pure);
     case "object-literal":
-      return e.properties.every((p) => pure(p.value));
+      return e.properties.every((p) => pure(p.kind === "spread" ? p.expr : p.value));
     case "call":
       return e.callee.kind === "identifier" && e.args.length === 0 && pureCallNames !== undefined && pureCallNames.has(e.callee.name);
     case "array-method":
@@ -1672,7 +1686,7 @@ function usesPerPath(name, expr) {
         }
         return add(walk(e.object), sum(e.args));
       case "object-literal":
-        return sum(e.properties.map((p) => p.value));
+        return sum(e.properties.map((p) => p.kind === "spread" ? p.expr : p.value));
       case "arrow":
         return walk(e.body).max > 0 ? { min: 0, max: Number.POSITIVE_INFINITY } : { min: 0, max: 0 };
     }
@@ -1738,7 +1752,7 @@ function inlineBinding(expr, name, value) {
       case "object-literal":
         return {
           kind: "object-literal",
-          properties: e.properties.map((p) => ({ ...p, value: walk(p.value, enclosing) })),
+          properties: e.properties.map((p) => p.kind === "spread" ? { ...p, expr: walk(p.expr, enclosing) } : { ...p, value: walk(p.value, enclosing) }),
           raw: e.raw
         };
       case "literal":
@@ -1971,7 +1985,7 @@ function materializeGetterCalls(expr, names) {
       return {
         kind: "object-literal",
         raw: expr.raw,
-        properties: expr.properties.map((p) => ({ ...p, value: rw(p.value) }))
+        properties: expr.properties.map((p) => p.kind === "spread" ? { ...p, expr: rw(p.expr) } : { ...p, value: rw(p.value) })
       };
     case "arrow":
       return { kind: "arrow", params: expr.params, body: rw(expr.body) };
@@ -2029,7 +2043,7 @@ function freeVarsInBody(body, params) {
         return;
       case "object-literal":
         for (const p of e.properties)
-          visit(p.value, bound);
+          visit(p.kind === "spread" ? p.expr : p.value, bound);
         return;
       case "array-method":
         if (e.method === "includes" || e.method === "join") {
@@ -2104,7 +2118,7 @@ function freeIdentifiers(expr) {
         return true;
       case "object-literal":
         for (const p of e.properties)
-          if (!visit(p.value, bound))
+          if (!visit(p.kind === "spread" ? p.expr : p.value, bound))
             return false;
         return true;
       case "arrow": {
@@ -2251,10 +2265,17 @@ function toEvalNode(e) {
     case "object-literal": {
       const properties = [];
       for (const p of e.properties) {
+        if (p.kind === "spread") {
+          const spreadExpr = toEvalNode(p.expr);
+          if (!spreadExpr)
+            return null;
+          properties.push({ kind: "spread", expr: spreadExpr });
+          continue;
+        }
         const value = toEvalNode(p.value);
         if (!value)
           return null;
-        properties.push({ key: p.key, value });
+        properties.push({ kind: "prop", key: p.key, value });
       }
       return { kind: "object-literal", properties };
     }
@@ -10114,6 +10135,8 @@ function matchToLocaleDateStringCall(callee, args, metadata) {
   let tz = null;
   const probeOptions = {};
   for (const prop of options.properties) {
+    if (prop.kind === "spread")
+      return null;
     if (prop.value.kind !== "literal" || prop.value.literalType !== "string")
       return null;
     const value = String(prop.value.value);
@@ -11879,7 +11902,10 @@ function resolveCallbackMethodFunctionReferences(expr, analyzer, bound = EMPTY_B
           ...e.method === "flat" && e.depthExpr ? { depthExpr: visit2(e.depthExpr, bound2) } : {}
         };
       case "object-literal":
-        return { ...e, properties: e.properties.map((p) => ({ ...p, value: visit2(p.value, bound2) })) };
+        return {
+          ...e,
+          properties: e.properties.map((p) => p.kind === "spread" ? { ...p, expr: visit2(p.expr, bound2) } : { ...p, value: visit2(p.value, bound2) })
+        };
       case "arrow": {
         const inner = e.params.length === 0 ? bound2 : new Set([...bound2, ...e.params]);
         return { ...e, body: visit2(e.body, inner) };
@@ -23480,12 +23506,38 @@ function evalNode(node, ctx) {
     const baseResult = evalNode(node.expression, ctx);
     if (baseResult === undefined)
       return;
-    return UNRESOLVED;
+    if (baseResult === UNRESOLVED || baseResult === null || typeof baseResult !== "object") {
+      return UNRESOLVED;
+    }
+    const proto = Object.getPrototypeOf(baseResult);
+    if (proto !== Object.prototype && proto !== null)
+      return UNRESOLVED;
+    const key = node.name.text;
+    return Object.prototype.hasOwnProperty.call(baseResult, key) ? baseResult[key] : undefined;
   }
   if (ts22.isCallExpression(node)) {
     if (node.arguments.length === 0 && ts22.isIdentifier(node.expression) && node.expression.text in ctx.bindings) {
       return ctx.bindings[node.expression.text];
     }
+    if (ts22.isPropertyAccessExpression(node.expression) && node.expression.name.text === "map" && node.arguments.length === 1) {
+      const arrow = node.arguments[0];
+      if (ts22.isArrowFunction(arrow) && arrow.parameters.length === 1 && ts22.isIdentifier(arrow.parameters[0].name) && !ts22.isBlock(arrow.body)) {
+        const recv = evalNode(node.expression.expression, ctx);
+        if (Array.isArray(recv)) {
+          const paramName = arrow.parameters[0].name.text;
+          const mapped = [];
+          for (const item of recv) {
+            const localBindings = { ...ctx.bindings, [paramName]: item };
+            const v = evalNode(arrow.body, { ...ctx, bindings: localBindings });
+            if (v === UNRESOLVED)
+              return UNRESOLVED;
+            mapped.push(v === undefined ? null : v);
+          }
+          return mapped;
+        }
+      }
+      return UNRESOLVED;
+    }
     if (ts22.isPropertyAccessExpression(node.expression) && node.expression.name.text === "join") {
       const recv = evalNode(node.expression.expression, ctx);
       if (Array.isArray(recv)) {
@@ -23989,7 +24041,7 @@ function parseRecordIndexAccess(val, localConstants, propsParams, resolveKey) {
 
 // src/ssr-seed-plan.ts
 function classify2(name, origin, expr, parsed, available) {
-  if (!isSupported(parsed).supported)
+  if (!isSupportedValue(parsed).supported)
     return { kind: "opaque", name, origin };
   const frees = freeIdentifiers(parsed);
   if (frees === null)
@@ -24052,7 +24104,7 @@ function computeSsrSeedPlan(metadata) {
       }
     }
     const expr = signal.initialValue.trim();
-    steps.push(expr === "" ? { kind: "opaque", name: signal.getter, origin: "signal" } : classify2(signal.getter, "signal", expr, resolveThroughLocalConsts(parseExpression(expr), localConsts), available));
+    steps.push(expr === "" ? { kind: "opaque", name: signal.getter, origin: "signal" } : classify2(signal.getter, "signal", expr, resolveThroughLocalConsts(signal.parsed ?? parseExpression(`(${expr})`), localConsts), available));
     available.add(signal.getter);
   }
   for (const memo of metadata.memos) {
@@ -24216,7 +24268,7 @@ function checkExpr(expr, loc, meta, bindings, matchers, errors, seen) {
       break;
     case "object-literal":
       for (const prop of expr.properties)
-        recurse(prop.value);
+        recurse(prop.kind === "spread" ? prop.expr : prop.value);
       break;
     case "array-method":
       recurse(expr.object);
@@ -25599,6 +25651,26 @@ function isStringConcatBinary(op, left, right, isStringName) {
 function groupBinaryOperand(operand, emitted) {
   return operand.kind === "binary" || operand.kind === "logical" || operand.kind === "conditional" ? `(${emitted})` : emitted;
 }
+function groupObjectLiteralSegments(properties, literalOf, emit) {
+  const segments = [];
+  let run = [];
+  const flushRun = () => {
+    if (run.length > 0) {
+      segments.push(literalOf(run));
+      run = [];
+    }
+  };
+  for (const p of properties) {
+    if (p.kind === "spread") {
+      flushRun();
+      segments.push(emit(p.expr));
+    } else {
+      run.push(p);
+    }
+  }
+  flushRun();
+  return segments;
+}
 function emitParsedExpr(expr, emitter) {
   const emit = (child) => emitParsedExpr(child, emitter);
   switch (expr.kind) {
@@ -25713,72 +25785,6 @@ function collectLoopBoundNames(ir) {
   visit3(ir.root);
   return names;
 }
-// src/signal-init-eval.ts
-var BLOCKED_GLOBALS = [
-  "globalThis",
-  "window",
-  "document",
-  "Date",
-  "Math",
-  "crypto",
-  "performance",
-  "fetch",
-  "setTimeout",
-  "setInterval",
-  "require",
-  "process",
-  "Function"
-];
-function isTransportable(value, ancestors = new Set) {
-  if (value === null)
-    return true;
-  const t = typeof value;
-  if (t === "boolean" || t === "number" || t === "string")
-    return true;
-  if (t !== "object")
-    return false;
-  if (ancestors.has(value))
-    return false;
-  ancestors.add(value);
-  try {
-    if (Array.isArray(value)) {
-      if (Object.keys(value).length !== value.length)
-        return false;
-      return value.every((el) => el !== undefined && isTransportable(el, ancestors));
-    }
-    const proto = Object.getPrototypeOf(value);
-    if (proto !== Object.prototype && proto !== null)
-      return false;
-    return Object.values(value).every((v) => isTransportable(v, ancestors));
-  } finally {
-    ancestors.delete(value);
-  }
-}
-function tryEvaluateSignalInit(expr, props) {
-  const src = expr.trim();
-  if (src === "")
-    return { ok: false };
-  let fn;
-  try {
-    fn = new Function("props", ...BLOCKED_GLOBALS, `'use strict'; return (
-${src}
-);`);
-  } catch {
-    return { ok: false };
-  }
-  try {
-    const value = fn(props ?? {});
-    if (value === undefined)
-      return { ok: true, value: undefined };
-    return isTransportable(value) ? { ok: true, value } : { ok: false };
-  } catch {
-    return { ok: false };
-  }
-}
-function evaluateSignalInit(expr, props) {
-  const result = tryEvaluateSignalInit(expr, props);
-  return result.ok && result.value !== undefined ? result.value : null;
-}
 // src/static-literal.ts
 function evaluateStaticLiteral(expr, bindings) {
   switch (expr.kind) {
@@ -25811,6 +25817,17 @@ function evaluateStaticLiteral(expr, bindings) {
     case "object-literal": {
       const out = {};
       for (const prop of expr.properties) {
+        if (prop.kind === "spread") {
+          const resolved2 = evaluateStaticLiteral(prop.expr, bindings);
+          if (!resolved2)
+            return null;
+          if (resolved2.value === null || resolved2.value === undefined)
+            continue;
+          if (typeof resolved2.value !== "object" || Array.isArray(resolved2.value))
+            return null;
+          Object.assign(out, resolved2.value);
+          continue;
+        }
         const resolved = evaluateStaticLiteral(prop.value, bindings);
         if (!resolved)
           return null;
@@ -25880,6 +25897,8 @@ function matchQueryHrefCall(callee, args, localNames) {
     return null;
   const triples = [];
   for (const p of obj.properties) {
+    if (p.kind === "spread")
+      return null;
     const v = p.value;
     if (v.kind === "conditional" && isOmitBranch(v.alternate)) {
       triples.push({ guard: v.test, key: p.key, value: v.consequent });
@@ -26067,6 +26086,8 @@ function htmlPropValue(parsed) {
   if (parsed.properties.length !== 1)
     return null;
   const [prop] = parsed.properties;
+  if (prop.kind === "spread")
+    return null;
   if (prop.key !== "__html")
     return null;
   return prop.value;
@@ -28950,7 +28971,6 @@ function profileToJSON(profile) {
 registerBuiltinLoweringPlugins();
 export {
   tsNodeToParsedExpr,
-  tryEvaluateSignalInit,
   traceUpdatePath,
   testAdapter,
   stringifyParsedExpr,
@@ -28992,6 +29012,7 @@ export {
   joinProfilerEvents,
   isValueReferenceIdentifier,
   isValidHelperId,
+  isSupportedValue,
   isSupported,
   isStringTypedOperand,
   isStringConcatBinary,
@@ -29004,6 +29025,7 @@ export {
   importsSearchParams,
   identifierPath,
   hasUnsafeStyleValue,
+  groupObjectLiteralSegments,
   groupBinaryOperand,
   graphToJSON,
   getLoweringPlugins,
@@ -29043,7 +29065,6 @@ export {
   extractArrowBodyExpression,
   exprToString,
   evaluateStaticLiteral,
-  evaluateSignalInit,
   evaluateProfileGates,
   evalStringArrayJoin,
   envSignalReaderFor,

package/dist/query-href-lowering.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query-href-lowering.d.ts","sourceRoot":"","sources":["../src/query-href-lowering.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AAExD,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,KAAK,EAAE,UAAU,GAAG,IAAI,CAAA;IACxB,oCAAoC;IACpC,GAAG,EAAE,MAAM,CAAA;IACX,uEAAuE;IACvE,KAAK,EAAE,UAAU,CAAA;CAClB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,UAAU,CAAA;IAChB,OAAO,EAAE,eAAe,EAAE,CAAA;CAC3B;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,SAAS,UAAU,EAAE,EAC3B,UAAU,EAAE,WAAW,CAAC,MAAM,CAAC,GAC9B,aAAa,GAAG,IAAI,CAkBtB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAAG,MAAM,EAAE,CAoBzF"}
+{"version":3,"file":"query-href-lowering.d.ts","sourceRoot":"","sources":["../src/query-href-lowering.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AAExD,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,KAAK,EAAE,UAAU,GAAG,IAAI,CAAA;IACxB,oCAAoC;IACpC,GAAG,EAAE,MAAM,CAAA;IACX,uEAAuE;IACvE,KAAK,EAAE,UAAU,CAAA;CAClB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,UAAU,CAAA;IAChB,OAAO,EAAE,eAAe,EAAE,CAAA;CAC3B;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,SAAS,UAAU,EAAE,EAC3B,UAAU,EAAE,WAAW,CAAC,MAAM,CAAC,GAC9B,aAAa,GAAG,IAAI,CAsBtB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAAG,MAAM,EAAE,CAoBzF"}

package/dist/ssr-seed-plan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ssr-seed-plan.d.ts","sourceRoot":"","sources":["../src/ssr-seed-plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAGH,OAAO,EAAsB,KAAK,eAAe,EAAE,MAAM,0BAA0B,CAAA;AACnF,OAAO,EAML,KAAK,UAAU,EAChB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAE5C;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,WAAW,GACnB;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,eAAe,CAAA;CAAE,GAC7D;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,GAC/G;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,CAAA;CAAE,CAAA;AAE/D,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,KAAK,EAAE,WAAW,EAAE,CAAA;CACrB;AA4FD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,UAAU,GAAG,WAAW,CAqDpE"}
+{"version":3,"file":"ssr-seed-plan.d.ts","sourceRoot":"","sources":["../src/ssr-seed-plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAGH,OAAO,EAAsB,KAAK,eAAe,EAAE,MAAM,0BAA0B,CAAA;AACnF,OAAO,EAML,KAAK,UAAU,EAChB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAE5C;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,WAAW,GACnB;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,eAAe,CAAA;CAAE,GAC7D;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,GAC/G;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,CAAA;CAAE,CAAA;AAE/D,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,KAAK,EAAE,WAAW,EAAE,CAAA;CACrB;AAiGD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,UAAU,GAAG,WAAW,CAiEpE"}

package/dist/static-literal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"static-literal.d.ts","sourceRoot":"","sources":["../src/static-literal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAE9C;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,UAAU,EAChB,QAAQ,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,GACtC;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CA+D3B;AAED,iFAAiF;AACjF,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAE9D;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,WAAW,EAAE,UAAU,GAAG,SAAS,EACnC,cAAc,EAAE,aAAa,CAAC,YAAY,CAAC,GAAG,SAAS,EACvD,IAAI,CAAC,EAAE;IAAE,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAA;CAAE,GACpD,OAAO,EAAE,GAAG,IAAI,CAYlB"}
+{"version":3,"file":"static-literal.d.ts","sourceRoot":"","sources":["../src/static-literal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAE9C;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,UAAU,EAChB,QAAQ,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,GACtC;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CA6E3B;AAED,iFAAiF;AACjF,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAE9D;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,WAAW,EAAE,UAAU,GAAG,SAAS,EACnC,cAAc,EAAE,aAAa,CAAC,YAAY,CAAC,GAAG,SAAS,EACvD,IAAI,CAAC,EAAE;IAAE,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAA;CAAE,GACpD,OAAO,EAAE,GAAG,IAAI,CAYlB"}

package/dist/to-locale-date-lowering.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"to-locale-date-lowering.d.ts","sourceRoot":"","sources":["../src/to-locale-date-lowering.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAY,MAAM,YAAY,CAAA;AACtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAI1E;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,QAA4C,CAAA;AAKxE;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAWhE;AASD;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAA;IACf,sEAAsE;IACtE,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,CAAA;CACvB;AAmFD;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAEtE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACnC,gBAAgB,GAAG,IAAI,CAOzB;AA0PD,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,SAAS,UAAU,EAAE,EAC3B,QAAQ,EAAE,UAAU,GACnB,YAAY,GAAG,IAAI,CAyErB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAmBtF;AAED,eAAO,MAAM,kBAAkB,EAAE,cAMhC,CAAA"}
+{"version":3,"file":"to-locale-date-lowering.d.ts","sourceRoot":"","sources":["../src/to-locale-date-lowering.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAY,MAAM,YAAY,CAAA;AACtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAI1E;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,QAA4C,CAAA;AAKxE;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAWhE;AASD;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAA;IACf,sEAAsE;IACtE,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,CAAA;CACvB;AAmFD;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAEtE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACnC,gBAAgB,GAAG,IAAI,CAOzB;AA0PD,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,SAAS,UAAU,EAAE,EAC3B,QAAQ,EAAE,UAAU,GACnB,YAAY,GAAG,IAAI,CA6ErB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAmBtF;AAED,eAAO,MAAM,kBAAkB,EAAE,cAMhC,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/jsx",
-  "version": "0.31.10",
+  "version": "0.33.0",
   "description": "JSX compiler for BarefootJS - transforms JSX to server HTML + client JS",
   "type": "module",
   "main": "./dist/index.js",
@@ -49,7 +49,7 @@
     "directory": "packages/jsx"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.31.10"
+    "@barefootjs/shared": "0.33.0"
   },
   "peerDependencies": {
     "@barefootjs/client": ">=0.2.0",

package/src/__tests__/expression-parser.test.ts

@@ -1,6 +1,6 @@
 import { describe, test, expect } from 'bun:test'
 import ts from 'typescript'
-import { parseExpression, isSupported, exprToString, stringifyParsedExpr, parseBlockBody, foldBlockToExpr, extractArrowBodyExpression, parseStyleObjectEntries, parseProviderObjectLiteral, asCallbackMethodCall, containsHigherOrder } from '../expression-parser'
+import { parseExpression, isSupported, isSupportedValue, exprToString, stringifyParsedExpr, parseBlockBody, foldBlockToExpr, extractArrowBodyExpression, parseStyleObjectEntries, parseProviderObjectLiteral, asCallbackMethodCall, containsHigherOrder } from '../expression-parser'
 import { collectAllTypeRanges, reconstructWithoutTypes } from '../strip-types'
 
 describe('expression-parser', () => {
@@ -395,12 +395,23 @@ describe('expression-parser', () => {
       expect((parseExpression('true') as { raw?: string }).raw).toBeUndefined()
     })
 
-    test('falls through to unsupported for spread / computed-key object literals', () => {
-      // A spread member is not a plain map property — preserves the
-      // pre-A-1 `unsupported` behaviour (byte-identical).
-      expect(parseExpression('({ ...rest, a: 1 })').kind).toBe('unsupported')
-      // Computed key `[k]: v` can't resolve to a static name.
+    test('falls through to unsupported for computed-key object literals; spread parses as object-literal (#2696 Step 2)', () => {
+      // Computed key `[k]: v` can't resolve to a static name — still
+      // unsupported.
       expect(parseExpression('({ [k]: 1 })').kind).toBe('unsupported')
+      // A spread member (#2696 Step 2) is now a structured `{ kind:
+      // 'spread', expr }` entry, in source order alongside any `prop`
+      // entries — no longer the pre-#2696 blanket `unsupported`.
+      const spread = parseExpression('({ ...rest, a: 1 })')
+      expect(spread).toMatchObject({
+        kind: 'object-literal',
+        properties: [
+          { kind: 'spread', expr: { kind: 'identifier', name: 'rest' } },
+          { kind: 'prop', key: 'a', shorthand: false, value: { kind: 'literal', value: 1 } },
+        ],
+      })
+      // A method / getter / setter still isn't a plain map — still refuses.
+      expect(parseExpression('({ f() { return 1 } })').kind).toBe('unsupported')
     })
 
     test('a bare `{ … }` at statement position is a block, not an object literal', () => {
@@ -1402,6 +1413,32 @@ describe('expression-parser', () => {
       expect(result.supported).toBe(false)
     })
 
+    // #2696 review: `pos` propagates by pure inheritance, with no per-shape
+    // forcing to `value` — a RENDERED entry point's behaviour must stay
+    // byte-identical to before `isSupportedValue` existed, on every shape
+    // that reaches a container-contents position (an array-literal element,
+    // an array-method/callback receiver, a callback body). `isSupportedValue`
+    // admits the identical trees, since the whole tree it's entered on is a
+    // `value` position (a signal/memo initializer).
+    test('a populated object-literal array-literal element is refused at RENDERED, supported at VALUE', () => {
+      const expr = parseExpression('[{ a: 1 }]')
+      expect(expr.kind).toBe('array-literal')
+      expect(isSupported(expr).supported).toBe(false)
+      expect(isSupportedValue(expr).supported).toBe(true)
+    })
+
+    test('an array-of-objects .join() receiver is refused at RENDERED, supported at VALUE', () => {
+      const expr = parseExpression("[{ a: 1 }].join(',')")
+      expect(isSupported(expr).supported).toBe(false)
+      expect(isSupportedValue(expr).supported).toBe(true)
+    })
+
+    test('a .map() callback body returning an object literal is refused at RENDERED, supported at VALUE', () => {
+      const expr = parseExpression('items.map(t => ({ a: t }))')
+      expect(isSupported(expr).supported).toBe(false)
+      expect(isSupportedValue(expr).supported).toBe(true)
+    })
+
     test('L5: filter() with simple predicate IS supported', () => {
       const expr = parseExpression('items().filter(x => x.done)')
       const result = isSupported(expr)

package/src/__tests__/serialize-parsed-expr.test.ts

@@ -98,12 +98,26 @@ describe('serializeParsedExpr', () => {
     })
   })
 
-  test('map body: object literal carries key + value (no keyKind / shorthand)', () => {
+  test('map body: object literal carries kind + key + value (no keyKind / shorthand)', () => {
+    // #2696 Step 2: each entry now carries its own `kind` tag ('prop' here —
+    // no source spread in this body) so the evaluator can distinguish a
+    // `prop` from a `spread` entry without re-deriving it from field shape.
     expect(evalJSON('({ id: item.id, n: item.n })')).toEqual({
       kind: 'object-literal',
       properties: [
-        { key: 'id', value: { kind: 'member', object: { kind: 'identifier', name: 'item' }, property: 'id' } },
-        { key: 'n', value: { kind: 'member', object: { kind: 'identifier', name: 'item' }, property: 'n' } },
+        { kind: 'prop', key: 'id', value: { kind: 'member', object: { kind: 'identifier', name: 'item' }, property: 'id' } },
+        { kind: 'prop', key: 'n', value: { kind: 'member', object: { kind: 'identifier', name: 'item' }, property: 'n' } },
+      ],
+    })
+  })
+
+  test('map body: object literal carries a spread entry as `{ kind: "spread", expr }`', () => {
+    // The todo-app motivating shape (#2696): `{ ...t, editing: false }`.
+    expect(evalJSON("({ ...t, editing: false })")).toEqual({
+      kind: 'object-literal',
+      properties: [
+        { kind: 'spread', expr: { kind: 'identifier', name: 't' } },
+        { kind: 'prop', key: 'editing', value: { kind: 'literal', value: false } },
       ],
     })
   })