@pilotiq/pilotiq 0.24.1 → 0.24.2

package/src/schema/Section.ts

@@ -1,160 +0,0 @@
-import { Element } from './Element.js'
-import type { Action } from '../actions/Action.js'
-
-/**
- * Container that groups related Elements (typically Fields) under a heading
- * with optional description. Supports multi-column layouts and a collapsible
- * disclosure pattern. Mirrors panels' `Section` element.
- *
- * Used inside Forms to group related inputs, but composes anywhere a
- * container Element fits (e.g. inside a Card or another Section).
- *
- * Plan #8 polish: `icon / badge / aside / compact / persistCollapsed`.
- */
-export class Section extends Element {
-  private _description?: string
-  private _icon?: string
-  private _badge?: string
-  private _columns: 1 | 2 | 3 = 1
-  private _collapsible = false
-  private _defaultCollapsed = false
-  private _aside = false
-  private _compact = false
-  private _dense = false
-  private _secondary = false
-  private _persistCollapsed = false
-  private _persistKey?: string
-  private _afterHeader?: Action[]
-  /**
-   * Cascading `inlineLabel` default for descendant `Field`s. Read by
-   * `resolveSchema.deriveChildContext`. Per-field
-   * `Field.inlineLabel(...)` overrides; a more deeply-nested
-   * `Section.inlineLabel(...)` overrides for its subtree.
-   */
-  private _inlineLabel?: boolean
-
-  private constructor(private _title?: string) {
-    super()
-  }
-
-  static make(title?: string): Section {
-    return new Section(title)
-  }
-
-  description(d: string): this { this._description = d; return this }
-
-  /**
-   * Icon shown next to the section title. Resolved through the icon
-   * registry (`registerIcons({ name: Component })`) at render. Schema-time
-   * icons are string-only — component-typed icons are reserved for
-   * Resource/Global/Page where the Vite plugin can mint a manifest key.
-   */
-  icon(name: string): this { this._icon = name; return this }
-
-  /** Right-aligned pill in the section header. Pure cosmetic. */
-  badge(text: string): this { this._badge = text; return this }
-
-  /** Number of columns the section's children are laid out in. Defaults to 1. */
-  columns(n: 1 | 2 | 3): this { this._columns = n; return this }
-
-  /** Allow the user to collapse this section. Off by default. */
-  collapsible(v = true): this { this._collapsible = v; return this }
-
-  /** Start collapsed (only meaningful when `collapsible` is true). */
-  defaultCollapsed(v = true): this { this._defaultCollapsed = v; return this }
-
-  /**
-   * Render this section as the right-rail aside when nested inside a
-   * `Split` parent. No-op outside a `Split`.
-   */
-  aside(v = true): this { this._aside = v; return this }
-
-  /** Tighter padding + smaller heading. Useful in dense settings pages. */
-  compact(v = true): this { this._compact = v; return this }
-
-  /**
-   * Cascade `inlineLabel` to every descendant `Field` in this section
-   * whose own `.inlineLabel(...)` hasn't been called. Overrides any
-   * outer-form / outer-section setting for this subtree only. Pass
-   * `false` to revert to label-above for the subtree.
-   */
-  inlineLabel(v = true): this { this._inlineLabel = v; return this }
-  /** Internal — read by `resolveSchema.deriveChildContext`. */
-  getInlineLabel(): boolean | undefined { return this._inlineLabel }
-
-  /**
-   * Tighter spacing between the section's children. Orthogonal to
-   * `compact()` (which trims the section's outer padding/heading):
-   * `dense()` shrinks the inner grid `gap` so a long form fits more
-   * fields per scroll. Compose both for a settings-page look.
-   */
-  dense(v = true): this { this._dense = v; return this }
-
-  /**
-   * Muted background variant — uses the `bg-muted/40` token instead of
-   * `bg-card`. Pairs well with sections that wrap secondary or auxiliary
-   * controls (e.g. an "Advanced settings" group inside a primary card).
-   */
-  secondary(v = true): this { this._secondary = v; return this }
-
-  /**
-   * Persist the open/closed state to localStorage so user choices survive
-   * navigation. Only meaningful when `collapsible` is true. The optional
-   * `key` overrides the auto-key (which is built from the page slug +
-   * section title at render time).
-   */
-  persistCollapsed(key?: string): this {
-    this._persistCollapsed = true
-    if (key !== undefined) this._persistKey = key
-    return this
-  }
-
-  /**
-   * Action buttons rendered to the right of the section header. v1
-   * accepts `Action[]` only — Element-typed children would require a
-   * second resolver pass; keeping the slot Action-only dodges the
-   * resolution question (Actions serialize via `toMeta()` and their
-   * visibility evaluates inside the standard resolver walk that
-   * `resolveSchema` runs against `getAfterHeader()`).
-   *
-   * Actions placed here keep their full chrome surface — `.color() /
-   * .icon() / .iconButton() / .visible() / .disabled()` all work the
-   * same as anywhere else.
-   */
-  afterHeader(actions: Action[]): this {
-    this._afterHeader = actions
-    return this
-  }
-
-  /** Read-only access for the resolver. */
-  getAfterHeader(): Action[] | undefined { return this._afterHeader }
-
-  /** Set the section's children. Any Element type is accepted. */
-  schema(elements: Element[]): this {
-    this._children = elements
-    return this
-  }
-
-  getType(): string { return 'section' }
-
-  toMeta(): Record<string, unknown> {
-    return {
-      type: 'section' as const,
-      ...(this._title       ? { title:       this._title       } : {}),
-      ...(this._description ? { description: this._description } : {}),
-      ...(this._icon        ? { icon:        this._icon        } : {}),
-      ...(this._badge       ? { badge:       this._badge       } : {}),
-      columns:    this._columns,
-      collapsible: this._collapsible,
-      ...(this._collapsible && this._defaultCollapsed ? { defaultCollapsed: true } : {}),
-      ...(this._collapsible && this._persistCollapsed ? {
-        persistCollapsed: true,
-        ...(this._persistKey ? { persistKey: this._persistKey } : {}),
-      } : {}),
-      ...(this._aside     ? { aside:     true } : {}),
-      ...(this._compact   ? { compact:   true } : {}),
-      ...(this._dense     ? { dense:     true } : {}),
-      ...(this._secondary ? { secondary: true } : {}),
-    }
-  }
-}

package/src/schema/ServerDataElement.test.ts

@@ -1,140 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-
-import {
-  ServerDataElement,
-  isServerDataElement,
-  stampServerDataMeta,
-} from './ServerDataElement.js'
-import { Element } from './Element.js'
-import { resolveSchema } from './resolveSchema.js'
-
-class FakeWidget extends ServerDataElement {
-  private _payload: unknown
-  constructor(id: string | undefined, payload: unknown) {
-    super()
-    if (id) this._id = id
-    this._payload = payload
-  }
-  getType() { return 'fake-widget' }
-  toMeta() { return { type: 'fake-widget' as const, label: 'fake' } }
-  async resolveServerData() { return this._payload }
-}
-
-class PlainElement extends Element {
-  getType() { return 'plain' }
-  toMeta() { return { type: 'plain' as const } }
-}
-
-describe('ServerDataElement', () => {
-  describe('identity', () => {
-    it('falls back to constructor name when no id was set', () => {
-      class Contributions extends ServerDataElement {
-        getType() { return 'view' }
-        toMeta() { return { type: 'view' as const } }
-        async resolveServerData() { return null }
-      }
-      const w = new Contributions()
-      assert.equal(w.getId(), 'Contributions')
-    })
-
-    it('uses the explicit id when set via constructor', () => {
-      const w = new FakeWidget('posts-chart', null)
-      assert.equal(w.getId(), 'posts-chart')
-    })
-
-    it('id() setter overrides any inferred id', () => {
-      class Foo extends ServerDataElement {
-        getType() { return 'view' }
-        toMeta() { return { type: 'view' as const } }
-        async resolveServerData() { return null }
-      }
-      const w = new Foo().id('custom-id')
-      assert.equal(w.getId(), 'custom-id')
-    })
-  })
-
-  describe('flags', () => {
-    it('default isLazy() is true', () => {
-      const w = new FakeWidget('a', null)
-      assert.equal(w.isLazy(), true)
-    })
-
-    it('lazy(false) opts out', () => {
-      const w = new FakeWidget('a', null).lazy(false)
-      assert.equal(w.isLazy(), false)
-    })
-
-    it('lazy() with no arg defaults to true', () => {
-      const w = new FakeWidget('a', null).lazy(false).lazy()
-      assert.equal(w.isLazy(), true)
-    })
-
-    it('poll(seconds) stores positive numbers', () => {
-      const w = new FakeWidget('a', null).poll(30)
-      assert.equal(w.getPoll(), 30)
-    })
-
-    it('poll() ignores zero / negative / non-finite', () => {
-      const w = new FakeWidget('a', null).poll(0).poll(-5).poll(NaN)
-      assert.equal(w.getPoll(), undefined)
-    })
-  })
-
-  describe('isServerDataElement', () => {
-    it('returns true for ServerDataElement subclasses', () => {
-      assert.equal(isServerDataElement(new FakeWidget('a', null)), true)
-    })
-
-    it('returns false for plain Element subclasses', () => {
-      assert.equal(isServerDataElement(new PlainElement()), false)
-    })
-  })
-
-  describe('stampServerDataMeta + resolveSchema integration', () => {
-    it('stamps serverData / id / lazy on the meta during schema resolve', async () => {
-      const w = new FakeWidget('my-id', null)
-      const [meta] = await resolveSchema([w])
-      assert.equal(meta!['serverData'], true)
-      assert.equal(meta!['id'], 'my-id')
-      assert.equal(meta!['lazy'], true) // default
-    })
-
-    it('emits poll on the meta when set', async () => {
-      const w = new FakeWidget('my-id', null).poll(60)
-      const [meta] = await resolveSchema([w])
-      assert.equal(meta!['poll'], 60)
-    })
-
-    it('emits lazy: false explicitly when lazy(false)', async () => {
-      const w = new FakeWidget('my-id', null).lazy(false)
-      const [meta] = await resolveSchema([w])
-      assert.equal(meta!['lazy'], false)
-    })
-
-    it('preserves the subclass toMeta() surface', async () => {
-      const w = new FakeWidget('my-id', null)
-      const [meta] = await resolveSchema([w])
-      assert.equal(meta!['label'], 'fake')
-      assert.equal(meta!.type, 'fake-widget')
-    })
-
-    it('does NOT stamp on non-ServerDataElement elements', async () => {
-      const [meta] = await resolveSchema([new PlainElement()])
-      assert.equal(meta!['serverData'], undefined)
-      assert.equal(meta!['id'], undefined)
-    })
-  })
-
-  describe('stampServerDataMeta direct call', () => {
-    it('mutates the meta in place', () => {
-      const w = new FakeWidget('foo', null).poll(15)
-      const meta: Record<string, unknown> & { type: string } = { type: 'fake-widget' }
-      stampServerDataMeta(w, meta)
-      assert.equal(meta['serverData'], true)
-      assert.equal(meta['id'], 'foo')
-      assert.equal(meta['poll'], 15)
-      assert.equal(meta['lazy'], true)
-    })
-  })
-})

package/src/schema/ServerDataElement.ts

@@ -1,156 +0,0 @@
-import { Element, type ElementMeta } from './Element.js'
-import type { RenderContext } from './resolveSchema.js'
-
-/**
- * Element subclasses that compute their render-time payload from the
- * server. Plan #15 widgets — `Stat / StatsOverview / Chart / Table /
- * View` extend this. The contract is intentionally tiny:
- *
- *   - identity: every element carries an id (`Stat.make(id)` / inferred
- *     class name fallback) so the polling endpoint can find it,
- *   - hook:     `resolveServerData(ctx)` returns whatever JSON-clean
- *     payload the renderer should consume,
- *   - flags:    `poll(seconds)`, `lazy(bool=true)` shape the wire.
- *
- * `pageData.resolveServerDataElements` walks every page-data builder's
- * tree, collects elements where `isServerDataElement()` is true, and
- * runs `resolveServerData(ctx)` in parallel — except for lazy ones,
- * which paint a skeleton client-side and fetch via the polling endpoint
- * on mount. Results land on a single `_widgetData[id]` map alongside
- * `schemaData` so the renderer can look up its payload by id.
- *
- * Subclasses don't need to call `super.toMeta()` — the resolver stamps
- * `serverData / poll / lazy / id` onto the meta after the subclass's own
- * `toMeta()` runs. This keeps subclass meta authoring focused on the
- * widget's own surface (label, type, columns, …).
- */
-export abstract class ServerDataElement extends Element {
-  protected _id?: string
-  protected _poll?: number
-  // Default lazy=true (matches Filament v5's `$isLazy = true` default).
-  // `undefined` is treated as `true` everywhere; explicit `false` opts
-  // out (synchronous server-side resolve, ships data on first paint).
-  protected _lazy?: boolean
-  // Polling-endpoint URL stamped by `pageData.tagWidgetUrls`. The
-  // renderer reads `meta.widgetUrl` to fetch lazy data on mount and to
-  // re-fetch on `poll(seconds)` ticks. Set server-side per page-data
-  // pass — the field never round-trips back from the client.
-  protected _widgetUrl?: string
-
-  /**
-   * Stable identifier. Required so the polling endpoint can find this
-   * element after re-walking the schema. Subclasses that use a fluent
-   * factory (`Chart.make('posts-chart')`) pass an explicit id; subclasses
-   * that don't (e.g. `View`, where the user extends with `class
-   * ContributionMap extends View {}`) fall back to the constructor's
-   * class name via `getId()`.
-   */
-  getId(): string {
-    if (this._id) return this._id
-    const ctor = this.constructor as { name?: string }
-    return ctor.name ?? 'widget'
-  }
-
-  /** Set an explicit id. Useful when two instances of the same subclass
-   *  appear on the same page (e.g. two `View.component(X)` widgets). */
-  id(value: string): this {
-    this._id = value
-    return this
-  }
-
-  /** Polling interval in seconds. Number-only by design (cleaner than
-   *  Filament's '30s' string). Zero / negative / non-finite values are
-   *  ignored. */
-  poll(seconds: number): this {
-    if (Number.isFinite(seconds) && seconds > 0) this._poll = seconds
-    return this
-  }
-
-  getPoll(): number | undefined {
-    return this._poll
-  }
-
-  /**
-   * Opt out of (or back into) lazy loading. Default is lazy: the server
-   * paints a skeleton on first render and the client fetches the
-   * payload via the polling endpoint on mount. `lazy(false)` makes the
-   * server resolve `getServerData(ctx)` synchronously and ship the
-   * payload with the page.
-   */
-  lazy(value: boolean = true): this {
-    this._lazy = value
-    return this
-  }
-
-  /** True when this element should ship lazy (skeleton + first-paint
-   *  fetch). Default is true; unset === true. */
-  isLazy(): boolean {
-    return this._lazy !== false
-  }
-
-  /** Stamp the polling-endpoint URL. Called by `pageData.tagWidgetUrls`
-   *  during page-data builds — `${base}/_widget/:id` for panel-scope
-   *  dashboards and `${base}/${pageSlug}/_widget/:id` for custom-page
-   *  scope. The renderer reads `meta.widgetUrl` to fetch. */
-  withWidgetUrl(url: string): this {
-    this._widgetUrl = url
-    return this
-  }
-
-  getWidgetUrl(): string | undefined {
-    return this._widgetUrl
-  }
-
-  /** Discriminator that pageData / routes use to find server-data
-   *  elements without `instanceof` (Vite SSR module-cache duplication
-   *  trap — same posture as `findForms`). */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars -- structural marker
-  isServerDataElement(): true { return true }
-
-  /**
-   * Compute this element's render-time payload. Receives the same
-   * `RenderContext` the resolver builds (record/user/values/$get/...).
-   * Implementations should return a JSON-clean value — the resolver
-   * stamps it under `_widgetData[id]` for the renderer to consume.
-   *
-   * May throw — `resolveServerDataElements` swallows the throw and
-   * stamps `_widgetData[id] = { error: '...' }` so a single failing
-   * widget doesn't blank the whole dashboard. The polling-endpoint
-   * path handles errors symmetrically.
-   */
-  abstract resolveServerData(ctx: RenderContext): Promise<unknown>
-}
-
-/**
- * Structural type guard — Vite SSR module-cache duplication breaks
- * `instanceof` across module-graph entries (see
- * `feedback_vite_ssr_module_dup_instanceof.md`). Matches the
- * `findForms / findActions / isRepeaterField / isBuilderField` pattern.
- */
-export function isServerDataElement(el: Element): el is ServerDataElement {
-  const probe = el as unknown as { isServerDataElement?: () => unknown }
-  return typeof probe.isServerDataElement === 'function' && probe.isServerDataElement() === true
-}
-
-/**
- * Stamp `serverData / id / poll / lazy` onto an element's meta after
- * subclass `toMeta()` runs. Called by `resolveSchema` for every
- * `ServerDataElement`. Subclasses keep their `toMeta()` clean — they
- * only emit their own surface (label, kind, columns, …).
- *
- * Only stamps `lazy: true` when explicit; undefined-default ships as
- * `lazy: true` since the renderer treats absent as true. Keeps the wire
- * compact for the synchronous case (`lazy(false)` → no key emitted, but
- * `_widgetData[id]` already carries the payload).
- */
-export function stampServerDataMeta(el: ServerDataElement, meta: ElementMeta): void {
-  meta['serverData'] = true
-  meta['id']         = el.getId()
-  const poll = el.getPoll()
-  if (poll !== undefined) meta['poll'] = poll
-  // Always emit `lazy` so the renderer doesn't have to fall back through
-  // a default — explicit > implicit on the wire.
-  meta['lazy'] = el.isLazy()
-  const widgetUrl = el.getWidgetUrl()
-  if (widgetUrl !== undefined) meta['widgetUrl'] = widgetUrl
-}

package/src/schema/SlotComponent.test.ts

@@ -1,77 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { SlotComponent } from './SlotComponent.js'
-
-describe('SlotComponent schema primitive', () => {
-  it('emits component name and no props by default', () => {
-    const meta = SlotComponent.make('BookmarkButton').toMeta()
-    assert.equal(meta['type'],      'slotComponent')
-    assert.equal(meta['component'], 'BookmarkButton')
-    assert.equal('props' in meta,   false)
-  })
-
-  it('ships .props({...}) verbatim under meta.props', () => {
-    const meta = SlotComponent.make('BookmarkButton')
-      .props({ basePath: '/admin', recordId: '42' })
-      .toMeta()
-    assert.deepEqual(meta['props'], { basePath: '/admin', recordId: '42' })
-  })
-
-  it('successive .props() calls merge shallowly', () => {
-    const meta = SlotComponent.make('X')
-      .props({ a: 1, b: 2 })
-      .props({ b: 3, c: 4 })
-      .toMeta()
-    assert.deepEqual(meta['props'], { a: 1, b: 3, c: 4 })
-  })
-
-  it('exposes the component name via getComponentName()', () => {
-    const el = SlotComponent.make('BookmarkButton')
-    assert.equal(el.getComponentName(), 'BookmarkButton')
-  })
-
-  it('inherits Element.visible() / hidden() / columnSpan', () => {
-    const el = SlotComponent.make('X').visible(false).columnSpan(2)
-    assert.equal(el.hasVisibilityRule(), true)
-    assert.deepEqual(el.getLayoutPositioning(), { columnSpan: 2 })
-  })
-
-  it('getType returns slotComponent (matches wire shape discriminator)', () => {
-    assert.equal(SlotComponent.make('X').getType(), 'slotComponent')
-  })
-})
-
-describe('Slot component runtime registry', () => {
-  it('registers, retrieves, and resets', async () => {
-    const { registerSlotComponents, getSlotComponent, _resetSlotComponentRegistryForTests } =
-      await import('../slot-components/registry.js')
-    _resetSlotComponentRegistryForTests()
-    const Stub = (() => null) as unknown as Parameters<typeof registerSlotComponents>[0][string]
-    registerSlotComponents({ Stub })
-    assert.equal(getSlotComponent('Stub'), Stub)
-    assert.equal(getSlotComponent('Missing'), undefined)
-    _resetSlotComponentRegistryForTests()
-    assert.equal(getSlotComponent('Stub'), undefined)
-  })
-
-  it('skips falsy values during register', async () => {
-    const { registerSlotComponents, getSlotComponent, _resetSlotComponentRegistryForTests } =
-      await import('../slot-components/registry.js')
-    _resetSlotComponentRegistryForTests()
-    registerSlotComponents({ Bad: undefined as never })
-    assert.equal(getSlotComponent('Bad'), undefined)
-  })
-
-  it('multiple registrations merge into the same registry', async () => {
-    const { registerSlotComponents, getSlotComponent, _resetSlotComponentRegistryForTests } =
-      await import('../slot-components/registry.js')
-    _resetSlotComponentRegistryForTests()
-    const A = (() => null) as never
-    const B = (() => null) as never
-    registerSlotComponents({ A })
-    registerSlotComponents({ B })
-    assert.equal(getSlotComponent('A'), A)
-    assert.equal(getSlotComponent('B'), B)
-  })
-})

package/src/schema/SlotComponent.ts

@@ -1,71 +0,0 @@
-import { Element } from './Element.js'
-
-/**
- * Escape-hatch schema element that hands rendering off to a user-supplied
- * React component registered via `registerSlotComponents()`. Distinct from
- * `ComponentEntry` (which is record-bound and label-shelled for infolists)
- * and from `View` (which is widget-shaped with `getData`/polling). Use for
- * plugin-contributed UI that needs to mount inline at any schema position
- * — toolbars, header chips, sidebar contributions, anywhere `Action` /
- * `ActionGroup` would otherwise live.
- *
- * Wire shape ships only the registered name + a serialisable `props` bag.
- * The `_components.ts` build-time manifest doesn't see runtime-registered
- * components (they live in plugin packages, not `cfg.resources / globals
- * / pages` statics), so the lookup happens at render via the runtime
- * registry — same model as `registerEntryComponents` and
- * `registerWidgetComponents`.
- *
- * @example
- *   // bootstrap/providers.ts
- *   registerSlotComponents({ BookmarkButton })
- *
- *   // A plugin / app contributes the chip into the resource-edit header:
- *   panel.renderHook(
- *     'panels::resource.pages.edit-record.header.actions.before',
- *     (ctx) => [
- *       SlotComponent.make('BookmarkButton').props({
- *         basePath: ctx.basePath,
- *         resourceSlug: ctx.resource?.getSlug(),
- *         recordId: ctx.recordId,
- *       }),
- *     ],
- *   )
- */
-export class SlotComponent extends Element {
-  protected _componentName: string
-  protected _props?: Record<string, unknown>
-
-  protected constructor(componentName: string) {
-    super()
-    this._componentName = componentName
-  }
-
-  static make(componentName: string): SlotComponent {
-    return new SlotComponent(componentName)
-  }
-
-  /**
-   * Static props passed verbatim to the registered component. Must be
-   * JSON-serialisable — they ride through `viewProps` to the client.
-   * Successive calls merge shallowly with the previous bag.
-   */
-  props(props: Record<string, unknown>): this {
-    this._props = { ...(this._props ?? {}), ...props }
-    return this
-  }
-
-  getComponentName(): string {
-    return this._componentName
-  }
-
-  override getType(): string { return 'slotComponent' }
-
-  override toMeta(): Record<string, unknown> {
-    return {
-      type: 'slotComponent' as const,
-      component: this._componentName,
-      ...(this._props ? { props: this._props } : {}),
-    }
-  }
-}

package/src/schema/Split.ts

@@ -1,50 +0,0 @@
-import { Element } from './Element.js'
-
-export type SplitFrom = 'left' | 'right'
-
-/**
- * Two-column layout — main + aside. Renders as a stacked flex on small
- * viewports and a horizontal flex on `@md` (container query). Children
- * tagged with `.aside()` (e.g. `Section.aside()`) become the right-rail
- * (or left, when `from('left')`); without explicit markers, the second
- * child is treated as the aside.
- *
- * The renderer picks the aside-styled width from a small palette of
- * shadcn-flavoured sidebar widths (~20rem). The main child grows to
- * fill the remaining space.
- *
- * Useful for settings pages with a navigation card on the side, or for
- * resource forms where the primary content is a long article body and
- * the aside holds publish controls.
- */
-export class Split extends Element {
-  private _from: SplitFrom = 'right'
-  private _gap = 6
-
-  private constructor() { super() }
-
-  static make(): Split {
-    return new Split()
-  }
-
-  /** Which side the aside child sits on. Defaults to `'right'`. */
-  from(side: SplitFrom): this { this._from = side; return this }
-
-  /** Gap between main and aside (Tailwind spacing scale). Default 6 (24px). */
-  gap(n: number): this { this._gap = n; return this }
-
-  schema(elements: Element[]): this {
-    this._children = elements
-    return this
-  }
-
-  getType(): string { return 'split' }
-
-  toMeta(): Record<string, unknown> {
-    return {
-      type: 'split' as const,
-      from: this._from,
-      gap:  this._gap,
-    }
-  }
-}