@fozy-labs/rx-toolkit 0.5.3-rc.1 → 0.5.3

package/dist/query-v2/core/common/LifecycleHooks.js

@@ -0,0 +1,104 @@
+import { PromiseResolver } from "../../../common/utils/PromiseResolver";
+export class LifecycleHooks {
+    _onCacheEntryAdded;
+    _onQueryStarted;
+    _cacheEntryState = new Map();
+    _queryState = null;
+    _serializeArgs;
+    constructor(options) {
+        this._onCacheEntryAdded = options.onCacheEntryAdded;
+        this._onQueryStarted = options.onQueryStarted;
+        this._serializeArgs = options.serializeArgs;
+    }
+    fireCacheEntryAdded(args, getCacheEntry) {
+        if (!this._onCacheEntryAdded)
+            return;
+        const key = this._serializeArgs(args);
+        const $cacheDataLoaded = new PromiseResolver();
+        const $cacheEntryRemoved = new PromiseResolver();
+        // Prevent unhandled rejection if no consumer attaches .catch()
+        $cacheDataLoaded.promise.catch(() => { });
+        $cacheEntryRemoved.promise.catch(() => { });
+        const state = {
+            $cacheDataLoaded,
+            $cacheEntryRemoved,
+            dataLoaded: false,
+        };
+        this._cacheEntryState.set(key, state);
+        const tools = {
+            $cacheDataLoaded: $cacheDataLoaded.promise,
+            $cacheEntryRemoved: $cacheEntryRemoved.promise,
+            getCacheEntry: getCacheEntry,
+        };
+        this._onCacheEntryAdded(args, tools);
+    }
+    fireCacheEntryRemoved(args) {
+        const key = this._serializeArgs(args);
+        const state = this._cacheEntryState.get(key);
+        if (!state)
+            return;
+        if (!state.dataLoaded) {
+            state.$cacheDataLoaded.reject(new Error("Cache entry removed before data loaded"));
+        }
+        state.$cacheEntryRemoved.resolve();
+        this._cacheEntryState.delete(key);
+    }
+    resolveCacheDataLoaded(args, data) {
+        const key = this._serializeArgs(args);
+        const state = this._cacheEntryState.get(key);
+        if (!state || state.dataLoaded)
+            return;
+        state.dataLoaded = true;
+        state.$cacheDataLoaded.resolve(data);
+    }
+    fireQueryStarted(args, getCacheEntry) {
+        if (!this._onQueryStarted) {
+            // Still create state for resolving/rejecting even without callback
+            const resolver = new PromiseResolver();
+            resolver.promise.catch(() => { });
+            this._queryState = {
+                $queryFulfilled: resolver,
+            };
+            return;
+        }
+        const $queryFulfilled = new PromiseResolver();
+        // Prevent unhandled rejection if consumer doesn't attach .catch()
+        $queryFulfilled.promise.catch(() => { });
+        this._queryState = { $queryFulfilled };
+        const tools = {
+            $queryFulfilled: $queryFulfilled.promise,
+            getCacheEntry: () => getCacheEntry(),
+        };
+        this._onQueryStarted(args, tools);
+    }
+    resolveQueryFulfilled(data) {
+        if (!this._queryState)
+            return;
+        this._queryState.$queryFulfilled.resolve({ data, isError: false });
+        this._queryState = null;
+    }
+    rejectQueryFulfilled(error) {
+        if (!this._queryState)
+            return;
+        this._queryState.$queryFulfilled.reject(error);
+        this._queryState = null;
+    }
+    clearAll() {
+        for (const [, state] of this._cacheEntryState) {
+            if (!state.dataLoaded) {
+                state.$cacheDataLoaded.reject(new Error("Cache entry removed before data loaded"));
+            }
+            state.$cacheEntryRemoved.resolve();
+        }
+        this._cacheEntryState.clear();
+        if (this._queryState) {
+            try {
+                this._queryState.$queryFulfilled.reject(new Error("Resource reset"));
+            }
+            catch {
+                // Already settled
+            }
+            this._queryState = null;
+        }
+    }
+}

package/dist/query-v2/core/common/index.d.ts

@@ -0,0 +1,3 @@
+export { CacheEntry, type CacheEntryOptions } from "./CacheEntry";
+export { CacheMap, type TCacheMapInstance } from "./CacheMap";
+export { LifecycleHooks } from "./LifecycleHooks";

package/dist/query-v2/core/common/index.js

@@ -0,0 +1,3 @@
+export { CacheEntry } from "./CacheEntry";
+export { CacheMap } from "./CacheMap";
+export { LifecycleHooks } from "./LifecycleHooks";

package/dist/query-v2/core/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./common";
+export * from "./machines";
+export * from "./resource";

package/dist/query-v2/core/index.js

@@ -0,0 +1,3 @@
+export * from "./common";
+export * from "./machines";
+export * from "./resource";

package/dist/query-v2/core/machines/Machine.d.ts

@@ -0,0 +1,14 @@
+import type { TMachineStatus } from "../../../query-v2/types/machine.types";
+import { MachineError } from "./MachineError";
+import { MachineIdle } from "./MachineIdle";
+import { MachinePending } from "./MachinePending";
+import { MachineRefreshing } from "./MachineRefreshing";
+import { MachineSuccess } from "./MachineSuccess";
+export type TMachineInstance<TData = unknown, TError = Error> = MachineIdle | MachinePending<TData> | MachineSuccess<TData> | MachineError<TError> | MachineRefreshing<TData>;
+export declare const Machine: {
+    readonly idle: () => MachineIdle;
+    readonly fromSnapshot: <TData>(state: {
+        status: TMachineStatus;
+    } & Record<string, unknown>) => TMachineInstance<TData>;
+};
+export { MachineIdle, MachinePending, MachineSuccess, MachineError, MachineRefreshing };

package/dist/query-v2/core/machines/Machine.js

@@ -0,0 +1,33 @@
+import { NO_VALUE as NO_VALUE_VALUE } from "../../../query-v2/lib/NO_VALUE";
+import { MachineError } from "./MachineError";
+import { MachineIdle } from "./MachineIdle";
+import { MachinePending } from "./MachinePending";
+import { MachineRefreshing } from "./MachineRefreshing";
+import { MachineSuccess } from "./MachineSuccess";
+export const Machine = {
+    idle() {
+        return MachineIdle.create();
+    },
+    fromSnapshot(state) {
+        switch (state.status) {
+            case "idle":
+                return MachineIdle.create();
+            case "pending":
+                return MachinePending.create(state.args ?? null);
+            case "success":
+                return MachineSuccess.deploy({
+                    status: "success",
+                    args: state.args ?? null,
+                    data: state.data,
+                    updatedAt: state.updatedAt ?? Date.now(),
+                });
+            case "error":
+                return MachineError.create((state.error ?? new Error("Unknown error")), state.args ?? null);
+            case "refreshing":
+                return MachineRefreshing.create(state.data, state.args ?? null, state.updatedAt ?? Date.now(), NO_VALUE_VALUE, null);
+            default:
+                throw new Error(`Unknown machine status: ${state.status}`);
+        }
+    },
+};
+export { MachineIdle, MachinePending, MachineSuccess, MachineError, MachineRefreshing };

package/dist/query-v2/core/machines/MachineError.d.ts

@@ -0,0 +1,11 @@
+import type { TResourceV2ErrorState } from "../../../query-v2/types/machine.types";
+import { MachineIdle } from "./MachineIdle";
+import { MachinePending } from "./MachinePending";
+export declare class MachineError<TError = Error> {
+    readonly state: TResourceV2ErrorState<TError>;
+    private constructor();
+    retry(): MachinePending;
+    start(args: unknown): MachinePending;
+    reset(): MachineIdle;
+    static create<TError = Error>(error: TError, args: unknown): MachineError<TError>;
+}

package/dist/query-v2/core/machines/MachineError.js

@@ -0,0 +1,26 @@
+import { MachineIdle } from "./MachineIdle";
+import { MachinePending } from "./MachinePending";
+export class MachineError {
+    state;
+    constructor(error, args) {
+        this.state = {
+            status: "error",
+            args,
+            data: null,
+            error,
+            updatedAt: null,
+        };
+    }
+    retry() {
+        return MachinePending.create(this.state.args);
+    }
+    start(args) {
+        return MachinePending.create(args);
+    }
+    reset() {
+        return MachineIdle.create();
+    }
+    static create(error, args) {
+        return new MachineError(error, args);
+    }
+}

package/dist/query-v2/core/machines/MachineIdle.d.ts

@@ -0,0 +1,8 @@
+import type { TResourceV2IdleState } from "../../../query-v2/types/machine.types";
+import { MachinePending } from "./MachinePending";
+export declare class MachineIdle {
+    readonly state: TResourceV2IdleState;
+    start(args: unknown): MachinePending;
+    reset(): MachineIdle;
+    static create(): MachineIdle;
+}

package/dist/query-v2/core/machines/MachineIdle.js

@@ -0,0 +1,19 @@
+import { MachinePending } from "./MachinePending";
+export class MachineIdle {
+    state = {
+        status: "idle",
+        args: null,
+        data: null,
+        error: null,
+        updatedAt: null,
+    };
+    start(args) {
+        return MachinePending.create(args);
+    }
+    reset() {
+        return this;
+    }
+    static create() {
+        return new MachineIdle();
+    }
+}

package/dist/query-v2/core/machines/MachinePending.d.ts

@@ -0,0 +1,12 @@
+import type { TResourceV2PendingState } from "../../../query-v2/types/machine.types";
+import { MachineError } from "./MachineError";
+import { MachineIdle } from "./MachineIdle";
+import { MachineSuccess } from "./MachineSuccess";
+export declare class MachinePending<TData = unknown> {
+    readonly state: TResourceV2PendingState<TData>;
+    private constructor();
+    successHappened(data: TData): MachineSuccess<TData>;
+    errorHappened<TError = Error>(error: TError): MachineError<TError>;
+    reset(): MachineIdle;
+    static create<TData = unknown>(args: unknown): MachinePending<TData>;
+}

package/dist/query-v2/core/machines/MachinePending.js

@@ -0,0 +1,29 @@
+import { NO_VALUE as NO_VALUE_VALUE } from "../../../query-v2/lib/NO_VALUE";
+import { MachineError } from "./MachineError";
+import { MachineIdle } from "./MachineIdle";
+import { MachineSuccess } from "./MachineSuccess";
+export class MachinePending {
+    state;
+    constructor(args) {
+        this.state = {
+            status: "pending",
+            args,
+            data: null,
+            error: null,
+            updatedAt: null,
+            originalData: NO_VALUE_VALUE,
+        };
+    }
+    successHappened(data) {
+        return MachineSuccess.create(data, this.state.args);
+    }
+    errorHappened(error) {
+        return MachineError.create(error, this.state.args);
+    }
+    reset() {
+        return MachineIdle.create();
+    }
+    static create(args) {
+        return new MachinePending(args);
+    }
+}

package/dist/query-v2/core/machines/MachineRefreshing.d.ts

@@ -0,0 +1,14 @@
+import type { NO_VALUE } from "../../../query-v2/lib/NO_VALUE";
+import type { TResourceV2Patch, TResourceV2RefreshingState } from "../../../query-v2/types/machine.types";
+import { MachineIdle } from "./MachineIdle";
+import { MachineSuccess } from "./MachineSuccess";
+import { MachineWithData, type MachineWithDataState } from "./MachineWithData";
+export declare class MachineRefreshing<TData = unknown> extends MachineWithData<TData> {
+    readonly state: TResourceV2RefreshingState<TData>;
+    private constructor();
+    protected cloneWith(updates: Partial<MachineWithDataState<TData>>): this;
+    successHappened(data: TData): MachineSuccess<TData>;
+    errorHappened(_error: unknown): MachineSuccess<TData>;
+    reset(): MachineIdle;
+    static create<TData>(data: TData, args: unknown, updatedAt: number, originalData?: TData | NO_VALUE, patches?: TResourceV2Patch[] | null): MachineRefreshing<TData>;
+}

package/dist/query-v2/core/machines/MachineRefreshing.js

@@ -0,0 +1,46 @@
+import { NO_VALUE as NO_VALUE_VALUE } from "../../../query-v2/lib/NO_VALUE";
+import { MachineIdle } from "./MachineIdle";
+import { MachineSuccess } from "./MachineSuccess";
+import { MachineWithData } from "./MachineWithData";
+export class MachineRefreshing extends MachineWithData {
+    state;
+    constructor(data, args, updatedAt, originalData = NO_VALUE_VALUE, patches = null) {
+        super();
+        this.state = {
+            status: "refreshing",
+            args,
+            data,
+            error: null,
+            updatedAt,
+            originalData,
+            patches,
+        };
+    }
+    cloneWith(updates) {
+        return new MachineRefreshing(updates.data ?? this.state.data, this.state.args, this.state.updatedAt, updates.originalData !== undefined ? updates.originalData : this.state.originalData, updates.patches !== undefined ? updates.patches : this.state.patches);
+    }
+    successHappened(data) {
+        // Fresh data supersedes optimistic patches — abort all pending (per ADR-4, E11)
+        const cleaned = this.abortAllPendingPatches();
+        // Ignore cleaned data — fresh data from server replaces everything
+        void cleaned;
+        return MachineSuccess.create(data, this.state.args);
+    }
+    errorHappened(_error) {
+        // ADR-2: Preserve stale data on refresh error
+        // Return MachineSuccess with original stale data, same updatedAt, preserve patches
+        return MachineSuccess.deploy({
+            status: "success",
+            args: this.state.args,
+            data: this.state.data,
+            updatedAt: this.state.updatedAt,
+        });
+    }
+    reset() {
+        this.abortAllPendingPatches();
+        return MachineIdle.create();
+    }
+    static create(data, args, updatedAt, originalData = NO_VALUE_VALUE, patches = null) {
+        return new MachineRefreshing(data, args, updatedAt, originalData, patches);
+    }
+}

package/dist/query-v2/core/machines/MachineSuccess.d.ts

@@ -0,0 +1,16 @@
+import type { TResourceV2SuccessState } from "../../../query-v2/types/machine.types";
+import type { TResourceV2SnapshotSlice } from "../../../query-v2/types/snapshot.types";
+import { MachineIdle } from "./MachineIdle";
+import { MachinePending } from "./MachinePending";
+import { MachineRefreshing } from "./MachineRefreshing";
+import { MachineWithData, type MachineWithDataState } from "./MachineWithData";
+export declare class MachineSuccess<TData = unknown> extends MachineWithData<TData> {
+    readonly state: TResourceV2SuccessState<TData>;
+    private constructor();
+    protected cloneWith(updates: Partial<MachineWithDataState<TData>>): this;
+    invalidate(): MachineRefreshing<TData>;
+    start(args: unknown): MachinePending<TData>;
+    reset(): MachineIdle;
+    static create<TData>(data: TData, args: unknown): MachineSuccess<TData>;
+    static deploy<TData = unknown>(snapshotSlice: TResourceV2SnapshotSlice<TData>): MachineSuccess<TData>;
+}

package/dist/query-v2/core/machines/MachineSuccess.js

@@ -0,0 +1,42 @@
+import { NO_VALUE as NO_VALUE_VALUE } from "../../../query-v2/lib/NO_VALUE";
+import { MachineIdle } from "./MachineIdle";
+import { MachinePending } from "./MachinePending";
+import { MachineRefreshing } from "./MachineRefreshing";
+import { MachineWithData } from "./MachineWithData";
+export class MachineSuccess extends MachineWithData {
+    state;
+    constructor(data, args, updatedAt, originalData = NO_VALUE_VALUE, patches = null) {
+        super();
+        this.state = {
+            status: "success",
+            args,
+            data,
+            error: null,
+            updatedAt,
+            originalData,
+            patches,
+        };
+    }
+    cloneWith(updates) {
+        return new MachineSuccess(updates.data ?? this.state.data, this.state.args, this.state.updatedAt, updates.originalData !== undefined ? updates.originalData : this.state.originalData, updates.patches !== undefined ? updates.patches : this.state.patches);
+    }
+    invalidate() {
+        return MachineRefreshing.create(this.state.data, this.state.args, this.state.updatedAt, this.state.originalData, this.state.patches);
+    }
+    start(args) {
+        // Abort pending patches before transitioning (per ADR-4)
+        this.abortAllPendingPatches();
+        return MachinePending.create(args);
+    }
+    reset() {
+        // Abort pending patches before transitioning (per ADR-4)
+        this.abortAllPendingPatches();
+        return MachineIdle.create();
+    }
+    static create(data, args) {
+        return new MachineSuccess(data, args, Date.now());
+    }
+    static deploy(snapshotSlice) {
+        return new MachineSuccess(snapshotSlice.data, snapshotSlice.args, snapshotSlice.updatedAt);
+    }
+}

package/dist/query-v2/core/machines/MachineWithData.d.ts

@@ -0,0 +1,18 @@
+import type { NO_VALUE } from "../../../query-v2/lib/NO_VALUE";
+import type { TPatchFn, TResourceV2Patch } from "../../../query-v2/types/machine.types";
+export interface MachineWithDataState<TData> {
+    data: TData;
+    originalData: TData | NO_VALUE;
+    patches: TResourceV2Patch[] | null;
+}
+export declare abstract class MachineWithData<TData = unknown> {
+    abstract readonly state: MachineWithDataState<TData>;
+    protected abstract cloneWith(updates: Partial<MachineWithDataState<TData>>): this;
+    addPatch(patch: TResourceV2Patch): this;
+    finishPatch(type: "commit" | "abort", patch: TResourceV2Patch): this;
+    createPatch<TSelf extends MachineWithData<TData>>(this: TSelf, patchFn: TPatchFn<TData>): {
+        machine: TSelf;
+        patch: TResourceV2Patch;
+    };
+    abortAllPendingPatches(): this;
+}

package/dist/query-v2/core/machines/MachineWithData.js

@@ -0,0 +1,40 @@
+import { NO_VALUE as NO_VALUE_VALUE } from "../../../query-v2/lib/NO_VALUE";
+import { Patcher } from "./Patcher";
+export class MachineWithData {
+    addPatch(patch) {
+        const { state } = this;
+        const originalData = (state.originalData === NO_VALUE_VALUE ? state.data : state.originalData);
+        const currentPatches = state.patches ? [...state.patches, patch] : [patch];
+        const resolved = Patcher.resolvePatches(originalData, currentPatches);
+        return this.cloneWith({
+            data: resolved.data,
+            originalData,
+            patches: resolved.patches.length > 0 ? resolved.patches : null,
+        });
+    }
+    finishPatch(type, patch) {
+        const { state } = this;
+        const result = Patcher.finishPatch(state.originalData, state.patches, type, patch);
+        return this.cloneWith({
+            data: result.data ?? state.data,
+            originalData: result.originalData,
+            patches: result.patches,
+        });
+    }
+    createPatch(patchFn) {
+        const { state } = this;
+        const dataForPatch = state.data;
+        const patch = Patcher.createPatch(patchFn, dataForPatch);
+        const machine = this.addPatch(patch);
+        return { machine, patch };
+    }
+    abortAllPendingPatches() {
+        const { state } = this;
+        const result = Patcher.abortAllPending(state.originalData, state.patches);
+        return this.cloneWith({
+            data: result.data ?? state.data,
+            originalData: result.originalData,
+            patches: result.patches,
+        });
+    }
+}

package/dist/query-v2/core/machines/Patcher.d.ts

@@ -0,0 +1,20 @@
+import { NO_VALUE } from "../../../query-v2/lib/NO_VALUE";
+import type { TPatchFn, TResourceV2Patch } from "../../../query-v2/types/machine.types";
+export declare class Patcher {
+    static createPatch<TData>(patchFn: TPatchFn<TData>, data: TData): TResourceV2Patch;
+    static resolvePatches<TData>(originalData: TData, patches: TResourceV2Patch[]): {
+        data: TData;
+        patches: TResourceV2Patch[];
+        baseData: TData;
+    };
+    static finishPatch<TData>(originalData: TData | typeof NO_VALUE, patches: TResourceV2Patch[] | null, type: "commit" | "abort", patch: TResourceV2Patch): {
+        originalData: TData | typeof NO_VALUE;
+        patches: TResourceV2Patch[] | null;
+        data: TData | null;
+    };
+    static abortAllPending<TData>(originalData: TData | typeof NO_VALUE, patches: TResourceV2Patch[] | null): {
+        originalData: TData | typeof NO_VALUE;
+        patches: TResourceV2Patch[] | null;
+        data: TData | null;
+    };
+}

package/dist/query-v2/core/machines/Patcher.js

@@ -0,0 +1,104 @@
+import { applyPatches, enablePatches, produceWithPatches } from "immer";
+import { NO_VALUE } from "../../../query-v2/lib/NO_VALUE";
+enablePatches();
+function applyImmerPatches(data, patches) {
+    return applyPatches(data, patches);
+}
+export class Patcher {
+    static createPatch(patchFn, data) {
+        const [, patches, inversePatches] = produceWithPatches(data, patchFn);
+        return {
+            patches,
+            inversePatches,
+            status: "pending",
+        };
+    }
+    static resolvePatches(originalData, patches) {
+        let currentData = originalData;
+        let baseData = originalData;
+        const remainingPatches = [];
+        let foundPending = false;
+        const lastPendingIndex = patches.findLastIndex((p) => p.status === "pending");
+        patches.forEach((patch, index) => {
+            if (patch.status === "pending") {
+                foundPending = true;
+                currentData = applyImmerPatches(currentData, patch.patches);
+                remainingPatches.push(patch);
+            }
+            else if (foundPending) {
+                if (patch.status === "committed") {
+                    currentData = applyImmerPatches(currentData, patch.patches);
+                    remainingPatches.push(patch);
+                }
+                else if (patch.status === "aborted") {
+                    const hasPendingAfter = index < lastPendingIndex;
+                    if (hasPendingAfter) {
+                        currentData = applyImmerPatches(currentData, patch.inversePatches);
+                        remainingPatches.push(patch);
+                    }
+                    // No pending after → remove from queue
+                }
+            }
+            else {
+                // Before first pending
+                if (patch.status === "committed") {
+                    currentData = applyImmerPatches(currentData, patch.patches);
+                    baseData = currentData;
+                    // committed before pending → remove from queue
+                }
+                else if (patch.status === "aborted") {
+                    // aborted before pending → remove from queue
+                }
+            }
+        });
+        return { data: currentData, patches: remainingPatches, baseData };
+    }
+    static finishPatch(originalData, patches, type, patch) {
+        if (!patches) {
+            return { originalData, patches: null, data: null };
+        }
+        // Mark the target patch
+        patch.status = type === "commit" ? "committed" : "aborted";
+        // If no originalData, nothing to resolve
+        if (originalData === NO_VALUE) {
+            return { originalData, patches, data: null };
+        }
+        // Resolve patches
+        const resolved = Patcher.resolvePatches(originalData, patches);
+        const hasPending = resolved.patches.some((p) => p.status === "pending");
+        if (!hasPending) {
+            // No pending patches remain → clear originalData and patches
+            return {
+                originalData: NO_VALUE,
+                patches: resolved.patches.length > 0 ? resolved.patches : null,
+                data: resolved.data,
+            };
+        }
+        return {
+            originalData: resolved.baseData,
+            patches: resolved.patches.length > 0 ? resolved.patches : null,
+            data: resolved.data,
+        };
+    }
+    static abortAllPending(originalData, patches) {
+        if (!patches) {
+            return { originalData, patches: null, data: null };
+        }
+        // Mark all pending as aborted
+        for (const patch of patches) {
+            if (patch.status === "pending") {
+                patch.status = "aborted";
+            }
+        }
+        if (originalData === NO_VALUE) {
+            return { originalData: NO_VALUE, patches: null, data: null };
+        }
+        // Resolve: all should be either committed or aborted now
+        const resolved = Patcher.resolvePatches(originalData, patches);
+        return {
+            originalData: NO_VALUE,
+            patches: null,
+            data: resolved.data,
+        };
+    }
+}

package/dist/query-v2/core/machines/index.d.ts

@@ -0,0 +1,8 @@
+export { Machine, type TMachineInstance } from "./Machine";
+export { MachineIdle } from "./MachineIdle";
+export { MachinePending } from "./MachinePending";
+export { MachineSuccess } from "./MachineSuccess";
+export { MachineError } from "./MachineError";
+export { MachineRefreshing } from "./MachineRefreshing";
+export { MachineWithData } from "./MachineWithData";
+export { Patcher } from "./Patcher";

package/dist/query-v2/core/machines/index.js

@@ -0,0 +1,8 @@
+export { Machine } from "./Machine";
+export { MachineIdle } from "./MachineIdle";
+export { MachinePending } from "./MachinePending";
+export { MachineSuccess } from "./MachineSuccess";
+export { MachineError } from "./MachineError";
+export { MachineRefreshing } from "./MachineRefreshing";
+export { MachineWithData } from "./MachineWithData";
+export { Patcher } from "./Patcher";