@koordinates/xstate-tree 4.5.0 → 5.1.0-next.2

package/lib/useService.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useService = exports.loggingMetaOptions = void 0;
 const react_1 = require("react");
-const utils_1 = require("./utils");
 /**
  * @public
  */
@@ -23,9 +22,9 @@ exports.loggingMetaOptions = loggingMetaOptions;
  * @internal
  */
 function useService(service) {
-    const [current, setCurrent] = (0, react_1.useState)(service.state);
-    const [children, setChildren] = (0, react_1.useState)(service.children);
-    const childrenRef = (0, react_1.useRef)(new Map());
+    const [current, setCurrent] = (0, react_1.useState)(service.getSnapshot());
+    const [children, setChildren] = (0, react_1.useState)(service.getSnapshot().children);
+    const childrenRef = (0, react_1.useRef)({});
     (0, react_1.useEffect)(() => {
         childrenRef.current = children;
     }, [children]);
@@ -33,56 +32,17 @@ function useService(service) {
         // Set to current service state as there is a possibility
         // of a transition occurring between the initial useState()
         // initialization and useEffect() commit.
-        setCurrent(service.state);
-        setChildren(service.children);
-        const listener = function (state) {
-            if (state.changed) {
-                setCurrent(state);
-                if (!(0, utils_1.isEqual)(childrenRef.current, service.children)) {
-                    setChildren(new Map(service.children));
-                }
-            }
+        setCurrent(service.getSnapshot());
+        setChildren(service.getSnapshot().children);
+        const listener = function (snapshot) {
+            setCurrent(snapshot);
+            setChildren(service.getSnapshot().children);
         };
         const sub = service.subscribe(listener);
         return function () {
             sub.unsubscribe();
         };
     }, [service, setChildren]);
-    (0, react_1.useEffect)(() => {
-        function handler(event) {
-            var _a, _b, _c;
-            if (event.type.includes("done")) {
-                const idOfFinishedChild = event.type.split(".")[2];
-                childrenRef.current.delete(idOfFinishedChild);
-                setChildren(new Map(childrenRef.current));
-            }
-            console.debug(`[xstate-tree] ${service.id} handling event`, ((_c = (_b = (_a = service.machine.meta) === null || _a === void 0 ? void 0 : _a.xstateTree) === null || _b === void 0 ? void 0 : _b.ignoredEvents) === null || _c === void 0 ? void 0 : _c.has(event.type))
-                ? event.type
-                : event);
-        }
-        let prevState = undefined;
-        function transitionHandler(state) {
-            var _a, _b;
-            const ignoreContext = (_b = (_a = service.machine.meta) === null || _a === void 0 ? void 0 : _a.xstateTree) === null || _b === void 0 ? void 0 : _b.ignoreContext;
-            const context = ignoreContext ? "[context omitted]" : state.context;
-            if (prevState) {
-                console.debug(`[xstate-tree] ${service.id} transitioning from`, prevState.value, "to", state.value, context);
-            }
-            else {
-                console.debug(`[xstate-tree] ${service.id} transitioning to ${state.value}`, context);
-            }
-            prevState = state;
-        }
-        service.onEvent(handler);
-        service.onTransition(transitionHandler);
-        return () => {
-            service.off(handler);
-            service.off(transitionHandler);
-        };
-    }, [service, setChildren]);
-    return [
-        current,
-        children,
-    ];
+    return [current, children];
 }
 exports.useService = useService;

package/lib/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeMeta = exports.isNil = exports.isEqual = exports.difference = exports.isLikelyPageLoad = exports.assert = exports.assertIsDefined = exports.delay = void 0;
+exports.toJSON = exports.mergeMeta = exports.isNil = exports.isEqual = exports.difference = exports.isLikelyPageLoad = exports.assert = exports.assertIsDefined = exports.delay = void 0;
 function delay(ms = 0) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -130,3 +130,21 @@ function mergeMeta(meta) {
     }, {});
 }
 exports.mergeMeta = mergeMeta;
+function getCircularReplacer() {
+    const seen = new WeakSet();
+    return (key, value) => {
+        if (typeof value === "object" && value !== null) {
+            if (seen.has(value)) {
+                // Circular reference found, discard key
+                return;
+            }
+            // Store value in our set
+            seen.add(value);
+        }
+        return value;
+    };
+}
+function toJSON(value) {
+    return JSON.parse(JSON.stringify(value, getCircularReplacer()));
+}
+exports.toJSON = toJSON;

package/lib/xstate-tree.d.ts

@@ -1,28 +1,22 @@
-import { AnyEventObject } from 'xstate';
-import { AnyFunction } from 'xstate';
+import type { ActorRefFrom } from 'xstate';
 import { AnyStateMachine } from 'xstate';
-import { BaseActionObject } from 'xstate';
-import { ComponentPropsWithRef } from 'react';
 import { ContextFrom } from 'xstate';
-import { EventFrom } from 'xstate';
+import type { EventFrom } from 'xstate';
 import { EventObject } from 'xstate';
 import { History as History_2 } from 'history';
-import { InterpreterFrom } from 'xstate';
-import { JSXElementConstructor } from 'react';
+import { InputFrom } from 'xstate';
+import type { IsNever } from 'xstate';
 import { ParsedQuery } from 'query-string';
 import { default as React_2 } from 'react';
-import { ResolveTypegenMeta } from 'xstate';
-import { ServiceMap } from 'xstate';
-import type { StateFrom } from 'xstate';
-import { StateMachine } from 'xstate';
-import { TypegenDisabled } from 'xstate';
+import type { SnapshotFrom } from 'xstate';
+import type { StateValue } from 'xstate';
 import * as Z from 'zod';
 
 /**
  * @public
  */
 export declare type Actions<TMachine extends AnyStateMachine, TSelectorsOutput, TOut> = (args: {
-    send: InterpreterFrom<TMachine>["send"];
+    send: ActorRefFrom<TMachine>["send"];
     selectors: TSelectorsOutput;
 }) => TOut;
 
@@ -31,16 +25,7 @@ export declare type Actions<TMachine extends AnyStateMachine, TSelectorsOutput,
  *
  * Retrieves the actions return type from the xstate-tree machine
  */
-export declare type ActionsFrom<TMachine extends AnyXstateTreeMachine> = TMachine extends StateMachine<any, infer TMeta, any> ? TMeta extends {
-    meta: {
-        actions: infer TOut;
-    };
-} ? TOut extends (...args: any) => any ? ReturnType<TOut> : never : never : never;
-
-/**
- * @public
- */
-export declare type AnyActions = (send: any, selectors: any) => any;
+export declare type ActionsFrom<TMachine extends AnyXstateTreeMachine> = TMachine["_xstateTree"] extends XstateTreeMachineStateSchemaV2<any, any, infer TOut, any> ? TOut : never;
 
 /**
  * @public
@@ -65,12 +50,7 @@ export declare type AnyRoute = {
 /**
  * @public
  */
-export declare type AnySelector = V1Selectors<any, any, any, any>;
-
-/**
- * @public
- */
-export declare type AnyXstateTreeMachine = StateMachine<any, XstateTreeMachineStateSchemaV1<AnyStateMachine, AnySelector, AnyActions> | XstateTreeMachineStateSchemaV2<AnyStateMachine, any, any>, any>;
+export declare type AnyXstateTreeMachine = XstateTreeMachine<AnyStateMachine>;
 
 /**
  * @public
@@ -86,24 +66,6 @@ export declare type ArgumentsForRoute<T> = T extends Route<infer TParams, infer
  */
 export declare function broadcast(event: GlobalEvents): void;
 
-/**
- * @public
- *
- * Factory function for actions. The actions function is passed two arguments:
- * - `send` - the interpreters send function, which can be used to send events to the machine
- * - `selectors` - the output of the selectors function from {@link buildSelectors}
- *
- * The resulting action function will only be called once per invocation of a machine.
- * The selectors are passed in as a proxy to always read the latest selector value
- *
- * @param machine - The machine to create the actions for
- * @param selectors - The selectors function
- * @param actions - The action function
- * @returns The actions function - ready to be passed to {@link buildView}
- * @deprecated use {@link createXStateTreeMachine} instead
- * */
-export declare function buildActions<TMachine extends AnyStateMachine, TActions, TSelectors, TSend = InterpreterFrom<TMachine>["send"]>(__machine: TMachine, __selectors: TSelectors, actions: (send: TSend, selectors: OutputFromSelector<TSelectors>) => TActions): (send: TSend, selectors: OutputFromSelector<TSelectors>) => TActions;
-
 /**
  * @public
  *
@@ -178,7 +140,7 @@ export declare function buildRootComponent(machine: AnyXstateTreeMachine, routin
     getPathName?: () => string;
     getQueryString?: () => string;
 }): {
-    (): JSX.Element | null;
+    (): JSX.Element;
     rootMachine: AnyXstateTreeMachine;
 };
 
@@ -196,97 +158,11 @@ export declare function buildRootComponent(machine: AnyXstateTreeMachine, routin
  */
 export declare function buildRoutingMachine<TRoutes extends AnyRoute[]>(_routes: TRoutes, mappings: Record<TRoutes[number]["event"], AnyXstateTreeMachine>): AnyXstateTreeMachine;
 
-/**
- * @public
- *
- * Factory function for selectors. The selectors function is passed three arguments:
- * - `ctx` - the current context of the machines state
- * - `canHandleEvent` - a function that can be used to determine if the machine can handle a
- * given event, by simulating sending the event and seeing if a stat change would happen.
- * Handles guards
- * - `inState` - equivalent to xstates `state.matches`, allows checking if the machine is in a given state
- *
- * The resulting selector function has memoization. It will return the same value until the
- * machine's state changes or the machine's context changes
- * @param machine - The machine to create the selectors for
- * @param selectors - The selector function
- * @returns The selectors - ready to be passed to {@link buildActions}
- * @deprecated use {@link createXStateTreeMachine} instead
- */
-export declare function buildSelectors<TMachine extends AnyStateMachine, TSelectors, TContext = ContextFrom<TMachine>>(__machine: TMachine, selectors: (ctx: TContext, canHandleEvent: CanHandleEvent<TMachine>, inState: MatchesFrom<TMachine>, __currentState: never) => TSelectors): V1Selectors<TContext, EventFrom<TMachine>, TSelectors, MatchesFrom<TMachine>>;
-
-/**
- * @public
- *
- * Sets up a root component for use in an \@xstate/test model backed by \@testing-library/react for the component
- *
- * The logger argument should just be a simple function which forwards the arguments to console.log,
- * this is needed because Wallaby.js only displays console logs in tests that come from source code, not library code,
- * so any logs from inside this file don't show up in the test explorer
- *
- * The returned object has a `rootComponent` property and a function, `awaitTransition`, that returns a Promise
- * when called that is resolved the next time the underlying machine transitions. This can be used in the \@xstate/test
- * model to ensure after an event action is executed the test in the next state doesn't run until after the machine transitions
- *
- * It also delays for 5ms to ensure any React re-rendering happens in response to the state transition
- */
-export declare function buildTestRootComponent<TMachine extends AnyStateMachine, TSelectors extends AnySelector, TActions extends AnyActions, TContext = ContextFrom<TMachine>>(machine: StateMachine<TContext, XstateTreeMachineStateSchemaV1<TMachine, TSelectors, TActions> | XstateTreeMachineStateSchemaV2<TMachine, TSelectors, TActions>, EventFrom<TMachine>>, logger: typeof console.log): {
-    rootComponent: () => JSX.Element | null;
-    addTransitionListener: (listener: () => void) => void;
-    awaitTransition(): Promise<void>;
-};
-
-/**
- * @public
- *
- * Factory function for views. The view is passed four props:
- * - `slots` - the slots object, which can be used to render the children of the view invoked by the machine
- * - `actions` - the output of the actions function from {@link buildActions}
- * - `selectors` - the output of the selectors function from {@link buildSelectors}
- * - `inState` - equivalent to xstates `state.matches`, allows checking if the machine is in a given state
- *
- * The resulting view is wrapped in React.memo, it will re-render when the actions or selectors reference changes
- *
- * @param machine - The machine to create the view for
- * @param selectors - The selectors function from {@link buildSelectors}
- * @param actions - The actions function from {@link buildActions}
- * @param slots - The array of slots that can be rendered by the view
- * @param view - The view function
- * @returns The React view
- * @deprecated use {@link createXStateTreeMachine} instead
- */
-export declare function buildView<TMachine extends AnyStateMachine, TEvent extends EventObject, TActions, TSelectors extends AnySelector, TSlots extends readonly Slot[] = [], TMatches extends AnyFunction = MatchesFrom<TMachine>, TViewProps = ViewProps<OutputFromSelector<TSelectors>, TActions, TSlots, TMatches>, TSend = (send: TEvent) => void>(__machine: TMachine, __selectors: TSelectors, __actions: (send: TSend, selectors: OutputFromSelector<TSelectors>) => TActions, __slots: TSlots, view: React_2.ComponentType<TViewProps>): React_2.ComponentType<TViewProps>;
-
-/**
- * @public
- *
- * Aids in type inference for creating props objects for xstate-tree views.
- *
- * @param view - The view to create props for
- * @param props - The actions/selectors props to pass to the view
- * @returns An object with the view's selectors, actions, and inState function props
- */
-export declare function buildViewProps<C extends keyof JSX.IntrinsicElements | JSXElementConstructor<any>>(_view: C, props: Pick<InferViewProps<PropsOf<C>>, "actions" | "selectors">): InferViewProps<PropsOf<C>>;
-
-/**
- * @public
- *
- * staples xstate machine and xstate-tree metadata together into an xstate-tree machine
- *
- * @param machine - The machine to staple the selectors/actions/slots/view to
- * @param metadata - The xstate-tree metadata to staple to the machine
- * @returns The xstate-tree machine, ready to be invoked by other xstate-machines or used with `buildRootComponent`
- * @deprecated use {@link createXStateTreeMachine} instead
- */
-export declare function buildXStateTreeMachine<TMachine extends AnyStateMachine, TSelectors extends AnySelector, TActions extends AnyActions>(machine: TMachine, meta: XStateTreeMachineMetaV1<TMachine, TSelectors, TActions>): StateMachine<ContextFrom<TMachine>, XstateTreeMachineStateSchemaV1<TMachine, TSelectors, TActions>, EventFrom<TMachine>, any, any, any, any>;
-
 /**
  * @internal
  */
 export declare type CanHandleEvent<TMachine extends AnyStateMachine> = (e: EventFrom<TMachine>) => boolean;
 
-declare type Context = {};
-
 /**
  * @public
  * Creates an xstate-tree machine from an xstate-machine
@@ -301,7 +177,7 @@ declare type Context = {};
  * @param machine - The xstate machine to create the xstate-tree machine from
  * @param options - the xstate-tree options
  */
-export declare function createXStateTreeMachine<TMachine extends AnyStateMachine, TSelectorsOutput = ContextFrom<TMachine>, TActionsOutput = Record<never, string>, TSlots extends readonly Slot[] = []>(machine: TMachine, options: V2BuilderMeta<TMachine, TSelectorsOutput, TActionsOutput, TSlots>): StateMachine<ContextFrom<TMachine>, XstateTreeMachineStateSchemaV2<TMachine, TSelectorsOutput, TActionsOutput, TSlots>, EventFrom<TMachine>, any, any, any, any>;
+export declare function createXStateTreeMachine<TMachine extends AnyStateMachine, TSelectorsOutput = ContextFrom<TMachine>, TActionsOutput = Record<never, string>, TSlots extends readonly Slot[] = []>(machine: TMachine, options: V2BuilderMeta<TMachine, TSelectorsOutput, TActionsOutput, TSlots>): XstateTreeMachine<TMachine>;
 
 declare type EmptyKeys<T> = keyof {
     [K in keyof T as IsEmptyObject<T[K], true> extends true ? K : never]: T[K];
@@ -309,8 +185,6 @@ declare type EmptyKeys<T> = keyof {
 
 declare type EmptyRouteArguments<TParams, TQuery> = IsEmptyObject<TParams, true> extends true ? IsEmptyObject<TQuery, true> extends true ? true : false : false;
 
-declare type Events = any;
-
 /**
  * @public
  *
@@ -339,12 +213,6 @@ export declare type GlobalEvents = {
     };
 }[keyof XstateTreeEvents];
 
-declare type InferViewProps<T> = T extends ViewProps<infer TSelectors, infer TActions, never, infer TMatches> ? {
-    selectors: TSelectors;
-    actions: TActions;
-    inState: (state: Parameters<TMatches>[0]) => TMatches;
-} : never;
-
 declare type IsEmptyObject<Obj, ExcludeOptional extends boolean = false> = undefined extends Obj ? true : [keyof (ExcludeOptional extends true ? OmitOptional<Obj> : Obj)] extends [
 never
 ] ? true : false;
@@ -359,7 +227,7 @@ never
  * @param options - configure loading component and context to invoke machine with
  * @returns an xstate-tree machine that wraps the promise, invoking the resulting machine when it resolves
  */
-export declare function lazy<TMachine extends AnyStateMachine>(factory: () => Promise<TMachine>, { Loader, withContext, }?: Options<TMachine["context"]>): StateMachine<Context, any, Events, States, any, any, any>;
+export declare function lazy<TMachine extends AnyXstateTreeMachine>(factory: () => Promise<TMachine>, { Loader, input }?: Options<TMachine>): AnyXstateTreeMachine;
 
 /**
  * @public
@@ -415,7 +283,7 @@ declare type MakeEmptyObjectPropertiesOptional<T> = Omit<T, EmptyKeys<T>> & Part
 /**
  * @internal
  */
-export declare type MatchesFrom<T extends AnyStateMachine> = StateFrom<T>["matches"];
+export declare type MatchesFrom<T extends AnyStateMachine> = (value: ToStatePaths<SnapshotFrom<T>["value"]>) => boolean;
 
 /**
  * @public
@@ -460,7 +328,7 @@ declare type OmitOptional<T> = {
  */
 export declare function onBroadcast(handler: (event: GlobalEvents) => void): () => void;
 
-declare type Options<TContext> = {
+declare type Options<TStateMachine extends AnyStateMachine> = {
     /**
      * Displayed while the promise is resolving, defaults to returning null
      */
@@ -469,14 +337,9 @@ declare type Options<TContext> = {
      * Allows you to specify an overriden context when the machine is invoked
      * Automatically supplies the machines default context so only requires a partial of overrides
      */
-    withContext?: () => Partial<TContext>;
+    input?: InputFrom<TStateMachine>;
 };
 
-/**
- * @public
- */
-export declare type OutputFromSelector<T> = T extends V1Selectors<any, any, infer O, any> ? O : never;
-
 /**
  * @public
  *
@@ -497,8 +360,6 @@ export declare type PickEvent<T extends Extract<GlobalEvents, {
     type: T;
 }>;
 
-declare type PropsOf<C extends keyof JSX.IntrinsicElements | JSXElementConstructor<any>> = JSX.LibraryManagedAttributes<C, ComponentPropsWithRef<C>>;
-
 /**
  * @public
  *
@@ -680,11 +541,7 @@ export declare type Selectors<TMachine extends AnyStateMachine, TOut> = (args: {
  *
  * Retrieves the selector return type from the xstate-tree machine
  */
-export declare type SelectorsFrom<TMachine extends AnyXstateTreeMachine> = TMachine extends StateMachine<any, infer TMeta, any> ? TMeta extends {
-    meta: {
-        selectors: infer TOut;
-    };
-} ? TOut extends (...args: any) => any ? ReturnType<TOut> : never : never : never;
+export declare type SelectorsFrom<TMachine extends AnyXstateTreeMachine> = TMachine["_xstateTree"] extends XstateTreeMachineStateSchemaV2<any, infer TOut, any, any> ? TOut : never;
 
 /**
  * @public
@@ -730,19 +587,6 @@ export declare function singleSlot<T extends string>(name: T): SingleSlot<T>;
  */
 export declare type Slot = SingleSlot<any> | MultiSlot<any>;
 
-/**
- * @public
- *
- * Creates a dummy machine that just renders the supplied string - useful for rendering xstate-tree views in isolation
- *
- * @param name - the string to render in the machines view
- * @returns a dummy machine that renders a div containing the supplied string
- */
-export declare function slotTestingDummyFactory(name: string): StateMachine<unknown, XstateTreeMachineStateSchemaV1<StateMachine<unknown, any, AnyEventObject, {
-    value: any;
-    context: unknown;
-}, BaseActionObject, ServiceMap, ResolveTypegenMeta<TypegenDisabled, AnyEventObject, BaseActionObject, ServiceMap>>, () => {}, () => {}>, AnyEventObject, any, any, any, any>;
-
 /**
  * @public
  */
@@ -751,14 +595,6 @@ export declare enum SlotType {
     MultiSlot = 1
 }
 
-declare type States = {
-    value: "loading";
-    context: Context;
-} | {
-    value: "rendering";
-    context: Context;
-};
-
 /**
  * @public
  */
@@ -773,17 +609,21 @@ export declare type StyledLink<TStyleProps = {}> = <TRoute extends AnyRoute>(pro
  * @param activeRouteEvents - The active route events to use in the context
  */
 export declare function TestRoutingContext({ activeRouteEvents, children, }: {
-    activeRouteEvents: RoutingEvent<any>[];
+    activeRouteEvents: RoutingEvent<AnyRoute>[];
     children: React_2.ReactNode;
 }): JSX.Element;
 
+declare type ToStatePaths<TStateValue extends StateValue, TParentPath extends string = ""> = TStateValue extends string ? WithParentPath<TStateValue, TParentPath> : IsNever<keyof TStateValue> extends true ? never : WithParentPath<keyof TStateValue & string, TParentPath> | Values<{
+    [K in keyof TStateValue & string]?: ToStatePaths<NonNullable<TStateValue[K]>, WithParentPath<K, TParentPath>>;
+}>;
+
 /**
  * @public
  *
  * Returns the list of active routing events, or undefined if there are none / used outside of an xstate-tree routing context
  */
 export declare function useActiveRouteEvents(): {
-    type: unknown;
+    type: string;
     originalUrl: string;
     params: unknown;
     query: unknown;
@@ -812,11 +652,6 @@ export declare function useIsRouteActive(...routes: AnyRoute[]): boolean;
  */
 export declare function useRouteArgsIfActive<TRoute extends AnyRoute>(route: TRoute): ArgumentsForRoute<TRoute> | undefined;
 
-/**
- * @public
- */
-export declare type V1Selectors<TContext, TEvent, TSelectors, TMatches> = (ctx: TContext, canHandleEvent: (e: TEvent) => boolean, inState: TMatches, __currentState: never) => TSelectors;
-
 /**
  * @public
  */
@@ -827,6 +662,8 @@ export declare type V2BuilderMeta<TMachine extends AnyStateMachine, TSelectorsOu
     View: View<TActionsOutput, TSelectorsOutput, TSlots>;
 };
 
+declare type Values<T> = T[keyof T];
+
 /**
  * @public
  */
@@ -836,19 +673,6 @@ export declare type View<TActionsOutput, TSelectorsOutput, TSlots extends readon
     selectors: TSelectorsOutput;
 }>;
 
-/**
- * @public
- */
-export declare type ViewProps<TSelectors, TActions, TSlots extends readonly Slot[], TMatches extends AnyFunction> = {
-    slots: Record<GetSlotNames<TSlots>, React_2.ComponentType>;
-    actions: TActions;
-    selectors: TSelectors;
-    /**
-     * @deprecated see https://github.com/koordinates/xstate-tree/issues/33 use `inState` in the selector function instead
-     */
-    inState: TMatches;
-};
-
 /**
  * @public
  *
@@ -859,6 +683,8 @@ export declare type ViewProps<TSelectors, TActions, TSlots extends readonly Slot
  */
 export declare function viewToMachine(view: () => JSX.Element): AnyXstateTreeMachine;
 
+declare type WithParentPath<TCurrent extends string, TParentPath extends string> = `${TParentPath extends "" ? "" : `${TParentPath}.`}${TCurrent}`;
+
 /**
  * @public
  */
@@ -870,30 +696,18 @@ export declare type XstateTreeHistory<T = unknown> = History_2<{
 /**
  * @public
  */
-export declare type XStateTreeMachineMetaV1<TMachine extends AnyStateMachine, TSelectors, TActions extends AnyActions, TSlots extends readonly Slot[] = Slot[]> = {
-    slots: TSlots;
-    view: React_2.ComponentType<ViewProps<OutputFromSelector<TSelectors>, ReturnType<TActions>, TSlots, MatchesFrom<TMachine>>>;
-    selectors: TSelectors;
-    actions: TActions;
-    xstateTreeMachine?: true;
-};
+export declare type XstateTreeMachine<TMachine extends AnyStateMachine> = TMachine & XstateTreeMachineInjection<TMachine>;
 
 /**
- * @public
+ * @internal
  */
-export declare type XstateTreeMachineStateSchemaV1<TMachine extends AnyStateMachine, TSelectors extends AnySelector, TActions extends AnyActions> = {
-    meta: XStateTreeMachineMetaV1<TMachine, TSelectors, TActions> & {
-        builderVersion: 1;
-    };
+export declare type XstateTreeMachineInjection<TMachine extends AnyStateMachine> = {
+    _xstateTree: XstateTreeMachineStateSchemaV2<TMachine>;
 };
 
 /**
  * @public
  */
-export declare type XstateTreeMachineStateSchemaV2<TMachine extends AnyStateMachine, TSelectorsOutput = ContextFrom<TMachine>, TActionsOutput = Record<never, string>, TSlots extends readonly Slot[] = Slot[]> = {
-    meta: Required<V2BuilderMeta<TMachine, TSelectorsOutput, TActionsOutput, TSlots> & {
-        builderVersion: 2;
-    }>;
-};
+export declare type XstateTreeMachineStateSchemaV2<TMachine extends AnyStateMachine, TSelectorsOutput = ContextFrom<TMachine>, TActionsOutput = Record<never, string>, TSlots extends readonly Slot[] = Slot[]> = Required<V2BuilderMeta<TMachine, TSelectorsOutput, TActionsOutput, TSlots>>;
 
 export { }