@barefootjs/jsx 0.19.1 → 0.21.0

package/dist/index.js

@@ -5302,6 +5302,135 @@ function internalInvariant(cond, message) {
   }
 }
 
+// src/rich-type-evidence.ts
+var HOST_RICH_TYPE_NAMES = new Set([
+  "Date",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "URL",
+  "URLSearchParams",
+  "RegExp",
+  "Promise",
+  "Error",
+  "Symbol",
+  "BigInt",
+  "Function"
+]);
+function baseTypeName(raw) {
+  const idx = raw.indexOf("<");
+  return (idx === -1 ? raw : raw.slice(0, idx)).trim();
+}
+function isNullishArm(t) {
+  if (t.kind === "primitive" && (t.primitive === "null" || t.primitive === "undefined"))
+    return true;
+  return t.kind === "unknown" && (t.raw === "null" || t.raw === "undefined");
+}
+function stripUnion(type) {
+  if (!type || type.kind !== "union" || !type.unionTypes)
+    return type;
+  const nonNullish = type.unionTypes.filter((t) => !isNullishArm(t));
+  return nonNullish.length === 1 ? stripUnion(nonNullish[0]) : type;
+}
+function derefNamedType(type, meta) {
+  if (type.kind !== "interface")
+    return type;
+  if (type.properties && type.properties.length > 0)
+    return type;
+  const name = baseTypeName(type.raw);
+  const def = meta.typeDefinitions.find((d) => d.name === name);
+  if (!def?.properties)
+    return type;
+  return { ...type, properties: def.properties };
+}
+function lookupProperty(objType, propName, meta) {
+  const stripped = stripUnion(objType);
+  if (!stripped)
+    return null;
+  const deref = derefNamedType(stripped, meta);
+  const prop = deref.properties?.find((p) => p.name === propName);
+  return prop ? stripUnion(prop.type) : null;
+}
+function resolveReceiverType(expr, meta, bindings) {
+  if (expr.kind === "identifier") {
+    if (bindings.has(expr.name))
+      return stripUnion(bindings.get(expr.name) ?? null);
+    if (meta.propsObjectName !== null) {
+      return expr.name === meta.propsObjectName ? stripUnion(meta.propsType) : null;
+    }
+    const param = meta.propsParams.find((p) => p.name === expr.name && !p.isRest);
+    if (!param)
+      return null;
+    return lookupProperty(meta.propsType, param.sourceName ?? param.name, meta);
+  }
+  if (expr.kind === "member" && !expr.computed) {
+    const objType = resolveReceiverType(expr.object, meta, bindings);
+    return lookupProperty(objType, expr.property, meta);
+  }
+  return null;
+}
+
+// src/date-lowering.ts
+var CATALOGUED_RICH_TYPE_NAMES = new Set(["Date"]);
+var DATE_METHODS = new Set([
+  "getUTCFullYear",
+  "getUTCMonth",
+  "getUTCDate",
+  "getUTCHours",
+  "getUTCMinutes",
+  "getUTCSeconds",
+  "getTime",
+  "toISOString"
+]);
+var EMPTY_BINDINGS = new Map;
+function typeReachesDate(type, meta, seen) {
+  const stripped = stripUnion(type);
+  if (!stripped)
+    return false;
+  if (stripped.kind === "interface") {
+    const name = baseTypeName(stripped.raw);
+    if (name === "Date")
+      return true;
+    if (seen.has(name))
+      return false;
+    seen.add(name);
+  } else if (stripped.kind !== "object") {
+    return false;
+  }
+  const deref = derefNamedType(stripped, meta);
+  if (!deref.properties)
+    return false;
+  return deref.properties.some((p) => typeReachesDate(p.type, meta, seen));
+}
+function matchDateCall(callee, args, metadata) {
+  if (callee.kind !== "member" || callee.computed)
+    return null;
+  if (args.length !== 0 || !DATE_METHODS.has(callee.property))
+    return null;
+  const receiverType = resolveReceiverType(callee.object, metadata, EMPTY_BINDINGS);
+  if (!receiverType || receiverType.kind !== "interface")
+    return null;
+  const typeName = baseTypeName(receiverType.raw);
+  if (typeName !== "Date")
+    return null;
+  if (metadata.typeDefinitions.some((d) => d.name === typeName))
+    return null;
+  return {
+    kind: "helper-call",
+    helper: "date",
+    args: [callee.object, { kind: "literal", value: callee.property, literalType: "string" }]
+  };
+}
+var datePlugin = {
+  name: "date",
+  prepare(metadata) {
+    if (!metadata.propsType || !typeReachesDate(metadata.propsType, metadata, new Set))
+      return null;
+    return (callee, args) => matchDateCall(callee, args, metadata);
+  }
+};
+
 // src/analyzer.ts
 var { default: fs} = (() => ({}));
 var REACTIVE_BRAND_PACKAGES = [
@@ -7090,7 +7219,8 @@ function extractProps(param, ctx) {
           type: resolvedType,
           optional: !!member?.optional || !!element.initializer,
           defaultValue,
-          defaultContainsArrow: defaultContainsArrow || undefined
+          defaultContainsArrow: defaultContainsArrow || undefined,
+          ...sourcePropName !== localName && { sourceName: sourcePropName }
         });
       }
     }
@@ -7149,7 +7279,7 @@ function collectKeysFromMembers(members, ctx) {
   return keys;
 }
 function collectMemberTypes(typeNode, ctx) {
-  const isResolvablePrimitive = (info) => info.kind === "primitive" && (info.primitive === "string" || info.primitive === "number" || info.primitive === "boolean");
+  const isResolvablePrimitive = (info) => info.kind === "primitive" && (info.primitive === "string" || info.primitive === "number" || info.primitive === "boolean") || info.kind === "interface" && CATALOGUED_RICH_TYPE_NAMES.has(baseTypeName(info.raw));
   const fromMembers = (members) => {
     const map = new Map;
     for (const member of members) {
@@ -8386,18 +8516,60 @@ function exprHasFunctionCalls(expr) {
   visit2(expr);
   return found;
 }
+function getDateLoweringMatcher(ctx) {
+  if (ctx._dateLoweringMatcher === undefined) {
+    const a = ctx.analyzer;
+    const metadataSlice = {
+      propsType: a.propsType,
+      propsObjectName: a.propsObjectName,
+      propsParams: a.propsParams,
+      typeDefinitions: a.typeDefinitions
+    };
+    ctx._dateLoweringMatcher = datePlugin.prepare(metadataSlice);
+  }
+  return ctx._dateLoweringMatcher;
+}
+function lowerDateCalls(text, expr, ctx) {
+  const matcher = getDateLoweringMatcher(ctx);
+  if (!matcher)
+    return text;
+  const candidates = [];
+  function visit2(n) {
+    if (ts11.isCallExpression(n) && n.arguments.length === 0 && ts11.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && DATE_METHODS.has(n.expression.name.text)) {
+      candidates.push(n);
+    }
+    ts11.forEachChild(n, visit2);
+  }
+  visit2(expr);
+  if (candidates.length === 0)
+    return text;
+  const { protect, restore } = createTemplateAwareStringProtector();
+  let result = protect(text);
+  for (const call of candidates) {
+    const propAccess = call.expression;
+    const node = matcher(tsNodeToParsedExpr(propAccess), []);
+    if (!node || node.kind !== "helper-call" || node.helper !== "date")
+      continue;
+    const op = propAccess.name.text;
+    const receiverText = ctx.getJS(propAccess.expression);
+    const matchText = ctx.getJS(call);
+    result = result.replace(matchText, () => `date(${receiverText}, "${op}")`);
+  }
+  return restore(result);
+}
 function rewriteBarePropRefs2(text, expr, ctx) {
+  const dateLowered = lowerDateCalls(text, expr, ctx);
   let propNames = getDestructuredPropNames(ctx);
   if (!propNames)
-    return;
+    return dateLowered === text ? undefined : dateLowered;
   if (ctx.loopParams.size > 0) {
     const filtered = new Set([...propNames].filter((n) => !ctx.loopParams.has(n)));
     if (filtered.size === 0)
-      return;
+      return dateLowered === text ? undefined : dateLowered;
     propNames = filtered;
   }
   const extraPropRefs = collectBranchLocalPropRefsViaSubstitution(expr, ctx);
-  return rewriteBarePropRefs(text, expr, propNames, extraPropRefs);
+  return rewriteBarePropRefs(dateLowered, expr, propNames, extraPropRefs);
 }
 function collectBranchLocalPropRefsViaSubstitution(node, ctx) {
   const propDepsMap = ctx._branchScopePropDeps;
@@ -11829,7 +12001,8 @@ function collectLoopChildReactiveTexts(node, ctx, loopParam, loopParamBindings)
         return;
       const originFreeIds = freeIdsFromRefs(n.origin?.freeRefs);
       const expanded = expandConstantForReactivity(n.expr, ctx, originFreeIds);
-      if (classifyReactivity(expanded.expr, ctx, loopParam, loopParamBindings, expanded.freeIds).kind === "none")
+      const reactive = classifyReactivity(expanded.expr, ctx, loopParam, loopParamBindings, expanded.freeIds).kind !== "none" || decideWrapFromAstFlags(n).wrap;
+      if (!reactive)
         return;
       texts.push({
         slotId: n.slotId,
@@ -13230,7 +13403,8 @@ var RUNTIME_IMPORT_CANDIDATES = [
   "__bfText",
   "tAfter",
   "beginTurn",
-  "endTurn"
+  "endTurn",
+  "date"
 ];
 var RUNTIME_MODULE = "@barefootjs/client/runtime";
 var IMPORT_PLACEHOLDER = "/* __BAREFOOTJS_DOM_IMPORTS__ */";
@@ -16325,6 +16499,7 @@ function buildArmBody(branch, options) {
 }
 
 // src/ir-to-client-js/emit-reactive.ts
+import ts14 from "typescript";
 function bindingIdArg(ctx, slotId) {
   if (!ctx.profile || !slotId)
     return "";
@@ -16384,7 +16559,56 @@ function rewriteDestructuredPropsInExpr(expr, ctx) {
   }
   return restore(result);
 }
+function getReactiveDateLoweringMatcher(ctx) {
+  if (!ctx.propsType)
+    return null;
+  const metadataSlice = {
+    propsType: ctx.propsType,
+    propsObjectName: ctx.propsObjectName,
+    propsParams: ctx.propsParams,
+    typeDefinitions: ctx.typeDefinitions ?? []
+  };
+  return datePlugin.prepare(metadataSlice);
+}
+function lowerDateCallsInReactiveExpr(expr, matcher) {
+  if (!matcher)
+    return expr;
+  let sourceFile;
+  try {
+    sourceFile = ts14.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts14.ScriptTarget.Latest, true, ts14.ScriptKind.TS);
+  } catch {
+    return expr;
+  }
+  const stmt = sourceFile.statements[0];
+  if (!stmt || !ts14.isExpressionStatement(stmt))
+    return expr;
+  const root = ts14.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  const candidates = [];
+  const visit3 = (n) => {
+    if (ts14.isCallExpression(n) && n.arguments.length === 0 && ts14.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && DATE_METHODS.has(n.expression.name.text)) {
+      candidates.push(n);
+    }
+    ts14.forEachChild(n, visit3);
+  };
+  visit3(root);
+  if (candidates.length === 0)
+    return expr;
+  const { protect, restore } = createTemplateAwareStringProtector();
+  let result = protect(expr);
+  for (const call of candidates) {
+    const propAccess = call.expression;
+    const node = matcher(tsNodeToParsedExpr(propAccess), []);
+    if (!node || node.kind !== "helper-call" || node.helper !== "date")
+      continue;
+    const op = propAccess.name.text;
+    const receiverText = propAccess.expression.getText(sourceFile);
+    const matchText = call.getText(sourceFile);
+    result = result.replace(matchText, () => `date(${receiverText}, "${op}")`);
+  }
+  return restore(result);
+}
 function emitDynamicTextUpdates(lines, ctx) {
+  const dateLoweringMatcher = getReactiveDateLoweringMatcher(ctx);
   const byExpression = new Map;
   for (const elem of ctx.dynamicElements) {
     const key = elem.expression;
@@ -16393,7 +16617,8 @@ function emitDynamicTextUpdates(lines, ctx) {
     }
     byExpression.get(key).push(elem);
   }
-  for (const [expr, elems] of byExpression) {
+  for (const [rawExpr, elems] of byExpression) {
+    const expr = lowerDateCallsInReactiveExpr(rawExpr, dateLoweringMatcher);
     const conditionalElems = elems.filter((e) => e.insideConditional);
     const normalElems = elems.filter((e) => !e.insideConditional);
     if (normalElems.length > 0 || conditionalElems.length > 0) {
@@ -17893,20 +18118,20 @@ var PHASES = [
 ];
 
 // src/ir-to-client-js/rewrite-props-object.ts
-import ts14 from "typescript";
+import ts15 from "typescript";
 function rewritePropsObjectRef(code, propsObjectName) {
   const srcPropsName = propsObjectName ?? "props";
   if (srcPropsName === PROPS_PARAM)
     return code;
   if (!new RegExp(`\\b${srcPropsName}\\b`).test(code))
     return code;
-  const sourceFile = ts14.createSourceFile("init-body.ts", code, ts14.ScriptTarget.Latest, true, ts14.ScriptKind.TS);
+  const sourceFile = ts15.createSourceFile("init-body.ts", code, ts15.ScriptTarget.Latest, true, ts15.ScriptKind.TS);
   const spans = [];
   function visit3(node) {
-    if (ts14.isIdentifier(node) && node.text === srcPropsName && shouldRewrite(node)) {
+    if (ts15.isIdentifier(node) && node.text === srcPropsName && shouldRewrite(node)) {
       spans.push([node.getStart(sourceFile), node.getEnd()]);
     }
-    ts14.forEachChild(node, visit3);
+    ts15.forEachChild(node, visit3);
   }
   visit3(sourceFile);
   if (spans.length === 0)
@@ -17922,17 +18147,17 @@ function shouldRewrite(node) {
   const parent = node.parent;
   if (!parent)
     return true;
-  if (ts14.isPropertyAccessExpression(parent) && parent.name === node)
+  if (ts15.isPropertyAccessExpression(parent) && parent.name === node)
     return false;
-  if (ts14.isPropertyAssignment(parent) && parent.name === node)
+  if (ts15.isPropertyAssignment(parent) && parent.name === node)
     return false;
-  if (ts14.isShorthandPropertyAssignment(parent) && parent.name === node)
+  if (ts15.isShorthandPropertyAssignment(parent) && parent.name === node)
     return false;
-  if (ts14.isPropertySignature(parent) && parent.name === node)
+  if (ts15.isPropertySignature(parent) && parent.name === node)
     return false;
-  if (ts14.isPropertyDeclaration(parent) && parent.name === node)
+  if (ts15.isPropertyDeclaration(parent) && parent.name === node)
     return false;
-  if (ts14.isBindingElement(parent) && parent.name === node)
+  if (ts15.isBindingElement(parent) && parent.name === node)
     return false;
   return true;
 }
@@ -17969,9 +18194,10 @@ function generateInitFunction(ir, ctx, siblingComponents, localImportPrefixes) {
 `), ctx.propsObjectName);
   generatedCode += `
 ` + hydrateLine;
-  const allImportLines = resolveFinalImports(generatedCode, ir, localImportPrefixes);
   const moduleConstantsCode = emitModuleLevelDeclarations(classification.moduleLevelConstants, classification.moduleLevelFunctions, classification.moduleLevelSignals, classification.moduleLevelMemos);
-  return generatedCode.replace(IMPORT_PLACEHOLDER, allImportLines).replace(MODULE_CONSTANTS_PLACEHOLDER, moduleConstantsCode);
+  const codeWithModuleConstants = generatedCode.replace(MODULE_CONSTANTS_PLACEHOLDER, () => moduleConstantsCode);
+  const allImportLines = resolveFinalImports(codeWithModuleConstants, ir, localImportPrefixes);
+  return codeWithModuleConstants.replace(IMPORT_PLACEHOLDER, () => allImportLines);
 }
 
 // src/ir-to-client-js/source-map.ts
@@ -18219,6 +18445,8 @@ function createContext(ir, scope, adapterCapabilities, profile) {
     propsParams: ir.metadata.propsParams,
     propsObjectName: ir.metadata.propsObjectName,
     restPropsName: ir.metadata.restPropsName,
+    propsType: ir.metadata.propsType,
+    typeDefinitions: ir.metadata.typeDefinitions,
     interactiveElements: [],
     dynamicElements: [],
     conditionalElements: [],
@@ -18454,7 +18682,7 @@ function walkIR2(node, visitor) {
 }
 
 // src/preprocess-inline-jsx-callbacks.ts
-import ts15 from "typescript";
+import ts16 from "typescript";
 var SYNTHETIC_PREFIX = "BFInlineJsxCallback";
 var MAX_FIXPOINT_ITERATIONS = 16;
 function preprocessInlineJsxCallbacks(source, filePath) {
@@ -18476,8 +18704,8 @@ function preprocessInlineJsxCallbacks(source, filePath) {
   return { source: current, errors, syntheticNames };
 }
 function runSinglePass(source, filePath, startingCounter) {
-  const sourceFile = ts15.createSourceFile(filePath, source, ts15.ScriptTarget.Latest, true, ts15.ScriptKind.TSX);
-  const hasUseClient = sourceFile.statements.some((stmt) => ts15.isExpressionStatement(stmt) && ts15.isStringLiteral(stmt.expression) && (stmt.expression.text === "use client" || stmt.expression.text === "'use client'"));
+  const sourceFile = ts16.createSourceFile(filePath, source, ts16.ScriptTarget.Latest, true, ts16.ScriptKind.TSX);
+  const hasUseClient = sourceFile.statements.some((stmt) => ts16.isExpressionStatement(stmt) && ts16.isStringLiteral(stmt.expression) && (stmt.expression.text === "use client" || stmt.expression.text === "'use client'"));
   if (!hasUseClient) {
     return { source, errors: [], syntheticNames: [], counterAfter: startingCounter };
   }
@@ -18499,22 +18727,22 @@ function runSinglePass(source, filePath, startingCounter) {
     }
   }
   function visit3(node) {
-    if (ts15.isJsxAttribute(node) && node.initializer && ts15.isJsxExpression(node.initializer) && node.initializer.expression) {
+    if (ts16.isJsxAttribute(node) && node.initializer && ts16.isJsxExpression(node.initializer) && node.initializer.expression) {
       if (tryHandleArrowValue(node.initializer.expression)) {
         return;
       }
     }
-    if (ts15.isPropertyAssignment(node) && node.initializer) {
+    if (ts16.isPropertyAssignment(node) && node.initializer) {
       if (tryHandleArrowValue(node.initializer))
         return;
     }
-    ts15.forEachChild(node, visit3);
+    ts16.forEachChild(node, visit3);
   }
   function tryHandleArrowValue(initializer) {
     let expr = initializer;
-    while (ts15.isParenthesizedExpression(expr))
+    while (ts16.isParenthesizedExpression(expr))
       expr = expr.expression;
-    if (ts15.isArrowFunction(expr) && arrowBodyContainsJsx(expr)) {
+    if (ts16.isArrowFunction(expr) && arrowBodyContainsJsx(expr)) {
       return handleInlineArrow(expr);
     }
     return false;
@@ -18551,7 +18779,7 @@ function runSinglePass(source, filePath, startingCounter) {
     replacements.push({ start: arrowStart, end: arrowEnd, text: name });
     return true;
   }
-  ts15.forEachChild(sourceFile, visit3);
+  ts16.forEachChild(sourceFile, visit3);
   if (replacements.length === 0) {
     return { source, errors, syntheticNames, counterAfter: counter };
   }
@@ -18574,11 +18802,11 @@ function errorMessageForCapture(captures) {
   return `Inline JSX-returning arrow function captures non-module identifier(s): ` + `${captures.sort().join(", ")}. ` + `Extract the callback into a top-level '\\'use client\\'' component (e.g. ` + `\`function MyNode(n) { return <div/> }\` then \`renderNode={MyNode}\`) ` + `or pass captured values via component props.`;
 }
 function arrowBodyContainsJsx(arrow) {
-  if (ts15.isBlock(arrow.body)) {
+  if (ts16.isBlock(arrow.body)) {
     return blockReturnsJsx(arrow.body);
   }
   let body = arrow.body;
-  while (ts15.isParenthesizedExpression(body))
+  while (ts16.isParenthesizedExpression(body))
     body = body.expression;
   return isJsxLike(body);
 }
@@ -18587,24 +18815,24 @@ function blockReturnsJsx(block) {
   function visit3(n) {
     if (found)
       return;
-    if (ts15.isReturnStatement(n) && n.expression) {
+    if (ts16.isReturnStatement(n) && n.expression) {
       let e = n.expression;
-      while (ts15.isParenthesizedExpression(e))
+      while (ts16.isParenthesizedExpression(e))
         e = e.expression;
       if (isJsxLike(e)) {
         found = true;
         return;
       }
     }
-    if (ts15.isArrowFunction(n) || ts15.isFunctionDeclaration(n) || ts15.isFunctionExpression(n))
+    if (ts16.isArrowFunction(n) || ts16.isFunctionDeclaration(n) || ts16.isFunctionExpression(n))
       return;
-    ts15.forEachChild(n, visit3);
+    ts16.forEachChild(n, visit3);
   }
-  ts15.forEachChild(block, visit3);
+  ts16.forEachChild(block, visit3);
   return found;
 }
 function isJsxLike(expr) {
-  return ts15.isJsxElement(expr) || ts15.isJsxSelfClosingElement(expr) || ts15.isJsxFragment(expr);
+  return ts16.isJsxElement(expr) || ts16.isJsxSelfClosingElement(expr) || ts16.isJsxFragment(expr);
 }
 function collectArrowParamNames(arrow) {
   const names = new Set;
@@ -18614,13 +18842,13 @@ function collectArrowParamNames(arrow) {
 }
 function collectBindingNames(name, out) {
   const push = Array.isArray(out) ? (n) => out.push(n) : (n) => out.add(n);
-  if (ts15.isIdentifier(name)) {
+  if (ts16.isIdentifier(name)) {
     push(name.text);
-  } else if (ts15.isObjectBindingPattern(name)) {
+  } else if (ts16.isObjectBindingPattern(name)) {
     name.elements.forEach((el) => collectBindingNames(el.name, out));
-  } else if (ts15.isArrayBindingPattern(name)) {
+  } else if (ts16.isArrayBindingPattern(name)) {
     name.elements.forEach((el) => {
-      if (!ts15.isOmittedExpression(el))
+      if (!ts16.isOmittedExpression(el))
         collectBindingNames(el.name, out);
     });
   }
@@ -18647,48 +18875,48 @@ function collectFreeIdentifiers(arrow) {
     return bound.includes(name);
   }
   function visit3(node) {
-    if (ts15.isIdentifier(node)) {
+    if (ts16.isIdentifier(node)) {
       const parent = node.parent;
-      if (parent && ts15.isPropertyAccessExpression(parent) && parent.name === node)
+      if (parent && ts16.isPropertyAccessExpression(parent) && parent.name === node)
         return;
-      if (parent && ts15.isPropertyAssignment(parent) && parent.name === node)
+      if (parent && ts16.isPropertyAssignment(parent) && parent.name === node)
         return;
-      if (parent && ts15.isPropertySignature(parent) && parent.name === node)
+      if (parent && ts16.isPropertySignature(parent) && parent.name === node)
         return;
-      if (parent && ts15.isPropertyDeclaration(parent) && parent.name === node)
+      if (parent && ts16.isPropertyDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts15.isMethodDeclaration(parent) && parent.name === node)
+      if (parent && ts16.isMethodDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts15.isMethodSignature(parent) && parent.name === node)
+      if (parent && ts16.isMethodSignature(parent) && parent.name === node)
         return;
-      if (parent && ts15.isGetAccessorDeclaration(parent) && parent.name === node)
+      if (parent && ts16.isGetAccessorDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts15.isSetAccessorDeclaration(parent) && parent.name === node)
+      if (parent && ts16.isSetAccessorDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts15.isEnumMember(parent) && parent.name === node)
+      if (parent && ts16.isEnumMember(parent) && parent.name === node)
         return;
-      if (parent && ts15.isBindingElement(parent) && parent.propertyName === node)
+      if (parent && ts16.isBindingElement(parent) && parent.propertyName === node)
         return;
-      if (parent && ts15.isShorthandPropertyAssignment(parent) && parent.name === node) {
+      if (parent && ts16.isShorthandPropertyAssignment(parent) && parent.name === node) {
         if (!isBound(node.text))
           ids.add(node.text);
         return;
       }
-      if (parent && ts15.isParameter(parent) && parent.name === node)
+      if (parent && ts16.isParameter(parent) && parent.name === node)
         return;
-      if (parent && ts15.isVariableDeclaration(parent) && parent.name === node)
+      if (parent && ts16.isVariableDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts15.isFunctionDeclaration(parent) && parent.name === node)
+      if (parent && ts16.isFunctionDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts15.isClassDeclaration(parent) && parent.name === node)
+      if (parent && ts16.isClassDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts15.isJsxAttribute(parent) && parent.name === node)
+      if (parent && ts16.isJsxAttribute(parent) && parent.name === node)
         return;
-      if (parent && ts15.isJsxOpeningElement(parent) && parent.tagName === node) {
+      if (parent && ts16.isJsxOpeningElement(parent) && parent.tagName === node) {
         if (/^[a-z]/.test(node.text))
           return;
       }
-      if (parent && ts15.isJsxClosingElement(parent) && parent.tagName === node) {
+      if (parent && ts16.isJsxClosingElement(parent) && parent.tagName === node) {
         if (/^[a-z]/.test(node.text))
           return;
       }
@@ -18697,43 +18925,43 @@ function collectFreeIdentifiers(arrow) {
       ids.add(node.text);
       return;
     }
-    if (ts15.isVariableDeclaration(node)) {
+    if (ts16.isVariableDeclaration(node)) {
       const declared = pushBindings(node.name);
       if (node.initializer)
         visit3(node.initializer);
       return;
     }
-    if (ts15.isFunctionDeclaration(node)) {
+    if (ts16.isFunctionDeclaration(node)) {
       if (node.name)
         bound.push(node.name.text);
       visitInsideNewScope(node);
       return;
     }
-    if (ts15.isClassDeclaration(node)) {
+    if (ts16.isClassDeclaration(node)) {
       if (node.name)
         bound.push(node.name.text);
-      ts15.forEachChild(node, visit3);
+      ts16.forEachChild(node, visit3);
       return;
     }
-    if (ts15.isArrowFunction(node) || ts15.isFunctionExpression(node)) {
+    if (ts16.isArrowFunction(node) || ts16.isFunctionExpression(node)) {
       visitInsideNewScope(node);
       return;
     }
-    if (ts15.isCatchClause(node)) {
+    if (ts16.isCatchClause(node)) {
       const before = bound.length;
       if (node.variableDeclaration)
         pushBindings(node.variableDeclaration.name);
-      ts15.forEachChild(node, visit3);
+      ts16.forEachChild(node, visit3);
       popN(bound.length - before);
       return;
     }
-    if (ts15.isBlock(node)) {
+    if (ts16.isBlock(node)) {
       const before = bound.length;
-      ts15.forEachChild(node, visit3);
+      ts16.forEachChild(node, visit3);
       popN(bound.length - before);
       return;
     }
-    ts15.forEachChild(node, visit3);
+    ts16.forEachChild(node, visit3);
   }
   function visitInsideNewScope(fn) {
     const before = bound.length;
@@ -18756,29 +18984,29 @@ function collectFreeIdentifiers(arrow) {
 function collectModuleScopeNames(sourceFile) {
   const names = new Set;
   for (const stmt of sourceFile.statements) {
-    if (ts15.isFunctionDeclaration(stmt) && stmt.name)
+    if (ts16.isFunctionDeclaration(stmt) && stmt.name)
       names.add(stmt.name.text);
-    else if (ts15.isClassDeclaration(stmt) && stmt.name)
+    else if (ts16.isClassDeclaration(stmt) && stmt.name)
       names.add(stmt.name.text);
-    else if (ts15.isVariableStatement(stmt)) {
+    else if (ts16.isVariableStatement(stmt)) {
       for (const decl of stmt.declarationList.declarations)
         collectBindingNames(decl.name, names);
-    } else if (ts15.isImportDeclaration(stmt) && stmt.importClause) {
+    } else if (ts16.isImportDeclaration(stmt) && stmt.importClause) {
       const ic = stmt.importClause;
       if (ic.name)
         names.add(ic.name.text);
       if (ic.namedBindings) {
-        if (ts15.isNamespaceImport(ic.namedBindings))
+        if (ts16.isNamespaceImport(ic.namedBindings))
           names.add(ic.namedBindings.name.text);
         else
           for (const e of ic.namedBindings.elements)
             names.add(e.name.text);
       }
-    } else if (ts15.isTypeAliasDeclaration(stmt))
+    } else if (ts16.isTypeAliasDeclaration(stmt))
       names.add(stmt.name.text);
-    else if (ts15.isInterfaceDeclaration(stmt))
+    else if (ts16.isInterfaceDeclaration(stmt))
       names.add(stmt.name.text);
-    else if (ts15.isEnumDeclaration(stmt))
+    else if (ts16.isEnumDeclaration(stmt))
       names.add(stmt.name.text);
   }
   return names;
@@ -18786,7 +19014,7 @@ function collectModuleScopeNames(sourceFile) {
 function buildSyntheticDeclaration(name, arrow, sourceFile) {
   const paramsText = arrow.parameters.length === 0 ? "" : arrow.parameters.map((p) => p.getText(sourceFile)).join(", ");
   let bodyText;
-  if (ts15.isBlock(arrow.body)) {
+  if (ts16.isBlock(arrow.body)) {
     bodyText = arrow.body.getText(sourceFile);
   } else {
     const expr = arrow.body.getText(sourceFile);
@@ -18796,7 +19024,7 @@ function buildSyntheticDeclaration(name, arrow, sourceFile) {
 }
 
 // src/ssr-defaults.ts
-import ts16 from "typescript";
+import ts17 from "typescript";
 var UNRESOLVED = Symbol("unresolved");
 var NO_RETURN = Symbol("no-return");
 function extractSsrDefaults(metadata) {
@@ -18872,11 +19100,11 @@ function collectPropRefs(expr, propsObjectName, out) {
   if (!node)
     return;
   const visit3 = (n) => {
-    if (ts16.isPropertyAccessExpression(n) && ts16.isIdentifier(n.expression) && n.expression.text === propsObjectName && ts16.isIdentifier(n.name)) {
+    if (ts17.isPropertyAccessExpression(n) && ts17.isIdentifier(n.expression) && n.expression.text === propsObjectName && ts17.isIdentifier(n.name)) {
       out.add(n.name.text);
       return;
     }
-    ts16.forEachChild(n, visit3);
+    ts17.forEachChild(n, visit3);
   };
   visit3(node);
 }
@@ -18897,23 +19125,23 @@ function tryStaticEval(expr, ctx) {
 }
 function evalStatementsForReturn(statements, ctx) {
   for (const stmt of statements) {
-    if (ts16.isVariableStatement(stmt)) {
+    if (ts17.isVariableStatement(stmt)) {
       for (const d of stmt.declarationList.declarations) {
-        if (!ts16.isIdentifier(d.name) || !d.initializer)
+        if (!ts17.isIdentifier(d.name) || !d.initializer)
           continue;
         const v = evalNode(d.initializer, ctx);
         if (v !== UNRESOLVED)
           ctx.bindings[d.name.text] = v;
       }
-    } else if (ts16.isReturnStatement(stmt)) {
+    } else if (ts17.isReturnStatement(stmt)) {
       return stmt.expression ? evalNode(stmt.expression, ctx) : UNRESOLVED;
-    } else if (ts16.isIfStatement(stmt)) {
+    } else if (ts17.isIfStatement(stmt)) {
       const cond = evalNode(stmt.expression, ctx);
       if (cond === UNRESOLVED)
         return UNRESOLVED;
       const branch = cond ? stmt.thenStatement : stmt.elseStatement;
       if (branch) {
-        const taken = evalStatementsForReturn(ts16.isBlock(branch) ? branch.statements : [branch], ctx);
+        const taken = evalStatementsForReturn(ts17.isBlock(branch) ? branch.statements : [branch], ctx);
         if (taken !== NO_RETURN)
           return taken;
       }
@@ -18924,45 +19152,45 @@ function evalStatementsForReturn(statements, ctx) {
   return NO_RETURN;
 }
 function parseExpression2(expr) {
-  const sf = ts16.createSourceFile("__ssr_default__.ts", `(${expr})`, ts16.ScriptTarget.Latest, false, ts16.ScriptKind.TS);
+  const sf = ts17.createSourceFile("__ssr_default__.ts", `(${expr})`, ts17.ScriptTarget.Latest, false, ts17.ScriptKind.TS);
   const stmt = sf.statements[0];
-  if (!stmt || !ts16.isExpressionStatement(stmt))
+  if (!stmt || !ts17.isExpressionStatement(stmt))
     return null;
-  const inner = ts16.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  const inner = ts17.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
   return inner;
 }
 function evalNode(node, ctx) {
-  if (ts16.isParenthesizedExpression(node))
+  if (ts17.isParenthesizedExpression(node))
     return evalNode(node.expression, ctx);
-  if (ts16.isAsExpression(node))
+  if (ts17.isAsExpression(node))
     return evalNode(node.expression, ctx);
-  if (ts16.isSatisfiesExpression(node))
+  if (ts17.isSatisfiesExpression(node))
     return evalNode(node.expression, ctx);
-  if (ts16.isTypeAssertionExpression(node))
+  if (ts17.isTypeAssertionExpression(node))
     return evalNode(node.expression, ctx);
-  if (ts16.isNonNullExpression(node))
+  if (ts17.isNonNullExpression(node))
     return evalNode(node.expression, ctx);
-  if (ts16.isArrowFunction(node)) {
+  if (ts17.isArrowFunction(node)) {
     if (node.parameters.length !== 0)
       return UNRESOLVED;
-    if (!ts16.isBlock(node.body))
+    if (!ts17.isBlock(node.body))
       return evalNode(node.body, ctx);
     const localBindings = { ...ctx.bindings };
     const localCtx = { ...ctx, bindings: localBindings };
     const result = evalStatementsForReturn(node.body.statements, localCtx);
     return result === NO_RETURN ? UNRESOLVED : result;
   }
-  if (ts16.isNumericLiteral(node))
+  if (ts17.isNumericLiteral(node))
     return Number(node.text);
-  if (ts16.isStringLiteralLike(node))
+  if (ts17.isStringLiteralLike(node))
     return node.text;
-  if (node.kind === ts16.SyntaxKind.TrueKeyword)
+  if (node.kind === ts17.SyntaxKind.TrueKeyword)
     return true;
-  if (node.kind === ts16.SyntaxKind.FalseKeyword)
+  if (node.kind === ts17.SyntaxKind.FalseKeyword)
     return false;
-  if (node.kind === ts16.SyntaxKind.NullKeyword)
+  if (node.kind === ts17.SyntaxKind.NullKeyword)
     return null;
-  if (ts16.isIdentifier(node)) {
+  if (ts17.isIdentifier(node)) {
     if (node.text === "undefined")
       return;
     if (node.text in ctx.bindings)
@@ -18971,29 +19199,29 @@ function evalNode(node, ctx) {
       return;
     return UNRESOLVED;
   }
-  if (ts16.isPrefixUnaryExpression(node)) {
+  if (ts17.isPrefixUnaryExpression(node)) {
     const arg = evalNode(node.operand, ctx);
     if (arg === UNRESOLVED)
       return UNRESOLVED;
     switch (node.operator) {
-      case ts16.SyntaxKind.MinusToken:
+      case ts17.SyntaxKind.MinusToken:
         return typeof arg === "number" ? -arg : UNRESOLVED;
-      case ts16.SyntaxKind.PlusToken:
+      case ts17.SyntaxKind.PlusToken:
         return typeof arg === "number" ? +arg : UNRESOLVED;
-      case ts16.SyntaxKind.ExclamationToken:
+      case ts17.SyntaxKind.ExclamationToken:
         return !arg;
     }
     return UNRESOLVED;
   }
-  if (ts16.isObjectLiteralExpression(node)) {
+  if (ts17.isObjectLiteralExpression(node)) {
     const obj = {};
     for (const prop of node.properties) {
-      if (!ts16.isPropertyAssignment(prop))
+      if (!ts17.isPropertyAssignment(prop))
         return UNRESOLVED;
       let key;
-      if (ts16.isIdentifier(prop.name) || ts16.isStringLiteralLike(prop.name)) {
+      if (ts17.isIdentifier(prop.name) || ts17.isStringLiteralLike(prop.name)) {
         key = prop.name.text;
-      } else if (ts16.isNumericLiteral(prop.name)) {
+      } else if (ts17.isNumericLiteral(prop.name)) {
         key = prop.name.text;
       } else {
         return UNRESOLVED;
@@ -19005,10 +19233,10 @@ function evalNode(node, ctx) {
     }
     return obj;
   }
-  if (ts16.isArrayLiteralExpression(node)) {
+  if (ts17.isArrayLiteralExpression(node)) {
     const arr = [];
     for (const elem of node.elements) {
-      if (ts16.isOmittedExpression(elem))
+      if (ts17.isOmittedExpression(elem))
         return UNRESOLVED;
       const v = evalNode(elem, ctx);
       if (v === UNRESOLVED)
@@ -19017,7 +19245,7 @@ function evalNode(node, ctx) {
     }
     return arr;
   }
-  if (ts16.isElementAccessExpression(node)) {
+  if (ts17.isElementAccessExpression(node)) {
     const base = evalNode(node.expression, ctx);
     if (base === undefined)
       return;
@@ -19031,17 +19259,17 @@ function evalNode(node, ctx) {
     const k = String(key);
     return Object.prototype.hasOwnProperty.call(base, k) ? base[k] : undefined;
   }
-  if (ts16.isPropertyAccessExpression(node)) {
+  if (ts17.isPropertyAccessExpression(node)) {
     const baseResult = evalNode(node.expression, ctx);
     if (baseResult === undefined)
       return;
     return UNRESOLVED;
   }
-  if (ts16.isCallExpression(node)) {
-    if (node.arguments.length === 0 && ts16.isIdentifier(node.expression) && node.expression.text in ctx.bindings) {
+  if (ts17.isCallExpression(node)) {
+    if (node.arguments.length === 0 && ts17.isIdentifier(node.expression) && node.expression.text in ctx.bindings) {
       return ctx.bindings[node.expression.text];
     }
-    if (ts16.isPropertyAccessExpression(node.expression) && node.expression.name.text === "join") {
+    if (ts17.isPropertyAccessExpression(node.expression) && node.expression.name.text === "join") {
       const recv = evalNode(node.expression.expression, ctx);
       if (Array.isArray(recv)) {
         let sep2 = ",";
@@ -19057,27 +19285,27 @@ function evalNode(node, ctx) {
     }
     return UNRESOLVED;
   }
-  if (ts16.isConditionalExpression(node)) {
+  if (ts17.isConditionalExpression(node)) {
     const cond = evalNode(node.condition, ctx);
     if (cond === UNRESOLVED)
       return UNRESOLVED;
     return cond ? evalNode(node.whenTrue, ctx) : evalNode(node.whenFalse, ctx);
   }
-  if (ts16.isBinaryExpression(node)) {
+  if (ts17.isBinaryExpression(node)) {
     const op = node.operatorToken.kind;
-    if (op === ts16.SyntaxKind.QuestionQuestionToken) {
+    if (op === ts17.SyntaxKind.QuestionQuestionToken) {
       const l2 = evalNode(node.left, ctx);
       if (l2 !== UNRESOLVED && l2 !== null && l2 !== undefined)
         return l2;
       return evalNode(node.right, ctx);
     }
-    if (op === ts16.SyntaxKind.BarBarToken) {
+    if (op === ts17.SyntaxKind.BarBarToken) {
       const l2 = evalNode(node.left, ctx);
       if (l2 !== UNRESOLVED && l2)
         return l2;
       return evalNode(node.right, ctx);
     }
-    if (op === ts16.SyntaxKind.AmpersandAmpersandToken) {
+    if (op === ts17.SyntaxKind.AmpersandAmpersandToken) {
       const l2 = evalNode(node.left, ctx);
       if (l2 === UNRESOLVED)
         return UNRESOLVED;
@@ -19090,30 +19318,30 @@ function evalNode(node, ctx) {
     if (l === UNRESOLVED || r === UNRESOLVED)
       return UNRESOLVED;
     switch (op) {
-      case ts16.SyntaxKind.PlusToken:
+      case ts17.SyntaxKind.PlusToken:
         if (typeof l === "string" || typeof r === "string")
           return `${l}${r}`;
         if (typeof l === "number" && typeof r === "number")
           return l + r;
         return UNRESOLVED;
-      case ts16.SyntaxKind.MinusToken:
+      case ts17.SyntaxKind.MinusToken:
         return typeof l === "number" && typeof r === "number" ? l - r : UNRESOLVED;
-      case ts16.SyntaxKind.AsteriskToken:
+      case ts17.SyntaxKind.AsteriskToken:
         return typeof l === "number" && typeof r === "number" ? l * r : UNRESOLVED;
-      case ts16.SyntaxKind.SlashToken:
+      case ts17.SyntaxKind.SlashToken:
         return typeof l === "number" && typeof r === "number" && r !== 0 ? l / r : UNRESOLVED;
-      case ts16.SyntaxKind.PercentToken:
+      case ts17.SyntaxKind.PercentToken:
         return typeof l === "number" && typeof r === "number" && r !== 0 ? l % r : UNRESOLVED;
-      case ts16.SyntaxKind.EqualsEqualsEqualsToken:
-      case ts16.SyntaxKind.EqualsEqualsToken:
+      case ts17.SyntaxKind.EqualsEqualsEqualsToken:
+      case ts17.SyntaxKind.EqualsEqualsToken:
         return l === r;
-      case ts16.SyntaxKind.ExclamationEqualsEqualsToken:
-      case ts16.SyntaxKind.ExclamationEqualsToken:
+      case ts17.SyntaxKind.ExclamationEqualsEqualsToken:
+      case ts17.SyntaxKind.ExclamationEqualsToken:
         return l !== r;
     }
     return UNRESOLVED;
   }
-  if (ts16.isTemplateExpression(node)) {
+  if (ts17.isTemplateExpression(node)) {
     if (node.templateSpans.length === 0)
       return node.head.text;
     let acc = node.head.text;
@@ -19125,13 +19353,13 @@ function evalNode(node, ctx) {
     }
     return acc;
   }
-  if (ts16.isNoSubstitutionTemplateLiteral(node))
+  if (ts17.isNoSubstitutionTemplateLiteral(node))
     return node.text;
   return UNRESOLVED;
 }
 
 // src/augment-inherited-props.ts
-import ts17 from "typescript";
+import ts18 from "typescript";
 function collectContextConsumers(metadata) {
   const constants = metadata.localConstants ?? [];
   const contextDefaults = new Map;
@@ -19163,47 +19391,47 @@ function collectContextConsumers(metadata) {
 }
 function parseUseContextArg(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts17.isCallExpression(expr))
+  if (!expr || !ts18.isCallExpression(expr))
     return null;
-  if (!ts17.isIdentifier(expr.expression) || expr.expression.text !== "useContext")
+  if (!ts18.isIdentifier(expr.expression) || expr.expression.text !== "useContext")
     return null;
   if (expr.arguments.length !== 1)
     return null;
   const arg = expr.arguments[0];
-  return ts17.isIdentifier(arg) ? arg.text : null;
+  return ts18.isIdentifier(arg) ? arg.text : null;
 }
 function parseCreateContextDefault(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts17.isCallExpression(expr))
+  if (!expr || !ts18.isCallExpression(expr))
     return null;
   if (expr.arguments.length === 0)
     return null;
   const arg = expr.arguments[0];
-  if (ts17.isStringLiteral(arg) || ts17.isNoSubstitutionTemplateLiteral(arg))
+  if (ts18.isStringLiteral(arg) || ts18.isNoSubstitutionTemplateLiteral(arg))
     return arg.text;
-  if (ts17.isNumericLiteral(arg))
+  if (ts18.isNumericLiteral(arg))
     return Number(arg.text);
-  if (arg.kind === ts17.SyntaxKind.TrueKeyword)
+  if (arg.kind === ts18.SyntaxKind.TrueKeyword)
     return true;
-  if (arg.kind === ts17.SyntaxKind.FalseKeyword)
+  if (arg.kind === ts18.SyntaxKind.FalseKeyword)
     return false;
   return null;
 }
 function isObjectLiteralCreateContextDefault(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts17.isCallExpression(expr))
+  if (!expr || !ts18.isCallExpression(expr))
     return false;
   if (expr.arguments.length === 0)
     return false;
-  return ts17.isObjectLiteralExpression(expr.arguments[0]);
+  return ts18.isObjectLiteralExpression(expr.arguments[0]);
 }
 function parseSingleExpression(source) {
-  const sf = ts17.createSourceFile("__ctx.ts", `(${source})`, ts17.ScriptTarget.Latest, false);
+  const sf = ts18.createSourceFile("__ctx.ts", `(${source})`, ts18.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts17.isExpressionStatement(stmt))
+  if (!stmt || !ts18.isExpressionStatement(stmt))
     return null;
   let e = stmt.expression;
-  while (ts17.isParenthesizedExpression(e))
+  while (ts18.isParenthesizedExpression(e))
     e = e.expression;
   return e;
 }
@@ -19228,25 +19456,25 @@ function augmentInheritedPropAccesses(ir) {
   const pinCoalesceLiterals = (s) => {
     if (!s || !s.includes(propsObj))
       return;
-    const sf = ts17.createSourceFile("__aug.ts", `(${s})`, ts17.ScriptTarget.Latest, false);
+    const sf = ts18.createSourceFile("__aug.ts", `(${s})`, ts18.ScriptTarget.Latest, false);
     const visit3 = (n) => {
-      if (ts17.isBinaryExpression(n) && (n.operatorToken.kind === ts17.SyntaxKind.QuestionQuestionToken || n.operatorToken.kind === ts17.SyntaxKind.BarBarToken)) {
+      if (ts18.isBinaryExpression(n) && (n.operatorToken.kind === ts18.SyntaxKind.QuestionQuestionToken || n.operatorToken.kind === ts18.SyntaxKind.BarBarToken)) {
         let left = n.left;
-        while (ts17.isParenthesizedExpression(left))
+        while (ts18.isParenthesizedExpression(left))
           left = left.expression;
-        if (ts17.isPropertyAccessExpression(left) && ts17.isIdentifier(left.expression) && left.expression.text === propsObj) {
+        if (ts18.isPropertyAccessExpression(left) && ts18.isIdentifier(left.expression) && left.expression.text === propsObj) {
           const name = left.name.text;
           let right = n.right;
-          while (ts17.isParenthesizedExpression(right))
+          while (ts18.isParenthesizedExpression(right))
             right = right.expression;
-          if (ts17.isPrefixUnaryExpression(right))
+          if (ts18.isPrefixUnaryExpression(right))
             right = right.operand;
-          const kind = ts17.isNumericLiteral(right) ? "number" : right.kind === ts17.SyntaxKind.TrueKeyword || right.kind === ts17.SyntaxKind.FalseKeyword ? "boolean" : ts17.isStringLiteralLike(right) ? "string" : null;
+          const kind = ts18.isNumericLiteral(right) ? "number" : right.kind === ts18.SyntaxKind.TrueKeyword || right.kind === ts18.SyntaxKind.FalseKeyword ? "boolean" : ts18.isStringLiteralLike(right) ? "string" : null;
           if (kind && !coalesceLiteralTypes.has(name))
             coalesceLiteralTypes.set(name, kind);
         }
       }
-      ts17.forEachChild(n, visit3);
+      ts18.forEachChild(n, visit3);
     };
     visit3(sf);
   };
@@ -19357,33 +19585,33 @@ function augmentInheritedPropAccesses(ir) {
   }
 }
 function parseStaticStringConst(source) {
-  const sf = ts17.createSourceFile("__const.ts", `const __x = (${source});`, ts17.ScriptTarget.Latest, false);
+  const sf = ts18.createSourceFile("__const.ts", `const __x = (${source});`, ts18.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts17.isVariableStatement(stmt))
+  if (!stmt || !ts18.isVariableStatement(stmt))
     return null;
   let init = stmt.declarationList.declarations[0]?.initializer;
-  while (init && ts17.isParenthesizedExpression(init))
+  while (init && ts18.isParenthesizedExpression(init))
     init = init.expression;
   if (!init)
     return null;
-  if (ts17.isStringLiteral(init) || ts17.isNoSubstitutionTemplateLiteral(init)) {
+  if (ts18.isStringLiteral(init) || ts18.isNoSubstitutionTemplateLiteral(init)) {
     return init.text;
   }
   return evalStringArrayJoin(source);
 }
 function evalTemplateOfStringConsts(source, resolved) {
-  const sf = ts17.createSourceFile("__const.ts", `const __x = (${source});`, ts17.ScriptTarget.Latest, false);
+  const sf = ts18.createSourceFile("__const.ts", `const __x = (${source});`, ts18.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts17.isVariableStatement(stmt))
+  if (!stmt || !ts18.isVariableStatement(stmt))
     return null;
   let init = stmt.declarationList.declarations[0]?.initializer;
-  while (init && ts17.isParenthesizedExpression(init))
+  while (init && ts18.isParenthesizedExpression(init))
     init = init.expression;
-  if (!init || !ts17.isTemplateExpression(init))
+  if (!init || !ts18.isTemplateExpression(init))
     return null;
   let out = init.head.text;
   for (const span of init.templateSpans) {
-    if (!ts17.isIdentifier(span.expression))
+    if (!ts18.isIdentifier(span.expression))
       return null;
     const value = resolved.get(span.expression.text);
     if (value === undefined)
@@ -19414,30 +19642,30 @@ function lookupStaticRecordLiteral(objectName, key, constants) {
   const constInfo = (constants ?? []).find((c) => c.name === objectName && c.isModule);
   if (constInfo?.value === undefined)
     return null;
-  const sf = ts17.createSourceFile("__rec.ts", `(${constInfo.value})`, ts17.ScriptTarget.Latest, true);
+  const sf = ts18.createSourceFile("__rec.ts", `(${constInfo.value})`, ts18.ScriptTarget.Latest, true);
   if (sf.statements.length !== 1)
     return null;
   const stmt = sf.statements[0];
-  if (!ts17.isExpressionStatement(stmt))
+  if (!ts18.isExpressionStatement(stmt))
     return null;
   let parsed = stmt.expression;
-  while (ts17.isParenthesizedExpression(parsed))
+  while (ts18.isParenthesizedExpression(parsed))
     parsed = parsed.expression;
-  if (!ts17.isObjectLiteralExpression(parsed))
+  if (!ts18.isObjectLiteralExpression(parsed))
     return null;
   for (const prop of parsed.properties) {
-    if (!ts17.isPropertyAssignment(prop))
+    if (!ts18.isPropertyAssignment(prop))
       continue;
     const name = prop.name;
-    const propKey = ts17.isIdentifier(name) || ts17.isStringLiteral(name) || ts17.isNoSubstitutionTemplateLiteral(name) ? name.text : null;
+    const propKey = ts18.isIdentifier(name) || ts18.isStringLiteral(name) || ts18.isNoSubstitutionTemplateLiteral(name) ? name.text : null;
     if (propKey !== key)
       continue;
     let v = prop.initializer;
-    while (ts17.isParenthesizedExpression(v))
+    while (ts18.isParenthesizedExpression(v))
       v = v.expression;
-    if (ts17.isNumericLiteral(v))
+    if (ts18.isNumericLiteral(v))
       return { kind: "number", text: v.text };
-    if (ts17.isStringLiteral(v) || ts17.isNoSubstitutionTemplateLiteral(v)) {
+    if (ts18.isStringLiteral(v) || ts18.isNoSubstitutionTemplateLiteral(v)) {
       return { kind: "string", text: v.text };
     }
     return null;
@@ -19445,28 +19673,28 @@ function lookupStaticRecordLiteral(objectName, key, constants) {
   return null;
 }
 function evalStringArrayJoin(source) {
-  const sf = ts17.createSourceFile("__join.ts", `const __x = (${source});`, ts17.ScriptTarget.Latest, false);
+  const sf = ts18.createSourceFile("__join.ts", `const __x = (${source});`, ts18.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts17.isVariableStatement(stmt))
+  if (!stmt || !ts18.isVariableStatement(stmt))
     return null;
   let node = stmt.declarationList.declarations[0]?.initializer;
-  while (node && ts17.isParenthesizedExpression(node))
+  while (node && ts18.isParenthesizedExpression(node))
     node = node.expression;
-  if (!node || !ts17.isCallExpression(node))
+  if (!node || !ts18.isCallExpression(node))
     return null;
   const callee = node.expression;
-  if (!ts17.isPropertyAccessExpression(callee))
+  if (!ts18.isPropertyAccessExpression(callee))
     return null;
   if (callee.name.text !== "join")
     return null;
   let recv = callee.expression;
-  while (ts17.isParenthesizedExpression(recv))
+  while (ts18.isParenthesizedExpression(recv))
     recv = recv.expression;
-  if (!ts17.isArrayLiteralExpression(recv))
+  if (!ts18.isArrayLiteralExpression(recv))
     return null;
   const parts = [];
   for (const el of recv.elements) {
-    if (ts17.isStringLiteral(el) || ts17.isNoSubstitutionTemplateLiteral(el)) {
+    if (ts18.isStringLiteral(el) || ts18.isNoSubstitutionTemplateLiteral(el)) {
       parts.push(el.text);
     } else {
       return null;
@@ -19475,7 +19703,7 @@ function evalStringArrayJoin(source) {
   let sep2 = ",";
   if (node.arguments.length >= 1) {
     const arg = node.arguments[0];
-    if (ts17.isStringLiteral(arg) || ts17.isNoSubstitutionTemplateLiteral(arg))
+    if (ts18.isStringLiteral(arg) || ts18.isNoSubstitutionTemplateLiteral(arg))
       sep2 = arg.text;
     else
       return null;
@@ -19483,11 +19711,11 @@ function evalStringArrayJoin(source) {
   return parts.join(sep2);
 }
 function parseRecordIndexAccess(val, localConstants, propsParams, resolveKey) {
-  if (!ts17.isElementAccessExpression(val))
+  if (!ts18.isElementAccessExpression(val))
     return null;
   const obj = val.expression;
   const arg = val.argumentExpression;
-  if (!ts17.isIdentifier(obj) || !ts17.isIdentifier(arg))
+  if (!ts18.isIdentifier(obj) || !ts18.isIdentifier(arg))
     return null;
   let indexPropName;
   let defaultKey;
@@ -19503,35 +19731,35 @@ function parseRecordIndexAccess(val, localConstants, propsParams, resolveKey) {
   const constInfo = localConstants.find((c) => c.name === obj.text && c.isModule);
   if (constInfo?.value === undefined)
     return null;
-  const sf = ts17.createSourceFile("__rec.ts", `(${constInfo.value})`, ts17.ScriptTarget.Latest, true);
+  const sf = ts18.createSourceFile("__rec.ts", `(${constInfo.value})`, ts18.ScriptTarget.Latest, true);
   if (sf.statements.length !== 1)
     return null;
   const stmt = sf.statements[0];
-  if (!ts17.isExpressionStatement(stmt))
+  if (!ts18.isExpressionStatement(stmt))
     return null;
   let parsed = stmt.expression;
-  while (ts17.isParenthesizedExpression(parsed))
+  while (ts18.isParenthesizedExpression(parsed))
     parsed = parsed.expression;
-  if (!ts17.isObjectLiteralExpression(parsed))
+  if (!ts18.isObjectLiteralExpression(parsed))
     return null;
   const entries = [];
   for (const prop of parsed.properties) {
-    if (!ts17.isPropertyAssignment(prop))
+    if (!ts18.isPropertyAssignment(prop))
       return null;
     let key;
-    if (ts17.isIdentifier(prop.name)) {
+    if (ts18.isIdentifier(prop.name)) {
       key = prop.name.text;
-    } else if (ts17.isStringLiteral(prop.name) || ts17.isNoSubstitutionTemplateLiteral(prop.name)) {
+    } else if (ts18.isStringLiteral(prop.name) || ts18.isNoSubstitutionTemplateLiteral(prop.name)) {
       key = prop.name.text;
     } else {
       return null;
     }
     let v = prop.initializer;
-    while (ts17.isParenthesizedExpression(v))
+    while (ts18.isParenthesizedExpression(v))
       v = v.expression;
-    if (ts17.isNumericLiteral(v)) {
+    if (ts18.isNumericLiteral(v)) {
       entries.push({ key, value: { kind: "number", text: v.text } });
-    } else if (ts17.isStringLiteral(v) || ts17.isNoSubstitutionTemplateLiteral(v)) {
+    } else if (ts18.isStringLiteral(v) || ts18.isNoSubstitutionTemplateLiteral(v)) {
       entries.push({ key, value: { kind: "string", text: v.text } });
     } else {
       return null;
@@ -19584,6 +19812,221 @@ function computeSsrSeedPlan(metadata) {
   return { baseScope, steps };
 }
 
+// src/rich-type-refusal.ts
+var EMPTY_BINDINGS2 = new Map;
+function checkRichTypeMethodCalls(root, metadata, errors) {
+  if (!metadata.propsType)
+    return;
+  const matchers = prepareLoweringMatchers(metadata);
+  const seen = new Set;
+  walkNode(root, metadata, EMPTY_BINDINGS2, matchers, errors, seen);
+}
+function isLoweringClaimed(matchers, callee, args) {
+  return matchers.some((m) => m(callee, args) !== null);
+}
+function describeReceiverPath(expr) {
+  if (expr.kind === "identifier")
+    return expr.name;
+  if (expr.kind === "member" && !expr.computed)
+    return `${describeReceiverPath(expr.object)}.${expr.property}`;
+  return "<expression>";
+}
+function receiverRootIsProp(expr, bindings) {
+  let root = expr;
+  while (root.kind === "member" && !root.computed)
+    root = root.object;
+  return root.kind === "identifier" && !bindings.has(root.name);
+}
+function pushDiagnostic(errors, seen, loc, method, receiverPath, isProp, typeName) {
+  const key = `${loc.start.line}:${loc.start.column}:${receiverPath}.${method}`;
+  if (seen.has(key))
+    return;
+  seen.add(key);
+  const receiver = isProp ? `prop '${receiverPath}'` : `'${receiverPath}'`;
+  errors.push({
+    code: ErrorCodes.UNSUPPORTED_JSX_PATTERN,
+    severity: "error",
+    message: `Expression cannot be compiled to marked template: method '.${method}()' on ${receiver} of host type '${typeName}' has no catalogued lowering.`,
+    loc,
+    suggestion: {
+      message: "Add /* @client */ to evaluate this expression on the client only, or pre-compute the value server-side."
+    }
+  });
+}
+function checkExpr(expr, loc, meta, bindings, matchers, errors, seen) {
+  const recurse = (e, b = bindings) => checkExpr(e, loc, meta, b, matchers, errors, seen);
+  switch (expr.kind) {
+    case "call": {
+      if (expr.callee.kind === "member") {
+        const receiverType = resolveReceiverType(expr.callee.object, meta, bindings);
+        if (receiverType && receiverType.kind === "interface") {
+          const typeName = baseTypeName(receiverType.raw);
+          const inFileShadow = meta.typeDefinitions.some((d) => d.name === typeName);
+          if (HOST_RICH_TYPE_NAMES.has(typeName) && !inFileShadow && !isLoweringClaimed(matchers, expr.callee, expr.args)) {
+            pushDiagnostic(errors, seen, loc, expr.callee.property, describeReceiverPath(expr.callee.object), receiverRootIsProp(expr.callee.object, bindings), typeName);
+          }
+        }
+      }
+      recurse(expr.callee);
+      for (const arg of expr.args)
+        recurse(arg);
+      break;
+    }
+    case "member":
+      recurse(expr.object);
+      break;
+    case "index-access":
+      recurse(expr.object);
+      recurse(expr.index);
+      break;
+    case "binary":
+      recurse(expr.left);
+      recurse(expr.right);
+      break;
+    case "unary":
+      recurse(expr.argument);
+      break;
+    case "conditional":
+      recurse(expr.test);
+      recurse(expr.consequent);
+      recurse(expr.alternate);
+      break;
+    case "logical":
+      recurse(expr.left);
+      recurse(expr.right);
+      break;
+    case "template-literal":
+      for (const part of expr.parts)
+        if (part.type === "expression")
+          recurse(part.expr);
+      break;
+    case "arrow": {
+      const shadowed = new Map(bindings);
+      for (const param of expr.params)
+        shadowed.set(param, null);
+      recurse(expr.body, shadowed);
+      break;
+    }
+    case "array-literal":
+      for (const el of expr.elements)
+        recurse(el);
+      break;
+    case "object-literal":
+      for (const prop of expr.properties)
+        recurse(prop.value);
+      break;
+    case "array-method":
+      recurse(expr.object);
+      for (const arg of expr.args)
+        recurse(arg);
+      break;
+    case "identifier":
+    case "literal":
+    case "regex":
+    case "unsupported":
+      break;
+  }
+}
+function walkTemplateParts(parts, loc, meta, bindings, matchers, errors, seen) {
+  for (const part of parts) {
+    if (part.type === "ternary") {
+      const trimmed = part.condition.trim();
+      if (trimmed)
+        checkExpr(parseExpression(trimmed), loc, meta, bindings, matchers, errors, seen);
+    } else if (part.type === "lookup") {
+      const trimmed = part.key.trim();
+      if (trimmed)
+        checkExpr(parseExpression(trimmed), loc, meta, bindings, matchers, errors, seen);
+    }
+  }
+}
+function walkAttrValue(value, clientOnly, loc, meta, bindings, matchers, errors, seen) {
+  if (clientOnly)
+    return;
+  if (value.kind === "expression") {
+    if (value.parsed)
+      checkExpr(value.parsed, loc, meta, bindings, matchers, errors, seen);
+    if (value.parts)
+      walkTemplateParts(value.parts, loc, meta, bindings, matchers, errors, seen);
+  } else if (value.kind === "spread") {
+    if (value.parsed)
+      checkExpr(value.parsed, loc, meta, bindings, matchers, errors, seen);
+  } else if (value.kind === "template") {
+    walkTemplateParts(value.parts, loc, meta, bindings, matchers, errors, seen);
+  }
+}
+function walkNode(node, meta, bindings, matchers, errors, seen) {
+  if (node.type === "expression") {
+    if (!node.clientOnly && node.parsed)
+      checkExpr(node.parsed, node.loc, meta, bindings, matchers, errors, seen);
+  } else if (node.type === "conditional") {
+    if (!node.clientOnly && node.parsedCondition)
+      checkExpr(node.parsedCondition, node.loc, meta, bindings, matchers, errors, seen);
+  } else if (node.type === "if-statement") {
+    if (node.parsedCondition)
+      checkExpr(node.parsedCondition, node.loc, meta, bindings, matchers, errors, seen);
+  }
+  if (node.type === "element") {
+    for (const attr of node.attrs)
+      walkAttrValue(attr.value, attr.clientOnly, attr.loc, meta, bindings, matchers, errors, seen);
+  } else if (node.type === "component") {
+    for (const prop of node.props)
+      walkAttrValue(prop.value, prop.clientOnly, prop.loc, meta, bindings, matchers, errors, seen);
+  } else if (node.type === "provider") {
+    walkAttrValue(node.valueProp.value, node.valueProp.clientOnly, node.valueProp.loc, meta, bindings, matchers, errors, seen);
+  }
+  switch (node.type) {
+    case "element":
+    case "component":
+    case "fragment":
+    case "provider":
+      for (const child of node.children)
+        walkNode(child, meta, bindings, matchers, errors, seen);
+      break;
+    case "async":
+      walkNode(node.fallback, meta, bindings, matchers, errors, seen);
+      for (const child of node.children)
+        walkNode(child, meta, bindings, matchers, errors, seen);
+      break;
+    case "loop": {
+      if (node.clientOnly)
+        break;
+      if (node.arrayParsed)
+        checkExpr(node.arrayParsed, node.loc, meta, bindings, matchers, errors, seen);
+      const loopBindings = new Map(bindings);
+      const arrayType = node.arrayParsed ? resolveReceiverType(node.arrayParsed, meta, bindings) : null;
+      loopBindings.set(node.param, arrayType?.kind === "array" ? arrayType.elementType ?? null : null);
+      if (node.index)
+        loopBindings.set(node.index, null);
+      for (const child of node.children)
+        walkNode(child, meta, loopBindings, matchers, errors, seen);
+      if (node.childComponent) {
+        for (const child of node.childComponent.children)
+          walkNode(child, meta, loopBindings, matchers, errors, seen);
+      }
+      for (const nested of node.nestedComponents ?? []) {
+        for (const child of nested.children)
+          walkNode(child, meta, loopBindings, matchers, errors, seen);
+      }
+      for (const frag of node.flatMapCallback?.fragments ?? []) {
+        walkNode(frag.ir, meta, loopBindings, matchers, errors, seen);
+      }
+      break;
+    }
+    case "conditional":
+      if (node.clientOnly)
+        break;
+      walkNode(node.whenTrue, meta, bindings, matchers, errors, seen);
+      walkNode(node.whenFalse, meta, bindings, matchers, errors, seen);
+      break;
+    case "if-statement":
+      walkNode(node.consequent, meta, bindings, matchers, errors, seen);
+      if (node.alternate)
+        walkNode(node.alternate, meta, bindings, matchers, errors, seen);
+      break;
+  }
+}
+
 // src/compiler.ts
 function mergeTemplateImports(lines) {
   const result = [];
@@ -19644,6 +20087,7 @@ function compileMultipleComponents(source, filePath, componentNames, options) {
       errors: []
     };
     componentIR.metadata.clientAnalysis = analyzeClientNeeds(componentIR);
+    checkRichTypeMethodCalls(componentIR.root, componentIR.metadata, errors);
     if (options.cssLayerPrefix) {
       applyCssLayerPrefix(componentIR, options.cssLayerPrefix);
     }
@@ -19982,6 +20426,7 @@ function compileJSX(source, filePath, options) {
     errors: []
   };
   componentIR.metadata.clientAnalysis = analyzeClientNeeds(componentIR);
+  checkRichTypeMethodCalls(componentIR.root, componentIR.metadata, errors);
   if (ctx.importedClientSignalNames.size > 0) {
     const sources = new Set;
     for (const imp of ctx.imports) {
@@ -20086,7 +20531,7 @@ function compileJSX(source, filePath, options) {
   return { files, errors };
 }
 // src/shared-program.ts
-import ts18 from "typescript";
+import ts19 from "typescript";
 function commonParent(paths) {
   if (paths.length === 0)
     return process.cwd();
@@ -20107,10 +20552,10 @@ function commonParent(paths) {
 function createProgramForCorpus(files, options = {}) {
   const baseUrl = options.baseUrl ?? commonParent(files);
   const compilerOptions = {
-    target: ts18.ScriptTarget.Latest,
-    module: ts18.ModuleKind.ESNext,
-    moduleResolution: ts18.ModuleResolutionKind.Bundler,
-    jsx: ts18.JsxEmit.ReactJSX,
+    target: ts19.ScriptTarget.Latest,
+    module: ts19.ModuleKind.ESNext,
+    moduleResolution: ts19.ModuleResolutionKind.Bundler,
+    jsx: ts19.JsxEmit.ReactJSX,
     strict: true,
     skipLibCheck: true,
     noEmit: true,
@@ -20120,7 +20565,7 @@ function createProgramForCorpus(files, options = {}) {
     ...options.compilerOptions
   };
   const absolute = files.map((f) => path_default.resolve(f));
-  return ts18.createProgram(absolute, compilerOptions, undefined, options.oldProgram);
+  return ts19.createProgram(absolute, compilerOptions, undefined, options.oldProgram);
 }
 // src/adapters/interface.ts
 class BaseAdapter {
@@ -20933,7 +21378,7 @@ var queryHrefPlugin = {
     };
   }
 };
-var BUILTIN_LOWERING_PLUGINS = [queryHrefPlugin];
+var BUILTIN_LOWERING_PLUGINS = [queryHrefPlugin, datePlugin];
 function registerBuiltinLoweringPlugins() {
   for (const plugin of BUILTIN_LOWERING_PLUGINS)
     registerLoweringPlugin(plugin);
@@ -21059,7 +21504,7 @@ function dangerousInnerHtmlDiagnostic(expr, loc, reason) {
   };
 }
 // src/combine-client-js.ts
-import ts19 from "typescript";
+import ts20 from "typescript";
 var CHILD_PLACEHOLDER_RE = /import '\/\* @bf-child:(\w+) \*\/'/g;
 function combineParentChildClientJs(files) {
   const result = new Map;
@@ -21116,10 +21561,10 @@ function combineParentChildClientJs(files) {
   return result;
 }
 function parseAndMerge(content, importsBySource, otherImports, codeSections) {
-  const sourceFile = ts19.createSourceFile("combine.js", content, ts19.ScriptTarget.Latest, false, ts19.ScriptKind.JS);
+  const sourceFile = ts20.createSourceFile("combine.js", content, ts20.ScriptTarget.Latest, false, ts20.ScriptKind.JS);
   const importSpans = [];
   for (const stmt of sourceFile.statements) {
-    if (!ts19.isImportDeclaration(stmt))
+    if (!ts20.isImportDeclaration(stmt))
       continue;
     const start = stmt.getStart(sourceFile);
     const end = stmt.getEnd();
@@ -21129,8 +21574,8 @@ function parseAndMerge(content, importsBySource, otherImports, codeSections) {
       continue;
     const clause = stmt.importClause;
     const bindings = clause?.namedBindings;
-    const specifier = ts19.isStringLiteral(stmt.moduleSpecifier) ? stmt.moduleSpecifier.text : "";
-    if (clause && !clause.name && bindings && ts19.isNamedImports(bindings)) {
+    const specifier = ts20.isStringLiteral(stmt.moduleSpecifier) ? stmt.moduleSpecifier.text : "";
+    if (clause && !clause.name && bindings && ts20.isNamedImports(bindings)) {
       if (!importsBySource.has(specifier)) {
         importsBySource.set(specifier, new Set);
       }
@@ -21293,7 +21738,7 @@ function escapeRe(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 // src/debug.ts
-import ts20 from "typescript";
+import ts21 from "typescript";
 function buildComponentGraph(source, filePath, componentName) {
   const ctx = analyzeComponent(source, filePath, componentName);
   if (!ctx.jsxReturn) {
@@ -22578,7 +23023,7 @@ function truncateExpr(expr, max = 40) {
 function exprReadsPropMember(expr, propsObjectName) {
   let sf;
   try {
-    sf = ts20.createSourceFile("__attr.tsx", `(${expr})`, ts20.ScriptTarget.Latest, true, ts20.ScriptKind.TSX);
+    sf = ts21.createSourceFile("__attr.tsx", `(${expr})`, ts21.ScriptTarget.Latest, true, ts21.ScriptKind.TSX);
   } catch {
     return false;
   }
@@ -22586,11 +23031,11 @@ function exprReadsPropMember(expr, propsObjectName) {
   const visit3 = (n) => {
     if (found)
       return;
-    if (ts20.isPropertyAccessExpression(n) && ts20.isIdentifier(n.expression) && n.expression.text === propsObjectName && n.name.text !== "children") {
+    if (ts21.isPropertyAccessExpression(n) && ts21.isIdentifier(n.expression) && n.expression.text === propsObjectName && n.name.text !== "children") {
       found = true;
       return;
     }
-    ts20.forEachChild(n, visit3);
+    ts21.forEachChild(n, visit3);
   };
   visit3(sf);
   return found;
@@ -22660,7 +23105,7 @@ function findSourceFile2(meta) {
   return null;
 }
 // src/profiler.ts
-import ts21 from "typescript";
+import ts22 from "typescript";
 var PROFILE_SCHEMA_VERSION = 1;
 var DEFAULT_FANOUT_THRESHOLD = 8;
 function buildStaticBudget(source, filePath, componentName, options = {}) {
@@ -22930,15 +23375,15 @@ function joinProfilerEvents(events, index) {
   return { joined, unattributed, diagnostics };
 }
 function findUninstrumentedEffects(source, filePath, instrumentedLines) {
-  const sf = ts21.createSourceFile(filePath, source, ts21.ScriptTarget.Latest, true, ts21.ScriptKind.TSX);
+  const sf = ts22.createSourceFile(filePath, source, ts22.ScriptTarget.Latest, true, ts22.ScriptKind.TSX);
   const out = [];
   const visit3 = (node) => {
-    if (ts21.isCallExpression(node) && ts21.isIdentifier(node.expression) && node.expression.text === "createEffect") {
+    if (ts22.isCallExpression(node) && ts22.isIdentifier(node.expression) && node.expression.text === "createEffect") {
       const line = sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
       if (!instrumentedLines.has(line))
         out.push({ file: filePath, line });
     }
-    ts21.forEachChild(node, visit3);
+    ts22.forEachChild(node, visit3);
   };
   visit3(sf);
   out.sort((a, b) => a.line - b.line);
@@ -23246,13 +23691,13 @@ function assessBatchSafety(args) {
   const signalGetters = new Set(args.graph.signals.map((s) => s.name));
   let sf;
   try {
-    sf = ts21.createSourceFile("__h.ts", `const __h = ${args.handler}`, ts21.ScriptTarget.Latest, true);
+    sf = ts22.createSourceFile("__h.ts", `const __h = ${args.handler}`, ts22.ScriptTarget.Latest, true);
   } catch {
     return "unverified";
   }
   const calls = [];
   const visit3 = (node) => {
-    if (ts21.isCallExpression(node) && ts21.isIdentifier(node.expression)) {
+    if (ts22.isCallExpression(node) && ts22.isIdentifier(node.expression)) {
       const name = node.expression.text;
       if (setters.has(name))
         calls.push({ pos: node.getStart(sf), kind: "write" });
@@ -23261,7 +23706,7 @@ function assessBatchSafety(args) {
       else if (!signalGetters.has(name) && !memoNames.has(name))
         calls.push({ pos: node.getStart(sf), kind: "risky" });
     }
-    ts21.forEachChild(node, visit3);
+    ts22.forEachChild(node, visit3);
   };
   visit3(sf);
   calls.sort((a, b) => a.pos - b.pos);