@ank1015/llm 0.0.1 → 0.0.2

package/vendor/web/standalone/node_modules/next/dist/server/node-environment-extensions/io-utils.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "io", {
+    enumerable: true,
+    get: function() {
+        return io;
+    }
+});
+const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
+const _workunitasyncstorageexternal = require("../app-render/work-unit-async-storage.external");
+const _dynamicrendering = require("../app-render/dynamic-rendering");
+const _invarianterror = require("../../shared/lib/invariant-error");
+const _stagedrendering = require("../app-render/staged-rendering");
+const _runtimereactsexternal = require("../runtime-reacts.external");
+function io(expression, type) {
+    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+    if (!workUnitStore || !workStore) {
+        return;
+    }
+    switch(workUnitStore.type){
+        case 'prerender':
+        case 'prerender-runtime':
+            {
+                const prerenderSignal = workUnitStore.controller.signal;
+                if (prerenderSignal.aborted === false) {
+                    // If the prerender signal is already aborted we don't need to construct
+                    // any stacks because something else actually terminated the prerender.
+                    let message;
+                    switch(type){
+                        case 'time':
+                            message = `Route "${workStore.route}" used ${expression} before accessing either uncached data (e.g. \`fetch()\`) or Request data (e.g. \`cookies()\`, \`headers()\`, \`connection()\`, and \`searchParams\`). Accessing the current time in a Server Component requires reading one of these data sources first. Alternatively, consider moving this expression into a Client Component or Cache Component. See more info here: https://nextjs.org/docs/messages/next-prerender-current-time`;
+                            break;
+                        case 'random':
+                            message = `Route "${workStore.route}" used ${expression} before accessing either uncached data (e.g. \`fetch()\`) or Request data (e.g. \`cookies()\`, \`headers()\`, \`connection()\`, and \`searchParams\`). Accessing random values synchronously in a Server Component requires reading one of these data sources first. Alternatively, consider moving this expression into a Client Component or Cache Component. See more info here: https://nextjs.org/docs/messages/next-prerender-random`;
+                            break;
+                        case 'crypto':
+                            message = `Route "${workStore.route}" used ${expression} before accessing either uncached data (e.g. \`fetch()\`) or Request data (e.g. \`cookies()\`, \`headers()\`, \`connection()\`, and \`searchParams\`). Accessing random cryptographic values synchronously in a Server Component requires reading one of these data sources first. Alternatively, consider moving this expression into a Client Component or Cache Component. See more info here: https://nextjs.org/docs/messages/next-prerender-crypto`;
+                            break;
+                        default:
+                            throw Object.defineProperty(new _invarianterror.InvariantError('Unknown expression type in abortOnSynchronousPlatformIOAccess.'), "__NEXT_ERROR_CODE", {
+                                value: "E526",
+                                enumerable: false,
+                                configurable: true
+                            });
+                    }
+                    (0, _dynamicrendering.abortOnSynchronousPlatformIOAccess)(workStore.route, expression, applyOwnerStack(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+                        value: "E394",
+                        enumerable: false,
+                        configurable: true
+                    })), workUnitStore);
+                }
+                break;
+            }
+        case 'prerender-client':
+            {
+                const prerenderSignal = workUnitStore.controller.signal;
+                if (prerenderSignal.aborted === false) {
+                    // If the prerender signal is already aborted we don't need to construct
+                    // any stacks because something else actually terminated the prerender.
+                    let message;
+                    switch(type){
+                        case 'time':
+                            message = `Route "${workStore.route}" used ${expression} inside a Client Component without a Suspense boundary above it. See more info here: https://nextjs.org/docs/messages/next-prerender-current-time-client`;
+                            break;
+                        case 'random':
+                            message = `Route "${workStore.route}" used ${expression} inside a Client Component without a Suspense boundary above it. See more info here: https://nextjs.org/docs/messages/next-prerender-random-client`;
+                            break;
+                        case 'crypto':
+                            message = `Route "${workStore.route}" used ${expression} inside a Client Component without a Suspense boundary above it. See more info here: https://nextjs.org/docs/messages/next-prerender-crypto-client`;
+                            break;
+                        default:
+                            throw Object.defineProperty(new _invarianterror.InvariantError('Unknown expression type in abortOnSynchronousPlatformIOAccess.'), "__NEXT_ERROR_CODE", {
+                                value: "E526",
+                                enumerable: false,
+                                configurable: true
+                            });
+                    }
+                    (0, _dynamicrendering.abortOnSynchronousPlatformIOAccess)(workStore.route, expression, applyOwnerStack(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+                        value: "E394",
+                        enumerable: false,
+                        configurable: true
+                    })), workUnitStore);
+                }
+                break;
+            }
+        case 'request':
+            {
+                const stageController = workUnitStore.stagedRendering;
+                if (stageController && stageController.shouldTrackSyncInterrupt()) {
+                    let message;
+                    if (stageController.currentStage === _stagedrendering.RenderStage.Static || stageController.currentStage === _stagedrendering.RenderStage.EarlyStatic) {
+                        switch(type){
+                            case 'time':
+                                message = `Route "${workStore.route}" used ${expression} before accessing either uncached data (e.g. \`fetch()\`) or Request data (e.g. \`cookies()\`, \`headers()\`, \`connection()\`, and \`searchParams\`). Accessing the current time in a Server Component requires reading one of these data sources first. Alternatively, consider moving this expression into a Client Component or Cache Component. See more info here: https://nextjs.org/docs/messages/next-prerender-current-time`;
+                                break;
+                            case 'random':
+                                message = `Route "${workStore.route}" used ${expression} before accessing either uncached data (e.g. \`fetch()\`) or Request data (e.g. \`cookies()\`, \`headers()\`, \`connection()\`, and \`searchParams\`). Accessing random values synchronously in a Server Component requires reading one of these data sources first. Alternatively, consider moving this expression into a Client Component or Cache Component. See more info here: https://nextjs.org/docs/messages/next-prerender-random`;
+                                break;
+                            case 'crypto':
+                                message = `Route "${workStore.route}" used ${expression} before accessing either uncached data (e.g. \`fetch()\`) or Request data (e.g. \`cookies()\`, \`headers()\`, \`connection()\`, and \`searchParams\`). Accessing random cryptographic values synchronously in a Server Component requires reading one of these data sources first. Alternatively, consider moving this expression into a Client Component or Cache Component. See more info here: https://nextjs.org/docs/messages/next-prerender-crypto`;
+                                break;
+                            default:
+                                throw Object.defineProperty(new _invarianterror.InvariantError('Unknown expression type in abortOnSynchronousPlatformIOAccess.'), "__NEXT_ERROR_CODE", {
+                                    value: "E526",
+                                    enumerable: false,
+                                    configurable: true
+                                });
+                        }
+                    } else {
+                        // We're in the Runtime stage.
+                        // We only error for Sync IO in the Runtime stage if the route has a runtime prefetch config.
+                        // This check is implemented in `stageController.canSyncInterrupt()` --
+                        // if runtime prefetching isn't enabled, then we won't get here.
+                        let accessStatement;
+                        let additionalInfoLink;
+                        switch(type){
+                            case 'time':
+                                accessStatement = 'the current time';
+                                additionalInfoLink = 'https://nextjs.org/docs/messages/next-prerender-runtime-current-time';
+                                break;
+                            case 'random':
+                                accessStatement = 'random values synchronously';
+                                additionalInfoLink = 'https://nextjs.org/docs/messages/next-prerender-runtime-random';
+                                break;
+                            case 'crypto':
+                                accessStatement = 'random cryptographic values synchronously';
+                                additionalInfoLink = 'https://nextjs.org/docs/messages/next-prerender-runtime-crypto';
+                                break;
+                            default:
+                                throw Object.defineProperty(new _invarianterror.InvariantError('Unknown expression type in abortOnSynchronousPlatformIOAccess.'), "__NEXT_ERROR_CODE", {
+                                    value: "E526",
+                                    enumerable: false,
+                                    configurable: true
+                                });
+                        }
+                        message = `Route "${workStore.route}" used ${expression} before accessing either uncached data (e.g. \`fetch()\`) or awaiting \`connection()\`. When configured for Runtime prefetching, accessing ${accessStatement} in a Server Component requires reading one of these data sources first. Alternatively, consider moving this expression into a Client Component or Cache Component. See more info here: ${additionalInfoLink}`;
+                    }
+                    const syncIOError = applyOwnerStack(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+                        value: "E394",
+                        enumerable: false,
+                        configurable: true
+                    }));
+                    stageController.syncInterruptCurrentStageWithReason(syncIOError);
+                    // A build-time validation render uses a 'request' store type, but may be abortable.
+                    // If we're in the second, restarted render of the restart-on-cache miss flow,
+                    // Sync IO is an error, and unlike dev, there's no need to continue the render past the sync IO,
+                    // so we can abort it.
+                    if (workUnitStore.controller && !workUnitStore.controller.signal.aborted) {
+                        workUnitStore.controller.abort(syncIOError);
+                    }
+                }
+                break;
+            }
+        case 'validation-client':
+        case 'prerender-ppr':
+        case 'prerender-legacy':
+        case 'cache':
+        case 'private-cache':
+        case 'unstable-cache':
+        case 'generate-static-params':
+            break;
+        default:
+            workUnitStore;
+    }
+}
+function applyOwnerStack(error) {
+    // TODO: Instead of stitching the stacks here, we should log the original
+    // error as-is when it occurs, and let `patchErrorInspect` handle adding the
+    // owner stack, instead of logging it deferred in the `LogSafely` component
+    // via `throwIfDisallowedDynamic`.
+    if (process.env.NODE_ENV !== 'production') {
+        var _getClientReact_captureOwnerStack, _getClientReact, _getServerReact_captureOwnerStack, _getServerReact;
+        const ownerStack = ((_getClientReact = (0, _runtimereactsexternal.getClientReact)()) == null ? void 0 : (_getClientReact_captureOwnerStack = _getClientReact.captureOwnerStack) == null ? void 0 : _getClientReact_captureOwnerStack.call(_getClientReact)) ?? ((_getServerReact = (0, _runtimereactsexternal.getServerReact)()) == null ? void 0 : (_getServerReact_captureOwnerStack = _getServerReact.captureOwnerStack) == null ? void 0 : _getServerReact_captureOwnerStack.call(_getServerReact));
+        if (ownerStack) {
+            let stack = ownerStack;
+            if (error.stack) {
+                const frames = [];
+                for (const frame of error.stack.split('\n').slice(1)){
+                    if (frame.includes('react_stack_bottom_frame')) {
+                        break;
+                    }
+                    frames.push(frame);
+                }
+                stack = '\n' + frames.join('\n') + stack;
+            }
+            error.stack = error.name + ': ' + error.message + stack;
+        }
+    }
+    return error;
+}
+
+//# sourceMappingURL=io-utils.js.map

package/vendor/web/standalone/node_modules/next/dist/server/node-environment-extensions/node-crypto.js

@@ -0,0 +1,103 @@
+/**
+ * We extend node:crypto APIs during builds and revalidates to ensure that prerenders don't observe random bytes
+ * When cacheComponents is enabled. Random bytes are a form of IO even if they resolve synchronously. When cacheComponents is
+ * enabled we need to ensure that random bytes are excluded from prerenders unless they are cached.
+ *
+ *
+ * The extensions here never error nor alter the underlying return values and thus should be transparent to callers.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _ioutils = require("./io-utils");
+if (process.env.NEXT_RUNTIME === 'edge') {
+// nothing to patch
+} else {
+    const nodeCrypto = require('node:crypto');
+    // require('node:crypto').getRandomValues is an alias for
+    // crypto.getRandomValues which is extended in web-crypto.tsx
+    // require('node:crypto').randomUUID is not an alias for crypto.randomUUID
+    const randomUUIDExpression = "`require('node:crypto').randomUUID()`";
+    try {
+        const _randomUUID = nodeCrypto.randomUUID;
+        nodeCrypto.randomUUID = function randomUUID() {
+            (0, _ioutils.io)(randomUUIDExpression, 'random');
+            return _randomUUID.apply(this, arguments);
+        };
+    } catch  {
+        console.error(`Failed to install ${randomUUIDExpression} extension. When using \`cacheComponents\` calling this function will not correctly trigger dynamic behavior.`);
+    }
+    const randomBytesExpression = "`require('node:crypto').randomBytes(size)`";
+    try {
+        const _randomBytes = nodeCrypto.randomBytes;
+        // @ts-expect-error -- TODO: tell TS the overloads are preserved
+        nodeCrypto.randomBytes = function randomBytes() {
+            if (typeof arguments[1] !== 'function') {
+                // randomBytes is sync if the second arg is undefined
+                (0, _ioutils.io)(randomBytesExpression, 'random');
+            }
+            return _randomBytes.apply(this, arguments);
+        };
+    } catch  {
+        console.error(`Failed to install ${randomBytesExpression} extension. When using \`cacheComponents\` calling this function without a callback argument will not correctly trigger dynamic behavior.`);
+    }
+    const randomFillSyncExpression = "`require('node:crypto').randomFillSync(...)`";
+    try {
+        const _randomFillSync = nodeCrypto.randomFillSync;
+        // @ts-expect-error -- TODO: tell TS the overloads are preserved
+        nodeCrypto.randomFillSync = function randomFillSync() {
+            (0, _ioutils.io)(randomFillSyncExpression, 'random');
+            return _randomFillSync.apply(this, arguments);
+        };
+    } catch  {
+        console.error(`Failed to install ${randomFillSyncExpression} extension. When using \`cacheComponents\` calling this function will not correctly trigger dynamic behavior.`);
+    }
+    const randomIntExpression = "`require('node:crypto').randomInt(min, max)`";
+    try {
+        const _randomInt = nodeCrypto.randomInt;
+        // @ts-expect-error -- TODO: tell TS the overloads are preserved
+        nodeCrypto.randomInt = function randomInt() {
+            if (typeof arguments[2] !== 'function') {
+                // randomInt is sync if the third arg is undefined
+                (0, _ioutils.io)(randomIntExpression, 'random');
+            }
+            return _randomInt.apply(this, arguments);
+        };
+    } catch  {
+        console.error(`Failed to install ${randomBytesExpression} extension. When using \`cacheComponents\` calling this function without a callback argument will not correctly trigger dynamic behavior.`);
+    }
+    const generatePrimeSyncExpression = "`require('node:crypto').generatePrimeSync(...)`";
+    try {
+        const _generatePrimeSync = nodeCrypto.generatePrimeSync;
+        // @ts-expect-error -- TODO: tell TS the overloads are preserved
+        nodeCrypto.generatePrimeSync = function generatePrimeSync() {
+            (0, _ioutils.io)(generatePrimeSyncExpression, 'random');
+            return _generatePrimeSync.apply(this, arguments);
+        };
+    } catch  {
+        console.error(`Failed to install ${generatePrimeSyncExpression} extension. When using \`cacheComponents\` calling this function will not correctly trigger dynamic behavior.`);
+    }
+    const generateKeyPairSyncExpression = "`require('node:crypto').generateKeyPairSync(...)`";
+    try {
+        const _generateKeyPairSync = nodeCrypto.generateKeyPairSync;
+        // @ts-expect-error -- TODO: tell TS the overloads are preserved
+        nodeCrypto.generateKeyPairSync = function generateKeyPairSync() {
+            (0, _ioutils.io)(generateKeyPairSyncExpression, 'random');
+            return _generateKeyPairSync.apply(this, arguments);
+        };
+    } catch  {
+        console.error(`Failed to install ${generateKeyPairSyncExpression} extension. When using \`cacheComponents\` calling this function will not correctly trigger dynamic behavior.`);
+    }
+    const generateKeySyncExpression = "`require('node:crypto').generateKeySync(...)`";
+    try {
+        const _generateKeySync = nodeCrypto.generateKeySync;
+        nodeCrypto.generateKeySync = function generateKeySync() {
+            (0, _ioutils.io)(generateKeySyncExpression, 'random');
+            return _generateKeySync.apply(this, arguments);
+        };
+    } catch  {
+        console.error(`Failed to install ${generateKeySyncExpression} extension. When using \`cacheComponents\` calling this function will not correctly trigger dynamic behavior.`);
+    }
+}
+
+//# sourceMappingURL=node-crypto.js.map

package/vendor/web/standalone/node_modules/next/dist/server/node-environment-extensions/process-error-handlers.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "installProcessErrorHandlers", {
+    enumerable: true,
+    get: function() {
+        return installProcessErrorHandlers;
+    }
+});
+const _ispostpone = require("../lib/router-utils/is-postpone");
+let _global = globalThis;
+function installProcessErrorHandlers(shouldRemoveUncaughtErrorAndRejectionListeners) {
+    if (_global.nextInitializedProcessErrorHandlers) return;
+    _global.nextInitializedProcessErrorHandlers = true;
+    // The conventional wisdom of Node.js and other runtimes is to treat
+    // unhandled errors as fatal and exit the process.
+    //
+    // But Next.js is not a generic JS runtime — it's a specialized runtime for
+    // React Server Components.
+    //
+    // Many unhandled rejections are due to the late-awaiting pattern for
+    // prefetching data. In Next.js it's OK to call an async function without
+    // immediately awaiting it, to start the request as soon as possible
+    // without blocking unncessarily on the result. These can end up
+    // triggering an "unhandledRejection" if it later turns out that the
+    // data is not needed to render the page. Example:
+    //
+    //     const promise = fetchData()
+    //     const shouldShow = await checkCondition()
+    //     if (shouldShow) {
+    //       return <Component promise={promise} />
+    //     }
+    //
+    // In this example, `fetchData` is called immediately to start the request
+    // as soon as possible, but if `shouldShow` is false, then it will be
+    // discarded without unwrapping its result. If it errors, it will trigger
+    // an "unhandledRejection" event.
+    //
+    // Ideally, we would suppress these rejections completely without warning,
+    // because we don't consider them real errors. (TODO: Currently we do warn.)
+    //
+    // But regardless of whether we do or don't warn, we definitely shouldn't
+    // crash the entire process.
+    //
+    // Even a "legit" unhandled error unrelated to prefetching shouldn't
+    // prevent the rest of the page from rendering.
+    //
+    // So, we're going to intentionally override the default error handling
+    // behavior of the outer JS runtime to be more forgiving
+    // Remove any existing "unhandledRejection" and "uncaughtException" handlers.
+    // This is gated behind an experimental flag until we've considered the impact
+    // in various deployment environments. It's possible this may always need to
+    // be configurable.
+    if (shouldRemoveUncaughtErrorAndRejectionListeners) {
+        process.removeAllListeners('uncaughtException');
+        process.removeAllListeners('unhandledRejection');
+    }
+    // Install a new handler to prevent the process from crashing.
+    process.on('unhandledRejection', (reason)=>{
+        if ((0, _ispostpone.isPostpone)(reason)) {
+            // React postpones that are unhandled might end up logged here but they're
+            // not really errors. They're just part of rendering.
+            return;
+        }
+        // Immediately log the error.
+        // TODO: Ideally, if we knew that this error was triggered by application
+        // code, we would suppress it entirely without logging. We can't reliably
+        // detect all of these, but when cacheComponents is enabled, we could suppress
+        // at least some of them by waiting to log the error until after all in-
+        // progress renders have completed. Then, only log errors for which there
+        // was not a corresponding "rejectionHandled" event.
+        console.error(reason);
+    });
+    process.on('rejectionHandled', ()=>{
+    // TODO: See note in the unhandledRejection handler above. In the future,
+    // we may use the "rejectionHandled" event to de-queue an error from
+    // being logged.
+    });
+    // Unhandled exceptions are errors triggered by non-async functions, so this
+    // is unrelated to the late-awaiting pattern. However, for similar reasons,
+    // we still shouldn't crash the process. Just log it.
+    process.on('uncaughtException', (reason)=>{
+        if ((0, _ispostpone.isPostpone)(reason)) {
+            return;
+        }
+        console.error(reason);
+    });
+}
+
+//# sourceMappingURL=process-error-handlers.js.map

package/vendor/web/standalone/node_modules/next/dist/server/node-environment-extensions/random.js

@@ -0,0 +1,28 @@
+/**
+ * We extend Math.random() during builds and revalidates to ensure that prerenders don't observe randomness
+ * When cacheComponents is enabled. randomness is a form of IO even though it resolves synchronously. When cacheComponents is
+ * enabled we need to ensure that randomness is excluded from prerenders.
+ *
+ * The extensions here never error nor alter the random generation itself and thus should be transparent to callers.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _ioutils = require("./io-utils");
+const expression = '`Math.random()`';
+try {
+    const _random = Math.random;
+    Math.random = (function random() {
+        (0, _ioutils.io)(expression, 'random');
+        return _random.apply(null, arguments);
+    // We bind here to alter the `toString` printing to match `Math.random`'s native `toString`.
+    // eslint-disable-next-line no-extra-bind
+    }).bind(null);
+    Object.defineProperty(Math.random, 'name', {
+        value: 'random'
+    });
+} catch  {
+    console.error(`Failed to install ${expression} extension. When using \`cacheComponents\` calling this function will not correctly trigger dynamic behavior.`);
+}
+
+//# sourceMappingURL=random.js.map