@bildit-platform/engine 0.1.4 → 0.1.6

package/dist/esm/node_modules/.pnpm/next@15.3.1_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/next/dist/server/lib/clone-response.js

@@ -0,0 +1,86 @@
+/*
+   * Copyright (c) 2022 BILDIT, INC.
+   *
+   * This file, and the software contained herein, are the exclusive property of BILDIT, INC.
+   * Unauthorized copying, distribution, or modification of this software is strictly prohibited.
+   * All rights reserved.
+   *
+   * This file is licensed under the ENT License ("License"). Use of this file is subject to the
+   * terms and conditions specified in the License. You may obtain a copy of the License at:
+   *
+   *     https://bildit.co/ENTLicense
+   *
+   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+   * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+   * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+   * DAMAGES, OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM,
+   * OUT OF, OR IN CONNECTION WITH, THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+   */
+import { __exports as cloneResponse } from '../../../../../../../../_virtual/clone-response.js';
+
+/**
+ * Clones a response by teeing the body so we can return two independent
+ * ReadableStreams from it. This avoids the bug in the undici library around
+ * response cloning.
+ *
+ * After cloning, the original response's body will be consumed and closed.
+ *
+ * @see https://github.com/vercel/next.js/pull/73274
+ *
+ * @param original - The original response to clone.
+ * @returns A tuple containing two independent clones of the original response.
+ */
+
+var hasRequiredCloneResponse;
+
+function requireCloneResponse () {
+	if (hasRequiredCloneResponse) return cloneResponse;
+	hasRequiredCloneResponse = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "cloneResponse", {
+		    enumerable: true,
+		    get: function() {
+		        return cloneResponse;
+		    }
+		});
+		function cloneResponse(original) {
+		    // If the response has no body, then we can just return the original response
+		    // twice because it's immutable.
+		    if (!original.body) {
+		        return [
+		            original,
+		            original
+		        ];
+		    }
+		    const [body1, body2] = original.body.tee();
+		    const cloned1 = new Response(body1, {
+		        status: original.status,
+		        statusText: original.statusText,
+		        headers: original.headers
+		    });
+		    Object.defineProperty(cloned1, 'url', {
+		        value: original.url
+		    });
+		    const cloned2 = new Response(body2, {
+		        status: original.status,
+		        statusText: original.statusText,
+		        headers: original.headers
+		    });
+		    Object.defineProperty(cloned2, 'url', {
+		        value: original.url
+		    });
+		    return [
+		        cloned1,
+		        cloned2
+		    ];
+		}
+
+		
+	} (cloneResponse));
+	return cloneResponse;
+}
+
+export { requireCloneResponse as __require };

package/dist/esm/node_modules/.pnpm/next@15.3.1_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/next/dist/server/lib/decode-query-path-parameter.js

@@ -0,0 +1,58 @@
+/*
+   * Copyright (c) 2022 BILDIT, INC.
+   *
+   * This file, and the software contained herein, are the exclusive property of BILDIT, INC.
+   * Unauthorized copying, distribution, or modification of this software is strictly prohibited.
+   * All rights reserved.
+   *
+   * This file is licensed under the ENT License ("License"). Use of this file is subject to the
+   * terms and conditions specified in the License. You may obtain a copy of the License at:
+   *
+   *     https://bildit.co/ENTLicense
+   *
+   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+   * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+   * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+   * DAMAGES, OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM,
+   * OUT OF, OR IN CONNECTION WITH, THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+   */
+import { __exports as decodeQueryPathParameter } from '../../../../../../../../_virtual/decode-query-path-parameter.js';
+
+/**
+ * Decodes a query path parameter.
+ *
+ * @param value - The value to decode.
+ * @returns The decoded value.
+ */
+
+var hasRequiredDecodeQueryPathParameter;
+
+function requireDecodeQueryPathParameter () {
+	if (hasRequiredDecodeQueryPathParameter) return decodeQueryPathParameter;
+	hasRequiredDecodeQueryPathParameter = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "decodeQueryPathParameter", {
+		    enumerable: true,
+		    get: function() {
+		        return decodeQueryPathParameter;
+		    }
+		});
+		function decodeQueryPathParameter(value) {
+		    // When deployed to Vercel, the value may be encoded, so this attempts to
+		    // decode it and returns the original value if it fails.
+		    try {
+		        return decodeURIComponent(value);
+		    } catch  {
+		        return value;
+		    }
+		}
+
+		
+	} (decodeQueryPathParameter));
+	return decodeQueryPathParameter;
+}
+
+export { requireDecodeQueryPathParameter as __require };

package/dist/esm/node_modules/.pnpm/next@15.3.1_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/next/dist/server/lib/dedupe-fetch.js

@@ -0,0 +1,191 @@
+/*
+   * Copyright (c) 2022 BILDIT, INC.
+   *
+   * This file, and the software contained herein, are the exclusive property of BILDIT, INC.
+   * Unauthorized copying, distribution, or modification of this software is strictly prohibited.
+   * All rights reserved.
+   *
+   * This file is licensed under the ENT License ("License"). Use of this file is subject to the
+   * terms and conditions specified in the License. You may obtain a copy of the License at:
+   *
+   *     https://bildit.co/ENTLicense
+   *
+   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+   * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+   * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+   * DAMAGES, OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM,
+   * OUT OF, OR IN CONNECTION WITH, THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+   */
+import { __exports as dedupeFetch } from '../../../../../../../../_virtual/dedupe-fetch.js';
+import require$$1__default from 'react';
+import { __require as requireCloneResponse } from './clone-response.js';
+import { __require as requireInvariantError } from '../../shared/lib/invariant-error.js';
+
+/**
+ * Based on https://github.com/facebook/react/blob/d4e78c42a94be027b4dc7ed2659a5fddfbf9bd4e/packages/react/src/ReactFetch.js
+ */
+
+var hasRequiredDedupeFetch;
+
+function requireDedupeFetch () {
+	if (hasRequiredDedupeFetch) return dedupeFetch;
+	hasRequiredDedupeFetch = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "createDedupeFetch", {
+		    enumerable: true,
+		    get: function() {
+		        return createDedupeFetch;
+		    }
+		});
+		const _react = /*#__PURE__*/ _interop_require_wildcard(require$$1__default);
+		const _cloneresponse = requireCloneResponse();
+		const _invarianterror = requireInvariantError();
+		function _getRequireWildcardCache(nodeInterop) {
+		    if (typeof WeakMap !== "function") return null;
+		    var cacheBabelInterop = new WeakMap();
+		    var cacheNodeInterop = new WeakMap();
+		    return (_getRequireWildcardCache = function(nodeInterop) {
+		        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+		    })(nodeInterop);
+		}
+		function _interop_require_wildcard(obj, nodeInterop) {
+		    if (!nodeInterop && obj && obj.__esModule) {
+		        return obj;
+		    }
+		    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+		        return {
+		            default: obj
+		        };
+		    }
+		    var cache = _getRequireWildcardCache(nodeInterop);
+		    if (cache && cache.has(obj)) {
+		        return cache.get(obj);
+		    }
+		    var newObj = {
+		        __proto__: null
+		    };
+		    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+		    for(var key in obj){
+		        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+		            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+		            if (desc && (desc.get || desc.set)) {
+		                Object.defineProperty(newObj, key, desc);
+		            } else {
+		                newObj[key] = obj[key];
+		            }
+		        }
+		    }
+		    newObj.default = obj;
+		    if (cache) {
+		        cache.set(obj, newObj);
+		    }
+		    return newObj;
+		}
+		const simpleCacheKey = '["GET",[],null,"follow",null,null,null,null]' // generateCacheKey(new Request('https://blank'));
+		;
+		function generateCacheKey(request) {
+		    // We pick the fields that goes into the key used to dedupe requests.
+		    // We don't include the `cache` field, because we end up using whatever
+		    // caching resulted from the first request.
+		    // Notably we currently don't consider non-standard (or future) options.
+		    // This might not be safe. TODO: warn for non-standard extensions differing.
+		    // IF YOU CHANGE THIS UPDATE THE simpleCacheKey ABOVE.
+		    return JSON.stringify([
+		        request.method,
+		        Array.from(request.headers.entries()),
+		        request.mode,
+		        request.redirect,
+		        request.credentials,
+		        request.referrer,
+		        request.referrerPolicy,
+		        request.integrity
+		    ]);
+		}
+		function createDedupeFetch(originalFetch) {
+		    const getCacheEntries = _react.cache(// eslint-disable-next-line @typescript-eslint/no-unused-vars -- url is the cache key
+		    (url)=>[]);
+		    return function dedupeFetch(resource, options) {
+		        if (options && options.signal) {
+		            // If we're passed a signal, then we assume that
+		            // someone else controls the lifetime of this object and opts out of
+		            // caching. It's effectively the opt-out mechanism.
+		            // Ideally we should be able to check this on the Request but
+		            // it always gets initialized with its own signal so we don't
+		            // know if it's supposed to override - unless we also override the
+		            // Request constructor.
+		            return originalFetch(resource, options);
+		        }
+		        // Normalize the Request
+		        let url;
+		        let cacheKey;
+		        if (typeof resource === 'string' && !options) {
+		            // Fast path.
+		            cacheKey = simpleCacheKey;
+		            url = resource;
+		        } else {
+		            // Normalize the request.
+		            // if resource is not a string or a URL (its an instance of Request)
+		            // then do not instantiate a new Request but instead
+		            // reuse the request as to not disturb the body in the event it's a ReadableStream.
+		            const request = typeof resource === 'string' || resource instanceof URL ? new Request(resource, options) : resource;
+		            if (request.method !== 'GET' && request.method !== 'HEAD' || request.keepalive) {
+		                // We currently don't dedupe requests that might have side-effects. Those
+		                // have to be explicitly cached. We assume that the request doesn't have a
+		                // body if it's GET or HEAD.
+		                // keepalive gets treated the same as if you passed a custom cache signal.
+		                return originalFetch(resource, options);
+		            }
+		            cacheKey = generateCacheKey(request);
+		            url = request.url;
+		        }
+		        const cacheEntries = getCacheEntries(url);
+		        for(let i = 0, j = cacheEntries.length; i < j; i += 1){
+		            const [key, promise] = cacheEntries[i];
+		            if (key === cacheKey) {
+		                return promise.then(()=>{
+		                    const response = cacheEntries[i][2];
+		                    if (!response) throw Object.defineProperty(new _invarianterror.InvariantError('No cached response'), "__NEXT_ERROR_CODE", {
+		                        value: "E579",
+		                        enumerable: false,
+		                        configurable: true
+		                    });
+		                    // We're cloning the response using this utility because there exists
+		                    // a bug in the undici library around response cloning. See the
+		                    // following pull request for more details:
+		                    // https://github.com/vercel/next.js/pull/73274
+		                    const [cloned1, cloned2] = (0, _cloneresponse.cloneResponse)(response);
+		                    cacheEntries[i][2] = cloned2;
+		                    return cloned1;
+		                });
+		            }
+		        }
+		        // We pass the original arguments here in case normalizing the Request
+		        // doesn't include all the options in this environment.
+		        const promise = originalFetch(resource, options);
+		        const entry = [
+		            cacheKey,
+		            promise,
+		            null
+		        ];
+		        cacheEntries.push(entry);
+		        return promise.then((response)=>{
+		            // We're cloning the response using this utility because there exists
+		            // a bug in the undici library around response cloning. See the
+		            // following pull request for more details:
+		            // https://github.com/vercel/next.js/pull/73274
+		            const [cloned1, cloned2] = (0, _cloneresponse.cloneResponse)(response);
+		            entry[2] = cloned2;
+		            return cloned1;
+		        });
+		    };
+		}
+
+		
+	} (dedupeFetch));
+	return dedupeFetch;
+}
+
+export { requireDedupeFetch as __require };

package/dist/esm/node_modules/.pnpm/next@15.3.1_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/next/dist/server/lib/dev-bundler-service.js

@@ -0,0 +1,118 @@
+/*
+   * Copyright (c) 2022 BILDIT, INC.
+   *
+   * This file, and the software contained herein, are the exclusive property of BILDIT, INC.
+   * Unauthorized copying, distribution, or modification of this software is strictly prohibited.
+   * All rights reserved.
+   *
+   * This file is licensed under the ENT License ("License"). Use of this file is subject to the
+   * terms and conditions specified in the License. You may obtain a copy of the License at:
+   *
+   *     https://bildit.co/ENTLicense
+   *
+   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+   * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+   * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+   * DAMAGES, OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM,
+   * OUT OF, OR IN CONNECTION WITH, THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+   */
+import { __exports as devBundlerService } from '../../../../../../../../_virtual/dev-bundler-service.js';
+import './lru-cache.js';
+import { __require as requireMockRequest } from './mock-request.js';
+import { __require as requireHotReloaderTypes } from '../dev/hot-reloader-types.js';
+import { __exports as lruCache } from '../../../../../../../../_virtual/lru-cache.js';
+
+var hasRequiredDevBundlerService;
+
+function requireDevBundlerService () {
+	if (hasRequiredDevBundlerService) return devBundlerService;
+	hasRequiredDevBundlerService = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "DevBundlerService", {
+		    enumerable: true,
+		    get: function() {
+		        return DevBundlerService;
+		    }
+		});
+		const _lrucache = lruCache;
+		const _mockrequest = requireMockRequest();
+		const _hotreloadertypes = requireHotReloaderTypes();
+		class DevBundlerService {
+		    constructor(bundler, handler){
+		        this.bundler = bundler;
+		        this.handler = handler;
+		        this.ensurePage = async (definition)=>{
+		            // TODO: remove after ensure is pulled out of server
+		            return await this.bundler.hotReloader.ensurePage(definition);
+		        };
+		        this.logErrorWithOriginalStack = this.bundler.logErrorWithOriginalStack.bind(this.bundler);
+		        this.appIsrManifestInner = new _lrucache.LRUCache(8000, function length() {
+		            return 16;
+		        });
+		    }
+		    async getFallbackErrorComponents(url) {
+		        await this.bundler.hotReloader.buildFallbackError();
+		        // Build the error page to ensure the fallback is built too.
+		        // TODO: See if this can be moved into hotReloader or removed.
+		        await this.bundler.hotReloader.ensurePage({
+		            page: '/_error',
+		            clientOnly: false,
+		            definition: undefined,
+		            url
+		        });
+		    }
+		    async getCompilationError(page) {
+		        const errors = await this.bundler.hotReloader.getCompilationErrors(page);
+		        if (!errors) return;
+		        // Return the very first error we found.
+		        return errors[0];
+		    }
+		    async revalidate({ urlPath, revalidateHeaders, opts: revalidateOpts }) {
+		        const mocked = (0, _mockrequest.createRequestResponseMocks)({
+		            url: urlPath,
+		            headers: revalidateHeaders
+		        });
+		        await this.handler(mocked.req, mocked.res);
+		        await mocked.res.hasStreamed;
+		        if (mocked.res.getHeader('x-nextjs-cache') !== 'REVALIDATED' && mocked.res.statusCode !== 200 && !(mocked.res.statusCode === 404 && revalidateOpts.unstable_onlyGenerated)) {
+		            throw Object.defineProperty(new Error(`Invalid response ${mocked.res.statusCode}`), "__NEXT_ERROR_CODE", {
+		                value: "E175",
+		                enumerable: false,
+		                configurable: true
+		            });
+		        }
+		        return {};
+		    }
+		    get appIsrManifest() {
+		        const serializableManifest = {};
+		        for (const key of this.appIsrManifestInner.keys()){
+		            serializableManifest[key] = this.appIsrManifestInner.get(key);
+		        }
+		        return serializableManifest;
+		    }
+		    setIsrStatus(key, value) {
+		        var _this_bundler_hotReloader, _this_bundler;
+		        if (value === null) {
+		            this.appIsrManifestInner.remove(key);
+		        } else {
+		            this.appIsrManifestInner.set(key, value);
+		        }
+		        (_this_bundler = this.bundler) == null ? void 0 : (_this_bundler_hotReloader = _this_bundler.hotReloader) == null ? void 0 : _this_bundler_hotReloader.send({
+		            action: _hotreloadertypes.HMR_ACTIONS_SENT_TO_BROWSER.ISR_MANIFEST,
+		            data: this.appIsrManifest
+		        });
+		    }
+		    close() {
+		        this.bundler.hotReloader.close();
+		    }
+		}
+
+		
+	} (devBundlerService));
+	return devBundlerService;
+}
+
+export { requireDevBundlerService as __require };

package/dist/esm/node_modules/.pnpm/next@15.3.1_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/next/dist/server/lib/etag.js

@@ -0,0 +1,84 @@
+/*
+   * Copyright (c) 2022 BILDIT, INC.
+   *
+   * This file, and the software contained herein, are the exclusive property of BILDIT, INC.
+   * Unauthorized copying, distribution, or modification of this software is strictly prohibited.
+   * All rights reserved.
+   *
+   * This file is licensed under the ENT License ("License"). Use of this file is subject to the
+   * terms and conditions specified in the License. You may obtain a copy of the License at:
+   *
+   *     https://bildit.co/ENTLicense
+   *
+   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+   * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+   * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+   * DAMAGES, OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM,
+   * OUT OF, OR IN CONNECTION WITH, THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+   */
+import { __exports as etag } from '../../../../../../../../_virtual/etag.js';
+
+/**
+ * FNV-1a Hash implementation
+ * @author Travis Webb (tjwebb) <me@traviswebb.com>
+ *
+ * Ported from https://github.com/tjwebb/fnv-plus/blob/master/index.js
+ *
+ * Simplified, optimized and add modified for 52 bit, which provides a larger hash space
+ * and still making use of Javascript's 53-bit integer space.
+ */
+
+var hasRequiredEtag;
+
+function requireEtag () {
+	if (hasRequiredEtag) return etag;
+	hasRequiredEtag = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		function _export(target, all) {
+		    for(var name in all)Object.defineProperty(target, name, {
+		        enumerable: true,
+		        get: all[name]
+		    });
+		}
+		_export(exports, {
+		    fnv1a52: function() {
+		        return fnv1a52;
+		    },
+		    generateETag: function() {
+		        return generateETag;
+		    }
+		});
+		const fnv1a52 = (str)=>{
+		    const len = str.length;
+		    let i = 0, t0 = 0, v0 = 0x2325, t1 = 0, v1 = 0x8422, t2 = 0, v2 = 0x9ce4, t3 = 0, v3 = 0xcbf2;
+		    while(i < len){
+		        v0 ^= str.charCodeAt(i++);
+		        t0 = v0 * 435;
+		        t1 = v1 * 435;
+		        t2 = v2 * 435;
+		        t3 = v3 * 435;
+		        t2 += v0 << 8;
+		        t3 += v1 << 8;
+		        t1 += t0 >>> 16;
+		        v0 = t0 & 65535;
+		        t2 += t1 >>> 16;
+		        v1 = t1 & 65535;
+		        v3 = t3 + (t2 >>> 16) & 65535;
+		        v2 = t2 & 65535;
+		    }
+		    return (v3 & 15) * 281474976710656 + v2 * 4294967296 + v1 * 65536 + (v0 ^ v3 >> 4);
+		};
+		const generateETag = (payload, weak = false)=>{
+		    const prefix = weak ? 'W/"' : '"';
+		    return prefix + fnv1a52(payload).toString(36) + payload.length.toString(36) + '"';
+		};
+
+		
+	} (etag));
+	return etag;
+}
+
+export { requireEtag as __require };

package/dist/esm/node_modules/.pnpm/next@15.3.1_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/next/dist/server/lib/experimental/create-env-definitions.js

@@ -0,0 +1,81 @@
+/*
+   * Copyright (c) 2022 BILDIT, INC.
+   *
+   * This file, and the software contained herein, are the exclusive property of BILDIT, INC.
+   * Unauthorized copying, distribution, or modification of this software is strictly prohibited.
+   * All rights reserved.
+   *
+   * This file is licensed under the ENT License ("License"). Use of this file is subject to the
+   * terms and conditions specified in the License. You may obtain a copy of the License at:
+   *
+   *     https://bildit.co/ENTLicense
+   *
+   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+   * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+   * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+   * DAMAGES, OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM,
+   * OUT OF, OR IN CONNECTION WITH, THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+   */
+import { __exports as createEnvDefinitions } from '../../../../../../../../../_virtual/create-env-definitions.js';
+import require$$0 from 'node:path';
+import require$$1 from 'node:fs/promises';
+
+var hasRequiredCreateEnvDefinitions;
+
+function requireCreateEnvDefinitions () {
+	if (hasRequiredCreateEnvDefinitions) return createEnvDefinitions;
+	hasRequiredCreateEnvDefinitions = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "createEnvDefinitions", {
+		    enumerable: true,
+		    get: function() {
+		        return createEnvDefinitions;
+		    }
+		});
+		const _nodepath = require$$0;
+		const _promises = require$$1;
+		async function createEnvDefinitions({ distDir, loadedEnvFiles }) {
+		    const envLines = [];
+		    const seenKeys = new Set();
+		    // env files are in order of priority
+		    for (const { path, env } of loadedEnvFiles){
+		        for(const key in env){
+		            if (!seenKeys.has(key)) {
+		                envLines.push(`      /** Loaded from \`${path}\` */`);
+		                envLines.push(`      ${key}?: string`);
+		                seenKeys.add(key);
+		            }
+		        }
+		    }
+		    const envStr = envLines.join('\n');
+		    const definitionStr = `// Type definitions for Next.js environment variables
+declare global {
+  namespace NodeJS {
+    interface ProcessEnv {
+${envStr}
+    }
+  }
+}
+export {}`;
+		    if (process.env.NODE_ENV === 'test') {
+		        return definitionStr;
+		    }
+		    try {
+		        // we expect the types directory to already exist
+		        const envDtsPath = (0, _nodepath.join)(distDir, 'types', 'env.d.ts');
+		        // do not await, this is not essential for further process
+		        (0, _promises.writeFile)(envDtsPath, definitionStr, 'utf-8');
+		    } catch (e) {
+		        console.error('Failed to write env.d.ts:', e);
+		    }
+		}
+
+		
+	} (createEnvDefinitions));
+	return createEnvDefinitions;
+}
+
+export { requireCreateEnvDefinitions as __require };