mobx-mantle 0.3.6 → 0.6.1

package/dist/index.d.ts

@@ -1,6 +1,51 @@
-import * as react from 'react';
-import { Ref, JSX } from 'react';
-import { IObservableValue } from 'mobx';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React, { Ref, JSX } from 'react';
+import { Reaction } from 'mobx';
+import { M as MaybeGetter } from './reactive-args-BBucrU54.js';
+export { t as toValue } from './reactive-args-BBucrU54.js';
+
+declare const serviceType: unique symbol;
+/** Class tokens and typed symbols are also valid tsyringe injection tokens. */
+type ServiceToken<T extends object> = (new (...args: any[]) => T) | (symbol & {
+    readonly [serviceType]: T;
+});
+type ServiceResolver = <T extends object>(token: ServiceToken<T>) => T;
+declare function createServiceToken<T extends object>(description: string): ServiceToken<T>;
+declare function ServiceProvider({ resolve, children }: {
+    resolve: ServiceResolver;
+    children?: React.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+/** Synchronous construction scope, also useful outside React. Does not own services. */
+declare function withInjectionScope<T>(resolve: ServiceResolver | undefined, construct: () => T): T;
+/** Resolve during synchronous construction/onCreate, or inside withInjectionScope(). */
+declare function inject<T extends object>(token: ServiceToken<T>): T;
+
+/**
+ * Holder linking a component instance to its render reaction, so PropsBox
+ * can recognize "my own render is reading me" and skip tracking (React
+ * already delivers prop changes through memo — tracking would only schedule
+ * a redundant second render). Stable per React component instance; survives
+ * HMR instance swaps.
+ */
+interface RenderReactionHolder {
+    current: Reaction | null;
+}
+/**
+ * Minimal observer() for plain function components — re-renders when any
+ * observable read during render changes. Useful together with useBehavior()
+ * in codebases that don't (or don't yet) use Mantle components.
+ *
+ * @example
+ * ```tsx
+ * const Toolbar = observer((props: Props) => {
+ *   const size = useBehavior(() => withWindowSize());
+ *   return <div>{size.width}px</div>;
+ * });
+ * ```
+ */
+declare function observer<P extends object>(fc: ((props: P) => React.ReactElement | null) & {
+    displayName?: string;
+}): (props: P) => React.ReactElement | null;
 
 /** Options for the watch method */
 interface WatchOptions {
@@ -9,32 +54,74 @@ interface WatchOptions {
     /** Run callback immediately with current value */
     fireImmediately?: boolean;
 }
+/** Options for the effect method */
+interface EffectOptions {
+    /** Debounce the effect by N milliseconds */
+    delay?: number;
+}
 /**
  * Error context passed to the onError handler
  */
 interface MantleErrorContext {
     /** The lifecycle phase where the error occurred */
-    phase: 'onLayoutMount' | 'onMount' | 'onUpdate' | 'onUnmount' | 'watch';
-    /** The View or Behavior class name */
+    phase: 'onLayoutMount' | 'onMount' | 'onUpdate' | 'onUnmount' | 'watch' | 'effect' | 'sync';
+    /** The Component or Behavior class name */
     name: string;
-    /** Whether the error came from a Behavior (true) or a View (false) */
+    /** Whether the error came from a Behavior (true) or a Component (false) */
     isBehavior: boolean;
 }
 /**
  * Global configuration options for mobx-mantle
  */
 interface MantleConfig {
-    /** Whether to automatically make View/Behavior instances observable (default: true) */
+    /** Application service resolver, captured at construction. Explicit service scopes override it. */
+    resolveService?: ServiceResolver;
+    /** Whether to automatically make Component/Behavior instances observable (default: true) */
     autoObservable?: boolean;
+    /**
+     * Cache per-class prototype annotation data (getters, methods) so repeated
+     * instantiations of the same class skip the prototype walk (default: true).
+     * Turn off only if a class's prototype is mutated between instantiations.
+     */
+    cacheAnnotations?: boolean;
     /** Global error handler for lifecycle errors. Defaults to console.error. */
     onError?: (error: unknown, context: MantleErrorContext) => void;
+    /**
+     * Set true to opt into process-wide permissive MobX actions (default: false).
+     * By default Mantle preserves the host's MobX policy. Synchronous methods
+     * and lifecycle callbacks are actions; async continuations should use
+     * runInAction. Configure before the first component or behavior is created.
+     */
+    manageMobxActions?: boolean;
 }
 /**
  * Configure global defaults for mobx-mantle.
- * Settings can still be overridden per-view in createView options.
+ * Settings can still be overridden per-component in createComponent options.
  */
 declare function configure(config: MantleConfig): void;
 
+/**
+ * A watch/effect registration. `create` builds the underlying MobX reaction
+ * and returns its disposer. Specs registered before mount are kept so the
+ * reaction can be re-created if the host unmounts and remounts with the same
+ * instance — React StrictMode does exactly this in development.
+ */
+interface ReactiveSpec {
+    create: () => () => void;
+    stopped: boolean;
+    dispose: (() => void) | null;
+}
+
+/**
+ * Placeholder returned by sync() during construction. The wrapper constructor
+ * scans own fields right after onCreate, finds which key holds each marker,
+ * swaps in the initial value, and registers the hidden sync effect for that
+ * key. (Same post-onCreate scan window that behavior collection uses.)
+ */
+declare class SyncMarker {
+    readonly source: () => unknown;
+    constructor(source: () => unknown);
+}
 /**
  * Base class for behaviors. Provides lifecycle method signatures for IDE autocomplete.
  * Extend this class and wrap with createBehavior() to create a factory.
@@ -50,17 +137,50 @@ declare function configure(config: MantleConfig): void;
  * ```
  */
 declare class Behavior {
+    constructor();
+    inject<T extends object>(token: ServiceToken<T>): T;
     /** @internal */
     _watchDisposers: (() => void)[];
+    /** @internal — pre-mount watch/effect registrations, materialized at mount */
+    _reactiveSpecs: ReactiveSpec[];
+    /** @internal — child behaviors declared as fields, collected at construction */
+    _behaviors: BehaviorEntry[];
+    /** @internal — true after the parent Component first mounts */
+    _mounted: boolean;
+    /** @internal — set when effects clean up so StrictMode replay can resurrect pre-mount watchers */
+    _wasUnmounted: boolean;
+    /** @internal — sync() markers awaiting the post-onCreate field scan; null once construction completes */
+    _pendingSyncs: SyncMarker[] | null;
+    /** @internal — true while the hidden sync effect writes a mirrored field (dev write-guard) */
+    _syncWriting: boolean;
     onCreate?(...args: any[]): void;
     onLayoutMount?(): void | (() => void);
     onMount?(): void | (() => void);
     onUnmount?(): void;
+    /**
+     * Register a cleanup function to run automatically on unmount.
+     * Returns a function that can be called for early cleanup.
+     *
+     * Cleanups are one-shot: they are not re-created during React StrictMode's
+     * same-instance effect replay. Call this from onMount (which is replayed),
+     * or use effect() for a replay-safe setup/teardown pair.
+     */
+    addCleanup(cleanup: () => void): () => void;
+    /** @internal — addCleanup without the pre-mount dev warning (used by watch/effect) */
+    _addCleanup(cleanup: () => void): () => void;
     /**
      * Watch a reactive expression and run a callback when it changes.
-     * Automatically disposed on unmount.
+     * Automatically disposed on unmount and re-created during React StrictMode's
+     * same-instance effect replay.
      *
-     * @param expr - Reactive expression (getter) to watch
+     * Safe to call from onCreate: registration is recorded and comes alive
+     * when the parent commits (just before first paint), so the watcher
+     * tracks observable fields correctly and renders that React discards
+     * never leak reactions.
+     *
+     * @param source - Reactive expression (getter) to watch, or a MaybeGetter
+     *   argument passed through as-is. To watch a value that is itself a
+     *   function, wrap it: `watch(() => this.callback, …)`
      * @param callback - Called when the expression result changes
      * @param options - Optional configuration (delay, fireImmediately)
      * @returns Dispose function for early teardown
@@ -73,7 +193,52 @@ declare class Behavior {
      * }
      * ```
      */
-    watch<T>(expr: () => T, callback: (value: T, prevValue: T | undefined) => void, options?: WatchOptions): () => void;
+    watch<T>(source: MaybeGetter<T>, callback: (value: T, prevValue: T | undefined) => void, options?: WatchOptions): () => void;
+    /**
+     * Run a side effect that auto-tracks reactive dependencies.
+     * Re-runs whenever any accessed observable changes.
+     * Automatically disposed on unmount.
+     *
+     * Best for simple synchronization (DOM updates, logging). For complex
+     * side effects with explicit triggers, prefer `watch()`.
+     *
+     * @param fn - Effect function. May return a cleanup function.
+     * @param options - Optional configuration (delay)
+     * @returns Dispose function for early teardown
+     *
+     * @example
+     * ```tsx
+     * onCreate() {
+     *   this.effect(() => {
+     *     console.log('Current value:', this.value);
+     *   });
+     * }
+     * ```
+     */
+    effect(fn: () => void | (() => void), options?: EffectOptions): () => void;
+    /**
+     * Normalize a MaybeGetter argument into an ordinary field that stays
+     * current. Call once in onCreate (or a field initializer) and assign the
+     * result to a field; everywhere else, read the field like normal state:
+     *
+     * ```tsx
+     * url!: string;
+     *
+     * onCreate(url: MaybeGetter<string>) {
+     *   this.url = this.sync(url);            // the one convention line
+     *   this.watch(() => this.url, (u) => this.load(u));
+     * }
+     * refresh() { this.load(this.url); }      // plain read, always current
+     * ```
+     *
+     * - Plain value → the field just holds it (no effect registered).
+     * - Getter → a hidden effect keeps the field updated whenever the getter's
+     *   observable sources change (alive from mount, like watch/effect).
+     *
+     * The sync is one-way (argument → field). Don't write to the field from
+     * outside: the next source change overwrites it (dev mode warns).
+     */
+    sync<T>(source: MaybeGetter<T>): T;
     /** @internal */
     _disposeWatchers(): void;
 }
@@ -122,19 +287,19 @@ type BehaviorArgs<T extends new (...args: any[]) => any> = ConstructorParams<T>
  * export const withDrag = createBehavior(DragTrait);
  * ```
  *
- * @example Using in a View
+ * @example Using in a Component
  * ```tsx
- * class Editor extends View<Props> {
+ * class Editor extends Component<Props> {
  *   canvas = this.ref<HTMLCanvasElement>();
  *
  *   // No `new` keyword — factory function
  *   drag = withDrag(this.canvas);
  *   autosave = withAutosave('/api/save', 5000);
  * }
- * export default createView(Editor);
+ * export default createComponent(Editor);
  * ```
  *
- * The `with` prefix convention signals that the view manages this behavior's lifecycle.
+ * The `with` prefix convention signals that the component manages this behavior's lifecycle.
  */
 /**
  * Type that supports both `new` and direct call syntax
@@ -147,78 +312,77 @@ declare function createBehavior<T extends new (...args: any[]) => any>(Def: T, o
     autoObservable?: boolean;
 }): BehaviorFactory<BehaviorArgs<T>, InstanceType<T>>;
 
-/**
- * Decorator context type for TC39 decorators
- */
-interface DecoratorContext {
-    kind: 'field' | 'method' | 'getter' | 'setter' | 'accessor' | 'class';
+type Context = {
+    kind: string;
     name: string | symbol;
-    metadata: Record<symbol, unknown>;
-}
+    metadata?: Record<symbol, unknown>;
+    static?: boolean;
+    private?: boolean;
+};
+/** Plain fields in either TypeScript decorator mode; no accessor keyword needed. */
+declare const observable: ((_target: any, key: string | symbol | Context, descriptor?: PropertyDescriptor) => void) & {
+    ref: (_target: any, key: string | symbol | Context, descriptor?: PropertyDescriptor) => void;
+    shallow: (_target: any, key: string | symbol | Context, descriptor?: PropertyDescriptor) => void;
+    deep: (_target: any, key: string | symbol | Context, descriptor?: PropertyDescriptor) => void;
+    struct: (_target: any, key: string | symbol | Context, descriptor?: PropertyDescriptor) => void;
+};
+/** Bound prototype method, or an arrow-function field (already bound); synchronous writes are batched. */
+declare const action: (target: any, key: string | symbol | Context, descriptor?: PropertyDescriptor) => void;
+declare const computed: (_target: any, key: string | symbol | Context, descriptor?: PropertyDescriptor) => void;
+
 /**
- * Marks a field as observable. No `accessor` keyword needed.
- *
- * @example
- * ```tsx
- * class Counter extends View {
- *   @observable count = 0;
- * }
- * export default createView(Counter);
- * ```
+ * Props holder built on MobX's public atom API. Reads are tracked like any
+ * observable. Writes come in two flavors:
+ * - setSilently: update the value without notifying observers — safe during
+ *   React's render phase (see Component._syncProps)
+ * - set: update and notify observers — called from useLayoutEffect after
+ *   React finishes the render pass
  */
-declare function observable(_value: undefined, context: DecoratorContext): void;
-declare namespace observable {
-    var ref: (_value: undefined, context: DecoratorContext) => void;
-    var shallow: (_value: undefined, context: DecoratorContext) => void;
-    var struct: (_value: undefined, context: DecoratorContext) => void;
-    var deep: (_value: undefined, context: DecoratorContext) => void;
+declare class PropsBox<P> {
+    private _atom;
+    private _value;
+    /**
+     * @internal The owning component's render reaction. Reads coming from it
+     * are not tracked: React already re-renders the component on prop change
+     * (via memo), so letting the render reaction observe the props atom would
+     * only schedule a redundant second render after every prop change.
+     * Computeds, watchers, and other components track normally.
+     */
+    _renderReaction: RenderReactionHolder | null;
+    constructor(value: P, name: string);
+    get(): P;
+    setSilently(value: P): void;
+    set(value: P): void;
 }
-/**
- * Marks a method as an action. Auto-bound by default.
- *
- * @example
- * ```tsx
- * class Counter extends View {
- *   @observable count = 0;
- *
- *   @action increment() {
- *     this.count++;
- *   }
- * }
- * export default createView(Counter);
- * ```
- */
-declare function action(_value: Function, context: DecoratorContext): void;
-/**
- * Marks a getter as computed.
- * Note: Getters are automatically computed in autoObservable mode,
- * but this decorator is useful for explicit annotation.
- *
- * @example
- * ```tsx
- * class Counter extends View {
- *   @observable count = 0;
- *
- *   @computed get doubled() {
- *     return this.count * 2;
- *   }
- * }
- * export default createView(Counter);
- * ```
- */
-declare function computed(_value: Function, context: DecoratorContext): void;
-
-declare class View<P = {}> {
+type ComponentConstructor<C extends Component<any> = Component<any>> = abstract new (...args: any[]) => C;
+declare class Component<P = {}> {
     /** @internal */
-    _propsBox: IObservableValue<P>;
+    _propsBox: PropsBox<P>;
+    constructor(props?: P);
     get props(): P;
-    /** @internal — called by createView to silently update props during render */
+    /** Resolve through the scope captured during construction; preserve service identity. */
+    inject<T extends object>(token: ServiceToken<T>): T;
+    /** Return the immediate ancestor in the live Mantle view tree. */
+    getParent(): Component<any> | undefined;
+    /** Find the nearest parent with the supplied logical model identity. */
+    findParent<C extends Component<any>>(type: ComponentConstructor<C>): C | undefined;
+    /** Return all Mantle parents, ordered from the immediate parent to the root. */
+    getParents(): readonly Component<any>[];
+    /** Return the highest Mantle ancestor, or this instance when already root. */
+    getRoot(): Component<any>;
+    /** @internal — called by createComponent to silently update props during render */
     _syncProps(value: P): void;
     forwardRef?: Ref<any>;
     /** @internal */
     _behaviors: BehaviorEntry[];
     /** @internal */
     _watchDisposers: (() => void)[];
+    /** @internal — pre-mount watch/effect registrations, materialized at mount */
+    _reactiveSpecs: ReactiveSpec[];
+    /** @internal — true after the first (layout) mount */
+    _mounted: boolean;
+    /** @internal — set when effects clean up so StrictMode replay can resurrect watchers */
+    _wasUnmounted: boolean;
     onCreate?(props: P): void;
     onLayoutMount?(): void | (() => void);
     onMount?(): void | (() => void);
@@ -227,18 +391,33 @@ declare class View<P = {}> {
     ref<T extends HTMLElement = HTMLElement>(): {
         current: T | null;
     };
+    /**
+     * Register a cleanup function to run automatically on unmount.
+     * Returns a function that can be called for early cleanup.
+     *
+     * Cleanups are one-shot: they are not re-created during React StrictMode's
+     * same-instance effect replay. Call this from onMount (which is replayed),
+     * or use effect() for a replay-safe setup/teardown pair.
+     */
+    addCleanup(cleanup: () => void): () => void;
+    /** @internal — addCleanup without the pre-mount dev warning (used by watch/effect) */
+    _addCleanup(cleanup: () => void): () => void;
     /**
      * Watch a reactive expression and run a callback when it changes.
-     * Automatically disposed on unmount.
+     * Automatically disposed on unmount. Watchers declared before mount
+     * (field initializers, onCreate) are re-created during React StrictMode's
+     * same-instance effect replay.
      *
-     * @param expr - Reactive expression (getter) to watch
+     * @param source - Reactive expression (getter) to watch, or a MaybeGetter
+     *   argument passed through as-is. To watch a value that is itself a
+     *   function, wrap it: `watch(() => this.callback, …)`
      * @param callback - Called when the expression result changes
      * @param options - Optional configuration (delay, fireImmediately)
      * @returns Dispose function for early teardown
      *
      * @example
      * ```tsx
-     * onCreate() {
+     * onMount() {
      *   this.watch(
      *     () => this.query,
      *     async (query) => {
@@ -251,7 +430,42 @@ declare class View<P = {}> {
      * }
      * ```
      */
-    watch<T>(expr: () => T, callback: (value: T, prevValue: T | undefined) => void, options?: WatchOptions): () => void;
+    watch<T>(source: MaybeGetter<T>, callback: (value: T, prevValue: T | undefined) => void, options?: WatchOptions): () => void;
+    /**
+     * Run a side effect that auto-tracks reactive dependencies.
+     * Re-runs whenever any accessed observable changes.
+     * Automatically disposed on unmount. Effects declared before mount
+     * (field initializers, onCreate) are re-created during React StrictMode's
+     * same-instance effect replay.
+     *
+     * Best for simple synchronization (DOM updates, logging). For complex
+     * side effects with explicit triggers, prefer `watch()`.
+     *
+     * @param fn - Effect function. May return a cleanup function.
+     * @param options - Optional configuration (delay)
+     * @returns Dispose function for early teardown
+     *
+     * @example
+     * ```tsx
+     * onMount() {
+     *   this.effect(() => {
+     *     document.title = `${this.items.length} items`;
+     *   });
+     * }
+     * ```
+     *
+     * @example With cleanup
+     * ```tsx
+     * onMount() {
+     *   this.effect(() => {
+     *     const handler = () => console.log(this.count);
+     *     window.addEventListener('click', handler);
+     *     return () => window.removeEventListener('click', handler);
+     *   });
+     * }
+     * ```
+     */
+    effect(fn: () => void | (() => void), options?: EffectOptions): () => void;
     /** @internal */
     _disposeWatchers(): void;
     /** @internal - Scan own properties for behavior instances and register them */
@@ -265,9 +479,143 @@ declare class View<P = {}> {
     render?(): JSX.Element | null;
 }
 
-type PropsOf<V> = V extends View<infer P> ? P : object;
-declare function createView<V extends View<any>>(ViewClass: new () => V, templateOrOptions?: ((vm: V) => JSX.Element) | {
+type PropsOf<C> = C extends Component<infer P> ? P : object;
+/**
+ * Return type for createComponent.
+ *
+ * Simple callable signature that works with libraries expecting ComponentType<P>
+ * or strict function components (react-window, react-virtualized, etc.).
+ *
+ * Uses ReactElement | null rather than React.FC's looser ReactNode return type.
+ */
+type MantleComponent<P> = (props: P) => React.ReactElement | null;
+/**
+ * Return type for createForwardRef when you need typed ref forwarding.
+ *
+ * Use this when you need to forward refs to DOM elements or child components
+ * and want TypeScript to know the ref type.
+ */
+type ForwardRefMantleComponent<P, RefType> = ((props: P) => React.ReactElement | null) & React.ForwardRefExoticComponent<React.PropsWithoutRef<P> & React.RefAttributes<RefType>>;
+declare function createComponent<C extends Component<any>>(ComponentClass: new (...args: any[]) => C, templateOrOptions?: ((vm: C) => JSX.Element) | {
+    autoObservable?: boolean;
+}): MantleComponent<PropsOf<C>>;
+/**
+ * Creates a React component with typed ref forwarding.
+ *
+ * Use this instead of createComponent when you need to forward refs to DOM elements
+ * or child components and want proper TypeScript support for the ref type.
+ *
+ * @example
+ * ```tsx
+ * class FancyInput extends Component<Props> {
+ *   render() {
+ *     return <input ref={this.forwardRef} className="fancy" />;
+ *   }
+ * }
+ *
+ * const FancyInputComponent = createForwardRef<HTMLInputElement>(FancyInput);
+ *
+ * // Parent gets typed ref:
+ * const inputRef = useRef<HTMLInputElement>(null);
+ * <FancyInputComponent ref={inputRef} />
+ * ```
+ */
+declare function createForwardRef<RefType, C extends Component<any> = Component<any>>(ComponentClass: new (...args: any[]) => C, templateOrOptions?: ((vm: C) => JSX.Element) | {
     autoObservable?: boolean;
-}): react.ForwardRefExoticComponent<react.PropsWithoutRef<PropsOf<V>> & react.RefAttributes<unknown>>;
+}): ForwardRefMantleComponent<PropsOf<C>, RefType>;
+
+/**
+ * Host a behavior inside a plain React function component. The behavior gets
+ * the same lifecycle relay a Mantle Component would give it: onLayoutMount in
+ * the layout phase, onMount after paint, watchers alive from commit, full
+ * teardown at unmount, and StrictMode remount resurrection.
+ *
+ * The instance is created once per mount lifetime, from a factory so nothing
+ * is constructed on re-renders. It is returned as-is — wrap the component in
+ * observer() (from mobx-mantle) so renders track the behavior's observables:
+ *
+ * @example
+ * ```tsx
+ * const Toolbar = observer(() => {
+ *   const size = useBehavior(() => withWindowSize());
+ *   return <div>{size.width} × {size.height}</div>;
+ * });
+ * ```
+ *
+ * Note: the factory runs once, so getter arguments close over the first
+ * render's scope. Getters reading observables (a store, another behavior)
+ * stay live; getters reading a function component's props capture the first
+ * render's props object and go stale — pass observable sources instead.
+ */
+declare function useBehavior<T extends object>(create: () => T): T;
+
+interface SharedOptions {
+    /**
+     * Persist the shared fields to localStorage under the key and restore
+     * them at startup, so a fresh window starts where the last one left off.
+     * Default true.
+     */
+    persist?: boolean;
+    /**
+     * The fields to share. Defaults to the store's own observable data
+     * fields: not getters, not methods, not names starting with `_`.
+     */
+    fields?: readonly string[];
+}
+interface ShareStoresOptions extends SharedOptions {
+    /** Key prefix for each store; the key is `${prefix}:${name}`. Default `shared`. */
+    prefix?: string;
+}
+/**
+ * Share a MobX store's state across every window of one application:
+ * other tabs, the frames a design tool hosts, anything on the same origin
+ * that imports the same module. Each window keeps its own store instance;
+ * values are mirrored, identity is not shared, and nothing goes through a
+ * server or a parent document.
+ *
+ * Mechanics, the web's own answer for two windows, packaged so it is never
+ * written by hand:
+ * - restore the store's fields from localStorage at startup (`persist`);
+ * - publish changes through a reaction to localStorage and a
+ *   BroadcastChannel;
+ * - apply incoming changes from the channel or the `storage` event inside
+ *   an action.
+ * Echo loops are bounded because a window only publishes when its
+ * serialized state changed, and only applies what differs from it.
+ *
+ * The one authoring rule: effects must derive from state — a `reaction`,
+ * `autorun`, or a component's `watch`/`effect` — never run inside setters,
+ * because a change that arrives from another window sets fields directly.
+ *
+ * @example
+ * export const themeStore = shared(new ThemeStore(), 'theme');
+ */
+declare function shared<T extends object>(store: T, key: string, options?: SharedOptions): T;
+/** Stop sharing a store (tests, teardown). The store keeps its current state. */
+declare function unshare(store: object): void;
+/**
+ * Share several stores at once, keyed by name: the one line an application
+ * writes at its entry point (a design tool's manifest, an app's main
+ * module) so every window that imports it wires the same stores.
+ *
+ * @example
+ * shareStores({ themeStore, navPreferences });
+ */
+declare function shareStores<T extends Record<string, object>>(stores: T, options?: ShareStoresOptions): T;
+
+type ModelClass<C extends Component<any> = Component<any>> = new (...args: any[]) => C;
+interface ModelSubstitution<C extends Component<any> = Component<any>> {
+    /** Runs for each instance instead of its original constructor. Supply data/callbacks only. */
+    state: () => object;
+    /** Required for integrated render() classes; optional for separate templates. */
+    template?: (model: C) => React.JSX.Element;
+}
+/** Construction policy. The mounted tree takes a snapshot; remount to change it. */
+declare function ModelProvider({ models, children }: {
+    models: ReadonlyMap<ModelClass, ModelSubstitution>;
+    children?: React.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+/** Logical identity works for real and substituted models. It does not fake instanceof. */
+declare function isModel<C extends Component<any>>(model: object, type: abstract new (...args: any[]) => C): model is C;
 
-export { Behavior, type MantleConfig, type MantleErrorContext, View, View as ViewModel, type WatchOptions, action, computed, configure, createBehavior, createView, observable };
+export { Behavior, Component, type ComponentConstructor, type ForwardRefMantleComponent, type MantleComponent, type MantleConfig, type MantleErrorContext, MaybeGetter, type ModelClass, ModelProvider, type ModelSubstitution, ServiceProvider, type ServiceResolver, type ServiceToken, type ShareStoresOptions, type SharedOptions, Component as ViewModel, type WatchOptions, action, computed, configure, createBehavior, createComponent, createForwardRef, createServiceToken, inject, isModel, observable, observer, shareStores, shared, unshare, useBehavior, withInjectionScope };