@veryfront/ext-bundler-esbuild 0.1.985

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,2 @@
+Veryfront Code
+Copyright 2026 Veryfront GmbH

package/README.md

@@ -0,0 +1,45 @@
+# @veryfront/ext-bundler-esbuild
+
+> **Category:** Build | **Contracts:** `Bundler`, `ModuleLexer` | **Built-in**
+
+Provides ESM bundling and module analysis for Veryfront's runtime build pipeline and module-graph analysis, backed by esbuild and es-module-lexer.
+
+Registers two contracts:
+
+- **`Bundler`** — esbuild-backed module bundler (`EsbuildBundler`)
+- **`ModuleLexer`** — es-module-lexer-backed ESM scanner (`EsModuleLexer`)
+
+Without this extension, both surfaces throw an install-suggestion error.
+
+## Registration
+
+This extension is auto-enabled by core bootstrap. Add it to `veryfront.config.ts` only when you need to override the built-in registration:
+
+```ts
+import extEsbuild from "@veryfront/ext-bundler-esbuild";
+
+export default defineConfig({
+  extensions: [extEsbuild()],
+});
+```
+
+## Provided contracts
+
+| Contract      | Implementation   | Backed by         |
+| ------------- | ---------------- | ----------------- |
+| `Bundler`     | `EsbuildBundler` | `esbuild`         |
+| `ModuleLexer` | `EsModuleLexer`  | `es-module-lexer` |
+
+Both classes are also exported by name so callers can construct an instance outside the registry:
+
+```ts
+import { EsbuildBundler, EsModuleLexer } from "@veryfront/ext-bundler-esbuild";
+```
+
+## Configuration
+
+No factory options. The extension reads no environment variables and takes no config.
+
+## Lifecycle
+
+The factory's `teardown()` calls `EsbuildBundler.stop()` to release the esbuild service on shutdown.

package/esm/_dnt.polyfills.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Based on [import-meta-ponyfill](https://github.com/gaubee/import-meta-ponyfill),
+ * but instead of using npm to install additional dependencies,
+ * this approach manually consolidates cjs/mjs/d.ts into a single file.
+ *
+ * Note that this code might be imported multiple times
+ * (for example, both dnt.test.polyfills.ts and dnt.polyfills.ts contain this code;
+ *  or Node.js might dynamically clear the cache and then force a require).
+ * Therefore, it's important to avoid redundant writes to global objects.
+ * Additionally, consider that commonjs is used alongside esm,
+ * so the two ponyfill functions are stored independently in two separate global objects.
+ */
+import { createRequire } from "node:module";
+import { type URL } from "node:url";
+declare global {
+    interface ImportMeta {
+        /** A string representation of the fully qualified module URL. When the
+         * module is loaded locally, the value will be a file URL (e.g.
+         * `file:///path/module.ts`).
+         *
+         * You can also parse the string as a URL to determine more information about
+         * how the current module was loaded. For example to determine if a module was
+         * local or not:
+         *
+         * ```ts
+         * const url = new URL(import.meta.url);
+         * if (url.protocol === "file:") {
+         *   console.log("this module was loaded locally");
+         * }
+         * ```
+         */
+        url: string;
+        /**
+         * A function that returns resolved specifier as if it would be imported
+         * using `import(specifier)`.
+         *
+         * ```ts
+         * console.log(import.meta.resolve("./foo.js"));
+         * // file:///dev/foo.js
+         * ```
+         *
+         * @param specifier The module specifier to resolve relative to `parent`.
+         * @param parent The absolute parent module URL to resolve from.
+         * @returns The absolute (`file:`) URL string for the resolved module.
+         */
+        resolve(specifier: string, parent?: string | URL | undefined): string;
+        /** A flag that indicates if the current module is the main module that was
+         * called when starting the program under Deno.
+         *
+         * ```ts
+         * if (import.meta.main) {
+         *   // this was loaded as the main module, maybe do some bootstrapping
+         * }
+         * ```
+         */
+        main: boolean;
+        /** The absolute path of the current module.
+         *
+         * This property is only provided for local modules (ie. using `file://` URLs).
+         *
+         * Example:
+         * ```
+         * // Unix
+         * console.log(import.meta.filename); // /home/alice/my_module.ts
+         *
+         * // Windows
+         * console.log(import.meta.filename); // C:\alice\my_module.ts
+         * ```
+         */
+        filename: string;
+        /** The absolute path of the directory containing the current module.
+         *
+         * This property is only provided for local modules (ie. using `file://` URLs).
+         *
+         * * Example:
+         * ```
+         * // Unix
+         * console.log(import.meta.dirname); // /home/alice
+         *
+         * // Windows
+         * console.log(import.meta.dirname); // C:\alice
+         * ```
+         */
+        dirname: string;
+    }
+}
+type NodeRequest = ReturnType<typeof createRequire>;
+type NodeModule = NonNullable<NodeRequest["main"]>;
+interface ImportMetaPonyfillCommonjs {
+    (require: NodeRequest, module: NodeModule): ImportMeta;
+}
+interface ImportMetaPonyfillEsmodule {
+    (importMeta: ImportMeta): ImportMeta;
+}
+interface ImportMetaPonyfill extends ImportMetaPonyfillCommonjs, ImportMetaPonyfillEsmodule {
+}
+export declare let import_meta_ponyfill_commonjs: ImportMetaPonyfillCommonjs;
+export declare let import_meta_ponyfill_esmodule: ImportMetaPonyfillEsmodule;
+export declare let import_meta_ponyfill: ImportMetaPonyfill;
+export {};
+//# sourceMappingURL=_dnt.polyfills.d.ts.map

package/esm/_dnt.polyfills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.polyfills.d.ts","sourceRoot":"","sources":["../src/_dnt.polyfills.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5C,OAAO,EAAgC,KAAK,GAAG,EAAE,MAAM,UAAU,CAAC;AAGlE,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,UAAU;QAClB;;;;;;;;;;;;;;WAcG;QACH,GAAG,EAAE,MAAM,CAAC;QACZ;;;;;;;;;;;;WAYG;QACH,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,GAAG,GAAG,SAAS,GAAG,MAAM,CAAC;QACtE;;;;;;;;WAQG;QACH,IAAI,EAAE,OAAO,CAAC;QAEd;;;;;;;;;;;;WAYG;QACH,QAAQ,EAAE,MAAM,CAAC;QAEjB;;;;;;;;;;;;WAYG;QACH,OAAO,EAAE,MAAM,CAAC;KACjB;CACF;AAED,KAAK,WAAW,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC;AACpD,KAAK,UAAU,GAAG,WAAW,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC;AACnD,UAAU,0BAA0B;IAClC,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,GAAG,UAAU,CAAC;CACxD;AACD,UAAU,0BAA0B;IAClC,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,CAAC;CACtC;AACD,UAAU,kBACR,SAAQ,0BAA0B,EAAE,0BAA0B;CAC/D;AAiBD,eAAO,IAAI,6BAA6B,EA2BnC,0BAA0B,CAAC;AAMhC,eAAO,IAAI,6BAA6B,EA4DnC,0BAA0B,CAAC;AAMhC,eAAO,IAAI,oBAAoB,EAoB1B,kBAAkB,CAAC"}

package/esm/_dnt.polyfills.js

@@ -0,0 +1,127 @@
+/**
+ * Based on [import-meta-ponyfill](https://github.com/gaubee/import-meta-ponyfill),
+ * but instead of using npm to install additional dependencies,
+ * this approach manually consolidates cjs/mjs/d.ts into a single file.
+ *
+ * Note that this code might be imported multiple times
+ * (for example, both dnt.test.polyfills.ts and dnt.polyfills.ts contain this code;
+ *  or Node.js might dynamically clear the cache and then force a require).
+ * Therefore, it's important to avoid redundant writes to global objects.
+ * Additionally, consider that commonjs is used alongside esm,
+ * so the two ponyfill functions are stored independently in two separate global objects.
+ */
+//@ts-ignore
+import { createRequire } from "node:module";
+//@ts-ignore
+import { fileURLToPath, pathToFileURL } from "node:url";
+//@ts-ignore
+import { dirname } from "node:path";
+const defineGlobalPonyfill = (symbolFor, fn) => {
+    if (!Reflect.has(globalThis, Symbol.for(symbolFor))) {
+        Object.defineProperty(globalThis, Symbol.for(symbolFor), {
+            configurable: true,
+            get() {
+                return fn;
+            },
+        });
+    }
+};
+export let import_meta_ponyfill_commonjs = (Reflect.get(globalThis, Symbol.for("import-meta-ponyfill-commonjs")) ??
+    (() => {
+        const moduleImportMetaWM = new WeakMap();
+        return (require, module) => {
+            let importMetaCache = moduleImportMetaWM.get(module);
+            if (importMetaCache == null) {
+                const importMeta = Object.assign(Object.create(null), {
+                    url: pathToFileURL(module.filename).href,
+                    main: require.main == module,
+                    resolve: (specifier, parentURL = importMeta.url) => {
+                        return pathToFileURL((importMeta.url === parentURL
+                            ? require
+                            : createRequire(parentURL))
+                            .resolve(specifier)).href;
+                    },
+                    filename: module.filename,
+                    dirname: module.path,
+                });
+                moduleImportMetaWM.set(module, importMeta);
+                importMetaCache = importMeta;
+            }
+            return importMetaCache;
+        };
+    })());
+defineGlobalPonyfill("import-meta-ponyfill-commonjs", import_meta_ponyfill_commonjs);
+export let import_meta_ponyfill_esmodule = (Reflect.get(globalThis, Symbol.for("import-meta-ponyfill-esmodule")) ??
+    ((importMeta) => {
+        const resolveFunStr = String(importMeta.resolve);
+        const shimWs = new WeakSet();
+        //@ts-ignore
+        const mainUrl = ("file:///" + process.argv[1].replace(/\\/g, "/"))
+            .replace(/\/{3,}/, "///");
+        const commonShim = (importMeta) => {
+            if (typeof importMeta.main !== "boolean") {
+                importMeta.main = importMeta.url === mainUrl;
+            }
+            if (typeof importMeta.filename !== "string") {
+                importMeta.filename = fileURLToPath(importMeta.url);
+                importMeta.dirname = dirname(importMeta.filename);
+            }
+        };
+        if (
+        // v16.2.0+, v14.18.0+: Add support for WHATWG URL object to parentURL parameter.
+        resolveFunStr === "undefined" ||
+            // v20.0.0+, v18.19.0+"" This API now returns a string synchronously instead of a Promise.
+            resolveFunStr.startsWith("async")
+        // enable by --experimental-import-meta-resolve flag
+        ) {
+            import_meta_ponyfill_esmodule = (importMeta) => {
+                if (!shimWs.has(importMeta)) {
+                    shimWs.add(importMeta);
+                    const importMetaUrlRequire = {
+                        url: importMeta.url,
+                        require: createRequire(importMeta.url),
+                    };
+                    importMeta.resolve = function resolve(specifier, parentURL = importMeta.url) {
+                        return pathToFileURL((importMetaUrlRequire.url === parentURL
+                            ? importMetaUrlRequire.require
+                            : createRequire(parentURL)).resolve(specifier)).href;
+                    };
+                    commonShim(importMeta);
+                }
+                return importMeta;
+            };
+        }
+        else {
+            /// native support
+            import_meta_ponyfill_esmodule = (importMeta) => {
+                if (!shimWs.has(importMeta)) {
+                    shimWs.add(importMeta);
+                    commonShim(importMeta);
+                }
+                return importMeta;
+            };
+        }
+        return import_meta_ponyfill_esmodule(importMeta);
+    }));
+defineGlobalPonyfill("import-meta-ponyfill-esmodule", import_meta_ponyfill_esmodule);
+export let import_meta_ponyfill = ((...args) => {
+    const _MODULE = (() => {
+        if (typeof require === "function" && typeof module === "object") {
+            return "commonjs";
+        }
+        else {
+            // eval("typeof import.meta");
+            return "esmodule";
+        }
+    })();
+    if (_MODULE === "commonjs") {
+        //@ts-ignore
+        import_meta_ponyfill = (r, m) => import_meta_ponyfill_commonjs(r, m);
+    }
+    else {
+        //@ts-ignore
+        import_meta_ponyfill = (im) => import_meta_ponyfill_esmodule(im);
+    }
+    //@ts-ignore
+    return import_meta_ponyfill(...args);
+});

package/esm/_dnt.shims.d.ts

@@ -0,0 +1,12 @@
+import { Deno } from "@deno/shim-deno";
+export { Deno } from "@deno/shim-deno";
+export { crypto, type Crypto, type SubtleCrypto, type AlgorithmIdentifier, type Algorithm, type RsaOaepParams, type BufferSource, type AesCtrParams, type AesCbcParams, type AesGcmParams, type CryptoKey, type KeyAlgorithm, type KeyType, type KeyUsage, type EcdhKeyDeriveParams, type HkdfParams, type HashAlgorithmIdentifier, type Pbkdf2Params, type AesDerivedKeyParams, type HmacImportParams, type JsonWebKey, type RsaOtherPrimesInfo, type KeyFormat, type RsaHashedKeyGenParams, type RsaKeyGenParams, type BigInteger, type EcKeyGenParams, type NamedCurve, type CryptoKeyPair, type AesKeyGenParams, type HmacKeyGenParams, type RsaHashedImportParams, type EcKeyImportParams, type AesKeyAlgorithm, type RsaPssParams, type EcdsaParams } from "@deno/shim-crypto";
+import { setInterval, setTimeout } from "@deno/shim-timers";
+export { setInterval, setTimeout } from "@deno/shim-timers";
+export declare const dntGlobalThis: Omit<typeof globalThis, "setInterval" | "setTimeout" | "crypto" | "Deno"> & {
+    Deno: typeof Deno;
+    crypto: import("@deno/shim-crypto").Crypto;
+    setInterval: typeof setInterval;
+    setTimeout: typeof setTimeout;
+};
+//# sourceMappingURL=_dnt.shims.d.ts.map

package/esm/_dnt.shims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.shims.d.ts","sourceRoot":"","sources":["../src/_dnt.shims.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAEvC,OAAO,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,KAAK,YAAY,EAAE,KAAK,mBAAmB,EAAE,KAAK,SAAS,EAAE,KAAK,aAAa,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,KAAK,SAAS,EAAE,KAAK,YAAY,EAAE,KAAK,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,mBAAmB,EAAE,KAAK,UAAU,EAAE,KAAK,uBAAuB,EAAE,KAAK,YAAY,EAAE,KAAK,mBAAmB,EAAE,KAAK,gBAAgB,EAAE,KAAK,UAAU,EAAE,KAAK,kBAAkB,EAAE,KAAK,SAAS,EAAE,KAAK,qBAAqB,EAAE,KAAK,eAAe,EAAE,KAAK,UAAU,EAAE,KAAK,cAAc,EAAE,KAAK,UAAU,EAAE,KAAK,aAAa,EAAE,KAAK,eAAe,EAAE,KAAK,gBAAgB,EAAE,KAAK,qBAAqB,EAAE,KAAK,iBAAiB,EAAE,KAAK,eAAe,EAAE,KAAK,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrvB,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAQ5D,eAAO,MAAM,aAAa;;;;;CAA2C,CAAC"}

package/esm/_dnt.shims.js

@@ -0,0 +1,68 @@
+import { Deno } from "@deno/shim-deno";
+export { Deno } from "@deno/shim-deno";
+import { crypto } from "@deno/shim-crypto";
+export { crypto } from "@deno/shim-crypto";
+import { setInterval, setTimeout } from "@deno/shim-timers";
+export { setInterval, setTimeout } from "@deno/shim-timers";
+const dntGlobals = {
+    Deno,
+    crypto,
+    setInterval,
+    setTimeout,
+};
+export const dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+function createMergeProxy(baseObj, extObj) {
+    return new Proxy(baseObj, {
+        get(_target, prop, _receiver) {
+            if (prop in extObj) {
+                return extObj[prop];
+            }
+            else {
+                return baseObj[prop];
+            }
+        },
+        set(_target, prop, value) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            baseObj[prop] = value;
+            return true;
+        },
+        deleteProperty(_target, prop) {
+            let success = false;
+            if (prop in extObj) {
+                delete extObj[prop];
+                success = true;
+            }
+            if (prop in baseObj) {
+                delete baseObj[prop];
+                success = true;
+            }
+            return success;
+        },
+        ownKeys(_target) {
+            const baseKeys = Reflect.ownKeys(baseObj);
+            const extKeys = Reflect.ownKeys(extObj);
+            const extKeysSet = new Set(extKeys);
+            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+        },
+        defineProperty(_target, prop, desc) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            Reflect.defineProperty(baseObj, prop, desc);
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (prop in extObj) {
+                return Reflect.getOwnPropertyDescriptor(extObj, prop);
+            }
+            else {
+                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+            }
+        },
+        has(_target, prop) {
+            return prop in extObj || prop in baseObj;
+        },
+    });
+}

package/esm/binary.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Idempotent one-shot setup — copies the esbuild binary out of the VFS (if
+ * running in `deno compile`) and sets ESBUILD_BINARY_PATH. No-op on normal
+ * Deno or when the env var is already set.
+ */
+export declare function ensureEsbuildBinary(): Promise<void>;
+//# sourceMappingURL=binary.d.ts.map

package/esm/binary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary.d.ts","sourceRoot":"","sources":["../src/binary.ts"],"names":[],"mappings":"AAmHA;;;;GAIG;AACH,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC,CAiCzD"}

package/esm/binary.js

@@ -0,0 +1,143 @@
+/**
+ * Binary extraction for `deno compile` VFS.
+ *
+ * Ported from src/platform/compat/esbuild.ts + esbuild-shared.ts. When the
+ * framework runs as a compiled Deno binary, the esbuild native binary lives
+ * inside the VFS and must be copied to a writable path before esbuild's
+ * child-process spawn can find it.
+ *
+ * On normal Deno (not `deno compile`) or when ESBUILD_BINARY_PATH is already
+ * set, `ensureEsbuildBinary()` is a no-op.
+ *
+ * @module extensions/ext-bundler-esbuild/binary
+ */
+import * as dntShim from "./_dnt.shims.js";
+import { isDenoCompiled } from "./runtime.js";
+const ESBUILD_VERSION = "0.28.1";
+function getTempDir() {
+    try {
+        return (dntShim.Deno.env.get("TMPDIR") ?? dntShim.Deno.env.get("TEMP") ?? dntShim.Deno.env.get("TMP") ?? "/tmp");
+    }
+    catch {
+        return "/tmp";
+    }
+}
+function getEsbuildBinaryName() {
+    const archMap = { x86_64: "x64", aarch64: "arm64" };
+    const arch = archMap[dntShim.Deno.build.arch] ?? dntShim.Deno.build.arch;
+    return `@esbuild/${dntShim.Deno.build.os}-${arch}`;
+}
+function getVFSBasePath(filePath, tempDir) {
+    const denoCompileMatch = filePath.match(/^(.*\/deno-compile-[^/]+)\//);
+    if (denoCompileMatch?.[1])
+        return denoCompileMatch[1];
+    const parts = filePath.split("/");
+    const srcIndex = parts.lastIndexOf("src");
+    if (srcIndex > 0)
+        return parts.slice(0, srcIndex).join("/");
+    return `${tempDir}/deno-compile-veryfront`;
+}
+async function isFile(path) {
+    try {
+        const stat = await dntShim.Deno.stat(path);
+        return stat.isFile;
+    }
+    catch {
+        return false;
+    }
+}
+async function findEsbuildInVFS() {
+    const binaryName = getEsbuildBinaryName();
+    const vfsBase = getVFSBasePath(new URL(globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta).url).pathname, getTempDir());
+    const possiblePaths = [
+        `${vfsBase}/node_modules/${binaryName}/bin/esbuild`,
+        `${vfsBase}/node_modules/.deno/${binaryName}@${ESBUILD_VERSION}/node_modules/${binaryName}/bin/esbuild`,
+        `${vfsBase}/node_modules/.deno/esbuild@${ESBUILD_VERSION}/node_modules/${binaryName}/bin/esbuild`,
+        `${vfsBase}/node_modules/esbuild/bin/esbuild`,
+        `${vfsBase}/node_modules/.package/esbuild@${ESBUILD_VERSION}/bin/esbuild`,
+        `${vfsBase}/node_modules/.package/${binaryName}@${ESBUILD_VERSION}/bin/esbuild`,
+    ];
+    for (const p of possiblePaths) {
+        if (await isFile(p))
+            return p;
+    }
+    try {
+        const nodeModulesPath = `${vfsBase}/node_modules`;
+        for await (const entry of dntShim.Deno.readDir(nodeModulesPath)) {
+            if (entry.name !== binaryName && !entry.name.startsWith("@esbuild"))
+                continue;
+            const binPath = `${nodeModulesPath}/${entry.name}/bin/esbuild`;
+            if (await isFile(binPath))
+                return binPath;
+        }
+    }
+    catch {
+        /* node_modules not readable in VFS */
+    }
+    return null;
+}
+async function extractEsbuildBinary() {
+    const cacheDir = `${getTempDir()}/veryfront-esbuild`;
+    const targetPath = `${cacheDir}/esbuild-${ESBUILD_VERSION}`;
+    try {
+        const stat = await dntShim.Deno.stat(targetPath);
+        if (stat.isFile && stat.mode && (stat.mode & 0o111))
+            return targetPath;
+    }
+    catch {
+        /* cache miss */
+    }
+    const vfsPath = await findEsbuildInVFS();
+    if (!vfsPath) {
+        throw new Error(`[ext-bundler-esbuild] Could not find esbuild binary in deno compile VFS. ` +
+            `Platform: ${getEsbuildBinaryName()}. ` +
+            `Ensure esbuild is in dependencies and deno compile includes node_modules.`);
+    }
+    await dntShim.Deno.mkdir(cacheDir, { recursive: true });
+    const binary = await dntShim.Deno.readFile(vfsPath);
+    await dntShim.Deno.writeFile(targetPath, binary, { mode: 0o755 });
+    return targetPath;
+}
+let setupComplete = false;
+let setupPromise = null;
+/**
+ * Idempotent one-shot setup — copies the esbuild binary out of the VFS (if
+ * running in `deno compile`) and sets ESBUILD_BINARY_PATH. No-op on normal
+ * Deno or when the env var is already set.
+ */
+export async function ensureEsbuildBinary() {
+    if (setupComplete)
+        return;
+    if (setupPromise) {
+        await setupPromise;
+        return;
+    }
+    setupPromise = (async () => {
+        try {
+            if (dntShim.Deno.env.get("ESBUILD_BINARY_PATH") || !isDenoCompiled) {
+                setupComplete = true;
+                return;
+            }
+            try {
+                const binaryPath = await extractEsbuildBinary();
+                dntShim.Deno.env.set("ESBUILD_BINARY_PATH", binaryPath);
+                // esbuild reads process.env (not Deno.env) on some code paths.
+                const proc = dntShim.dntGlobalThis.process;
+                if (proc?.env)
+                    proc.env.ESBUILD_BINARY_PATH = binaryPath;
+            }
+            catch (err) {
+                console.error("[ext-bundler-esbuild] Binary extraction failed:", err);
+            }
+        }
+        finally {
+            setupComplete = true;
+        }
+    })();
+    try {
+        await setupPromise;
+    }
+    finally {
+        setupPromise = null;
+    }
+}

package/esm/es-module-lexer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * es-module-lexer-backed implementation of the {@link ModuleLexer} contract.
+ *
+ * es-module-lexer@2 exports `init` as a Promise in its ESM build but older
+ * typings expect a function. We tolerate both shapes (as the in-tree
+ * src/transforms/esm/lexer.ts did).
+ *
+ * @module extensions/ext-bundler-esbuild/es-module-lexer
+ */
+import type { ImportSpecifier, ModuleLexer } from "veryfront/extensions/bundler";
+/** es-module-lexer-backed {@link ModuleLexer} implementation. */
+export declare class EsModuleLexer implements ModuleLexer {
+    private initPromise;
+    init(): Promise<void>;
+    parse(code: string): readonly ImportSpecifier[];
+}
+//# sourceMappingURL=es-module-lexer.d.ts.map

package/esm/es-module-lexer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"es-module-lexer.d.ts","sourceRoot":"","sources":["../src/es-module-lexer.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAGjF,iEAAiE;AACjE,qBAAa,aAAc,YAAW,WAAW;IAC/C,OAAO,CAAC,WAAW,CAA8B;IAE3C,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAY3B,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,eAAe,EAAE;CAIhD"}

package/esm/es-module-lexer.js

@@ -0,0 +1,29 @@
+/**
+ * es-module-lexer-backed implementation of the {@link ModuleLexer} contract.
+ *
+ * es-module-lexer@2 exports `init` as a Promise in its ESM build but older
+ * typings expect a function. We tolerate both shapes (as the in-tree
+ * src/transforms/esm/lexer.ts did).
+ *
+ * @module extensions/ext-bundler-esbuild/es-module-lexer
+ */
+import { init, parse } from "es-module-lexer";
+/** es-module-lexer-backed {@link ModuleLexer} implementation. */
+export class EsModuleLexer {
+    initPromise = null;
+    async init() {
+        if (this.initPromise) {
+            await this.initPromise;
+            return;
+        }
+        const anyInit = init;
+        this.initPromise = typeof anyInit === "function"
+            ? anyInit()
+            : anyInit;
+        await this.initPromise;
+    }
+    parse(code) {
+        const [imports] = parse(code);
+        return imports;
+    }
+}

package/esm/esbuild-bundler.d.ts

@@ -0,0 +1,20 @@
+/**
+ * esbuild-backed implementation of the {@link Bundler} contract.
+ *
+ * Lazy-initializes the esbuild binary (including `deno compile` VFS
+ * extraction) on first use. All options pass through to esbuild unchanged
+ * because the {@link BundleOptions} shape was designed to be esbuild-compatible;
+ * the only translation is converting {@link BundlerPlugin}s into esbuild
+ * plugins via {@link toEsbuildPlugin}.
+ *
+ * @module extensions/ext-bundler-esbuild/esbuild-bundler
+ */
+import type { BuildContext, BundleOptions, Bundler, BundleResult, TransformOptions, TransformResult } from "veryfront/extensions/bundler";
+/** esbuild-backed {@link Bundler} implementation. */
+export declare class EsbuildBundler implements Bundler {
+    bundle(options: BundleOptions): Promise<BundleResult>;
+    transform(options: TransformOptions): Promise<TransformResult>;
+    context(options: BundleOptions): Promise<BuildContext>;
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=esbuild-bundler.d.ts.map

package/esm/esbuild-bundler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"esbuild-bundler.d.ts","sourceRoot":"","sources":["../src/esbuild-bundler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EAEb,OAAO,EACP,YAAY,EAGZ,gBAAgB,EAChB,eAAe,EAChB,MAAM,8BAA8B,CAAC;AAoDtC,qDAAqD;AACrD,qBAAa,cAAe,YAAW,OAAO;IACtC,MAAM,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAWrD,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC;IAW9D,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAiBtD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAM5B"}

package/esm/esbuild-bundler.js

@@ -0,0 +1,98 @@
+/**
+ * esbuild-backed implementation of the {@link Bundler} contract.
+ *
+ * Lazy-initializes the esbuild binary (including `deno compile` VFS
+ * extraction) on first use. All options pass through to esbuild unchanged
+ * because the {@link BundleOptions} shape was designed to be esbuild-compatible;
+ * the only translation is converting {@link BundlerPlugin}s into esbuild
+ * plugins via {@link toEsbuildPlugin}.
+ *
+ * @module extensions/ext-bundler-esbuild/esbuild-bundler
+ */
+import { ensureEsbuildBinary } from "./binary.js";
+import { toEsbuildPlugin } from "./plugin-adapter.js";
+let esbuildModule = null;
+async function getEsbuild() {
+    await ensureEsbuildBinary();
+    if (esbuildModule)
+        return esbuildModule;
+    esbuildModule = await import("esbuild");
+    return esbuildModule;
+}
+// deno-lint-ignore no-explicit-any
+function toMessage(m) {
+    return {
+        text: m.text,
+        location: m.location ?? null,
+        notes: m.notes,
+        pluginName: m.pluginName,
+        detail: m.detail,
+    };
+}
+// deno-lint-ignore no-explicit-any
+function toMessages(ms) {
+    return (ms ?? []).map(toMessage);
+}
+// deno-lint-ignore no-explicit-any
+function toOutput(f) {
+    return {
+        path: f.path,
+        contents: f.contents,
+        text: f.text,
+        hash: f.hash,
+    };
+}
+function mapOptions(options) {
+    const { plugins, ...rest } = options;
+    const mapped = { ...rest };
+    if (plugins && plugins.length > 0) {
+        mapped.plugins = plugins.map(toEsbuildPlugin);
+    }
+    return mapped;
+}
+/** esbuild-backed {@link Bundler} implementation. */
+export class EsbuildBundler {
+    async bundle(options) {
+        const esbuild = await getEsbuild();
+        const result = await esbuild.build(mapOptions(options));
+        return {
+            outputFiles: (result.outputFiles ?? []).map(toOutput),
+            warnings: toMessages(result.warnings),
+            errors: toMessages(result.errors),
+            metafile: result.metafile,
+        };
+    }
+    async transform(options) {
+        const esbuild = await getEsbuild();
+        const { code, ...rest } = options;
+        const result = await esbuild.transform(code, rest);
+        return {
+            code: result.code,
+            map: result.map,
+            warnings: toMessages(result.warnings).map((m) => m.text),
+        };
+    }
+    async context(options) {
+        const esbuild = await getEsbuild();
+        const ctx = await esbuild.context(mapOptions(options));
+        return {
+            rebuild: async () => {
+                const result = await ctx.rebuild();
+                return {
+                    outputFiles: (result.outputFiles ?? []).map(toOutput),
+                    warnings: toMessages(result.warnings),
+                    errors: toMessages(result.errors),
+                    metafile: result.metafile,
+                };
+            },
+            dispose: () => ctx.dispose(),
+        };
+    }
+    async stop() {
+        const m = esbuildModule;
+        if (!m)
+            return;
+        esbuildModule = null;
+        await m.stop();
+    }
+}

package/esm/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ext-bundler-esbuild — Bundler + ModuleLexer contract implementations backed by
+ * esbuild and es-module-lexer.
+ *
+ * @module extensions/ext-bundler-esbuild
+ */
+import "./_dnt.polyfills.js";
+import type { ExtensionFactory } from "veryfront/extensions";
+import { EsbuildBundler } from "./esbuild-bundler.js";
+import { EsModuleLexer } from "./es-module-lexer.js";
+/**
+ * Default export — the ext-bundler-esbuild extension factory.
+ *
+ * Registers both the `Bundler` (esbuild-backed) and `ModuleLexer`
+ * (es-module-lexer-backed) contracts.
+ */
+declare const extEsbuild: ExtensionFactory;
+export default extEsbuild;
+export { EsbuildBundler, EsModuleLexer };
+//# sourceMappingURL=index.d.ts.map

package/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,qBAAqB,CAAC;AAG7B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAE7D,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAErD;;;;;GAKG;AACH,QAAA,MAAM,UAAU,EAAE,gBAwBjB,CAAC;AAEF,eAAe,UAAU,CAAC;AAC1B,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,CAAC"}

package/esm/index.js

@@ -0,0 +1,41 @@
+/**
+ * ext-bundler-esbuild — Bundler + ModuleLexer contract implementations backed by
+ * esbuild and es-module-lexer.
+ *
+ * @module extensions/ext-bundler-esbuild
+ */
+import "./_dnt.polyfills.js";
+import { EsbuildBundler } from "./esbuild-bundler.js";
+import { EsModuleLexer } from "./es-module-lexer.js";
+/**
+ * Default export — the ext-bundler-esbuild extension factory.
+ *
+ * Registers both the `Bundler` (esbuild-backed) and `ModuleLexer`
+ * (es-module-lexer-backed) contracts.
+ */
+const extEsbuild = () => {
+    const bundler = new EsbuildBundler();
+    const lexer = new EsModuleLexer();
+    return {
+        name: "ext-bundler-esbuild",
+        version: "0.1.0",
+        contracts: {
+            provides: ["Bundler", "ModuleLexer"],
+        },
+        capabilities: [],
+        setup(ctx) {
+            if (!ctx.get("Bundler")) {
+                ctx.provide("Bundler", bundler);
+            }
+            if (!ctx.get("ModuleLexer")) {
+                ctx.provide("ModuleLexer", lexer);
+            }
+            ctx.logger.info("[ext-bundler-esbuild] Bundler + ModuleLexer registered");
+        },
+        async teardown() {
+            await bundler.stop?.();
+        },
+    };
+};
+export default extEsbuild;
+export { EsbuildBundler, EsModuleLexer };

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/plugin-adapter.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Plugin adapter — converts {@link BundlerPlugin} (the bundler-agnostic
+ * contract shape) into an esbuild `Plugin`. The contract's onResolve /
+ * onLoad shapes were deliberately designed to match esbuild's, so the
+ * translation is near-1:1; this module exists to isolate the esbuild
+ * import from the rest of the extension.
+ *
+ * @module extensions/ext-bundler-esbuild/plugin-adapter
+ */
+import type { BundlerPlugin } from "veryfront/extensions/bundler";
+type EsbuildPlugin = any;
+export declare function toEsbuildPlugin(plugin: BundlerPlugin): EsbuildPlugin;
+export {};
+//# sourceMappingURL=plugin-adapter.d.ts.map

package/esm/plugin-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-adapter.d.ts","sourceRoot":"","sources":["../src/plugin-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACV,aAAa,EAMd,MAAM,8BAA8B,CAAC;AAEtC,KAAK,aAAa,GAAG,GAAG,CAAC;AAEzB,wBAAgB,eAAe,CAAC,MAAM,EAAE,aAAa,GAAG,aAAa,CA4CpE"}

package/esm/plugin-adapter.js

@@ -0,0 +1,55 @@
+/**
+ * Plugin adapter — converts {@link BundlerPlugin} (the bundler-agnostic
+ * contract shape) into an esbuild `Plugin`. The contract's onResolve /
+ * onLoad shapes were deliberately designed to match esbuild's, so the
+ * translation is near-1:1; this module exists to isolate the esbuild
+ * import from the rest of the extension.
+ *
+ * @module extensions/ext-bundler-esbuild/plugin-adapter
+ */
+export function toEsbuildPlugin(plugin) {
+    return {
+        name: plugin.name,
+        // deno-lint-ignore no-explicit-any
+        setup(build) {
+            const bridged = {
+                onResolve(options, callback) {
+                    // deno-lint-ignore no-explicit-any
+                    build.onResolve(options, async (args) => {
+                        const resolveArgs = {
+                            path: args.path,
+                            importer: args.importer,
+                            namespace: args.namespace,
+                            resolveDir: args.resolveDir,
+                            kind: args.kind,
+                            pluginData: args.pluginData,
+                        };
+                        const result = await callback(resolveArgs);
+                        if (result == null)
+                            return result ?? null;
+                        return result;
+                    });
+                },
+                onLoad(options, callback) {
+                    // deno-lint-ignore no-explicit-any
+                    build.onLoad(options, async (args) => {
+                        const loadArgs = {
+                            path: args.path,
+                            namespace: args.namespace,
+                            suffix: args.suffix,
+                            pluginData: args.pluginData,
+                        };
+                        const result = await callback(loadArgs);
+                        if (result == null)
+                            return result ?? null;
+                        return result;
+                    });
+                },
+                onDispose(callback) {
+                    build.onDispose(callback);
+                },
+            };
+            plugin.setup(bridged);
+        },
+    };
+}

package/esm/runtime.d.ts

@@ -0,0 +1,4 @@
+export declare const isDeno: boolean;
+/** True if running inside a `deno compile`'d binary (needs VFS extraction). */
+export declare const isDenoCompiled: boolean;
+//# sourceMappingURL=runtime.d.ts.map

package/esm/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAkCA,eAAO,MAAM,MAAM,EAAE,OAA+D,CAAC;AAkBrF,+EAA+E;AAC/E,eAAO,MAAM,cAAc,EAAE,OAA0C,CAAC"}

package/esm/runtime.js

@@ -0,0 +1,43 @@
+/**
+ * Runtime detection — inlined from src/platform/compat/runtime.ts so the
+ * extension stays dependency-free on core.
+ *
+ * Only the bits needed by the esbuild binary extractor are included here.
+ *
+ * @module extensions/ext-bundler-esbuild/runtime
+ */
+import * as dntShim from "./_dnt.shims.js";
+function hasRealDeno() {
+    return (typeof dntShim.Deno !== "undefined" &&
+        typeof dntShim.Deno.version === "object" &&
+        typeof dntShim.Deno.build === "object" &&
+        typeof dntShim.Deno.build.os === "string");
+}
+function hasBunGlobal() {
+    return dntShim.dntGlobalThis.Bun != null;
+}
+function hasNodeProcess() {
+    const g = dntShim.dntGlobalThis;
+    return g.process?.versions?.node != null && !g.process?.versions?.deno;
+}
+export const isDeno = !hasNodeProcess() && !hasBunGlobal() && hasRealDeno();
+function testDenoCompiledDetection(execPath) {
+    if (!execPath)
+        return false;
+    const binary = execPath.split(/[/\\]/).pop()?.toLowerCase();
+    if (!binary)
+        return false;
+    return binary !== "deno" && binary !== "deno.exe";
+}
+function isDenoCompiledBinary() {
+    if (!hasRealDeno())
+        return false;
+    try {
+        return testDenoCompiledDetection(dntShim.Deno.execPath());
+    }
+    catch {
+        return false;
+    }
+}
+/** True if running inside a `deno compile`'d binary (needs VFS extraction). */
+export const isDenoCompiled = isDeno && isDenoCompiledBinary();

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@veryfront/ext-bundler-esbuild",
+  "version": "0.1.985",
+  "description": "Veryfront first-party extension package for ext-bundler-esbuild",
+  "keywords": [
+    "veryfront",
+    "extension",
+    "ext-bundler-esbuild"
+  ],
+  "author": "Veryfront",
+  "homepage": "https://github.com/veryfront/veryfront-code/tree/main/extensions/ext-bundler-esbuild",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/veryfront/veryfront-code.git",
+    "directory": "extensions/ext-bundler-esbuild"
+  },
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/veryfront/veryfront-code/issues"
+  },
+  "module": "./esm/index.js",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "types": "./esm/index.d.ts"
+    }
+  },
+  "scripts": {},
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "veryfront": {
+    "extension": true,
+    "contracts": {
+      "provides": [
+        "Bundler",
+        "ModuleLexer"
+      ]
+    },
+    "capabilities": []
+  },
+  "dependencies": {
+    "@deno/shim-deno": "~0.18.0",
+    "@deno/shim-crypto": "~0.3.1",
+    "@deno/shim-timers": "~0.1.0",
+    "es-module-lexer": "2.0.0",
+    "esbuild": "0.28.1"
+  },
+  "peerDependencies": {
+    "veryfront": "^0.1.985"
+  },
+  "type": "module",
+  "types": "./esm/index.d.ts",
+  "files": [
+    "esm",
+    "LICENSE",
+    "NOTICE",
+    "README.md"
+  ]
+}