@rb-pulse/core 1.2.24 → 1.3.0

package/index.ts

@@ -1,399 +1,350 @@
 /**
- * @pulse/core — Component, signal, and event API for Pulse framework scripts.
+ * @pulse/core — Global ambient declarations for Pulse framework TypeScript scripts.
  *
- * Write game scripts in TypeScript; compile to Lua via `rb build`.
- * Every API maps 1-to-1 to the Pulse Lua runtime.
+ * Mental model:
+ *   - SolidJS-style reactive signals: `signal(default)` returns a PulseSignal<T>.
+ *     Call it to read, `.set()` to write, `.watch()` to subscribe — just like
+ *     SolidJS `createSignal` but without the getter/setter tuple split.
+ *   - Next.js-style file-based pages: place `src/pages/1_Home.ts`, `2_Combat.ts`…
+ *     Each file calls `definePage(...)` at the top level — tab order is determined
+ *     by the numeric filename prefix, just like Next.js routes.
+ *   - Components are SolidJS-style setup functions: call `defineComponent(name, setup)`
+ *     where `setup` declares signals, registers `on.*` handlers, and returns widgets.
+ *   - All APIs are Lua globals — no imports needed. TypeScript sees them via this
+ *     `declare global {}` block. TSTL will NOT emit any `require()` calls.
  *
- * @example
- * ```typescript
- * import { defineComponent, signal, on } from '@pulse/core'
- * import { toggle, slider } from '@pulse/ui'
- *
- * export const KillAura = defineComponent(() => {
- *   const enabled = signal(false)
- *   const range   = signal(50)
- *
- *   on.heartbeat({ when: enabled, every: 0.1 }, dt => {
- *     // runs every 0.1 s while enabled === true
- *   })
- *
- *   return [
- *     toggle('Kill Aura').bind(enabled),
- *     slider('Range', { min: 1, max: 500 }).bind(range),
- *   ]
- * })
- * ```
- */
-
-// ── Signal ─────────────────────────────────────────────────────────────────────
-
-/**
- * Reactive state cell returned by `signal()`.
- *
- * Call it to read the current value; use `.set()` to write.
- * Changes automatically propagate to UI widgets, event guards, and watchers.
- *
- * Compiles to: `Signal(initialValue)` in Lua.
- */
-export interface Signal<T> {
-  /** Read the current value. Compiles to: `signalName()` */
-  (): T
-  /**
-   * Write a new value. Triggers UI, handler, and watcher updates.
-   * Compiles to: `signalName.set(value)`
-   */
-  set(value: T): void
-  /**
-   * Toggle the signal value (boolean signals only).
-   * Equivalent to `signal.set(!signal())`.
-   * Compiles to: `signalName.toggle()`
-   *
-   * @example
-   * const enabled = signal(false)
-   * button('Toggle').onClick(() => enabled.toggle())
-   */
-  toggle(this: Signal<boolean>): void
-  /**
-   * Subscribe to value changes. The callback fires immediately with the
-   * current value, then on every subsequent change.
-   * Returns an unsubscribe function.
-   * Compiles to: `signalName.watch(fn)`
-   *
-   * @example
-   * const unsubscribe = enabled.watch(v => {
-   *   print('enabled changed to', v)
-   * })
-   * // later: unsubscribe()
-   */
-  watch(fn: (value: T) => void): () => void
-  /**
-   * Mirror this signal's value into another signal on every change.
-   * Useful for propagating values across component boundaries.
-   * Compiles to: `signalName.mirror(target)`
-   */
-  mirror(target: Signal<T>): void
-}
-
-/**
- * Derived signal — recomputes when any signal read inside `fn` changes.
- * Read-only; no `.set()`.
- *
- * Compiles to: `Computed(fn)` in Lua.
- */
-export interface Computed<T> {
-  (): T
-}
-
-// ── Event options ──────────────────────────────────────────────────────────────
-
-/**
- * Options for periodic event handlers (`on.heartbeat`, `on.renderStepped`, `on.stepped`).
- * Both fields are optional — omit entirely to run every frame with no guard.
- */
-export interface HandlerOpts {
-  /**
-   * Gate: skip the callback while this signal is `false`.
-   * The event connection stays alive but the callback is skipped.
-   * Compiles to: `when = signalName` in the event binding.
-   */
-  when?: Signal<boolean>
-  /**
-   * Throttle: minimum seconds between callback invocations.
-   * Uses an internal accumulator — does not create extra connections.
-   * Accepts a number or a reactive `Signal<number>` for live adjustment.
-   * Compiles to: `every = value` in the event binding.
-   *
-   * @default 0  (every frame)
-   */
-  every?: number | Signal<number>
-}
-
-// ── Widget base ────────────────────────────────────────────────────────────────
-
-/** Base interface shared by all widget definitions returned from `defineComponent`. */
-export interface WidgetDef {
-  /**
-   * Bind this widget to a signal so their values stay in sync.
-   * The widget writes the signal on user interaction; the signal
-   * drives the widget when set programmatically.
-   */
-  bind(signal: Signal<any>): this
-}
-
-// ── Component ──────────────────────────────────────────────────────────────────
-
-/** Setup function type for `defineComponent`. */
-export type ComponentSetup = () => WidgetDef[]
-
-/**
- * Opaque component handle returned by `defineComponent`.
- * Pass it to `groupbox({ mount: MyComponent })` to embed its widgets.
- */
-export interface Component<S extends ComponentSetup> {
-  readonly _type:    'component'
-  readonly _widgets: ReturnType<S>
-}
-
-// ── Core API ───────────────────────────────────────────────────────────────────
-
-/**
- * Define a Pulse component — the primary building block.
- *
- * The setup function runs once on initialisation.
- * Declare signals, register event handlers with `on.*`, then return an array
- * of widget definitions to mount into the component's groupbox.
- * All `on.*` subscriptions are auto-disconnected when the component is destroyed.
- *
- * Compiles to a self-contained Lua IIFE with Signal/bind wiring.
- *
- * @param setup  Called once at init. Returns UI widget array.
+ * Compiled to Lua via typescript-to-lua (TSTL): `rb build` handles this for you.
  *
  * @example
- * export const SpeedHack = defineComponent(() => {
+ * // src/combat/SpeedHack.ts
+ * defineComponent('SpeedHack', () => {
  *   const enabled = signal(false)
  *   const speed   = signal(16)
- *
  *   on.heartbeat({ when: enabled }, () => {
- *     // manipulate character walkspeed
- *   })
- *
- *   on.respawn(() => {
- *     if (enabled()) applySpeed(speed())
+ *     const h = _PulseGetHumanoid() as any
+ *     if (h) h.WalkSpeed = speed()
  *   })
- *
  *   return [
- *     toggle('Speed hack').bind(enabled),
- *     slider('Speed', { min: 1, max: 250, suffix: ' studs/s' }).bind(speed),
+ *     toggle('Speed Hack').bind(enabled),
+ *     slider('Walk Speed', { min: 16, max: 250 }).bind(speed),
  *   ]
  * })
  */
-export declare function defineComponent<S extends ComponentSetup>(setup: S): Component<S>
 
-/**
- * Create a reactive state cell with an initial value.
- *
- * Compiles to: `Signal(initialValue)` in Lua.
- *
- * @param initialValue  The starting value.
- *
- * @example
- * const enabled = signal(false)   // Signal<boolean>
- * const range   = signal(50)      // Signal<number>
- * const mode    = signal('Auto')  // Signal<string>
- *
- * enabled()           // read → false
- * enabled.set(true)   // write
- * enabled.toggle()    // flip boolean
- * enabled.watch(v => print(v))  // subscribe
- */
-export declare function signal<T>(initialValue: T): Signal<T>
+declare global {
 
-/**
- * Create a derived signal that recomputes automatically when its dependencies change.
- *
- * Compiles to: `Computed(fn)` in Lua.
- *
- * @param fn  Pure function reading one or more signals. Must not have side effects.
- *
- * @example
- * const fov   = signal(90)
- * const label = computed(() => `FOV: ${fov()}`)
- *
- * // Use in a toggle tooltip or paragraph widget
- * paragraph('Current FOV', label())
- */
-export declare function computed<T>(fn: () => T): Computed<T>
+  // ── Signal ────────────────────────────────────────────────────────────────────
 
-// ── Event namespace ────────────────────────────────────────────────────────────
-
-/**
- * Event subscription namespace.
- * All connections are automatically cleaned up when the component is destroyed.
- *
- * @example
- * on.heartbeat({ when: enabled, every: 0.1 }, dt => { ... })
- * on.heartbeat(dt => updateDisplay(dt))           // no opts overload
- * on.signal(range, v => applyRange(v))            // signal watcher
- * on.inputBegan(input => handleKey(input))
- * on.respawn(() => reapplyEffects())
- * on.after(0.5, () => init())                     // delayed one-shot
- */
-export declare const on: {
   /**
-   * RunService.Heartbeat — fires every frame.
-   *
-   * Compiles to: `on Heartbeat { when = ..., every = ... }` in .rblua.
+   * Reactive state cell returned by `signal()`.
    *
-   * @param opts     Optional `when` guard and `every` throttle.
-   * @param fn       Callback invoked each (throttled) tick. Receives delta-time.
+   * Call it to read the current value. Changes propagate to UI widgets,
+   * event guards, and watchers automatically.
    *
-   * @example
-   * // Throttled, gated
-   * on.heartbeat({ when: enabled, every: 0.1 }, dt => {
-   *   doWork()
-   * })
-   *
-   * // Every frame, no guard
-   * on.heartbeat(dt => updateDisplay(dt))
+   * Like SolidJS `createSignal` but without the getter/setter tuple split.
    */
-  heartbeat(opts: HandlerOpts, fn: (dt: number) => void): void
-  heartbeat(fn: (dt: number) => void): void
+  interface PulseSignal<T> {
+    /** Read the current value. */
+    (): T
+    /** Write a new value. Triggers UI, handler, and watcher updates. */
+    set(this: PulseSignal<T>, value: T): void
+    /**
+     * Toggle the signal value (boolean signals only).
+     * Equivalent to `signal.set(!signal())`.
+     */
+    toggle(this: PulseSignal<boolean>): void
+    /**
+     * Subscribe to value changes. Returns an unsubscribe function.
+     * Fires immediately with the current value, then on every change.
+     */
+    watch(this: PulseSignal<T>, fn: (value: T) => void): () => void
+    /**
+     * Apply a function to the current value and set the result.
+     * @example speed.update(v => v + 10)
+     */
+    update(this: PulseSignal<T>, fn: (current: T) => T): void
+  }
+
+  // ── Event options ─────────────────────────────────────────────────────────────
 
   /**
-   * RunService.RenderStepped — fires before every frame render (client only).
-   * Prefer `heartbeat` for game logic; use this for camera / visual work.
-   *
-   * @example
-   * on.renderStepped({ when: espEnabled }, dt => drawBoxes(dt))
-   * on.renderStepped(dt => updateCamera(dt))
+   * Options for periodic event handlers (`on.heartbeat`, `on.renderStepped`, `on.stepped`).
+   * Both fields are optional — omit entirely to run every frame with no guard.
    */
-  renderStepped(opts: HandlerOpts, fn: (dt: number) => void): void
-  renderStepped(fn: (dt: number) => void): void
+  interface HandlerOpts {
+    /**
+     * Gate: skip the callback while this signal is `false`.
+     * The event connection stays alive but the callback is skipped.
+     */
+    when?: PulseSignal<boolean>
+    /**
+     * Throttle: minimum seconds between callback invocations.
+     * Accepts a number or a reactive `PulseSignal<number>` for live adjustment.
+     * @default 0  (every frame)
+     */
+    every?: number | PulseSignal<number>
+  }
+
+  // ── Widget definitions ────────────────────────────────────────────────────────
+
+  interface ToggleDef {
+    bind(this: ToggleDef, sig: PulseSignal<boolean>): ToggleDef
+    withTip(this: ToggleDef, text: string): ToggleDef
+    withDefault(this: ToggleDef, v: boolean): ToggleDef
+  }
+
+  interface SliderDef {
+    bind(this: SliderDef, sig: PulseSignal<number>): SliderDef
+    withTip(this: SliderDef, text: string): SliderDef
+    withDefault(this: SliderDef, v: number): SliderDef
+  }
+
+  interface DropdownDef {
+    bind(this: DropdownDef, sig: PulseSignal<string>): DropdownDef
+    withTip(this: DropdownDef, text: string): DropdownDef
+    withDefault(this: DropdownDef, v: string): DropdownDef
+  }
+
+  interface ButtonDef {
+    onClick(this: ButtonDef, fn: () => void): ButtonDef
+    bind(this: ButtonDef): ButtonDef
+  }
+
+  type WidgetDef = ToggleDef | SliderDef | DropdownDef | ButtonDef | {
+    bind(this: any): any
+  }
+
+  // ── Component / Page / Layout ────────────────────────────────────────────────
+
+  /** Opaque handle returned by `defineComponent`. */
+  interface ComponentRef {
+    readonly _name: string
+    readonly _ui:   WidgetDef[]
+  }
+
+  interface GroupboxDef {
+    readonly type:  'groupbox'
+    readonly side:  'left' | 'right'
+    readonly title: string
+    readonly icon:  string
+    readonly mount?: string
+  }
+
+  interface PageDef {
+    readonly title:  string
+    readonly icon:   string
+    readonly layout: GroupboxDef[]
+  }
+
+  interface LayoutConfig {
+    title:               string
+    author?:             string
+    toggleKey?:          string
+    size?:               [number, number]
+    uiLibrary?:          'windui' | 'linoria'
+    theme?:              string
+    icon?:               string
+    folder?:             string
+    acrylic?:            boolean
+    transparency?:       number
+    openButtonMobileOnly?: boolean
+    openButtonIcon?:     string
+    themes?:             Array<{ name: string; values: Record<string, string> }>
+    compatExclude?:      string[]
+  }
+
+  // ── Core API — all are Lua globals, no require() ──────────────────────────────
 
   /**
-   * RunService.Stepped — fires at the physics step rate.
+   * SolidJS-style reactive state — see createSignal.
    *
-   * @example
-   * on.stepped({ when: enabled }, (t, dt) => applyVelocity(dt))
-   */
-  stepped(opts: HandlerOpts, fn: (time: number, dt: number) => void): void
-  stepped(fn: (time: number, dt: number) => void): void
-
-  /**
-   * UserInputService.InputBegan.
+   * Creates a reactive state cell with an initial value.
+   * Compiles to `Signal(initialValue)` in Lua.
    *
    * @example
-   * on.inputBegan((input, gpe) => {
-   *   if (gpe) return
-   *   if (input.KeyCode === Enum.KeyCode.X) enabled.toggle()
-   * })
+   * const enabled = signal(false)   // PulseSignal<boolean>
+   * const speed   = signal(16)      // PulseSignal<number>
+   * enabled()           // read
+   * enabled.set(true)   // write
+   * enabled.toggle()    // flip boolean
    */
-  inputBegan(fn: (input: InputObject, gameProcessed: boolean) => void): void
+  function signal<T>(initialValue: T): PulseSignal<T>
 
   /**
-   * UserInputService.InputEnded.
-   *
-   * @example
-   * on.inputEnded(input => {
-   *   if (input.UserInputType === Enum.UserInputType.MouseButton1) release()
-   * })
+   * Create a derived value that recomputes when its dependencies change.
+   * Compiles to `Computed(fn)` in Lua.
    */
-  inputEnded(fn: (input: InputObject, gameProcessed: boolean) => void): void
+  function computed<T>(fn: () => T): () => T
 
   /**
-   * Fires when the player's character respawns.
-   * Use this to re-apply effects that attach to the character.
+   * SolidJS-style component setup function.
    *
-   * @example
-   * on.respawn(() => {
-   *   if (enabled()) applySpeed(speed())
-   * })
-   */
-  respawn(fn: () => void): void
-
-  /**
-   * Player.CharacterAdded — fires when a new character model is added.
+   * The setup function runs once on init. Declare signals, register `on.*`
+   * handlers, then return an array of widget definitions. All connections are
+   * auto-disconnected when the component is destroyed.
    *
    * @example
-   * on.characterAdded(char => {
-   *   const hrp = char.WaitForChild('HumanoidRootPart') as BasePart
+   * defineComponent('SpeedHack', () => {
+   *   const enabled = signal(false)
+   *   on.heartbeat({ when: enabled }, () => { ... })
+   *   return [toggle('Speed Hack').bind(enabled)]
    * })
    */
-  characterAdded(fn: (character: Model) => void): void
+  function defineComponent(name: string, setup: () => WidgetDef[]): ComponentRef
 
   /**
-   * Player.CharacterRemoving — fires just before the character is removed.
-   *
-   * @example
-   * on.characterRemoving(() => cleanup())
+   * Event subscription namespace.
+   * All connections are automatically cleaned up when the component is destroyed.
+   * Must be called inside a `defineComponent` setup function.
    */
-  characterRemoving(fn: (character: Model) => void): void
+  const on: {
+    /**
+     * RunService.Heartbeat — fires every frame.
+     * Like SolidJS createEffect scoped to RunService.Heartbeat.
+     *
+     * @example
+     * on.heartbeat({ when: enabled, every: 0.1 }, dt => { doWork() })
+     * on.heartbeat(dt => updateDisplay(dt))
+     */
+    heartbeat(opts: HandlerOpts, fn: (dt: number) => void): void
+    heartbeat(fn: (dt: number) => void): void
+
+    /** RunService.RenderStepped — fires before every frame render (client only). */
+    renderStepped(opts: HandlerOpts, fn: (dt: number) => void): void
+    renderStepped(fn: (dt: number) => void): void
+
+    /** RunService.Stepped — fires at the physics step rate. */
+    stepped(opts: HandlerOpts, fn: (time: number, dt: number) => void): void
+    stepped(fn: (time: number, dt: number) => void): void
+
+    /** UserInputService.InputBegan. */
+    inputBegan(fn: (input: any, gameProcessed: boolean) => void): void
+
+    /** UserInputService.InputEnded. */
+    inputEnded(fn: (input: any, gameProcessed: boolean) => void): void
+
+    /** Fires when the player's character respawns. */
+    respawn(fn: () => void): void
+
+    /** Player.CharacterAdded — fires when a new character model is added. */
+    characterAdded(fn: (character: any) => void): void
+
+    /** Player.CharacterRemoving — fires just before the character is removed. */
+    characterRemoving(fn: (character: any) => void): void
+
+    /**
+     * Subscribe to changes on a signal.
+     * Fires immediately with the current value, then on every change.
+     */
+    signal<T>(sig: PulseSignal<T>, fn: (val: T) => void): void
+
+    /**
+     * Run a one-shot callback after a delay (seconds).
+     * @example on.after(0.5, () => init())
+     */
+    after(seconds: number, fn: () => void): void
+  }
+
+  // ── Widget factory globals ─────────────────────────────────────────────────────
+
+  /** Toggle widget — checkbox bound to a `PulseSignal<boolean>`. */
+  function toggle(label: string, opts?: { tip?: string; default?: boolean }): ToggleDef
+
+  /** Slider widget — numeric range input. */
+  function slider(label: string, opts?: {
+    min?: number; max?: number; step?: number; default?: number;
+    suffix?: string; tip?: string
+  }): SliderDef
+
+  /** Dropdown widget — selectable list of string options. */
+  function dropdown(label: string, opts?: {
+    options?: string[]; default?: string; tip?: string
+  }): DropdownDef
+
+  /** Multi-select dropdown widget. */
+  function multidropdown(label: string, opts?: {
+    options?: string[]; default?: string[]; tip?: string
+  }): DropdownDef
+
+  /** Button widget — triggers a callback when clicked. */
+  function button(label: string, fn: () => void, opts?: { tip?: string }): ButtonDef
+  function button(label: string, opts?: { tip?: string }): ButtonDef
+
+  /** Keybind widget — lets the user rebind a hotkey. */
+  function keybind(label: string, opts?: { key?: string; tip?: string }): WidgetDef
+
+  /** Label widget — static non-interactive text. */
+  function label(text: string): WidgetDef
+
+  /** Separator widget — horizontal divider line. */
+  function separator(): WidgetDef
 
   /**
-   * Subscribe to changes on a signal — fires immediately with the current value,
-   * then on every subsequent change. Part of component lifecycle (auto-disconnected).
-   *
-   * Compiles to: `on signalName { }` signal handler in .rblua.
-   *
-   * @param sig  The signal to watch.
-   * @param fn   Called with the new value on every change.
-   *
-   * @example
-   * on.signal(enabled, v => {
-   *   if (v) activateESP() else deactivateESP()
-   * })
-   *
-   * on.signal(range, v => updateAimRadius(v))
+   * Declare a groupbox column in a page.
+   * @param side  'left' or 'right' column
+   * @param title Groupbox header text
+   * @param opts  icon, mount (component name string), widgets
    */
-  signal<T>(sig: Signal<T>, fn: (val: T) => void): void
+  function groupbox(side: 'left' | 'right', title: string, opts?: {
+    icon?: string; mount?: string; widgets?: WidgetDef[]
+  }): GroupboxDef
 
   /**
-   * Run a one-shot callback after a delay.
-   * Runs inside the component's init phase — useful for deferred setup.
-   * Compiles to: `task.delay(seconds, fn)` wrapped in component lifecycle.
+   * Next.js-style file-based page tab — place in src/pages/N_Name.ts.
    *
-   * @param seconds  Delay in seconds (0.5 is typical for post-mount init).
-   * @param fn       Callback to run once.
+   * Each file calls `definePage` at the top level. Tab order is determined
+   * by the numeric prefix of the filename (1_Home.ts, 2_Combat.ts, …).
    *
    * @example
-   * on.after(0.5, () => {
-   *   // safe to read UI state here — everything is mounted
-   *   Pulse.UI.paragraph('Info', 'Loaded!')
-   * })
+   * // src/pages/1_Home.ts
+   * definePage('Home', { icon: 'house' }, () => [
+   *   groupbox('left', 'Player', { icon: 'person', mount: 'SpeedHack' }),
+   * ])
    */
-  after(seconds: number, fn: () => void): void
-}
-
-// ── Roblox type stubs ──────────────────────────────────────────────────────────
-// Minimal stubs so editors don't error. Install @pulse/roblox for full types.
-
-/** @see @pulse/roblox */
-export interface InputObject {
-  KeyCode:       { Value: number; Name: string }
-  UserInputType: { Value: number; Name: string }
-  Position:      Vector3
-  Delta:         Vector3
-}
+  function definePage(
+    title:    string,
+    opts:     { icon?: string },
+    factory:  () => GroupboxDef[],
+  ): PageDef
+
+  // ── Roblox globals (minimal stubs) ────────────────────────────────────────────
+
+  const game: {
+    GetService(name: string): any
+    HttpGet(url: string): string
+  }
+
+  const workspace: {
+    CurrentCamera: any
+    [key: string]: any
+  }
+
+  const Enum: Record<string, Record<string, any>>
+
+  const Color3: {
+    new(r: number, g: number, b: number): any
+    fromRGB(r: number, g: number, b: number): any
+  }
+
+  const Vector3: {
+    new(x: number, y: number, z: number): any
+  }
+
+  const CFrame: {
+    new(x: number, y: number, z: number): any
+  }
+
+  // ── Pulse character helpers ───────────────────────────────────────────────────
+
+  /** Returns `LocalPlayer.Character` or nil. */
+  function _PulseGetChar(): any
+  /** Returns `HumanoidRootPart` from the character, or nil. */
+  function _PulseGetHRP(): any
+  /** Returns `Humanoid` from the character, or nil. */
+  function _PulseGetHumanoid(): any
+  /** Returns true if the local player's humanoid is alive. */
+  function _PulseGetAlive(): boolean
 
-/** @see @pulse/roblox */
-export interface Model {
-  WaitForChild(name: string, timeout?: number): Instance
-  FindFirstChild(name: string): Instance | undefined
-  FindFirstChildOfClass(className: string): Instance | undefined
-  GetChildren(): Instance[]
 }
 
-/** @see @pulse/roblox */
-export interface Instance {
-  Name:      string
-  Parent:    Instance | undefined
-  Destroy(): void
-}
-
-/** @see @pulse/roblox */
-export interface BasePart extends Instance {
-  Position:     Vector3
-  CFrame:       CFrame
-  Size:         Vector3
-  Anchored:     boolean
-  CanCollide:   boolean
-  Transparency: number
-}
-
-/** @see @pulse/roblox */
-export interface Vector3 {
-  X: number; Y: number; Z: number
-  Magnitude: number
-  Unit: Vector3
-  add(other: Vector3): Vector3
-  sub(other: Vector3): Vector3
-  mul(scalar: number): Vector3
-}
-
-/** @see @pulse/roblox */
-export interface CFrame {
-  Position:   Vector3
-  LookVector: Vector3
-  RightVector: Vector3
-  UpVector:   Vector3
-}
+export {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rb-pulse/core",
-  "version": "1.2.24",
+  "version": "1.3.0",
   "description": "Pulse framework — component, signal, and event TypeScript API",
   "main": "./index.ts",
   "types": "./index.ts",