failproofai 0.0.1-beta.1

package/.next/standalone/node_modules/next/dist/server/web/spec-extension/adapters/request-cookies.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    MutableRequestCookiesAdapter: null,
+    ReadonlyRequestCookiesError: null,
+    RequestCookiesAdapter: null,
+    appendMutableCookies: null,
+    areCookiesMutableInCurrentPhase: null,
+    createCookiesWithMutableAccessCheck: null,
+    getModifiedCookieValues: null,
+    responseCookiesToRequestCookies: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    MutableRequestCookiesAdapter: function() {
+        return MutableRequestCookiesAdapter;
+    },
+    ReadonlyRequestCookiesError: function() {
+        return ReadonlyRequestCookiesError;
+    },
+    RequestCookiesAdapter: function() {
+        return RequestCookiesAdapter;
+    },
+    appendMutableCookies: function() {
+        return appendMutableCookies;
+    },
+    areCookiesMutableInCurrentPhase: function() {
+        return areCookiesMutableInCurrentPhase;
+    },
+    createCookiesWithMutableAccessCheck: function() {
+        return createCookiesWithMutableAccessCheck;
+    },
+    getModifiedCookieValues: function() {
+        return getModifiedCookieValues;
+    },
+    responseCookiesToRequestCookies: function() {
+        return responseCookiesToRequestCookies;
+    }
+});
+const _cookies = require("../cookies");
+const _reflect = require("./reflect");
+const _workasyncstorageexternal = require("../../../app-render/work-async-storage.external");
+const _actionrevalidationkind = require("../../../../shared/lib/action-revalidation-kind");
+class ReadonlyRequestCookiesError extends Error {
+    constructor(){
+        super('Cookies can only be modified in a Server Action or Route Handler. Read more: https://nextjs.org/docs/app/api-reference/functions/cookies#options');
+    }
+    static callable() {
+        throw new ReadonlyRequestCookiesError();
+    }
+}
+class RequestCookiesAdapter {
+    static seal(cookies) {
+        return new Proxy(cookies, {
+            get (target, prop, receiver) {
+                switch(prop){
+                    case 'clear':
+                    case 'delete':
+                    case 'set':
+                        return ReadonlyRequestCookiesError.callable;
+                    default:
+                        return _reflect.ReflectAdapter.get(target, prop, receiver);
+                }
+            }
+        });
+    }
+}
+const SYMBOL_MODIFY_COOKIE_VALUES = Symbol.for('next.mutated.cookies');
+function getModifiedCookieValues(cookies) {
+    const modified = cookies[SYMBOL_MODIFY_COOKIE_VALUES];
+    if (!modified || !Array.isArray(modified) || modified.length === 0) {
+        return [];
+    }
+    return modified;
+}
+function appendMutableCookies(headers, mutableCookies) {
+    const modifiedCookieValues = getModifiedCookieValues(mutableCookies);
+    if (modifiedCookieValues.length === 0) {
+        return false;
+    }
+    // Return a new response that extends the response with
+    // the modified cookies as fallbacks. `res` cookies
+    // will still take precedence.
+    const resCookies = new _cookies.ResponseCookies(headers);
+    const returnedCookies = resCookies.getAll();
+    // Set the modified cookies as fallbacks.
+    for (const cookie of modifiedCookieValues){
+        resCookies.set(cookie);
+    }
+    // Set the original cookies as the final values.
+    for (const cookie of returnedCookies){
+        resCookies.set(cookie);
+    }
+    return true;
+}
+class MutableRequestCookiesAdapter {
+    static wrap(cookies, onUpdateCookies) {
+        const responseCookies = new _cookies.ResponseCookies(new Headers());
+        for (const cookie of cookies.getAll()){
+            responseCookies.set(cookie);
+        }
+        let modifiedValues = [];
+        const modifiedCookies = new Set();
+        const updateResponseCookies = ()=>{
+            // TODO-APP: change method of getting workStore
+            const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+            if (workStore) {
+                workStore.pathWasRevalidated = _actionrevalidationkind.ActionDidRevalidateStaticAndDynamic;
+            }
+            const allCookies = responseCookies.getAll();
+            modifiedValues = allCookies.filter((c)=>modifiedCookies.has(c.name));
+            if (onUpdateCookies) {
+                const serializedCookies = [];
+                for (const cookie of modifiedValues){
+                    const tempCookies = new _cookies.ResponseCookies(new Headers());
+                    tempCookies.set(cookie);
+                    serializedCookies.push(tempCookies.toString());
+                }
+                onUpdateCookies(serializedCookies);
+            }
+        };
+        const wrappedCookies = new Proxy(responseCookies, {
+            get (target, prop, receiver) {
+                switch(prop){
+                    // A special symbol to get the modified cookie values
+                    case SYMBOL_MODIFY_COOKIE_VALUES:
+                        return modifiedValues;
+                    // TODO: Throw error if trying to set a cookie after the response
+                    // headers have been set.
+                    case 'delete':
+                        return function(...args) {
+                            modifiedCookies.add(typeof args[0] === 'string' ? args[0] : args[0].name);
+                            try {
+                                target.delete(...args);
+                                return wrappedCookies;
+                            } finally{
+                                updateResponseCookies();
+                            }
+                        };
+                    case 'set':
+                        return function(...args) {
+                            modifiedCookies.add(typeof args[0] === 'string' ? args[0] : args[0].name);
+                            try {
+                                target.set(...args);
+                                return wrappedCookies;
+                            } finally{
+                                updateResponseCookies();
+                            }
+                        };
+                    default:
+                        return _reflect.ReflectAdapter.get(target, prop, receiver);
+                }
+            }
+        });
+        return wrappedCookies;
+    }
+}
+function createCookiesWithMutableAccessCheck(requestStore) {
+    const wrappedCookies = new Proxy(requestStore.mutableCookies, {
+        get (target, prop, receiver) {
+            switch(prop){
+                case 'delete':
+                    return function(...args) {
+                        ensureCookiesAreStillMutable(requestStore, 'cookies().delete');
+                        target.delete(...args);
+                        return wrappedCookies;
+                    };
+                case 'set':
+                    return function(...args) {
+                        ensureCookiesAreStillMutable(requestStore, 'cookies().set');
+                        target.set(...args);
+                        return wrappedCookies;
+                    };
+                default:
+                    return _reflect.ReflectAdapter.get(target, prop, receiver);
+            }
+        }
+    });
+    return wrappedCookies;
+}
+function areCookiesMutableInCurrentPhase(requestStore) {
+    return requestStore.phase === 'action';
+}
+/** Ensure that cookies() starts throwing on mutation
+ * if we changed phases and can no longer mutate.
+ *
+ * This can happen when going:
+ *   'render' -> 'after'
+ *   'action' -> 'render'
+ * */ function ensureCookiesAreStillMutable(requestStore, _callingExpression) {
+    if (!areCookiesMutableInCurrentPhase(requestStore)) {
+        // TODO: maybe we can give a more precise error message based on callingExpression?
+        throw new ReadonlyRequestCookiesError();
+    }
+}
+function responseCookiesToRequestCookies(responseCookies) {
+    const requestCookies = new _cookies.RequestCookies(new Headers());
+    for (const cookie of responseCookies.getAll()){
+        requestCookies.set(cookie);
+    }
+    return requestCookies;
+}
+
+//# sourceMappingURL=request-cookies.js.map

package/.next/standalone/node_modules/next/dist/server/web/spec-extension/cookies.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    RequestCookies: null,
+    ResponseCookies: null,
+    stringifyCookie: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    RequestCookies: function() {
+        return _cookies.RequestCookies;
+    },
+    ResponseCookies: function() {
+        return _cookies.ResponseCookies;
+    },
+    stringifyCookie: function() {
+        return _cookies.stringifyCookie;
+    }
+});
+const _cookies = require("next/dist/compiled/@edge-runtime/cookies");
+
+//# sourceMappingURL=cookies.js.map

package/.next/standalone/node_modules/next/dist/server/web/spec-extension/fetch-event.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    NextFetchEvent: null,
+    getWaitUntilPromiseFromEvent: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    NextFetchEvent: function() {
+        return NextFetchEvent;
+    },
+    getWaitUntilPromiseFromEvent: function() {
+        return getWaitUntilPromiseFromEvent;
+    }
+});
+const _error = require("../error");
+const responseSymbol = Symbol('response');
+const passThroughSymbol = Symbol('passThrough');
+const waitUntilSymbol = Symbol('waitUntil');
+class FetchEvent {
+    constructor(_request, waitUntil){
+        this[passThroughSymbol] = false;
+        this[waitUntilSymbol] = waitUntil ? {
+            kind: 'external',
+            function: waitUntil
+        } : {
+            kind: 'internal',
+            promises: []
+        };
+    }
+    // TODO: is this dead code? NextFetchEvent never lets this get called
+    respondWith(response) {
+        if (!this[responseSymbol]) {
+            this[responseSymbol] = Promise.resolve(response);
+        }
+    }
+    // TODO: is this dead code? passThroughSymbol is unused
+    passThroughOnException() {
+        this[passThroughSymbol] = true;
+    }
+    waitUntil(promise) {
+        if (this[waitUntilSymbol].kind === 'external') {
+            // if we received an external waitUntil, we delegate to it
+            // TODO(after): this will make us not go through `getServerError(error, 'edge-server')` in `sandbox`
+            const waitUntil = this[waitUntilSymbol].function;
+            return waitUntil(promise);
+        } else {
+            // if we didn't receive an external waitUntil, we make it work on our own
+            // (and expect the caller to do something with the promises)
+            this[waitUntilSymbol].promises.push(promise);
+        }
+    }
+}
+function getWaitUntilPromiseFromEvent(event) {
+    return event[waitUntilSymbol].kind === 'internal' ? Promise.all(event[waitUntilSymbol].promises).then(()=>{}) : undefined;
+}
+class NextFetchEvent extends FetchEvent {
+    constructor(params){
+        var _params_context;
+        super(params.request, (_params_context = params.context) == null ? void 0 : _params_context.waitUntil);
+        this.sourcePage = params.page;
+    }
+    /**
+   * @deprecated The `request` is now the first parameter and the API is now async.
+   *
+   * Read more: https://nextjs.org/docs/messages/middleware-new-signature
+   */ get request() {
+        throw Object.defineProperty(new _error.PageSignatureError({
+            page: this.sourcePage
+        }), "__NEXT_ERROR_CODE", {
+            value: "E394",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    /**
+   * @deprecated Using `respondWith` is no longer needed.
+   *
+   * Read more: https://nextjs.org/docs/messages/middleware-new-signature
+   */ respondWith() {
+        throw Object.defineProperty(new _error.PageSignatureError({
+            page: this.sourcePage
+        }), "__NEXT_ERROR_CODE", {
+            value: "E394",
+            enumerable: false,
+            configurable: true
+        });
+    }
+}
+
+//# sourceMappingURL=fetch-event.js.map

package/.next/standalone/node_modules/next/dist/server/web/spec-extension/image-response.js

@@ -0,0 +1,22 @@
+/**
+ * @deprecated ImageResponse moved from "next/server" to "next/og" since Next.js 14, please import from "next/og" instead.
+ * Migration with codemods: https://nextjs.org/docs/app/building-your-application/upgrading/codemods#next-og-import
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ImageResponse", {
+    enumerable: true,
+    get: function() {
+        return ImageResponse;
+    }
+});
+function ImageResponse() {
+    throw Object.defineProperty(new Error('ImageResponse moved from "next/server" to "next/og" since Next.js 14, please import from "next/og" instead'), "__NEXT_ERROR_CODE", {
+        value: "E183",
+        enumerable: false,
+        configurable: true
+    });
+}
+
+//# sourceMappingURL=image-response.js.map

package/.next/standalone/node_modules/next/dist/server/web/spec-extension/request.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    INTERNALS: null,
+    NextRequest: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    INTERNALS: function() {
+        return INTERNALS;
+    },
+    NextRequest: function() {
+        return NextRequest;
+    }
+});
+const _nexturl = require("../next-url");
+const _utils = require("../utils");
+const _error = require("../error");
+const _cookies = require("./cookies");
+const INTERNALS = Symbol('internal request');
+class NextRequest extends Request {
+    constructor(input, init = {}){
+        const url = typeof input !== 'string' && 'url' in input ? input.url : String(input);
+        (0, _utils.validateURL)(url);
+        // node Request instance requires duplex option when a body
+        // is present or it errors, we don't handle this for
+        // Request being passed in since it would have already
+        // errored if this wasn't configured
+        if (process.env.NEXT_RUNTIME !== 'edge') {
+            if (init.body && init.duplex !== 'half') {
+                init.duplex = 'half';
+            }
+        }
+        if (input instanceof Request) super(input, init);
+        else super(url, init);
+        const nextUrl = new _nexturl.NextURL(url, {
+            headers: (0, _utils.toNodeOutgoingHttpHeaders)(this.headers),
+            nextConfig: init.nextConfig
+        });
+        this[INTERNALS] = {
+            cookies: new _cookies.RequestCookies(this.headers),
+            nextUrl,
+            url: process.env.__NEXT_NO_MIDDLEWARE_URL_NORMALIZE ? url : nextUrl.toString()
+        };
+    }
+    [Symbol.for('edge-runtime.inspect.custom')]() {
+        return {
+            cookies: this.cookies,
+            nextUrl: this.nextUrl,
+            url: this.url,
+            // rest of props come from Request
+            bodyUsed: this.bodyUsed,
+            cache: this.cache,
+            credentials: this.credentials,
+            destination: this.destination,
+            headers: Object.fromEntries(this.headers),
+            integrity: this.integrity,
+            keepalive: this.keepalive,
+            method: this.method,
+            mode: this.mode,
+            redirect: this.redirect,
+            referrer: this.referrer,
+            referrerPolicy: this.referrerPolicy,
+            signal: this.signal
+        };
+    }
+    get cookies() {
+        return this[INTERNALS].cookies;
+    }
+    get nextUrl() {
+        return this[INTERNALS].nextUrl;
+    }
+    /**
+   * @deprecated
+   * `page` has been deprecated in favour of `URLPattern`.
+   * Read more: https://nextjs.org/docs/messages/middleware-request-page
+   */ get page() {
+        throw new _error.RemovedPageError();
+    }
+    /**
+   * @deprecated
+   * `ua` has been removed in favour of \`userAgent\` function.
+   * Read more: https://nextjs.org/docs/messages/middleware-parse-user-agent
+   */ get ua() {
+        throw new _error.RemovedUAError();
+    }
+    get url() {
+        return this[INTERNALS].url;
+    }
+}
+
+//# sourceMappingURL=request.js.map

package/.next/standalone/node_modules/next/dist/server/web/spec-extension/response.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "NextResponse", {
+    enumerable: true,
+    get: function() {
+        return NextResponse;
+    }
+});
+const _cookies = require("../../web/spec-extension/cookies");
+const _nexturl = require("../next-url");
+const _utils = require("../utils");
+const _reflect = require("./adapters/reflect");
+const _cookies1 = require("./cookies");
+const INTERNALS = Symbol('internal response');
+const REDIRECTS = new Set([
+    301,
+    302,
+    303,
+    307,
+    308
+]);
+function handleMiddlewareField(init, headers) {
+    var _init_request;
+    if (init == null ? void 0 : (_init_request = init.request) == null ? void 0 : _init_request.headers) {
+        if (!(init.request.headers instanceof Headers)) {
+            throw Object.defineProperty(new Error('request.headers must be an instance of Headers'), "__NEXT_ERROR_CODE", {
+                value: "E119",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        const keys = [];
+        for (const [key, value] of init.request.headers){
+            headers.set('x-middleware-request-' + key, value);
+            keys.push(key);
+        }
+        headers.set('x-middleware-override-headers', keys.join(','));
+    }
+}
+class NextResponse extends Response {
+    constructor(body, init = {}){
+        super(body, init);
+        const headers = this.headers;
+        const cookies = new _cookies1.ResponseCookies(headers);
+        const cookiesProxy = new Proxy(cookies, {
+            get (target, prop, receiver) {
+                switch(prop){
+                    case 'delete':
+                    case 'set':
+                        {
+                            return (...args)=>{
+                                const result = Reflect.apply(target[prop], target, args);
+                                const newHeaders = new Headers(headers);
+                                if (result instanceof _cookies1.ResponseCookies) {
+                                    headers.set('x-middleware-set-cookie', result.getAll().map((cookie)=>(0, _cookies.stringifyCookie)(cookie)).join(','));
+                                }
+                                handleMiddlewareField(init, newHeaders);
+                                return result;
+                            };
+                        }
+                    default:
+                        return _reflect.ReflectAdapter.get(target, prop, receiver);
+                }
+            }
+        });
+        this[INTERNALS] = {
+            cookies: cookiesProxy,
+            url: init.url ? new _nexturl.NextURL(init.url, {
+                headers: (0, _utils.toNodeOutgoingHttpHeaders)(headers),
+                nextConfig: init.nextConfig
+            }) : undefined
+        };
+    }
+    [Symbol.for('edge-runtime.inspect.custom')]() {
+        return {
+            cookies: this.cookies,
+            url: this.url,
+            // rest of props come from Response
+            body: this.body,
+            bodyUsed: this.bodyUsed,
+            headers: Object.fromEntries(this.headers),
+            ok: this.ok,
+            redirected: this.redirected,
+            status: this.status,
+            statusText: this.statusText,
+            type: this.type
+        };
+    }
+    get cookies() {
+        return this[INTERNALS].cookies;
+    }
+    static json(body, init) {
+        const response = Response.json(body, init);
+        return new NextResponse(response.body, response);
+    }
+    static redirect(url, init) {
+        const status = typeof init === 'number' ? init : (init == null ? void 0 : init.status) ?? 307;
+        if (!REDIRECTS.has(status)) {
+            throw Object.defineProperty(new RangeError('Failed to execute "redirect" on "response": Invalid status code'), "__NEXT_ERROR_CODE", {
+                value: "E529",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        const initObj = typeof init === 'object' ? init : {};
+        const headers = new Headers(initObj == null ? void 0 : initObj.headers);
+        headers.set('Location', (0, _utils.validateURL)(url));
+        return new NextResponse(null, {
+            ...initObj,
+            headers,
+            status
+        });
+    }
+    static rewrite(destination, init) {
+        const headers = new Headers(init == null ? void 0 : init.headers);
+        headers.set('x-middleware-rewrite', (0, _utils.validateURL)(destination));
+        handleMiddlewareField(init, headers);
+        return new NextResponse(null, {
+            ...init,
+            headers
+        });
+    }
+    static next(init) {
+        const headers = new Headers(init == null ? void 0 : init.headers);
+        headers.set('x-middleware-next', '1');
+        handleMiddlewareField(init, headers);
+        return new NextResponse(null, {
+            ...init,
+            headers
+        });
+    }
+}
+
+//# sourceMappingURL=response.js.map