{"version":3,"sources":["../../../src/server/app-render/manifests-singleton.ts"],"sourcesContent":["import type { ActionManifest } from '../../build/webpack/plugins/flight-client-entry-plugin'\nimport type { ClientReferenceManifest } from '../../build/webpack/plugins/flight-manifest-plugin'\nimport type { DeepReadonly } from '../../shared/lib/deep-readonly'\nimport { InvariantError } from '../../shared/lib/invariant-error'\nimport { normalizeAppPath } from '../../shared/lib/router/utils/app-paths'\nimport { pathHasPrefix } from '../../shared/lib/router/utils/path-has-prefix'\nimport { removePathPrefix } from '../../shared/lib/router/utils/remove-path-prefix'\nimport { workAsyncStorage } from './work-async-storage.external'\n\nexport interface ServerModuleMap {\n  readonly [name: string]: {\n    readonly id: string | number\n    readonly name: string\n    readonly chunks: Readonly<Array<string>> // currently not used\n    readonly async?: boolean\n  }\n}\n\n// This is a global singleton that is, among other things, also used to\n// encode/decode bound args of server function closures. This can't be using a\n// AsyncLocalStorage as it might happen at the module level.\nconst MANIFESTS_SINGLETON = Symbol.for('next.server.manifests')\n\ninterface ManifestsSingleton {\n  readonly clientReferenceManifestsPerRoute: Map<\n    string,\n    DeepReadonly<ClientReferenceManifest>\n  >\n  readonly proxiedClientReferenceManifest: DeepReadonly<ClientReferenceManifest>\n  serverActionsManifest: DeepReadonly<ActionManifest>\n  serverModuleMap: ServerModuleMap\n}\n\ntype GlobalThisWithManifests = typeof globalThis & {\n  [MANIFESTS_SINGLETON]?: ManifestsSingleton\n}\n\ntype ClientReferenceManifestMappingProp =\n  | 'clientModules'\n  | 'rscModuleMapping'\n  | 'edgeRscModuleMapping'\n  | 'ssrModuleMapping'\n  | 'edgeSSRModuleMapping'\n\nconst globalThisWithManifests = globalThis as GlobalThisWithManifests\n\nfunction createProxiedClientReferenceManifest(\n  clientReferenceManifestsPerRoute: Map<\n    string,\n    DeepReadonly<ClientReferenceManifest>\n  >\n): DeepReadonly<ClientReferenceManifest> {\n  const createMappingProxy = (prop: ClientReferenceManifestMappingProp) => {\n    return new Proxy(\n      {},\n      {\n        get(_, id: string) {\n          const workStore = workAsyncStorage.getStore()\n\n          if (workStore) {\n            const currentManifest = clientReferenceManifestsPerRoute.get(\n              workStore.route\n            )\n\n            if (currentManifest?.[prop][id]) {\n              return currentManifest[prop][id]\n            }\n\n            // In development, we also check all other manifests to see if the\n            // module exists there. This is to support a scenario where React's\n            // I/O tracking (dev-only) creates a connection from one page to\n            // another through an emitted async I/O node that references client\n            // components from the other page, e.g. in owner props.\n            // TODO: Maybe we need to add a `debugBundlerConfig` option to React\n            // to avoid this workaround. The current workaround has the\n            // disadvantage that one might accidentally or intentionally share\n            // client references across pages (e.g. by storing them in a global\n            // variable), which would then only be caught in production.\n            if (process.env.NODE_ENV !== 'production') {\n              for (const [\n                route,\n                manifest,\n              ] of clientReferenceManifestsPerRoute) {\n                if (route === workStore.route) {\n                  continue\n                }\n\n                const entry = manifest[prop][id]\n\n                if (entry !== undefined) {\n                  return entry\n                }\n              }\n            }\n          } else {\n            // If there's no work store defined, we can assume that a client\n            // reference manifest is needed during module evaluation, e.g. to\n            // create a server function using a higher-order function. This\n            // might also use client components which need to be serialized by\n            // Flight, and therefore client references need to be resolvable. In\n            // that case we search all page manifests to find the module.\n            for (const manifest of clientReferenceManifestsPerRoute.values()) {\n              const entry = manifest[prop][id]\n\n              if (entry !== undefined) {\n                return entry\n              }\n            }\n          }\n\n          return undefined\n        },\n      }\n    )\n  }\n\n  const mappingProxies = new Map<\n    ClientReferenceManifestMappingProp,\n    ReturnType<typeof createMappingProxy>\n  >()\n\n  return new Proxy(\n    {},\n    {\n      get(_, prop) {\n        const workStore = workAsyncStorage.getStore()\n\n        switch (prop) {\n          case 'moduleLoading':\n          case 'entryCSSFiles':\n          case 'entryJSFiles': {\n            if (!workStore) {\n              throw new InvariantError(\n                `Cannot access \"${prop}\" without a work store.`\n              )\n            }\n\n            const currentManifest = clientReferenceManifestsPerRoute.get(\n              workStore.route\n            )\n\n            if (!currentManifest) {\n              throw new InvariantError(\n                `The client reference manifest for route \"${workStore.route}\" does not exist.`\n              )\n            }\n\n            return currentManifest[prop]\n          }\n          case 'clientModules':\n          case 'rscModuleMapping':\n          case 'edgeRscModuleMapping':\n          case 'ssrModuleMapping':\n          case 'edgeSSRModuleMapping': {\n            let proxy = mappingProxies.get(prop)\n\n            if (!proxy) {\n              proxy = createMappingProxy(prop)\n              mappingProxies.set(prop, proxy)\n            }\n\n            return proxy\n          }\n          default: {\n            throw new InvariantError(\n              `This is a proxied client reference manifest. The property \"${String(prop)}\" is not handled.`\n            )\n          }\n        }\n      },\n    }\n  ) as DeepReadonly<ClientReferenceManifest>\n}\n\n/**\n * This function creates a Flight-acceptable server module map proxy from our\n * Server Reference Manifest similar to our client module map. This is because\n * our manifest contains a lot of internal Next.js data that are relevant to the\n * runtime, workers, etc. that React doesn't need to know.\n */\nfunction createServerModuleMap(): ServerModuleMap {\n  return new Proxy(\n    {},\n    {\n      get: (_, id: string) => {\n        const workers =\n          getServerActionsManifest()[\n            process.env.NEXT_RUNTIME === 'edge' ? 'edge' : 'node'\n          ]?.[id]?.workers\n\n        if (!workers) {\n          return undefined\n        }\n\n        const workStore = workAsyncStorage.getStore()\n\n        let workerEntry:\n          | { moduleId: string | number; async: boolean }\n          | undefined\n\n        if (workStore) {\n          workerEntry = workers[normalizeWorkerPageName(workStore.page)]\n        } else {\n          // If there's no work store defined, we can assume that a server\n          // module map is needed during module evaluation, e.g. to create a\n          // server action using a higher-order function. Therefore it should be\n          // safe to return any entry from the manifest that matches the action\n          // ID. They all refer to the same module ID, which must also exist in\n          // the current page bundle. TODO: This is currently not guaranteed in\n          // Turbopack, and needs to be fixed.\n          workerEntry = Object.values(workers).at(0)\n        }\n\n        if (!workerEntry) {\n          return undefined\n        }\n\n        const { moduleId, async } = workerEntry\n\n        return { id: moduleId, name: id, chunks: [], async }\n      },\n    }\n  )\n}\n\n/**\n * The flight entry loader keys actions by bundlePath. bundlePath corresponds\n * with the relative path (including 'app') to the page entrypoint.\n */\nfunction normalizeWorkerPageName(pageName: string) {\n  if (pathHasPrefix(pageName, 'app')) {\n    return pageName\n  }\n\n  return 'app' + pageName\n}\n\n/**\n * Converts a bundlePath (relative path to the entrypoint) to a routable page\n * name.\n */\nfunction denormalizeWorkerPageName(bundlePath: string) {\n  return normalizeAppPath(removePathPrefix(bundlePath, 'app'))\n}\n\n/**\n * Checks if the requested action has a worker for the current page.\n * If not, it returns the first worker that has a handler for the action.\n */\nexport function selectWorkerForForwarding(\n  actionId: string,\n  pageName: string\n): string | undefined {\n  const serverActionsManifest = getServerActionsManifest()\n  const workers =\n    serverActionsManifest[\n      process.env.NEXT_RUNTIME === 'edge' ? 'edge' : 'node'\n    ][actionId]?.workers\n\n  // There are no workers to handle this action, nothing to forward to.\n  if (!workers) {\n    return\n  }\n\n  // If there is an entry for the current page, we don't need to forward.\n  if (workers[normalizeWorkerPageName(pageName)]) {\n    return\n  }\n\n  // Otherwise, grab the first worker that has a handler for this action id.\n  return denormalizeWorkerPageName(Object.keys(workers)[0])\n}\n\nexport function setManifestsSingleton({\n  page,\n  clientReferenceManifest,\n  serverActionsManifest,\n}: {\n  page: string\n  clientReferenceManifest: DeepReadonly<ClientReferenceManifest>\n  serverActionsManifest: DeepReadonly<ActionManifest>\n}) {\n  const existingSingleton = globalThisWithManifests[MANIFESTS_SINGLETON]\n\n  if (existingSingleton) {\n    existingSingleton.clientReferenceManifestsPerRoute.set(\n      normalizeAppPath(page),\n      clientReferenceManifest\n    )\n\n    existingSingleton.serverActionsManifest = serverActionsManifest\n  } else {\n    const clientReferenceManifestsPerRoute = new Map<\n      string,\n      DeepReadonly<ClientReferenceManifest>\n    >([[normalizeAppPath(page), clientReferenceManifest]])\n\n    const proxiedClientReferenceManifest = createProxiedClientReferenceManifest(\n      clientReferenceManifestsPerRoute\n    )\n\n    globalThisWithManifests[MANIFESTS_SINGLETON] = {\n      clientReferenceManifestsPerRoute,\n      proxiedClientReferenceManifest,\n      serverActionsManifest,\n      serverModuleMap: createServerModuleMap(),\n    }\n  }\n}\n\nfunction getManifestsSingleton(): ManifestsSingleton {\n  const manifestSingleton = globalThisWithManifests[MANIFESTS_SINGLETON]\n\n  if (!manifestSingleton) {\n    throw new InvariantError('The manifests singleton was not initialized.')\n  }\n\n  return manifestSingleton\n}\n\nexport function getClientReferenceManifest(): DeepReadonly<ClientReferenceManifest> {\n  return getManifestsSingleton().proxiedClientReferenceManifest\n}\n\nexport function getServerActionsManifest(): DeepReadonly<ActionManifest> {\n  return getManifestsSingleton().serverActionsManifest\n}\n\nexport function getServerModuleMap() {\n  return getManifestsSingleton().serverModuleMap\n}\n"],"names":["getClientReferenceManifest","getServerActionsManifest","getServerModuleMap","selectWorkerForForwarding","setManifestsSingleton","MANIFESTS_SINGLETON","Symbol","for","globalThisWithManifests","globalThis","createProxiedClientReferenceManifest","clientReferenceManifestsPerRoute","createMappingProxy","prop","Proxy","get","_","id","workStore","workAsyncStorage","getStore","currentManifest","route","process","env","NODE_ENV","manifest","entry","undefined","values","mappingProxies","Map","InvariantError","proxy","set","String","createServerModuleMap","workers","NEXT_RUNTIME","workerEntry","normalizeWorkerPageName","page","Object","at","moduleId","async","name","chunks","pageName","pathHasPrefix","denormalizeWorkerPageName","bundlePath","normalizeAppPath","removePathPrefix","actionId","serverActionsManifest","keys","clientReferenceManifest","existingSingleton","proxiedClientReferenceManifest","serverModuleMap","getManifestsSingleton","manifestSingleton"],"mappings":"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","ignoreList":[0]}