@modern-js/devtools-kit 2.49.4 → 2.50.0

package/dist/channel.js

@@ -35,6 +35,7 @@ __export(channel_exports, {
 module.exports = __toCommonJS(channel_exports);
 var import_nanoid = require("nanoid");
 var flatted = __toESM(require("flatted"));
+var import_serializer = require("./serializer");
 class WebSocketChannel {
   static link(ws) {
     return new Promise((resolve, reject) => {
@@ -75,10 +76,11 @@ class WebSocketChannel {
   serialize(data) {
     return flatted.stringify([
       data
-    ]);
+    ], import_serializer.replacer);
   }
   deserialize(e) {
-    return flatted.parse(e.data.toString())[0];
+    const msg = flatted.parse(e.data.toString(), import_serializer.reviver)[0];
+    return msg;
   }
   constructor(ws) {
     this.ws = ws;

package/dist/client.d.ts

@@ -1,17 +1,14 @@
 import type { ComponentType, ReactElement } from 'react';
-import type { Entrypoint } from '@modern-js/types';
-import { FileSystemRoutes } from './server';
+import type { Op } from './valtio';
 export interface ClientFunctions {
     refresh: () => void;
-    updateFileSystemRoutes: (param: {
-        entrypoint: Entrypoint;
-        routes: FileSystemRoutes;
-    }) => void;
+    applyStateOperations: (ops: Op[]) => Promise<void>;
 }
 export declare class NameDefinition {
     formalName: string;
     casualName: string;
     prefixName: string;
+    shortName: string;
 }
 export interface ShortenAlias {
     replace: string | RegExp;

package/dist/client.js

@@ -42,6 +42,7 @@ class NameDefinition {
     this.formalName = "Modern.js";
     this.casualName = "modern.js";
     this.prefixName = "_modern_js";
+    this.shortName = "modern";
   }
 }
 class PackageDefinition {

package/dist/node.d.ts

@@ -6,3 +6,8 @@ export * from './constants';
 export * from './channel';
 export * from './rsdoctor';
 export * from './runtime-globals';
+export * from './promise';
+export * from './valtio';
+export type * from './storage-preset';
+export * from './state';
+export * from './serializer';

package/dist/node.js

@@ -23,6 +23,10 @@ __reExport(node_exports, require("./constants"), module.exports);
 __reExport(node_exports, require("./channel"), module.exports);
 __reExport(node_exports, require("./rsdoctor"), module.exports);
 __reExport(node_exports, require("./runtime-globals"), module.exports);
+__reExport(node_exports, require("./promise"), module.exports);
+__reExport(node_exports, require("./valtio"), module.exports);
+__reExport(node_exports, require("./state"), module.exports);
+__reExport(node_exports, require("./serializer"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require("./server"),
@@ -32,5 +36,9 @@ __reExport(node_exports, require("./runtime-globals"), module.exports);
   ...require("./constants"),
   ...require("./channel"),
   ...require("./rsdoctor"),
-  ...require("./runtime-globals")
+  ...require("./runtime-globals"),
+  ...require("./promise"),
+  ...require("./valtio"),
+  ...require("./state"),
+  ...require("./serializer")
 });

package/dist/promise.d.ts

@@ -0,0 +1,28 @@
+import type { Path } from './valtio';
+export type PromiseResolve<T> = (value: T | PromiseLike<T>) => void;
+export type PromiseReject = (reason?: any) => void;
+export declare const isPromiseLike: <T = any>(obj: unknown) => obj is PromiseLike<T>;
+export declare class PromiseStub<T> implements PromiseLike<T> {
+    static create<T>(): PromiseStub<T>;
+    static get<T>(promise: Promise<T>): PromiseStub<T>;
+    resolve: PromiseResolve<T>;
+    reject: PromiseReject;
+    promise: Promise<T>;
+    protected constructor();
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): PromiseLike<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult>;
+}
+export declare const traversePromises: (obj: any, path?: Path) => [PromiseLike<unknown>, Path][];
+export declare const applySettled: <T = unknown>(promise: PromiseLike<T>) => Promise<unknown>;
+export interface PromiseResolvers<T> {
+    resolve: PromiseResolve<T>;
+    reject: PromiseReject;
+    promise: Promise<T>;
+}
+type Primitive = string | number | boolean | null | undefined | symbol | bigint;
+type DeepToResolversIgnore = Date | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | Error | RegExp | ((...args: any[]) => any) | Primitive;
+export type DeepToResolvers<T> = T extends DeepToResolversIgnore ? T : T extends Promise<unknown> ? PromiseResolvers<Awaited<T>> : T extends object ? {
+    [K in keyof T]: DeepToResolvers<T[K]>;
+} : T;
+export declare const withResolvers: <T>() => PromiseResolvers<T>;
+export {};

package/dist/promise.js

@@ -0,0 +1,128 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var promise_exports = {};
+__export(promise_exports, {
+  PromiseStub: () => PromiseStub,
+  applySettled: () => applySettled,
+  isPromiseLike: () => isPromiseLike,
+  traversePromises: () => traversePromises,
+  withResolvers: () => withResolvers
+});
+module.exports = __toCommonJS(promise_exports);
+const isPromiseLike = (obj) => obj !== null && typeof obj === "object" && typeof obj.then === "function";
+const _promiseResolveMapping = /* @__PURE__ */ new WeakMap();
+const _promiseRejectMapping = /* @__PURE__ */ new WeakMap();
+class PromiseStub {
+  static create() {
+    const stub = new PromiseStub();
+    stub.promise = new Promise((resolve, reject) => {
+      stub.resolve = resolve;
+      stub.reject = reject;
+    });
+    _promiseResolveMapping.set(stub.promise, stub.resolve);
+    _promiseRejectMapping.set(stub.promise, stub.reject);
+    return stub;
+  }
+  static get(promise) {
+    const resolve = _promiseResolveMapping.get(promise);
+    const reject = _promiseRejectMapping.get(promise);
+    if (!resolve || !reject) {
+      throw new Error("Invalid promise");
+    }
+    const stub = new PromiseStub();
+    stub.promise = promise;
+    stub.resolve = resolve;
+    stub.reject = reject;
+    return stub;
+  }
+  then(onfulfilled, onrejected) {
+    return this.promise.then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.promise.catch(onrejected);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  constructor() {
+  }
+}
+const traversePromises = (obj, path = []) => {
+  const promises = /* @__PURE__ */ new Set();
+  const memo = /* @__PURE__ */ new WeakSet();
+  const traverse = (value, currentPath) => {
+    if (value === null)
+      return;
+    if (typeof value === "object") {
+      if (memo.has(value)) {
+        return;
+      } else {
+        memo.add(value);
+      }
+    }
+    if (isPromiseLike(value)) {
+      promises.add([
+        value,
+        currentPath
+      ]);
+    } else if (typeof value === "object") {
+      for (const [k, v] of Object.entries(value)) {
+        traverse(v, [
+          ...currentPath,
+          k
+        ]);
+      }
+    }
+  };
+  traverse(obj, path);
+  return Array.from(promises.values());
+};
+const applySettled = (promise) => {
+  const settled = {};
+  promise.then((value) => {
+    settled.resolved = value;
+  });
+  if ("catch" in promise && typeof promise.catch === "function") {
+    promise.catch((err) => {
+      settled.rejected = err;
+    });
+  }
+  return new Promise(async (resolve, reject) => {
+    await Promise.resolve();
+    if ("rejected" in settled) {
+      reject(settled.rejected);
+    } else if ("resolved" in settled) {
+      resolve(settled.resolved);
+    }
+  });
+};
+const withResolvers = () => {
+  const resolvers = {};
+  resolvers.promise = new Promise((resolve, reject) => {
+    resolvers.resolve = resolve;
+    resolvers.reject = reject;
+  });
+  return resolvers;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PromiseStub,
+  applySettled,
+  isPromiseLike,
+  traversePromises,
+  withResolvers
+});

package/dist/runtime.d.ts

@@ -6,3 +6,8 @@ export * from './constants';
 export * from './channel';
 export type * from './rsdoctor';
 export * from './runtime-globals';
+export type * from './storage-preset';
+export * from './promise';
+export * from './valtio';
+export * from './state';
+export * from './serializer';

package/dist/runtime.js

@@ -21,6 +21,10 @@ __reExport(runtime_exports, require("./utils"), module.exports);
 __reExport(runtime_exports, require("./constants"), module.exports);
 __reExport(runtime_exports, require("./channel"), module.exports);
 __reExport(runtime_exports, require("./runtime-globals"), module.exports);
+__reExport(runtime_exports, require("./promise"), module.exports);
+__reExport(runtime_exports, require("./valtio"), module.exports);
+__reExport(runtime_exports, require("./state"), module.exports);
+__reExport(runtime_exports, require("./serializer"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require("./client"),
@@ -28,5 +32,9 @@ __reExport(runtime_exports, require("./runtime-globals"), module.exports);
   ...require("./utils"),
   ...require("./constants"),
   ...require("./channel"),
-  ...require("./runtime-globals")
+  ...require("./runtime-globals"),
+  ...require("./promise"),
+  ...require("./valtio"),
+  ...require("./state"),
+  ...require("./serializer")
 });

package/dist/serializer.d.ts

@@ -0,0 +1,2 @@
+export declare function replacer(this: any, _key: string, value: any): any;
+export declare function reviver(this: any, _key: string, value: any): any;

package/dist/serializer.js

@@ -0,0 +1,47 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var serializer_exports = {};
+__export(serializer_exports, {
+  replacer: () => replacer,
+  reviver: () => reviver
+});
+module.exports = __toCommonJS(serializer_exports);
+var import_promise = require("./promise");
+function replacer(_key, value) {
+  if ((0, import_promise.isPromiseLike)(value)) {
+    return {
+      __type__: "promise"
+    };
+  }
+  return value;
+}
+function reviver(_key, value) {
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  if (value.__type__ === "promise" && Object.keys(value).length === 1) {
+    return import_promise.PromiseStub.create().promise;
+  }
+  return value;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  replacer,
+  reviver
+});

package/dist/server.d.ts

@@ -1,8 +1,10 @@
 import type { AppTools, IAppContext, UserConfig } from '@modern-js/app-tools';
 import type { RsbuildContext, NormalizedConfig as NormalizedBuilderConfig, RsbuildConfig, webpack, Rspack, WebpackConfig, RspackConfig } from '@modern-js/uni-builder';
-import { NormalizedConfig } from '@modern-js/core';
-import { RouteLegacy, NestedRouteForCli, PageRoute } from '@modern-js/types';
+import type { NormalizedConfig } from '@modern-js/core';
+import type { RouteLegacy, NestedRouteForCli, PageRoute } from '@modern-js/types';
 import type { Manifest } from '@rsdoctor/types';
+import type { StoragePresetConfig, StoragePresetContext, StoragePresetWithIdent } from './storage-preset';
+import type { ServerExportedState } from './state';
 import type { ClientDefinition } from './client';
 export type BuilderContext = RsbuildContext;
 export type FrameworkConfig = UserConfig<AppTools>;
@@ -11,6 +13,13 @@ export type BuilderConfig = RsbuildConfig;
 export type { NormalizedBuilderConfig, WebpackConfig, RspackConfig };
 export type Aliases = NonNullable<NonNullable<WebpackConfig['resolve']>['alias']>;
 export type BundlerConfig = WebpackConfig | RspackConfig;
+export interface DevtoolsContext {
+    enable: boolean;
+    endpoint: string;
+    dataSource: string;
+    def: ClientDefinition;
+    storagePresets: StoragePresetContext[];
+}
 export type Compiler = webpack.Compiler | Rspack.Compiler | webpack.MultiCompiler | Rspack.MultiCompiler;
 export type AppContext = Omit<IAppContext, 'builder' | 'serverInternalPlugins'>;
 export type FileSystemRoutes = RouteLegacy[] | (NestedRouteForCli | PageRoute)[];
@@ -21,19 +30,19 @@ export interface DoctorManifestOverview {
     summary: Manifest.RsdoctorManifest['data']['summary'];
     errors: Manifest.RsdoctorManifest['data']['errors'];
 }
+export interface DevtoolsConfig {
+    storagePresets?: StoragePresetConfig[];
+}
+export interface ResolvedDevtoolsConfig {
+    storagePresets: StoragePresetContext[];
+}
 export interface ServerFunctions {
-    getFrameworkConfig: () => Promise<FrameworkConfig>;
-    getTransformedFrameworkConfig: () => Promise<TransformedFrameworkConfig>;
-    getBuilderConfig: () => Promise<BuilderConfig>;
-    getTransformedBuilderConfig: () => Promise<NormalizedBuilderConfig>;
-    getBundlerConfigs: () => Promise<BundlerConfig[]>;
-    getTransformedBundlerConfigs: () => Promise<BundlerConfig[]>;
-    getAppContext: () => Promise<AppContext>;
-    getFileSystemRoutes: (entryName: string) => Promise<FileSystemRoutes>;
-    getBuilderContext: () => Promise<RsbuildContext>;
-    getDependencies: () => Promise<Record<string, string>>;
-    getCompileTimeCost: () => Promise<number>;
-    getClientDefinition: () => Promise<ClientDefinition>;
-    getDoctorOverview: () => Promise<DoctorManifestOverview>;
     echo: (content: string) => string;
+    pullExportedState: () => Promise<ServerExportedState>;
+    createTemporaryStoragePreset: () => Promise<StoragePresetWithIdent>;
+    pasteStoragePreset: (target: {
+        filename: string;
+        id: string;
+    }) => Promise<void>;
+    open: (filename: string) => Promise<void>;
 }

package/dist/state.d.ts

@@ -0,0 +1,37 @@
+import type { AppContext, BuilderConfig, BuilderContext, BundlerConfig, DevtoolsContext, DoctorManifestOverview, FileSystemRoutes, FrameworkConfig, NormalizedBuilderConfig, TransformedFrameworkConfig } from './server';
+import { type DeepToResolvers } from './promise';
+export interface ServerExportedState {
+    framework: {
+        context: Promise<AppContext>;
+        config: {
+            resolved: Promise<FrameworkConfig>;
+            transformed: Promise<TransformedFrameworkConfig>;
+        };
+    };
+    builder: {
+        context: Promise<BuilderContext>;
+        config: {
+            resolved: Promise<BuilderConfig>;
+            transformed: Promise<NormalizedBuilderConfig>;
+        };
+    };
+    bundler: {
+        configs: {
+            resolved: Promise<BundlerConfig[]>;
+            transformed: Promise<BundlerConfig[]>;
+        };
+    };
+    doctor: Promise<DoctorManifestOverview | void>;
+    context: DevtoolsContext | Promise<DevtoolsContext>;
+    performance: Promise<{
+        compileDuration: number;
+    }>;
+    dependencies: Record<string, string>;
+    fileSystemRoutes: Record<string, FileSystemRoutes>;
+}
+export type ServerExportedStateResolvers = DeepToResolvers<ServerExportedState>;
+export interface ServerExportedStateResult {
+    resolvers: ServerExportedStateResolvers;
+    state: ServerExportedState;
+}
+export declare const createServerExportedState: () => ServerExportedStateResult;

package/dist/state.js

@@ -0,0 +1,88 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var state_exports = {};
+__export(state_exports, {
+  createServerExportedState: () => createServerExportedState
+});
+module.exports = __toCommonJS(state_exports);
+var import_promise = require("./promise");
+const createServerExportedState = () => {
+  const resolvers = {
+    framework: {
+      context: import_promise.PromiseStub.create(),
+      config: {
+        resolved: import_promise.PromiseStub.create(),
+        transformed: import_promise.PromiseStub.create()
+      }
+    },
+    builder: {
+      context: import_promise.PromiseStub.create(),
+      config: {
+        resolved: import_promise.PromiseStub.create(),
+        transformed: import_promise.PromiseStub.create()
+      }
+    },
+    bundler: {
+      configs: {
+        resolved: import_promise.PromiseStub.create(),
+        transformed: import_promise.PromiseStub.create()
+      }
+    },
+    doctor: import_promise.PromiseStub.create(),
+    context: import_promise.PromiseStub.create(),
+    performance: import_promise.PromiseStub.create(),
+    dependencies: {},
+    fileSystemRoutes: {}
+  };
+  const state = {
+    framework: {
+      context: resolvers.framework.context.promise,
+      config: {
+        resolved: resolvers.framework.config.resolved.promise,
+        transformed: resolvers.framework.config.transformed.promise
+      }
+    },
+    builder: {
+      context: resolvers.builder.context.promise,
+      config: {
+        resolved: resolvers.builder.config.resolved.promise,
+        transformed: resolvers.builder.config.transformed.promise
+      }
+    },
+    bundler: {
+      configs: {
+        resolved: resolvers.bundler.configs.resolved.promise,
+        transformed: resolvers.bundler.configs.transformed.promise
+      }
+    },
+    doctor: resolvers.doctor.promise,
+    context: resolvers.context.promise,
+    performance: resolvers.performance.promise,
+    dependencies: resolvers.dependencies,
+    fileSystemRoutes: resolvers.fileSystemRoutes
+  };
+  return {
+    resolvers,
+    state
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createServerExportedState
+});

package/dist/storage-preset.d.ts

@@ -0,0 +1,13 @@
+export interface StoragePresetConfig {
+    id?: string;
+    name: string;
+    cookie?: Record<string, string>;
+    localStorage?: Record<string, string>;
+    sessionStorage?: Record<string, string>;
+}
+export interface StoragePresetWithIdent extends StoragePresetConfig {
+    id: string;
+}
+export interface StoragePresetContext extends StoragePresetWithIdent {
+    filename: string;
+}

package/dist/storage-preset.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var storage_preset_exports = {};
+module.exports = __toCommonJS(storage_preset_exports);

package/dist/valtio.d.ts

@@ -0,0 +1,5 @@
+export type Path = (string | symbol)[];
+export type Op = [op: 'set', path: Path, value: unknown, prevValue: unknown] | [op: 'delete', path: Path, prevValue: unknown] | [op: 'resolve', path: Path, value: unknown] | [op: 'reject', path: Path, error: unknown];
+export declare const resolvePaths: (obj: any, path: Path) => any;
+export declare const applyOperation: (state: Record<any, any>, op: Op) => void;
+export declare const extractSettledOperations: (state: object) => Promise<Op[]>;

package/dist/valtio.js

@@ -0,0 +1,95 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var valtio_exports = {};
+__export(valtio_exports, {
+  applyOperation: () => applyOperation,
+  extractSettledOperations: () => extractSettledOperations,
+  resolvePaths: () => resolvePaths
+});
+module.exports = __toCommonJS(valtio_exports);
+var import_promise = require("./promise");
+const resolvePaths = (obj, path) => {
+  let current = obj;
+  for (const key of path) {
+    current = current[key];
+  }
+  return current;
+};
+const applyOperation = (state, op) => {
+  const [operation, path, value, _prevValue] = op;
+  const dirnames = path.slice(0, -1);
+  const basename = path[path.length - 1];
+  const parent = resolvePaths(state, dirnames);
+  if (operation === "delete") {
+    delete parent[basename];
+  } else if (operation === "set") {
+    if (value instanceof import_promise.PromiseStub) {
+      parent[basename] = value.promise;
+    } else {
+      parent[basename] = value;
+    }
+  } else {
+    const promise = parent[basename];
+    let promiseStub;
+    if (promise instanceof import_promise.PromiseStub) {
+      promiseStub = promise;
+    } else {
+      try {
+        promiseStub = import_promise.PromiseStub.get(promise);
+      } catch {
+        promiseStub = import_promise.PromiseStub.create();
+      }
+    }
+    if (operation === "resolve") {
+      promiseStub.resolve(value);
+    } else {
+      promiseStub.reject(value);
+    }
+  }
+};
+const extractSettledOperations = async (state) => {
+  const ops = [];
+  const _promises = [];
+  for (const [promise, path] of (0, import_promise.traversePromises)(state)) {
+    const sendResolveMessage = (value) => {
+      ops.push([
+        "resolve",
+        path,
+        value
+      ]);
+    };
+    const sendRejectMessage = (error) => {
+      ops.push([
+        "reject",
+        path,
+        error
+      ]);
+    };
+    const _promise = (0, import_promise.applySettled)(promise).then(sendResolveMessage).catch(sendRejectMessage);
+    _promises.push(_promise);
+  }
+  await Promise.all(_promises);
+  return ops;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyOperation,
+  extractSettledOperations,
+  resolvePaths
+});

package/package.json

@@ -21,7 +21,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.49.4",
+  "version": "2.50.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",
@@ -61,10 +61,11 @@
     "ufo": "^1.3.0",
     "flatted": "^3.2.9",
     "ws": "^8.13.0",
-    "@rsdoctor/types": "^0.1.3",
-    "@rsdoctor/utils": "^0.1.3",
-    "@modern-js/types": "2.49.4",
-    "@modern-js/utils": "2.49.4"
+    "cookie-es": "^1.0.0",
+    "@rsdoctor/types": "^0.2.4",
+    "@rsdoctor/utils": "^0.2.4",
+    "@modern-js/utils": "2.50.0",
+    "@modern-js/types": "2.50.0"
   },
   "devDependencies": {
     "@babel/core": "^7.23.2",
@@ -79,13 +80,13 @@
     "react": "~18.2.0",
     "type-fest": "^4.1.0",
     "typescript": "^5",
-    "@modern-js/app-tools": "2.49.4",
-    "@modern-js/core": "2.49.4",
-    "@modern-js/module-tools": "2.49.4",
-    "@modern-js/types": "2.49.4",
-    "@modern-js/uni-builder": "2.49.4",
-    "@scripts/build": "2.49.4",
-    "@scripts/jest-config": "2.49.4"
+    "@modern-js/module-tools": "2.50.0",
+    "@modern-js/app-tools": "2.50.0",
+    "@modern-js/types": "2.50.0",
+    "@modern-js/core": "2.50.0",
+    "@modern-js/uni-builder": "2.50.0",
+    "@scripts/build": "2.50.0",
+    "@scripts/jest-config": "2.50.0"
   },
   "peerDependencies": {
     "react": "~18.2.0"