@openclaw/diagnostics-otel 2026.7.2-beta.2 → 2026.7.2-beta.4

package/node_modules/es-module-lexer/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "es-module-lexer",
+  "version": "2.3.1",
+  "description": "Lexes ES modules returning their import/export metadata",
+  "main": "dist/lexer.cjs",
+  "module": "dist/lexer.js",
+  "types": "types/lexer.d.ts",
+  "exports": {
+    ".": {
+      "types": "./types/lexer.d.ts",
+      "module": "./dist/lexer.js",
+      "import": "./dist/lexer.js",
+      "require": "./dist/lexer.cjs"
+    },
+    "./js": {
+      "types": "./types/lexer.d.ts",
+      "default": "./dist/lexer.asm.js"
+    },
+    "./minimal": {
+      "types": "./types/lexer.minimal.d.ts",
+      "module": "./dist/lexer.minimal.js",
+      "import": "./dist/lexer.minimal.js",
+      "require": "./dist/lexer.minimal.cjs"
+    },
+    "./minimal/js": {
+      "types": "./types/lexer.minimal.d.ts",
+      "default": "./dist/lexer.minimal.asm.js"
+    }
+  },
+  "scripts": {
+    "build": "npm install -g chomp ; chomp build",
+    "test": "npm install -g chomp ; chomp test"
+  },
+  "author": "Guy Bedford",
+  "license": "MIT",
+  "devDependencies": {
+    "@babel/cli": "^7.29.7",
+    "@babel/core": "^7.29.7",
+    "@babel/plugin-transform-modules-commonjs": "^7.29.7",
+    "@swc/cli": "^0.8.1",
+    "@swc/core": "^1.15.41",
+    "@types/node": "^25.9.3",
+    "kleur": "^4.1.5",
+    "mocha": "^11.7.6",
+    "terser": "^5.48.0",
+    "typescript": "^6.0.3"
+  },
+  "files": [
+    "dist",
+    "types",
+    "lexer.js"
+  ],
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/guybedford/es-module-lexer.git"
+  },
+  "bugs": {
+    "url": "https://github.com/guybedford/es-module-lexer/issues"
+  },
+  "homepage": "https://github.com/guybedford/es-module-lexer#readme",
+  "directories": {
+    "lib": "lib",
+    "test": "test"
+  },
+  "keywords": []
+}

package/node_modules/es-module-lexer/types/lexer.d.ts

@@ -0,0 +1,227 @@
+export declare enum ImportType {
+    /**
+     * A normal static using any syntax variations
+     *   import .. from 'module'
+     */
+    Static = 1,
+    /**
+     * A dynamic import expression `import(specifier)`
+     * or `import(specifier, opts)`
+     */
+    Dynamic = 2,
+    /**
+     * An import.meta expression
+     */
+    ImportMeta = 3,
+    /**
+     * A source phase import
+     *   import source x from 'module'
+     */
+    StaticSourcePhase = 4,
+    /**
+     * A dynamic source phase import
+     *   import.source('module')
+     */
+    DynamicSourcePhase = 5,
+    /**
+     * A defer phase import
+     *   import defer * as x from 'module'
+     */
+    StaticDeferPhase = 6,
+    /**
+     * A dynamic defer phase import
+     *   import.defer('module')
+     */
+    DynamicDeferPhase = 7
+}
+export interface ImportSpecifier {
+    /**
+     * Module name
+     *
+     * To handle escape sequences in specifier strings, the .n field of imported specifiers will be provided where possible.
+     *
+     * For dynamic import expressions, this field will be empty if not a valid JS string.
+     * For static import expressions, this field will always be populated.
+     *
+     * @example
+     * const [imports1, exports1] = parse(String.raw`import './\u0061\u0062.js'`);
+     * imports1[0].n;
+     * // Returns "./ab.js"
+     *
+     * const [imports2, exports2] = parse(`import("./ab.js")`);
+     * imports2[0].n;
+     * // Returns "./ab.js"
+     *
+     * const [imports3, exports3] = parse(`import("./" + "ab.js")`);
+     * imports3[0].n;
+     * // Returns undefined
+     */
+    readonly n: string | undefined;
+    /**
+     * Type of import statement
+     */
+    readonly t: ImportType;
+    /**
+     * Start of module specifier
+     *
+     * @example
+     * const source = `import { a } from 'asdf'`;
+     * const [imports, exports] = parse(source);
+     * source.substring(imports[0].s, imports[0].e);
+     * // Returns "asdf"
+     */
+    readonly s: number;
+    /**
+     * End of module specifier
+     */
+    readonly e: number;
+    /**
+     * Start of import statement
+     *
+     * @example
+     * const source = `import { a } from 'asdf'`;
+     * const [imports, exports] = parse(source);
+     * source.substring(imports[0].ss, imports[0].se);
+     * // Returns "import { a } from 'asdf';"
+     */
+    readonly ss: number;
+    /**
+     * End of import statement
+     */
+    readonly se: number;
+    /**
+     * If this import keyword is a dynamic import, this is the start value.
+     * If this import keyword is a static import, this is -1.
+     * If this import keyword is an import.meta expresion, this is -2.
+     */
+    readonly d: number;
+    /**
+     * If this import has an import attribute, this is the start value.
+     * Otherwise this is `-1`.
+     */
+    readonly a: number;
+    /**
+     * Parsed import attributes as an array of [key, value] tuples.
+     * If this import has no attributes, this is `null`.
+     *
+     * @example
+     * const source = `import foo from 'bar' with { type: "json" }`;
+     * const [imports] = parse(source);
+     * imports[0].at;
+     * // Returns [['type', 'json']]
+     *
+     * @example
+     * const source = `import foo from 'bar' with { type: "json", integrity: "sha384-..." }`;
+     * const [imports] = parse(source);
+     * imports[0].at;
+     * // Returns [['type', 'json'], ['integrity', 'sha384-...']]
+     */
+    readonly at: ReadonlyArray<readonly [string, string]> | null;
+}
+export interface ExportSpecifier {
+    /**
+     * Exported name
+     *
+     * @example
+     * const source = `export default []`;
+     * const [imports, exports] = parse(source);
+     * exports[0].n;
+     * // Returns "default"
+     *
+     * @example
+     * const source = `export const asdf = 42`;
+     * const [imports, exports] = parse(source);
+     * exports[0].n;
+     * // Returns "asdf"
+     */
+    readonly n: string;
+    /**
+     * Local name, or undefined.
+     *
+     * @example
+     * const source = `export default []`;
+     * const [imports, exports] = parse(source);
+     * exports[0].ln;
+     * // Returns undefined
+     *
+     * @example
+     * const asdf = 42;
+     * const source = `export { asdf as a }`;
+     * const [imports, exports] = parse(source);
+     * exports[0].ln;
+     * // Returns "asdf"
+     */
+    readonly ln: string | undefined;
+    /**
+     * Start of exported name
+     *
+     * @example
+     * const source = `export default []`;
+     * const [imports, exports] = parse(source);
+     * source.substring(exports[0].s, exports[0].e);
+     * // Returns "default"
+     *
+     * @example
+     * const source = `export { 42 as asdf }`;
+     * const [imports, exports] = parse(source);
+     * source.substring(exports[0].s, exports[0].e);
+     * // Returns "asdf"
+     */
+    readonly s: number;
+    /**
+     * End of exported name
+     */
+    readonly e: number;
+    /**
+     * Start of local name, or -1.
+     *
+     * @example
+     * const asdf = 42;
+     * const source = `export { asdf as a }`;
+     * const [imports, exports] = parse(source);
+     * source.substring(exports[0].ls, exports[0].le);
+     * // Returns "asdf"
+     */
+    readonly ls: number;
+    /**
+     * End of local name, or -1.
+     */
+    readonly le: number;
+    /**
+     * Start of the export statement.
+     *
+     * Only the statement start is provided; the statement end is not tracked
+     * (see https://github.com/guybedford/es-module-lexer/issues/112). Every
+     * specifier of a statement reports the same start, so `export { a, b }`
+     * returns the same `ss` for both `a` and `b`.
+     *
+     * @example
+     * const source = `export { a, b } from 'mod'`;
+     * const [imports, exports] = parse(source);
+     * source.slice(exports[0].ss, exports[0].ss + 6);
+     * // Returns "export"
+     */
+    readonly ss: number;
+}
+export interface ParseError extends Error {
+    idx: number;
+}
+/**
+ * Outputs the list of exports and locations of import specifiers,
+ * including dynamic import and import meta handling.
+ *
+ * @param source Source code to parser
+ * @param name Optional sourcename
+ * @returns Tuple contaning imports list and exports list.
+ */
+export declare function parse(source: string, name?: string): readonly [
+    imports: ReadonlyArray<ImportSpecifier>,
+    exports: ReadonlyArray<ExportSpecifier>,
+    facade: boolean,
+    hasModuleSyntax: boolean
+];
+/**
+ * Wait for init to resolve before calling `parse`.
+ */
+export declare const init: Promise<void>;
+export declare const initSync: () => void;

package/node_modules/es-module-lexer/types/lexer.minimal.d.ts

@@ -0,0 +1,46 @@
+// Type definitions for the es-module-lexer minimal build (es-module-lexer/minimal).
+// Auto-generated by build/gen-min-dts.mjs — do not edit.
+import { ImportType, ImportSpecifier, ParseError } from './lexer.js';
+export { ImportType, ImportSpecifier, ParseError };
+
+/**
+ * Export specifier — minimal build.
+ *
+ * Identical to the full ExportSpecifier except that the export statement start
+ * (`ss`) is not tracked in the minimal build.
+ */
+export interface ExportSpecifier {
+  /** Exported name */
+  readonly n: string;
+  /** Local name, or undefined */
+  readonly ln: string | undefined;
+  /** Start of exported name */
+  readonly s: number;
+  /** End of exported name */
+  readonly e: number;
+  /** Start of local name, or -1 */
+  readonly ls: number;
+  /** End of local name, or -1 */
+  readonly le: number;
+}
+
+/**
+ * Outputs the lexical analysis of the source — minimal build.
+ *
+ * Returns a 2-tuple of imports and exports. Unlike the full build, the minimal
+ * build does not emit the facade / hasModuleSyntax flags, and ImportSpecifier
+ * `at` is always null (read assertions via `source.slice(a, se - 1)`).
+ *
+ * @param source Source code to parse
+ * @param name Optional sourcename
+ */
+export declare function parse(source: string, name?: string): readonly [
+  imports: ReadonlyArray<ImportSpecifier>,
+  exports: ReadonlyArray<ExportSpecifier>
+];
+
+/**
+ * Wait for init to resolve before calling `parse`.
+ */
+export declare const init: Promise<void>;
+export declare const initSync: () => void;

package/node_modules/import-in-the-middle/CHANGELOG.md

@@ -1,5 +1,42 @@
 # Changelog
 
+## [3.3.2](https://github.com/nodejs/import-in-the-middle/compare/import-in-the-middle-v3.3.1...import-in-the-middle-v3.3.2) (2026-07-20)
+
+
+### Bug Fixes
+
+* delegate tagged modules to their owning loader ([#276](https://github.com/nodejs/import-in-the-middle/issues/276)) ([e0c57bd](https://github.com/nodejs/import-in-the-middle/commit/e0c57bd810d89d74e6a22a14c243d650cbda8a3c))
+* escape loader URL in generated wrappers ([#275](https://github.com/nodejs/import-in-the-middle/issues/275)) ([86ca0e5](https://github.com/nodejs/import-in-the-middle/commit/86ca0e579cb8b592b0ae49cef9bc834b3971592d))
+* skip code generation on broken maglev ([#271](https://github.com/nodejs/import-in-the-middle/issues/271)) ([ae914ac](https://github.com/nodejs/import-in-the-middle/commit/ae914ac41a4cc9215cbaf4fa5ec48fbe3fa8e7b3))
+
+## [3.3.1](https://github.com/nodejs/import-in-the-middle/compare/import-in-the-middle-v3.3.0...import-in-the-middle-v3.3.1) (2026-07-07)
+
+
+### Performance Improvements
+
+* hoist generated wrapper binding runtime ([#267](https://github.com/nodejs/import-in-the-middle/issues/267)) ([4f41140](https://github.com/nodejs/import-in-the-middle/commit/4f41140d44f91448899580cbb97f558539005657))
+* read each wrapped module from disk once ([#265](https://github.com/nodejs/import-in-the-middle/issues/265)) ([22b40aa](https://github.com/nodejs/import-in-the-middle/commit/22b40aa86003934c944b0f586be3889e8c230616))
+
+## [3.3.0](https://github.com/nodejs/import-in-the-middle/compare/import-in-the-middle-v3.2.0...import-in-the-middle-v3.3.0) (2026-07-02)
+
+
+### Features
+
+* instrument type-stripped TypeScript modules ([#258](https://github.com/nodejs/import-in-the-middle/issues/258)) ([3c6b456](https://github.com/nodejs/import-in-the-middle/commit/3c6b4568a3d23028576ffb728e908a4d06e48523))
+
+
+### Bug Fixes
+
+* guard against circular export-star recursion ([#261](https://github.com/nodejs/import-in-the-middle/issues/261)) ([b957de3](https://github.com/nodejs/import-in-the-middle/commit/b957de3667292ec2ea3b8729704664d1324eaa8f))
+* keep get-esm-exports synchronous so require() works ([#266](https://github.com/nodejs/import-in-the-middle/issues/266)) ([4244b25](https://github.com/nodejs/import-in-the-middle/commit/4244b2512f6256af0ff916f6dc98cc65d988187a))
+* resolve re-exported values from their defining module ([#263](https://github.com/nodejs/import-in-the-middle/issues/263)) ([5ef34cb](https://github.com/nodejs/import-in-the-middle/commit/5ef34cbb59fb65cd0e25b27e06236d6c95c69176))
+
+
+### Performance Improvements
+
+* replace acorn with es-module-lexer for ESM parsing ([#259](https://github.com/nodejs/import-in-the-middle/issues/259)) ([b8cc8af](https://github.com/nodejs/import-in-the-middle/commit/b8cc8af150f46d09b1f447e01a89344d2e647c2c))
+* shrink generated wrapper source ([#264](https://github.com/nodejs/import-in-the-middle/issues/264)) ([491d968](https://github.com/nodejs/import-in-the-middle/commit/491d968d5e80cf0f0add2caeb0f447106caf32c3))
+
 ## [3.2.0](https://github.com/nodejs/import-in-the-middle/compare/import-in-the-middle-v3.1.0...import-in-the-middle-v3.2.0) (2026-06-22)
 
 

package/node_modules/import-in-the-middle/README.md

@@ -117,13 +117,32 @@ node --import=./instrument.mjs ./my-app.mjs
 
 ## Synchronous loader hooks
 
-On Node.js versions that provide
+On Node.js versions that support
 [`module.registerHooks()`](https://nodejs.org/api/module.html#moduleregisterhooksoptions)
-(>= 22.15.0 / >= 24.0.0) the loader can run *synchronously*, on the application
-thread, instead of on the separate thread that `module.register()` uses. Running
-in-thread removes the message channel: `Hook()` registrations are visible to the
-loader directly, so the `createAddHookMessageChannel` /
-`waitForAllMessagesAcknowledged` step shown above is unnecessary.
+the loader can run *synchronously*, on the application thread, instead of on the
+separate thread that `module.register()` uses. Running in-thread removes the
+message channel: `Hook()` registrations are visible to the loader directly, so
+the `createAddHookMessageChannel` / `waitForAllMessagesAcknowledged` step shown
+above is unnecessary.
+
+`module.registerHooks()` was added in 22.15.0 / 24.0.0, but its synchronous load
+hook rejected the nullish CommonJS `source` the loader returns for `require()`s
+pulled into the ESM graph until [nodejs/node#59929][]. The fix shipped in
+**22.22.3, 24.11.1, 25.1.0 and 26.0.0**; earlier versions ship
+`module.registerHooks()` but cannot run the synchronous loader. Use
+`supportsSyncHooks()` to branch on this rather than a hand-written version check:
+
+```js
+import { register, supportsSyncHooks } from 'import-in-the-middle/register-hooks.mjs'
+
+if (supportsSyncHooks()) {
+  register({ include: ['package-i-want-to-include'] })
+} else {
+  // Fall back to the asynchronous loader, e.g. module.register('import-in-the-middle/hook.mjs').
+}
+```
+
+[nodejs/node#59929]: https://github.com/nodejs/node/pull/59929
 
 `instrument.mjs`
 
@@ -143,7 +162,7 @@ node --import=./instrument.mjs ./my-app.mjs
 ```
 
 `register()` accepts the same `include` / `exclude` options as the asynchronous
-loader and throws on a Node.js version without `module.registerHooks()`.
+loader and throws on a Node.js version where `supportsSyncHooks()` is `false`.
 
 ### Custom matching with `shouldInclude`
 
@@ -175,9 +194,46 @@ registration (`register-hooks.mjs`, shown above) and for predicates constructed
 the loader thread; it is not accepted through the `data` option of the asynchronous
 `module.register('import-in-the-middle/hook.mjs', ...)`.
 
+## TypeScript modules
+
+On Node.js versions that strip TypeScript types natively (those exposing
+[`module.stripTypeScriptTypes()`](https://nodejs.org/api/module.html#modulestriptypescripttypescode-options),
+>= 22.13.0 / >= 23.9.0 / >= 24.0.0), `import-in-the-middle` intercepts `.ts`,
+`.mts` and `.cts` modules just like their JavaScript counterparts. The types are
+stripped before the module's exports are read, so type-only exports
+(`export type`, `export interface`) are not present on the intercepted
+namespace; value exports are.
+
+```ts
+// math.mts
+export type Op = '+' | '-'
+export function add (a: number, b: number): number {
+  return a + b
+}
+```
+
+```js
+Hook(['./math.mts'], (exported) => {
+  // `exported.add` is interceptable; the `Op` type is not part of the namespace
+})
+```
+
+On Node.js versions where type stripping is not enabled by default, run with
+`--experimental-strip-types`. Older versions that predate
+`module.stripTypeScriptTypes()` leave TypeScript modules untouched.
+
 ## Limitations
 
 * You cannot add new exports to a module. You can only modify existing ones.
 * While bindings to module exports end up being "re-bound" when modified in a
   hook, dynamically imported modules cannot be altered after they're loaded.
 * Modules loaded via `require` are not affected at all.
+* A module's set of export *names* is assumed to be stable for the lifetime of
+  the process. `import-in-the-middle` reads a module's source once to lex its
+  exports and reuses that export set on later loads of the same URL. An upstream
+  loader that returns a *different set of exports* for the same URL across calls
+  — a stateful codegen loader, or one that varies its output by `context` — is
+  not supported and will be instrumented with the export set from its first
+  load. Idempotent transforms (type stripping, AST instrumentation, minifiers)
+  are unaffected, and the actual module still executes the source its real load
+  returns; only the interceptable export *names* are memoized.