@wular/coder 0.4.2 → 0.4.5

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

@@ -0,0 +1,590 @@
+// @bun
+import {
+  consumedSegments,
+  isGroupSegment,
+  isSlotSegment,
+  matchSegments,
+  matchSlotInterceptor,
+  pathnameSegments,
+  slotConventionFile,
+  slotDirectoriesIn
+} from "./index-cn86z041.js";
+import {
+  toPosixPath
+} from "./index-4da76t62.js";
+import {
+  getRenderExtensions
+} from "./index-zqpqyg8p.js";
+
+// src/render/slots.tsx
+import { AsyncLocalStorage } from "async_hooks";
+import { basename, join, relative, sep } from "path";
+import { h } from "preact";
+import { Suspense } from "../../../src/api/suspense.ts";
+
+// src/utils/serialize.ts
+var TYPED_ARRAY_MARKER = "$$pnext_typed_array";
+var ARRAY_BUFFER_MARKER = "$$pnext_array_buffer";
+var MAP_MARKER = "$$pnext_map";
+var SET_MARKER = "$$pnext_set";
+var REF_MARKER = "$$pnext_ref";
+var PROMISE_MARKER_KEY = "__pnextPromise";
+function isTypedArray(value) {
+  return ArrayBuffer.isView(value) && !(value instanceof DataView);
+}
+function bytesToBase64(bytes) {
+  if (typeof Buffer !== "undefined")
+    return Buffer.from(bytes).toString("base64");
+  let binary = "";
+  for (const byte of bytes)
+    binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+function encodeTypedArray(value) {
+  const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  return { [TYPED_ARRAY_MARKER]: { type: value.constructor.name, data: bytesToBase64(bytes) } };
+}
+function encodeArrayBuffer(value) {
+  return { [ARRAY_BUFFER_MARKER]: bytesToBase64(new Uint8Array(value)) };
+}
+function encodeBinary(value, ancestors = new Map, path = []) {
+  if (value === null || typeof value !== "object")
+    return value;
+  if (isTypedArray(value))
+    return encodeTypedArray(value);
+  if (value instanceof ArrayBuffer)
+    return encodeArrayBuffer(value);
+  const ancestorPath = ancestors.get(value);
+  if (ancestorPath)
+    return { [REF_MARKER]: ancestorPath };
+  ancestors.set(value, path);
+  const encoded = encodeContainer(value, ancestors, path);
+  ancestors.delete(value);
+  return encoded;
+}
+function encodeContainer(value, ancestors, path) {
+  if (Array.isArray(value)) {
+    return value.map((item, index) => encodeBinary(item, ancestors, [...path, String(index)]));
+  }
+  if (value instanceof Map) {
+    return {
+      [MAP_MARKER]: [...value.entries()].map(([k, v]) => [
+        encodeBinary(k, ancestors),
+        encodeBinary(v, ancestors)
+      ])
+    };
+  }
+  if (value instanceof Set) {
+    return { [SET_MARKER]: [...value].map((item) => encodeBinary(item, ancestors)) };
+  }
+  if (Object.getPrototypeOf(value) !== Object.prototype)
+    return value;
+  const out = {};
+  for (const [key, item] of Object.entries(value)) {
+    out[key] = encodeBinary(item, ancestors, [...path, key]);
+  }
+  return out;
+}
+function revivePromiseMarkers(props, sync) {
+  return reviveMarkers(props, new Set, sync);
+}
+var SYNC_PROP_KEYS = new Set(["params", "searchParams"]);
+function reviveMarkers(value, seen, sync, key) {
+  if (value === null || typeof value !== "object" || seen.has(value))
+    return value;
+  if (PROMISE_MARKER_KEY in value) {
+    const resolved = value[PROMISE_MARKER_KEY];
+    const promise = fulfilledPromise(resolved);
+    if (!sync || !key || !SYNC_PROP_KEYS.has(key))
+      return promise;
+    if (resolved === null || typeof resolved !== "object")
+      return promise;
+    return sync(promise, key, resolved);
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    for (let index = 0;index < value.length; index++) {
+      value[index] = reviveMarkers(value[index], seen, sync);
+    }
+    return value;
+  }
+  if (Object.getPrototypeOf(value) !== Object.prototype)
+    return value;
+  const target = value;
+  for (const name of Object.keys(target)) {
+    target[name] = reviveMarkers(target[name], seen, sync, name);
+  }
+  return value;
+}
+function fulfilledPromise(value) {
+  const promise = Promise.resolve(value);
+  promise.status = "fulfilled";
+  promise.value = value;
+  return promise;
+}
+function isElementLike(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  return value.constructor === undefined && "type" in value && "props" in value;
+}
+function assertSerializable(value, path = "props", seen = new Set, allowElements = false) {
+  if (value == null)
+    return;
+  if (allowElements && isElementLike(value))
+    return;
+  const type = typeof value;
+  if (type === "string" || type === "number" || type === "boolean")
+    return;
+  if (type === "function" || type === "symbol" || type === "bigint" || type === "undefined") {
+    throw new Error(`${path} is not serializable: ${type}`);
+  }
+  if (isTypedArray(value) || value instanceof ArrayBuffer)
+    return;
+  if (value instanceof Date || value instanceof URL) {
+    throw new Error(`${path} must be a plain JSON value`);
+  }
+  if (typeof value.then === "function") {
+    throw new Error(`${path} is a Promise: a promise prop must be reachable at the top level of the props or nested in plain objects/arrays/Maps/Sets - one held by a class instance cannot be awaited or serialized, and server actions take no promises at all`);
+  }
+  if (typeof value !== "object")
+    return;
+  if (seen.has(value))
+    return;
+  seen.add(value);
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => assertSerializable(item, `${path}[${index}]`, seen, allowElements));
+    return;
+  }
+  if (value instanceof Map) {
+    let index = 0;
+    for (const [key, item] of value.entries()) {
+      assertSerializable(key, `${path}<Map key ${index}>`, seen);
+      assertSerializable(item, `${path}<Map value ${index}>`, seen);
+      index++;
+    }
+    return;
+  }
+  if (value instanceof Set) {
+    let index = 0;
+    for (const item of value) {
+      assertSerializable(item, `${path}<Set item ${index}>`, seen);
+      index++;
+    }
+    return;
+  }
+  if (Object.getPrototypeOf(value) !== Object.prototype) {
+    throw new Error(`${path} must be a plain object`);
+  }
+  for (const [key, item] of Object.entries(value)) {
+    assertSerializable(item, `${path}.${key}`, seen, allowElements);
+  }
+}
+var TAINT_REGISTRY_KEY = "__pnext_tainted_values__";
+function taintRegistry() {
+  const host = globalThis;
+  const existing = host[TAINT_REGISTRY_KEY];
+  if (existing)
+    return existing;
+  const created = new Map;
+  host[TAINT_REGISTRY_KEY] = created;
+  return created;
+}
+function taintObjectReference(messages, value) {
+  taintRegistry().set(value, messages);
+}
+function assertNotTainted(value, seen = new Set) {
+  const registry = taintRegistry();
+  if (registry.size === 0)
+    return;
+  if (value === null || typeof value !== "object")
+    return;
+  const messages = registry.get(value);
+  if (messages !== undefined) {
+    throw new Error(messages.prod);
+  }
+  if (seen.has(value))
+    return;
+  seen.add(value);
+  if (Array.isArray(value)) {
+    for (const item of value)
+      assertNotTainted(item, seen);
+    return;
+  }
+  if (value instanceof Map) {
+    for (const [key, item] of value.entries()) {
+      assertNotTainted(key, seen);
+      assertNotTainted(item, seen);
+    }
+    return;
+  }
+  if (value instanceof Set) {
+    for (const item of value)
+      assertNotTainted(item, seen);
+    return;
+  }
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== Object.prototype && proto !== null)
+    return;
+  for (const item of Object.values(value))
+    assertNotTainted(item, seen);
+}
+function serializeProps(value, options) {
+  assertNotTainted(value);
+  assertSerializable(value, "props", new Set, options?.allowElements);
+  return JSON.stringify(encodeBinary(value)).replace(/[<>&\u2028\u2029]/g, (char) => {
+    switch (char) {
+      case "<":
+        return "\\u003c";
+      case ">":
+        return "\\u003e";
+      case "&":
+        return "\\u0026";
+      case "\u2028":
+        return "\\u2028";
+      case "\u2029":
+        return "\\u2029";
+      default:
+        return char;
+    }
+  });
+}
+
+// src/render/slots.tsx
+function createSlotContext(options, deps) {
+  const urlPath = trimPathname(options.nav?.targetPath ?? options.url.pathname);
+  const childrenPath = trimPathname(options.nav?.childrenPath ?? options.url.pathname);
+  const urlSearch = stripRscSearch(options.url.search);
+  const childrenSearch = options.nav?.soft && childrenPath !== trimPathname(options.url.pathname) ? options.nav?.state?.childrenSearch ?? "" : urlSearch;
+  return {
+    options,
+    deps,
+    appPath: options.config.appPath,
+    urlPath,
+    urlSegments: pathnameSegments(urlPath),
+    urlSearch,
+    childrenPath,
+    childrenSegments: pathnameSegments(childrenPath),
+    childrenSearch,
+    soft: Boolean(options.nav?.soft),
+    statePaths: options.nav?.state?.slots ?? {},
+    stateOut: options.slotStateOut ?? {},
+    matches: []
+  };
+}
+function trimPathname(pathname) {
+  return pathname.length > 1 ? pathname.replace(/\/+$/, "") || "/" : pathname;
+}
+function sourceParts(source) {
+  const queryIndex = source.indexOf("?");
+  if (queryIndex === -1)
+    return { path: trimPathname(source), search: "" };
+  return {
+    path: trimPathname(source.slice(0, queryIndex)),
+    search: source.slice(queryIndex)
+  };
+}
+function stripRscSearch(search) {
+  if (!search.includes("_rsc"))
+    return search;
+  const params = new URLSearchParams(search);
+  params.delete("_rsc");
+  const stripped = params.toString();
+  return stripped ? `?${stripped}` : "";
+}
+async function renderDirSlots(context, dir) {
+  const slotDirs = slotDirectoriesIn(dir);
+  if (slotDirs.length === 0)
+    return {};
+  const consumed = consumedSegments(context.appPath, dir);
+  const effectiveConsumed = Number.isFinite(consumed) ? consumed : context.childrenSegments.length;
+  const props = {};
+  for (const slotDir of slotDirs) {
+    const content = await resolveSlotContent(context, slotDir, effectiveConsumed);
+    props[basename(slotDir).slice(1)] = content == null ? null : wrapSlotBoundary(content);
+  }
+  return props;
+}
+async function resolveSlotContent(context, slotDir, consumed) {
+  const key = toPosixPath(relative(context.appPath, slotDir));
+  if (context.soft && context.urlPath !== context.childrenPath) {
+    const intercepted = matchSlotInterceptor(context.appPath, slotDir, context.urlPath);
+    if (intercepted) {
+      context.stateOut[key] = context.urlPath + context.urlSearch;
+      return renderSlotMatch(context, slotDir, intercepted, context.urlSearch);
+    }
+  }
+  const sources = [];
+  const pushSource = (path, search) => {
+    if (!sources.some((source) => source.path === path))
+      sources.push({ path, search });
+  };
+  const rawStateSource = context.statePaths[key];
+  const stateSource = rawStateSource ? sourceParts(rawStateSource) : undefined;
+  const preserveForInterception = context.soft && context.urlPath !== context.childrenPath && context.options.route.slotDirs?.some((dir) => Boolean(matchSlotInterceptor(context.appPath, dir, context.urlPath)));
+  if (preserveForInterception && stateSource && segmentsSharePrefix(pathnameSegments(stateSource.path), context.childrenSegments, consumed)) {
+    pushSource(stateSource.path, stateSource.search);
+  }
+  if (segmentsSharePrefix(context.urlSegments, context.childrenSegments, consumed)) {
+    pushSource(context.urlPath, context.urlSearch);
+  }
+  if (context.soft && stateSource && segmentsSharePrefix(pathnameSegments(stateSource.path), context.childrenSegments, consumed)) {
+    pushSource(stateSource.path, stateSource.search);
+  }
+  if (context.childrenPath !== context.urlPath) {
+    pushSource(context.childrenPath, context.childrenSearch);
+  }
+  for (const source of sources) {
+    const intercepted = context.soft && source.path !== context.urlPath ? matchSlotInterceptor(context.appPath, slotDir, source.path) : null;
+    const match = intercepted ?? matchSegments(slotDir, pathnameSegments(source.path).slice(consumed));
+    if (!match)
+      continue;
+    context.stateOut[key] = source.path + source.search;
+    return renderSlotMatch(context, slotDir, match, source.search);
+  }
+  const defaultFile = slotConventionFile(slotDir, "default");
+  if (!defaultFile)
+    return null;
+  return renderSlotComponent(context, defaultFile, {});
+}
+async function renderSlotMatch(context, slotDir, match, sourceSearch) {
+  let tree = match.file ? await renderSlotComponent(context, match.file, match.params, sourceSearch) : null;
+  const chain = [slotDir];
+  for (const name of match.dirs)
+    chain.push(join(chain[chain.length - 1], name));
+  context.matches.push({
+    slotDir,
+    ...match.file ? { pageFile: match.file } : {},
+    layoutFiles: chain.flatMap((dir) => slotConventionFile(dir, "layout") ?? []),
+    params: match.params
+  });
+  for (const dir of [...chain].reverse()) {
+    const loadingFile = slotConventionFile(dir, "loading");
+    if (loadingFile) {
+      const module2 = await context.deps.importModule(loadingFile, context.options);
+      const Loading = context.deps.markServerReference(module2.default);
+      if (Loading) {
+        tree = h(Suspense, { fallback: h(Loading, {}) }, tree);
+      }
+    }
+    const layoutFile = slotConventionFile(dir, "layout");
+    if (!layoutFile)
+      continue;
+    const module = await context.deps.importModule(layoutFile, context.options);
+    const Layout = context.deps.markServerReference(module.default);
+    if (!Layout)
+      continue;
+    const nestedSlots = await renderDirSlots(context, dir);
+    tree = h(Layout, {
+      ...slotPageProps(context, match.params, sourceSearch),
+      ...nestedSlots,
+      children: tree
+    });
+  }
+  return wrapSlotParamsScope({ ...context.options.params ?? {}, ...match.params }, tree);
+}
+var paramsScopeSymbol = Symbol.for("pnext.paramsScope");
+var PARAMS_SCOPE_PROP = "__pnextParams";
+var paramsSnapshotStorage = new AsyncLocalStorage;
+var ParamsScopeMarker = (props) => props.children;
+ParamsScopeMarker[paramsScopeSymbol] = true;
+var slotBoundarySymbol = Symbol.for("pnext.slotBoundary");
+var SlotBoundaryMarker = (props) => props.children;
+SlotBoundaryMarker[slotBoundarySymbol] = true;
+function wrapSlotBoundary(content) {
+  return h(SlotBoundaryMarker, null, content);
+}
+function currentParamsSnapshot() {
+  return paramsSnapshotStorage.getStore();
+}
+function runInParamsScope(params, fn) {
+  return paramsSnapshotStorage.run(params, fn);
+}
+function paramsScopeParams(props) {
+  return props[PARAMS_SCOPE_PROP] ?? {};
+}
+function wrapSlotParamsScope(params, tree) {
+  return h(ParamsScopeMarker, { [PARAMS_SCOPE_PROP]: params }, tree);
+}
+async function renderSlotComponent(context, file, params, sourceSearch) {
+  const props = slotPageProps(context, params, sourceSearch);
+  const reference = context.options.route.clientReferences.find((item) => item.file === file && item.exportName === "default");
+  if (reference) {
+    const Component2 = context.options.clientComponents?.get(reference.id) ?? context.deps.clientReferenceStub(reference);
+    return h(Component2, {
+      params: promiseMarker(await props.params),
+      searchParams: promiseMarker(await props.searchParams)
+    });
+  }
+  const module = await context.deps.importModule(file, context.options);
+  const Component = context.deps.markServerReference(module.default);
+  if (!Component)
+    return null;
+  return h(Component, props);
+}
+function promiseMarker(value) {
+  return { [PROMISE_MARKER_KEY]: value ?? null };
+}
+var PROMISE_PLACEHOLDER_KEY = "__pnextParams";
+function promisePlaceholderMarker(kind) {
+  return { [PROMISE_MARKER_KEY]: null, [PROMISE_PLACEHOLDER_KEY]: kind };
+}
+function promisePlaceholderJson(kind) {
+  return `{"${PROMISE_MARKER_KEY}":null,"${PROMISE_PLACEHOLDER_KEY}":"${kind}"}`;
+}
+function revivePromiseProps(props) {
+  return revivePromiseMarkers({ ...props }, getRenderExtensions().legacySyncProps);
+}
+function slotPageProps(context, params, sourceSearch) {
+  const base = context.deps.createPageProps(context.options);
+  const baseSearch = context.soft && context.childrenPath !== trimPathname(context.options.url.pathname) ? context.childrenSearch : context.urlSearch;
+  return {
+    ...base,
+    params: Promise.resolve({ ...context.options.params ?? {}, ...params }),
+    ...sourceSearch !== undefined && sourceSearch !== baseSearch ? { searchParams: fulfilledPromise2(searchParamsObject(sourceSearch)) } : {}
+  };
+}
+function searchParamsObject(search) {
+  const result = {};
+  new URLSearchParams(search).forEach((value, key) => {
+    if (key === "_rsc")
+      return;
+    const current = result[key];
+    if (current === undefined)
+      result[key] = value;
+    else if (Array.isArray(current))
+      current.push(value);
+    else
+      result[key] = [current, value];
+  });
+  return result;
+}
+function fulfilledPromise2(value) {
+  const promise = Promise.resolve(value);
+  promise.status = "fulfilled";
+  promise.value = value;
+  return promise;
+}
+function segmentsSharePrefix(a, b, length) {
+  for (let index = 0;index < length; index += 1) {
+    if (a[index] !== b[index])
+      return false;
+  }
+  return true;
+}
+var layoutSegmentStorage = new AsyncLocalStorage;
+function runInLayoutSegmentScope(segments, fn, scope = {}) {
+  return layoutSegmentStorage.run({ segments, ...scope }, fn);
+}
+function currentLayoutSegmentSnapshot() {
+  const scope = layoutSegmentStorage.getStore();
+  if (!scope)
+    return;
+  const slots = {};
+  let depth = 0;
+  if (scope.appPath && scope.layoutDir) {
+    depth = layoutSegmentDepth(scope.appPath, scope.layoutDir);
+    const owner = toPosixPath(relative(scope.appPath, scope.layoutDir));
+    const prefix = owner ? `${owner}/@` : "@";
+    for (const [dir, path] of Object.entries(scope.slots ?? {})) {
+      if (!dir.startsWith(prefix))
+        continue;
+      const key = dir.slice(prefix.length);
+      if (key.includes("/"))
+        continue;
+      slots[key] = pathnameSegments(path);
+    }
+  }
+  return { depth, segments: scope.segments, slots };
+}
+function hasLayoutSegmentScope() {
+  return layoutSegmentStorage.getStore() !== undefined;
+}
+function currentLayoutSegments(slotKey) {
+  const scope = layoutSegmentStorage.getStore();
+  if (!scope)
+    return [];
+  if (!slotKey)
+    return scope.segments;
+  if (!scope.appPath || !scope.layoutDir)
+    return [];
+  const owner = toPosixPath(relative(scope.appPath, scope.layoutDir));
+  const slotPath = scope.slots?.[owner ? `${owner}/@${slotKey}` : `@${slotKey}`];
+  return slotPath ? pathnameSegments(slotPath) : [];
+}
+function fullLayoutSegments(appPath, leafDir, params) {
+  const relativeDir = relative(appPath, leafDir);
+  if (relativeDir.startsWith(".."))
+    return [];
+  const segments = [];
+  for (const name of relativeDir.split(sep).filter(Boolean)) {
+    if (isSlotSegment(name))
+      continue;
+    if (isGroupSegment(name)) {
+      segments.push(name);
+      continue;
+    }
+    const optional = /^\[\[\.\.\.([^\]]+)\]\]$/.exec(name);
+    const catchAll = optional ?? /^\[\.\.\.([^\]]+)\]$/.exec(name);
+    if (catchAll?.[1]) {
+      const value = params[catchAll[1]];
+      const joined = Array.isArray(value) ? value.join("/") : value ?? "";
+      if (joined)
+        segments.push(joined);
+      continue;
+    }
+    const dynamic = /^\[([^\].]+)\]$/.exec(name);
+    if (dynamic?.[1]) {
+      const value = params[dynamic[1]];
+      segments.push(Array.isArray(value) ? value.join("/") : String(value ?? ""));
+      continue;
+    }
+    segments.push(name);
+  }
+  return segments;
+}
+function layoutParamsForDir(appPath, layoutDir, params) {
+  const relativeDir = relative(appPath, layoutDir);
+  if (relativeDir.startsWith(".."))
+    return {};
+  const scoped = {};
+  for (const name of relativeDir.split(sep).filter(Boolean)) {
+    if (isSlotSegment(name) || isGroupSegment(name))
+      continue;
+    const optional = /^\[\[\.\.\.([^\]]+)\]\]$/.exec(name);
+    if (optional?.[1]) {
+      const value = params[optional[1]];
+      if (value !== undefined && (Array.isArray(value) ? value.length > 0 : value != null)) {
+        scoped[optional[1]] = value;
+      }
+      continue;
+    }
+    const catchAll = /^\[\.\.\.([^\]]+)\]$/.exec(name);
+    if (catchAll?.[1]) {
+      const value = params[catchAll[1]];
+      if (value !== undefined)
+        scoped[catchAll[1]] = value;
+      continue;
+    }
+    const dynamic = /^\[([^\].]+)\]$/.exec(name);
+    if (dynamic?.[1]) {
+      const value = params[dynamic[1]];
+      if (value !== undefined)
+        scoped[dynamic[1]] = value;
+    }
+  }
+  return scoped;
+}
+function layoutSegmentDepth(appPath, layoutDir) {
+  const relativeDir = relative(appPath, layoutDir);
+  if (relativeDir.startsWith("..") || relativeDir === "")
+    return 0;
+  let depth = 0;
+  for (const name of relativeDir.split(sep).filter(Boolean)) {
+    if (isSlotSegment(name))
+      continue;
+    depth += 1;
+  }
+  return depth;
+}
+
+export { isElementLike, taintObjectReference, assertNotTainted, serializeProps, createSlotContext, renderDirSlots, paramsScopeSymbol, slotBoundarySymbol, currentParamsSnapshot, runInParamsScope, paramsScopeParams, promiseMarker, promisePlaceholderMarker, promisePlaceholderJson, revivePromiseProps, runInLayoutSegmentScope, currentLayoutSegmentSnapshot, hasLayoutSegmentScope, currentLayoutSegments, fullLayoutSegments, layoutParamsForDir, layoutSegmentDepth };

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

@@ -0,0 +1,59 @@
+// @bun
+import {
+  currentRequest,
+  getWorkUnit
+} from "./index-grta8ap3.js";
+
+// src/compat/lifecycle/after-scope.ts
+import { AsyncLocalStorage } from "async_hooks";
+var REQUEST_PATH_KEY = Symbol.for("pnext.requestPath");
+var INSPECT_CUSTOM = Symbol.for("nodejs.util.inspect.custom");
+var requestApiScope = new AsyncLocalStorage;
+function runWithAfterRequestApiScope(allowed, callback) {
+  return requestApiScope.run(allowed, callback);
+}
+function afterRequestApisAllowed() {
+  return requestApiScope.getStore() === true;
+}
+function recordRequestPath(pathname) {
+  const unit = getWorkUnit();
+  if (unit)
+    (unit.compat ??= {})[REQUEST_PATH_KEY] = pathname;
+}
+function currentRoutePath() {
+  const recorded = getWorkUnit()?.compat?.[REQUEST_PATH_KEY];
+  if (recorded)
+    return recorded;
+  try {
+    const request = currentRequest();
+    return request ? new URL(request.url).pathname : "";
+  } catch {
+    return "";
+  }
+}
+function lifecycleError(message) {
+  const formatted = `Error: ${message}`;
+  return {
+    name: "Error",
+    message,
+    stack: formatted,
+    toString: () => formatted,
+    [INSPECT_CUSTOM]: () => formatted
+  };
+}
+function assertRequestApiAllowedInAfter(api) {
+  const unit = getWorkUnit();
+  if (unit?.phase !== "after")
+    return;
+  if (afterRequestApisAllowed() && currentRequest())
+    return;
+  const suffix = api === "connection()" ? "" : " This is not supported.";
+  throw lifecycleError(`Route ${currentRoutePath()} used \`${api}\` inside \`after()\`.${suffix}`);
+}
+function assertDraftModeToggleAllowedInAfter(method) {
+  if (getWorkUnit()?.phase !== "after")
+    return;
+  throw lifecycleError(`Route ${currentRoutePath()} used "draftMode().${method}()" inside \`after()\``);
+}
+
+export { runWithAfterRequestApiScope, afterRequestApisAllowed, recordRequestPath, lifecycleError, assertRequestApiAllowedInAfter, assertDraftModeToggleAllowedInAfter };