@barefootjs/jsx 0.20.0 → 0.21.2

package/src/expression-parser.ts

@@ -186,6 +186,53 @@ type MissingFromKindRegistry = Exclude<ParsedExpr['kind'], (typeof PARSED_EXPR_K
 const _kindRegistryIsExhaustive: MissingFromKindRegistry extends never ? true : never = true
 void _kindRegistryIsExhaustive
 
+/**
+ * Runtime registry of the catalogued `array-method` names — the positive
+ * counterpart to `UNSUPPORTED_METHODS`'s negative gate, and the denominator
+ * the coverage ledger's array-method floor test (`coverage-map.test.ts`)
+ * requires a covering fixture for. This is the catalogue half of the
+ * change-time coupling rule (`spec/subset-conformance.md` / `CLAUDE.md`):
+ * the exhaustiveness pin below makes adding a method to the `array-method`
+ * union without listing it here a compile error, and the floor test then
+ * makes shipping a listed method with no fixture a test failure.
+ */
+export const ARRAY_METHOD_NAMES = [
+  'join',
+  'includes',
+  'indexOf',
+  'lastIndexOf',
+  'at',
+  'concat',
+  'slice',
+  'reverse',
+  'toReversed',
+  'toLowerCase',
+  'toUpperCase',
+  'trim',
+  'trimStart',
+  'trimEnd',
+  'toFixed',
+  'split',
+  'startsWith',
+  'endsWith',
+  'replace',
+  'replaceAll',
+  'repeat',
+  'padStart',
+  'padEnd',
+  'flat',
+] as const satisfies ReadonlyArray<Extract<ParsedExpr, { kind: 'array-method' }>['method']>
+
+// Exhaustiveness pin: adding a method to the `array-method` union (either
+// variant) without listing it in `ARRAY_METHOD_NAMES` fails to compile here
+// (same drift defence as `PARSED_EXPR_KINDS`).
+type MissingFromArrayMethodRegistry = Exclude<
+  Extract<ParsedExpr, { kind: 'array-method' }>['method'],
+  (typeof ARRAY_METHOD_NAMES)[number]
+>
+const _arrayMethodRegistryIsExhaustive: MissingFromArrayMethodRegistry extends never ? true : never = true
+void _arrayMethodRegistryIsExhaustive
+
 /**
  * One property of an `object-literal` `ParsedExpr`. The key is the
  * resolved (non-computed) property name — for `{ a: 1 }` and shorthand

package/src/index.ts

@@ -322,7 +322,7 @@ export { ErrorCodes, createError, formatError, generateCodeFrame } from './error
 // Expression Parser
 export { parseExpression, tsNodeToParsedExpr, asCallbackMethodCall, CALLBACK_METHODS, sortComparatorFromArrow, serializeParsedExpr, freeVarsInBody, freeIdentifiers, materializeGetterCalls, isSupported, exprToString, stringifyParsedExpr, identifierPath, parseBlockBody, parseBlockBodyTolerant, foldBlockToExpr, predicateTernaryToLogical, containsHigherOrder, extractArrowBodyExpression, parseStyleObjectEntries, hasUnsafeStyleValue, parseProviderObjectLiteral, type ProviderObjectMember, type FoldBlockOptions } from './expression-parser.ts'
 export type { StyleObjectEntry } from './expression-parser.ts'
-export { PARSED_EXPR_KINDS } from './expression-parser.ts'
+export { PARSED_EXPR_KINDS, ARRAY_METHOD_NAMES } from './expression-parser.ts'
 export type { ParsedExpr, ObjectLiteralProperty, ParsedStatement, SortComparator, SortKey, FlatDepth, SupportLevel, SupportResult, TemplatePart } from './expression-parser.ts'
 export { buildLoopChainExpr } from './loop-chain.ts'
 export type { LoopChainInputs } from './loop-chain.ts'

package/src/ir-to-client-js/emit-reactive.ts

@@ -4,11 +4,15 @@
  * client-only expressions, and reactive component prop bindings.
  */
 
-import type { AttrMeta } from '../types.ts'
+import ts from 'typescript'
+import type { AttrMeta, IRMetadata } from '../types.ts'
 import { isBooleanAttr } from '../html-constants.ts'
 import type { ClientJsContext } from './types.ts'
 import { toHtmlAttrName, varSlotId, PROPS_PARAM } from './utils.ts'
 import { createTemplateAwareStringProtector } from './html-template.ts'
+import { datePlugin, DATE_METHODS } from '../date-lowering.ts'
+import { tsNodeToParsedExpr } from '../expression-parser.ts'
+import type { LoweringMatcher } from '../lowering-registry.ts'
 
 /**
  * Profile mode (#1690, SR3/SR4): the id appended to a DOM-binding effect so the
@@ -95,8 +99,104 @@ export function rewriteDestructuredPropsInExpr(expr: string, ctx: ClientJsContex
   return restore(result)
 }
 
+/**
+ * Bind `datePlugin`'s matcher (#2292) for this component's reactive-text
+ * emission. Reads the same four `EvidenceMetadata` fields
+ * (`rich-type-evidence.ts`) `jsx-to-ir.ts`'s `getDateLoweringMatcher` reads
+ * off the analyzer for the STATIC template path, so a prop-method call
+ * re-evaluated inside a `createEffect` lowers to the `date` helper under
+ * the exact same evidence the static template and every SSR adapter use.
+ * `ctx.propsType` is optional on `ClientJsContext` (threaded through only
+ * for this purpose, `index.ts`'s `createContext`); a context predating
+ * #2292 — or a hand-built test fixture — simply carries no Date evidence,
+ * so this returns null and callers emit the expression unchanged.
+ */
+function getReactiveDateLoweringMatcher(ctx: ClientJsContext): LoweringMatcher | null {
+  if (!ctx.propsType) return null
+  const metadataSlice: Pick<IRMetadata, 'propsType' | 'propsObjectName' | 'propsParams' | 'typeDefinitions'> = {
+    propsType: ctx.propsType,
+    propsObjectName: ctx.propsObjectName,
+    propsParams: ctx.propsParams,
+    typeDefinitions: ctx.typeDefinitions ?? [],
+  }
+  return datePlugin.prepare(metadataSlice as unknown as IRMetadata)
+}
+
+/**
+ * Reactive-path counterpart to `jsx-to-ir.ts`'s `lowerDateCalls` (#2292):
+ * without this, a Date-typed prop's catalogued accessor call re-evaluated
+ * inside `createEffect` (the Solid-style wrap-by-default fallback for any
+ * expression containing a function call, #937) still called the RAW
+ * `.toISOString()` / etc. on the hydrated STRING prop value and threw —
+ * the static template alone wasn't enough to fix hydration.
+ *
+ * `expr` here (`IRExpression.expr`, threaded through
+ * `ctx.dynamicElements`) is ALREADY the bare-identifier source form the
+ * SAME `createEffect` body closes over via the destructured-prop shim
+ * (`const createdAt = _p.createdAt ?? {}` at the top of `init()`) — so
+ * unlike the static-template path, the receiver does NOT need a `_p.`
+ * prefix: swapping the raw call for `date(<receiver>, "<op>")` is enough.
+ *
+ * No live `ts.Node` survives into this phase (`expr` is a plain string),
+ * so this re-parses it fresh via `ts.createSourceFile` — the same
+ * technique `expression-parser.ts`'s `parseExpression` uses — rather than
+ * a regex scan (per CLAUDE.md's structural-parsing rule): every candidate
+ * span comes from walking the freshly-parsed AST, and `matcher(...)` is
+ * the SAME `datePlugin` matcher the static path and every SSR adapter
+ * bind, so a call lowers here iff it would lower there too.
+ */
+function lowerDateCallsInReactiveExpr(expr: string, matcher: LoweringMatcher | null): string {
+  if (!matcher) return expr
+  let sourceFile: ts.SourceFile
+  try {
+    sourceFile = ts.createSourceFile('__reactive_expr__.ts', `(${expr});`, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)
+  } catch {
+    return expr
+  }
+  const stmt = sourceFile.statements[0]
+  if (!stmt || !ts.isExpressionStatement(stmt)) return expr
+  const root = ts.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression
+
+  const candidates: ts.CallExpression[] = []
+  const visit = (n: ts.Node): void => {
+    if (
+      ts.isCallExpression(n) &&
+      n.arguments.length === 0 &&
+      ts.isPropertyAccessExpression(n.expression) &&
+      !n.expression.questionDotToken &&
+      DATE_METHODS.has(n.expression.name.text)
+    ) {
+      candidates.push(n)
+    }
+    ts.forEachChild(n, visit)
+  }
+  visit(root)
+  if (candidates.length === 0) return expr
+
+  // Template-aware: protect quoted strings AND template-literal static
+  // segments (leaving `${…}` interpolations exposed) so the non-global
+  // `.replace` can't rewrite a backtick constant that coincidentally
+  // matches the call text before the real call site (Copilot review, #2294).
+  const { protect, restore } = createTemplateAwareStringProtector()
+  let result = protect(expr)
+  for (const call of candidates) {
+    const propAccess = call.expression as ts.PropertyAccessExpression
+    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)
+    // Replacer-function form: a `$` sequence in `receiverText` would
+    // otherwise be reinterpreted as a `String.replace` pattern token and
+    // corrupt the output (repo precedent, #2285).
+    result = result.replace(matchText, () => `date(${receiverText}, "${op}")`)
+  }
+  return restore(result)
+}
+
 /** Emit createEffect blocks that update text nodes for reactive expressions. */
 export function emitDynamicTextUpdates(lines: string[], ctx: ClientJsContext): void {
+  const dateLoweringMatcher = getReactiveDateLoweringMatcher(ctx)
   // Group elements by expression to consolidate effects with same dependencies
   const byExpression = new Map<string, typeof ctx.dynamicElements>()
   for (const elem of ctx.dynamicElements) {
@@ -107,7 +207,8 @@ export function emitDynamicTextUpdates(lines: string[], ctx: ClientJsContext): v
     byExpression.get(key)!.push(elem)
   }
 
-  for (const [expr, elems] of byExpression) {
+  for (const [rawExpr, elems] of byExpression) {
+    const expr = lowerDateCallsInReactiveExpr(rawExpr, dateLoweringMatcher)
     // Separate conditional vs non-conditional elements
     const conditionalElems = elems.filter(e => e.insideConditional)
     const normalElems = elems.filter(e => !e.insideConditional)

package/src/ir-to-client-js/imports.ts

@@ -17,6 +17,10 @@ export const RUNTIME_IMPORT_CANDIDATES = [
   'tAfter',
   // Profile mode (#1690, SR3) — turn-boundary markers around event handlers.
   'beginTurn', 'endTurn',
+  // Catalogued `Date` lowering (#2274/#2292) — the client counterpart to
+  // every SSR adapter's `date` runtime helper (`date-lowering.ts`'s
+  // `datePlugin`).
+  'date',
 ] as const
 
 /** @deprecated Use RUNTIME_IMPORT_CANDIDATES */

package/src/ir-to-client-js/index.ts

@@ -175,6 +175,8 @@ function createContext(
     propsParams: ir.metadata.propsParams,
     propsObjectName: ir.metadata.propsObjectName,
     restPropsName: ir.metadata.restPropsName,
+    propsType: ir.metadata.propsType,
+    typeDefinitions: ir.metadata.typeDefinitions,
 
     interactiveElements: [],
     dynamicElements: [],

package/src/ir-to-client-js/types.ts

@@ -20,6 +20,8 @@ import type {
   ParamInfo,
   CompilerError,
   ImportInfo,
+  TypeInfo,
+  TypeDefinition,
 } from '../types.ts'
 import type { CsrInlinabilityMap } from './csr-substitute.ts'
 import type { SkeletonSlotPaths } from './html-template.ts'
@@ -67,6 +69,19 @@ export interface ClientJsContext {
   propsParams: ParamInfo[]
   propsObjectName: string | null
   restPropsName: string | null
+  /**
+   * Threaded through (alongside `propsParams` above) so the reactive-effect
+   * emitter can bind its own `datePlugin` matcher (#2292) — see
+   * `emit-reactive.ts`'s `getReactiveDateLoweringMatcher`. Mirrors the
+   * `EvidenceMetadata` slice (`rich-type-evidence.ts`) the SSR adapters and
+   * `jsx-to-ir.ts`'s static-template lowering both consult; nothing else in
+   * this file reads a Date-typed prop's shape. Optional (rather than a hard
+   * requirement alongside `propsParams`) so existing hand-built
+   * `ClientJsContext` test fixtures that predate #2292 keep type-checking
+   * without every call site listing these two fields.
+   */
+  propsType?: TypeInfo | null
+  typeDefinitions?: TypeDefinition[]
 
   // Collected elements
   interactiveElements: InteractiveElement[]

package/src/jsx-to-ir.ts

@@ -30,6 +30,7 @@ import {
   type SourceLocation,
   type TypeInfo,
   type OriginInfo,
+  type IRMetadata,
   isReactiveOrigin,
   AttrValueOf,
 } from './types.ts'
@@ -46,6 +47,9 @@ import {
 } from './prop-rewrite.ts'
 import { resolveFreeRefs, isNameBound as isNameBoundInEnv, type BindingEnvironment } from './free-refs.ts'
 import { computeFileScope } from './ir-to-client-js/component-scope.ts'
+import { createTemplateAwareStringProtector } from './ir-to-client-js/html-template.ts'
+import { datePlugin, DATE_METHODS } from './date-lowering.ts'
+import type { LoweringMatcher } from './lowering-registry.ts'
 import { extractFreeIdentifiersFromNode, initializerShapeContainsJsx } from './analyzer.ts'
 import { iterateJsTokens, replaceInExprContexts } from './scanner/js-scanner.ts'
 import { toHTMLAttrName, decodeEntities } from '@barefootjs/shared'
@@ -164,6 +168,13 @@ interface TransformContext {
    * aliased `import { Async as Boundary }` maps `<Boundary>` to the built-in.
    */
   _clientBuiltinTags?: Map<string, ClientBuiltinTag>
+  /**
+   * Cached `datePlugin` matcher (#2292), bound once to this component's
+   * metadata. `undefined` = not yet computed; `null` = computed and
+   * inactive (this component's props never reach a `Date`, `datePlugin`'s
+   * own `prepare` gate). See `getDateLoweringMatcher`.
+   */
+  _dateLoweringMatcher?: LoweringMatcher | null
 }
 
 /**
@@ -285,14 +296,128 @@ function exprHasFunctionCalls(expr: ts.Expression): boolean {
   return found
 }
 
+/**
+ * Bind (and cache on `ctx`) `datePlugin`'s matcher (#2292) for this
+ * component. Reuses the SAME `LoweringPlugin` the SSR adapters bind via
+ * `prepareLoweringMatchers` — not a re-implementation of its receiver-type
+ * resolution — so a call lowers on the client iff `datePlugin` would lower
+ * it on the SSR path (parity is mandatory per #2292).
+ *
+ * `datePlugin.prepare` only reads `propsType` / `propsObjectName` /
+ * `propsParams` / `typeDefinitions` off its `IRMetadata` parameter (see
+ * `rich-type-evidence.ts`'s `EvidenceMetadata` — the `Pick` of exactly
+ * those four fields). `ctx.analyzer` carries live, fully-populated values
+ * for all four by the time any expression is transformed (analysis runs
+ * to completion before `jsxToIR`'s AST walk begins), so a slice of just
+ * those fields is sufficient — the cast bridges that narrower shape to
+ * the wider `IRMetadata` parameter type every lowering plugin declares.
+ */
+function getDateLoweringMatcher(ctx: TransformContext): LoweringMatcher | null {
+  if (ctx._dateLoweringMatcher === undefined) {
+    const a = ctx.analyzer
+    const metadataSlice: Pick<IRMetadata, 'propsType' | 'propsObjectName' | 'propsParams' | 'typeDefinitions'> = {
+      propsType: a.propsType,
+      propsObjectName: a.propsObjectName,
+      propsParams: a.propsParams,
+      typeDefinitions: a.typeDefinitions,
+    }
+    ctx._dateLoweringMatcher = datePlugin.prepare(metadataSlice as unknown as IRMetadata)
+  }
+  return ctx._dateLoweringMatcher
+}
+
+/**
+ * Client-side counterpart to `datePlugin` (#2274 was SSR-only; #2292
+ * closes the gap). The client emitter (`ir-to-client-js/`) emits raw,
+ * prop-rewritten source strings and never consults the lowering registry
+ * (its module doc) — so left alone, a Date-typed prop's catalogued
+ * accessor call leaks through as `_p.createdAt.toISOString()`, which
+ * throws at hydration: props are JSON round-tripped with no type-aware
+ * revival (`hydrate.ts`'s `parseProps`), so the prop arrives as its ISO
+ * string, not a `Date` instance.
+ *
+ * Walks `expr`'s AST for zero-arg calls to a `DATE_METHODS` name (a cheap
+ * syntactic pre-filter) and confirms each candidate against the SAME
+ * `datePlugin` matcher the SSR adapters use, via `tsNodeToParsedExpr` —
+ * the identical receiver-type resolution, not a re-implementation, so a
+ * call lowers here iff it would lower on the SSR path. A match splices
+ * `date(<receiver>, "<op>")` in place of the raw call; `imports.ts`'s
+ * `detectUsedImports` regex-scans the emitted `date(` call against
+ * `RUNTIME_IMPORT_CANDIDATES` to auto-import the runtime helper.
+ *
+ * The splice is a plain (non-global) text `.replace` per candidate, run
+ * in AST (left-to-right, source) order — not a JS-parsing regex, since
+ * every candidate span comes from walking `expr`'s real AST first. This
+ * is safe specifically because any call the matcher accepts has, by
+ * construction, no TS-only syntax anywhere in its own span: the matcher
+ * only resolves evidence through a bare identifier or a non-computed
+ * member chain (`resolveReceiverType`'s two supported `ParsedExpr`
+ * shapes), and the call itself takes zero arguments. So `ctx.getJS` of
+ * that one sub-node — which strips only type syntax — is guaranteed
+ * byte-identical to its raw source slice, and thus guaranteed to appear
+ * verbatim as a contiguous substring of `text` regardless of unrelated
+ * type-stripping elsewhere in the enclosing expression. String spans in
+ * `text` are protected first (`createTemplateAwareStringProtector` — both
+ * quoted strings AND template-literal *static* segments, leaving `${…}`
+ * interpolations exposed) so a coincidentally-identical string constant —
+ * e.g. a backtick `` `createdAt.toISOString()` `` sitting before the real
+ * call — can never be mistaken for a call site by the non-global
+ * `.replace`.
+ */
+function lowerDateCalls(text: string, expr: ts.Node, ctx: TransformContext): string {
+  const matcher = getDateLoweringMatcher(ctx)
+  if (!matcher) return text
+
+  const candidates: ts.CallExpression[] = []
+  function visit(n: ts.Node) {
+    if (
+      ts.isCallExpression(n) &&
+      n.arguments.length === 0 &&
+      ts.isPropertyAccessExpression(n.expression) &&
+      !n.expression.questionDotToken &&
+      DATE_METHODS.has(n.expression.name.text)
+    ) {
+      candidates.push(n)
+    }
+    ts.forEachChild(n, visit)
+  }
+  visit(expr)
+  if (candidates.length === 0) return text
+
+  const { protect, restore } = createTemplateAwareStringProtector()
+  let result = protect(text)
+  for (const call of candidates) {
+    const propAccess = call.expression as ts.PropertyAccessExpression
+    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)
+    // Replacer-function form: a `$` sequence in `receiverText` (a prop named
+    // `$1`, say) would otherwise be reinterpreted as a `String.replace`
+    // pattern token and corrupt the output (repo precedent, #2285).
+    result = result.replace(matchText, () => `date(${receiverText}, "${op}")`)
+  }
+  return restore(result)
+}
+
 /**
  * Rewrite bare destructured prop references in expression text.
  * Thin wrapper that caches prop names on ctx and delegates to the shared core.
  * Returns undefined if no rewriting is needed (SolidJS-style or no props).
  */
 function rewriteBarePropRefs(text: string, expr: ts.Node, ctx: TransformContext): string | undefined {
+  // #2292: lower a Date-typed prop's catalogued accessor call BEFORE the
+  // bare-prop-name rewrite below, so the receiver identifier still picks
+  // up the usual `_p.` prefix (destructured mode) or falls through to the
+  // CSR template emitter's separate `props.` → `_p.` rewrite
+  // (`html-template.ts`'s `transformExpr`, props-object mode). Runs
+  // unconditionally — ahead of the `propNames` gate — because Date
+  // evidence comes from `ctx.analyzer.propsType`, independent of whether
+  // this component destructures its props.
+  const dateLowered = lowerDateCalls(text, expr, ctx)
   let propNames = getDestructuredPropNames(ctx)
-  if (!propNames) return undefined
+  if (!propNames) return dateLowered === text ? undefined : dateLowered
   // #2222: a name bound as an enclosing loop callback's item/index param
   // refers to the loop binding, not the prop, at THIS transform position —
   // `ctx.loopParams` is the live loop-param set (destructured binding
@@ -303,7 +428,7 @@ function rewriteBarePropRefs(text: string, expr: ts.Node, ctx: TransformContext)
   // its set on ctx and must not be mutated.
   if (ctx.loopParams.size > 0) {
     const filtered = new Set([...propNames].filter(n => !ctx.loopParams.has(n)))
-    if (filtered.size === 0) return undefined
+    if (filtered.size === 0) return dateLowered === text ? undefined : dateLowered
     propNames = filtered
   }
   // #1425: union any prop refs that `expr` reaches via branch-local
@@ -316,7 +441,7 @@ function rewriteBarePropRefs(text: string, expr: ts.Node, ctx: TransformContext)
   // `_branchScopePropDeps` at branch entry; here we just walk `expr`
   // for references to those locals and union the matching dep sets.
   const extraPropRefs = collectBranchLocalPropRefsViaSubstitution(expr, ctx)
-  return rewriteBarePropRefsCore(text, expr, propNames, extraPropRefs)
+  return rewriteBarePropRefsCore(dateLowered, expr, propNames, extraPropRefs)
 }
 
 /**
@@ -4493,6 +4618,37 @@ function getAttributeValue(attr: ts.JsxAttribute, ctx: TransformContext): AttrVa
       }
     }
 
+    // Bare `attr={record[key]}` (#2300): an element access whose base is a
+    // local const object-literal `Record` indexed by a prop, written directly
+    // as ANY string-attribute value rather than inside a template literal
+    // (`class={record[key]}` is the motivating class-composition case, but this
+    // is attribute-agnostic — it fires for any qualifying attribute). Lift it
+    // into the SAME `lookup` part the `${record[key]}` template-literal form
+    // produces (`tryResolveTemplateSpanFromConst` handles both), so every
+    // adapter renders it through the shared, already-working lookup path
+    // instead of a raw index-access that the typed / strict backends (Go,
+    // minijinja, ERB, Jinja) mishandle for a function-local const — it is not
+    // a prop field, so those emit an unpopulated `.Record`/nil lookup and the
+    // value renders empty (or errors). `tryResolveTemplateSpanFromConst`
+    // returns null for anything but the `IDENT[KEY]` → all-string-`Record`
+    // shape, so any other element access falls through to the bare-expression
+    // path unchanged.
+    // Only a DYNAMIC key qualifies (a prop reference, the #2300 shape). A
+    // static string / numeric literal key (`paths['icon']`) stays on the
+    // bare-expression path — the adapters already resolve a constant-key index,
+    // and it must remain a plain `expression` attr (jsx-to-ir regression pin),
+    // not a single-case `lookup`.
+    if (
+      ts.isElementAccessExpression(expr) &&
+      !ts.isStringLiteralLike(expr.argumentExpression) &&
+      !ts.isNumericLiteral(expr.argumentExpression)
+    ) {
+      const parts = tryResolveTemplateSpanFromConst(expr, ctx)
+      if (parts) {
+        return AttrValueOf.template(parts)
+      }
+    }
+
     // `className={classes}` where `classes` is a local const bound to
     // a template literal — resolve the template literal here and let
     // adapters render the structured form. This is the cva-style

package/src/rich-type-evidence.ts

@@ -78,7 +78,7 @@ function isNullishArm(t: TypeInfo): boolean {
   return t.kind === 'unknown' && (t.raw === 'null' || t.raw === 'undefined')
 }
 
-function stripUnion(type: TypeInfo | null): TypeInfo | null {
+export function stripUnion(type: TypeInfo | null): TypeInfo | null {
   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
@@ -93,7 +93,7 @@ function stripUnion(type: TypeInfo | null): TypeInfo | null {
  * reference, which `typeNodeToTypeInfo` intentionally resolves to
  * `{ kind: 'interface', raw }` with no member walk of its own.
  */
-function derefNamedType(type: TypeInfo, meta: EvidenceMetadata): TypeInfo {
+export function derefNamedType(type: TypeInfo, meta: EvidenceMetadata): TypeInfo {
   if (type.kind !== 'interface') return type
   if (type.properties && type.properties.length > 0) return type
   const name = baseTypeName(type.raw)