"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
0 && (module.exports = {
    createServerModuleMap: null,
    getActionNotFoundError: null,
    getInvalidServerReferenceIdError: null,
    selectWorkerForForwarding: null
});
function _export(target, all) {
    for(var name in all)Object.defineProperty(target, name, {
        enumerable: true,
        get: all[name]
    });
}
_export(exports, {
    createServerModuleMap: function() {
        return createServerModuleMap;
    },
    getActionNotFoundError: function() {
        return getActionNotFoundError;
    },
    getInvalidServerReferenceIdError: function() {
        return getInvalidServerReferenceIdError;
    },
    selectWorkerForForwarding: function() {
        return selectWorkerForForwarding;
    }
});
const _apppaths = require("../../shared/lib/router/utils/app-paths");
const _pathhasprefix = require("../../shared/lib/router/utils/path-has-prefix");
const _removepathprefix = require("../../shared/lib/router/utils/remove-path-prefix");
const _serverreferenceinfo = require("../../shared/lib/server-reference-info");
const _reflectutils = require("../../shared/lib/utils/reflect-utils");
const _workasyncstorageexternal = require("./work-async-storage.external");
function getActionNotFoundError(actionId) {
    return Object.defineProperty(new Error(`Failed to find Server Action${actionId ? ` "${actionId}"` : ''}. This request might be from an older or newer deployment.\nRead more: https://nextjs.org/docs/messages/failed-to-find-server-action`), "__NEXT_ERROR_CODE", {
        value: "E788",
        enumerable: false,
        configurable: true
    });
}
function getInvalidServerReferenceIdError(id) {
    // `id` is arbitrary client-provided input. Unlike the not-found case, it has
    // not passed the length gate and can reach this error via a malformed server
    // reference in an action payload, so it may be of any length and contain
    // control characters. `JSON.stringify` escapes newlines and quotes so it
    // can't forge log lines, and truncating overly long ids prevents log
    // flooding. Ids at or below the cap are logged in full so that we only add an
    // ellipsis to ids that are meaningfully longer than the truncated length.
    const encoded = JSON.stringify(id.length > MAX_LOGGED_SERVER_REFERENCE_ID_LENGTH ? id.slice(0, TRUNCATED_SERVER_REFERENCE_ID_LENGTH) + '…' : id);
    return Object.defineProperty(new Error(`The Server Reference ID did not match the expected format. Received ${encoded}.\nRead more: https://nextjs.org/docs/messages/failed-to-find-server-action`), "__NEXT_ERROR_CODE", {
        value: "E793",
        enumerable: false,
        configurable: true
    });
}
// Ids at or below the cap are logged in full. Longer ids are truncated to the
// shorter length and marked with an ellipsis, so the cap leaves headroom over
// the truncated length rather than ellipsizing ids that are barely too long.
const MAX_LOGGED_SERVER_REFERENCE_ID_LENGTH = 100;
const TRUNCATED_SERVER_REFERENCE_ID_LENGTH = 90;
function createServerModuleMap({ serverActionsManifest }) {
    return new Proxy(Object.create(null), {
        get: (target, id, receiver)=>{
            var _serverActionsManifest__id, _serverActionsManifest_;
            // React's debug serialization can probe the module map like a plain object.
            // These probes are not server reference lookups.
            if (typeof id !== 'string') {
                return Reflect.get(target, id, receiver);
            }
            if (_reflectutils.wellKnownProperties.has(id)) {
                return Reflect.get(target, id, receiver);
            }
            if (!(0, _serverreferenceinfo.mightBeServerReferenceId)(id)) {
                throw getInvalidServerReferenceIdError(id);
            }
            const workers = (_serverActionsManifest_ = serverActionsManifest[process.env.NEXT_RUNTIME === 'edge' ? 'edge' : 'node']) == null ? void 0 : (_serverActionsManifest__id = _serverActionsManifest_[id]) == null ? void 0 : _serverActionsManifest__id.workers;
            if (!workers) {
                throw getActionNotFoundError(id);
            }
            const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
            let workerEntry;
            if (workStore) {
                workerEntry = workers[normalizeWorkerPageName(workStore.page)];
            } else {
                // If there's no work store defined, we can assume that a server
                // module map is needed during module evaluation, e.g. to create a
                // server action using a higher-order function. Therefore it should be
                // safe to return any entry from the manifest that matches the action
                // ID. They all refer to the same module ID, which must also exist in
                // the current page bundle. TODO: This is currently not guaranteed in
                // Turbopack, and needs to be fixed.
                workerEntry = Object.values(workers).at(0);
            }
            if (!workerEntry) {
                throw getActionNotFoundError(id);
            }
            const { moduleId, async } = workerEntry;
            return {
                id: moduleId,
                name: id,
                chunks: [],
                async
            };
        }
    });
}
function selectWorkerForForwarding(actionId, pageName, serverActionsManifest) {
    var _serverActionsManifest__actionId;
    const workers = (_serverActionsManifest__actionId = serverActionsManifest[process.env.NEXT_RUNTIME === 'edge' ? 'edge' : 'node'][actionId]) == null ? void 0 : _serverActionsManifest__actionId.workers;
    const workerName = normalizeWorkerPageName(pageName);
    // no workers, nothing to forward to
    if (!workers) return;
    // if there is a worker for this page, no need to forward it.
    if (workers[workerName]) {
        return;
    }
    // otherwise, grab the first worker that has a handler for this action id
    return denormalizeWorkerPageName(Object.keys(workers)[0]);
}
/**
 * The flight entry loader keys actions by bundlePath.
 * bundlePath corresponds with the relative path (including 'app') to the page entrypoint.
 */ function normalizeWorkerPageName(pageName) {
    if ((0, _pathhasprefix.pathHasPrefix)(pageName, 'app')) {
        return pageName;
    }
    return 'app' + pageName;
}
/**
 * Converts a bundlePath (relative path to the entrypoint) to a routable page name
 */ function denormalizeWorkerPageName(bundlePath) {
    return (0, _apppaths.normalizeAppPath)((0, _removepathprefix.removePathPrefix)(bundlePath, 'app'));
}

//# sourceMappingURL=action-utils.js.map