@claudeye/linux-arm64 1.0.6-beta.1 → 1.0.6-beta.3

package/assets/standalone/node_modules/next/dist/server/app-render/encryption.js

@@ -123,10 +123,25 @@ const encryptActionBoundArgs = _react.default.cache(async function encryptAction
             once: true
         });
     }
+    const prerenderResumeDataCache = workUnitStore ? (0, _workunitasyncstorageexternal.getPrerenderResumeDataCache)(workUnitStore) : null;
+    const renderResumeDataCache = workUnitStore ? (0, _workunitasyncstorageexternal.getRenderResumeDataCache)(workUnitStore) : null;
     // Using Flight to serialize the args into a string.
     const serialized = await (0, _nodewebstreamshelper.streamToString)((0, _server.renderToReadableStream)(args, clientModules, {
         filterStackFrame,
         signal: hangingInputAbortSignal,
+        debugChannel: // In Cache Components, we want to cache the encrypted result,
+        // and we use the unencrypted bound args as a cache key.
+        // In order to do that we need to strip debug info, because it
+        // contains timing information and thus changes each time we serialize the args.
+        // We can do this by piping debug info into a debug channel that throws it away.
+        //
+        // Note that this can result in dangling debug info references when we decode the bound args,
+        // but React ignores those as long as no debug channel is passed on the decode side, so it's fine:
+        // https://github.com/facebook/react/blob/bb8a76c6cc77ea2976d690ea09f5a1b3d9b1792a/packages/react-client/src/ReactFlightClient.js#L1711-L1729
+        // https://github.com/facebook/react/blob/bb8a76c6cc77ea2976d690ea09f5a1b3d9b1792a/packages/react-client/src/ReactFlightClient.js#L4005-L4025
+        process.env.NODE_ENV === 'development' && (prerenderResumeDataCache || renderResumeDataCache) ? {
+            writable: new WritableStream()
+        } : undefined,
         onError (err) {
             if (hangingInputAbortSignal == null ? void 0 : hangingInputAbortSignal.aborted) {
                 return;
@@ -160,8 +175,6 @@ const encryptActionBoundArgs = _react.default.cache(async function encryptAction
         return encodeActionBoundArg(actionId, serialized);
     }
     startReadOnce();
-    const prerenderResumeDataCache = (0, _workunitasyncstorageexternal.getPrerenderResumeDataCache)(workUnitStore);
-    const renderResumeDataCache = (0, _workunitasyncstorageexternal.getRenderResumeDataCache)(workUnitStore);
     const cacheKey = actionId + serialized;
     const cachedEncrypted = (prerenderResumeDataCache == null ? void 0 : prerenderResumeDataCache.encryptedBoundArgs.get(cacheKey)) ?? (renderResumeDataCache == null ? void 0 : renderResumeDataCache.encryptedBoundArgs.get(cacheKey));
     if (cachedEncrypted) {
@@ -209,12 +222,14 @@ async function decryptActionBoundArgs(actionId, encryptedPromise) {
                     }
                     break;
                 case 'prerender-client':
+                case 'validation-client':
                 case 'prerender-ppr':
                 case 'prerender-legacy':
                 case 'request':
                 case 'cache':
                 case 'private-cache':
                 case 'unstable-cache':
+                case 'generate-static-params':
                 case undefined:
                     return controller.close();
                 default:
@@ -223,6 +238,12 @@ async function decryptActionBoundArgs(actionId, encryptedPromise) {
         }
     }), {
         findSourceMapURL,
+        // NOTE: When we serialized the bound args, we may have used a dummy debug channel to strip debug info.
+        // In that case, it's important that we also *don't* pass a debug channel here, because that will make
+        // the Flight Client ignore the dangling references:
+        // https://github.com/facebook/react/blob/bb8a76c6cc77ea2976d690ea09f5a1b3d9b1792a/packages/react-client/src/ReactFlightClient.js#L1711-L1729
+        // https://github.com/facebook/react/blob/bb8a76c6cc77ea2976d690ea09f5a1b3d9b1792a/packages/react-client/src/ReactFlightClient.js#L4005-L4025
+        debugChannel: undefined,
         serverConsumerManifest: {
             // moduleLoading must be null because we don't want to trigger preloads of ClientReferences
             // to be added to the current execution. Instead, we'll wait for any ClientReference

package/assets/standalone/node_modules/next/dist/server/app-render/entry-base.js

@@ -8,7 +8,9 @@ Object.defineProperty(exports, "__esModule", {
     ClientSegmentRoot: null,
     Fragment: null,
     HTTPAccessFallbackBoundary: null,
+    InstantValidation: null,
     LayoutRouter: null,
+    LoadingBoundaryProvider: null,
     Postpone: null,
     RenderFromTemplateContext: null,
     RootLayoutBoundary: null,
@@ -16,6 +18,7 @@ Object.defineProperty(exports, "__esModule", {
     SegmentViewStateNode: null,
     actionAsyncStorage: null,
     captureOwnerStack: null,
+    collectPrefetchHints: null,
     collectSegmentData: null,
     createElement: null,
     createMetadataComponents: null,
@@ -57,9 +60,15 @@ _export(exports, {
     HTTPAccessFallbackBoundary: function() {
         return _errorboundary.HTTPAccessFallbackBoundary;
     },
+    InstantValidation: function() {
+        return InstantValidation;
+    },
     LayoutRouter: function() {
         return _layoutrouter.default;
     },
+    LoadingBoundaryProvider: function() {
+        return _layoutrouter.LoadingBoundaryProvider;
+    },
     Postpone: function() {
         return _postpone.Postpone;
     },
@@ -81,6 +90,9 @@ _export(exports, {
     captureOwnerStack: function() {
         return _react.captureOwnerStack;
     },
+    collectPrefetchHints: function() {
+        return _collectsegmentdata.collectPrefetchHints;
+    },
     collectSegmentData: function() {
         return _collectsegmentdata.collectSegmentData;
     },
@@ -148,7 +160,7 @@ _export(exports, {
 const _server = require("react-server-dom-webpack/server");
 const _static = require("react-server-dom-webpack/static");
 const _react = require("react");
-const _layoutrouter = /*#__PURE__*/ _interop_require_default(require("../../client/components/layout-router"));
+const _layoutrouter = /*#__PURE__*/ _interop_require_wildcard(require("../../client/components/layout-router"));
 const _renderfromtemplatecontext = /*#__PURE__*/ _interop_require_default(require("../../client/components/render-from-template-context"));
 const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
 const _workunitasyncstorageexternal = require("./work-unit-async-storage.external");
@@ -212,6 +224,13 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
+const InstantValidation = ()=>{
+    if (process.env.NEXT_RUNTIME !== 'edge' && process.env.__NEXT_CACHE_COMPONENTS) {
+        return require('./instant-validation/instant-validation');
+    } else {
+        return undefined;
+    }
+};
 let SegmentViewNode = ()=>null;
 let SegmentViewStateNode = ()=>null;
 if (process.env.NODE_ENV === 'development') {

package/assets/standalone/node_modules/next/dist/server/app-render/get-asset-query-string.js

@@ -20,8 +20,8 @@ function getAssetQueryString(ctx, addTimestamp) {
     if (shouldAddVersion) {
         qs += `?v=${ctx.requestTimestamp}`;
     }
-    if (ctx.renderOpts.deploymentId) {
-        qs += `${shouldAddVersion ? '&' : '?'}dpl=${ctx.renderOpts.deploymentId}`;
+    if (ctx.sharedContext.clientAssetToken) {
+        qs += `${shouldAddVersion ? '&' : '?'}dpl=${ctx.sharedContext.clientAssetToken}`;
     }
     return qs;
 }

package/assets/standalone/node_modules/next/dist/server/app-render/get-layer-assets.js

@@ -26,7 +26,7 @@ function getLayerAssets({ ctx, layoutOrPagePath, injectedCSS: injectedCSSWithCur
                 const fontFilename = preloadedFontFiles[i];
                 const ext = /\.(woff|woff2|eot|ttf|otf)$/.exec(fontFilename)[1];
                 const type = `font/${ext}`;
-                const href = `${ctx.assetPrefix}/_next/${(0, _encodeuripath.encodeURIPath)(fontFilename)}`;
+                const href = `${ctx.assetPrefix}/_next/${(0, _encodeuripath.encodeURIPath)(fontFilename)}${(0, _getassetquerystring.getAssetQueryString)(ctx, true)}`;
                 preloadCallbacks.push(()=>{
                     ctx.componentMod.preloadFont(href, type, ctx.renderOpts.crossOrigin, ctx.nonce);
                 });

package/assets/standalone/node_modules/next/dist/server/app-render/instant-validation/boundary-constants.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "INSTANT_VALIDATION_BOUNDARY_NAME", {
+    enumerable: true,
+    get: function() {
+        return INSTANT_VALIDATION_BOUNDARY_NAME;
+    }
+});
+const INSTANT_VALIDATION_BOUNDARY_NAME = '__next_instant_validation_boundary__';
+
+//# sourceMappingURL=boundary-constants.js.map

package/assets/standalone/node_modules/next/dist/server/app-render/instant-validation/boundary-impl.js

@@ -0,0 +1,103 @@
+/* eslint-disable @next/internal/no-ambiguous-jsx -- React Client */ // Do not put a "use client" directive here. Import this module via the shim in
+// `packages/next/src/client/components/instant-validation/boundary.tsx` instead.
+// 'use client'
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    InstantValidationBoundaryContext: null,
+    PlaceValidationBoundaryBelowThisLevel: null,
+    RenderValidationBoundaryAtThisLevel: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    InstantValidationBoundaryContext: function() {
+        return InstantValidationBoundaryContext;
+    },
+    PlaceValidationBoundaryBelowThisLevel: function() {
+        return PlaceValidationBoundaryBelowThisLevel;
+    },
+    RenderValidationBoundaryAtThisLevel: function() {
+        return RenderValidationBoundaryAtThisLevel;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _react = require("react");
+const _boundaryconstants = require("./boundary-constants");
+const _invarianterror = require("../../../shared/lib/invariant-error");
+const _workunitasyncstorageexternal = require("../work-unit-async-storage.external");
+if (typeof window !== 'undefined') {
+    throw Object.defineProperty(new _invarianterror.InvariantError('Instant validation boundaries should never appear in browser bundles.'), "__NEXT_ERROR_CODE", {
+        value: "E1117",
+        enumerable: false,
+        configurable: true
+    });
+}
+function getValidationBoundaryTracking() {
+    const store = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+    if (!store) return null;
+    switch(store.type){
+        case 'validation-client':
+            return store.boundaryState;
+        case 'prerender':
+        case 'prerender-client':
+        case 'prerender-ppr':
+        case 'prerender-legacy':
+        case 'prerender-runtime':
+        case 'request':
+        case 'cache':
+        case 'private-cache':
+        case 'unstable-cache':
+        case 'generate-static-params':
+            break;
+        default:
+            store;
+    }
+    return null;
+}
+// We use a namespace object to allow us to recover the name of the function
+// at runtime even when production bundling/minification is used.
+const NameSpace = {
+    [_boundaryconstants.INSTANT_VALIDATION_BOUNDARY_NAME]: function({ id, children }) {
+        // Track which boundaries we actually managed to render.
+        const state = getValidationBoundaryTracking();
+        if (state === null) {
+            throw Object.defineProperty(new _invarianterror.InvariantError('Missing boundary tracking state'), "__NEXT_ERROR_CODE", {
+                value: "E1060",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        state.renderedIds.add(id);
+        return children;
+    }
+};
+const InstantValidationBoundaryContext = /*#__PURE__*/ (0, _react.createContext)(null);
+function PlaceValidationBoundaryBelowThisLevel({ id, children }) {
+    return(// OuterLayoutRouter will see this and render a `RenderValidationBoundaryAtThisLevel`.
+    /*#__PURE__*/ (0, _jsxruntime.jsx)(InstantValidationBoundaryContext, {
+        value: id,
+        children: children
+    }));
+}
+function RenderValidationBoundaryAtThisLevel({ id, children }) {
+    // We got a boundaryId from the context. Clear the context so that the children don't render another boundary.
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(InstantValidationBoundary, {
+        id: id,
+        children: /*#__PURE__*/ (0, _jsxruntime.jsx)(InstantValidationBoundaryContext, {
+            value: null,
+            children: children
+        })
+    });
+}
+const InstantValidationBoundary = // We use slice(0) to trick the bundler into not inlining/minifying the function
+// so it retains the name inferred from the namespace object
+NameSpace[_boundaryconstants.INSTANT_VALIDATION_BOUNDARY_NAME.slice(0)];
+
+//# sourceMappingURL=boundary-impl.js.map

package/assets/standalone/node_modules/next/dist/server/app-render/instant-validation/boundary-tracking.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createValidationBoundaryTracking", {
+    enumerable: true,
+    get: function() {
+        return createValidationBoundaryTracking;
+    }
+});
+function createValidationBoundaryTracking() {
+    return {
+        expectedIds: new Set(),
+        renderedIds: new Set()
+    };
+}
+
+//# sourceMappingURL=boundary-tracking.js.map

package/assets/standalone/node_modules/next/dist/server/app-render/instant-validation/instant-config.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    anySegmentHasRuntimePrefetchEnabled: null,
+    anySegmentNeedsInstantValidationInBuild: null,
+    anySegmentNeedsInstantValidationInDev: null,
+    findSegmentsWithInstantConfig: null,
+    isPageAllowedToBlock: null,
+    resolveInstantConfigSamplesForPage: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    anySegmentHasRuntimePrefetchEnabled: function() {
+        return anySegmentHasRuntimePrefetchEnabled;
+    },
+    anySegmentNeedsInstantValidationInBuild: function() {
+        return anySegmentNeedsInstantValidationInBuild;
+    },
+    anySegmentNeedsInstantValidationInDev: function() {
+        return anySegmentNeedsInstantValidationInDev;
+    },
+    findSegmentsWithInstantConfig: function() {
+        return findSegmentsWithInstantConfig;
+    },
+    isPageAllowedToBlock: function() {
+        return isPageAllowedToBlock;
+    },
+    resolveInstantConfigSamplesForPage: function() {
+        return resolveInstantConfigSamplesForPage;
+    }
+});
+const _appdirmodule = require("../../lib/app-dir-module");
+const _parseloadertree = require("../../../shared/lib/router/utils/parse-loader-tree");
+const _workasyncstorageexternal = require("../work-async-storage.external");
+async function anySegmentHasRuntimePrefetchEnabled(tree) {
+    const { mod: layoutOrPageMod } = await (0, _appdirmodule.getLayoutOrPageModule)(tree);
+    // TODO(restart-on-cache-miss): Does this work correctly for client page/layout modules?
+    const instantConfig = layoutOrPageMod ? layoutOrPageMod.unstable_instant : undefined;
+    const hasRuntimePrefetch = instantConfig && typeof instantConfig === 'object' ? instantConfig.prefetch === 'runtime' : false;
+    if (hasRuntimePrefetch) {
+        return true;
+    }
+    const { parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(tree);
+    for(const parallelRouteKey in parallelRoutes){
+        const parallelRoute = parallelRoutes[parallelRouteKey];
+        const hasChildRuntimePrefetch = await anySegmentHasRuntimePrefetchEnabled(parallelRoute);
+        if (hasChildRuntimePrefetch) {
+            return true;
+        }
+    }
+    return false;
+}
+async function isPageAllowedToBlock(tree) {
+    const { mod: layoutOrPageMod } = await (0, _appdirmodule.getLayoutOrPageModule)(tree);
+    // TODO(restart-on-cache-miss): Does this work correctly for client page/layout modules?
+    const instantConfig = layoutOrPageMod ? layoutOrPageMod.unstable_instant : undefined;
+    // If we encounter a non-false instant config before a instant=false,
+    // the page isn't allowed to block. The config expresses a requirement for
+    // instant UI, so we should make sure that a static shell exists.
+    // (even if it'd use runtime prefetching for client navs)
+    if (instantConfig !== undefined) {
+        if (typeof instantConfig === 'object') {
+            return false;
+        } else if (instantConfig === false) {
+            return true;
+        }
+    }
+    const { parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(tree);
+    for(const parallelRouteKey in parallelRoutes){
+        const parallelRoute = parallelRoutes[parallelRouteKey];
+        const subtreeIsBlocking = await isPageAllowedToBlock(parallelRoute);
+        if (subtreeIsBlocking) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Checks if any segments in the loader tree have `instant` configs that need validating.
+ * NOTE: Client navigations call this multiple times, so we cache it.
+ * */ // Shared helper (not exported, not cached — called by the cached wrappers)
+async function anySegmentNeedsInstantValidation(rootTree, mode) {
+    const segments = await findSegmentsWithInstantConfig(rootTree);
+    // Check if there's any configs with `prefetch: 'static'` or `mode: 'instant'`.
+    // (If there's only `false`, there's no need to run validation).
+    // If any segment has `unstable_disableValidation`, we skip validation for the whole tree.
+    let needsValidation = false;
+    for (const { config } of segments){
+        if (typeof config === 'object') {
+            if (config.unstable_disableValidation === true || mode === 'dev' && config.unstable_disableDevValidation === true || mode === 'build' && config.unstable_disableBuildValidation === true) {
+                return false;
+            }
+            // do not short-circuit, some other segment might still have `unstable_disableValidation`
+            needsValidation = true;
+        }
+    }
+    return needsValidation;
+}
+const anySegmentNeedsInstantValidationInDev = cacheScopedToWorkStore(async (rootTree)=>anySegmentNeedsInstantValidation(rootTree, 'dev'));
+const anySegmentNeedsInstantValidationInBuild = cacheScopedToWorkStore(async (rootTree)=>anySegmentNeedsInstantValidation(rootTree, 'build'));
+const findSegmentsWithInstantConfig = cacheScopedToWorkStore(async (rootTree)=>{
+    const results = [];
+    async function visit(tree, path) {
+        const { mod: layoutOrPageMod } = await (0, _appdirmodule.getLayoutOrPageModule)(tree);
+        // TODO(restart-on-cache-miss): Does this work correctly for client page/layout modules?
+        const instantConfig = layoutOrPageMod ? layoutOrPageMod.unstable_instant : undefined;
+        if (instantConfig !== undefined) {
+            results.push({
+                path,
+                config: instantConfig
+            });
+        }
+        const { parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(tree);
+        for(const parallelRouteKey in parallelRoutes){
+            const childTree = parallelRoutes[parallelRouteKey];
+            await visit(childTree, [
+                ...path,
+                parallelRouteKey
+            ]);
+        }
+    }
+    await visit(rootTree, []);
+    return results;
+});
+const resolveInstantConfigSamplesForPage = async (tree)=>{
+    const { mod: layoutOrPageMod } = await (0, _appdirmodule.getLayoutOrPageModule)(tree);
+    const instantConfig = layoutOrPageMod ? layoutOrPageMod.unstable_instant : undefined;
+    let samples = null;
+    if (instantConfig !== undefined && typeof instantConfig === 'object' && instantConfig.samples) {
+        samples = instantConfig.samples;
+    }
+    // The samples from inner segments override samples from outer segments,
+    // i.e. a page overrides the samples from a layout.
+    // We do not perform any merging logic.
+    const { parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(tree);
+    for(const parallelRouteKey in parallelRoutes){
+        if (parallelRouteKey !== 'children') {
+            continue;
+        }
+        const childTree = parallelRoutes[parallelRouteKey];
+        const childSamples = await resolveInstantConfigSamplesForPage(childTree);
+        if (childSamples !== null) {
+            samples = childSamples;
+        }
+    }
+    return samples;
+};
+/**
+ * A simple cache wrapper for 1-argument functions.
+ * The cache will live as long as the current WorkStore,
+ * i.e. it's scoped to a single request.
+ */ function cacheScopedToWorkStore(func) {
+    const resultsPerWorkStore = new WeakMap();
+    return (arg)=>{
+        const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+        if (!workStore) {
+            // No caching.
+            return func(arg);
+        }
+        let results = resultsPerWorkStore.get(workStore);
+        if (results && results.has(arg)) {
+            return results.get(arg);
+        }
+        const result = func(arg);
+        if (!results) {
+            results = new WeakMap();
+            resultsPerWorkStore.set(workStore, results);
+        }
+        results.set(arg, result);
+        return result;
+    };
+}
+
+//# sourceMappingURL=instant-config.js.map

package/assets/standalone/node_modules/next/dist/server/app-render/instant-validation/instant-samples-client.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    expectCompleteParamsInClientValidation: null,
+    instrumentParamsForClientValidation: null,
+    instrumentSearchParamsForClientValidation: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    expectCompleteParamsInClientValidation: function() {
+        return expectCompleteParamsInClientValidation;
+    },
+    instrumentParamsForClientValidation: function() {
+        return instrumentParamsForClientValidation;
+    },
+    instrumentSearchParamsForClientValidation: function() {
+        return instrumentSearchParamsForClientValidation;
+    }
+});
+const _workunitasyncstorageexternal = require("../work-unit-async-storage.external");
+const _workasyncstorageexternal = require("../work-async-storage.external");
+const _instantsamples = require("./instant-samples");
+const _instantvalidationerror = require("./instant-validation-error");
+function instrumentParamsForClientValidation(underlyingParams) {
+    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+    if (workStore && workUnitStore) {
+        switch(workUnitStore.type){
+            case 'validation-client':
+                {
+                    if (workUnitStore.validationSamples) {
+                        const declaredKeys = new Set(Object.keys(workUnitStore.validationSamples.params ?? {}));
+                        return (0, _instantsamples.createExhaustiveParamsProxy)(underlyingParams, declaredKeys, workStore.route);
+                    }
+                    break;
+                }
+            case 'prerender-runtime':
+            case 'prerender-client':
+            case 'prerender-legacy':
+            case 'prerender-ppr':
+            case 'prerender':
+            case 'cache':
+            case 'request':
+            case 'private-cache':
+            case 'unstable-cache':
+            case 'generate-static-params':
+                break;
+            default:
+                workUnitStore;
+        }
+    }
+    return underlyingParams;
+}
+function expectCompleteParamsInClientValidation(expression) {
+    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+    if (workStore && workUnitStore) {
+        switch(workUnitStore.type){
+            case 'validation-client':
+                {
+                    if (workUnitStore.validationSamples) {
+                        const fallbackParams = workUnitStore.fallbackRouteParams;
+                        if (fallbackParams && fallbackParams.size > 0) {
+                            const missingParams = Array.from(fallbackParams.keys());
+                            (0, _instantsamples.trackMissingSampleErrorAndThrow)(Object.defineProperty(new _instantvalidationerror.InstantValidationError(`Route "${workStore.route}" called ${expression} but param${missingParams.length > 1 ? 's' : ''} ${missingParams.map((p)=>`"${p}"`).join(', ')} ${missingParams.length > 1 ? 'are' : 'is'} not defined in the \`samples\` of \`unstable_instant\`. ` + `${expression} requires all route params to be provided.`), "__NEXT_ERROR_CODE", {
+                                value: "E1109",
+                                enumerable: false,
+                                configurable: true
+                            }));
+                        }
+                    }
+                    break;
+                }
+            case 'prerender-runtime':
+            case 'prerender-client':
+            case 'prerender-legacy':
+            case 'prerender-ppr':
+            case 'prerender':
+            case 'cache':
+            case 'request':
+            case 'private-cache':
+            case 'unstable-cache':
+            case 'generate-static-params':
+                break;
+            default:
+                workUnitStore;
+        }
+    }
+}
+function instrumentSearchParamsForClientValidation(underlyingSearchParams) {
+    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+    if (workStore && workUnitStore) {
+        switch(workUnitStore.type){
+            case 'validation-client':
+                {
+                    if (workUnitStore.validationSamples) {
+                        const declaredKeys = new Set(Object.keys(workUnitStore.validationSamples.searchParams ?? {}));
+                        return (0, _instantsamples.createExhaustiveURLSearchParamsProxy)(underlyingSearchParams, declaredKeys, workStore.route);
+                    }
+                    break;
+                }
+            case 'prerender-runtime':
+            case 'prerender-client':
+            case 'prerender-legacy':
+            case 'prerender-ppr':
+            case 'prerender':
+            case 'cache':
+            case 'request':
+            case 'private-cache':
+            case 'unstable-cache':
+            case 'generate-static-params':
+                break;
+            default:
+                workUnitStore;
+        }
+    }
+    return underlyingSearchParams;
+}
+
+//# sourceMappingURL=instant-samples-client.js.map