@barefootjs/erb 0.31.8 → 0.31.10

package/dist/vite.js

@@ -3025,6 +3025,34 @@ var SVG_ROOT_TAGS = new Set([
   "animateTransform",
   "animateMotion"
 ]);
+var MATHML_ROOT_TAGS = new Set([
+  "math",
+  "mrow",
+  "mfrac",
+  "msup",
+  "msub",
+  "msubsup",
+  "mn",
+  "mi",
+  "mo",
+  "mtext",
+  "munder",
+  "mover",
+  "munderover",
+  "mtable",
+  "mtr",
+  "mtd",
+  "msqrt",
+  "mroot",
+  "mstyle",
+  "merror",
+  "mpadded",
+  "mphantom",
+  "menclose",
+  "semantics",
+  "annotation",
+  "annotation-xml"
+]);
 
 // ../jsx/src/ir-to-client-js/collect-elements.ts
 var EMPTY_RENDER_EXPRS = new Set(["null", "undefined", "false", "''", '""', "``"]);
@@ -3888,6 +3916,38 @@ function classify(name, origin, expr, parsed, available) {
   }
   return { kind: "derived", name, origin, expr, parsed, frees: [...frees] };
 }
+function localConstExprsByName(metadata) {
+  const out = new Map;
+  for (const c of metadata.localConstants ?? []) {
+    if (c.isModule || c.declarationKind !== "const" || c.value === undefined)
+      continue;
+    out.set(c.name, c.parsed ?? parseExpression(c.value.trim()));
+  }
+  return out;
+}
+function resolveThroughLocalConsts(parsed, localConsts) {
+  let current = parsed;
+  const maxIter = localConsts.size + 1;
+  for (let i = 0;i < maxIter; i++) {
+    const frees = freeIdentifiers(current);
+    if (frees === null)
+      break;
+    let changed = false;
+    for (const name of frees) {
+      const value = localConsts.get(name);
+      if (!value)
+        continue;
+      const inlined = inlineBinding(current, name, value);
+      if (inlined === null)
+        continue;
+      current = inlined;
+      changed = true;
+    }
+    if (!changed)
+      break;
+  }
+  return current;
+}
 function computeSsrSeedPlan(metadata) {
   const baseScope = metadata.propsParams.map((p) => p.name);
   if (metadata.propsObjectName)
@@ -3896,6 +3956,7 @@ function computeSsrSeedPlan(metadata) {
     baseScope.push(name);
   }
   const available = new Set(baseScope);
+  const localConsts = localConstExprsByName(metadata);
   const steps = [];
   for (const signal of metadata.signals) {
     if (signal.envReader) {
@@ -3907,13 +3968,13 @@ function computeSsrSeedPlan(metadata) {
       }
     }
     const expr = signal.initialValue.trim();
-    steps.push(expr === "" ? { kind: "opaque", name: signal.getter, origin: "signal" } : classify(signal.getter, "signal", expr, parseExpression(expr), available));
+    steps.push(expr === "" ? { kind: "opaque", name: signal.getter, origin: "signal" } : classify(signal.getter, "signal", expr, resolveThroughLocalConsts(parseExpression(expr), localConsts), available));
     available.add(signal.getter);
   }
   for (const memo of metadata.memos) {
     const body = extractArrowBodyExpression(memo.computation);
     const expr = body?.trim() ?? "";
-    steps.push(expr === "" ? { kind: "opaque", name: memo.name, origin: "memo" } : classify(memo.name, "memo", expr, memo.parsed ?? parseExpression(expr), available));
+    steps.push(expr === "" ? { kind: "opaque", name: memo.name, origin: "memo" } : classify(memo.name, "memo", expr, resolveThroughLocalConsts(memo.parsed ?? parseExpression(expr), localConsts), available));
     available.add(memo.name);
   }
   return { baseScope, steps };

package/lib/barefoot_js.rb

@@ -125,11 +125,23 @@ module BarefootJS
       props = _props
       return '' unless props && !props.empty?
 
+      # Exclude the internal `scope_id` key from the client hydration
+      # payload: it is a server-side render detail (already carried by
+      # `_scope_id` for bf-s/bf-h/bf-m emission) with zero client runtime
+      # consumers -- the only bf-p parser (packages/client/src/runtime/
+      # hydrate.ts's parseProps -> runInit) never reads it back out.
+      # Filtered here, the single marshal boundary for bf-p, so it's
+      # excluded no matter how a `scope_id` key ends up in the props Hash
+      # (found via the bf-p semantic-comparison audit against the Hono
+      # reference adapter, which never emits it).
+      client_props = props.reject { |k, _| k.to_s == 'scope_id' }
+      return '' if client_props.empty?
+
       # The JSON must be attribute-escaped: a raw `'` inside a string value
       # (e.g. a blog paragraph) terminates the single-quoted attribute and
       # truncates the hydration payload. The browser entity-decodes the
       # attribute value, so the client's JSON.parse sees the original text.
-      json = html_escape(backend.encode_json(props))
+      json = html_escape(backend.encode_json(client_props))
       %( bf-p='#{json}')
     end
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/erb",
-  "version": "0.31.8",
+  "version": "0.31.10",
   "description": "ERB (Embedded Ruby) adapter for BarefootJS — compiles IR to .erb templates and ships the Ruby rendering backend; runs under any Rack app (Sinatra, Rails)",
   "type": "module",
   "main": "./dist/index.js",
@@ -54,7 +54,7 @@
     "directory": "packages/adapter-erb"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.31.8"
+    "@barefootjs/shared": "0.31.10"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0",
@@ -71,9 +71,9 @@
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/jsx": "0.31.8",
-    "@barefootjs/vite": "0.31.8",
-    "@barefootjs/client": "0.31.8",
+    "@barefootjs/jsx": "0.31.10",
+    "@barefootjs/vite": "0.31.10",
+    "@barefootjs/client": "0.31.10",
     "typescript": "^5.0.0",
     "vite": "^6.0.0"
   }

package/src/__tests__/erb-adapter.test.ts

@@ -479,11 +479,15 @@ export function TodoList(props: { initialTodos?: Todo[] }) {
     // as a thrown "ruby render failed" error, so a `NoMethodError` string
     // anywhere in a caught error would fail this test outright rather than
     // reaching these assertions. Post-fix: only the not-done todo (id 2)
-    // survives the 'active' filter.
-    expect(html).not.toContain('Eat breakfast')
-    expect(html).toContain('Write tests')
-    expect(html).toContain('data-key="2"')
-    expect(html).not.toContain('data-key="1"')
+    // survives the 'active' filter. The bf-p hydration payload legitimately
+    // carries the full unfiltered `initialTodos` (both quote styles,
+    // mirroring `normalizeHTML`), so the assertions target the rendered
+    // list only.
+    const rendered = html.replace(/\s*bf-p=(?:"[^"]*"|'[^']*')/g, '')
+    expect(rendered).not.toContain('Eat breakfast')
+    expect(rendered).toContain('Write tests')
+    expect(rendered).toContain('data-key="2"')
+    expect(rendered).not.toContain('data-key="1"')
   })
 })
 

package/src/test-render.ts

@@ -264,8 +264,13 @@ export async function renderErbComponent(options: RenderOptions): Promise<string
     // value domain is JSON-shaped symbol-keyed Hashes throughout, so
     // `JSON.parse(..., symbolize_names: true)` on the Ruby side is the
     // whole marshalling story; no hand-built Ruby literals.
-    const { obj: rootProps, needsSearchParams } = buildRubyProps(props, ir)
+    const { obj: rootProps, needsSearchParams, userProps } = buildRubyProps(props, ir)
     await Bun.write(resolve(tempDir, 'props.json'), JSON.stringify(rootProps))
+    // Separate from `props.json`: the caller-facing subset only (no
+    // scope_id / signal / memo bookkeeping) — what `bf._props(...)` below
+    // feeds `props_attr`'s bf-p payload, matching what a production
+    // Sinatra route handler passes, not this harness's internal vars hash.
+    await Bun.write(resolve(tempDir, 'user_props.json'), JSON.stringify(userProps))
 
     // Honour `__instanceId` from props for the root scope id so
     // shared-component fixtures (which pin `<ComponentName>_test`) match
@@ -310,6 +315,16 @@ bf = BarefootJS::Context.new(backend)
 bf._scope_id(${rootScopeId})
 
 props = JSON.parse(File.read(File.join(__dir__, 'props.json')), symbolize_names: true)
+# Mirrors production's \`props_attr\` contract (see barefoot_js.rb and
+# props_attr_test.rb): the caller is expected to seed \`_props\` before
+# rendering the root component, so this harness must call it explicitly.
+#
+# \`user_props.json\` — NOT \`props\` above — is what \`_props\` gets: \`props\`
+# is this harness's internal vars hash (scope_id, signal/memo seed
+# values), which a real Sinatra route handler never has and never passes.
+# Production's bf-p carries neither scope_id nor signal state, only the
+# caller-facing props.
+bf._props(JSON.parse(File.read(File.join(__dir__, 'user_props.json')), symbolize_names: true))
 ${needsSearchParams ? "# (#1922) Request-scoped searchParams() env signal: bind the reserved\n# `search_params` vars key to an empty-query reader. Only when the\n# component imports `searchParams`.\nprops[:search_params] = bf.search_params('')\n" : ''}
 ${childRenderers}
 html = backend.render_named(${rubyStringLiteral(toSnakeCase(componentName))}, bf, props)
@@ -491,12 +506,20 @@ function toSnakeCase(name: string): string {
 
 /**
  * Build the root props object (later JSON-serialised) + whether the
- * component imports `searchParams`.
+ * component imports `searchParams`, PLUS `userProps` — the exact raw
+ * fixture props (no defaults, no null-fill, no signal/memo seeding),
+ * mirroring production's route-handler call `bf._props(props)` verbatim.
+ * `obj` stays the full internal vars hash the compiled template renders
+ * against (local-var-keyed, defaulted, signal/memo-seeded); `userProps`
+ * is for `bf._props(...)` (bf-p hydration payload) only — these must NOT
+ * be the same object, and `userProps` must NOT be derived from `obj` or
+ * from the defaulted stash: production's own bf-p carries only what the
+ * caller actually passed in, unmodified.
  */
 function buildRubyProps(
   props: Record<string, unknown> | undefined,
   ir: ComponentIR,
-): { obj: Record<string, unknown>; needsSearchParams: boolean } {
+): { obj: Record<string, unknown>; needsSearchParams: boolean; userProps: Record<string, unknown> } {
   const obj: Record<string, unknown> = {}
 
   const explicitScope = typeof props?.__instanceId === 'string' ? props.__instanceId : 'test'
@@ -509,6 +532,10 @@ function buildRubyProps(
   // (`propName`, e.g. `n` for `{ n: count }`) is honoured, not just the
   // local template var name (#2524 SSR half). `props` is keyed by the
   // caller-facing name, exactly what `propName` resolves against.
+  //
+  // This defaulted/derived stash feeds ONLY `obj` (the template-rendering
+  // vars hash) below — never `userProps` (the bf-p payload), which is
+  // built separately, straight off the raw `props` argument.
   const rootSsrDefaults = extractSsrDefaults(ir.metadata) ?? {}
   const derivedProps = deriveStashFromDefaults(rootSsrDefaults, props ?? {})
   for (const param of ir.metadata.propsParams) {
@@ -558,11 +585,36 @@ function buildRubyProps(
     }
   }
 
+  // `bf._props(...)` payload (bf-p hydration): mirrors production's
+  // route-handler call `bf._props(props)` verbatim — the caller's raw
+  // props dict, unmodified. No default-filling, no signal/memo seeding,
+  // no rest-bag nesting: a real Sinatra/Rack handler never rearranges
+  // the dict it received before handing it to `_props`. Excludes
+  // internal harness-only keys (`__instanceId` etc.), which are never a
+  // real caller-facing prop.
+  const userProps: Record<string, unknown> = {}
+  if (props) {
+    for (const [key, value] of Object.entries(props)) {
+      if (key.startsWith('__')) continue
+      userProps[key] = value
+    }
+  }
+
   // Signal values evaluated from props (after user props).
   for (const signal of ir.metadata.signals) {
     // Env signals (#2057 / #1922) are bound below via `search_params('')`,
     // not from a static initial value.
     if (signal.envReader) continue
+    // #2669: a self-derivation collision (the signal's own initializer
+    // derives from a same-named prop, e.g. `createSignal(props.label ??
+    // 'Default')`) already got the correct RAW-prop seed above via
+    // `derivedProps` / `obj[param.name]` — `extractSsrDefaults` marks that
+    // with a `propName`-carrying entry (see its docstring's invariant).
+    // Re-seeding here with this harness's OWN recompute
+    // (`evaluateSignalInit`) would clobber the correctly-derived caller
+    // value with the harness's evaluated-from-static-props number, papering
+    // over the exact production bug this fixture exists to catch.
+    if (rootSsrDefaults[signal.getter]?.propName !== undefined) continue
     const value = evaluateSignalInit(signal.initialValue.trim(), props)
     if (value !== null) {
       obj[signal.getter] = value
@@ -572,11 +624,17 @@ function buildRubyProps(
   // Memo values seeded from the statically-evaluated ssrDefaults, same
   // as the production plugin's before_render hook.
   for (const memo of ir.metadata.memos) {
+    // #2669: same self-derivation skip as the signal loop above — a
+    // `propName`-carrying memo entry already stands as the correctly
+    // prop-derived seed; don't clobber it with the memo's OWN evaluated
+    // value (which for a non-idempotent derivation is already the WRONG,
+    // double-applied number).
+    if (rootSsrDefaults[memo.name]?.propName !== undefined) continue
     obj[memo.name] = rootSsrDefaults[memo.name]?.value ?? 0
   }
 
   const needsSearchParams = importsSearchParams(ir.metadata)
 
-  return { obj, needsSearchParams }
+  return { obj, needsSearchParams, userProps }
 }