@mhmo91/schmancy 0.9.27 → 0.10.1

package/types/src/sheet/sheet.d.ts

@@ -1,23 +1,7 @@
+import { SchmancyElement } from '@mixins/index';
 import { SchmancySheetPosition } from './sheet.service';
-declare const SchmancySheet_base: CustomElementConstructor & import("@mixins/index").Constructor<import("lit").LitElement> & import("@mixins/index").Constructor<import("@mixins/index").IBaseMixin>;
-/**
- * Side-docked or bottom-docked panel — a dialog variant that slides in from an edge. Driven imperatively by the `sheet` service; rarely instantiated directly.
- *
- * @element schmancy-sheet
- * @summary Prefer `sheet.open({ component, position })` over placing this element declaratively — the service handles stacking, focus, close on outside-click, ESC, and router integration.
- * @example
- * import { sheet, SchmancySheetPosition } from '@mhmo91/schmancy'
- * sheet.open({
- *   component: new MyEditorElement(),
- *   position: SchmancySheetPosition.Side,
- *   title: 'Edit item',
- * })
- * @platform dialog close - Positioned-fixed panel with backdrop. Degrades to a `<dialog>` if the tag never registers — loses slide animation, keeps focus trap + dismiss.
- * @attr position - `'side' | 'bottom'`. Which edge the sheet docks to.
- * @attr open - Boolean; sheet is visible when true.
- * @fires close - When the sheet is dismissed (backdrop click, close button, ESC).
- */
-export default class SchmancySheet extends SchmancySheet_base {
+export default class SchmancySheet extends SchmancyElement {
+    static styles: import("lit").CSSResult[];
     open: boolean;
     position: SchmancySheetPosition;
     persist: boolean;
@@ -43,4 +27,3 @@ declare global {
         'schmancy-sheet': SchmancySheet;
     }
 }
-export {};

package/types/src/skeleton/skeleton.d.ts

@@ -1,4 +1,4 @@
-declare const SchmancySkeleton_base: import("@mixins/index").Constructor<CustomElementConstructor> & import("@mixins/index").Constructor<import("@mixins/index").ITailwindElementMixin> & import("@mixins/index").Constructor<import("lit").LitElement> & import("@mixins/index").Constructor<import("@mixins/index").IBaseMixin>;
+import { SchmancyElement } from '@mixins/index';
 /**
  * Placeholder shimmer surface shown while content loads. Renders a
  * shape-configurable rectangle with a reduced-motion-aware shimmer.
@@ -10,7 +10,8 @@ declare const SchmancySkeleton_base: import("@mixins/index").Constructor<CustomE
  * @attr radius - CSS length for corner radius; ignored for `shape=circle`.
  * @csspart surface - The shimmering surface element.
  */
-export declare class SchmancySkeleton extends SchmancySkeleton_base {
+export declare class SchmancySkeleton extends SchmancyElement {
+    static styles: import("lit").CSSResult[];
     shape: 'rect' | 'circle' | 'text';
     width: string;
     height: string;
@@ -24,4 +25,3 @@ declare global {
         'schmancy-skeleton': SchmancySkeleton;
     }
 }
-export {};

package/types/src/slider/slide.d.ts

@@ -1,3 +1,4 @@
+import { SchmancyElement } from '@mixins/index';
 /**
  * Supported slide "types."
  * - 'image': Renders an <img>
@@ -10,8 +11,8 @@ type SlideType = 'image' | 'video' | 'content';
  * which maps to CSS object-fit.
  */
 type ObjectFit = 'cover' | 'contain' | 'fill' | 'scale-down' | 'none';
-declare const SchmancySlide_base: CustomElementConstructor & import("@mixins/index").Constructor<import("lit").LitElement> & import("@mixins/index").Constructor<import("@mixins/index").IBaseMixin>;
-export declare class SchmancySlide extends SchmancySlide_base {
+export declare class SchmancySlide extends SchmancyElement {
+    static styles: import("lit").CSSResult[];
     /**
      * Determines how this slide should be rendered.
      * Defaults to 'content' if not provided.

package/types/src/slider/slider.d.ts

@@ -1,5 +1,6 @@
-declare const SchmancySlider_base: CustomElementConstructor & import("@mixins/index").Constructor<import("lit").LitElement> & import("@mixins/index").Constructor<import("@mixins/index").IBaseMixin>;
-export declare class SchmancySlider extends SchmancySlider_base {
+import { SchmancyElement } from '@mixins/index';
+export declare class SchmancySlider extends SchmancyElement {
+    static styles: import("lit").CSSResult[];
     /**
      * Currently centered slide index
      */
@@ -22,4 +23,3 @@ declare global {
         'schmancy-slider': SchmancySlider;
     }
 }
-export {};

package/types/src/splash-screen/splash-screen.d.ts

@@ -1,5 +1,5 @@
+import { SchmancyElement } from '@mixins/index';
 export type SchmancySplashScreenDoneEvent = CustomEvent<void>;
-declare const SchmancySplashScreen_base: CustomElementConstructor & import("../../mixins").Constructor<import("lit").LitElement> & import("../../mixins").Constructor<import("../../mixins").IBaseMixin>;
 /**
  * Full-viewport splash overlay that dismisses once a minimum duration has
  * elapsed and (optionally) an external `ready` signal has fired. The splash
@@ -22,7 +22,8 @@ declare const SchmancySplashScreen_base: CustomElementConstructor & import("../.
  * </schmancy-splash-screen>
  * ```
  */
-export default class SchmancySplashScreen extends SchmancySplashScreen_base {
+export default class SchmancySplashScreen extends SchmancyElement {
+    static styles: import("lit").CSSResult[];
     /**
      * Minimum duration (ms) the splash layer stays visible. Prevents a flash
      * when the app loads faster than expected.
@@ -57,4 +58,3 @@ declare global {
         'schmancy-splash-screen': SchmancySplashScreen;
     }
 }
-export {};

package/types/src/state/active-host.d.ts

@@ -0,0 +1,18 @@
+declare global {
+    interface Promise<T> {
+        readonly __schmancyActiveHostPatched?: true;
+    }
+}
+export declare const _activeHost: {
+    /** Run `fn` with `host` as the active host for the duration of `fn` and
+     *  any awaits / microtasks / Promise chains that descend from it. */
+    run<R>(host: HTMLElement | undefined, fn: () => R): R;
+    /** The current active host, or undefined if no `run()` is on the stack. */
+    get(): HTMLElement | undefined;
+};
+export declare function resolveActiveHost(): HTMLElement | undefined;
+/** Stable context key for a state namespace. `Symbol.for(...)` so the same
+ *  namespace string yields the same symbol across module boundaries — the
+ *  ContextProvider on `<schmancy-context>` and the ContextRequestEvent
+ *  dispatched by a state read must agree on identity. */
+export declare function stateContextKey(namespace: string): symbol;

package/types/src/state/index.d.ts

@@ -0,0 +1,145 @@
+import { Signal } from '@lit-labs/signals';
+import { Observable } from 'rxjs';
+import { type Draft } from 'immer';
+import { type StorageBackend } from './persist';
+import './schmancy-context';
+export type { StorageBackend } from './persist';
+export { Signal } from '@lit-labs/signals';
+export { _activeHost } from './active-host';
+export { SchmancyContext } from './schmancy-context';
+declare const stateBrand: unique symbol;
+declare const namespaceBrand: unique symbol;
+/**
+ * Open registry — augment via `declare module '@mhmo91/schmancy/state'` to
+ * bind a TypeScript type to a namespace string. Augmenting flips that
+ * namespace to overload (A) of the factory: zero ceremony at the call
+ * site, T comes from the registry.
+ */
+export interface SchmancyStateRegistry {
+}
+export type RegisteredNamespace = keyof SchmancyStateRegistry & string;
+/** Feature-prefix convention enforced at compile time. */
+export type FeatureNamespace = `${string}/${string}`;
+export type AssertNovel<NS extends string> = NS extends RegisteredNamespace ? never & {
+    readonly __error: `Namespace "${NS}" already registered`;
+} : NS;
+export type SyncStorage = Exclude<StorageBackend, 'indexeddb'>;
+export type AsyncStorage = Extract<StorageBackend, 'indexeddb'>;
+export type IsAsync<S extends StorageBackend> = S extends AsyncStorage ? true : false;
+type _Has<T, U> = T extends U ? true : never;
+type _IsNullable<T> = [_Has<T, null> | _Has<T, undefined>] extends [never] ? false : true;
+/**
+ * Shape classifier — drives the variant write API per T. Order: structural
+ * shapes first (Map / Set / Array), primitives, then nullable-union check,
+ * then plain object.
+ */
+export type Kind<T> = [T] extends [Map<unknown, unknown>] ? 'map' : [T] extends [Set<unknown>] ? 'set' : [T] extends [readonly unknown[]] ? 'array' : [T] extends [string | number | boolean | bigint | symbol] ? 'primitive' : _IsNullable<T> extends true ? 'nullable' : [T] extends [object] ? 'object' : 'unknown';
+export interface ObjectAPI<T> {
+    set(patch: Partial<T>, merge?: boolean): void;
+    replace(next: T): void;
+    update(recipe: (draft: Draft<T>) => void): void;
+    delete<K extends keyof T>(key: K): void;
+}
+export interface MapAPI<T> {
+    set: T extends Map<infer K, infer V> ? (key: K, value: V) => void : never;
+    replace(next: T): void;
+    delete: T extends Map<infer K, unknown> ? (key: K) => void : never;
+    clear(): void;
+}
+export interface SetAPI<T> {
+    add: T extends Set<infer U> ? (value: U) => void : never;
+    delete: T extends Set<infer U> ? (value: U) => boolean : never;
+    toggle: T extends Set<infer U> ? (value: U) => void : never;
+    replace(next: T): void;
+    clear(): void;
+}
+export interface ArrayAPI<T> {
+    push: T extends readonly (infer U)[] ? (...items: U[]) => void : never;
+    replace(next: T): void;
+    update(recipe: (draft: Draft<T>) => void): void;
+    clear(): void;
+}
+export interface ScalarAPI<T> {
+    set(next: T): void;
+    replace(next: T): void;
+}
+export type WriteAPI<T> = Kind<T> extends 'map' ? MapAPI<T> : Kind<T> extends 'set' ? SetAPI<T> : Kind<T> extends 'array' ? ArrayAPI<T> : Kind<T> extends 'object' ? ObjectAPI<T> : ScalarAPI<T>;
+export interface BaseAPI<NS extends string, T, S extends StorageBackend> {
+    readonly [stateBrand]: true;
+    readonly namespace: NS & {
+        readonly [namespaceBrand]: NS;
+    };
+    readonly storage: S;
+    /**
+     * Current value. For sync backends (memory/local/session) the load is
+     * synchronous, so the type narrows to `T`. For `idb` the load is genuinely
+     * async — `value` is `T | undefined` until `ready` resolves. Read with
+     * `state.value ?? state.defaultValue` if you don't care about the
+     * pre-load distinction; await `state.ready` if you do.
+     */
+    readonly value: IsAsync<S> extends true ? T | undefined : T;
+    readonly defaultValue: T;
+    readonly ready: Promise<void>;
+    readonly loaded: boolean;
+    readonly signal: Signal.State<T>;
+    readonly $: Observable<T>;
+    destroy(): void;
+    /** Internal: build a fresh per-`<schmancy-context>` copy seeded with the
+     *  current value. Exposed on the type so a state can be passed to
+     *  `<schmancy-context provides={[…]}>` without casts. Not for end-user
+     *  code — the leading underscore signals "internal API". */
+    _isolatedInstance(): {
+        destroy(): void;
+    } & Record<string | symbol, unknown>;
+}
+export interface SyncState<NS extends string, T, S extends SyncStorage> extends BaseAPI<NS, T, S>, Disposable {
+    [Symbol.dispose](): void;
+}
+export interface AsyncState<NS extends string, T> extends BaseAPI<NS, T, 'indexeddb'>, Disposable, AsyncDisposable {
+    [Symbol.dispose](): void;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+export type State<NS extends string, T, S extends StorageBackend> = S extends AsyncStorage ? AsyncState<NS, T> & WriteAPI<T> : SyncState<NS, T, S extends SyncStorage ? S : never> & WriteAPI<T>;
+export interface NamespaceHandlePinned<NS extends string, T> {
+    memory(initial: T): State<NS, T, 'memory'>;
+    local(initial: T): State<NS, T, 'local'>;
+    session(initial: T): State<NS, T, 'session'>;
+    idb(initial: T): State<NS, T, 'indexeddb'>;
+}
+export interface NamespaceHandleInferred<NS extends string> {
+    memory<U>(initial: U): State<NS, U, 'memory'>;
+    local<U>(initial: U): State<NS, U, 'local'>;
+    session<U>(initial: U): State<NS, U, 'session'>;
+    idb<U>(initial: U): State<NS, U, 'indexeddb'>;
+}
+export declare function state<NS extends RegisteredNamespace>(namespace: NS): NamespaceHandlePinned<NS, SchmancyStateRegistry[NS]>;
+export declare function state<const NS extends FeatureNamespace>(namespace: NS extends RegisteredNamespace ? never : AssertNovel<NS>): NamespaceHandleInferred<NS>;
+export declare function state<T, const NS extends FeatureNamespace = FeatureNamespace>(namespace: NS extends RegisteredNamespace ? never : AssertNovel<NS>): NamespaceHandlePinned<NS, T>;
+export { computed } from '@lit-labs/signals';
+export interface EffectHandle extends Disposable {
+    [Symbol.dispose](): void;
+}
+export declare function effect(fn: () => void): EffectHandle;
+export interface FromObservableOptions {
+    storage?: StorageBackend;
+}
+/**
+ * Lift an Observable into a state(). The state is initialized with
+ * `initial`, then updates on every Observable emission. Cleanup on
+ * dispose unsubscribes the source.
+ */
+export declare function stateFromObservable<T, NS extends FeatureNamespace>(observable: Observable<T>, namespace: NS, initial: T, options?: FromObservableOptions): State<NS, T, 'memory'>;
+import type { ReactiveControllerHost } from 'lit';
+/** Permissive duck-typed contract — v1 IStore<T>, v2 State<>, and
+ *  computed() outputs (`Signal.Computed<T>` wrapped in a thin shim) all
+ *  satisfy it once you supply a `value` getter and an Observable `$`. */
+export interface ObservableState<T> {
+    readonly value: T;
+    readonly $: Observable<T>;
+}
+export interface BoundState<T> {
+    readonly value: T;
+    readonly $: Observable<T>;
+}
+export declare function bindState<T>(host: ReactiveControllerHost, source: ObservableState<T>): BoundState<T>;
+export declare function observe<T>(source: ObservableState<T>): (proto: object, propertyKey: string | symbol) => void;

package/types/src/state/persist.d.ts

@@ -0,0 +1,14 @@
+export type StorageBackend = 'memory' | 'local' | 'session' | 'indexeddb';
+export interface StorageAdapter<T> {
+    load(): Promise<T | null>;
+    save(value: T): Promise<void>;
+    clear(): Promise<void>;
+    close?(): Promise<void>;
+}
+export declare class StateStorageError<T = unknown> extends Error {
+    readonly cause?: T;
+    readonly context?: Record<string, unknown>;
+    readonly timestamp: Date;
+    constructor(message: string, cause?: T, context?: Record<string, unknown>);
+}
+export declare function createAdapter<T>(backend: StorageBackend, key: string): StorageAdapter<T>;

package/types/src/state/schmancy-context.d.ts

@@ -0,0 +1,31 @@
+import { LitElement } from 'lit';
+/** Duck-typed view of what the `state()` factory hands out, restricted to the
+ *  bits `<schmancy-context>` needs. Kept internal — consumers see the full
+ *  `State<>` type and never refer to this. */
+export interface StateTemplate {
+    readonly namespace: string;
+    readonly value: unknown;
+    /** Internal hook the factory adds to every state instance. Builds a fresh
+     *  per-context copy seeded with the current value, sharing nothing with the
+     *  global instance. The returned object exposes `destroy()` so the context
+     *  element can flush + close on disconnect. */
+    _isolatedInstance(): {
+        destroy(): void;
+    } & Record<string | symbol, unknown>;
+}
+export declare class SchmancyContext extends LitElement {
+    /** States to isolate under this subtree. Pass the same instances you import
+     *  at module scope (e.g. `provides={[cart, menu]}`). Outside this element
+     *  they continue to behave as module-scoped globals; descendants of this
+     *  element see a per-element isolated copy. */
+    provides: readonly StateTemplate[];
+    private _scoped;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'schmancy-context': SchmancyContext;
+    }
+}

package/types/src/state/state.test-d.d.ts

@@ -0,0 +1,131 @@
+import type { AssertNovel, FeatureNamespace, IsAsync, Kind, ObjectAPI, State } from './index';
+type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
+type Expect<T extends true> = T;
+type Assignable<A, B> = A extends B ? true : false;
+interface CartItem {
+    id: string;
+    name: string;
+    price: number;
+    quantity: number;
+}
+interface CartState {
+    items: CartItem[];
+    total: number;
+}
+interface PamDoc {
+    id: string;
+    amount: number;
+}
+declare function form1Probe(): import("./index").SyncState<"test-d/cart-form-1", CartState, "session"> & ObjectAPI<CartState>;
+declare function form2Probe(): import("./index").SyncState<`${string}/${string}`, CartState, "session"> & ObjectAPI<CartState>;
+declare function mapProbe(): import("./index").AsyncState<`${string}/${string}`, Map<string, PamDoc>> & import("./index").MapAPI<Map<string, PamDoc>>;
+declare function setProbe(): import("./index").SyncState<`${string}/${string}`, Set<string>, "memory"> & import("./index").SetAPI<Set<string>>;
+declare function arrayProbe(): import("./index").SyncState<`${string}/${string}`, number[], "memory"> & import("./index").ArrayAPI<number[]>;
+declare function flagProbe(): import("./index").SyncState<`${string}/${string}`, boolean, "memory"> & import("./index").ScalarAPI<boolean>;
+type Form1 = ReturnType<typeof form1Probe>;
+type Form2 = ReturnType<typeof form2Probe>;
+type Docs = ReturnType<typeof mapProbe>;
+type Sel = ReturnType<typeof setProbe>;
+type Items = ReturnType<typeof arrayProbe>;
+type Flag = ReturnType<typeof flagProbe>;
+type _kObject = Expect<Equal<Kind<CartState>, 'object'>>;
+type _kMap = Expect<Equal<Kind<Map<string, PamDoc>>, 'map'>>;
+type _kSet = Expect<Equal<Kind<Set<string>>, 'set'>>;
+type _kArrayReadonly = Expect<Equal<Kind<readonly string[]>, 'array'>>;
+type _kArrayMutable = Expect<Equal<Kind<string[]>, 'array'>>;
+type _kBoolean = Expect<Equal<Kind<boolean>, 'primitive'>>;
+type _kNumber = Expect<Equal<Kind<number>, 'primitive'>>;
+type _kString = Expect<Equal<Kind<string>, 'primitive'>>;
+type _idbAsync = Expect<Equal<IsAsync<'indexeddb'>, true>>;
+type _memSync = Expect<Equal<IsAsync<'memory'>, false>>;
+type _sesSync = Expect<Equal<IsAsync<'session'>, false>>;
+type _locSync = Expect<Equal<IsAsync<'local'>, false>>;
+type _f1Value = Expect<Equal<Form1['value'], CartState>>;
+type _f1SetArg0 = Expect<Equal<Parameters<Form1['set']>[0], Partial<CartState>>>;
+type _f1SetArg1 = Expect<Equal<Parameters<Form1['set']>[1], boolean | undefined>>;
+type _f1Replace = Expect<Equal<Parameters<Form1['replace']>, [CartState]>>;
+type _f2SetArg0 = Expect<Equal<Parameters<Form2['set']>[0], Partial<CartState>>>;
+type _f2SetArg1 = Expect<Equal<Parameters<Form2['set']>[1], boolean | undefined>>;
+type _f2Replace = Expect<Equal<Parameters<Form2['replace']>, [CartState]>>;
+type _f2DeleteKeys = Expect<Equal<Parameters<Form2['delete']>[0], keyof CartState>>;
+type _f2HasUpdate = Expect<Assignable<Form2, {
+    update: ObjectAPI<CartState>['update'];
+}>>;
+type _f2Value = Expect<Equal<Form2['value'], CartState>>;
+type _f2Sync = Expect<Assignable<Form2, Disposable>>;
+type _docsSetShape = Expect<Equal<Parameters<Docs['set']>, [string, PamDoc]>>;
+type _docsDeleteShape = Expect<Equal<Parameters<Docs['delete']>, [string]>>;
+type _docsHasClear = Expect<Equal<Parameters<Docs['clear']>, []>>;
+type _docsValue = Expect<Equal<Docs['value'], Map<string, PamDoc>>>;
+type _docsAsync = Expect<Assignable<Docs, AsyncDisposable>>;
+type _docsSync = Expect<Assignable<Docs, Disposable>>;
+type _selAdd = Expect<Equal<Parameters<Sel['add']>, [string]>>;
+type _selToggle = Expect<Equal<Parameters<Sel['toggle']>, [string]>>;
+type _selDelete = Expect<Equal<Parameters<Sel['delete']>, [string]>>;
+type _selDeleteReturns = Expect<Equal<ReturnType<Sel['delete']>, boolean>>;
+type _selValue = Expect<Equal<Sel['value'], Set<string>>>;
+type _selSync = Expect<Assignable<Sel, Disposable>>;
+type _itemsPush = Expect<Equal<Parameters<Items['push']>, number[]>>;
+type _itemsHasUpdate = Expect<Equal<'update' extends keyof Items ? true : false, true>>;
+type _itemsHasClear = Expect<Equal<'clear' extends keyof Items ? true : false, true>>;
+type _flagSet = Expect<Equal<Parameters<Flag['set']>, [boolean]>>;
+type _flagNoUpdate = Expect<Equal<'update' extends keyof Flag ? true : false, false>>;
+type _flagNoDelete = Expect<Equal<'delete' extends keyof Flag ? true : false, false>>;
+type _slashlessRejected = Expect<Equal<'cart' extends FeatureNamespace ? true : false, false>>;
+type _slashedAccepted = Expect<Equal<'a/b' extends FeatureNamespace ? true : false, true>>;
+type _twoSlashesAccepted = Expect<Equal<'a/b/c' extends FeatureNamespace ? true : false, true>>;
+type _assertNovelOnFresh = Expect<Equal<AssertNovel<'test-d/fresh'>, 'test-d/fresh'>>;
+type _syncMemoryState = Expect<Assignable<State<'test-d/x', CartState, 'memory'>, {
+    value: CartState;
+}>>;
+type _asyncIdbState = Expect<Assignable<State<'test-d/x', CartState, 'indexeddb'>, AsyncDisposable>>;
+export type _SchmancyStateTypeSpec = [
+    _kObject,
+    _kMap,
+    _kSet,
+    _kArrayReadonly,
+    _kArrayMutable,
+    _kBoolean,
+    _kNumber,
+    _kString,
+    _idbAsync,
+    _memSync,
+    _sesSync,
+    _locSync,
+    _f1Value,
+    _f1SetArg0,
+    _f1SetArg1,
+    _f1Replace,
+    _f2SetArg0,
+    _f2SetArg1,
+    _f2Replace,
+    _f2DeleteKeys,
+    _f2HasUpdate,
+    _f2Value,
+    _f2Sync,
+    _docsSetShape,
+    _docsDeleteShape,
+    _docsHasClear,
+    _docsValue,
+    _docsAsync,
+    _docsSync,
+    _selAdd,
+    _selToggle,
+    _selDelete,
+    _selDeleteReturns,
+    _selValue,
+    _selSync,
+    _itemsPush,
+    _itemsHasUpdate,
+    _itemsHasClear,
+    _flagSet,
+    _flagNoUpdate,
+    _flagNoDelete,
+    _slashlessRejected,
+    _slashedAccepted,
+    _twoSlashesAccepted,
+    _assertNovelOnFresh,
+    _syncMemoryState,
+    _asyncIdbState
+];
+export {};

package/types/src/state/state.test.d.ts

@@ -0,0 +1 @@
+export {};

package/types/src/steps/schmancy-step.d.ts

@@ -1,5 +1,6 @@
-declare const SchmancyStep_base: CustomElementConstructor & import("../../mixins").Constructor<import("lit").LitElement> & import("../../mixins").Constructor<import("../../mixins").IBaseMixin>;
-export declare class SchmancyStep extends SchmancyStep_base {
+import { SchmancyElement } from '@mixins/index';
+export declare class SchmancyStep extends SchmancyElement {
+    static styles: import("lit").CSSResult[];
     /**
      * The step's position (1-based). This is used to compare against
      * the container's current step to decide if it's "complete",
@@ -50,4 +51,3 @@ declare global {
         'schmancy-step': SchmancyStep;
     }
 }
-export {};

package/types/src/steps/schmancy-steps-container.d.ts

@@ -1,3 +1,4 @@
+import { SchmancyElement } from '@mixins/index';
 import { StepsController } from './steps.context';
 /**
  * Custom event emitted when the current step changes.
@@ -7,8 +8,8 @@ import { StepsController } from './steps.context';
 export type SchmancyStepsChangeEvent = CustomEvent<{
     value: number;
 }>;
-declare const SchmancyStepsContainer_base: CustomElementConstructor & import("../../mixins").Constructor<import("lit").LitElement> & import("../../mixins").Constructor<import("../../mixins").IBaseMixin>;
-export declare class SchmancyStepsContainer extends SchmancyStepsContainer_base {
+export declare class SchmancyStepsContainer extends SchmancyElement {
+    static styles: import("lit").CSSResult[];
     private controller;
     stepsController: StepsController;
     set currentStep(value: number);
@@ -31,4 +32,3 @@ declare global {
         'schmancy-steps-container': SchmancyStepsContainer;
     }
 }
-export {};

package/types/src/surface/surface.d.ts

@@ -1,22 +1,30 @@
+import { SchmancyElement } from '@mixins/index';
 import { TSurfaceColor } from '@schmancy/types';
 export declare const SchmancySurfaceTypeContext: {
     __context__: TSurfaceColor;
 };
 export type { SchmancySurfaceFill, SchmancySurfaceRounded, SchmancySurfaceElevation } from '@mixins/surface.mixin';
-declare const SchmancySurface_base: import("../../mixins").Constructor<import("@mixins/surface.mixin").ISurfaceMixin> & import("../../mixins").Constructor<CustomElementConstructor> & import("../../mixins").Constructor<import("@mixins/tailwind.mixin").ITailwindElementMixin> & import("../../mixins").Constructor<import("lit").LitElement> & import("../../mixins").Constructor<import("../../mixins").IBaseMixin>;
+declare const SchmancySurface_base: import("@mixins/index").Constructor<import("@mixins/surface.mixin").ISurfaceMixin> & typeof SchmancyElement;
 /**
- * Themed container — the root surface primitive. Sets background, text color, rounding, elevation, and (optionally) internal scroll. Provides a `SchmancySurfaceTypeContext` so descendants can adapt to the enclosing surface variant.
+ * `<schmancy-surface>` component
+ *
+ * This component renders a styled container that adapts its dimensions based on the `fill` property.
+ * It supports various rounding options, elevation levels, and applies background and text color classes
+ * based on the specified surface variant. Additionally, when the `scroller` property is true, the component
+ * enables internal scrolling by applying overflow and scroll-behavior styles.
+ *
+ * SurfaceMixin automatically provides surfaceStyles CSS.
  *
  * @element schmancy-surface
- * @summary Wrap a region of a page when you need it to pick up theme tokens (background + on-color + elevation). Nest surfaces to express Material Design's hierarchical color stacking.
+ * @slot - Default slot for projecting child content.
+ *
  * @example
  * <schmancy-surface fill="all" rounded="all" elevation="3" type="surfaceBright" scroller>
  *   <p>Your scrollable content here</p>
  * </schmancy-surface>
- * @platform div - Styled `<div>` with theme-driven background/color/elevation. Degrades to a plain `<div>` if the tag never registers — text stays readable, just loses theming.
- * @slot - Default slot for projecting child content.
  */
 export declare class SchmancySurface extends SchmancySurface_base {
+    static styles: import("lit").CSSResult[];
     /**
      * Specifies the surface type for styling.
      * Provided to descendant components via context.

package/types/src/switch/switch.d.ts

@@ -1,18 +1,14 @@
-import { LitElement } from 'lit';
+import { SchmancyElement } from '@mixins/index';
 export type SchmancySwitchChangeEvent = CustomEvent<{
     value: boolean;
 }>;
-declare const SchmancySwitch_base: import("@mixins/index").Constructor<CustomElementConstructor> & import("@mixins/index").Constructor<import("@mixins/index").ITailwindElementMixin> & import("@mixins/index").Constructor<LitElement> & import("@mixins/index").Constructor<import("@mixins/index").IBaseMixin>;
 /**
- * Binary on/off control with immediate effect. Form-associated, keyboard-accessible, semantically a switch (ARIA role="switch"). Distinct from `schmancy-checkbox`: a switch represents an immediate state change, a checkbox represents a selection in a form to be submitted.
+ * Binary on/off control. Form-associated, keyboard-accessible, semantically a
+ * switch (ARIA role="switch"). Distinct from `schmancy-checkbox`: a switch
+ * represents an immediate state change, a checkbox represents a selection in
+ * a form to be submitted.
  *
  * @element schmancy-switch
- * @summary Use when flipping the control takes effect right away (e.g. "Dark mode", "Enable notifications"). Prefer schmancy-checkbox for form submissions.
- * @example
- * <schmancy-switch ?checked=${this.darkMode} @change=${(e) => this.darkMode = e.detail.value}>
- *   Dark mode
- * </schmancy-switch>
- * @platform switch change - Accessible native `<button role="switch" aria-checked>` under the hood. No native HTML element exists; falls back to a styled checkbox if the tag never registers.
  * @fires change - `CustomEvent<{ value: boolean }>` when the state changes.
  * @attr checked - Initial checked state (also reflected via `value`).
  * @attr disabled - Disables interaction.
@@ -21,7 +17,8 @@ declare const SchmancySwitch_base: import("@mixins/index").Constructor<CustomEle
  * @csspart track - The background track.
  * @csspart thumb - The moving thumb.
  */
-export declare class SchmancySwitch extends SchmancySwitch_base {
+export declare class SchmancySwitch extends SchmancyElement {
+    static styles: import("lit").CSSResult[];
     static formAssociated: boolean;
     private internals;
     checked: boolean;
@@ -54,4 +51,3 @@ declare global {
         'schmancy-switch': SchmancySwitch;
     }
 }
-export {};

package/types/src/table/row.d.ts

@@ -1,7 +1,7 @@
+import { SchmancyElement } from '@mixins/index';
 import { TemplateResult } from 'lit';
 import { TableColumn } from './table';
-declare const SchmancyTableRow_base: CustomElementConstructor & import("../../mixins").Constructor<import("lit").LitElement> & import("../../mixins").Constructor<import("../../mixins").IBaseMixin>;
-export declare class SchmancyTableRow<T extends Record<string, any> = any> extends SchmancyTableRow_base {
+export declare class SchmancyTableRow<T extends Record<string, any> = any> extends SchmancyElement {
     columns: TableColumn<T>[];
     item: T;
     cols: string;
@@ -17,4 +17,3 @@ declare global {
         'schmancy-table-row': SchmancyTableRow;
     }
 }
-export {};

package/types/src/table/table.d.ts

@@ -1,4 +1,5 @@
 import '@lit-labs/virtualizer';
+import { SchmancyElement } from '@mixins/index';
 import { TemplateResult } from 'lit';
 import './row';
 export interface TableColumn<T extends Record<string, any> = any> {
@@ -15,19 +16,12 @@ export interface RowEventDetail<T> {
     index: number;
 }
 export type SortDirection = 'asc' | 'desc' | null;
-declare const SchmancyDataTable_base: CustomElementConstructor & import("../../mixins").Constructor<import("lit").LitElement> & import("../../mixins").Constructor<import("../../mixins").IBaseMixin>;
 /**
- * Generic data table — typed columns, optional sort, custom renderers per column. Pass `data` (array) and `columns` (TableColumn descriptors).
+ * SchmancyDataTable is a generic data table component.
+ * It supports sorting, filtering, and custom rendering of rows.
  *
- * @element schmancy-table
- * @summary Use for tabular data where each column has a known shape. Pair with `<schmancy-table-row>` for the per-row interaction surface. Sort by setting `sortable: true` on a column descriptor; the table emits `sort-change` so the parent can re-fetch / re-sort in the data layer if needed.
- * @example
- * <schmancy-table .data=${rows} .columns=${[{ name: 'Name', key: 'name' }, { name: 'Status', key: 'status' }]}></schmancy-table>
- * @platform table - Renders an accessible table with `<lit-virtualizer>` for large datasets. Degrades to a styled `<table>` if the tag never registers.
- * @fires click - When a data row is activated. `detail.item` is the row's source object, `detail.index` is the position in the data array.
- * @fires sort-change - When the user toggles a column sort. `detail.column` is the column key, `detail.direction` is `'asc' | 'desc' | null`.
  */
-export declare class SchmancyDataTable<T extends Record<string, any> = any> extends SchmancyDataTable_base {
+export declare class SchmancyDataTable<T extends Record<string, any> = any> extends SchmancyElement {
     columns: TableColumn<T>[];
     data: T[];
     keyField: keyof T;
@@ -52,4 +46,3 @@ declare global {
         'schmancy-table': SchmancyDataTable;
     }
 }
-export {};

package/types/src/tabs/index.d.ts

@@ -1,4 +1,2 @@
 export * from './tab';
 export * from './tabs-group';
-export * from './tabs-compatibility';
-export * from './tabs-compatibility';

package/types/src/tabs/tab.d.ts

@@ -1,5 +1,5 @@
-declare const SchmancyTab_base: import("@mixins/index").Constructor<CustomElementConstructor> & import("@mixins/index").Constructor<import("@mixins/index").ITailwindElementMixin> & import("@mixins/index").Constructor<import("lit").LitElement> & import("@mixins/index").Constructor<import("@mixins/index").IBaseMixin>;
-export default class SchmancyTab extends SchmancyTab_base {
+import { SchmancyElement } from '@mixins/index';
+export default class SchmancyTab extends SchmancyElement {
     label: any;
     value: any;
     active: boolean;
@@ -12,4 +12,3 @@ declare global {
         'schmancy-tab': SchmancyTab;
     }
 }
-export {};