@lynx-js/lynx-bundle-rslib-config-canary 0.0.0 → 0.0.1-canary-20251201-3692a169

package/CHANGELOG.md

@@ -0,0 +1,21 @@
+# @lynx-js/lynx-bundle-rslib-config
+
+## 0.0.1-canary-20251201060736-3692a169ae443124de0e9f7a288318f5dfba13b0
+
+### Patch Changes
+
+- Add `@lynx-js/lynx-bundle-rslib-config` for bundling Lynx bundle with [Rslib](https://rslib.rs/): ([#1943](https://github.com/lynx-family/lynx-stack/pull/1943))
+
+  ```js
+  // rslib.config.js
+  import { defineExternalBundleRslibConfig } from "@lynx-js/lynx-bundle-rslib-config";
+
+  export default defineExternalBundleRslibConfig({
+    id: "utils-lib",
+    source: {
+      entry: {
+        utils: "./src/utils.ts",
+      },
+    },
+  });
+  ```

package/README.md

@@ -0,0 +1,3 @@
+<h2 align="center">@lynx-js/lynx-bundle-rslib-config</h2>
+
+The package `@lynx-js/lynx-bundle-rslib-config` provides the configurations for bundling Lynx bundle with [Rslib](https://rslib.rs/).

package/lib/externalBundleRslibConfig.d.ts

@@ -0,0 +1,100 @@
+import type { LibConfig, RslibConfig } from '@rslib/core';
+/**
+ * The options for encoding the external bundle.
+ *
+ * @public
+ */
+export interface EncodeOptions {
+    /**
+     * The target SDK version of the external bundle.
+     *
+     * @defaultValue '3.4'
+     */
+    targetSdkVersion?: string;
+}
+/**
+ * The Layer name of background and main-thread.
+ *
+ * @public
+ */
+export declare const LAYERS: {
+    readonly BACKGROUND: "background";
+    readonly MAIN_THREAD: "main-thread";
+};
+/**
+ * The default lib config{@link LibConfig} for external bundle.
+ *
+ * @public
+ */
+export declare const defaultExternalBundleLibConfig: LibConfig;
+/**
+ * Get the rslib config for building Lynx external bundles.
+ *
+ * @public
+ *
+ * @example
+ *
+ * If you want to build an external bundle which use in Lynx background thread, you can use the following code:
+ *
+ * ```js
+ * // rslib.config.js
+ * import { defineExternalBundleRslibConfig, LAYERS } from '@lynx-js/lynx-bundle-rslib-config'
+ *
+ * export default defineExternalBundleRslibConfig({
+ *   id: 'utils-lib',
+ *   source: {
+ *     entry: {
+ *       utils: {
+ *         import: './src/utils.ts',
+ *         layer: LAYERS.BACKGROUND,
+ *       }
+ *     }
+ *   }
+ * })
+ * ```
+ *
+ * Then you can use `lynx.loadScript('utils', { bundleName: 'utils-lib-bundle-url' })` in background thread.
+ *
+ * @example
+ *
+ * If you want to build an external bundle which use in Lynx main thread, you can use the following code:
+ *
+ * ```js
+ * // rslib.config.js
+ * import { defineExternalBundleRslibConfig, LAYERS } from '@lynx-js/lynx-bundle-rslib-config'
+ *
+ * export default defineExternalBundleRslibConfig({
+ *   id: 'utils-lib',
+ *   source: {
+ *     entry: {
+ *       utils: {
+ *         import: './src/utils.ts',
+ *         layer: LAYERS.MAIN_THREAD,
+ *       }
+ *     }
+ *   }
+ * })
+ * ```
+ * Then you can use `lynx.loadScript('utils', { bundleName: 'utils-lib-bundle-url' })` in main-thread.
+ *
+ * @example
+ *
+ * If you want to build an external bundle which use both in Lynx main thread and background thread. You don't need to set the layer.
+ *
+ * ```js
+ * // rslib.config.js
+ * import { defineExternalBundleRslibConfig } from '@lynx-js/lynx-bundle-rslib-config'
+ *
+ * export default defineExternalBundleRslibConfig({
+ *   id: 'utils-lib',
+ *   source: {
+ *     entry: {
+ *       utils: './src/utils.ts',
+ *     },
+ *   }
+ * })
+ * ```
+ *
+ * Then you can use `lynx.loadScript('utils', { bundleName: 'utils-lib-bundle-url' })` in background thread and `lynx.loadScript('utils__main-thread', { bundleName: 'utils-lib-bundle-url' })` in main-thread.
+ */
+export declare function defineExternalBundleRslibConfig(userLibConfig: LibConfig, encodeOptions?: EncodeOptions): RslibConfig;

package/lib/externalBundleRslibConfig.js

@@ -0,0 +1,239 @@
+// Copyright 2025 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+import { rsbuild } from '@rslib/core';
+import { RuntimeWrapperWebpackPlugin as BackgroundRuntimeWrapperWebpackPlugin } from '@lynx-js/runtime-wrapper-webpack-plugin';
+import { ExternalBundleWebpackPlugin } from './webpack/ExternalBundleWebpackPlugin.js';
+import { MainThreadRuntimeWrapperWebpackPlugin } from './webpack/MainThreadRuntimeWrapperWebpackPlugin.js';
+/**
+ * The Layer name of background and main-thread.
+ *
+ * @public
+ */
+export const LAYERS = {
+    BACKGROUND: 'background',
+    MAIN_THREAD: 'main-thread',
+};
+/**
+ * The default lib config{@link LibConfig} for external bundle.
+ *
+ * @public
+ */
+export const defaultExternalBundleLibConfig = {
+    format: 'cjs',
+    syntax: 'es2015',
+    autoExtension: false,
+    autoExternal: {
+        dependencies: false,
+        peerDependencies: false,
+    },
+    shims: {
+        cjs: {
+            // Don't inject shim because Lynx don't support.
+            'import.meta.url': false,
+        },
+    },
+    output: {
+        minify: {
+            jsOptions: {
+                minimizerOptions: {
+                    compress: {
+                        /**
+                         * the module wrapper iife need to be kept to provide the return value
+                         * for the module loader in lynx_core.js
+                         */
+                        negate_iife: false,
+                        // Allow return in module wrapper
+                        side_effects: false,
+                    },
+                },
+            },
+        },
+    },
+    source: {
+        include: [/node_modules/],
+    },
+};
+/**
+ * Get the rslib config for building Lynx external bundles.
+ *
+ * @public
+ *
+ * @example
+ *
+ * If you want to build an external bundle which use in Lynx background thread, you can use the following code:
+ *
+ * ```js
+ * // rslib.config.js
+ * import { defineExternalBundleRslibConfig, LAYERS } from '@lynx-js/lynx-bundle-rslib-config'
+ *
+ * export default defineExternalBundleRslibConfig({
+ *   id: 'utils-lib',
+ *   source: {
+ *     entry: {
+ *       utils: {
+ *         import: './src/utils.ts',
+ *         layer: LAYERS.BACKGROUND,
+ *       }
+ *     }
+ *   }
+ * })
+ * ```
+ *
+ * Then you can use `lynx.loadScript('utils', { bundleName: 'utils-lib-bundle-url' })` in background thread.
+ *
+ * @example
+ *
+ * If you want to build an external bundle which use in Lynx main thread, you can use the following code:
+ *
+ * ```js
+ * // rslib.config.js
+ * import { defineExternalBundleRslibConfig, LAYERS } from '@lynx-js/lynx-bundle-rslib-config'
+ *
+ * export default defineExternalBundleRslibConfig({
+ *   id: 'utils-lib',
+ *   source: {
+ *     entry: {
+ *       utils: {
+ *         import: './src/utils.ts',
+ *         layer: LAYERS.MAIN_THREAD,
+ *       }
+ *     }
+ *   }
+ * })
+ * ```
+ * Then you can use `lynx.loadScript('utils', { bundleName: 'utils-lib-bundle-url' })` in main-thread.
+ *
+ * @example
+ *
+ * If you want to build an external bundle which use both in Lynx main thread and background thread. You don't need to set the layer.
+ *
+ * ```js
+ * // rslib.config.js
+ * import { defineExternalBundleRslibConfig } from '@lynx-js/lynx-bundle-rslib-config'
+ *
+ * export default defineExternalBundleRslibConfig({
+ *   id: 'utils-lib',
+ *   source: {
+ *     entry: {
+ *       utils: './src/utils.ts',
+ *     },
+ *   }
+ * })
+ * ```
+ *
+ * Then you can use `lynx.loadScript('utils', { bundleName: 'utils-lib-bundle-url' })` in background thread and `lynx.loadScript('utils__main-thread', { bundleName: 'utils-lib-bundle-url' })` in main-thread.
+ */
+export function defineExternalBundleRslibConfig(userLibConfig, encodeOptions = {}) {
+    return {
+        lib: [
+            // eslint-disable-next-line import/namespace
+            rsbuild.mergeRsbuildConfig(defaultExternalBundleLibConfig, userLibConfig),
+        ],
+        plugins: [
+            externalBundleEntryRsbuildPlugin(),
+            externalBundleRsbuildPlugin(encodeOptions.targetSdkVersion),
+        ],
+    };
+}
+const externalBundleEntryRsbuildPlugin = () => ({
+    name: 'lynx:external-bundle-entry',
+    setup(api) {
+        api.modifyBundlerChain((chain) => {
+            // copy entries
+            const entries = chain.entryPoints.entries() ?? {};
+            chain.entryPoints.clear();
+            const backgroundEntryName = [];
+            const mainThreadEntryName = [];
+            const addLayeredEntry = (entryName, entryValue) => {
+                chain
+                    .entry(entryName)
+                    .add(entryValue)
+                    .end();
+            };
+            Object.entries(entries).forEach(([entryName, entryPoint]) => {
+                const entryPointValue = entryPoint.values();
+                for (const value of entryPointValue) {
+                    if (typeof value === 'string' || Array.isArray(value)) {
+                        const mainThreadEntry = `${entryName}__main-thread`;
+                        const backgroundEntry = entryName;
+                        mainThreadEntryName.push(mainThreadEntry);
+                        backgroundEntryName.push(backgroundEntry);
+                        addLayeredEntry(mainThreadEntry, {
+                            import: value,
+                            layer: LAYERS.MAIN_THREAD,
+                        });
+                        addLayeredEntry(backgroundEntry, {
+                            import: value,
+                            layer: LAYERS.BACKGROUND,
+                        });
+                    }
+                    else {
+                        // object
+                        const { layer } = value;
+                        if (layer === LAYERS.MAIN_THREAD) {
+                            mainThreadEntryName.push(entryName);
+                            addLayeredEntry(entryName, {
+                                ...value,
+                                layer: LAYERS.MAIN_THREAD,
+                            });
+                        }
+                        else if (layer === LAYERS.BACKGROUND) {
+                            backgroundEntryName.push(entryName);
+                            addLayeredEntry(entryName, { ...value, layer: LAYERS.BACKGROUND });
+                        }
+                        else {
+                            // not specify layer
+                            const mainThreadEntry = `${entryName}__main-thread`;
+                            const backgroundEntry = entryName;
+                            mainThreadEntryName.push(mainThreadEntry);
+                            backgroundEntryName.push(backgroundEntry);
+                            addLayeredEntry(mainThreadEntry, {
+                                ...value,
+                                layer: LAYERS.MAIN_THREAD,
+                            });
+                            addLayeredEntry(backgroundEntry, {
+                                ...value,
+                                layer: LAYERS.BACKGROUND,
+                            });
+                        }
+                    }
+                }
+            });
+            // add external bundle wrapper
+            // dprint-ignore
+            chain
+                .plugin(MainThreadRuntimeWrapperWebpackPlugin.name)
+                .use(MainThreadRuntimeWrapperWebpackPlugin, [{
+                    test: mainThreadEntryName.map((name) => new RegExp(`${escapeRegex(name)}\\.js$`)),
+                }])
+                .end()
+                .plugin(BackgroundRuntimeWrapperWebpackPlugin.name)
+                .use(BackgroundRuntimeWrapperWebpackPlugin, [{
+                    test: backgroundEntryName.map((name) => new RegExp(`${escapeRegex(name)}\\.js$`)),
+                }])
+                .end();
+        });
+    },
+});
+const externalBundleRsbuildPlugin = (targetSdkVersion) => ({
+    name: 'lynx:gen-external-bundle',
+    async setup(api) {
+        const { getEncodeMode } = await import('@lynx-js/tasm');
+        api.modifyBundlerChain((chain, { environment: { name: libName } }) => {
+            // dprint-ignore
+            chain
+                .plugin(ExternalBundleWebpackPlugin.name)
+                .use(ExternalBundleWebpackPlugin, [
+                {
+                    bundleFileName: `${libName}.lynx.bundle`,
+                    encode: getEncodeMode(),
+                    targetSdkVersion,
+                },
+            ])
+                .end();
+        });
+    },
+});
+const escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+//# sourceMappingURL=externalBundleRslibConfig.js.map

package/lib/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @packageDocumentation
+ *
+ * `@lynx-js/lynx-bundle-rslib-config` is the package that provides the configurations for bundling Lynx bundle with {@link https://rslib.rs/ | Rslib}.
+ *
+ * 1. Install the package:
+ *
+ * ```bash
+ * pnpm add @lynx-js/lynx-bundle-rslib-config @rslib/core -D
+ * ```
+ *
+ * 2. Add the following code to `rslib.config.ts`:
+ *
+ * ```ts
+ * import { defineExternalBundleRslibConfig } from '@lynx-js/lynx-bundle-rslib-config'
+ *
+ * export default defineExternalBundleRslibConfig({
+ *   id: 'my-utils',
+ *   source: {
+ *     entry: {
+ *       utils: './src/utils.ts'
+ *     }
+ *   }
+ * })
+ * ```
+ *
+ * 3. Run the command `pnpm rslib build` and you will get the `my-utils.lynx.bundle` in the `dist` directory. You can upload the bundle to CDN or server.
+ *
+ * 4. Finally, you can fetch and load the external bundle through:
+ *
+ * ```js
+ * const bundleUrl = 'http://cdn.com/my-utils.lynx.bundle'
+ * lynx.fetchBundle(bundleUrl).wait(3) // timeout is 3s
+ *
+ * if (__BACKGROUND__) {
+ *   const utils = lynx.loadScript('utils', { bundleName: bundleUrl })
+ * } else {
+ *   const utils = lynx.loadScript('utils__main-thread', { bundleName: bundleUrl })
+ * }
+ * ```
+ *
+ * For more detail, please refer to the {@link defineExternalBundleRslibConfig}.
+ */
+export { defineExternalBundleRslibConfig, defaultExternalBundleLibConfig, LAYERS, } from './externalBundleRslibConfig.js';
+export type { EncodeOptions } from './externalBundleRslibConfig.js';
+export { ExternalBundleWebpackPlugin } from './webpack/ExternalBundleWebpackPlugin.js';
+export type { ExternalBundleWebpackPluginOptions } from './webpack/ExternalBundleWebpackPlugin.js';
+export { MainThreadRuntimeWrapperWebpackPlugin } from './webpack/MainThreadRuntimeWrapperWebpackPlugin.js';
+export type { MainThreadRuntimeWrapperWebpackPluginOptions } from './webpack/MainThreadRuntimeWrapperWebpackPlugin.js';

package/lib/index.js

@@ -0,0 +1,50 @@
+// Copyright 2025 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+/**
+ * @packageDocumentation
+ *
+ * `@lynx-js/lynx-bundle-rslib-config` is the package that provides the configurations for bundling Lynx bundle with {@link https://rslib.rs/ | Rslib}.
+ *
+ * 1. Install the package:
+ *
+ * ```bash
+ * pnpm add @lynx-js/lynx-bundle-rslib-config @rslib/core -D
+ * ```
+ *
+ * 2. Add the following code to `rslib.config.ts`:
+ *
+ * ```ts
+ * import { defineExternalBundleRslibConfig } from '@lynx-js/lynx-bundle-rslib-config'
+ *
+ * export default defineExternalBundleRslibConfig({
+ *   id: 'my-utils',
+ *   source: {
+ *     entry: {
+ *       utils: './src/utils.ts'
+ *     }
+ *   }
+ * })
+ * ```
+ *
+ * 3. Run the command `pnpm rslib build` and you will get the `my-utils.lynx.bundle` in the `dist` directory. You can upload the bundle to CDN or server.
+ *
+ * 4. Finally, you can fetch and load the external bundle through:
+ *
+ * ```js
+ * const bundleUrl = 'http://cdn.com/my-utils.lynx.bundle'
+ * lynx.fetchBundle(bundleUrl).wait(3) // timeout is 3s
+ *
+ * if (__BACKGROUND__) {
+ *   const utils = lynx.loadScript('utils', { bundleName: bundleUrl })
+ * } else {
+ *   const utils = lynx.loadScript('utils__main-thread', { bundleName: bundleUrl })
+ * }
+ * ```
+ *
+ * For more detail, please refer to the {@link defineExternalBundleRslibConfig}.
+ */
+export { defineExternalBundleRslibConfig, defaultExternalBundleLibConfig, LAYERS, } from './externalBundleRslibConfig.js';
+export { ExternalBundleWebpackPlugin } from './webpack/ExternalBundleWebpackPlugin.js';
+export { MainThreadRuntimeWrapperWebpackPlugin } from './webpack/MainThreadRuntimeWrapperWebpackPlugin.js';
+//# sourceMappingURL=index.js.map

package/lib/webpack/ExternalBundleWebpackPlugin.d.ts

@@ -0,0 +1,51 @@
+import type { Compiler } from 'webpack';
+/**
+ * The options for {@link ExternalBundleWebpackPlugin}.
+ *
+ * @public
+ */
+export interface ExternalBundleWebpackPluginOptions {
+    /**
+     * The external bundle filename.
+     *
+     * @example
+     * ```js
+     * new ExternalBundleWebpackPlugin({
+     *   bundleFileName: 'lib.lynx.bundle'
+     * })
+     * ```
+     */
+    bundleFileName: string;
+    /**
+     * The encode method which is exported from lynx-tasm package.
+     *
+     * @example
+     * ```js
+     * import { getEncodeMode } from '@lynx-js/tasm';
+     *
+     * new ExternalBundleWebpackPlugin({
+     *   encode: getEncodeMode()
+     * })
+     * ```
+     */
+    encode: (opts: unknown) => Promise<{
+        buffer: Buffer;
+    }>;
+    /**
+     * The target SDK version of the external bundle.
+     *
+     * @defaultValue '3.4'
+     */
+    targetSdkVersion?: string | undefined;
+}
+/**
+ * The webpack plugin to build and emit the external bundle.
+ *
+ * @public
+ */
+export declare class ExternalBundleWebpackPlugin {
+    #private;
+    private options;
+    constructor(options: ExternalBundleWebpackPluginOptions);
+    apply(compiler: Compiler): void;
+}

package/lib/webpack/ExternalBundleWebpackPlugin.js

@@ -0,0 +1,73 @@
+const isDebug = () => {
+    if (!process.env['DEBUG']) {
+        return false;
+    }
+    const values = process.env['DEBUG'].toLocaleLowerCase().split(',');
+    return ['rsbuild', 'rspeedy', '*'].some((key) => values.includes(key));
+};
+/**
+ * The webpack plugin to build and emit the external bundle.
+ *
+ * @public
+ */
+export class ExternalBundleWebpackPlugin {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    apply(compiler) {
+        compiler.hooks.thisCompilation.tap(ExternalBundleWebpackPlugin.name, (compilation) => {
+            compilation.hooks.processAssets.tapPromise({
+                name: ExternalBundleWebpackPlugin.name,
+                stage: 
+                /**
+                 * Generate the html after minification and dev tooling is done
+                 * and source-map is generated
+                 */
+                compiler.webpack.Compilation
+                    .PROCESS_ASSETS_STAGE_OPTIMIZE_HASH,
+            }, () => {
+                return this.#generateExternalBundle(compiler, compilation);
+            });
+        });
+    }
+    async #generateExternalBundle(compiler, compilation) {
+        const assets = compilation.getAssets();
+        const { buffer, encodeOptions } = await this.#encode(assets);
+        const { RawSource } = compiler.webpack.sources;
+        compilation.emitAsset(this.options.bundleFileName, new RawSource(buffer, false));
+        if (isDebug()) {
+            compilation.emitAsset('tasm.json', new RawSource(JSON.stringify(encodeOptions, null, 2)));
+        }
+        else {
+            assets.forEach(({ name }) => {
+                compilation.deleteAsset(name);
+            });
+        }
+    }
+    async #encode(assets) {
+        const customSections = assets
+            .filter(({ name }) => name.endsWith('.js'))
+            .reduce((prev, cur) => ({
+            ...prev,
+            [cur.name.replace(/\.js$/, '')]: {
+                content: cur.source.source().toString(),
+            },
+        }), {});
+        const compilerOptions = {
+            enableFiberArch: true,
+            // lynx.fetchBundle requires targetSdkVersion >= 3.4
+            targetSdkVersion: this.options.targetSdkVersion ?? '3.4',
+        };
+        const encodeOptions = {
+            compilerOptions,
+            sourceContent: {
+                appType: 'DynamicComponent',
+            },
+            customSections,
+        };
+        const { buffer } = await this.options.encode(encodeOptions);
+        return { buffer, encodeOptions };
+    }
+}
+//# sourceMappingURL=ExternalBundleWebpackPlugin.js.map

package/lib/webpack/MainThreadRuntimeWrapperWebpackPlugin.d.ts

@@ -0,0 +1,26 @@
+import type { BannerPlugin, Compiler } from 'webpack';
+/**
+ * The options of {@link MainThreadRuntimeWrapperWebpackPlugin}.
+ *
+ * @public
+ */
+export interface MainThreadRuntimeWrapperWebpackPluginOptions {
+    /**
+     * Include all modules that pass test assertion.
+     *
+     * @defaultValue `/\.js$/`
+     *
+     * @public
+     */
+    test: BannerPlugin['options']['test'];
+}
+/**
+ * The main-thread runtime wrapper for external bundle.
+ *
+ * @public
+ */
+export declare class MainThreadRuntimeWrapperWebpackPlugin {
+    private options;
+    constructor(options?: Partial<MainThreadRuntimeWrapperWebpackPluginOptions>);
+    apply(compiler: Compiler): void;
+}

package/lib/webpack/MainThreadRuntimeWrapperWebpackPlugin.js

@@ -0,0 +1,29 @@
+/**
+ * The main-thread runtime wrapper for external bundle.
+ *
+ * @public
+ */
+export class MainThreadRuntimeWrapperWebpackPlugin {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    apply(compiler) {
+        const { BannerPlugin } = compiler.webpack;
+        new BannerPlugin({
+            test: this.options.test ?? /\.js$/,
+            raw: true,
+            banner: `(function () {   
+  const module = { exports: {} }
+  const exports = module.exports`,
+        }).apply(compiler);
+        new BannerPlugin({
+            test: this.options.test ?? /\.js$/,
+            raw: true,
+            banner: `return module.exports
+})()`,
+            footer: true,
+        }).apply(compiler);
+    }
+}
+//# sourceMappingURL=MainThreadRuntimeWrapperWebpackPlugin.js.map

package/package.json

@@ -1,9 +1,50 @@
 {
   "name": "@lynx-js/lynx-bundle-rslib-config-canary",
-  "type": "module",
-  "version": "0.0.0",
+  "version": "0.0.1-canary-20251201-3692a169",
   "description": "The rsbuild config for building Lynx bundle",
-  "main": "index.js",
-  "keywords": [],
-  "license": "Apache-2.0"
-}
+  "keywords": [
+    "Rsbuild",
+    "Rspeedy",
+    "Lynx",
+    "Rslib"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lynx-family/lynx-stack.git",
+    "directory": "packages/rspeedy/lynx-bundle-rslib-config"
+  },
+  "license": "Apache-2.0",
+  "author": {
+    "name": "Hengchang Lu",
+    "email": "luhengchang228@gmail.com"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    }
+  },
+  "files": [
+    "lib",
+    "!lib/**/*.js.map",
+    "CHANGELOG.md",
+    "README.md"
+  ],
+  "dependencies": {
+    "@lynx-js/runtime-wrapper-webpack-plugin": "npm:@lynx-js/runtime-wrapper-webpack-plugin-canary@0.1.3",
+    "@lynx-js/tasm": "0.0.20"
+  },
+  "devDependencies": {
+    "@rslib/core": "^0.15.0",
+    "vitest": "^3.2.4",
+    "webpack": "^5.102.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "api-extractor": "api-extractor run --verbose",
+    "test": "vitest"
+  }
+}

package/index.js

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