@pyreon/elements 0.24.4 → 0.24.6

package/src/helpers/Wrapper/styled.ts

@@ -1,64 +0,0 @@
-/**
- * Styled component for the Element wrapper layer. Handles responsive
- * block/inline-flex display, direction, alignment, and custom CSS injection.
- * Includes special handling for the `parentFix` / `childFix` flags that
- * split flex behavior across two DOM nodes for button/fieldset/legend
- * elements where a single flex container is insufficient.
- */
-import { config } from '@pyreon/ui-core'
-import { alignContent, extendCss, makeItResponsive } from '@pyreon/unistyle'
-import type { ResponsiveStylesCallback } from '../../types'
-import type { StyledProps } from './types'
-
-const { styled, css, component } = config
-
-const childFixCSS = `
-  display: flex;
-  flex: 1;
-  width: 100%;
-  height: 100%;
-`
-
-const parentFixCSS = `
-  flex-direction: column;
-`
-
-export const styles: ResponsiveStylesCallback = ({ theme: t, css: cssFn }) => cssFn`
-  ${alignContent({
-    direction: t.direction,
-    alignX: t.alignX,
-    alignY: t.alignY,
-  })};
-
-  /*
-   * Always emit a value for the block-related properties so a responsive
-   * theme that flips from \`block: true\` at one breakpoint to \`block: false\`
-   * at another resets cleanly. Previously \`align-self\` / \`width\` / \`height\`
-   * were only set when the truthy branch matched, which left the prior
-   * breakpoint's values cascading through.
-   */
-  ${`align-self: ${t.block ? 'stretch' : 'auto'};
-     width: ${t.block ? '100%' : 'auto'};
-     height: ${t.alignY === 'block' ? '100%' : 'auto'};`};
-
-  ${!t.childFix && `display: ${t.block ? 'flex' : 'inline-flex'};`};
-  ${t.parentFix && parentFixCSS};
-
-  ${t.extraStyles && extendCss(t.extraStyles as Parameters<typeof extendCss>[0])};
-`
-
-const platformCSS = `box-sizing: border-box;`
-
-export default styled(component, { layer: 'elements' })`
-  position: relative;
-  ${platformCSS};
-
-  ${(({ $childFix }: StyledProps) => $childFix && childFixCSS) as any};
-
-  ${makeItResponsive({
-    key: '$element',
-    styles,
-    css,
-    normalize: true,
-  })};
-`

package/src/helpers/Wrapper/types.ts

@@ -1,56 +0,0 @@
-import type { VNodeChild } from '@pyreon/core'
-import type { HTMLTags } from '@pyreon/ui-core'
-import type {
-  AlignX,
-  AlignY,
-  ContentAlignX,
-  ContentAlignY,
-  ContentBoolean,
-  ContentDirection,
-  Css,
-  Direction,
-  ExtendCss,
-  ResponsiveBoolType,
-} from '../../types'
-
-export type Reference = unknown
-
-export interface Props {
-  children: VNodeChild | VNodeChild[]
-  tag: HTMLTags | undefined
-  block: ResponsiveBoolType | undefined
-  isInline: boolean | undefined
-  direction: Direction | undefined
-  alignX: AlignX | undefined
-  alignY: AlignY | undefined
-  equalCols: ResponsiveBoolType | undefined
-  extendCss: ExtendCss | undefined
-  dangerouslySetInnerHTML: { __html: string } | undefined
-}
-
-export interface StyledProps {
-  $element: {
-    direction: Direction
-    alignX: AlignX
-    alignY: AlignY
-    equalCols: ResponsiveBoolType
-  } & Partial<{
-    block: ResponsiveBoolType
-    extraStyles: ExtendCss
-    childFix: true
-    parentFix: true
-  }>
-  $childFix?: true
-}
-
-export type ThemeProps = {
-  direction: ContentDirection
-  alignX: ContentAlignX
-  alignY: ContentAlignY
-  equalCols: ContentBoolean
-} & Partial<{
-  block: ContentBoolean
-  extraStyles: Css
-  childFix: true
-  parentFix: true
-}>

package/src/helpers/Wrapper/utils.ts

@@ -1,7 +0,0 @@
-import { INLINE_ELEMENTS_FLEX_FIX } from './constants'
-
-type IsWebFixNeeded = (tag?: string) => boolean
-export const isWebFixNeeded: IsWebFixNeeded = (tag) => {
-  if (tag && tag in INLINE_ELEMENTS_FLEX_FIX) return true
-  return false
-}

package/src/helpers/index.ts

@@ -1,4 +0,0 @@
-import Content from './Content'
-import Wrapper from './Wrapper'
-
-export { Content, Wrapper }

package/src/helpers/internElementBundle.ts

@@ -1,37 +0,0 @@
-/**
- * Module-scope intern cache for `$element` bundles passed to Wrapper's styled
- * component. Same primitive prop tuple → same object identity, so the styler's
- * `elClassCache` (added 2026-Q2 alongside this) hits and skips the resolve
- * pipeline. Analogous to `@pyreon/rocketstyle`'s dimension-prop memo (PR #344)
- * but at the layer below — covers non-rocketstyle Element / Wrapper / Text usage
- * AND the residual styled wrappers under any rocketstyle component.
- *
- * Cache key is a JSON-stringified shallow snapshot of the bundle. LRU-bound at
- * 256 entries; oldest-first eviction. Bail (return the input as-is, no cache)
- * when any value is a function (signal accessor) or a non-string object (CSS
- * callback / CSSResult / nested object) — those cannot be safely round-tripped
- * through JSON without losing identity guarantees.
- */
-const _bundleCache = new Map<string, Record<string, unknown>>()
-const BUNDLE_CAP = 256
-
-export const internElementBundle = <T extends Record<string, unknown>>(bundle: T): T => {
-  for (const k in bundle) {
-    const v = bundle[k]
-    if (typeof v === 'function') return bundle
-    if (v != null && typeof v === 'object') return bundle
-  }
-  const key = JSON.stringify(bundle)
-  const existing = _bundleCache.get(key)
-  if (existing) {
-    _bundleCache.delete(key)
-    _bundleCache.set(key, existing)
-    return existing as T
-  }
-  if (_bundleCache.size >= BUNDLE_CAP) {
-    const oldest = _bundleCache.keys().next().value
-    if (oldest !== undefined) _bundleCache.delete(oldest)
-  }
-  _bundleCache.set(key, bundle)
-  return bundle
-}

package/src/helpers/isPyreonComponent.ts

@@ -1,46 +0,0 @@
-/**
- * Detect whether a function value is a framework component (created via
- * `rocketstyle()` or one of `@pyreon/elements`' component factories), as
- * opposed to a plain reactive-accessor function.
- *
- * Used by `Element` / `Content` `resolveSlot` to discriminate between
- *   `beforeContent={Header}` — component-reference shorthand, MUST mount
- *     as `h(Component, null)` so the framework HOC's
- *     `removeUndefinedProps(props)` / `splitProps(props)` get the
- *     default-filled props object, not bare `undefined`.
- *   `beforeContent={() => <Header />}` — reactive accessor, MUST be called
- *     so its body's signal reads land inside the enclosing
- *     `mountReactive` effect.
- *
- * Both are `typeof === 'function'`. The discriminator is the marker
- * attached by each factory:
- *   - `IS_ROCKETSTYLE` — set by `@pyreon/rocketstyle` (`rocketstyle.ts:527`,
- *     `542`) on every `rocketstyle(...).config(...)` chain end-point.
- *   - `PYREON__COMPONENT` — set by every `@pyreon/elements` component
- *     factory (Element, Text, List, Portal, Overlay, Util, Content,
- *     Wrapper, …).
- *   - `pkgName` — same components also carry this; checked as a fallback
- *     in case a third-party package mirrors the elements convention.
- *
- * Plain bare-function components without any marker (e.g.
- * `const MyComp = () => <div />`) intentionally take the accessor path
- * — they don't access props, so calling them with no args is safe AND
- * returns the VNode the renderer expects. The marker check ONLY rescues
- * components whose HOC pipelines REQUIRE props to be defined.
- *
- * Reference: regression report on 0.24.3 / PR #839 — `resolveSlot` called
- * any function-valued slot bare, crashing real consumers (bokisch.com
- * SSG build: `Prerendered 0 page(s) + 404.html`) that used the
- * `beforeContent={Component}` shorthand documented since the original
- * Element API.
- */
-export function isPyreonComponent(value: unknown): boolean {
-  if (typeof value !== 'function') return false
-  // `Object.hasOwn` (not `in`) so a marker on a parent prototype doesn't
-  // count — the marker is always an own-property in the factories.
-  return (
-    Object.hasOwn(value, 'IS_ROCKETSTYLE') ||
-    Object.hasOwn(value, 'PYREON__COMPONENT') ||
-    Object.hasOwn(value, 'pkgName')
-  )
-}

package/src/index.ts

@@ -1,42 +0,0 @@
-import { Provider } from '@pyreon/unistyle'
-
-export type { ElementProps, PyreonElement } from './Element'
-export { Element } from './Element'
-export type {
-  ChildrenProps as IteratorChildrenProps,
-  ElementType,
-  ExtendedProps,
-  LooseProps as IteratorLooseProps,
-  MaybeNull,
-  ObjectProps as IteratorObjectProps,
-  ObjectValue,
-  Props as IteratorProps,
-  PropsCallback,
-  SimpleProps as IteratorSimpleProps,
-  SimpleValue,
-} from './helpers/Iterator'
-export { default as Iterator } from './helpers/Iterator'
-export type { ListProps } from './List'
-export { List } from './List'
-export type { OverlayProps, UseOverlayProps } from './Overlay'
-export { Overlay, OverlayProvider, useOverlay } from './Overlay'
-export type { PortalProps } from './Portal'
-export { Portal } from './Portal'
-export type { TextProps } from './Text'
-export { Text } from './Text'
-export type {
-  AlignX,
-  AlignY,
-  Content,
-  ContentBoolean,
-  Direction,
-  ExtendCss,
-  InnerRef,
-  PyreonStatic,
-  Responsive,
-  ResponsiveBoolType,
-} from './types'
-export type { UtilProps } from './Util'
-export { Util } from './Util'
-
-export { Provider }

package/src/manifest.ts

@@ -1,190 +0,0 @@
-import { defineManifest } from '@pyreon/manifest'
-
-export default defineManifest({
-  name: '@pyreon/elements',
-  title: 'Base Primitives',
-  tagline:
-    'Five foundational layout primitives — Element, Text, List, Overlay, Portal — plus the useOverlay positioning hook and the Iterator data helper',
-  description:
-    "The structural layer every styled / rocketstyle component renders through. `Element` is the responsive flexbox block (direction / alignX / alignY / gap / block + before/after content slots); `Text` is inline typography; `List` is a flowing-children container with the four-overload Iterator data API; `Overlay` is a positioned layer with backdrop driven by `useOverlay` (viewport flip, ESC, click-outside, scroll tracking, hover delay — never reimplement this); `Portal` renders children outside the DOM hierarchy into a per-instance wrapper. Element has a 2026-Q2 simple-path fast path that inlines the Wrapper helper for non-compound, non-needsFix tags (31-45% faster mount) — its rendered VNode then exposes the HTML tag as `props.as` and layout under `props.$element.{...}` instead of flat props.",
-  category: 'browser',
-  features: [
-    'Element — responsive flexbox block: direction / alignX / alignY / gap / block, beforeContent / afterContent slots, equalBeforeAfter (ResizeObserver-tracked)',
-    'Text — inline typography primitive',
-    'List — flowing-children container; data via the four-overload Iterator API',
-    'Overlay + useOverlay — positioned layer (dropdown/modal/tooltip) with viewport flip, ESC, click-outside, scroll tracking, hover delay',
-    'Portal — renders children into a per-instance wrapper inside a DOMLocation (default document.body)',
-    'Iterator — Simple / Object / Children / Loose overloads keep primitive-vs-object iteration modes type-safe',
-    'Util — bare utility primitive; Provider re-exported from @pyreon/unistyle',
-    'Simple-path fast path: non-compound Elements skip a component invocation + splitProps + mountChild',
-  ],
-  api: [
-    {
-      name: 'Element',
-      kind: 'component',
-      signature: 'Element(props: ElementProps): VNodeChild',
-      summary:
-        "The responsive flexbox block primitive every layout-bearing component renders through. Layout props live here (NOT in a styler `.theme()`): `direction` (`inline` | `rows` | `reverseInline` | `reverseRows` — note `row` is INVALID), `alignX`, `alignY`, `gap`, `block`, plus `beforeContent` / `afterContent` slot wrappers and `equalBeforeAfter` (equalizes the slot widths on mount AND keeps them equal via ResizeObserver). The 2026-Q2 simple-path fast path inlines the Wrapper for non-compound, non-needsFix tags: the rendered VNode then exposes the HTML tag as `props.as` and layout under `props.$element.{direction,alignX,alignY,block,equalCols,extraStyles}` rather than flat props (styled-components consumers see no change since `as` is the canonical tag selector).",
-      example: `import { Element } from "@pyreon/elements"
-
-<Element tag="section" direction="rows" gap="md" alignX="center">
-  <Header />
-  <Body />
-</Element>`,
-      mistakes: [
-        'Using `direction="row"` — invalid; the values are `inline` / `rows` / `reverseInline` / `reverseRows`',
-        'Putting layout props in a styler `.theme()` callback — `direction` / `alignX` / `alignY` / `gap` / `block` are Element ATTRS, not CSS; theme is for colors / spacing / borders',
-        'Reading flat `props.direction` on a simple-path Element in a test or styled consumer — the fast path moves layout to `props.$element.*` and the tag to `props.as`; read both shapes via a helper',
-        'Passing children to a void `tag` (`hr` / `img` / `br` / `input`) — Element correctly drops them; do not rely on a children slot for void tags',
-        'Relying on `equalBeforeAfter` measuring async slot content where `ResizeObserver` is undefined (older runtimes / SSR) — it falls back to the one-shot mount measurement there',
-      ],
-      seeAlso: ['Text', 'List', 'Portal'],
-    },
-    {
-      name: 'Text',
-      kind: 'component',
-      signature: 'Text(props: TextProps): VNodeChild',
-      summary:
-        'Inline typography primitive — the text counterpart to `Element`. Carries typography props and renders an inline element; use it for runs of text that need the design-system typography contract rather than a raw `<span>`. Like `Element`, visual styling belongs in the styler/rocketstyle layer; `Text` owns the inline-flow structure.',
-      example: `import { Text } from "@pyreon/elements"
-
-<Text tag="span">Inline label</Text>`,
-      seeAlso: ['Element'],
-    },
-    {
-      name: 'List',
-      kind: 'component',
-      signature: 'List(props: ListProps): VNodeChild',
-      summary:
-        'A flowing-children container (`ul` / `ol` / `dl` / custom) built on the Iterator data API. Render children directly OR drive it with `data` + a `component` renderer. Inherits Iterator’s four typed overloads (Simple / Object / Children / Loose) and additionally blocks Element-only `label` / `content` props at the type level.',
-      example: `import { List } from "@pyreon/elements"
-
-<List tag="ul" data={items()} component={(item) => <li>{item.name}</li>} />`,
-      mistakes: [
-        'Mixing primitive and object entries in `data` (`[1, {id:1}, null]`) — primitive arrays and object arrays are mutually exclusive iteration modes; the typed overloads reject the mix for direct callers',
-        'Passing `valueName` with an object-array `data` — `valueName` is a Simple-mode (primitive) prop only',
-        'Passing `children` AND `data`/`component` — Children mode and Object mode are distinct overloads; pick one',
-      ],
-      seeAlso: ['Iterator', 'Element'],
-    },
-    {
-      name: 'Overlay',
-      kind: 'component',
-      signature: 'Overlay(props: OverlayProps): VNodeChild',
-      summary:
-        'A positioned layer (dropdown / modal / tooltip / popover) with an optional backdrop, driven internally by `useOverlay`. It handles viewport flipping, ESC-to-close, click-outside, scroll tracking, and hover delay — do NOT reimplement any of that in a primitive; compose `Overlay` (or `useOverlay`) instead. Renders through `Portal` so the layer escapes overflow/stacking contexts.',
-      example: `import { Overlay } from "@pyreon/elements"
-
-<Overlay isOpen={open()} type="dropdown" align="bottom" onClose={() => open.set(false)}>
-  <Menu />
-</Overlay>`,
-      mistakes: [
-        'Hand-rolling positioning / flip / click-outside / ESC logic in a tooltip or dropdown primitive — `useOverlay` already owns all of it; reimplementing drifts from the shared behavior',
-        'Reading the rendered overlay as `document.body.firstChild` — it renders through `Portal` into a per-instance wrapper; traverse the wrapper, not body’s direct child',
-      ],
-      seeAlso: ['useOverlay', 'OverlayProvider', 'Portal'],
-    },
-    {
-      name: 'useOverlay',
-      kind: 'hook',
-      signature:
-        'useOverlay(props?: Partial<UseOverlayProps>): { isOpen, open, close, toggle, triggerProps, overlayProps, /* … */ }',
-      summary:
-        'The positioning + interaction engine `Overlay` is built on, exposed for headless consumers. Options: `openOn` / `closeOn` (`click` | `hover` | …), `type` (`dropdown` | `modal` | …), `position` (`fixed` | …), `align` + `alignX` / `alignY` + `offsetX` / `offsetY`, `closeOnEsc`, `hoverDelay`, `throttleDelay`, `parentContainer`, `disabled`, `onOpen` / `onClose`. SSR-safe: the internal positioning helpers early-return under no-`window` so the contract is documented at the call site rather than crashing on the server.',
-      example: `import { useOverlay } from "@pyreon/elements"
-
-const o = useOverlay({ openOn: "hover", type: "tooltip", hoverDelay: 150 })
-// spread o.triggerProps on the anchor, o.overlayProps on the floating layer`,
-      mistakes: [
-        'Passing `align` as a function accessor — it is a value option, not a signal accessor; let the compiler wrap reactive values',
-        'Expecting positioning to run during SSR — the helpers are guarded and no-op without `window`; positioning happens post-mount on the client',
-        'Reaching for `addEventListener` for outside-click / scroll instead of letting `useOverlay` own the listener lifecycle — it self-cleans on unmount',
-      ],
-      seeAlso: ['Overlay', 'OverlayProvider'],
-    },
-    {
-      name: 'OverlayProvider',
-      kind: 'component',
-      signature: 'OverlayProvider(props: { children?: VNodeChild }): VNodeChild',
-      summary:
-        'Context provider that lets nested overlays coordinate (shared root, stacking, outside-click scoping). `useOverlay` reads it via `useOverlayContext`. Marked `nativeCompat` so it works correctly inside `@pyreon/{react,preact,vue,solid}-compat` apps (its `provide()` runs in Pyreon’s setup frame, not the compat wrapper accessor).',
-      example: `import { OverlayProvider } from "@pyreon/elements"
-
-<OverlayProvider>
-  <App />
-</OverlayProvider>`,
-      seeAlso: ['useOverlay', 'Overlay'],
-    },
-    {
-      name: 'Portal',
-      kind: 'component',
-      signature: 'Portal(props: PortalProps): VNodeChild',
-      summary:
-        'Renders children OUTSIDE the parent DOM hierarchy — into a PER-INSTANCE wrapper element (default `<div>`, configurable via `tag`) created inside a `DOMLocation` (default `document.body`). Multiple Portals sharing a location each get their OWN wrapper so children never intermingle, which gives cleanup isolation when several modals / tooltips share a portal root.',
-      example: `import { Portal } from "@pyreon/elements"
-
-<Portal>
-  <Modal />
-</Portal>`,
-      mistakes: [
-        'Asserting `document.body.firstChild === modalRoot` in a test — the Portal nests one level deeper; query the per-instance wrapper (`document.body.querySelector("[data-…]").parentElement`) instead',
-        'Assuming all Portals share one container — each instance gets its own wrapper inside the DOMLocation; they do not merge',
-      ],
-      seeAlso: ['Overlay', 'Element'],
-    },
-    {
-      name: 'Iterator',
-      kind: 'component',
-      signature: 'Iterator<T>(props: IteratorProps<T>): VNodeChild',
-      summary:
-        'The data-iteration helper backing `List` (default export of `helpers/Iterator`). FOUR typed overloads keep iteration modes honest: `SimpleProps<T>` (primitive arrays — `valueName` allowed), `ObjectProps<T>` (object arrays — `valueName` and `children` FORBIDDEN), `ChildrenProps` (no data/component, only children), and a `LooseProps` fallback that exists so rocketstyle/attrs forwarding patterns (`<Iterator {...wrapperProps} />`) bind without a per-call-site overload error. The discriminator picks the overload via `unknown extends T ? Loose : T extends SimpleValue ? Simple : T extends ObjectValue ? Object : Children`.',
-      example: `import Iterator from "@pyreon/elements/helpers/Iterator"
-
-<Iterator data={users()} component={(u) => <Row user={u} />} />`,
-      mistakes: [
-        'Mixed-shape `data` (`[1, {id:1}, null]`) — primitive and object iteration are mutually exclusive; the narrow overloads reject it (the Loose fallback only catches forwarding-pattern shapes)',
-        '`valueName` with object-array `data` — Simple-mode only; ObjectProps forbids it',
-        '`children` together with `data`/`component` — Children and Object are distinct overloads; the runtime picks the mode by which props are populated, but the types steer you to one',
-      ],
-      seeAlso: ['List'],
-    },
-    {
-      name: 'Util',
-      kind: 'component',
-      signature: 'Util(props: UtilProps): VNodeChild',
-      summary:
-        'A bare utility primitive — the minimal structural wrapper when you need an Element-family node without layout semantics (no flex direction / align). Use it for thin passthrough containers where `Element` would impose unwanted flex defaults.',
-      example: `import { Util } from "@pyreon/elements"
-
-<Util>{children}</Util>`,
-      seeAlso: ['Element'],
-    },
-    {
-      name: 'Provider',
-      kind: 'component',
-      signature: 'Provider(props: { children?: VNodeChild }): VNodeChild',
-      summary:
-        'Re-exported from `@pyreon/unistyle` for convenience (responsive/breakpoint context). Most apps mount the unified `<PyreonUI>` from `@pyreon/ui-core` instead, which wires this internally — reach for the bare `Provider` only outside the `ui-core` provider tree.',
-      example: `import { Provider } from "@pyreon/elements"`,
-      seeAlso: ['Element'],
-    },
-  ],
-  gotchas: [
-    {
-      label: 'Layout in attrs, not theme',
-      note: 'Element/Text/List layout props (`direction`, `alignX`, `alignY`, `gap`, `block`, `tag`) are primitive ATTRS — they target the inner flex wrapper. Colors / spacing / borders / shadows belong in the styler or rocketstyle `.theme()` layer. `direction` accepts `inline` / `rows` / `reverseInline` / `reverseRows` — `row` is invalid.',
-    },
-    {
-      label: 'Simple-path fast path changed the VNode shape',
-      note: 'A non-compound, non-needsFix Element renders a VNode exposing the HTML tag as `props.as` and layout under `props.$element.{direction,alignX,alignY,block,equalCols,extraStyles}` — NOT flat `props.{tag,direction,…}`. Production styled-components consumers are unaffected (`as` is canonical); test/introspection code must read both shapes.',
-    },
-    {
-      label: 'Overlay positioning is centralised',
-      note: 'Viewport flip, ESC, click-outside, scroll tracking, hover delay all live in `useOverlay`. Never reimplement them in a tooltip / dropdown / popover primitive — compose `Overlay` or `useOverlay`. The positioning helpers are SSR-guarded (no-op without `window`).',
-    },
-    {
-      label: 'Portal nests a per-instance wrapper',
-      note: '`Portal` renders into its OWN wrapper element inside the DOMLocation (default `document.body`), not directly as a body child. DOM assertions must traverse one extra level; multiple Portals do not share a container.',
-    },
-  ],
-})

package/src/tests/manifest-snapshot.test.ts

@@ -1,45 +0,0 @@
-import {
-  renderApiReferenceEntries,
-  renderLlmsFullSection,
-  renderLlmsTxtLine,
-} from '@pyreon/manifest'
-import manifest from '../manifest'
-
-describe('gen-docs — elements snapshot', () => {
-  it('renders a llms.txt bullet starting with the package prefix', () => {
-    const line = renderLlmsTxtLine(manifest)
-    expect(line.startsWith('- @pyreon/elements —')).toBe(true)
-  })
-
-  it('renders a llms-full.txt section with the right header', () => {
-    const section = renderLlmsFullSection(manifest)
-    expect(section.startsWith('## @pyreon/elements —')).toBe(true)
-    expect(section).toContain('```typescript')
-  })
-
-  it('renders MCP api-reference entries for every api[] item', () => {
-    const record = renderApiReferenceEntries(manifest)
-    expect(Object.keys(record).sort()).toEqual([
-      'elements/Element',
-      'elements/Iterator',
-      'elements/List',
-      'elements/Overlay',
-      'elements/OverlayProvider',
-      'elements/Portal',
-      'elements/Provider',
-      'elements/Text',
-      'elements/Util',
-      'elements/useOverlay',
-    ])
-  })
-
-  it('carries the layout-in-attrs foot-gun on the Element entry', () => {
-    const record = renderApiReferenceEntries(manifest)
-    expect(record['elements/Element']?.mistakes).toContain('Using `direction="row"` — invalid')
-  })
-
-  it('flags the Portal per-instance-wrapper assertion trap', () => {
-    const record = renderApiReferenceEntries(manifest)
-    expect(record['elements/Portal']?.mistakes).toContain('document.body.firstChild')
-  })
-})

package/src/types.ts

@@ -1,112 +0,0 @@
-/**
- * Shared type definitions for the elements package. Provides responsive
- * value types (single | array | breakpoint-map) for layout props like
- * alignment and direction, plus utility types for merging prop objects.
- */
-import type { ComponentFn } from '@pyreon/core'
-import type { BreakpointKeys, config, render } from '@pyreon/ui-core'
-import type { MakeItResponsiveStyles } from '@pyreon/unistyle'
-
-export type ResponsiveStylesCallback = MakeItResponsiveStyles
-
-type ExtractNullableKeys<T> = {
-  [P in keyof T as T[P] extends null | undefined ? never : P]: T[P]
-}
-
-type Id<T> = T extends infer U ? { [K in keyof U]: U[K] } : never
-
-type SpreadTwo<L, R> = Id<Pick<L, Exclude<keyof L, keyof R>> & R>
-
-type Spread<A extends readonly [...any]> = A extends [infer L, ...infer R]
-  ? SpreadTwo<L, Spread<R>>
-  : unknown
-
-export type MergeTypes<A extends readonly [...any]> = ExtractNullableKeys<Spread<A>>
-
-export type InnerRef = HTMLElement | ((el: HTMLElement | null) => void) | null
-
-export type CssCallback = (css: typeof config.css) => ReturnType<typeof css>
-
-export type Css = CssCallback | ReturnType<typeof config.css> | string
-
-export type Content = Parameters<typeof render>['0']
-
-export type ContentAlignX = 'left' | 'center' | 'right' | 'spaceBetween' | 'spaceAround' | 'block'
-
-export type ContentAlignY = 'top' | 'center' | 'bottom' | 'spaceBetween' | 'spaceAround' | 'block'
-
-export type ContentDirection = 'inline' | 'rows' | 'reverseInline' | 'reverseRows'
-
-export type ContentBoolean = boolean
-export type ContentSimpleValue = string | number
-
-export type Ref = HTMLElement
-
-export type AlignY =
-  | ContentAlignY
-  | ContentAlignY[]
-  | Partial<Record<BreakpointKeys, ContentAlignY>>
-
-export type AlignX =
-  | ContentAlignX
-  | ContentAlignX[]
-  | Partial<Record<BreakpointKeys, ContentAlignX>>
-
-export type Direction =
-  | ContentDirection
-  | ContentDirection[]
-  | Partial<Record<BreakpointKeys, ContentDirection>>
-
-export type ResponsiveBoolType =
-  | ContentBoolean
-  | ContentBoolean[]
-  | Partial<Record<BreakpointKeys, ContentBoolean>>
-
-export type Responsive =
-  | ContentSimpleValue
-  | ContentSimpleValue[]
-  | Partial<Record<BreakpointKeys, number | string>>
-
-export type ExtendCss = Css | Css[] | Partial<Record<BreakpointKeys, Css>>
-
-/**
- * Extracts the props type from a Pyreon component function — multi-overload
- * aware. Matches up to 4 call signatures and produces the UNION of their
- * first-argument types. Iterator / List ship 3-overload primitives whose
- * LAST overload is `ChildrenProps` (the loosest); without overload-aware
- * extraction, `ExtractProps<Iterator>` returned just `ChildrenProps` and
- * lost `SimpleProps<T>` / `ObjectProps<T>` shapes. Mirrors vitus-labs
- * PR #222.
- *
- * Kept in sync with the copies in `@pyreon/core` / `@pyreon/attrs` /
- * `@pyreon/rocketstyle`.
- */
-export type ExtractProps<TComponentOrTProps> = TComponentOrTProps extends {
-  (props: infer P1, ...args: any): any
-  (props: infer P2, ...args: any): any
-  (props: infer P3, ...args: any): any
-  (props: infer P4, ...args: any): any
-}
-  ? P1 | P2 | P3 | P4
-  : TComponentOrTProps extends {
-        (props: infer P1, ...args: any): any
-        (props: infer P2, ...args: any): any
-        (props: infer P3, ...args: any): any
-      }
-    ? P1 | P2 | P3
-    : TComponentOrTProps extends {
-          (props: infer P1, ...args: any): any
-          (props: infer P2, ...args: any): any
-        }
-      ? P1 | P2
-      : TComponentOrTProps extends ComponentFn<infer TProps>
-        ? TProps
-        : TComponentOrTProps
-
-export type PyreonComponent<P extends Record<string, any> = {}> = ComponentFn<P> & PyreonStatic
-
-export interface PyreonStatic {
-  displayName?: string | undefined
-  pkgName?: string
-  PYREON__COMPONENT?: `@pyreon/${string}`
-}

package/src/utils.ts

@@ -1,5 +0,0 @@
-// `import.meta.env.DEV` is provided by Vite/Rolldown at build time and
-// literal-replaced so prod bundles tree-shake the dev branch to zero bytes.
-// Typed through a narrowing interface so downstream packages don't need
-// `vite/client` in their tsconfigs to type-check this file transitively.
-export const IS_DEVELOPMENT: boolean = process.env.NODE_ENV !== 'production'