@wular/coder 0.4.2 → 0.4.4

package/dist/dash/standalone/node_modules/@wular/pnext/dist/server/_chunks/index-he6n2bvp.js

@@ -0,0 +1,1270 @@
+// @bun
+import {
+  actionId,
+  inlineUseServerFunctions,
+  moduleLevelUseServer,
+  workspaceRelative
+} from "./index-6q7zvrap.js";
+import {
+  isTaggedPrimitiveThrow,
+  tagPrimitiveThrow,
+  untagPrimitiveThrow
+} from "./index-79ngvam8.js";
+import {
+  revalidationEventCount
+} from "./index-akkrvjn6.js";
+import {
+  getNextConfig,
+  nextConfigReleased
+} from "./index-m63czgq5.js";
+import {
+  pathToFileHref
+} from "./index-71885zaq.js";
+import {
+  runWithRequest,
+  setPhase
+} from "./index-grta8ap3.js";
+
+// src/compat/actions/config.ts
+import { existsSync } from "fs";
+import { createRequire } from "module";
+import path from "path";
+
+// src/compat/actions/endpoint.ts
+import { isNotFoundError, isRedirectError } from "../../../src/api/navigation.ts";
+import { toNextRequest } from "../../../src/api/server.ts";
+
+// src/compat/lifecycle/error-serialize.ts
+var REDACTED_MESSAGE = "Minified React error #441; visit https://react.dev/errors/441 for the full message or use the non-minified dev environment for full errors and additional helpful warnings.";
+function stableDigest(input) {
+  let hash = 5381;
+  for (let i = 0;i < input.length; i++) {
+    hash = hash * 33 ^ input.charCodeAt(i);
+  }
+  return (hash >>> 0).toString();
+}
+function customDigest(error) {
+  const digest = error.digest;
+  return typeof digest === "string" && digest.length > 0 ? digest : undefined;
+}
+function digestSuffix(error) {
+  if (!isTaggedPrimitiveThrow(error))
+    return "";
+  const raw = untagPrimitiveThrow(error);
+  return raw === null || raw === undefined ? "@E394" : "";
+}
+function wrapThrownValue(value) {
+  const error = tagPrimitiveThrow(value);
+  error.stack = `Error: ${error.message}
+    at stringify (<anonymous>)`;
+  return error;
+}
+function formatErrorLog(trace, digest, error) {
+  const environmentName = error?.environmentName;
+  const environment = typeof environmentName === "string" ? `  environmentName: '${environmentName}',
+` : "";
+  return `\u2A2F ${trace} {
+${environment}  digest: '${digest}'
+}`;
+}
+function serializeBoundaryError(ctx) {
+  const { error, dev } = ctx;
+  const custom = customDigest(error);
+  const digest = custom ?? stableDigest(`${error.message}${error.stack ?? ""}`) + digestSuffix(error);
+  const boundaryError = new Error(dev ? error.message : REDACTED_MESSAGE);
+  boundaryError.name = error.name || "Error";
+  boundaryError.digest = digest;
+  boundaryError.stack = undefined;
+  return boundaryError;
+}
+
+// src/compat/actions/registry.ts
+var registry = new Map;
+function registerActionModule(filePath, exportNames, options = {}) {
+  const modulePath = options.modulePath ?? filePath;
+  const entries = [];
+  for (const exportName of exportNames) {
+    const id = actionId(filePath, exportName, options.root);
+    const entry = { id, modulePath, exportName, filePath };
+    registry.set(id, entry);
+    entries.push(entry);
+  }
+  return entries;
+}
+function lookupAction(id) {
+  const entry = registry.get(id);
+  if (!entry)
+    return;
+  return { modulePath: entry.modulePath, exportName: entry.exportName };
+}
+function lookupActionSource(id) {
+  return registry.get(id)?.filePath;
+}
+function clearActions() {
+  registry.clear();
+}
+
+// src/compat/actions/instances.ts
+import { createHash } from "crypto";
+var instances = new Map;
+function createInstanceScope(routeId) {
+  return { routeId, counts: new Map };
+}
+function registerActionInstance(scope, fn) {
+  const callable = fn;
+  const hash = sourceHash(callable);
+  const index = scope.counts.get(hash) ?? 0;
+  scope.counts.set(hash, index + 1);
+  const id = `i:${scope.routeId}:${hash}:${index}`;
+  instances.set(id, callable);
+  return id;
+}
+function lookupActionInstance(id) {
+  return instances.get(id);
+}
+function isInstanceActionId(id) {
+  return id.startsWith("i:");
+}
+function instanceActionRouteId(id) {
+  if (!isInstanceActionId(id))
+    return;
+  const parts = id.split(":");
+  if (parts.length < 4)
+    return;
+  return parts.slice(1, -2).join(":");
+}
+globalThis.__pnextMarkInlineAction = (fn) => {
+  if (typeof fn === "function")
+    fn.$$pnextInlineAction = true;
+  return fn;
+};
+function isMarkedInlineAction(fn) {
+  return typeof fn === "function" && fn.$$pnextInlineAction === true;
+}
+globalThis.__pnextTagInlineAction = (fn, id) => {
+  if (typeof fn !== "function")
+    return;
+  const tagged = fn;
+  instances.set(id, tagged);
+  tagged.$$pnextAssignedId = id;
+  if (!("$$id" in tagged)) {
+    Object.defineProperty(tagged, "$$id", { value: id, configurable: true, writable: true });
+  }
+};
+function overriddenActionId(fn) {
+  if (typeof fn !== "function")
+    return;
+  const tagged = fn;
+  if (typeof tagged.$$id === "string" && tagged.$$id !== tagged.$$pnextAssignedId) {
+    return tagged.$$id;
+  }
+  return;
+}
+function assignedInlineActionId(fn) {
+  if (typeof fn !== "function")
+    return;
+  const tagged = fn;
+  return typeof tagged.$$pnextAssignedId === "string" ? tagged.$$pnextAssignedId : undefined;
+}
+function sourceHash(fn) {
+  let source = "";
+  try {
+    source = String(fn);
+  } catch {
+    source = "opaque";
+  }
+  return createHash("sha256").update(source).digest("hex").slice(0, 10);
+}
+
+// src/compat/actions/rewrite.ts
+function rewriteInlineActionTags(source, file, root) {
+  if (!source.includes("use server"))
+    return source;
+  if (moduleLevelUseServer(source))
+    return source;
+  const topLevel = inlineUseServerFunctions(source).filter((action) => action.start === 0 || source[action.start - 1] === `
+`);
+  if (topLevel.length === 0)
+    return source;
+  const key = workspaceRelative(file, root);
+  const insertions = [];
+  const fallbacks = [];
+  for (const action of topLevel) {
+    if (source.includes(`__pnextTagInlineAction(${action.name},`))
+      continue;
+    const id = inlineActionId(key, action.name);
+    const tag = `
+;typeof ${action.name} === 'function' && globalThis.__pnextTagInlineAction && globalThis.__pnextTagInlineAction(${action.name}, ${JSON.stringify(id)});`;
+    const at = declarationEnd(source, action.directiveEnd);
+    if (at === undefined)
+      fallbacks.push(tag);
+    else
+      insertions.push({ at, text: tag });
+  }
+  let out = source;
+  for (const { at, text } of insertions.sort((a, b) => b.at - a.at)) {
+    out = out.slice(0, at) + text + out.slice(at);
+  }
+  if (fallbacks.length > 0)
+    out = `${out}
+${fallbacks.join(`
+`)}
+`;
+  return out;
+}
+function rewriteAnonymousInlineActionMarks(source) {
+  if (!source.includes("use server"))
+    return source;
+  if (moduleLevelUseServer(source))
+    return source;
+  const wraps = anonymousInlineActionSpans(source);
+  if (wraps.length === 0)
+    return source;
+  let out = source;
+  for (const { start, end } of wraps.sort((a, b) => b.start - a.start)) {
+    const fn = out.slice(start, end);
+    out = `${out.slice(0, start)}(globalThis.__pnextMarkInlineAction ? globalThis.__pnextMarkInlineAction(${fn}) : ${fn})${out.slice(end)}`;
+  }
+  return out;
+}
+function anonymousInlineActionSpans(source) {
+  const directive = /\{\s*(['"])use server\1\s*;?/g;
+  const spans = [];
+  for (let match;match = directive.exec(source); ) {
+    const start = functionExpressionStart(source, match.index);
+    if (start === undefined)
+      continue;
+    const end = bodyEnd(source, match.index);
+    if (end === undefined)
+      continue;
+    spans.push({ start, end, directiveEnd: match.index + match[0].length });
+  }
+  return spans;
+}
+function functionExpressionStart(source, open) {
+  let i = skipBackWhitespace(source, open - 1);
+  if (source[i] === ">" && source[i - 1] === "=") {
+    i = skipBackWhitespace(source, i - 2);
+    const head = source[i] === ")" ? matchingOpenParen(source, i) : identifierStart(source, i);
+    if (head === undefined)
+      return;
+    i = head;
+  } else if (source[i] === ")") {
+    const paren = matchingOpenParen(source, i);
+    if (paren === undefined)
+      return;
+    let j = skipBackWhitespace(source, paren - 1);
+    const name = identifierStart(source, j);
+    if (name === undefined)
+      return;
+    if (source.slice(name, j + 1) !== "function") {
+      j = skipBackWhitespace(source, name - 1);
+      const keyword = identifierStart(source, j);
+      if (keyword === undefined || source.slice(keyword, j + 1) !== "function")
+        return;
+      i = keyword;
+    } else {
+      i = name;
+    }
+  } else {
+    return;
+  }
+  const withAsync = precedingKeyword(source, i, "async");
+  if (withAsync !== undefined)
+    i = withAsync;
+  const before = skipBackWhitespace(source, i - 1);
+  if (before < 0)
+    return;
+  if (source[before] === "{")
+    return isJsxExpressionContainer(source, before) ? i : undefined;
+  return "(,:[=?&|".includes(source[before] ?? "") ? i : undefined;
+}
+function isJsxExpressionContainer(source, open) {
+  const before = skipBackWhitespace(source, open - 1);
+  if (before < 0)
+    return false;
+  const ch = source[before];
+  if (source[before - 1] === "=")
+    return false;
+  return ch === "=" || ch === ">";
+}
+function skipBackWhitespace(source, from) {
+  let i = from;
+  while (i >= 0 && /\s/.test(source[i] ?? ""))
+    i--;
+  return i;
+}
+function identifierStart(source, end) {
+  if (!/[\w$]/.test(source[end] ?? ""))
+    return;
+  let i = end;
+  while (i >= 0 && /[\w$]/.test(source[i] ?? ""))
+    i--;
+  return i + 1;
+}
+function matchingOpenParen(source, close) {
+  let depth = 0;
+  for (let i = close;i >= 0; i--) {
+    if (source[i] === ")")
+      depth++;
+    else if (source[i] === "(") {
+      depth--;
+      if (depth === 0)
+        return i;
+    }
+  }
+  return;
+}
+function precedingKeyword(source, at, keyword) {
+  const end = skipBackWhitespace(source, at - 1);
+  const start = identifierStart(source, end);
+  if (start === undefined || source.slice(start, end + 1) !== keyword)
+    return;
+  return start;
+}
+function bodyEnd(source, open) {
+  const end = declarationEnd(source, open + 1);
+  if (end === undefined)
+    return;
+  return source[end - 1] === ";" ? end - 1 : end;
+}
+function declarationEnd(source, directiveEnd) {
+  let open = -1;
+  for (let i = directiveEnd - 1;i >= 0; i--) {
+    if (source[i] === "{") {
+      open = i;
+      break;
+    }
+  }
+  if (open === -1)
+    return;
+  let depth = 0;
+  for (let i = open;i < source.length; i++) {
+    const ch = source[i];
+    if (ch === '"' || ch === "'" || ch === "`") {
+      i = skipString(source, i, ch);
+      continue;
+    }
+    if (ch === "/" && source[i + 1] === "/") {
+      const nl = source.indexOf(`
+`, i + 2);
+      if (nl === -1)
+        return;
+      i = nl;
+      continue;
+    }
+    if (ch === "/" && source[i + 1] === "*") {
+      const end = source.indexOf("*/", i + 2);
+      if (end === -1)
+        return;
+      i = end + 1;
+      continue;
+    }
+    if (ch === "{")
+      depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0) {
+        let end = i + 1;
+        if (source[end] === ";")
+          end += 1;
+        return end;
+      }
+    }
+  }
+  return;
+}
+function skipString(source, i, quote) {
+  for (let j = i + 1;j < source.length; j++) {
+    const ch = source[j];
+    if (ch === "\\") {
+      j += 1;
+      continue;
+    }
+    if (ch === quote)
+      return j;
+    if (quote === "`" && ch === "$" && source[j + 1] === "{") {
+      let depth = 1;
+      j += 2;
+      while (j < source.length && depth > 0) {
+        if (source[j] === "{")
+          depth++;
+        else if (source[j] === "}")
+          depth--;
+        j++;
+      }
+      j -= 1;
+    }
+  }
+  return source.length;
+}
+function inlineActionId(fileKey, name) {
+  return `if:${encodeURIComponent(fileKey)}:${encodeURIComponent(name)}`;
+}
+function inlineActionModuleKey(id) {
+  if (!id.startsWith("if:"))
+    return;
+  const rest = id.slice(3);
+  const separator = rest.lastIndexOf(":");
+  if (separator === -1)
+    return;
+  try {
+    return decodeURIComponent(rest.slice(0, separator));
+  } catch {
+    return;
+  }
+}
+function isInlineActionId(id) {
+  return id.startsWith("if:");
+}
+
+// src/compat/actions/return.ts
+var TEMP_REF_MARKER = "$$pnext_temp_ref";
+var ACTION_ELEMENT_MARKER = "$$pnext_element";
+var ACTION_ELEMENT_HTML_MARKER = "$$pnext_element_html";
+var clientReferenceSymbol = Symbol.for("pnext.clientReference");
+var ACTION_STREAM_CONTENT_TYPE = "x-component/pnext-stream";
+function createTempRefScope() {
+  const ids = new WeakMap;
+  let active = false;
+  return {
+    track(object, id) {
+      ids.set(object, id);
+      active = true;
+    },
+    idFor(value) {
+      if (value === null || typeof value !== "object")
+        return;
+      return ids.get(value);
+    },
+    get active() {
+      return active;
+    }
+  };
+}
+function extractTempRefs(value, scope, seen = new Set) {
+  if (value === null || typeof value !== "object")
+    return value;
+  if (seen.has(value))
+    return value;
+  seen.add(value);
+  if (Array.isArray(value)) {
+    for (let i = 0;i < value.length; i++)
+      value[i] = extractTempRefs(value[i], scope, seen);
+    return value;
+  }
+  const record = value;
+  const id = record[TEMP_REF_MARKER];
+  if (typeof id === "string") {
+    delete record[TEMP_REF_MARKER];
+    scope.track(record, id);
+  }
+  for (const key of Object.keys(record)) {
+    record[key] = extractTempRefs(record[key], scope, seen);
+  }
+  return record;
+}
+async function serializeReturnWithTempRefs(value, scope, renderElement) {
+  const walk = async (input, seen) => {
+    if (input === null || typeof input !== "object")
+      return input;
+    const marker = scope.active ? scope.idFor(input) : undefined;
+    if (marker !== undefined)
+      return { [TEMP_REF_MARKER]: marker };
+    if (seen.has(input))
+      return input;
+    seen.add(input);
+    const element = clientReferenceElement(input);
+    if (element) {
+      return {
+        [ACTION_ELEMENT_MARKER]: {
+          id: element.id,
+          props: await walk(element.props, seen),
+          ...element.key !== undefined ? { key: element.key } : {}
+        }
+      };
+    }
+    if (renderElement && isServerElement(input)) {
+      return { [ACTION_ELEMENT_HTML_MARKER]: await renderElement(input) };
+    }
+    if (Array.isArray(input))
+      return Promise.all(input.map((item) => walk(item, seen)));
+    const proto = Object.getPrototypeOf(input);
+    if (proto !== Object.prototype && proto !== null)
+      return input;
+    const out = {};
+    for (const [key, item] of Object.entries(input)) {
+      out[key] = await walk(item, seen);
+    }
+    return out;
+  };
+  return walk(value, new Set);
+}
+function isServerElement(value) {
+  const vnode = value;
+  if (!("type" in vnode) || !("props" in vnode))
+    return false;
+  if (vnode.$$typeof === Symbol.for("react.element"))
+    return true;
+  return Object.prototype.hasOwnProperty.call(value, "constructor") && value.constructor === undefined;
+}
+function clientReferenceElement(value) {
+  const vnode = value;
+  if (typeof vnode.type !== "function")
+    return;
+  const reference = vnode.type[clientReferenceSymbol];
+  if (typeof reference?.id !== "string")
+    return;
+  const key = typeof vnode.key === "string" || typeof vnode.key === "number" ? vnode.key : undefined;
+  return { id: reference.id, props: vnode.props ?? {}, ...key !== undefined ? { key } : {} };
+}
+function isReadableStreamReturn(value) {
+  return typeof ReadableStream !== "undefined" && value instanceof ReadableStream;
+}
+
+// src/compat/actions/protocol.ts
+var ACTION_ID_HEADER = "next-action";
+var ACTION_REDIRECT_HEADER = "x-action-redirect";
+var ACTION_REFRESH_HEADER = "x-pnext-action-refresh";
+var NEXT_ACTION_REVALIDATED_HEADER = "x-action-revalidated";
+var ACTION_NOT_FOUND_HEADER = "x-pnext-action-not-found";
+var NEXT_ACTION_NOT_FOUND_HEADER = "x-nextjs-action-not-found";
+var REDIRECT_TYPE_HEADER = "x-pnext-redirect-type";
+var ACTION_ERROR_DIGEST_HEADER = "x-pnext-action-error-digest";
+var ARG_ACTION_MARKER = "$$pnext_action_ref";
+var ACTION_ID_FIELD = "$pnext_action_id";
+var SUBMIT_ACTION_ID_FIELD = "$pnext_submit_action_id";
+var ACTION_ARGS_FIELD = "$pnext_args";
+var FORM_STATE_FIELD = "$pnext_form_state";
+var ARG_FORMDATA_MARKER = "$$pnext_fd";
+var ARG_FILE_MARKER = "$$pnext_file";
+var ARG_FORMDATA_PREFIX = "$pnext_fd_";
+var ARG_FILE_PREFIX = "$pnext_file_";
+var PROP_ACTION_MARKER = "$$pnextAction";
+var MAX_ACTION_ARGS = 1000;
+function tooManyArgsMessage(count) {
+  return `Server Action arguments list is too long (${count}). Maximum allowed is ${MAX_ACTION_ARGS}.`;
+}
+var MASKED_ACTION_ERROR = "Minified React error #441; visit https://react.dev/errors/441 for the full message or use the non-minified dev environment for full errors and additional helpful warnings.";
+
+// src/compat/actions/endpoint.ts
+var DEFAULT_BODY_LIMIT_BYTES = 1024 * 1024;
+function installServerActionDispatch(importModule) {
+  globalThis.__PNEXT_SERVER_ACTIONS__ = {
+    async call(dispatchId, dispatchArgs) {
+      const target = lookupAction(dispatchId);
+      if (!target) {
+        throw new Error(`Failed to find Server Action "${dispatchId}". This request might be from an older or newer deployment.`);
+      }
+      const module = await importModule(target.modulePath);
+      const fn = module[target.exportName];
+      if (typeof fn !== "function") {
+        throw new Error(`Failed to find Server Action "${dispatchId}".`);
+      }
+      return fn(...dispatchArgs);
+    }
+  };
+}
+async function runAction(request, options) {
+  const id = request.headers.get(ACTION_ID_HEADER);
+  if (!id) {
+    return errorResponse(`Missing ${ACTION_ID_HEADER} header`, 400);
+  }
+  installServerActionDispatch(options.importModule);
+  let action;
+  try {
+    action = await resolveAction(id, request, options);
+  } catch (error) {
+    console.error(error);
+    action = undefined;
+  }
+  if (!action) {
+    console.error(`Failed to find Server Action "${id}". This request might be from an older or newer deployment.
+` + "Read more: https://nextjs.org/docs/messages/failed-to-find-server-action");
+    return new Response(`Server Action "${id}" was not found on the server.`, {
+      status: 404,
+      headers: {
+        "content-type": "text/plain; charset=utf-8",
+        [NEXT_ACTION_NOT_FOUND_HEADER]: "1"
+      }
+    });
+  }
+  const limit = options.maxBodyBytes ?? DEFAULT_BODY_LIMIT_BYTES;
+  let args;
+  try {
+    args = await decodeArgs(request, limit);
+  } catch (error) {
+    if (error instanceof BodyLimitError) {
+      console.error(`Error: ${error.message}`);
+      console.error("To configure the body size limit for Server Actions, see: https://nextjs.org/docs/app/api-reference/next-config-js/serverActions#bodysizelimit");
+      return errorResponse(options.dev ? error.message : MASKED_ACTION_ERROR, 500);
+    }
+    return errorResponse(`Invalid action payload: ${messageOf(error)}`, 400);
+  }
+  try {
+    args = await reviveActionRefs(args, (id2) => resolveAction(id2, request, options));
+  } catch (error) {
+    if (error instanceof UnknownActionReferenceError) {
+      return errorResponse(error.message, 404);
+    }
+    return errorResponse(`Invalid action payload: ${messageOf(error)}`, 400);
+  }
+  if (args.length > MAX_ACTION_ARGS) {
+    const message = tooManyArgsMessage(args.length);
+    console.error(`Error: ${message}`);
+    return errorResponse(options.dev ? message : MASKED_ACTION_ERROR, 500);
+  }
+  const tempRefs = createTempRefScope();
+  args = args.map((arg) => extractTempRefs(arg, tempRefs));
+  const responseHeaders = new Headers;
+  const revalidationsBefore = revalidationEventCount();
+  const nextRequest = toNextRequest(request);
+  try {
+    setPhase("action");
+    const data = await runWithRequest(nextRequest, () => Promise.resolve(action(...args)), {}, { responseHeaders }).finally(() => setPhase("render"));
+    const refresh = revalidationEventCount() !== revalidationsBefore || hasSetCookie(responseHeaders);
+    if (isReadableStreamReturn(data)) {
+      const headers2 = new Headers({ "content-type": ACTION_STREAM_CONTENT_TYPE });
+      setRefreshHeaders(headers2, refresh);
+      return withResponseHeaders(new Response(data, { status: 200, headers: headers2 }), responseHeaders);
+    }
+    const serialized = await serializeReturnWithTempRefs(data, tempRefs, options.renderActionElement);
+    const body = {
+      data: encodeBinaryReturn(serialized)
+    };
+    const headers = new Headers({ "content-type": "application/json; charset=utf-8" });
+    setRefreshHeaders(headers, refresh);
+    return withResponseHeaders(new Response(JSON.stringify(body), { status: 200, headers }), responseHeaders);
+  } catch (error) {
+    if (isRedirectError(error)) {
+      return withResponseHeaders(redirectResponse(error, revalidationEventCount() !== revalidationsBefore || hasSetCookie(responseHeaders)), responseHeaders);
+    }
+    if (isNotFoundError(error)) {
+      return withResponseHeaders(new Response("Not found", {
+        status: 404,
+        headers: {
+          "content-type": "text/plain; charset=utf-8",
+          [ACTION_NOT_FOUND_HEADER]: "1"
+        }
+      }), responseHeaders);
+    }
+    const message = messageOf(error);
+    let digest;
+    if (error instanceof Error) {
+      digest = serializeBoundaryError({ error, dev: Boolean(options.dev) }).digest;
+      const trace = error.stack ?? error.message;
+      console.error(typeof digest === "string" ? `${trace}
+  digest: '${digest}'` : trace);
+    } else {
+      console.error(error);
+    }
+    await options.onError?.(error, request);
+    const masked = errorResponse(options.dev ? message : MASKED_ACTION_ERROR, 500);
+    if (typeof digest === "string")
+      masked.headers.set(ACTION_ERROR_DIGEST_HEADER, digest);
+    return withResponseHeaders(masked, responseHeaders);
+  }
+}
+async function resolveAction(id, request, options) {
+  if (isInlineActionId(id)) {
+    let instance = lookupActionInstance(id);
+    if (!instance && options.importSourceModule) {
+      const moduleKey = inlineActionModuleKey(id);
+      if (moduleKey) {
+        try {
+          await options.importSourceModule(moduleKey);
+        } catch {}
+        instance = lookupActionInstance(id);
+      }
+    }
+    return instance;
+  }
+  if (isInstanceActionId(id)) {
+    let instance = lookupActionInstance(id);
+    if (!instance && options.rerenderRoute) {
+      const routeId = instanceActionRouteId(id);
+      if (routeId) {
+        try {
+          await options.rerenderRoute(routeId, request);
+        } catch {}
+        instance = lookupActionInstance(id);
+      }
+    }
+    return instance;
+  }
+  const target = lookupAction(id);
+  if (!target)
+    return;
+  const module = await options.importModule(target.modulePath);
+  const action = module[target.exportName];
+  return typeof action === "function" ? action : undefined;
+}
+
+class BodyLimitError extends Error {
+}
+async function readBodyBytesWithLimit(request, limit) {
+  const bytes = await request.arrayBuffer();
+  if (bytes.byteLength > limit) {
+    throw new BodyLimitError(`Body exceeded ${formatLimit(limit)} limit`);
+  }
+  return bytes;
+}
+function bufferedFormRequest(request, bytes) {
+  const headers = new Headers(request.headers);
+  headers.delete("content-length");
+  return new Request(request.url, {
+    method: request.method,
+    headers,
+    body: bytes.byteLength === 0 ? undefined : bytes
+  });
+}
+function formatLimit(limit) {
+  if (limit % (1024 * 1024) === 0)
+    return `${limit / (1024 * 1024)}mb`;
+  if (limit % 1024 === 0)
+    return `${limit / 1024}kb`;
+  return `${limit} bytes`;
+}
+async function decodeArgs(request, limit) {
+  const bytes = await readBodyBytesWithLimit(request, limit);
+  const contentType = request.headers.get("content-type") ?? "";
+  if (contentType.includes("multipart/form-data") || contentType.includes("form-urlencoded")) {
+    const form = await bufferedFormRequest(request, bytes).formData();
+    const argsField = form.get(ACTION_ARGS_FIELD);
+    form.delete(ACTION_ID_FIELD);
+    if (typeof argsField === "string") {
+      form.delete(ACTION_ARGS_FIELD);
+      return decodeStructuredArgs(argsField, form);
+    }
+    const stateField = form.get(FORM_STATE_FIELD);
+    if (typeof stateField === "string") {
+      form.delete(FORM_STATE_FIELD);
+      let state = null;
+      try {
+        state = JSON.parse(stateField);
+      } catch {
+        state = stateField;
+      }
+      return [state, form];
+    }
+    return [form];
+  }
+  const text = new TextDecoder("utf-8").decode(bytes);
+  if (text.trim() === "")
+    return [];
+  const parsed = JSON.parse(text);
+  return Array.isArray(parsed) ? parsed : [parsed];
+}
+async function reviveActionRefs(args, resolve) {
+  const reviveValue = async (value) => {
+    if (value === null || typeof value !== "object")
+      return value;
+    if (Array.isArray(value))
+      return Promise.all(value.map(reviveValue));
+    const record = value;
+    if (typeof record[ARG_ACTION_MARKER] === "string") {
+      const fn = await resolve(record[ARG_ACTION_MARKER]);
+      if (!fn) {
+        const id = String(record[ARG_ACTION_MARKER]);
+        console.error(`Failed to find Server Action "${id}". This request might be from an older or newer deployment.
+` + "Read more: https://nextjs.org/docs/messages/failed-to-find-server-action");
+        throw new UnknownActionReferenceError(id);
+      }
+      return fn;
+    }
+    if (record.$$pnext_undefined === true)
+      return;
+    const binary = reviveBinaryMarker(record);
+    if (binary !== undefined)
+      return binary;
+    if (typeof record.$$pnext_date === "string")
+      return new Date(record.$$pnext_date);
+    if (Array.isArray(record.$$pnext_map)) {
+      const entries = await Promise.all(record.$$pnext_map.map(async ([k, v]) => [await reviveValue(k), await reviveValue(v)]));
+      return new Map(entries);
+    }
+    if (Array.isArray(record.$$pnext_set)) {
+      return new Set(await Promise.all(record.$$pnext_set.map(reviveValue)));
+    }
+    if (value instanceof FormData || value instanceof Blob)
+      return value;
+    if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
+      return value;
+    }
+    const out = {};
+    for (const [key, item] of Object.entries(record))
+      out[key] = await reviveValue(item);
+    return out;
+  };
+  return Promise.all(args.map(reviveValue));
+}
+var TYPED_ARRAY_MARKER = "$$pnext_typed_array";
+var ARRAY_BUFFER_MARKER = "$$pnext_array_buffer";
+var TYPED_ARRAY_CTORS = {
+  Int8Array,
+  Uint8Array,
+  Uint8ClampedArray,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array,
+  BigInt64Array,
+  BigUint64Array
+};
+function isTypedArrayView(value) {
+  return ArrayBuffer.isView(value) && !(value instanceof DataView);
+}
+function encodeBinaryReturn(value, seen = new Set) {
+  if (value === null || typeof value !== "object")
+    return value;
+  if (value instanceof ArrayBuffer) {
+    return { [ARRAY_BUFFER_MARKER]: Buffer.from(new Uint8Array(value)).toString("base64") };
+  }
+  if (isTypedArrayView(value)) {
+    const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    return {
+      [TYPED_ARRAY_MARKER]: {
+        type: value.constructor.name,
+        data: Buffer.from(bytes).toString("base64")
+      }
+    };
+  }
+  if (seen.has(value))
+    return value;
+  seen.add(value);
+  if (Array.isArray(value))
+    return value.map((item) => encodeBinaryReturn(item, seen));
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== Object.prototype && proto !== null)
+    return value;
+  const out = {};
+  for (const [key, item] of Object.entries(value)) {
+    out[key] = encodeBinaryReturn(item, seen);
+  }
+  return out;
+}
+function reviveBinaryMarker(record) {
+  const typed = record[TYPED_ARRAY_MARKER];
+  if (typed && typeof typed === "object") {
+    const { type, data } = typed;
+    const Ctor = type ? TYPED_ARRAY_CTORS[type] : undefined;
+    if (Ctor && typeof data === "string") {
+      const bytes = Buffer.from(data, "base64");
+      return new Ctor(bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength));
+    }
+  }
+  const buffer = record[ARRAY_BUFFER_MARKER];
+  if (typeof buffer === "string") {
+    const bytes = Buffer.from(buffer, "base64");
+    return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+  }
+  return;
+}
+
+class UnknownActionReferenceError extends Error {
+  actionId;
+  constructor(actionId2) {
+    super(`Server Action "${actionId2}" was not found on the server.`);
+    this.actionId = actionId2;
+  }
+}
+function decodeStructuredArgs(argsJson, form) {
+  const parsed = JSON.parse(argsJson);
+  const list = Array.isArray(parsed) ? parsed : [parsed];
+  return list.map((item) => reviveArg(item, form));
+}
+function reviveArg(value, form) {
+  if (value === null || typeof value !== "object")
+    return value;
+  if (Array.isArray(value))
+    return value.map((item) => reviveArg(item, form));
+  const record = value;
+  if (typeof record[ARG_FORMDATA_MARKER] === "number") {
+    const slot = record[ARG_FORMDATA_MARKER];
+    const prefix = `${ARG_FORMDATA_PREFIX}${slot}:`;
+    const data = new FormData;
+    for (const [key, item] of form.entries()) {
+      if (key.startsWith(prefix))
+        data.append(key.slice(prefix.length), item);
+    }
+    return data;
+  }
+  if (typeof record[ARG_FILE_MARKER] === "number") {
+    const slot = record[ARG_FILE_MARKER];
+    return form.get(`${ARG_FILE_PREFIX}${slot}`);
+  }
+  const revived = {};
+  for (const [key, item] of Object.entries(record))
+    revived[key] = reviveArg(item, form);
+  return revived;
+}
+function redirectResponse(error, refresh) {
+  const redirectType = error.redirectType;
+  const headers = new Headers({
+    location: error.location,
+    [ACTION_REDIRECT_HEADER]: error.location
+  });
+  if (redirectType === "replace")
+    headers.set(REDIRECT_TYPE_HEADER, "replace");
+  setRefreshHeaders(headers, refresh);
+  return new Response(null, { status: 303, headers });
+}
+function setRefreshHeaders(headers, refresh) {
+  if (!refresh)
+    return;
+  headers.set(ACTION_REFRESH_HEADER, "1");
+  headers.set(NEXT_ACTION_REVALIDATED_HEADER, "1");
+}
+function errorResponse(message, status) {
+  return new Response(message, {
+    status,
+    headers: { "content-type": "text/plain; charset=utf-8" }
+  });
+}
+function withResponseHeaders(response, extra) {
+  const setCookies = extra.getSetCookie?.() ?? [];
+  if (setCookies.length === 0)
+    return response;
+  for (const cookie of setCookies)
+    response.headers.append("set-cookie", cookie);
+  return response;
+}
+function hasSetCookie(headers) {
+  return headers.has("set-cookie");
+}
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/compat/actions/config.ts
+var SIZE_LIMIT_ERROR = "Server Actions Size Limit must be a valid number or filesize format larger than 1MB";
+async function loadServerActionsConfig(root) {
+  const config = await loadResolvedNextConfig(root);
+  const experimental = config?.experimental;
+  const limit = config?.serverActions?.bodySizeLimit ?? (experimental && typeof experimental === "object" && experimental.serverActions ? experimental.serverActions.bodySizeLimit : undefined);
+  if (limit === undefined)
+    return { bodySizeLimitBytes: DEFAULT_BODY_LIMIT_BYTES };
+  return { bodySizeLimitBytes: parseBodySizeLimit(limit) };
+}
+async function loadResolvedNextConfig(root) {
+  return loadNextConfigFromStore() ?? await loadNextConfig(root);
+}
+function loadNextConfigFromStore() {
+  try {
+    const store = getNextConfig();
+    return store && Object.keys(store).length > 0 ? store : undefined;
+  } catch {
+    return;
+  }
+}
+async function loadNextConfig(root) {
+  if (nextConfigReleased())
+    return getNextConfig();
+  for (const name of ["next.config.js", "next.config.mjs", "next.config.cjs"]) {
+    const file = path.join(root, name);
+    if (!existsSync(file))
+      continue;
+    try {
+      if (name.endsWith(".js") || name.endsWith(".cjs")) {
+        const requireFrom = createRequire(path.join(root, "noop.js"));
+        delete requireFrom.cache[requireFrom.resolve(file)];
+        const required = requireFrom(file);
+        let value2 = required && typeof required === "object" && "default" in required ? required.default : required;
+        if (typeof value2 === "function") {
+          value2 = await value2("phase-production-server", { defaultConfig: {} });
+        }
+        return value2 ?? undefined;
+      }
+      const loaded = await import(`${pathToFileHref(file)}?v=${Date.now()}`);
+      let value = loaded.default ?? loaded;
+      if (typeof value === "function") {
+        value = await value("phase-production-server", { defaultConfig: {} });
+      }
+      return value ?? undefined;
+    } catch {
+      return;
+    }
+  }
+  return;
+}
+function validateServerActionsConfigSync(root) {
+  let config = nextConfigReleased() ? getNextConfig() : undefined;
+  const requireFrom = createRequire(path.join(root, "noop.js"));
+  for (const name of config ? [] : ["next.config.js", "next.config.cjs"]) {
+    const file = path.join(root, name);
+    if (!existsSync(file))
+      continue;
+    try {
+      delete requireFrom.cache[requireFrom.resolve(file)];
+      let value = requireFrom(file);
+      if (value && typeof value === "object" && "default" in value) {
+        value = value.default;
+      }
+      if (typeof value === "function") {
+        value = value("phase-production-server", { defaultConfig: {} });
+      }
+      config = value;
+    } catch (error) {
+      if (error instanceof Error && error.message === SIZE_LIMIT_ERROR)
+        throw error;
+      return;
+    }
+    break;
+  }
+  if (!config)
+    return;
+  const experimental = config.experimental;
+  const limit = config.serverActions?.bodySizeLimit ?? (experimental && typeof experimental === "object" && experimental.serverActions ? experimental.serverActions.bodySizeLimit : undefined);
+  if (limit === undefined)
+    return;
+  parseBodySizeLimit(limit);
+}
+function parseBodySizeLimit(value) {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value <= 0)
+      throw new Error(SIZE_LIMIT_ERROR);
+    return Math.floor(value);
+  }
+  if (typeof value === "string") {
+    const match = /^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb)?$/i.exec(value.trim());
+    if (!match)
+      throw new Error(SIZE_LIMIT_ERROR);
+    const amount = Number(match[1]);
+    if (!Number.isFinite(amount) || amount <= 0)
+      throw new Error(SIZE_LIMIT_ERROR);
+    const unit = (match[2] ?? "b").toLowerCase();
+    const factor = unit === "gb" ? 1073741824 : unit === "mb" ? 1048576 : unit === "kb" ? 1024 : 1;
+    return Math.floor(amount * factor);
+  }
+  throw new Error(SIZE_LIMIT_ERROR);
+}
+
+// src/compat/next/rewrites.ts
+var VALID_CONDITION_TYPES = new Set(["host", "header", "query", "cookie"]);
+async function loadCompatRewrites(root) {
+  let config = await loadResolvedNextConfig(root);
+  if (typeof config?.rewrites !== "function")
+    config = await loadNextConfig(root);
+  const producer = config?.rewrites;
+  if (typeof producer !== "function")
+    return [];
+  let value;
+  try {
+    value = await producer();
+  } catch {
+    return [];
+  }
+  const entries = Array.isArray(value) ? value.map((entry) => ({ ...entry, fallback: false })) : value && typeof value === "object" ? ["beforeFiles", "afterFiles", "fallback"].flatMap((key) => {
+    const list = value[key];
+    return Array.isArray(list) ? list.map((entry) => ({ ...entry, fallback: key === "fallback" })) : [];
+  }) : [];
+  const rewrites = [];
+  for (const entry of entries) {
+    if (!entry?.source || !entry.destination)
+      continue;
+    const has = parseConditions(entry.has);
+    const missing = parseConditions(entry.missing);
+    if (has === null || missing === null)
+      continue;
+    const compiled = compileSource(entry.source);
+    if (compiled) {
+      rewrites.push({
+        ...compiled,
+        destination: entry.destination,
+        has,
+        missing,
+        fallback: entry.fallback,
+        outsideBasePath: entry.basePath === false
+      });
+    }
+  }
+  return rewrites;
+}
+function parseConditions(value) {
+  if (value === undefined)
+    return [];
+  if (!Array.isArray(value))
+    return null;
+  const conditions = [];
+  for (const raw of value) {
+    if (!raw || typeof raw !== "object")
+      return null;
+    const { type, key, value: condValue } = raw;
+    if (typeof type !== "string" || !VALID_CONDITION_TYPES.has(type))
+      return null;
+    if (key !== undefined && typeof key !== "string")
+      return null;
+    if (condValue !== undefined && typeof condValue !== "string")
+      return null;
+    conditions.push({
+      type,
+      ...typeof key === "string" ? { key } : {},
+      ...typeof condValue === "string" ? { value: condValue } : {}
+    });
+  }
+  return conditions;
+}
+function compileSource(source) {
+  const paramNames = [];
+  const segments = source.split("/").filter(Boolean);
+  const parts = [];
+  for (const segment of segments) {
+    const custom = /^:([A-Za-z_$][\w$]*)\((.*)\)$/.exec(segment);
+    if (custom?.[1] !== undefined && custom[2] !== undefined) {
+      paramNames.push(custom[1]);
+      parts.push(`(${custom[2]})`);
+      continue;
+    }
+    const catchAll = /^:([A-Za-z_$][\w$]*)[*+]$/.exec(segment);
+    if (catchAll?.[1]) {
+      paramNames.push(catchAll[1]);
+      parts.push("(.*)");
+      continue;
+    }
+    const optional = /^:([A-Za-z_$][\w$]*)\?$/.exec(segment);
+    if (optional?.[1]) {
+      paramNames.push(optional[1]);
+      parts.push("([^/]*)");
+      continue;
+    }
+    const param = /^:([A-Za-z_$][\w$]*)$/.exec(segment);
+    if (param?.[1]) {
+      paramNames.push(param[1]);
+      parts.push("([^/]+)");
+      continue;
+    }
+    if (segment.startsWith("(") && segment.endsWith(")")) {
+      parts.push(`(?:${segment.slice(1, -1)})`);
+      continue;
+    }
+    if (/^[\w.\- ]+$/.test(segment)) {
+      parts.push(segment.replace(/\./g, "\\."));
+      continue;
+    }
+    if (/[.*+?^${}()|[\]\\]/.test(segment))
+      return null;
+    parts.push(segment.replace(/[/\\]/g, ""));
+  }
+  return { regex: new RegExp(`^/${parts.join("/")}/?$`), paramNames };
+}
+function evaluateCondition(condition, ctx) {
+  const target = conditionTarget(condition, ctx);
+  if (target === undefined)
+    return null;
+  if (condition.value === undefined)
+    return {};
+  const regex = new RegExp(`^(?:${condition.value})$`);
+  const match = regex.exec(target);
+  if (!match)
+    return null;
+  return match.groups ? { ...match.groups } : {};
+}
+function conditionTarget(condition, ctx) {
+  switch (condition.type) {
+    case "host":
+      return ctx.host;
+    case "header":
+      return condition.key ? ctx.headers.get(condition.key) ?? undefined : undefined;
+    case "cookie":
+      return condition.key ? ctx.cookies[condition.key] : undefined;
+    case "query":
+      return condition.key ? ctx.query.get(condition.key) ?? undefined : undefined;
+    default:
+      return;
+  }
+}
+function applyCompatRewrites(rewrites, pathname, ctx) {
+  return resolveCompatRewrite(rewrites, pathname, ctx)?.pathname;
+}
+function resolveCompatRewrite(rewrites, pathname, ctx) {
+  const context = ctx ?? {
+    host: "",
+    headers: new Headers,
+    cookies: {},
+    query: new URLSearchParams
+  };
+  for (const rewrite of rewrites) {
+    const match = rewrite.regex.exec(pathname);
+    if (!match)
+      continue;
+    const params = {};
+    rewrite.paramNames.forEach((name, index) => {
+      params[name] = match[index + 1] ?? "";
+    });
+    const conditionParams = evaluateConditions(rewrite, context);
+    if (conditionParams === null)
+      continue;
+    Object.assign(params, conditionParams);
+    const [destPath, destQuery] = splitDestination(rewrite.destination);
+    const { pathname: newPath, used: usedInPath } = substitute(destPath, params);
+    const search = new URLSearchParams(context.query);
+    let usedInQuery = false;
+    if (destQuery) {
+      const destParams = new URLSearchParams(destQuery);
+      for (const [key, rawValue] of destParams.entries()) {
+        const { pathname: value, used } = substitute(rawValue, params);
+        if (used)
+          usedInQuery = true;
+        search.set(key, value);
+      }
+    }
+    const anyUsed = usedInPath.size > 0 || usedInQuery;
+    if (!anyUsed) {
+      for (const [name, value] of Object.entries(params)) {
+        if (!search.has(name))
+          search.append(name, value);
+      }
+    }
+    return {
+      pathname: newPath,
+      search,
+      destination: /^https?:/.test(newPath) ? normalizeDestination(newPath, search) : undefined
+    };
+  }
+  return;
+}
+function normalizeDestination(pathname, search) {
+  try {
+    const destination = new URL(pathname);
+    for (const [key, value] of search.entries()) {
+      destination.searchParams.set(key, value);
+    }
+    return destination.toString();
+  } catch {
+    return;
+  }
+}
+function evaluateConditions(rule, ctx) {
+  const params = {};
+  for (const condition of rule.has) {
+    const captured = evaluateCondition(condition, ctx);
+    if (captured === null)
+      return null;
+    Object.assign(params, captured);
+  }
+  for (const condition of rule.missing) {
+    if (evaluateCondition(condition, ctx) !== null)
+      return null;
+  }
+  return params;
+}
+function splitDestination(destination) {
+  const index = destination.indexOf("?");
+  if (index === -1)
+    return [destination, undefined];
+  return [destination.slice(0, index), destination.slice(index + 1)];
+}
+function substitute(template, params) {
+  const used = new Set;
+  const result = template.replace(/:([A-Za-z_$][\w$]*)(\*|\+|\?)?/g, (whole, name) => {
+    if (!(name in params))
+      return whole;
+    used.add(name);
+    return params[name] ?? "";
+  });
+  return { pathname: result, used };
+}
+
+export { wrapThrownValue, formatErrorLog, serializeBoundaryError, registerActionModule, lookupActionSource, clearActions, createInstanceScope, registerActionInstance, isInstanceActionId, instanceActionRouteId, isMarkedInlineAction, overriddenActionId, assignedInlineActionId, rewriteInlineActionTags, rewriteAnonymousInlineActionMarks, anonymousInlineActionSpans, inlineActionModuleKey, isInlineActionId, ACTION_ID_HEADER, ACTION_REDIRECT_HEADER, ACTION_REFRESH_HEADER, NEXT_ACTION_REVALIDATED_HEADER, ACTION_NOT_FOUND_HEADER, NEXT_ACTION_NOT_FOUND_HEADER, REDIRECT_TYPE_HEADER, ACTION_ID_FIELD, SUBMIT_ACTION_ID_FIELD, FORM_STATE_FIELD, PROP_ACTION_MARKER, MASKED_ACTION_ERROR, runAction, loadServerActionsConfig, loadResolvedNextConfig, loadNextConfig, validateServerActionsConfigSync, loadCompatRewrites, parseConditions, compileSource, applyCompatRewrites, resolveCompatRewrite, evaluateConditions, splitDestination, substitute };