mates-devtools 0.1.0-beta.1

package/dist/types/lib/Router/navigateTo.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Navigates to `path` by updating both `window.history` and `pathAtom` in
+ * sync, so the Router re-renders reactively.
+ *
+ * - By default uses `pushState`, creating a new browser history entry.
+ * - Pass `replace = true` to use `replaceState` instead — the current entry
+ *   is overwritten, so the user cannot navigate back to the previous URL.
+ * - Silently no-ops if navigation is currently locked (`navigationLocked()`
+ *   returns `true`). Nothing is pushed/replaced and `pathAtom` is not updated.
+ * - `data` is forwarded as the state argument to the history API and can be
+ *   retrieved later via `history.state`.
+ *
+ * Scroll-to-top is intentionally **not** handled here. It belongs in the
+ * router layer (`animatedRouter`'s `scrollToTop` option) so that:
+ *   1. The scroll fires at the right moment (after exit animation, before
+ *      enter animation) rather than prematurely before the old page exits.
+ *   2. Nested / child routers can opt out with `scrollToTop: false` without
+ *      affecting the parent.
+ *
+ * @param path    - The pathname to navigate to (e.g. `"/about"`).
+ * @param replace - When `true`, calls `replaceState` instead of `pushState`.
+ *                  Defaults to `false`.
+ * @param data    - Optional state object passed to the history API.
+ *
+ * @example
+ * navigateTo("/about");                          // pushState
+ * navigateTo("/login", true);                    // replaceState (no new history entry)
+ * navigateTo("/profile", false, { userId: 42 }); // pushState with state data
+ */
+export declare function navigateTo(path: string, replace?: boolean, data?: any): void;
+//# sourceMappingURL=navigateTo.d.ts.map

package/dist/types/lib/Router/navigateTo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigateTo.d.ts","sourceRoot":"","sources":["../../../../../lib/Router/navigateTo.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI,CAU5E"}

package/dist/types/lib/Router/navigationLock.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Reactive atom holding the current navigation lock state.
+ *
+ * When `true`, all navigation is suspended:
+ *  - `navigateTo()` becomes a no-op.
+ *  - `pathAtom` is hard-locked via `superAtom.lock()`, so `.set()` calls are
+ *    silently ignored.
+ *  - The `qsAtom → URL` effect and the `popstate` handler both bail out early.
+ *  - The `hashAtom → URL` effect and the `hashchange` handler both bail out early.
+ *
+ * When `false` (the default), all navigation works normally.
+ *
+ * Prefer using the `lockNavigation()` / `unlockNavigation()` helpers over
+ * calling `navigationLocked.set()` directly.
+ *
+ * @example
+ * import { navigationLocked } from "mates";
+ *
+ * navigationLocked(); // false — unlocked by default
+ */
+export declare const navigationLocked: import("..").AtomType<boolean>;
+/**
+ * Locks navigation across the entire Router module.
+ *
+ * After calling this, the following all become no-ops until
+ * `unlockNavigation()` is called:
+ *  - `navigateTo()`
+ *  - `pathAtom.set()` (hard-locked via `superAtom`)
+ *  - `qsAtom` → URL writes
+ *  - `hashAtom` → URL writes
+ *  - `popstate` / `hashchange` → atom updates
+ *
+ * @example
+ * lockNavigation();
+ * navigateTo("/somewhere"); // no-op
+ */
+export declare const lockNavigation: () => void;
+/**
+ * Unlocks navigation, re-enabling all navigation operations that were
+ * suppressed by `lockNavigation()`.
+ *
+ * @example
+ * lockNavigation();
+ * navigateTo("/somewhere"); // no-op
+ *
+ * unlockNavigation();
+ * navigateTo("/somewhere"); // works — pushState + pathAtom.set()
+ */
+export declare const unlockNavigation: () => void;
+//# sourceMappingURL=navigationLock.d.ts.map

package/dist/types/lib/Router/navigationLock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigationLock.d.ts","sourceRoot":"","sources":["../../../../../lib/Router/navigationLock.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,gBAAgB,gCAAc,CAAC;AAE5C;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,cAAc,YAAmC,CAAC;AAE/D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,YAAoC,CAAC"}

package/dist/types/lib/Router/pathAtom.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @file pathAtom.ts
+ *
+ * Provides `pathAtom` — the single source of truth for the current URL
+ * pathname inside the Router module.
+ *
+ * `pathAtom` is a `superAtom` (a lockable reactive atom) initialised with
+ * `window.location.pathname` at module load time.  Because it is a
+ * `superAtom`, it can be hard-locked and hard-unlocked in response to the
+ * navigation lock state, which causes every subscriber (including the Router
+ * itself) to ignore updates while navigation is locked.
+ *
+ * Three browser events keep `pathAtom` in sync with navigation that happens
+ * outside of `navigateTo`:
+ *  - `popstate`   — browser back / forward buttons
+ *  - `hashchange` — hash-only navigations that also change the pathname
+ *  - `navigate`   — Navigation API (supported in modern browsers)
+ *
+ * Any component or effect that reads `pathAtom()` will automatically re-run
+ * whenever the path changes.
+ *
+ * **Do NOT set `pathAtom` directly.**  Use `navigateTo()` instead so that
+ * `window.history` and the atom are always updated together.
+ *
+ * @example
+ * pathAtom.get(); // "/current/path"
+ * pathAtom();     // same — tracked read (registers a reactive dependency)
+ *
+ * // Do NOT do this:
+ * // pathAtom.set("/somewhere"); // bypasses history API
+ * // Use instead:
+ * // navigateTo("/somewhere");
+ */
+/**
+ * Reactive atom holding the current `window.location.pathname`.
+ *
+ * Implemented as a `superAtom` so it can be locked/unlocked in step with
+ * `navigationLocked()`.  Prefer reading via the call syntax (`pathAtom()`)
+ * inside reactive contexts so that the caller re-renders on path changes.
+ */
+export declare const pathAtom: import("..").SuperAtomType<string>;
+//# sourceMappingURL=pathAtom.d.ts.map

package/dist/types/lib/Router/pathAtom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathAtom.d.ts","sourceRoot":"","sources":["../../../../../lib/Router/pathAtom.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,oCAEpB,CAAC"}

package/dist/types/lib/Router/pathResolver.d.ts

@@ -0,0 +1,9 @@
+export { buildPath } from "./buildPath";
+export { hashAtom } from "./hashAtom";
+export { isPathMatching } from "./isPathMatching";
+export { location } from "./location";
+export { navigateTo } from "./navigateTo";
+export { lockNavigation, navigationLocked, unlockNavigation, } from "./navigationLock";
+export { pathAtom } from "./pathAtom";
+export { qsAtom } from "./qsAtom";
+//# sourceMappingURL=pathResolver.d.ts.map

package/dist/types/lib/Router/pathResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathResolver.d.ts","sourceRoot":"","sources":["../../../../../lib/Router/pathResolver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC"}

package/dist/types/lib/Router/qsAtom.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Singleton atom holding the current URL query string as a parsed object.
+ *
+ * Hydrated from `window.location.search` at module load time.  All reads are
+ * reactive — any effect or component that calls `qsAtom()` will re-run
+ * whenever the query string state changes.
+ *
+ * Setting the atom via `qsAtom.set(obj)` automatically serialises the new
+ * value back to the URL query string using `history.replaceState`.
+ */
+export declare const qsAtom: import("..").AtomType<Record<string, any>>;
+//# sourceMappingURL=qsAtom.d.ts.map

package/dist/types/lib/Router/qsAtom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"qsAtom.d.ts","sourceRoot":"","sources":["../../../../../lib/Router/qsAtom.ts"],"names":[],"mappings":"AAmFA;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,4CAAqC,CAAC"}

package/dist/types/lib/Template/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./scheduler";
+export * from "./x";
+export * from "./x-x.types";
+export * from "./x-x.utils";
+export * from "./xProvider";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/lib/Template/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../lib/Template/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,KAAK,CAAC;AACpB,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC"}

package/dist/types/lib/Template/scheduler.d.ts

@@ -0,0 +1,59 @@
+import type { HostElement } from "./x-x.types";
+declare class CleanupScheduler {
+    private pending;
+    private isScheduled;
+    /**
+     * Schedule a deferred cleanup for a disconnected component.
+     * The actual teardown runs in a microtask so that DOM moves
+     * (disconnect → reconnect in the same tick) can cancel it.
+     */
+    scheduleDisconnect(component: HostElement): void;
+    /** Cancel a pending disconnect (called from connectedCallback on move). */
+    cancelDisconnect(component: HostElement): void;
+    /** Run full teardown for components that are truly gone. */
+    private flush;
+    reset(): void;
+}
+/**
+ * Immediate, synchronous teardown of all component reactive state.
+ * Runs cleanups, clears subscriptions, resets mount flag.
+ * Does NOT clear _view, _props, or oldView — the caller decides those.
+ */
+export declare function resetComponentState(comp: HostElement): void;
+declare class EffectScheduler {
+    private pendingEffects;
+    isScheduled: boolean;
+    private _isFlushing;
+    get isFlushing(): boolean;
+    reset(): void;
+    schedule(effectFn: () => void): void;
+    flush(): void;
+}
+declare class RenderScheduler {
+    private pendingComponents;
+    private nextPendingComponents;
+    /** Components in the current sorted wave, used to dedup mid-flush schedules. */
+    private _currentWave;
+    isScheduled: boolean;
+    private _isFlushing;
+    private _flushVersion;
+    /** Callbacks to run once after all pending renders (including deferred children) complete. */
+    private _onIdleCallbacks;
+    /** Monotonically increasing counter stamped on each flush cycle. */
+    get flushVersion(): number;
+    /**
+     * Register a one-shot callback that fires after the render scheduler
+     * has fully settled (no more pending or next-pending components).
+     * Used by onAllMount to wait for all descendants to mount.
+     */
+    onceIdle(fn: () => void): void;
+    private _drainIdleCallbacks;
+    reset(): void;
+    schedule(component: HostElement): void;
+    flush(): void;
+}
+export declare const cleanupScheduler: CleanupScheduler;
+export declare const effectScheduler: EffectScheduler;
+export declare const globalScheduler: RenderScheduler;
+export {};
+//# sourceMappingURL=scheduler.d.ts.map

package/dist/types/lib/Template/scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../../../../../lib/Template/scheduler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAQ/C,cAAM,gBAAgB;IACpB,OAAO,CAAC,OAAO,CAA0B;IACzC,OAAO,CAAC,WAAW,CAAS;IAE5B;;;;OAIG;IACH,kBAAkB,CAAC,SAAS,EAAE,WAAW;IAQzC,2EAA2E;IAC3E,gBAAgB,CAAC,SAAS,EAAE,WAAW;IAIvC,4DAA4D;IAC5D,OAAO,CAAC,KAAK;IAgBb,KAAK;CAIN;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,WAAW,QAoBpD;AAED,cAAM,eAAe;IACnB,OAAO,CAAC,cAAc,CAAyB;IACxC,WAAW,UAAS;IAC3B,OAAO,CAAC,WAAW,CAAS;IAE5B,IAAI,UAAU,IAAI,OAAO,CAExB;IAED,KAAK;IAML,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI;IAQ7B,KAAK;CA8BN;AAED,cAAM,eAAe;IACnB,OAAO,CAAC,iBAAiB,CAA0B;IACnD,OAAO,CAAC,qBAAqB,CAA0B;IACvD,gFAAgF;IAChF,OAAO,CAAC,YAAY,CAA0B;IACvC,WAAW,UAAS;IAC3B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,aAAa,CAAK;IAC1B,8FAA8F;IAC9F,OAAO,CAAC,gBAAgB,CAAsB;IAE9C,oEAAoE;IACpE,IAAI,YAAY,WAEf;IAED;;;;OAIG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,IAAI;IASvB,OAAO,CAAC,mBAAmB;IAc3B,KAAK;IASL,QAAQ,CAAC,SAAS,EAAE,WAAW;IA0B/B,KAAK;CA+CN;AAED,eAAO,MAAM,gBAAgB,kBAAyB,CAAC;AACvD,eAAO,MAAM,eAAe,iBAAwB,CAAC;AACrD,eAAO,MAAM,eAAe,iBAAwB,CAAC"}

package/dist/types/lib/Template/x-x.d.ts

@@ -0,0 +1,60 @@
+import { type CleanupEventType } from "../Mutables/events/events";
+export declare class Component extends HTMLElement {
+    private _props;
+    _propsFn: () => Record<string, any>;
+    name: string;
+    private _view;
+    private _templateFn;
+    private _hasMounted;
+    private _renderScheduled;
+    _xviewRender: () => void;
+    componentId: number;
+    cleanups: Map<any, Function[]>;
+    scopes: Map<new () => any, () => any>;
+    /** useState instances registered on this component (for devtools inspection) */
+    _useStates: {
+        state: any;
+        atom: any;
+    }[];
+    addScope(scopeClass: new () => any, scope: any): void;
+    lastVersion: number;
+    /** DOM nesting depth (number of x-x ancestors). Used by RenderScheduler to sort parent-first. */
+    _depth: number;
+    /** Nearest x-x ancestor (set during connectedCallback depth walk). */
+    _parentComponent: Component | null;
+    /** Flush-cycle stamp set by _render(). Used by RenderScheduler to deduplicate. */
+    _renderVersion: number;
+    /** Error handlers registered via onError(). */
+    _errorHandlers: ((error: unknown) => void)[];
+    /** When non-null, the component is in error state and skips re-renders. */
+    _errorState: unknown;
+    onEachUpdateCallbacks: Set<() => void>;
+    onEachUpdate(callback: () => void): void;
+    DOMReadyEvent: null | CleanupEventType;
+    PaintEvent: null | CleanupEventType;
+    constructor();
+    set props(val: Record<string, any>);
+    get props(): Record<string, any>;
+    oldView: any;
+    private _isViewLoading;
+    /**
+     * When the view reference changes, store it, update the backing field, and
+     * reset mount state so the next render re-initialises.
+     *
+     * Scenario 2: element stays in DOM but internal component changes.
+     * We run a synchronous teardown of reactive state so the outer function
+     * re-runs on the next render.
+     */
+    private _applyViewChange;
+    set view(val: any);
+    get view(): any;
+    callOnEachUpdate(): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private _onRequestParentScope;
+    addToCleanUps(key: any, cleanup: Function): void;
+    _render(): void;
+    private _mountComponent;
+    private _handleRenderError;
+}
+//# sourceMappingURL=x-x.d.ts.map

package/dist/types/lib/Template/x-x.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-x.d.ts","sourceRoot":"","sources":["../../../../../lib/Template/x-x.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,KAAK,gBAAgB,EAAgB,MAAM,2BAA2B,CAAC;AAwBhF,qBAAa,SAAU,SAAQ,WAAW;IACxC,OAAO,CAAC,MAAM,CAAsB;IAE7B,QAAQ,EAAE,MAAM,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACpC,IAAI,SAAe;IAC1B,OAAO,CAAC,KAAK,CAAM;IACnB,OAAO,CAAC,WAAW,CAEV;IACT,OAAO,CAAC,WAAW,CAAU;IAC7B,OAAO,CAAC,gBAAgB,CAAU;IAE3B,YAAY,EAAE,MAAM,IAAI,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,GAAG,CAAC,GAAG,EAAE,QAAQ,EAAE,CAAC,CAAC;IAC/B,MAAM,EAAE,GAAG,CAAC,UAAU,GAAG,EAAE,MAAM,GAAG,CAAC,CAAa;IAEzD,gFAAgF;IACzE,UAAU,EAAE;QAAE,KAAK,EAAE,GAAG,CAAC;QAAC,IAAI,EAAE,GAAG,CAAA;KAAE,EAAE,CAAM;IAEpD,QAAQ,CAAC,UAAU,EAAE,UAAU,GAAG,EAAE,KAAK,EAAE,GAAG;IAIvC,WAAW,SAAM;IAExB,iGAAiG;IAC1F,MAAM,SAAK;IAClB,sEAAsE;IAC/D,gBAAgB,EAAE,SAAS,GAAG,IAAI,CAAQ;IACjD,kFAAkF;IAC3E,cAAc,SAAK;IAE1B,+CAA+C;IACxC,cAAc,EAAE,CAAC,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC,EAAE,CAAM;IACzD,2EAA2E;IACpE,WAAW,EAAE,OAAO,CAAQ;IAG5B,qBAAqB,EAAE,GAAG,CAAC,MAAM,IAAI,CAAC,CAAa;IACnD,YAAY,CAAC,QAAQ,EAAE,MAAM,IAAI;IAKjC,aAAa,EAAE,IAAI,GAAG,gBAAgB,CAAQ;IAC9C,UAAU,EAAE,IAAI,GAAG,gBAAgB,CAAQ;;IAwBlD,IAAI,KAAK,CAAC,GAAG,qBAAA,EAGZ;IAED,IAAI,KAAK,wBAER;IAEM,OAAO,EAAE,GAAG,CAAC;IAEpB,OAAO,CAAC,cAAc,CAAS;IAM/B;;;;;;;OAOG;IACH,OAAO,CAAC,gBAAgB;IAmBxB,IAAI,IAAI,CAAC,GAAG,KAAA,EAyBX;IAED,IAAI,IAAI,QAEP;IAMD,gBAAgB;IAIhB,iBAAiB;IAgCjB,oBAAoB;IAqBpB,OAAO,CAAC,qBAAqB,CAa3B;IAEF,aAAa,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,QAAQ;IAazC,OAAO;IA6CP,OAAO,CAAC,eAAe;IAqFvB,OAAO,CAAC,kBAAkB;CA0E3B"}

package/dist/types/lib/Template/x-x.types.d.ts

@@ -0,0 +1,91 @@
+import type { nothing, TemplateResult } from "lit-html";
+import type { Component as ComponentElement } from "./x-x";
+export type { Component as ComponentElement } from "./x-x";
+/**
+ * HostElement — the x-x custom element instance, augmented with
+ * runtime-added properties from hooks (useSetup, useState, etc.)
+ */
+export interface HostElement extends ComponentElement {
+    _setupStack?: any[];
+    _setupIndex?: number;
+    state?: any;
+    [key: string]: any;
+}
+/**
+ * TemplateFn — the inner function returned by a Component.
+ * Called on every render. Returns a lit-html TemplateResult.
+ */
+export type TemplateFn = () => TemplateResult | null | typeof nothing;
+/**
+ * Props<T> — a function that returns the props object of type T.
+ * This is what the Component receives as its argument.
+ *
+ * @example
+ * const props: Props<{ name: string }> = () => ({ name: "Alice" });
+ */
+export type Props<T = Record<string, any>> = () => T;
+/**
+ * Component<T> — a closure function that receives a Props<T> function
+ * and returns a TemplateFn. The outer function runs once on mount;
+ * the returned TemplateFn runs on every render.
+ *
+ * @example
+ * const MyComponent: Component<{ name: string }> = (props) => {
+ *   const count = atom(0);
+ *   return () => html`<div>${props().name}: ${count()}</div>`;
+ * };
+ */
+export type Component<T extends Record<string, any> = Record<string, any>> = (propsFn: Props<T>) => TemplateFn;
+/**
+ * LazyComponent<T> — an async function that returns a module (or a module
+ * with a `default` export) containing a `Component<T>`.  Pass one of these
+ * to `x()` or a `Router` config entry to enable code-splitting / lazy loading.
+ *
+ * The runtime detects `isAsyncValue(val) === true`, calls `resolveAsyncValue`,
+ * and then forwards the unwrapped `Component` to the normal render path once
+ * the promise settles.
+ *
+ * @example
+ * // inline with x():
+ * x(async () => import("./HeavyPage"));
+ *
+ * // inside Router config:
+ * Router([{ path: "/heavy", component: async () => import("./HeavyPage") }]);
+ */
+export type LazyComponent<T extends Record<string, any> = Record<string, any>> = () => Promise<Component<T> | {
+    default: Component<T>;
+}>;
+/**
+ * ComponentType<T> — the full union of everything that can be passed as a
+ * view / component reference.  Use this when you need to accept both eager
+ * and lazy forms in a single parameter type.
+ */
+export type ComponentType<T extends Record<string, any> = Record<string, any>> = Component<T> | LazyComponent<T>;
+/**
+ * Setter — wraps an event handler so it runs in the context of the
+ * current host component.
+ */
+export type Setter = <T extends (...args: any[]) => any>(fn: T) => T;
+/** @deprecated Use Component instead */
+export type ComponentFn<T extends Record<string, any> = Record<string, any>> = Component<T>;
+/** @deprecated Use Component instead */
+export type View<T extends Record<string, any> = Record<string, any>> = Component<T>;
+/** @deprecated Use Component instead */
+export type ClosureComponent<T extends Record<string, any> = Record<string, any>> = Component<T>;
+/** @deprecated Use Component instead */
+export type ViewComponent<T extends Record<string, any> = Record<string, any>> = Component<T>;
+/** @deprecated Use Component instead */
+export type C<T extends Record<string, any> = Record<string, any>> = Component<T>;
+/** @deprecated Use Component instead */
+export type OuterFn<T extends Record<string, any> = Record<string, any>> = Component<T>;
+/** @deprecated Use Props instead */
+export type PropsType<T extends Record<string, any> = Record<string, any>> = Props<T>;
+/** @deprecated Use TemplateFn instead */
+export type RenderFn = TemplateFn;
+/** @deprecated Use TemplateFn instead */
+export type InnerFn = TemplateFn;
+/** @deprecated Use TemplateFn instead */
+export type TemplateComponent = TemplateFn;
+/** @deprecated Use TemplateFn instead */
+export type X = TemplateFn;
+//# sourceMappingURL=x-x.types.d.ts.map

package/dist/types/lib/Template/x-x.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-x.types.d.ts","sourceRoot":"","sources":["../../../../../lib/Template/x-x.types.ts"],"names":[],"mappings":"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"}

package/dist/types/lib/Template/x-x.utils.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Checks whether a value is async — an AsyncFunction, a Promise, or a thenable.
+ */
+export declare function isAsyncValue(val: any): boolean;
+/**
+ * Normalises an async value (AsyncFunction | Promise | thenable) into a plain
+ * Promise so callers can simply `.then(...)` on the result.
+ */
+export declare function resolveAsyncValue(val: any): Promise<any>;
+/**
+ * Extracts the resolved module's default export (if present) or the module
+ * itself.  Used after awaiting a lazy / async component import.
+ */
+export declare function unwrapModule(module: any): any;
+//# sourceMappingURL=x-x.utils.d.ts.map

package/dist/types/lib/Template/x-x.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-x.utils.d.ts","sourceRoot":"","sources":["../../../../../lib/Template/x-x.utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAQ9C;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAGxD;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,CAE7C"}

package/dist/types/lib/Template/x.d.ts

@@ -0,0 +1,5 @@
+import type { ComponentType } from "./x-x.types";
+export declare const x: <T extends Record<string, any>>(viewFn: ComponentType<T>, props?: T) => import("lit-html").TemplateResult<1>;
+export declare const view: <T extends Record<string, any>>(viewFn: ComponentType<T>, props?: T) => import("lit-html").TemplateResult<1>;
+export declare const renderX: <T extends Record<string, any>>(viewFn: ComponentType<T>, element: HTMLElement, props?: T) => import("lit-html").RootPart;
+//# sourceMappingURL=x.d.ts.map

package/dist/types/lib/Template/x.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x.d.ts","sourceRoot":"","sources":["../../../../../lib/Template/x.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,eAAO,MAAM,CAAC,GAAI,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC7C,QAAQ,aAAa,CAAC,CAAC,CAAC,EACxB,QAAO,CAAW,yCAGnB,CAAC;AAGF,eAAO,MAAM,IAAI,GARC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,UACrC,aAAa,CAAC,CAAC,CAAC,UACjB,CAAC,yCAMW,CAAC;AAEtB,eAAO,MAAM,OAAO,GAAI,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACnD,QAAQ,aAAa,CAAC,CAAC,CAAC,EACxB,SAAS,WAAW,EACpB,QAAO,CAAW,gCAGnB,CAAC"}

package/dist/types/lib/Template/xProvider.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=xProvider.d.ts.map

package/dist/types/lib/Template/xProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xProvider.d.ts","sourceRoot":"","sources":["../../../../../lib/Template/xProvider.ts"],"names":[],"mappings":""}

package/dist/types/lib/Timers/createManagedTimer.d.ts

@@ -0,0 +1,12 @@
+type TimerType = "timeout" | "interval";
+type TimerId = ReturnType<typeof setTimeout> | ReturnType<typeof setInterval>;
+/**
+ * Internal helper to create managed timers with automatic cleanup
+ * @param fn - Function to execute
+ * @param delay - Delay/interval in milliseconds
+ * @param type - Timer type (timeout or interval)
+ * @returns Timer ID
+ */
+export declare const createManagedTimer: (fn: () => void, delay: number, type: TimerType) => TimerId;
+export {};
+//# sourceMappingURL=createManagedTimer.d.ts.map

package/dist/types/lib/Timers/createManagedTimer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createManagedTimer.d.ts","sourceRoot":"","sources":["../../../../../lib/Timers/createManagedTimer.ts"],"names":[],"mappings":"AAEA,KAAK,SAAS,GAAG,SAAS,GAAG,UAAU,CAAC;AACxC,KAAK,OAAO,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;AAE9E;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,GAC7B,IAAI,MAAM,IAAI,EACd,OAAO,MAAM,EACb,MAAM,SAAS,KACd,OAcF,CAAC"}

package/dist/types/lib/Timers/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./createManagedTimer";
+export * from "./interval";
+export * from "./timeout";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/lib/Timers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../lib/Timers/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC"}

package/dist/types/lib/Timers/interval.d.ts

@@ -0,0 +1,2 @@
+export declare const onInterval: (fn: () => void, interval: number) => number;
+//# sourceMappingURL=interval.d.ts.map

package/dist/types/lib/Timers/interval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interval.d.ts","sourceRoot":"","sources":["../../../../../lib/Timers/interval.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,UAAU,GAAI,IAAI,MAAM,IAAI,EAAE,UAAU,MAAM,WAE1D,CAAC"}

package/dist/types/lib/Timers/timeout.d.ts

@@ -0,0 +1,2 @@
+export declare const onTimeout: (fn: () => void, delay: number) => number;
+//# sourceMappingURL=timeout.d.ts.map

package/dist/types/lib/Timers/timeout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeout.d.ts","sourceRoot":"","sources":["../../../../../lib/Timers/timeout.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,SAAS,GAAI,IAAI,MAAM,IAAI,EAAE,OAAO,MAAM,WAEtD,CAAC"}

package/dist/types/lib/TrackState/componentStatus.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Global component running status tracker.
+ * Used to enforce safety checks and prevent certain operations during specific
+ * execution contexts.
+ */
+export declare const componentRunningStatus: {
+    /**
+     * Set to true while a scope's setup() method is running.
+     *
+     * NOTE: setup() is called during scope creation, which can only happen inside
+     * a component's outer function. The outer function is an unrestricted context,
+     * so setup() inherits the same permissions — reactive primitives (atoms, events,
+     * channels, actions, setters, on(), effect(), …) CAN be created freely here,
+     * exactly as they can be in the outer function itself.
+     *
+     * This flag is kept for informational / tooling purposes (e.g. CSS-in-JS
+     * assertModuleLevel checks) and is NOT used by assertNotInRestrictedContext.
+     */
+    setupInProgress: boolean;
+    /**
+     * Set to true while the template function (inner render function) is running.
+     *
+     * During template execution reactive primitives CANNOT be created because the
+     * template reruns on every update — creating atoms/events/etc. here would
+     * produce a new instance on every render, causing memory leaks and broken
+     * reactivity.  Only `scope()` / `useScope()` lookups are permitted.
+     */
+    templateInProgress: boolean;
+    /**
+     * Set to true while a component's outer function is running.
+     * Tracked for debugging / devtools purposes only — does NOT restrict anything.
+     * Reactive primitives CAN be created freely in the outer function.
+     */
+    viewOuterInProgress: boolean;
+    /**
+     * Set to true while an `eleHook()` or `htmlHook()` mount or lifecycle
+     * callback is executing. Indicates that a hook is in progress and allows
+     * certain operations that would otherwise be restricted.
+     */
+    isHookRunning: boolean;
+};
+/**
+ * Returns true when the current execution context forbids the creation of new
+ * reactive primitives.
+ *
+ * Restricted contexts
+ * ───────────────────
+ *   • Template function   — reruns every render; primitives created here leak
+ *   • effect() / memo()   — should only read state, never create new primitives
+ *
+ * Unrestricted contexts
+ * ─────────────────────
+ *   • ES module scope     — top of file, safe to create global primitives
+ *   • Component outer fn  — runs once on mount; the canonical place for locals
+ *   • Scope setup()       — called from the outer fn, inherits its permissions
+ *   • Hook callbacks      — eleHook / htmlHook mount and lifecycle methods run
+ *                           with isHookRunning = true. Subscriptions and atom
+ *                           creation are permitted because the hook author owns
+ *                           teardown via the onCleanup return value.
+ */
+export declare function isInRestrictedContext(): boolean;
+/**
+ * Throws a descriptive error when called from a restricted execution context.
+ *
+ * Allowed
+ * ───────
+ *   ✅  ES module scope           (top-level, outside any component)
+ *   ✅  Component outer function  (runs once on mount)
+ *   ✅  Scope setup()             (runs inside the outer function — same rules)
+ *   ✅  Hook callbacks            (isHookRunning === true)
+ *                                 eleHook / htmlHook mount and lifecycle methods
+ *                                 may freely subscribe and create atoms. The hook
+ *                                 author is responsible for unsubscribing inside
+ *                                 the onCleanup return — this is NOT automatic.
+ *
+ * Forbidden
+ * ─────────
+ *   ❌  Template / render function   (templateInProgress === true)
+ *   ❌  effect() or memo() callback  (isEffectRunning()  === true)
+ */
+export declare function assertNotInRestrictedContext(operationName: string): void;
+/**
+ * Throws unless the current execution context is a component's outer function
+ * (i.e. `viewOuterInProgress === true`).
+ *
+ * Use this for APIs — such as `ws()` — that register cleanup handlers via
+ * `registerCleanup` and therefore require an active component host.  Calling
+ * them at module level or inside inner functions (event handlers, timers, etc.)
+ * would silently skip cleanup, leaving timers and sockets running after the
+ * component unmounts.
+ *
+ * Allowed
+ * ───────
+ *   ✅  Component outer function  (viewOuterInProgress === true)
+ *   ✅  Scope setup()             (sets viewOuterInProgress = true, same rules)
+ *
+ * Forbidden
+ * ─────────
+ *   ❌  Module / file scope                      (no active host, no cleanup)
+ *   ❌  Inner functions / event handlers         (outer fn has already returned)
+ *   ❌  Template / render function               (templateInProgress === true)
+ *   ❌  effect() or memo() callback              (isEffectRunning() === true)
+ */
+export declare function assertComponentOuterContext(operationName: string): void;
+//# sourceMappingURL=componentStatus.d.ts.map

package/dist/types/lib/TrackState/componentStatus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"componentStatus.d.ts","sourceRoot":"","sources":["../../../../../lib/TrackState/componentStatus.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,sBAAsB;IACjC;;;;;;;;;;;OAWG;;IAGH;;;;;;;OAOG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;CAEJ,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,qBAAqB,IAAI,OAAO,CAG/C;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,4BAA4B,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAiBxE;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,2BAA2B,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAsBvE"}

package/dist/types/lib/TrackState/readTracking.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Read tracking state for dependency collection.
+ * Used by atoms, units, getters, and effects to track which stores are read
+ * during reactive computations.
+ */
+export declare function isReadTrackingEnabled(): boolean;
+export declare function getStoresBeingRead(): Set<any>;
+export declare function isEffectRunning(): boolean;
+export declare function addStoreBeingRead(store: any): void;
+export declare function pushEffect(): void;
+export declare function popEffect(): void;
+export interface TrackingSnapshot {
+    prevEnabled: boolean;
+    prevStores: Set<any>;
+}
+export declare function saveAndEnableTracking(): TrackingSnapshot;
+export declare function restoreTracking(prev: TrackingSnapshot): Set<any>;
+export declare const startTracking: typeof saveAndEnableTracking;
+export declare const stopTracking: typeof restoreTracking;
+//# sourceMappingURL=readTracking.d.ts.map

package/dist/types/lib/TrackState/readTracking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readTracking.d.ts","sourceRoot":"","sources":["../../../../../lib/TrackState/readTracking.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAQH,wBAAgB,qBAAqB,IAAI,OAAO,CAE/C;AAED,wBAAgB,kBAAkB,IAAI,GAAG,CAAC,GAAG,CAAC,CAE7C;AAED,wBAAgB,eAAe,IAAI,OAAO,CAEzC;AAID,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,GAAG,QAE3C;AAED,wBAAgB,UAAU,SAEzB;AAED,wBAAgB,SAAS,SAExB;AAID,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,OAAO,CAAC;IACrB,UAAU,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;CACtB;AAED,wBAAgB,qBAAqB,IAAI,gBAAgB,CAQxD;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,gBAAgB,GAAG,GAAG,CAAC,GAAG,CAAC,CAKhE;AAID,eAAO,MAAM,aAAa,8BAAwB,CAAC;AACnD,eAAO,MAAM,YAAY,wBAAkB,CAAC"}

package/dist/types/lib/Utils/Context.d.ts

@@ -0,0 +1,6 @@
+export declare class Context<T> {
+    id: string;
+    context: T;
+}
+export default Context;
+//# sourceMappingURL=Context.d.ts.map

package/dist/types/lib/Utils/Context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Context.d.ts","sourceRoot":"","sources":["../../../../../lib/Utils/Context.ts"],"names":[],"mappings":"AAAA,qBAAa,OAAO,CAAC,CAAC;IACpB,EAAE,SAA+C;IACjD,OAAO,EAAE,CAAC,CAAwB;CACnC;AAED,eAAe,OAAO,CAAC"}